l/api/glewinfo_8c_source.html

/*

** The OpenGL Extension Wrangler Library

** Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>

** Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>

** Copyright (C) 2002, Lev Povalahev

** All rights reserved.

**

** Redistribution and use in source and binary forms, with or without

** modification, are permitted provided that the following conditions are met:

**

** * Redistributions of source code must retain the above copyright notice,

**   this list of conditions and the following disclaimer.

** * Redistributions in binary form must reproduce the above copyright notice,

**   this list of conditions and the following disclaimer in the documentation

**   and/or other materials provided with the distribution.

** * The name of the author may be used to endorse or promote products

**   derived from this software without specific prior written permission.

**

** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

** THE POSSIBILITY OF SUCH DAMAGE.

*/


#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <GL/glew.h>

#if defined(_WIN32)

#include <GL/wglew.h>

#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)

#include <GL/glxew.h>

#endif


#ifdef GLEW_REGAL

#include <GL/Regal.h>

#endif


static FILE* f;


#ifdef GLEW_MX

GLEWContext _glewctx;

#define glewGetContext() (&_glewctx)

#ifdef _WIN32

WGLEWContext _wglewctx;

#define wglewGetContext() (&_wglewctx)

#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)

GLXEWContext _glxewctx;

#define glxewGetContext() (&_glxewctx)

#endif

#endif


#if defined(_WIN32)

GLboolean glewCreateContext (int* pixelformat);

#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)

GLboolean glewCreateContext (const char* display, int* visual);

#else

GLboolean glewCreateContext ();

#endif


#if defined(_WIN32) || !defined(__APPLE__) || defined(GLEW_APPLE_GLX)

GLboolean glewParseArgs (int argc, char** argv, char** display, int* visual);

#endif


void glewDestroyContext ();


/* ------------------------------------------------------------------------- */


static void glewPrintExt (const char* name, GLboolean def1, GLboolean def2, GLboolean def3)

{

  unsigned int i;

  fprintf(f, "\n%s:", name);

  for (i=0; i<62-strlen(name); i++) fprintf(f, " ");

  fprintf(f, "%s ", def1 ? "OK" : "MISSING");

  if (def1 != def2)

    fprintf(f, "[%s] ", def2 ? "OK" : "MISSING");

  if (def1 != def3)

    fprintf(f, "[%s]\n", def3 ? "OK" : "MISSING");

  else

    fprintf(f, "\n");

  for (i=0; i<strlen(name)+1; i++) fprintf(f, "-");

  fprintf(f, "\n");

  fflush(f);

}


static void glewInfoFunc (const char* name, GLint undefined)

{

  unsigned int i;

  fprintf(f, "  %s:", name);

  for (i=0; i<60-strlen(name); i++) fprintf(f, " ");

  fprintf(f, "%s\n", undefined ? "MISSING" : "OK");

  fflush(f);

}


/* ----------------------------- GL_VERSION_1_1 ---------------------------- */


#ifdef GL_VERSION_1_1


static void _glewInfo_GL_VERSION_1_1 (void)

{

  glewPrintExt("GL_VERSION_1_1", GLEW_VERSION_1_1, GLEW_VERSION_1_1, GLEW_VERSION_1_1);

}


#endif /* GL_VERSION_1_1 */


#ifdef GL_VERSION_1_2


static void _glewInfo_GL_VERSION_1_2 (void)

{

  glewPrintExt("GL_VERSION_1_2", GLEW_VERSION_1_2, GLEW_VERSION_1_2, GLEW_VERSION_1_2);


  glewInfoFunc("glCopyTexSubImage3D", glCopyTexSubImage3D == NULL);

  glewInfoFunc("glDrawRangeElements", glDrawRangeElements == NULL);

  glewInfoFunc("glTexImage3D", glTexImage3D == NULL);

  glewInfoFunc("glTexSubImage3D", glTexSubImage3D == NULL);

}


#endif /* GL_VERSION_1_2 */


#ifdef GL_VERSION_1_2_1


static void _glewInfo_GL_VERSION_1_2_1 (void)

{

  glewPrintExt("GL_VERSION_1_2_1", GLEW_VERSION_1_2_1, GLEW_VERSION_1_2_1, GLEW_VERSION_1_2_1);

}


#endif /* GL_VERSION_1_2_1 */


#ifdef GL_VERSION_1_3


static void _glewInfo_GL_VERSION_1_3 (void)

{

  glewPrintExt("GL_VERSION_1_3", GLEW_VERSION_1_3, GLEW_VERSION_1_3, GLEW_VERSION_1_3);


  glewInfoFunc("glActiveTexture", glActiveTexture == NULL);

  glewInfoFunc("glClientActiveTexture", glClientActiveTexture == NULL);

  glewInfoFunc("glCompressedTexImage1D", glCompressedTexImage1D == NULL);

  glewInfoFunc("glCompressedTexImage2D", glCompressedTexImage2D == NULL);

  glewInfoFunc("glCompressedTexImage3D", glCompressedTexImage3D == NULL);

  glewInfoFunc("glCompressedTexSubImage1D", glCompressedTexSubImage1D == NULL);

  glewInfoFunc("glCompressedTexSubImage2D", glCompressedTexSubImage2D == NULL);

  glewInfoFunc("glCompressedTexSubImage3D", glCompressedTexSubImage3D == NULL);

  glewInfoFunc("glGetCompressedTexImage", glGetCompressedTexImage == NULL);

  glewInfoFunc("glLoadTransposeMatrixd", glLoadTransposeMatrixd == NULL);

  glewInfoFunc("glLoadTransposeMatrixf", glLoadTransposeMatrixf == NULL);

  glewInfoFunc("glMultTransposeMatrixd", glMultTransposeMatrixd == NULL);

  glewInfoFunc("glMultTransposeMatrixf", glMultTransposeMatrixf == NULL);

  glewInfoFunc("glMultiTexCoord1d", glMultiTexCoord1d == NULL);

  glewInfoFunc("glMultiTexCoord1dv", glMultiTexCoord1dv == NULL);

  glewInfoFunc("glMultiTexCoord1f", glMultiTexCoord1f == NULL);

  glewInfoFunc("glMultiTexCoord1fv", glMultiTexCoord1fv == NULL);

  glewInfoFunc("glMultiTexCoord1i", glMultiTexCoord1i == NULL);

  glewInfoFunc("glMultiTexCoord1iv", glMultiTexCoord1iv == NULL);

  glewInfoFunc("glMultiTexCoord1s", glMultiTexCoord1s == NULL);

  glewInfoFunc("glMultiTexCoord1sv", glMultiTexCoord1sv == NULL);

  glewInfoFunc("glMultiTexCoord2d", glMultiTexCoord2d == NULL);

  glewInfoFunc("glMultiTexCoord2dv", glMultiTexCoord2dv == NULL);

  glewInfoFunc("glMultiTexCoord2f", glMultiTexCoord2f == NULL);

  glewInfoFunc("glMultiTexCoord2fv", glMultiTexCoord2fv == NULL);

  glewInfoFunc("glMultiTexCoord2i", glMultiTexCoord2i == NULL);

  glewInfoFunc("glMultiTexCoord2iv", glMultiTexCoord2iv == NULL);

  glewInfoFunc("glMultiTexCoord2s", glMultiTexCoord2s == NULL);

  glewInfoFunc("glMultiTexCoord2sv", glMultiTexCoord2sv == NULL);

  glewInfoFunc("glMultiTexCoord3d", glMultiTexCoord3d == NULL);

  glewInfoFunc("glMultiTexCoord3dv", glMultiTexCoord3dv == NULL);

  glewInfoFunc("glMultiTexCoord3f", glMultiTexCoord3f == NULL);

  glewInfoFunc("glMultiTexCoord3fv", glMultiTexCoord3fv == NULL);

  glewInfoFunc("glMultiTexCoord3i", glMultiTexCoord3i == NULL);

  glewInfoFunc("glMultiTexCoord3iv", glMultiTexCoord3iv == NULL);

  glewInfoFunc("glMultiTexCoord3s", glMultiTexCoord3s == NULL);

  glewInfoFunc("glMultiTexCoord3sv", glMultiTexCoord3sv == NULL);

  glewInfoFunc("glMultiTexCoord4d", glMultiTexCoord4d == NULL);

  glewInfoFunc("glMultiTexCoord4dv", glMultiTexCoord4dv == NULL);

  glewInfoFunc("glMultiTexCoord4f", glMultiTexCoord4f == NULL);

  glewInfoFunc("glMultiTexCoord4fv", glMultiTexCoord4fv == NULL);

  glewInfoFunc("glMultiTexCoord4i", glMultiTexCoord4i == NULL);

  glewInfoFunc("glMultiTexCoord4iv", glMultiTexCoord4iv == NULL);

  glewInfoFunc("glMultiTexCoord4s", glMultiTexCoord4s == NULL);

  glewInfoFunc("glMultiTexCoord4sv", glMultiTexCoord4sv == NULL);

  glewInfoFunc("glSampleCoverage", glSampleCoverage == NULL);

}


#endif /* GL_VERSION_1_3 */


#ifdef GL_VERSION_1_4


static void _glewInfo_GL_VERSION_1_4 (void)

{

  glewPrintExt("GL_VERSION_1_4", GLEW_VERSION_1_4, GLEW_VERSION_1_4, GLEW_VERSION_1_4);


  glewInfoFunc("glBlendColor", glBlendColor == NULL);

  glewInfoFunc("glBlendEquation", glBlendEquation == NULL);

  glewInfoFunc("glBlendFuncSeparate", glBlendFuncSeparate == NULL);

  glewInfoFunc("glFogCoordPointer", glFogCoordPointer == NULL);

  glewInfoFunc("glFogCoordd", glFogCoordd == NULL);

  glewInfoFunc("glFogCoorddv", glFogCoorddv == NULL);

  glewInfoFunc("glFogCoordf", glFogCoordf == NULL);

  glewInfoFunc("glFogCoordfv", glFogCoordfv == NULL);

  glewInfoFunc("glMultiDrawArrays", glMultiDrawArrays == NULL);

  glewInfoFunc("glMultiDrawElements", glMultiDrawElements == NULL);

  glewInfoFunc("glPointParameterf", glPointParameterf == NULL);

  glewInfoFunc("glPointParameterfv", glPointParameterfv == NULL);

  glewInfoFunc("glPointParameteri", glPointParameteri == NULL);

  glewInfoFunc("glPointParameteriv", glPointParameteriv == NULL);

  glewInfoFunc("glSecondaryColor3b", glSecondaryColor3b == NULL);

  glewInfoFunc("glSecondaryColor3bv", glSecondaryColor3bv == NULL);

  glewInfoFunc("glSecondaryColor3d", glSecondaryColor3d == NULL);

  glewInfoFunc("glSecondaryColor3dv", glSecondaryColor3dv == NULL);

  glewInfoFunc("glSecondaryColor3f", glSecondaryColor3f == NULL);

  glewInfoFunc("glSecondaryColor3fv", glSecondaryColor3fv == NULL);

  glewInfoFunc("glSecondaryColor3i", glSecondaryColor3i == NULL);

  glewInfoFunc("glSecondaryColor3iv", glSecondaryColor3iv == NULL);

  glewInfoFunc("glSecondaryColor3s", glSecondaryColor3s == NULL);

  glewInfoFunc("glSecondaryColor3sv", glSecondaryColor3sv == NULL);

  glewInfoFunc("glSecondaryColor3ub", glSecondaryColor3ub == NULL);

  glewInfoFunc("glSecondaryColor3ubv", glSecondaryColor3ubv == NULL);

  glewInfoFunc("glSecondaryColor3ui", glSecondaryColor3ui == NULL);

  glewInfoFunc("glSecondaryColor3uiv", glSecondaryColor3uiv == NULL);

  glewInfoFunc("glSecondaryColor3us", glSecondaryColor3us == NULL);

  glewInfoFunc("glSecondaryColor3usv", glSecondaryColor3usv == NULL);

  glewInfoFunc("glSecondaryColorPointer", glSecondaryColorPointer == NULL);

  glewInfoFunc("glWindowPos2d", glWindowPos2d == NULL);

  glewInfoFunc("glWindowPos2dv", glWindowPos2dv == NULL);

  glewInfoFunc("glWindowPos2f", glWindowPos2f == NULL);

  glewInfoFunc("glWindowPos2fv", glWindowPos2fv == NULL);

  glewInfoFunc("glWindowPos2i", glWindowPos2i == NULL);

  glewInfoFunc("glWindowPos2iv", glWindowPos2iv == NULL);

  glewInfoFunc("glWindowPos2s", glWindowPos2s == NULL);

  glewInfoFunc("glWindowPos2sv", glWindowPos2sv == NULL);

  glewInfoFunc("glWindowPos3d", glWindowPos3d == NULL);

  glewInfoFunc("glWindowPos3dv", glWindowPos3dv == NULL);

  glewInfoFunc("glWindowPos3f", glWindowPos3f == NULL);

  glewInfoFunc("glWindowPos3fv", glWindowPos3fv == NULL);

  glewInfoFunc("glWindowPos3i", glWindowPos3i == NULL);

  glewInfoFunc("glWindowPos3iv", glWindowPos3iv == NULL);

  glewInfoFunc("glWindowPos3s", glWindowPos3s == NULL);

  glewInfoFunc("glWindowPos3sv", glWindowPos3sv == NULL);

}


#endif /* GL_VERSION_1_4 */


#ifdef GL_VERSION_1_5


static void _glewInfo_GL_VERSION_1_5 (void)

{

  glewPrintExt("GL_VERSION_1_5", GLEW_VERSION_1_5, GLEW_VERSION_1_5, GLEW_VERSION_1_5);


  glewInfoFunc("glBeginQuery", glBeginQuery == NULL);

  glewInfoFunc("glBindBuffer", glBindBuffer == NULL);

  glewInfoFunc("glBufferData", glBufferData == NULL);

  glewInfoFunc("glBufferSubData", glBufferSubData == NULL);

  glewInfoFunc("glDeleteBuffers", glDeleteBuffers == NULL);

  glewInfoFunc("glDeleteQueries", glDeleteQueries == NULL);

  glewInfoFunc("glEndQuery", glEndQuery == NULL);

  glewInfoFunc("glGenBuffers", glGenBuffers == NULL);

  glewInfoFunc("glGenQueries", glGenQueries == NULL);

  glewInfoFunc("glGetBufferParameteriv", glGetBufferParameteriv == NULL);

  glewInfoFunc("glGetBufferPointerv", glGetBufferPointerv == NULL);

  glewInfoFunc("glGetBufferSubData", glGetBufferSubData == NULL);

  glewInfoFunc("glGetQueryObjectiv", glGetQueryObjectiv == NULL);

  glewInfoFunc("glGetQueryObjectuiv", glGetQueryObjectuiv == NULL);

  glewInfoFunc("glGetQueryiv", glGetQueryiv == NULL);

  glewInfoFunc("glIsBuffer", glIsBuffer == NULL);

  glewInfoFunc("glIsQuery", glIsQuery == NULL);

  glewInfoFunc("glMapBuffer", glMapBuffer == NULL);

  glewInfoFunc("glUnmapBuffer", glUnmapBuffer == NULL);

}


#endif /* GL_VERSION_1_5 */


#ifdef GL_VERSION_2_0


static void _glewInfo_GL_VERSION_2_0 (void)

{

  glewPrintExt("GL_VERSION_2_0", GLEW_VERSION_2_0, GLEW_VERSION_2_0, GLEW_VERSION_2_0);


  glewInfoFunc("glAttachShader", glAttachShader == NULL);

  glewInfoFunc("glBindAttribLocation", glBindAttribLocation == NULL);

  glewInfoFunc("glBlendEquationSeparate", glBlendEquationSeparate == NULL);

  glewInfoFunc("glCompileShader", glCompileShader == NULL);

  glewInfoFunc("glCreateProgram", glCreateProgram == NULL);

  glewInfoFunc("glCreateShader", glCreateShader == NULL);

  glewInfoFunc("glDeleteProgram", glDeleteProgram == NULL);

  glewInfoFunc("glDeleteShader", glDeleteShader == NULL);

  glewInfoFunc("glDetachShader", glDetachShader == NULL);

  glewInfoFunc("glDisableVertexAttribArray", glDisableVertexAttribArray == NULL);

  glewInfoFunc("glDrawBuffers", glDrawBuffers == NULL);

  glewInfoFunc("glEnableVertexAttribArray", glEnableVertexAttribArray == NULL);

  glewInfoFunc("glGetActiveAttrib", glGetActiveAttrib == NULL);

  glewInfoFunc("glGetActiveUniform", glGetActiveUniform == NULL);

  glewInfoFunc("glGetAttachedShaders", glGetAttachedShaders == NULL);

  glewInfoFunc("glGetAttribLocation", glGetAttribLocation == NULL);

  glewInfoFunc("glGetProgramInfoLog", glGetProgramInfoLog == NULL);

  glewInfoFunc("glGetProgramiv", glGetProgramiv == NULL);

  glewInfoFunc("glGetShaderInfoLog", glGetShaderInfoLog == NULL);

  glewInfoFunc("glGetShaderSource", glGetShaderSource == NULL);

  glewInfoFunc("glGetShaderiv", glGetShaderiv == NULL);

  glewInfoFunc("glGetUniformLocation", glGetUniformLocation == NULL);

  glewInfoFunc("glGetUniformfv", glGetUniformfv == NULL);

  glewInfoFunc("glGetUniformiv", glGetUniformiv == NULL);

  glewInfoFunc("glGetVertexAttribPointerv", glGetVertexAttribPointerv == NULL);

  glewInfoFunc("glGetVertexAttribdv", glGetVertexAttribdv == NULL);

  glewInfoFunc("glGetVertexAttribfv", glGetVertexAttribfv == NULL);

  glewInfoFunc("glGetVertexAttribiv", glGetVertexAttribiv == NULL);

  glewInfoFunc("glIsProgram", glIsProgram == NULL);

  glewInfoFunc("glIsShader", glIsShader == NULL);

  glewInfoFunc("glLinkProgram", glLinkProgram == NULL);

  glewInfoFunc("glShaderSource", glShaderSource == NULL);

  glewInfoFunc("glStencilFuncSeparate", glStencilFuncSeparate == NULL);

  glewInfoFunc("glStencilMaskSeparate", glStencilMaskSeparate == NULL);

  glewInfoFunc("glStencilOpSeparate", glStencilOpSeparate == NULL);

  glewInfoFunc("glUniform1f", glUniform1f == NULL);

  glewInfoFunc("glUniform1fv", glUniform1fv == NULL);

  glewInfoFunc("glUniform1i", glUniform1i == NULL);

  glewInfoFunc("glUniform1iv", glUniform1iv == NULL);

  glewInfoFunc("glUniform2f", glUniform2f == NULL);

  glewInfoFunc("glUniform2fv", glUniform2fv == NULL);

  glewInfoFunc("glUniform2i", glUniform2i == NULL);

  glewInfoFunc("glUniform2iv", glUniform2iv == NULL);

  glewInfoFunc("glUniform3f", glUniform3f == NULL);

  glewInfoFunc("glUniform3fv", glUniform3fv == NULL);

  glewInfoFunc("glUniform3i", glUniform3i == NULL);

  glewInfoFunc("glUniform3iv", glUniform3iv == NULL);

  glewInfoFunc("glUniform4f", glUniform4f == NULL);

  glewInfoFunc("glUniform4fv", glUniform4fv == NULL);

  glewInfoFunc("glUniform4i", glUniform4i == NULL);

  glewInfoFunc("glUniform4iv", glUniform4iv == NULL);

  glewInfoFunc("glUniformMatrix2fv", glUniformMatrix2fv == NULL);

  glewInfoFunc("glUniformMatrix3fv", glUniformMatrix3fv == NULL);

  glewInfoFunc("glUniformMatrix4fv", glUniformMatrix4fv == NULL);

  glewInfoFunc("glUseProgram", glUseProgram == NULL);

  glewInfoFunc("glValidateProgram", glValidateProgram == NULL);

  glewInfoFunc("glVertexAttrib1d", glVertexAttrib1d == NULL);

  glewInfoFunc("glVertexAttrib1dv", glVertexAttrib1dv == NULL);

  glewInfoFunc("glVertexAttrib1f", glVertexAttrib1f == NULL);

  glewInfoFunc("glVertexAttrib1fv", glVertexAttrib1fv == NULL);

  glewInfoFunc("glVertexAttrib1s", glVertexAttrib1s == NULL);

  glewInfoFunc("glVertexAttrib1sv", glVertexAttrib1sv == NULL);

  glewInfoFunc("glVertexAttrib2d", glVertexAttrib2d == NULL);

  glewInfoFunc("glVertexAttrib2dv", glVertexAttrib2dv == NULL);

  glewInfoFunc("glVertexAttrib2f", glVertexAttrib2f == NULL);

  glewInfoFunc("glVertexAttrib2fv", glVertexAttrib2fv == NULL);

  glewInfoFunc("glVertexAttrib2s", glVertexAttrib2s == NULL);

  glewInfoFunc("glVertexAttrib2sv", glVertexAttrib2sv == NULL);

  glewInfoFunc("glVertexAttrib3d", glVertexAttrib3d == NULL);

  glewInfoFunc("glVertexAttrib3dv", glVertexAttrib3dv == NULL);

  glewInfoFunc("glVertexAttrib3f", glVertexAttrib3f == NULL);

  glewInfoFunc("glVertexAttrib3fv", glVertexAttrib3fv == NULL);

  glewInfoFunc("glVertexAttrib3s", glVertexAttrib3s == NULL);

  glewInfoFunc("glVertexAttrib3sv", glVertexAttrib3sv == NULL);

  glewInfoFunc("glVertexAttrib4Nbv", glVertexAttrib4Nbv == NULL);

  glewInfoFunc("glVertexAttrib4Niv", glVertexAttrib4Niv == NULL);

  glewInfoFunc("glVertexAttrib4Nsv", glVertexAttrib4Nsv == NULL);

  glewInfoFunc("glVertexAttrib4Nub", glVertexAttrib4Nub == NULL);

  glewInfoFunc("glVertexAttrib4Nubv", glVertexAttrib4Nubv == NULL);

  glewInfoFunc("glVertexAttrib4Nuiv", glVertexAttrib4Nuiv == NULL);

  glewInfoFunc("glVertexAttrib4Nusv", glVertexAttrib4Nusv == NULL);

  glewInfoFunc("glVertexAttrib4bv", glVertexAttrib4bv == NULL);

  glewInfoFunc("glVertexAttrib4d", glVertexAttrib4d == NULL);

  glewInfoFunc("glVertexAttrib4dv", glVertexAttrib4dv == NULL);

  glewInfoFunc("glVertexAttrib4f", glVertexAttrib4f == NULL);

  glewInfoFunc("glVertexAttrib4fv", glVertexAttrib4fv == NULL);

  glewInfoFunc("glVertexAttrib4iv", glVertexAttrib4iv == NULL);

  glewInfoFunc("glVertexAttrib4s", glVertexAttrib4s == NULL);

  glewInfoFunc("glVertexAttrib4sv", glVertexAttrib4sv == NULL);

  glewInfoFunc("glVertexAttrib4ubv", glVertexAttrib4ubv == NULL);

  glewInfoFunc("glVertexAttrib4uiv", glVertexAttrib4uiv == NULL);

  glewInfoFunc("glVertexAttrib4usv", glVertexAttrib4usv == NULL);

  glewInfoFunc("glVertexAttribPointer", glVertexAttribPointer == NULL);

}


#endif /* GL_VERSION_2_0 */


#ifdef GL_VERSION_2_1


static void _glewInfo_GL_VERSION_2_1 (void)

{

  glewPrintExt("GL_VERSION_2_1", GLEW_VERSION_2_1, GLEW_VERSION_2_1, GLEW_VERSION_2_1);


  glewInfoFunc("glUniformMatrix2x3fv", glUniformMatrix2x3fv == NULL);

  glewInfoFunc("glUniformMatrix2x4fv", glUniformMatrix2x4fv == NULL);

  glewInfoFunc("glUniformMatrix3x2fv", glUniformMatrix3x2fv == NULL);

  glewInfoFunc("glUniformMatrix3x4fv", glUniformMatrix3x4fv == NULL);

  glewInfoFunc("glUniformMatrix4x2fv", glUniformMatrix4x2fv == NULL);

  glewInfoFunc("glUniformMatrix4x3fv", glUniformMatrix4x3fv == NULL);

}


#endif /* GL_VERSION_2_1 */


#ifdef GL_VERSION_3_0


static void _glewInfo_GL_VERSION_3_0 (void)

{

  glewPrintExt("GL_VERSION_3_0", GLEW_VERSION_3_0, GLEW_VERSION_3_0, GLEW_VERSION_3_0);


  glewInfoFunc("glBeginConditionalRender", glBeginConditionalRender == NULL);

  glewInfoFunc("glBeginTransformFeedback", glBeginTransformFeedback == NULL);

  glewInfoFunc("glBindFragDataLocation", glBindFragDataLocation == NULL);

  glewInfoFunc("glClampColor", glClampColor == NULL);

  glewInfoFunc("glClearBufferfi", glClearBufferfi == NULL);

  glewInfoFunc("glClearBufferfv", glClearBufferfv == NULL);

  glewInfoFunc("glClearBufferiv", glClearBufferiv == NULL);

  glewInfoFunc("glClearBufferuiv", glClearBufferuiv == NULL);

  glewInfoFunc("glColorMaski", glColorMaski == NULL);

  glewInfoFunc("glDisablei", glDisablei == NULL);

  glewInfoFunc("glEnablei", glEnablei == NULL);

  glewInfoFunc("glEndConditionalRender", glEndConditionalRender == NULL);

  glewInfoFunc("glEndTransformFeedback", glEndTransformFeedback == NULL);

  glewInfoFunc("glGetBooleani_v", glGetBooleani_v == NULL);

  glewInfoFunc("glGetFragDataLocation", glGetFragDataLocation == NULL);

  glewInfoFunc("glGetStringi", glGetStringi == NULL);

  glewInfoFunc("glGetTexParameterIiv", glGetTexParameterIiv == NULL);

  glewInfoFunc("glGetTexParameterIuiv", glGetTexParameterIuiv == NULL);

  glewInfoFunc("glGetTransformFeedbackVarying", glGetTransformFeedbackVarying == NULL);

  glewInfoFunc("glGetUniformuiv", glGetUniformuiv == NULL);

  glewInfoFunc("glGetVertexAttribIiv", glGetVertexAttribIiv == NULL);

  glewInfoFunc("glGetVertexAttribIuiv", glGetVertexAttribIuiv == NULL);

  glewInfoFunc("glIsEnabledi", glIsEnabledi == NULL);

  glewInfoFunc("glTexParameterIiv", glTexParameterIiv == NULL);

  glewInfoFunc("glTexParameterIuiv", glTexParameterIuiv == NULL);

  glewInfoFunc("glTransformFeedbackVaryings", glTransformFeedbackVaryings == NULL);

  glewInfoFunc("glUniform1ui", glUniform1ui == NULL);

  glewInfoFunc("glUniform1uiv", glUniform1uiv == NULL);

  glewInfoFunc("glUniform2ui", glUniform2ui == NULL);

  glewInfoFunc("glUniform2uiv", glUniform2uiv == NULL);

  glewInfoFunc("glUniform3ui", glUniform3ui == NULL);

  glewInfoFunc("glUniform3uiv", glUniform3uiv == NULL);

  glewInfoFunc("glUniform4ui", glUniform4ui == NULL);

  glewInfoFunc("glUniform4uiv", glUniform4uiv == NULL);

  glewInfoFunc("glVertexAttribI1i", glVertexAttribI1i == NULL);

  glewInfoFunc("glVertexAttribI1iv", glVertexAttribI1iv == NULL);

  glewInfoFunc("glVertexAttribI1ui", glVertexAttribI1ui == NULL);

  glewInfoFunc("glVertexAttribI1uiv", glVertexAttribI1uiv == NULL);

  glewInfoFunc("glVertexAttribI2i", glVertexAttribI2i == NULL);

  glewInfoFunc("glVertexAttribI2iv", glVertexAttribI2iv == NULL);

  glewInfoFunc("glVertexAttribI2ui", glVertexAttribI2ui == NULL);

  glewInfoFunc("glVertexAttribI2uiv", glVertexAttribI2uiv == NULL);

  glewInfoFunc("glVertexAttribI3i", glVertexAttribI3i == NULL);

  glewInfoFunc("glVertexAttribI3iv", glVertexAttribI3iv == NULL);

  glewInfoFunc("glVertexAttribI3ui", glVertexAttribI3ui == NULL);

  glewInfoFunc("glVertexAttribI3uiv", glVertexAttribI3uiv == NULL);

  glewInfoFunc("glVertexAttribI4bv", glVertexAttribI4bv == NULL);

  glewInfoFunc("glVertexAttribI4i", glVertexAttribI4i == NULL);

  glewInfoFunc("glVertexAttribI4iv", glVertexAttribI4iv == NULL);

  glewInfoFunc("glVertexAttribI4sv", glVertexAttribI4sv == NULL);

  glewInfoFunc("glVertexAttribI4ubv", glVertexAttribI4ubv == NULL);

  glewInfoFunc("glVertexAttribI4ui", glVertexAttribI4ui == NULL);

  glewInfoFunc("glVertexAttribI4uiv", glVertexAttribI4uiv == NULL);

  glewInfoFunc("glVertexAttribI4usv", glVertexAttribI4usv == NULL);

  glewInfoFunc("glVertexAttribIPointer", glVertexAttribIPointer == NULL);

}


#endif /* GL_VERSION_3_0 */


#ifdef GL_VERSION_3_1


static void _glewInfo_GL_VERSION_3_1 (void)

{

  glewPrintExt("GL_VERSION_3_1", GLEW_VERSION_3_1, GLEW_VERSION_3_1, GLEW_VERSION_3_1);


  glewInfoFunc("glDrawArraysInstanced", glDrawArraysInstanced == NULL);

  glewInfoFunc("glDrawElementsInstanced", glDrawElementsInstanced == NULL);

  glewInfoFunc("glPrimitiveRestartIndex", glPrimitiveRestartIndex == NULL);

  glewInfoFunc("glTexBuffer", glTexBuffer == NULL);

}


#endif /* GL_VERSION_3_1 */


#ifdef GL_VERSION_3_2


static void _glewInfo_GL_VERSION_3_2 (void)

{

  glewPrintExt("GL_VERSION_3_2", GLEW_VERSION_3_2, GLEW_VERSION_3_2, GLEW_VERSION_3_2);


  glewInfoFunc("glFramebufferTexture", glFramebufferTexture == NULL);

  glewInfoFunc("glGetBufferParameteri64v", glGetBufferParameteri64v == NULL);

  glewInfoFunc("glGetInteger64i_v", glGetInteger64i_v == NULL);

}


#endif /* GL_VERSION_3_2 */


#ifdef GL_VERSION_3_3


static void _glewInfo_GL_VERSION_3_3 (void)

{

  glewPrintExt("GL_VERSION_3_3", GLEW_VERSION_3_3, GLEW_VERSION_3_3, GLEW_VERSION_3_3);


  glewInfoFunc("glVertexAttribDivisor", glVertexAttribDivisor == NULL);

}


#endif /* GL_VERSION_3_3 */


#ifdef GL_VERSION_4_0


static void _glewInfo_GL_VERSION_4_0 (void)

{

  glewPrintExt("GL_VERSION_4_0", GLEW_VERSION_4_0, GLEW_VERSION_4_0, GLEW_VERSION_4_0);


  glewInfoFunc("glBlendEquationSeparatei", glBlendEquationSeparatei == NULL);

  glewInfoFunc("glBlendEquationi", glBlendEquationi == NULL);

  glewInfoFunc("glBlendFuncSeparatei", glBlendFuncSeparatei == NULL);

  glewInfoFunc("glBlendFunci", glBlendFunci == NULL);

  glewInfoFunc("glMinSampleShading", glMinSampleShading == NULL);

}


#endif /* GL_VERSION_4_0 */


#ifdef GL_VERSION_4_1


static void _glewInfo_GL_VERSION_4_1 (void)

{

  glewPrintExt("GL_VERSION_4_1", GLEW_VERSION_4_1, GLEW_VERSION_4_1, GLEW_VERSION_4_1);

}


#endif /* GL_VERSION_4_1 */


#ifdef GL_VERSION_4_2


static void _glewInfo_GL_VERSION_4_2 (void)

{

  glewPrintExt("GL_VERSION_4_2", GLEW_VERSION_4_2, GLEW_VERSION_4_2, GLEW_VERSION_4_2);

}


#endif /* GL_VERSION_4_2 */


#ifdef GL_VERSION_4_3


static void _glewInfo_GL_VERSION_4_3 (void)

{

  glewPrintExt("GL_VERSION_4_3", GLEW_VERSION_4_3, GLEW_VERSION_4_3, GLEW_VERSION_4_3);

}


#endif /* GL_VERSION_4_3 */


#ifdef GL_VERSION_4_4


static void _glewInfo_GL_VERSION_4_4 (void)

{

  glewPrintExt("GL_VERSION_4_4", GLEW_VERSION_4_4, GLEW_VERSION_4_4, GLEW_VERSION_4_4);

}


#endif /* GL_VERSION_4_4 */


#ifdef GL_3DFX_multisample


static void _glewInfo_GL_3DFX_multisample (void)

{

  glewPrintExt("GL_3DFX_multisample", GLEW_3DFX_multisample, glewIsSupported("GL_3DFX_multisample"), glewGetExtension("GL_3DFX_multisample"));

}


#endif /* GL_3DFX_multisample */


#ifdef GL_3DFX_tbuffer


static void _glewInfo_GL_3DFX_tbuffer (void)

{

  glewPrintExt("GL_3DFX_tbuffer", GLEW_3DFX_tbuffer, glewIsSupported("GL_3DFX_tbuffer"), glewGetExtension("GL_3DFX_tbuffer"));


  glewInfoFunc("glTbufferMask3DFX", glTbufferMask3DFX == NULL);

}


#endif /* GL_3DFX_tbuffer */


#ifdef GL_3DFX_texture_compression_FXT1


static void _glewInfo_GL_3DFX_texture_compression_FXT1 (void)

{

  glewPrintExt("GL_3DFX_texture_compression_FXT1", GLEW_3DFX_texture_compression_FXT1, glewIsSupported("GL_3DFX_texture_compression_FXT1"), glewGetExtension("GL_3DFX_texture_compression_FXT1"));

}


#endif /* GL_3DFX_texture_compression_FXT1 */


#ifdef GL_AMD_blend_minmax_factor


static void _glewInfo_GL_AMD_blend_minmax_factor (void)

{

  glewPrintExt("GL_AMD_blend_minmax_factor", GLEW_AMD_blend_minmax_factor, glewIsSupported("GL_AMD_blend_minmax_factor"), glewGetExtension("GL_AMD_blend_minmax_factor"));

}


#endif /* GL_AMD_blend_minmax_factor */


#ifdef GL_AMD_conservative_depth


static void _glewInfo_GL_AMD_conservative_depth (void)

{

  glewPrintExt("GL_AMD_conservative_depth", GLEW_AMD_conservative_depth, glewIsSupported("GL_AMD_conservative_depth"), glewGetExtension("GL_AMD_conservative_depth"));

}


#endif /* GL_AMD_conservative_depth */


#ifdef GL_AMD_debug_output


static void _glewInfo_GL_AMD_debug_output (void)

{

  glewPrintExt("GL_AMD_debug_output", GLEW_AMD_debug_output, glewIsSupported("GL_AMD_debug_output"), glewGetExtension("GL_AMD_debug_output"));


  glewInfoFunc("glDebugMessageCallbackAMD", glDebugMessageCallbackAMD == NULL);

  glewInfoFunc("glDebugMessageEnableAMD", glDebugMessageEnableAMD == NULL);

  glewInfoFunc("glDebugMessageInsertAMD", glDebugMessageInsertAMD == NULL);

  glewInfoFunc("glGetDebugMessageLogAMD", glGetDebugMessageLogAMD == NULL);

}


#endif /* GL_AMD_debug_output */


#ifdef GL_AMD_depth_clamp_separate


static void _glewInfo_GL_AMD_depth_clamp_separate (void)

{

  glewPrintExt("GL_AMD_depth_clamp_separate", GLEW_AMD_depth_clamp_separate, glewIsSupported("GL_AMD_depth_clamp_separate"), glewGetExtension("GL_AMD_depth_clamp_separate"));

}


#endif /* GL_AMD_depth_clamp_separate */


#ifdef GL_AMD_draw_buffers_blend


static void _glewInfo_GL_AMD_draw_buffers_blend (void)

{

  glewPrintExt("GL_AMD_draw_buffers_blend", GLEW_AMD_draw_buffers_blend, glewIsSupported("GL_AMD_draw_buffers_blend"), glewGetExtension("GL_AMD_draw_buffers_blend"));


  glewInfoFunc("glBlendEquationIndexedAMD", glBlendEquationIndexedAMD == NULL);

  glewInfoFunc("glBlendEquationSeparateIndexedAMD", glBlendEquationSeparateIndexedAMD == NULL);

  glewInfoFunc("glBlendFuncIndexedAMD", glBlendFuncIndexedAMD == NULL);

  glewInfoFunc("glBlendFuncSeparateIndexedAMD", glBlendFuncSeparateIndexedAMD == NULL);

}


#endif /* GL_AMD_draw_buffers_blend */


#ifdef GL_AMD_interleaved_elements


static void _glewInfo_GL_AMD_interleaved_elements (void)

{

  glewPrintExt("GL_AMD_interleaved_elements", GLEW_AMD_interleaved_elements, glewIsSupported("GL_AMD_interleaved_elements"), glewGetExtension("GL_AMD_interleaved_elements"));


  glewInfoFunc("glVertexAttribParameteriAMD", glVertexAttribParameteriAMD == NULL);

}


#endif /* GL_AMD_interleaved_elements */


#ifdef GL_AMD_multi_draw_indirect


static void _glewInfo_GL_AMD_multi_draw_indirect (void)

{

  glewPrintExt("GL_AMD_multi_draw_indirect", GLEW_AMD_multi_draw_indirect, glewIsSupported("GL_AMD_multi_draw_indirect"), glewGetExtension("GL_AMD_multi_draw_indirect"));


  glewInfoFunc("glMultiDrawArraysIndirectAMD", glMultiDrawArraysIndirectAMD == NULL);

  glewInfoFunc("glMultiDrawElementsIndirectAMD", glMultiDrawElementsIndirectAMD == NULL);

}


#endif /* GL_AMD_multi_draw_indirect */


#ifdef GL_AMD_name_gen_delete


static void _glewInfo_GL_AMD_name_gen_delete (void)

{

  glewPrintExt("GL_AMD_name_gen_delete", GLEW_AMD_name_gen_delete, glewIsSupported("GL_AMD_name_gen_delete"), glewGetExtension("GL_AMD_name_gen_delete"));


  glewInfoFunc("glDeleteNamesAMD", glDeleteNamesAMD == NULL);

  glewInfoFunc("glGenNamesAMD", glGenNamesAMD == NULL);

  glewInfoFunc("glIsNameAMD", glIsNameAMD == NULL);

}


#endif /* GL_AMD_name_gen_delete */


#ifdef GL_AMD_performance_monitor


static void _glewInfo_GL_AMD_performance_monitor (void)

{

  glewPrintExt("GL_AMD_performance_monitor", GLEW_AMD_performance_monitor, glewIsSupported("GL_AMD_performance_monitor"), glewGetExtension("GL_AMD_performance_monitor"));


  glewInfoFunc("glBeginPerfMonitorAMD", glBeginPerfMonitorAMD == NULL);

  glewInfoFunc("glDeletePerfMonitorsAMD", glDeletePerfMonitorsAMD == NULL);

  glewInfoFunc("glEndPerfMonitorAMD", glEndPerfMonitorAMD == NULL);

  glewInfoFunc("glGenPerfMonitorsAMD", glGenPerfMonitorsAMD == NULL);

  glewInfoFunc("glGetPerfMonitorCounterDataAMD", glGetPerfMonitorCounterDataAMD == NULL);

  glewInfoFunc("glGetPerfMonitorCounterInfoAMD", glGetPerfMonitorCounterInfoAMD == NULL);

  glewInfoFunc("glGetPerfMonitorCounterStringAMD", glGetPerfMonitorCounterStringAMD == NULL);

  glewInfoFunc("glGetPerfMonitorCountersAMD", glGetPerfMonitorCountersAMD == NULL);

  glewInfoFunc("glGetPerfMonitorGroupStringAMD", glGetPerfMonitorGroupStringAMD == NULL);

  glewInfoFunc("glGetPerfMonitorGroupsAMD", glGetPerfMonitorGroupsAMD == NULL);

  glewInfoFunc("glSelectPerfMonitorCountersAMD", glSelectPerfMonitorCountersAMD == NULL);

}


#endif /* GL_AMD_performance_monitor */


#ifdef GL_AMD_pinned_memory


static void _glewInfo_GL_AMD_pinned_memory (void)

{

  glewPrintExt("GL_AMD_pinned_memory", GLEW_AMD_pinned_memory, glewIsSupported("GL_AMD_pinned_memory"), glewGetExtension("GL_AMD_pinned_memory"));

}


#endif /* GL_AMD_pinned_memory */


#ifdef GL_AMD_query_buffer_object


static void _glewInfo_GL_AMD_query_buffer_object (void)

{

  glewPrintExt("GL_AMD_query_buffer_object", GLEW_AMD_query_buffer_object, glewIsSupported("GL_AMD_query_buffer_object"), glewGetExtension("GL_AMD_query_buffer_object"));

}


#endif /* GL_AMD_query_buffer_object */


#ifdef GL_AMD_sample_positions


static void _glewInfo_GL_AMD_sample_positions (void)

{

  glewPrintExt("GL_AMD_sample_positions", GLEW_AMD_sample_positions, glewIsSupported("GL_AMD_sample_positions"), glewGetExtension("GL_AMD_sample_positions"));


  glewInfoFunc("glSetMultisamplefvAMD", glSetMultisamplefvAMD == NULL);

}


#endif /* GL_AMD_sample_positions */


#ifdef GL_AMD_seamless_cubemap_per_texture


static void _glewInfo_GL_AMD_seamless_cubemap_per_texture (void)

{

  glewPrintExt("GL_AMD_seamless_cubemap_per_texture", GLEW_AMD_seamless_cubemap_per_texture, glewIsSupported("GL_AMD_seamless_cubemap_per_texture"), glewGetExtension("GL_AMD_seamless_cubemap_per_texture"));

}


#endif /* GL_AMD_seamless_cubemap_per_texture */


#ifdef GL_AMD_shader_stencil_export


static void _glewInfo_GL_AMD_shader_stencil_export (void)

{

  glewPrintExt("GL_AMD_shader_stencil_export", GLEW_AMD_shader_stencil_export, glewIsSupported("GL_AMD_shader_stencil_export"), glewGetExtension("GL_AMD_shader_stencil_export"));

}


#endif /* GL_AMD_shader_stencil_export */


#ifdef GL_AMD_shader_trinary_minmax


static void _glewInfo_GL_AMD_shader_trinary_minmax (void)

{

  glewPrintExt("GL_AMD_shader_trinary_minmax", GLEW_AMD_shader_trinary_minmax, glewIsSupported("GL_AMD_shader_trinary_minmax"), glewGetExtension("GL_AMD_shader_trinary_minmax"));

}


#endif /* GL_AMD_shader_trinary_minmax */


#ifdef GL_AMD_sparse_texture


static void _glewInfo_GL_AMD_sparse_texture (void)

{

  glewPrintExt("GL_AMD_sparse_texture", GLEW_AMD_sparse_texture, glewIsSupported("GL_AMD_sparse_texture"), glewGetExtension("GL_AMD_sparse_texture"));


  glewInfoFunc("glTexStorageSparseAMD", glTexStorageSparseAMD == NULL);

  glewInfoFunc("glTextureStorageSparseAMD", glTextureStorageSparseAMD == NULL);

}


#endif /* GL_AMD_sparse_texture */


#ifdef GL_AMD_stencil_operation_extended


static void _glewInfo_GL_AMD_stencil_operation_extended (void)

{

  glewPrintExt("GL_AMD_stencil_operation_extended", GLEW_AMD_stencil_operation_extended, glewIsSupported("GL_AMD_stencil_operation_extended"), glewGetExtension("GL_AMD_stencil_operation_extended"));


  glewInfoFunc("glStencilOpValueAMD", glStencilOpValueAMD == NULL);

}


#endif /* GL_AMD_stencil_operation_extended */


#ifdef GL_AMD_texture_texture4


static void _glewInfo_GL_AMD_texture_texture4 (void)

{

  glewPrintExt("GL_AMD_texture_texture4", GLEW_AMD_texture_texture4, glewIsSupported("GL_AMD_texture_texture4"), glewGetExtension("GL_AMD_texture_texture4"));

}


#endif /* GL_AMD_texture_texture4 */


#ifdef GL_AMD_transform_feedback3_lines_triangles


static void _glewInfo_GL_AMD_transform_feedback3_lines_triangles (void)

{

  glewPrintExt("GL_AMD_transform_feedback3_lines_triangles", GLEW_AMD_transform_feedback3_lines_triangles, glewIsSupported("GL_AMD_transform_feedback3_lines_triangles"), glewGetExtension("GL_AMD_transform_feedback3_lines_triangles"));

}


#endif /* GL_AMD_transform_feedback3_lines_triangles */


#ifdef GL_AMD_vertex_shader_layer


static void _glewInfo_GL_AMD_vertex_shader_layer (void)

{

  glewPrintExt("GL_AMD_vertex_shader_layer", GLEW_AMD_vertex_shader_layer, glewIsSupported("GL_AMD_vertex_shader_layer"), glewGetExtension("GL_AMD_vertex_shader_layer"));

}


#endif /* GL_AMD_vertex_shader_layer */


#ifdef GL_AMD_vertex_shader_tessellator


static void _glewInfo_GL_AMD_vertex_shader_tessellator (void)

{

  glewPrintExt("GL_AMD_vertex_shader_tessellator", GLEW_AMD_vertex_shader_tessellator, glewIsSupported("GL_AMD_vertex_shader_tessellator"), glewGetExtension("GL_AMD_vertex_shader_tessellator"));


  glewInfoFunc("glTessellationFactorAMD", glTessellationFactorAMD == NULL);

  glewInfoFunc("glTessellationModeAMD", glTessellationModeAMD == NULL);

}


#endif /* GL_AMD_vertex_shader_tessellator */


#ifdef GL_AMD_vertex_shader_viewport_index


static void _glewInfo_GL_AMD_vertex_shader_viewport_index (void)

{

  glewPrintExt("GL_AMD_vertex_shader_viewport_index", GLEW_AMD_vertex_shader_viewport_index, glewIsSupported("GL_AMD_vertex_shader_viewport_index"), glewGetExtension("GL_AMD_vertex_shader_viewport_index"));

}


#endif /* GL_AMD_vertex_shader_viewport_index */


#ifdef GL_ANGLE_depth_texture


static void _glewInfo_GL_ANGLE_depth_texture (void)

{

  glewPrintExt("GL_ANGLE_depth_texture", GLEW_ANGLE_depth_texture, glewIsSupported("GL_ANGLE_depth_texture"), glewGetExtension("GL_ANGLE_depth_texture"));

}


#endif /* GL_ANGLE_depth_texture */


#ifdef GL_ANGLE_framebuffer_blit


static void _glewInfo_GL_ANGLE_framebuffer_blit (void)

{

  glewPrintExt("GL_ANGLE_framebuffer_blit", GLEW_ANGLE_framebuffer_blit, glewIsSupported("GL_ANGLE_framebuffer_blit"), glewGetExtension("GL_ANGLE_framebuffer_blit"));


  glewInfoFunc("glBlitFramebufferANGLE", glBlitFramebufferANGLE == NULL);

}


#endif /* GL_ANGLE_framebuffer_blit */


#ifdef GL_ANGLE_framebuffer_multisample


static void _glewInfo_GL_ANGLE_framebuffer_multisample (void)

{

  glewPrintExt("GL_ANGLE_framebuffer_multisample", GLEW_ANGLE_framebuffer_multisample, glewIsSupported("GL_ANGLE_framebuffer_multisample"), glewGetExtension("GL_ANGLE_framebuffer_multisample"));


  glewInfoFunc("glRenderbufferStorageMultisampleANGLE", glRenderbufferStorageMultisampleANGLE == NULL);

}


#endif /* GL_ANGLE_framebuffer_multisample */


#ifdef GL_ANGLE_instanced_arrays


static void _glewInfo_GL_ANGLE_instanced_arrays (void)

{

  glewPrintExt("GL_ANGLE_instanced_arrays", GLEW_ANGLE_instanced_arrays, glewIsSupported("GL_ANGLE_instanced_arrays"), glewGetExtension("GL_ANGLE_instanced_arrays"));


  glewInfoFunc("glDrawArraysInstancedANGLE", glDrawArraysInstancedANGLE == NULL);

  glewInfoFunc("glDrawElementsInstancedANGLE", glDrawElementsInstancedANGLE == NULL);

  glewInfoFunc("glVertexAttribDivisorANGLE", glVertexAttribDivisorANGLE == NULL);

}


#endif /* GL_ANGLE_instanced_arrays */


#ifdef GL_ANGLE_pack_reverse_row_order


static void _glewInfo_GL_ANGLE_pack_reverse_row_order (void)

{

  glewPrintExt("GL_ANGLE_pack_reverse_row_order", GLEW_ANGLE_pack_reverse_row_order, glewIsSupported("GL_ANGLE_pack_reverse_row_order"), glewGetExtension("GL_ANGLE_pack_reverse_row_order"));

}


#endif /* GL_ANGLE_pack_reverse_row_order */


#ifdef GL_ANGLE_program_binary


static void _glewInfo_GL_ANGLE_program_binary (void)

{

  glewPrintExt("GL_ANGLE_program_binary", GLEW_ANGLE_program_binary, glewIsSupported("GL_ANGLE_program_binary"), glewGetExtension("GL_ANGLE_program_binary"));

}


#endif /* GL_ANGLE_program_binary */


#ifdef GL_ANGLE_texture_compression_dxt1


static void _glewInfo_GL_ANGLE_texture_compression_dxt1 (void)

{

  glewPrintExt("GL_ANGLE_texture_compression_dxt1", GLEW_ANGLE_texture_compression_dxt1, glewIsSupported("GL_ANGLE_texture_compression_dxt1"), glewGetExtension("GL_ANGLE_texture_compression_dxt1"));

}


#endif /* GL_ANGLE_texture_compression_dxt1 */


#ifdef GL_ANGLE_texture_compression_dxt3


static void _glewInfo_GL_ANGLE_texture_compression_dxt3 (void)

{

  glewPrintExt("GL_ANGLE_texture_compression_dxt3", GLEW_ANGLE_texture_compression_dxt3, glewIsSupported("GL_ANGLE_texture_compression_dxt3"), glewGetExtension("GL_ANGLE_texture_compression_dxt3"));

}


#endif /* GL_ANGLE_texture_compression_dxt3 */


#ifdef GL_ANGLE_texture_compression_dxt5


static void _glewInfo_GL_ANGLE_texture_compression_dxt5 (void)

{

  glewPrintExt("GL_ANGLE_texture_compression_dxt5", GLEW_ANGLE_texture_compression_dxt5, glewIsSupported("GL_ANGLE_texture_compression_dxt5"), glewGetExtension("GL_ANGLE_texture_compression_dxt5"));

}


#endif /* GL_ANGLE_texture_compression_dxt5 */


#ifdef GL_ANGLE_texture_usage


static void _glewInfo_GL_ANGLE_texture_usage (void)

{

  glewPrintExt("GL_ANGLE_texture_usage", GLEW_ANGLE_texture_usage, glewIsSupported("GL_ANGLE_texture_usage"), glewGetExtension("GL_ANGLE_texture_usage"));

}


#endif /* GL_ANGLE_texture_usage */


#ifdef GL_ANGLE_timer_query


static void _glewInfo_GL_ANGLE_timer_query (void)

{

  glewPrintExt("GL_ANGLE_timer_query", GLEW_ANGLE_timer_query, glewIsSupported("GL_ANGLE_timer_query"), glewGetExtension("GL_ANGLE_timer_query"));


  glewInfoFunc("glBeginQueryANGLE", glBeginQueryANGLE == NULL);

  glewInfoFunc("glDeleteQueriesANGLE", glDeleteQueriesANGLE == NULL);

  glewInfoFunc("glEndQueryANGLE", glEndQueryANGLE == NULL);

  glewInfoFunc("glGenQueriesANGLE", glGenQueriesANGLE == NULL);

  glewInfoFunc("glGetQueryObjecti64vANGLE", glGetQueryObjecti64vANGLE == NULL);

  glewInfoFunc("glGetQueryObjectivANGLE", glGetQueryObjectivANGLE == NULL);

  glewInfoFunc("glGetQueryObjectui64vANGLE", glGetQueryObjectui64vANGLE == NULL);

  glewInfoFunc("glGetQueryObjectuivANGLE", glGetQueryObjectuivANGLE == NULL);

  glewInfoFunc("glGetQueryivANGLE", glGetQueryivANGLE == NULL);

  glewInfoFunc("glIsQueryANGLE", glIsQueryANGLE == NULL);

  glewInfoFunc("glQueryCounterANGLE", glQueryCounterANGLE == NULL);

}


#endif /* GL_ANGLE_timer_query */


#ifdef GL_ANGLE_translated_shader_source


static void _glewInfo_GL_ANGLE_translated_shader_source (void)

{

  glewPrintExt("GL_ANGLE_translated_shader_source", GLEW_ANGLE_translated_shader_source, glewIsSupported("GL_ANGLE_translated_shader_source"), glewGetExtension("GL_ANGLE_translated_shader_source"));


  glewInfoFunc("glGetTranslatedShaderSourceANGLE", glGetTranslatedShaderSourceANGLE == NULL);

}


#endif /* GL_ANGLE_translated_shader_source */


#ifdef GL_APPLE_aux_depth_stencil


static void _glewInfo_GL_APPLE_aux_depth_stencil (void)

{

  glewPrintExt("GL_APPLE_aux_depth_stencil", GLEW_APPLE_aux_depth_stencil, glewIsSupported("GL_APPLE_aux_depth_stencil"), glewGetExtension("GL_APPLE_aux_depth_stencil"));

}


#endif /* GL_APPLE_aux_depth_stencil */


#ifdef GL_APPLE_client_storage


static void _glewInfo_GL_APPLE_client_storage (void)

{

  glewPrintExt("GL_APPLE_client_storage", GLEW_APPLE_client_storage, glewIsSupported("GL_APPLE_client_storage"), glewGetExtension("GL_APPLE_client_storage"));

}


#endif /* GL_APPLE_client_storage */


#ifdef GL_APPLE_element_array


static void _glewInfo_GL_APPLE_element_array (void)

{

  glewPrintExt("GL_APPLE_element_array", GLEW_APPLE_element_array, glewIsSupported("GL_APPLE_element_array"), glewGetExtension("GL_APPLE_element_array"));


  glewInfoFunc("glDrawElementArrayAPPLE", glDrawElementArrayAPPLE == NULL);

  glewInfoFunc("glDrawRangeElementArrayAPPLE", glDrawRangeElementArrayAPPLE == NULL);

  glewInfoFunc("glElementPointerAPPLE", glElementPointerAPPLE == NULL);

  glewInfoFunc("glMultiDrawElementArrayAPPLE", glMultiDrawElementArrayAPPLE == NULL);

  glewInfoFunc("glMultiDrawRangeElementArrayAPPLE", glMultiDrawRangeElementArrayAPPLE == NULL);

}


#endif /* GL_APPLE_element_array */


#ifdef GL_APPLE_fence


static void _glewInfo_GL_APPLE_fence (void)

{

  glewPrintExt("GL_APPLE_fence", GLEW_APPLE_fence, glewIsSupported("GL_APPLE_fence"), glewGetExtension("GL_APPLE_fence"));


  glewInfoFunc("glDeleteFencesAPPLE", glDeleteFencesAPPLE == NULL);

  glewInfoFunc("glFinishFenceAPPLE", glFinishFenceAPPLE == NULL);

  glewInfoFunc("glFinishObjectAPPLE", glFinishObjectAPPLE == NULL);

  glewInfoFunc("glGenFencesAPPLE", glGenFencesAPPLE == NULL);

  glewInfoFunc("glIsFenceAPPLE", glIsFenceAPPLE == NULL);

  glewInfoFunc("glSetFenceAPPLE", glSetFenceAPPLE == NULL);

  glewInfoFunc("glTestFenceAPPLE", glTestFenceAPPLE == NULL);

  glewInfoFunc("glTestObjectAPPLE", glTestObjectAPPLE == NULL);

}


#endif /* GL_APPLE_fence */


#ifdef GL_APPLE_float_pixels


static void _glewInfo_GL_APPLE_float_pixels (void)

{

  glewPrintExt("GL_APPLE_float_pixels", GLEW_APPLE_float_pixels, glewIsSupported("GL_APPLE_float_pixels"), glewGetExtension("GL_APPLE_float_pixels"));

}


#endif /* GL_APPLE_float_pixels */


#ifdef GL_APPLE_flush_buffer_range


static void _glewInfo_GL_APPLE_flush_buffer_range (void)

{

  glewPrintExt("GL_APPLE_flush_buffer_range", GLEW_APPLE_flush_buffer_range, glewIsSupported("GL_APPLE_flush_buffer_range"), glewGetExtension("GL_APPLE_flush_buffer_range"));


  glewInfoFunc("glBufferParameteriAPPLE", glBufferParameteriAPPLE == NULL);

  glewInfoFunc("glFlushMappedBufferRangeAPPLE", glFlushMappedBufferRangeAPPLE == NULL);

}


#endif /* GL_APPLE_flush_buffer_range */


#ifdef GL_APPLE_object_purgeable


static void _glewInfo_GL_APPLE_object_purgeable (void)

{

  glewPrintExt("GL_APPLE_object_purgeable", GLEW_APPLE_object_purgeable, glewIsSupported("GL_APPLE_object_purgeable"), glewGetExtension("GL_APPLE_object_purgeable"));


  glewInfoFunc("glGetObjectParameterivAPPLE", glGetObjectParameterivAPPLE == NULL);

  glewInfoFunc("glObjectPurgeableAPPLE", glObjectPurgeableAPPLE == NULL);

  glewInfoFunc("glObjectUnpurgeableAPPLE", glObjectUnpurgeableAPPLE == NULL);

}


#endif /* GL_APPLE_object_purgeable */


#ifdef GL_APPLE_pixel_buffer


static void _glewInfo_GL_APPLE_pixel_buffer (void)

{

  glewPrintExt("GL_APPLE_pixel_buffer", GLEW_APPLE_pixel_buffer, glewIsSupported("GL_APPLE_pixel_buffer"), glewGetExtension("GL_APPLE_pixel_buffer"));

}


#endif /* GL_APPLE_pixel_buffer */


#ifdef GL_APPLE_rgb_422


static void _glewInfo_GL_APPLE_rgb_422 (void)

{

  glewPrintExt("GL_APPLE_rgb_422", GLEW_APPLE_rgb_422, glewIsSupported("GL_APPLE_rgb_422"), glewGetExtension("GL_APPLE_rgb_422"));

}


#endif /* GL_APPLE_rgb_422 */


#ifdef GL_APPLE_row_bytes


static void _glewInfo_GL_APPLE_row_bytes (void)

{

  glewPrintExt("GL_APPLE_row_bytes", GLEW_APPLE_row_bytes, glewIsSupported("GL_APPLE_row_bytes"), glewGetExtension("GL_APPLE_row_bytes"));

}


#endif /* GL_APPLE_row_bytes */


#ifdef GL_APPLE_specular_vector


static void _glewInfo_GL_APPLE_specular_vector (void)

{

  glewPrintExt("GL_APPLE_specular_vector", GLEW_APPLE_specular_vector, glewIsSupported("GL_APPLE_specular_vector"), glewGetExtension("GL_APPLE_specular_vector"));

}


#endif /* GL_APPLE_specular_vector */


#ifdef GL_APPLE_texture_range


static void _glewInfo_GL_APPLE_texture_range (void)

{

  glewPrintExt("GL_APPLE_texture_range", GLEW_APPLE_texture_range, glewIsSupported("GL_APPLE_texture_range"), glewGetExtension("GL_APPLE_texture_range"));


  glewInfoFunc("glGetTexParameterPointervAPPLE", glGetTexParameterPointervAPPLE == NULL);

  glewInfoFunc("glTextureRangeAPPLE", glTextureRangeAPPLE == NULL);

}


#endif /* GL_APPLE_texture_range */


#ifdef GL_APPLE_transform_hint


static void _glewInfo_GL_APPLE_transform_hint (void)

{

  glewPrintExt("GL_APPLE_transform_hint", GLEW_APPLE_transform_hint, glewIsSupported("GL_APPLE_transform_hint"), glewGetExtension("GL_APPLE_transform_hint"));

}


#endif /* GL_APPLE_transform_hint */


#ifdef GL_APPLE_vertex_array_object


static void _glewInfo_GL_APPLE_vertex_array_object (void)

{

  glewPrintExt("GL_APPLE_vertex_array_object", GLEW_APPLE_vertex_array_object, glewIsSupported("GL_APPLE_vertex_array_object"), glewGetExtension("GL_APPLE_vertex_array_object"));


  glewInfoFunc("glBindVertexArrayAPPLE", glBindVertexArrayAPPLE == NULL);

  glewInfoFunc("glDeleteVertexArraysAPPLE", glDeleteVertexArraysAPPLE == NULL);

  glewInfoFunc("glGenVertexArraysAPPLE", glGenVertexArraysAPPLE == NULL);

  glewInfoFunc("glIsVertexArrayAPPLE", glIsVertexArrayAPPLE == NULL);

}


#endif /* GL_APPLE_vertex_array_object */


#ifdef GL_APPLE_vertex_array_range


static void _glewInfo_GL_APPLE_vertex_array_range (void)

{

  glewPrintExt("GL_APPLE_vertex_array_range", GLEW_APPLE_vertex_array_range, glewIsSupported("GL_APPLE_vertex_array_range"), glewGetExtension("GL_APPLE_vertex_array_range"));


  glewInfoFunc("glFlushVertexArrayRangeAPPLE", glFlushVertexArrayRangeAPPLE == NULL);

  glewInfoFunc("glVertexArrayParameteriAPPLE", glVertexArrayParameteriAPPLE == NULL);

  glewInfoFunc("glVertexArrayRangeAPPLE", glVertexArrayRangeAPPLE == NULL);

}


#endif /* GL_APPLE_vertex_array_range */


#ifdef GL_APPLE_vertex_program_evaluators


static void _glewInfo_GL_APPLE_vertex_program_evaluators (void)

{

  glewPrintExt("GL_APPLE_vertex_program_evaluators", GLEW_APPLE_vertex_program_evaluators, glewIsSupported("GL_APPLE_vertex_program_evaluators"), glewGetExtension("GL_APPLE_vertex_program_evaluators"));


  glewInfoFunc("glDisableVertexAttribAPPLE", glDisableVertexAttribAPPLE == NULL);

  glewInfoFunc("glEnableVertexAttribAPPLE", glEnableVertexAttribAPPLE == NULL);

  glewInfoFunc("glIsVertexAttribEnabledAPPLE", glIsVertexAttribEnabledAPPLE == NULL);

  glewInfoFunc("glMapVertexAttrib1dAPPLE", glMapVertexAttrib1dAPPLE == NULL);

  glewInfoFunc("glMapVertexAttrib1fAPPLE", glMapVertexAttrib1fAPPLE == NULL);

  glewInfoFunc("glMapVertexAttrib2dAPPLE", glMapVertexAttrib2dAPPLE == NULL);

  glewInfoFunc("glMapVertexAttrib2fAPPLE", glMapVertexAttrib2fAPPLE == NULL);

}


#endif /* GL_APPLE_vertex_program_evaluators */


#ifdef GL_APPLE_ycbcr_422


static void _glewInfo_GL_APPLE_ycbcr_422 (void)

{

  glewPrintExt("GL_APPLE_ycbcr_422", GLEW_APPLE_ycbcr_422, glewIsSupported("GL_APPLE_ycbcr_422"), glewGetExtension("GL_APPLE_ycbcr_422"));

}


#endif /* GL_APPLE_ycbcr_422 */


#ifdef GL_ARB_ES2_compatibility


static void _glewInfo_GL_ARB_ES2_compatibility (void)

{

  glewPrintExt("GL_ARB_ES2_compatibility", GLEW_ARB_ES2_compatibility, glewIsSupported("GL_ARB_ES2_compatibility"), glewGetExtension("GL_ARB_ES2_compatibility"));


  glewInfoFunc("glClearDepthf", glClearDepthf == NULL);

  glewInfoFunc("glDepthRangef", glDepthRangef == NULL);

  glewInfoFunc("glGetShaderPrecisionFormat", glGetShaderPrecisionFormat == NULL);

  glewInfoFunc("glReleaseShaderCompiler", glReleaseShaderCompiler == NULL);

  glewInfoFunc("glShaderBinary", glShaderBinary == NULL);

}


#endif /* GL_ARB_ES2_compatibility */


#ifdef GL_ARB_ES3_compatibility


static void _glewInfo_GL_ARB_ES3_compatibility (void)

{

  glewPrintExt("GL_ARB_ES3_compatibility", GLEW_ARB_ES3_compatibility, glewIsSupported("GL_ARB_ES3_compatibility"), glewGetExtension("GL_ARB_ES3_compatibility"));

}


#endif /* GL_ARB_ES3_compatibility */


#ifdef GL_ARB_arrays_of_arrays


static void _glewInfo_GL_ARB_arrays_of_arrays (void)

{

  glewPrintExt("GL_ARB_arrays_of_arrays", GLEW_ARB_arrays_of_arrays, glewIsSupported("GL_ARB_arrays_of_arrays"), glewGetExtension("GL_ARB_arrays_of_arrays"));

}


#endif /* GL_ARB_arrays_of_arrays */


#ifdef GL_ARB_base_instance


static void _glewInfo_GL_ARB_base_instance (void)

{

  glewPrintExt("GL_ARB_base_instance", GLEW_ARB_base_instance, glewIsSupported("GL_ARB_base_instance"), glewGetExtension("GL_ARB_base_instance"));


  glewInfoFunc("glDrawArraysInstancedBaseInstance", glDrawArraysInstancedBaseInstance == NULL);

  glewInfoFunc("glDrawElementsInstancedBaseInstance", glDrawElementsInstancedBaseInstance == NULL);

  glewInfoFunc("glDrawElementsInstancedBaseVertexBaseInstance", glDrawElementsInstancedBaseVertexBaseInstance == NULL);

}


#endif /* GL_ARB_base_instance */


#ifdef GL_ARB_bindless_texture


static void _glewInfo_GL_ARB_bindless_texture (void)

{

  glewPrintExt("GL_ARB_bindless_texture", GLEW_ARB_bindless_texture, glewIsSupported("GL_ARB_bindless_texture"), glewGetExtension("GL_ARB_bindless_texture"));


  glewInfoFunc("glGetImageHandleARB", glGetImageHandleARB == NULL);

  glewInfoFunc("glGetTextureHandleARB", glGetTextureHandleARB == NULL);

  glewInfoFunc("glGetTextureSamplerHandleARB", glGetTextureSamplerHandleARB == NULL);

  glewInfoFunc("glGetVertexAttribLui64vARB", glGetVertexAttribLui64vARB == NULL);

  glewInfoFunc("glIsImageHandleResidentARB", glIsImageHandleResidentARB == NULL);

  glewInfoFunc("glIsTextureHandleResidentARB", glIsTextureHandleResidentARB == NULL);

  glewInfoFunc("glMakeImageHandleNonResidentARB", glMakeImageHandleNonResidentARB == NULL);

  glewInfoFunc("glMakeImageHandleResidentARB", glMakeImageHandleResidentARB == NULL);

  glewInfoFunc("glMakeTextureHandleNonResidentARB", glMakeTextureHandleNonResidentARB == NULL);

  glewInfoFunc("glMakeTextureHandleResidentARB", glMakeTextureHandleResidentARB == NULL);

  glewInfoFunc("glProgramUniformHandleui64ARB", glProgramUniformHandleui64ARB == NULL);

  glewInfoFunc("glProgramUniformHandleui64vARB", glProgramUniformHandleui64vARB == NULL);

  glewInfoFunc("glUniformHandleui64ARB", glUniformHandleui64ARB == NULL);

  glewInfoFunc("glUniformHandleui64vARB", glUniformHandleui64vARB == NULL);

  glewInfoFunc("glVertexAttribL1ui64ARB", glVertexAttribL1ui64ARB == NULL);

  glewInfoFunc("glVertexAttribL1ui64vARB", glVertexAttribL1ui64vARB == NULL);

}


#endif /* GL_ARB_bindless_texture */


#ifdef GL_ARB_blend_func_extended


static void _glewInfo_GL_ARB_blend_func_extended (void)

{

  glewPrintExt("GL_ARB_blend_func_extended", GLEW_ARB_blend_func_extended, glewIsSupported("GL_ARB_blend_func_extended"), glewGetExtension("GL_ARB_blend_func_extended"));


  glewInfoFunc("glBindFragDataLocationIndexed", glBindFragDataLocationIndexed == NULL);

  glewInfoFunc("glGetFragDataIndex", glGetFragDataIndex == NULL);

}


#endif /* GL_ARB_blend_func_extended */


#ifdef GL_ARB_buffer_storage


static void _glewInfo_GL_ARB_buffer_storage (void)

{

  glewPrintExt("GL_ARB_buffer_storage", GLEW_ARB_buffer_storage, glewIsSupported("GL_ARB_buffer_storage"), glewGetExtension("GL_ARB_buffer_storage"));


  glewInfoFunc("glBufferStorage", glBufferStorage == NULL);

  glewInfoFunc("glNamedBufferStorageEXT", glNamedBufferStorageEXT == NULL);

}


#endif /* GL_ARB_buffer_storage */


#ifdef GL_ARB_cl_event


static void _glewInfo_GL_ARB_cl_event (void)

{

  glewPrintExt("GL_ARB_cl_event", GLEW_ARB_cl_event, glewIsSupported("GL_ARB_cl_event"), glewGetExtension("GL_ARB_cl_event"));


  glewInfoFunc("glCreateSyncFromCLeventARB", glCreateSyncFromCLeventARB == NULL);

}


#endif /* GL_ARB_cl_event */


#ifdef GL_ARB_clear_buffer_object


static void _glewInfo_GL_ARB_clear_buffer_object (void)

{

  glewPrintExt("GL_ARB_clear_buffer_object", GLEW_ARB_clear_buffer_object, glewIsSupported("GL_ARB_clear_buffer_object"), glewGetExtension("GL_ARB_clear_buffer_object"));


  glewInfoFunc("glClearBufferData", glClearBufferData == NULL);

  glewInfoFunc("glClearBufferSubData", glClearBufferSubData == NULL);

  glewInfoFunc("glClearNamedBufferDataEXT", glClearNamedBufferDataEXT == NULL);

  glewInfoFunc("glClearNamedBufferSubDataEXT", glClearNamedBufferSubDataEXT == NULL);

}


#endif /* GL_ARB_clear_buffer_object */


#ifdef GL_ARB_clear_texture


static void _glewInfo_GL_ARB_clear_texture (void)

{

  glewPrintExt("GL_ARB_clear_texture", GLEW_ARB_clear_texture, glewIsSupported("GL_ARB_clear_texture"), glewGetExtension("GL_ARB_clear_texture"));


  glewInfoFunc("glClearTexImage", glClearTexImage == NULL);

  glewInfoFunc("glClearTexSubImage", glClearTexSubImage == NULL);

}


#endif /* GL_ARB_clear_texture */


#ifdef GL_ARB_color_buffer_float


static void _glewInfo_GL_ARB_color_buffer_float (void)

{

  glewPrintExt("GL_ARB_color_buffer_float", GLEW_ARB_color_buffer_float, glewIsSupported("GL_ARB_color_buffer_float"), glewGetExtension("GL_ARB_color_buffer_float"));


  glewInfoFunc("glClampColorARB", glClampColorARB == NULL);

}


#endif /* GL_ARB_color_buffer_float */


#ifdef GL_ARB_compatibility


static void _glewInfo_GL_ARB_compatibility (void)

{

  glewPrintExt("GL_ARB_compatibility", GLEW_ARB_compatibility, glewIsSupported("GL_ARB_compatibility"), glewGetExtension("GL_ARB_compatibility"));

}


#endif /* GL_ARB_compatibility */


#ifdef GL_ARB_compressed_texture_pixel_storage


static void _glewInfo_GL_ARB_compressed_texture_pixel_storage (void)

{

  glewPrintExt("GL_ARB_compressed_texture_pixel_storage", GLEW_ARB_compressed_texture_pixel_storage, glewIsSupported("GL_ARB_compressed_texture_pixel_storage"), glewGetExtension("GL_ARB_compressed_texture_pixel_storage"));

}


#endif /* GL_ARB_compressed_texture_pixel_storage */


#ifdef GL_ARB_compute_shader


static void _glewInfo_GL_ARB_compute_shader (void)

{

  glewPrintExt("GL_ARB_compute_shader", GLEW_ARB_compute_shader, glewIsSupported("GL_ARB_compute_shader"), glewGetExtension("GL_ARB_compute_shader"));


  glewInfoFunc("glDispatchCompute", glDispatchCompute == NULL);

  glewInfoFunc("glDispatchComputeIndirect", glDispatchComputeIndirect == NULL);

}


#endif /* GL_ARB_compute_shader */


#ifdef GL_ARB_compute_variable_group_size


static void _glewInfo_GL_ARB_compute_variable_group_size (void)

{

  glewPrintExt("GL_ARB_compute_variable_group_size", GLEW_ARB_compute_variable_group_size, glewIsSupported("GL_ARB_compute_variable_group_size"), glewGetExtension("GL_ARB_compute_variable_group_size"));


  glewInfoFunc("glDispatchComputeGroupSizeARB", glDispatchComputeGroupSizeARB == NULL);

}


#endif /* GL_ARB_compute_variable_group_size */


#ifdef GL_ARB_conservative_depth


static void _glewInfo_GL_ARB_conservative_depth (void)

{

  glewPrintExt("GL_ARB_conservative_depth", GLEW_ARB_conservative_depth, glewIsSupported("GL_ARB_conservative_depth"), glewGetExtension("GL_ARB_conservative_depth"));

}


#endif /* GL_ARB_conservative_depth */


#ifdef GL_ARB_copy_buffer


static void _glewInfo_GL_ARB_copy_buffer (void)

{

  glewPrintExt("GL_ARB_copy_buffer", GLEW_ARB_copy_buffer, glewIsSupported("GL_ARB_copy_buffer"), glewGetExtension("GL_ARB_copy_buffer"));


  glewInfoFunc("glCopyBufferSubData", glCopyBufferSubData == NULL);

}


#endif /* GL_ARB_copy_buffer */


#ifdef GL_ARB_copy_image


static void _glewInfo_GL_ARB_copy_image (void)

{

  glewPrintExt("GL_ARB_copy_image", GLEW_ARB_copy_image, glewIsSupported("GL_ARB_copy_image"), glewGetExtension("GL_ARB_copy_image"));


  glewInfoFunc("glCopyImageSubData", glCopyImageSubData == NULL);

}


#endif /* GL_ARB_copy_image */


#ifdef GL_ARB_debug_output


static void _glewInfo_GL_ARB_debug_output (void)

{

  glewPrintExt("GL_ARB_debug_output", GLEW_ARB_debug_output, glewIsSupported("GL_ARB_debug_output"), glewGetExtension("GL_ARB_debug_output"));


  glewInfoFunc("glDebugMessageCallbackARB", glDebugMessageCallbackARB == NULL);

  glewInfoFunc("glDebugMessageControlARB", glDebugMessageControlARB == NULL);

  glewInfoFunc("glDebugMessageInsertARB", glDebugMessageInsertARB == NULL);

  glewInfoFunc("glGetDebugMessageLogARB", glGetDebugMessageLogARB == NULL);

}


#endif /* GL_ARB_debug_output */


#ifdef GL_ARB_depth_buffer_float


static void _glewInfo_GL_ARB_depth_buffer_float (void)

{

  glewPrintExt("GL_ARB_depth_buffer_float", GLEW_ARB_depth_buffer_float, glewIsSupported("GL_ARB_depth_buffer_float"), glewGetExtension("GL_ARB_depth_buffer_float"));

}


#endif /* GL_ARB_depth_buffer_float */


#ifdef GL_ARB_depth_clamp


static void _glewInfo_GL_ARB_depth_clamp (void)

{

  glewPrintExt("GL_ARB_depth_clamp", GLEW_ARB_depth_clamp, glewIsSupported("GL_ARB_depth_clamp"), glewGetExtension("GL_ARB_depth_clamp"));

}


#endif /* GL_ARB_depth_clamp */


#ifdef GL_ARB_depth_texture


static void _glewInfo_GL_ARB_depth_texture (void)

{

  glewPrintExt("GL_ARB_depth_texture", GLEW_ARB_depth_texture, glewIsSupported("GL_ARB_depth_texture"), glewGetExtension("GL_ARB_depth_texture"));

}


#endif /* GL_ARB_depth_texture */


#ifdef GL_ARB_draw_buffers


static void _glewInfo_GL_ARB_draw_buffers (void)

{

  glewPrintExt("GL_ARB_draw_buffers", GLEW_ARB_draw_buffers, glewIsSupported("GL_ARB_draw_buffers"), glewGetExtension("GL_ARB_draw_buffers"));


  glewInfoFunc("glDrawBuffersARB", glDrawBuffersARB == NULL);

}


#endif /* GL_ARB_draw_buffers */


#ifdef GL_ARB_draw_buffers_blend


static void _glewInfo_GL_ARB_draw_buffers_blend (void)

{

  glewPrintExt("GL_ARB_draw_buffers_blend", GLEW_ARB_draw_buffers_blend, glewIsSupported("GL_ARB_draw_buffers_blend"), glewGetExtension("GL_ARB_draw_buffers_blend"));


  glewInfoFunc("glBlendEquationSeparateiARB", glBlendEquationSeparateiARB == NULL);

  glewInfoFunc("glBlendEquationiARB", glBlendEquationiARB == NULL);

  glewInfoFunc("glBlendFuncSeparateiARB", glBlendFuncSeparateiARB == NULL);

  glewInfoFunc("glBlendFunciARB", glBlendFunciARB == NULL);

}


#endif /* GL_ARB_draw_buffers_blend */


#ifdef GL_ARB_draw_elements_base_vertex


static void _glewInfo_GL_ARB_draw_elements_base_vertex (void)

{

  glewPrintExt("GL_ARB_draw_elements_base_vertex", GLEW_ARB_draw_elements_base_vertex, glewIsSupported("GL_ARB_draw_elements_base_vertex"), glewGetExtension("GL_ARB_draw_elements_base_vertex"));


  glewInfoFunc("glDrawElementsBaseVertex", glDrawElementsBaseVertex == NULL);

  glewInfoFunc("glDrawElementsInstancedBaseVertex", glDrawElementsInstancedBaseVertex == NULL);

  glewInfoFunc("glDrawRangeElementsBaseVertex", glDrawRangeElementsBaseVertex == NULL);

  glewInfoFunc("glMultiDrawElementsBaseVertex", glMultiDrawElementsBaseVertex == NULL);

}


#endif /* GL_ARB_draw_elements_base_vertex */


#ifdef GL_ARB_draw_indirect


static void _glewInfo_GL_ARB_draw_indirect (void)

{

  glewPrintExt("GL_ARB_draw_indirect", GLEW_ARB_draw_indirect, glewIsSupported("GL_ARB_draw_indirect"), glewGetExtension("GL_ARB_draw_indirect"));


  glewInfoFunc("glDrawArraysIndirect", glDrawArraysIndirect == NULL);

  glewInfoFunc("glDrawElementsIndirect", glDrawElementsIndirect == NULL);

}


#endif /* GL_ARB_draw_indirect */


#ifdef GL_ARB_draw_instanced


static void _glewInfo_GL_ARB_draw_instanced (void)

{

  glewPrintExt("GL_ARB_draw_instanced", GLEW_ARB_draw_instanced, glewIsSupported("GL_ARB_draw_instanced"), glewGetExtension("GL_ARB_draw_instanced"));

}


#endif /* GL_ARB_draw_instanced */


#ifdef GL_ARB_enhanced_layouts


static void _glewInfo_GL_ARB_enhanced_layouts (void)

{

  glewPrintExt("GL_ARB_enhanced_layouts", GLEW_ARB_enhanced_layouts, glewIsSupported("GL_ARB_enhanced_layouts"), glewGetExtension("GL_ARB_enhanced_layouts"));

}


#endif /* GL_ARB_enhanced_layouts */


#ifdef GL_ARB_explicit_attrib_location


static void _glewInfo_GL_ARB_explicit_attrib_location (void)

{

  glewPrintExt("GL_ARB_explicit_attrib_location", GLEW_ARB_explicit_attrib_location, glewIsSupported("GL_ARB_explicit_attrib_location"), glewGetExtension("GL_ARB_explicit_attrib_location"));

}


#endif /* GL_ARB_explicit_attrib_location */


#ifdef GL_ARB_explicit_uniform_location


static void _glewInfo_GL_ARB_explicit_uniform_location (void)

{

  glewPrintExt("GL_ARB_explicit_uniform_location", GLEW_ARB_explicit_uniform_location, glewIsSupported("GL_ARB_explicit_uniform_location"), glewGetExtension("GL_ARB_explicit_uniform_location"));

}


#endif /* GL_ARB_explicit_uniform_location */


#ifdef GL_ARB_fragment_coord_conventions


static void _glewInfo_GL_ARB_fragment_coord_conventions (void)

{

  glewPrintExt("GL_ARB_fragment_coord_conventions", GLEW_ARB_fragment_coord_conventions, glewIsSupported("GL_ARB_fragment_coord_conventions"), glewGetExtension("GL_ARB_fragment_coord_conventions"));

}


#endif /* GL_ARB_fragment_coord_conventions */


#ifdef GL_ARB_fragment_layer_viewport


static void _glewInfo_GL_ARB_fragment_layer_viewport (void)

{

  glewPrintExt("GL_ARB_fragment_layer_viewport", GLEW_ARB_fragment_layer_viewport, glewIsSupported("GL_ARB_fragment_layer_viewport"), glewGetExtension("GL_ARB_fragment_layer_viewport"));

}


#endif /* GL_ARB_fragment_layer_viewport */


#ifdef GL_ARB_fragment_program


static void _glewInfo_GL_ARB_fragment_program (void)

{

  glewPrintExt("GL_ARB_fragment_program", GLEW_ARB_fragment_program, glewIsSupported("GL_ARB_fragment_program"), glewGetExtension("GL_ARB_fragment_program"));

}


#endif /* GL_ARB_fragment_program */


#ifdef GL_ARB_fragment_program_shadow


static void _glewInfo_GL_ARB_fragment_program_shadow (void)

{

  glewPrintExt("GL_ARB_fragment_program_shadow", GLEW_ARB_fragment_program_shadow, glewIsSupported("GL_ARB_fragment_program_shadow"), glewGetExtension("GL_ARB_fragment_program_shadow"));

}


#endif /* GL_ARB_fragment_program_shadow */


#ifdef GL_ARB_fragment_shader


static void _glewInfo_GL_ARB_fragment_shader (void)

{

  glewPrintExt("GL_ARB_fragment_shader", GLEW_ARB_fragment_shader, glewIsSupported("GL_ARB_fragment_shader"), glewGetExtension("GL_ARB_fragment_shader"));

}


#endif /* GL_ARB_fragment_shader */


#ifdef GL_ARB_framebuffer_no_attachments


static void _glewInfo_GL_ARB_framebuffer_no_attachments (void)

{

  glewPrintExt("GL_ARB_framebuffer_no_attachments", GLEW_ARB_framebuffer_no_attachments, glewIsSupported("GL_ARB_framebuffer_no_attachments"), glewGetExtension("GL_ARB_framebuffer_no_attachments"));


  glewInfoFunc("glFramebufferParameteri", glFramebufferParameteri == NULL);

  glewInfoFunc("glGetFramebufferParameteriv", glGetFramebufferParameteriv == NULL);

  glewInfoFunc("glGetNamedFramebufferParameterivEXT", glGetNamedFramebufferParameterivEXT == NULL);

  glewInfoFunc("glNamedFramebufferParameteriEXT", glNamedFramebufferParameteriEXT == NULL);

}


#endif /* GL_ARB_framebuffer_no_attachments */


#ifdef GL_ARB_framebuffer_object


static void _glewInfo_GL_ARB_framebuffer_object (void)

{

  glewPrintExt("GL_ARB_framebuffer_object", GLEW_ARB_framebuffer_object, glewIsSupported("GL_ARB_framebuffer_object"), glewGetExtension("GL_ARB_framebuffer_object"));


  glewInfoFunc("glBindFramebuffer", glBindFramebuffer == NULL);

  glewInfoFunc("glBindRenderbuffer", glBindRenderbuffer == NULL);

  glewInfoFunc("glBlitFramebuffer", glBlitFramebuffer == NULL);

  glewInfoFunc("glCheckFramebufferStatus", glCheckFramebufferStatus == NULL);

  glewInfoFunc("glDeleteFramebuffers", glDeleteFramebuffers == NULL);

  glewInfoFunc("glDeleteRenderbuffers", glDeleteRenderbuffers == NULL);

  glewInfoFunc("glFramebufferRenderbuffer", glFramebufferRenderbuffer == NULL);

  glewInfoFunc("glFramebufferTexture1D", glFramebufferTexture1D == NULL);

  glewInfoFunc("glFramebufferTexture2D", glFramebufferTexture2D == NULL);

  glewInfoFunc("glFramebufferTexture3D", glFramebufferTexture3D == NULL);

  glewInfoFunc("glFramebufferTextureLayer", glFramebufferTextureLayer == NULL);

  glewInfoFunc("glGenFramebuffers", glGenFramebuffers == NULL);

  glewInfoFunc("glGenRenderbuffers", glGenRenderbuffers == NULL);

  glewInfoFunc("glGenerateMipmap", glGenerateMipmap == NULL);

  glewInfoFunc("glGetFramebufferAttachmentParameteriv", glGetFramebufferAttachmentParameteriv == NULL);

  glewInfoFunc("glGetRenderbufferParameteriv", glGetRenderbufferParameteriv == NULL);

  glewInfoFunc("glIsFramebuffer", glIsFramebuffer == NULL);

  glewInfoFunc("glIsRenderbuffer", glIsRenderbuffer == NULL);

  glewInfoFunc("glRenderbufferStorage", glRenderbufferStorage == NULL);

  glewInfoFunc("glRenderbufferStorageMultisample", glRenderbufferStorageMultisample == NULL);

}


#endif /* GL_ARB_framebuffer_object */


#ifdef GL_ARB_framebuffer_sRGB


static void _glewInfo_GL_ARB_framebuffer_sRGB (void)

{

  glewPrintExt("GL_ARB_framebuffer_sRGB", GLEW_ARB_framebuffer_sRGB, glewIsSupported("GL_ARB_framebuffer_sRGB"), glewGetExtension("GL_ARB_framebuffer_sRGB"));

}


#endif /* GL_ARB_framebuffer_sRGB */


#ifdef GL_ARB_geometry_shader4


static void _glewInfo_GL_ARB_geometry_shader4 (void)

{

  glewPrintExt("GL_ARB_geometry_shader4", GLEW_ARB_geometry_shader4, glewIsSupported("GL_ARB_geometry_shader4"), glewGetExtension("GL_ARB_geometry_shader4"));


  glewInfoFunc("glFramebufferTextureARB", glFramebufferTextureARB == NULL);

  glewInfoFunc("glFramebufferTextureFaceARB", glFramebufferTextureFaceARB == NULL);

  glewInfoFunc("glFramebufferTextureLayerARB", glFramebufferTextureLayerARB == NULL);

  glewInfoFunc("glProgramParameteriARB", glProgramParameteriARB == NULL);

}


#endif /* GL_ARB_geometry_shader4 */


#ifdef GL_ARB_get_program_binary


static void _glewInfo_GL_ARB_get_program_binary (void)

{

  glewPrintExt("GL_ARB_get_program_binary", GLEW_ARB_get_program_binary, glewIsSupported("GL_ARB_get_program_binary"), glewGetExtension("GL_ARB_get_program_binary"));


  glewInfoFunc("glGetProgramBinary", glGetProgramBinary == NULL);

  glewInfoFunc("glProgramBinary", glProgramBinary == NULL);

  glewInfoFunc("glProgramParameteri", glProgramParameteri == NULL);

}


#endif /* GL_ARB_get_program_binary */


#ifdef GL_ARB_gpu_shader5


static void _glewInfo_GL_ARB_gpu_shader5 (void)

{

  glewPrintExt("GL_ARB_gpu_shader5", GLEW_ARB_gpu_shader5, glewIsSupported("GL_ARB_gpu_shader5"), glewGetExtension("GL_ARB_gpu_shader5"));

}


#endif /* GL_ARB_gpu_shader5 */


#ifdef GL_ARB_gpu_shader_fp64


static void _glewInfo_GL_ARB_gpu_shader_fp64 (void)

{

  glewPrintExt("GL_ARB_gpu_shader_fp64", GLEW_ARB_gpu_shader_fp64, glewIsSupported("GL_ARB_gpu_shader_fp64"), glewGetExtension("GL_ARB_gpu_shader_fp64"));


  glewInfoFunc("glGetUniformdv", glGetUniformdv == NULL);

  glewInfoFunc("glUniform1d", glUniform1d == NULL);

  glewInfoFunc("glUniform1dv", glUniform1dv == NULL);

  glewInfoFunc("glUniform2d", glUniform2d == NULL);

  glewInfoFunc("glUniform2dv", glUniform2dv == NULL);

  glewInfoFunc("glUniform3d", glUniform3d == NULL);

  glewInfoFunc("glUniform3dv", glUniform3dv == NULL);

  glewInfoFunc("glUniform4d", glUniform4d == NULL);

  glewInfoFunc("glUniform4dv", glUniform4dv == NULL);

  glewInfoFunc("glUniformMatrix2dv", glUniformMatrix2dv == NULL);

  glewInfoFunc("glUniformMatrix2x3dv", glUniformMatrix2x3dv == NULL);

  glewInfoFunc("glUniformMatrix2x4dv", glUniformMatrix2x4dv == NULL);

  glewInfoFunc("glUniformMatrix3dv", glUniformMatrix3dv == NULL);

  glewInfoFunc("glUniformMatrix3x2dv", glUniformMatrix3x2dv == NULL);

  glewInfoFunc("glUniformMatrix3x4dv", glUniformMatrix3x4dv == NULL);

  glewInfoFunc("glUniformMatrix4dv", glUniformMatrix4dv == NULL);

  glewInfoFunc("glUniformMatrix4x2dv", glUniformMatrix4x2dv == NULL);

  glewInfoFunc("glUniformMatrix4x3dv", glUniformMatrix4x3dv == NULL);

}


#endif /* GL_ARB_gpu_shader_fp64 */


#ifdef GL_ARB_half_float_pixel


static void _glewInfo_GL_ARB_half_float_pixel (void)

{

  glewPrintExt("GL_ARB_half_float_pixel", GLEW_ARB_half_float_pixel, glewIsSupported("GL_ARB_half_float_pixel"), glewGetExtension("GL_ARB_half_float_pixel"));

}


#endif /* GL_ARB_half_float_pixel */


#ifdef GL_ARB_half_float_vertex


static void _glewInfo_GL_ARB_half_float_vertex (void)

{

  glewPrintExt("GL_ARB_half_float_vertex", GLEW_ARB_half_float_vertex, glewIsSupported("GL_ARB_half_float_vertex"), glewGetExtension("GL_ARB_half_float_vertex"));

}


#endif /* GL_ARB_half_float_vertex */


#ifdef GL_ARB_imaging


static void _glewInfo_GL_ARB_imaging (void)

{

  glewPrintExt("GL_ARB_imaging", GLEW_ARB_imaging, glewIsSupported("GL_ARB_imaging"), glewGetExtension("GL_ARB_imaging"));


  glewInfoFunc("glBlendEquation", glBlendEquation == NULL);

  glewInfoFunc("glColorSubTable", glColorSubTable == NULL);

  glewInfoFunc("glColorTable", glColorTable == NULL);

  glewInfoFunc("glColorTableParameterfv", glColorTableParameterfv == NULL);

  glewInfoFunc("glColorTableParameteriv", glColorTableParameteriv == NULL);

  glewInfoFunc("glConvolutionFilter1D", glConvolutionFilter1D == NULL);

  glewInfoFunc("glConvolutionFilter2D", glConvolutionFilter2D == NULL);

  glewInfoFunc("glConvolutionParameterf", glConvolutionParameterf == NULL);

  glewInfoFunc("glConvolutionParameterfv", glConvolutionParameterfv == NULL);

  glewInfoFunc("glConvolutionParameteri", glConvolutionParameteri == NULL);

  glewInfoFunc("glConvolutionParameteriv", glConvolutionParameteriv == NULL);

  glewInfoFunc("glCopyColorSubTable", glCopyColorSubTable == NULL);

  glewInfoFunc("glCopyColorTable", glCopyColorTable == NULL);

  glewInfoFunc("glCopyConvolutionFilter1D", glCopyConvolutionFilter1D == NULL);

  glewInfoFunc("glCopyConvolutionFilter2D", glCopyConvolutionFilter2D == NULL);

  glewInfoFunc("glGetColorTable", glGetColorTable == NULL);

  glewInfoFunc("glGetColorTableParameterfv", glGetColorTableParameterfv == NULL);

  glewInfoFunc("glGetColorTableParameteriv", glGetColorTableParameteriv == NULL);

  glewInfoFunc("glGetConvolutionFilter", glGetConvolutionFilter == NULL);

  glewInfoFunc("glGetConvolutionParameterfv", glGetConvolutionParameterfv == NULL);

  glewInfoFunc("glGetConvolutionParameteriv", glGetConvolutionParameteriv == NULL);

  glewInfoFunc("glGetHistogram", glGetHistogram == NULL);

  glewInfoFunc("glGetHistogramParameterfv", glGetHistogramParameterfv == NULL);

  glewInfoFunc("glGetHistogramParameteriv", glGetHistogramParameteriv == NULL);

  glewInfoFunc("glGetMinmax", glGetMinmax == NULL);

  glewInfoFunc("glGetMinmaxParameterfv", glGetMinmaxParameterfv == NULL);

  glewInfoFunc("glGetMinmaxParameteriv", glGetMinmaxParameteriv == NULL);

  glewInfoFunc("glGetSeparableFilter", glGetSeparableFilter == NULL);

  glewInfoFunc("glHistogram", glHistogram == NULL);

  glewInfoFunc("glMinmax", glMinmax == NULL);

  glewInfoFunc("glResetHistogram", glResetHistogram == NULL);

  glewInfoFunc("glResetMinmax", glResetMinmax == NULL);

  glewInfoFunc("glSeparableFilter2D", glSeparableFilter2D == NULL);

}


#endif /* GL_ARB_imaging */


#ifdef GL_ARB_indirect_parameters


static void _glewInfo_GL_ARB_indirect_parameters (void)

{

  glewPrintExt("GL_ARB_indirect_parameters", GLEW_ARB_indirect_parameters, glewIsSupported("GL_ARB_indirect_parameters"), glewGetExtension("GL_ARB_indirect_parameters"));


  glewInfoFunc("glMultiDrawArraysIndirectCountARB", glMultiDrawArraysIndirectCountARB == NULL);

  glewInfoFunc("glMultiDrawElementsIndirectCountARB", glMultiDrawElementsIndirectCountARB == NULL);

}


#endif /* GL_ARB_indirect_parameters */


#ifdef GL_ARB_instanced_arrays


static void _glewInfo_GL_ARB_instanced_arrays (void)

{

  glewPrintExt("GL_ARB_instanced_arrays", GLEW_ARB_instanced_arrays, glewIsSupported("GL_ARB_instanced_arrays"), glewGetExtension("GL_ARB_instanced_arrays"));


  glewInfoFunc("glDrawArraysInstancedARB", glDrawArraysInstancedARB == NULL);

  glewInfoFunc("glDrawElementsInstancedARB", glDrawElementsInstancedARB == NULL);

  glewInfoFunc("glVertexAttribDivisorARB", glVertexAttribDivisorARB == NULL);

}


#endif /* GL_ARB_instanced_arrays */


#ifdef GL_ARB_internalformat_query


static void _glewInfo_GL_ARB_internalformat_query (void)

{

  glewPrintExt("GL_ARB_internalformat_query", GLEW_ARB_internalformat_query, glewIsSupported("GL_ARB_internalformat_query"), glewGetExtension("GL_ARB_internalformat_query"));


  glewInfoFunc("glGetInternalformativ", glGetInternalformativ == NULL);

}


#endif /* GL_ARB_internalformat_query */


#ifdef GL_ARB_internalformat_query2


static void _glewInfo_GL_ARB_internalformat_query2 (void)

{

  glewPrintExt("GL_ARB_internalformat_query2", GLEW_ARB_internalformat_query2, glewIsSupported("GL_ARB_internalformat_query2"), glewGetExtension("GL_ARB_internalformat_query2"));


  glewInfoFunc("glGetInternalformati64v", glGetInternalformati64v == NULL);

}


#endif /* GL_ARB_internalformat_query2 */


#ifdef GL_ARB_invalidate_subdata


static void _glewInfo_GL_ARB_invalidate_subdata (void)

{

  glewPrintExt("GL_ARB_invalidate_subdata", GLEW_ARB_invalidate_subdata, glewIsSupported("GL_ARB_invalidate_subdata"), glewGetExtension("GL_ARB_invalidate_subdata"));


  glewInfoFunc("glInvalidateBufferData", glInvalidateBufferData == NULL);

  glewInfoFunc("glInvalidateBufferSubData", glInvalidateBufferSubData == NULL);

  glewInfoFunc("glInvalidateFramebuffer", glInvalidateFramebuffer == NULL);

  glewInfoFunc("glInvalidateSubFramebuffer", glInvalidateSubFramebuffer == NULL);

  glewInfoFunc("glInvalidateTexImage", glInvalidateTexImage == NULL);

  glewInfoFunc("glInvalidateTexSubImage", glInvalidateTexSubImage == NULL);

}


#endif /* GL_ARB_invalidate_subdata */


#ifdef GL_ARB_map_buffer_alignment


static void _glewInfo_GL_ARB_map_buffer_alignment (void)

{

  glewPrintExt("GL_ARB_map_buffer_alignment", GLEW_ARB_map_buffer_alignment, glewIsSupported("GL_ARB_map_buffer_alignment"), glewGetExtension("GL_ARB_map_buffer_alignment"));

}


#endif /* GL_ARB_map_buffer_alignment */


#ifdef GL_ARB_map_buffer_range


static void _glewInfo_GL_ARB_map_buffer_range (void)

{

  glewPrintExt("GL_ARB_map_buffer_range", GLEW_ARB_map_buffer_range, glewIsSupported("GL_ARB_map_buffer_range"), glewGetExtension("GL_ARB_map_buffer_range"));


  glewInfoFunc("glFlushMappedBufferRange", glFlushMappedBufferRange == NULL);

  glewInfoFunc("glMapBufferRange", glMapBufferRange == NULL);

}


#endif /* GL_ARB_map_buffer_range */


#ifdef GL_ARB_matrix_palette


static void _glewInfo_GL_ARB_matrix_palette (void)

{

  glewPrintExt("GL_ARB_matrix_palette", GLEW_ARB_matrix_palette, glewIsSupported("GL_ARB_matrix_palette"), glewGetExtension("GL_ARB_matrix_palette"));


  glewInfoFunc("glCurrentPaletteMatrixARB", glCurrentPaletteMatrixARB == NULL);

  glewInfoFunc("glMatrixIndexPointerARB", glMatrixIndexPointerARB == NULL);

  glewInfoFunc("glMatrixIndexubvARB", glMatrixIndexubvARB == NULL);

  glewInfoFunc("glMatrixIndexuivARB", glMatrixIndexuivARB == NULL);

  glewInfoFunc("glMatrixIndexusvARB", glMatrixIndexusvARB == NULL);

}


#endif /* GL_ARB_matrix_palette */


#ifdef GL_ARB_multi_bind


static void _glewInfo_GL_ARB_multi_bind (void)

{

  glewPrintExt("GL_ARB_multi_bind", GLEW_ARB_multi_bind, glewIsSupported("GL_ARB_multi_bind"), glewGetExtension("GL_ARB_multi_bind"));


  glewInfoFunc("glBindBuffersBase", glBindBuffersBase == NULL);

  glewInfoFunc("glBindBuffersRange", glBindBuffersRange == NULL);

  glewInfoFunc("glBindImageTextures", glBindImageTextures == NULL);

  glewInfoFunc("glBindSamplers", glBindSamplers == NULL);

  glewInfoFunc("glBindTextures", glBindTextures == NULL);

  glewInfoFunc("glBindVertexBuffers", glBindVertexBuffers == NULL);

}


#endif /* GL_ARB_multi_bind */


#ifdef GL_ARB_multi_draw_indirect


static void _glewInfo_GL_ARB_multi_draw_indirect (void)

{

  glewPrintExt("GL_ARB_multi_draw_indirect", GLEW_ARB_multi_draw_indirect, glewIsSupported("GL_ARB_multi_draw_indirect"), glewGetExtension("GL_ARB_multi_draw_indirect"));


  glewInfoFunc("glMultiDrawArraysIndirect", glMultiDrawArraysIndirect == NULL);

  glewInfoFunc("glMultiDrawElementsIndirect", glMultiDrawElementsIndirect == NULL);

}


#endif /* GL_ARB_multi_draw_indirect */


#ifdef GL_ARB_multisample


static void _glewInfo_GL_ARB_multisample (void)

{

  glewPrintExt("GL_ARB_multisample", GLEW_ARB_multisample, glewIsSupported("GL_ARB_multisample"), glewGetExtension("GL_ARB_multisample"));


  glewInfoFunc("glSampleCoverageARB", glSampleCoverageARB == NULL);

}


#endif /* GL_ARB_multisample */


#ifdef GL_ARB_multitexture


static void _glewInfo_GL_ARB_multitexture (void)

{

  glewPrintExt("GL_ARB_multitexture", GLEW_ARB_multitexture, glewIsSupported("GL_ARB_multitexture"), glewGetExtension("GL_ARB_multitexture"));


  glewInfoFunc("glActiveTextureARB", glActiveTextureARB == NULL);

  glewInfoFunc("glClientActiveTextureARB", glClientActiveTextureARB == NULL);

  glewInfoFunc("glMultiTexCoord1dARB", glMultiTexCoord1dARB == NULL);

  glewInfoFunc("glMultiTexCoord1dvARB", glMultiTexCoord1dvARB == NULL);

  glewInfoFunc("glMultiTexCoord1fARB", glMultiTexCoord1fARB == NULL);

  glewInfoFunc("glMultiTexCoord1fvARB", glMultiTexCoord1fvARB == NULL);

  glewInfoFunc("glMultiTexCoord1iARB", glMultiTexCoord1iARB == NULL);

  glewInfoFunc("glMultiTexCoord1ivARB", glMultiTexCoord1ivARB == NULL);

  glewInfoFunc("glMultiTexCoord1sARB", glMultiTexCoord1sARB == NULL);

  glewInfoFunc("glMultiTexCoord1svARB", glMultiTexCoord1svARB == NULL);

  glewInfoFunc("glMultiTexCoord2dARB", glMultiTexCoord2dARB == NULL);

  glewInfoFunc("glMultiTexCoord2dvARB", glMultiTexCoord2dvARB == NULL);

  glewInfoFunc("glMultiTexCoord2fARB", glMultiTexCoord2fARB == NULL);

  glewInfoFunc("glMultiTexCoord2fvARB", glMultiTexCoord2fvARB == NULL);

  glewInfoFunc("glMultiTexCoord2iARB", glMultiTexCoord2iARB == NULL);

  glewInfoFunc("glMultiTexCoord2ivARB", glMultiTexCoord2ivARB == NULL);

  glewInfoFunc("glMultiTexCoord2sARB", glMultiTexCoord2sARB == NULL);

  glewInfoFunc("glMultiTexCoord2svARB", glMultiTexCoord2svARB == NULL);

  glewInfoFunc("glMultiTexCoord3dARB", glMultiTexCoord3dARB == NULL);

  glewInfoFunc("glMultiTexCoord3dvARB", glMultiTexCoord3dvARB == NULL);

  glewInfoFunc("glMultiTexCoord3fARB", glMultiTexCoord3fARB == NULL);

  glewInfoFunc("glMultiTexCoord3fvARB", glMultiTexCoord3fvARB == NULL);

  glewInfoFunc("glMultiTexCoord3iARB", glMultiTexCoord3iARB == NULL);

  glewInfoFunc("glMultiTexCoord3ivARB", glMultiTexCoord3ivARB == NULL);

  glewInfoFunc("glMultiTexCoord3sARB", glMultiTexCoord3sARB == NULL);

  glewInfoFunc("glMultiTexCoord3svARB", glMultiTexCoord3svARB == NULL);

  glewInfoFunc("glMultiTexCoord4dARB", glMultiTexCoord4dARB == NULL);

  glewInfoFunc("glMultiTexCoord4dvARB", glMultiTexCoord4dvARB == NULL);

  glewInfoFunc("glMultiTexCoord4fARB", glMultiTexCoord4fARB == NULL);

  glewInfoFunc("glMultiTexCoord4fvARB", glMultiTexCoord4fvARB == NULL);

  glewInfoFunc("glMultiTexCoord4iARB", glMultiTexCoord4iARB == NULL);

  glewInfoFunc("glMultiTexCoord4ivARB", glMultiTexCoord4ivARB == NULL);

  glewInfoFunc("glMultiTexCoord4sARB", glMultiTexCoord4sARB == NULL);

  glewInfoFunc("glMultiTexCoord4svARB", glMultiTexCoord4svARB == NULL);

}


#endif /* GL_ARB_multitexture */


#ifdef GL_ARB_occlusion_query


static void _glewInfo_GL_ARB_occlusion_query (void)

{

  glewPrintExt("GL_ARB_occlusion_query", GLEW_ARB_occlusion_query, glewIsSupported("GL_ARB_occlusion_query"), glewGetExtension("GL_ARB_occlusion_query"));


  glewInfoFunc("glBeginQueryARB", glBeginQueryARB == NULL);

  glewInfoFunc("glDeleteQueriesARB", glDeleteQueriesARB == NULL);

  glewInfoFunc("glEndQueryARB", glEndQueryARB == NULL);

  glewInfoFunc("glGenQueriesARB", glGenQueriesARB == NULL);

  glewInfoFunc("glGetQueryObjectivARB", glGetQueryObjectivARB == NULL);

  glewInfoFunc("glGetQueryObjectuivARB", glGetQueryObjectuivARB == NULL);

  glewInfoFunc("glGetQueryivARB", glGetQueryivARB == NULL);

  glewInfoFunc("glIsQueryARB", glIsQueryARB == NULL);

}


#endif /* GL_ARB_occlusion_query */


#ifdef GL_ARB_occlusion_query2


static void _glewInfo_GL_ARB_occlusion_query2 (void)

{

  glewPrintExt("GL_ARB_occlusion_query2", GLEW_ARB_occlusion_query2, glewIsSupported("GL_ARB_occlusion_query2"), glewGetExtension("GL_ARB_occlusion_query2"));

}


#endif /* GL_ARB_occlusion_query2 */


#ifdef GL_ARB_pixel_buffer_object


static void _glewInfo_GL_ARB_pixel_buffer_object (void)

{

  glewPrintExt("GL_ARB_pixel_buffer_object", GLEW_ARB_pixel_buffer_object, glewIsSupported("GL_ARB_pixel_buffer_object"), glewGetExtension("GL_ARB_pixel_buffer_object"));

}


#endif /* GL_ARB_pixel_buffer_object */


#ifdef GL_ARB_point_parameters


static void _glewInfo_GL_ARB_point_parameters (void)

{

  glewPrintExt("GL_ARB_point_parameters", GLEW_ARB_point_parameters, glewIsSupported("GL_ARB_point_parameters"), glewGetExtension("GL_ARB_point_parameters"));


  glewInfoFunc("glPointParameterfARB", glPointParameterfARB == NULL);

  glewInfoFunc("glPointParameterfvARB", glPointParameterfvARB == NULL);

}


#endif /* GL_ARB_point_parameters */


#ifdef GL_ARB_point_sprite


static void _glewInfo_GL_ARB_point_sprite (void)

{

  glewPrintExt("GL_ARB_point_sprite", GLEW_ARB_point_sprite, glewIsSupported("GL_ARB_point_sprite"), glewGetExtension("GL_ARB_point_sprite"));

}


#endif /* GL_ARB_point_sprite */


#ifdef GL_ARB_program_interface_query


static void _glewInfo_GL_ARB_program_interface_query (void)

{

  glewPrintExt("GL_ARB_program_interface_query", GLEW_ARB_program_interface_query, glewIsSupported("GL_ARB_program_interface_query"), glewGetExtension("GL_ARB_program_interface_query"));


  glewInfoFunc("glGetProgramInterfaceiv", glGetProgramInterfaceiv == NULL);

  glewInfoFunc("glGetProgramResourceIndex", glGetProgramResourceIndex == NULL);

  glewInfoFunc("glGetProgramResourceLocation", glGetProgramResourceLocation == NULL);

  glewInfoFunc("glGetProgramResourceLocationIndex", glGetProgramResourceLocationIndex == NULL);

  glewInfoFunc("glGetProgramResourceName", glGetProgramResourceName == NULL);

  glewInfoFunc("glGetProgramResourceiv", glGetProgramResourceiv == NULL);

}


#endif /* GL_ARB_program_interface_query */


#ifdef GL_ARB_provoking_vertex


static void _glewInfo_GL_ARB_provoking_vertex (void)

{

  glewPrintExt("GL_ARB_provoking_vertex", GLEW_ARB_provoking_vertex, glewIsSupported("GL_ARB_provoking_vertex"), glewGetExtension("GL_ARB_provoking_vertex"));


  glewInfoFunc("glProvokingVertex", glProvokingVertex == NULL);

}


#endif /* GL_ARB_provoking_vertex */


#ifdef GL_ARB_query_buffer_object


static void _glewInfo_GL_ARB_query_buffer_object (void)

{

  glewPrintExt("GL_ARB_query_buffer_object", GLEW_ARB_query_buffer_object, glewIsSupported("GL_ARB_query_buffer_object"), glewGetExtension("GL_ARB_query_buffer_object"));

}


#endif /* GL_ARB_query_buffer_object */


#ifdef GL_ARB_robust_buffer_access_behavior


static void _glewInfo_GL_ARB_robust_buffer_access_behavior (void)

{

  glewPrintExt("GL_ARB_robust_buffer_access_behavior", GLEW_ARB_robust_buffer_access_behavior, glewIsSupported("GL_ARB_robust_buffer_access_behavior"), glewGetExtension("GL_ARB_robust_buffer_access_behavior"));

}


#endif /* GL_ARB_robust_buffer_access_behavior */


#ifdef GL_ARB_robustness


static void _glewInfo_GL_ARB_robustness (void)

{

  glewPrintExt("GL_ARB_robustness", GLEW_ARB_robustness, glewIsSupported("GL_ARB_robustness"), glewGetExtension("GL_ARB_robustness"));


  glewInfoFunc("glGetGraphicsResetStatusARB", glGetGraphicsResetStatusARB == NULL);

  glewInfoFunc("glGetnColorTableARB", glGetnColorTableARB == NULL);

  glewInfoFunc("glGetnCompressedTexImageARB", glGetnCompressedTexImageARB == NULL);

  glewInfoFunc("glGetnConvolutionFilterARB", glGetnConvolutionFilterARB == NULL);

  glewInfoFunc("glGetnHistogramARB", glGetnHistogramARB == NULL);

  glewInfoFunc("glGetnMapdvARB", glGetnMapdvARB == NULL);

  glewInfoFunc("glGetnMapfvARB", glGetnMapfvARB == NULL);

  glewInfoFunc("glGetnMapivARB", glGetnMapivARB == NULL);

  glewInfoFunc("glGetnMinmaxARB", glGetnMinmaxARB == NULL);

  glewInfoFunc("glGetnPixelMapfvARB", glGetnPixelMapfvARB == NULL);

  glewInfoFunc("glGetnPixelMapuivARB", glGetnPixelMapuivARB == NULL);

  glewInfoFunc("glGetnPixelMapusvARB", glGetnPixelMapusvARB == NULL);

  glewInfoFunc("glGetnPolygonStippleARB", glGetnPolygonStippleARB == NULL);

  glewInfoFunc("glGetnSeparableFilterARB", glGetnSeparableFilterARB == NULL);

  glewInfoFunc("glGetnTexImageARB", glGetnTexImageARB == NULL);

  glewInfoFunc("glGetnUniformdvARB", glGetnUniformdvARB == NULL);

  glewInfoFunc("glGetnUniformfvARB", glGetnUniformfvARB == NULL);

  glewInfoFunc("glGetnUniformivARB", glGetnUniformivARB == NULL);

  glewInfoFunc("glGetnUniformuivARB", glGetnUniformuivARB == NULL);

  glewInfoFunc("glReadnPixelsARB", glReadnPixelsARB == NULL);

}


#endif /* GL_ARB_robustness */


#ifdef GL_ARB_robustness_application_isolation


static void _glewInfo_GL_ARB_robustness_application_isolation (void)

{

  glewPrintExt("GL_ARB_robustness_application_isolation", GLEW_ARB_robustness_application_isolation, glewIsSupported("GL_ARB_robustness_application_isolation"), glewGetExtension("GL_ARB_robustness_application_isolation"));

}


#endif /* GL_ARB_robustness_application_isolation */


#ifdef GL_ARB_robustness_share_group_isolation


static void _glewInfo_GL_ARB_robustness_share_group_isolation (void)

{

  glewPrintExt("GL_ARB_robustness_share_group_isolation", GLEW_ARB_robustness_share_group_isolation, glewIsSupported("GL_ARB_robustness_share_group_isolation"), glewGetExtension("GL_ARB_robustness_share_group_isolation"));

}


#endif /* GL_ARB_robustness_share_group_isolation */


#ifdef GL_ARB_sample_shading


static void _glewInfo_GL_ARB_sample_shading (void)

{

  glewPrintExt("GL_ARB_sample_shading", GLEW_ARB_sample_shading, glewIsSupported("GL_ARB_sample_shading"), glewGetExtension("GL_ARB_sample_shading"));


  glewInfoFunc("glMinSampleShadingARB", glMinSampleShadingARB == NULL);

}


#endif /* GL_ARB_sample_shading */


#ifdef GL_ARB_sampler_objects


static void _glewInfo_GL_ARB_sampler_objects (void)

{

  glewPrintExt("GL_ARB_sampler_objects", GLEW_ARB_sampler_objects, glewIsSupported("GL_ARB_sampler_objects"), glewGetExtension("GL_ARB_sampler_objects"));


  glewInfoFunc("glBindSampler", glBindSampler == NULL);

  glewInfoFunc("glDeleteSamplers", glDeleteSamplers == NULL);

  glewInfoFunc("glGenSamplers", glGenSamplers == NULL);

  glewInfoFunc("glGetSamplerParameterIiv", glGetSamplerParameterIiv == NULL);

  glewInfoFunc("glGetSamplerParameterIuiv", glGetSamplerParameterIuiv == NULL);

  glewInfoFunc("glGetSamplerParameterfv", glGetSamplerParameterfv == NULL);

  glewInfoFunc("glGetSamplerParameteriv", glGetSamplerParameteriv == NULL);

  glewInfoFunc("glIsSampler", glIsSampler == NULL);

  glewInfoFunc("glSamplerParameterIiv", glSamplerParameterIiv == NULL);

  glewInfoFunc("glSamplerParameterIuiv", glSamplerParameterIuiv == NULL);

  glewInfoFunc("glSamplerParameterf", glSamplerParameterf == NULL);

  glewInfoFunc("glSamplerParameterfv", glSamplerParameterfv == NULL);

  glewInfoFunc("glSamplerParameteri", glSamplerParameteri == NULL);

  glewInfoFunc("glSamplerParameteriv", glSamplerParameteriv == NULL);

}


#endif /* GL_ARB_sampler_objects */


#ifdef GL_ARB_seamless_cube_map


static void _glewInfo_GL_ARB_seamless_cube_map (void)

{

  glewPrintExt("GL_ARB_seamless_cube_map", GLEW_ARB_seamless_cube_map, glewIsSupported("GL_ARB_seamless_cube_map"), glewGetExtension("GL_ARB_seamless_cube_map"));

}


#endif /* GL_ARB_seamless_cube_map */


#ifdef GL_ARB_seamless_cubemap_per_texture


static void _glewInfo_GL_ARB_seamless_cubemap_per_texture (void)

{

  glewPrintExt("GL_ARB_seamless_cubemap_per_texture", GLEW_ARB_seamless_cubemap_per_texture, glewIsSupported("GL_ARB_seamless_cubemap_per_texture"), glewGetExtension("GL_ARB_seamless_cubemap_per_texture"));

}


#endif /* GL_ARB_seamless_cubemap_per_texture */


#ifdef GL_ARB_separate_shader_objects


static void _glewInfo_GL_ARB_separate_shader_objects (void)

{

  glewPrintExt("GL_ARB_separate_shader_objects", GLEW_ARB_separate_shader_objects, glewIsSupported("GL_ARB_separate_shader_objects"), glewGetExtension("GL_ARB_separate_shader_objects"));


  glewInfoFunc("glActiveShaderProgram", glActiveShaderProgram == NULL);

  glewInfoFunc("glBindProgramPipeline", glBindProgramPipeline == NULL);

  glewInfoFunc("glCreateShaderProgramv", glCreateShaderProgramv == NULL);

  glewInfoFunc("glDeleteProgramPipelines", glDeleteProgramPipelines == NULL);

  glewInfoFunc("glGenProgramPipelines", glGenProgramPipelines == NULL);

  glewInfoFunc("glGetProgramPipelineInfoLog", glGetProgramPipelineInfoLog == NULL);

  glewInfoFunc("glGetProgramPipelineiv", glGetProgramPipelineiv == NULL);

  glewInfoFunc("glIsProgramPipeline", glIsProgramPipeline == NULL);

  glewInfoFunc("glProgramUniform1d", glProgramUniform1d == NULL);

  glewInfoFunc("glProgramUniform1dv", glProgramUniform1dv == NULL);

  glewInfoFunc("glProgramUniform1f", glProgramUniform1f == NULL);

  glewInfoFunc("glProgramUniform1fv", glProgramUniform1fv == NULL);

  glewInfoFunc("glProgramUniform1i", glProgramUniform1i == NULL);

  glewInfoFunc("glProgramUniform1iv", glProgramUniform1iv == NULL);

  glewInfoFunc("glProgramUniform1ui", glProgramUniform1ui == NULL);

  glewInfoFunc("glProgramUniform1uiv", glProgramUniform1uiv == NULL);

  glewInfoFunc("glProgramUniform2d", glProgramUniform2d == NULL);

  glewInfoFunc("glProgramUniform2dv", glProgramUniform2dv == NULL);

  glewInfoFunc("glProgramUniform2f", glProgramUniform2f == NULL);

  glewInfoFunc("glProgramUniform2fv", glProgramUniform2fv == NULL);

  glewInfoFunc("glProgramUniform2i", glProgramUniform2i == NULL);

  glewInfoFunc("glProgramUniform2iv", glProgramUniform2iv == NULL);

  glewInfoFunc("glProgramUniform2ui", glProgramUniform2ui == NULL);

  glewInfoFunc("glProgramUniform2uiv", glProgramUniform2uiv == NULL);

  glewInfoFunc("glProgramUniform3d", glProgramUniform3d == NULL);

  glewInfoFunc("glProgramUniform3dv", glProgramUniform3dv == NULL);

  glewInfoFunc("glProgramUniform3f", glProgramUniform3f == NULL);

  glewInfoFunc("glProgramUniform3fv", glProgramUniform3fv == NULL);

  glewInfoFunc("glProgramUniform3i", glProgramUniform3i == NULL);

  glewInfoFunc("glProgramUniform3iv", glProgramUniform3iv == NULL);

  glewInfoFunc("glProgramUniform3ui", glProgramUniform3ui == NULL);

  glewInfoFunc("glProgramUniform3uiv", glProgramUniform3uiv == NULL);

  glewInfoFunc("glProgramUniform4d", glProgramUniform4d == NULL);

  glewInfoFunc("glProgramUniform4dv", glProgramUniform4dv == NULL);

  glewInfoFunc("glProgramUniform4f", glProgramUniform4f == NULL);

  glewInfoFunc("glProgramUniform4fv", glProgramUniform4fv == NULL);

  glewInfoFunc("glProgramUniform4i", glProgramUniform4i == NULL);

  glewInfoFunc("glProgramUniform4iv", glProgramUniform4iv == NULL);

  glewInfoFunc("glProgramUniform4ui", glProgramUniform4ui == NULL);

  glewInfoFunc("glProgramUniform4uiv", glProgramUniform4uiv == NULL);

  glewInfoFunc("glProgramUniformMatrix2dv", glProgramUniformMatrix2dv == NULL);

  glewInfoFunc("glProgramUniformMatrix2fv", glProgramUniformMatrix2fv == NULL);

  glewInfoFunc("glProgramUniformMatrix2x3dv", glProgramUniformMatrix2x3dv == NULL);

  glewInfoFunc("glProgramUniformMatrix2x3fv", glProgramUniformMatrix2x3fv == NULL);

  glewInfoFunc("glProgramUniformMatrix2x4dv", glProgramUniformMatrix2x4dv == NULL);

  glewInfoFunc("glProgramUniformMatrix2x4fv", glProgramUniformMatrix2x4fv == NULL);

  glewInfoFunc("glProgramUniformMatrix3dv", glProgramUniformMatrix3dv == NULL);

  glewInfoFunc("glProgramUniformMatrix3fv", glProgramUniformMatrix3fv == NULL);

  glewInfoFunc("glProgramUniformMatrix3x2dv", glProgramUniformMatrix3x2dv == NULL);

  glewInfoFunc("glProgramUniformMatrix3x2fv", glProgramUniformMatrix3x2fv == NULL);

  glewInfoFunc("glProgramUniformMatrix3x4dv", glProgramUniformMatrix3x4dv == NULL);

  glewInfoFunc("glProgramUniformMatrix3x4fv", glProgramUniformMatrix3x4fv == NULL);

  glewInfoFunc("glProgramUniformMatrix4dv", glProgramUniformMatrix4dv == NULL);

  glewInfoFunc("glProgramUniformMatrix4fv", glProgramUniformMatrix4fv == NULL);

  glewInfoFunc("glProgramUniformMatrix4x2dv", glProgramUniformMatrix4x2dv == NULL);

  glewInfoFunc("glProgramUniformMatrix4x2fv", glProgramUniformMatrix4x2fv == NULL);

  glewInfoFunc("glProgramUniformMatrix4x3dv", glProgramUniformMatrix4x3dv == NULL);

  glewInfoFunc("glProgramUniformMatrix4x3fv", glProgramUniformMatrix4x3fv == NULL);

  glewInfoFunc("glUseProgramStages", glUseProgramStages == NULL);

  glewInfoFunc("glValidateProgramPipeline", glValidateProgramPipeline == NULL);

}


#endif /* GL_ARB_separate_shader_objects */


#ifdef GL_ARB_shader_atomic_counters


static void _glewInfo_GL_ARB_shader_atomic_counters (void)

{

  glewPrintExt("GL_ARB_shader_atomic_counters", GLEW_ARB_shader_atomic_counters, glewIsSupported("GL_ARB_shader_atomic_counters"), glewGetExtension("GL_ARB_shader_atomic_counters"));


  glewInfoFunc("glGetActiveAtomicCounterBufferiv", glGetActiveAtomicCounterBufferiv == NULL);

}


#endif /* GL_ARB_shader_atomic_counters */


#ifdef GL_ARB_shader_bit_encoding


static void _glewInfo_GL_ARB_shader_bit_encoding (void)

{

  glewPrintExt("GL_ARB_shader_bit_encoding", GLEW_ARB_shader_bit_encoding, glewIsSupported("GL_ARB_shader_bit_encoding"), glewGetExtension("GL_ARB_shader_bit_encoding"));

}


#endif /* GL_ARB_shader_bit_encoding */


#ifdef GL_ARB_shader_draw_parameters


static void _glewInfo_GL_ARB_shader_draw_parameters (void)

{

  glewPrintExt("GL_ARB_shader_draw_parameters", GLEW_ARB_shader_draw_parameters, glewIsSupported("GL_ARB_shader_draw_parameters"), glewGetExtension("GL_ARB_shader_draw_parameters"));

}


#endif /* GL_ARB_shader_draw_parameters */


#ifdef GL_ARB_shader_group_vote


static void _glewInfo_GL_ARB_shader_group_vote (void)

{

  glewPrintExt("GL_ARB_shader_group_vote", GLEW_ARB_shader_group_vote, glewIsSupported("GL_ARB_shader_group_vote"), glewGetExtension("GL_ARB_shader_group_vote"));

}


#endif /* GL_ARB_shader_group_vote */


#ifdef GL_ARB_shader_image_load_store


static void _glewInfo_GL_ARB_shader_image_load_store (void)

{

  glewPrintExt("GL_ARB_shader_image_load_store", GLEW_ARB_shader_image_load_store, glewIsSupported("GL_ARB_shader_image_load_store"), glewGetExtension("GL_ARB_shader_image_load_store"));


  glewInfoFunc("glBindImageTexture", glBindImageTexture == NULL);

  glewInfoFunc("glMemoryBarrier", glMemoryBarrier == NULL);

}


#endif /* GL_ARB_shader_image_load_store */


#ifdef GL_ARB_shader_image_size


static void _glewInfo_GL_ARB_shader_image_size (void)

{

  glewPrintExt("GL_ARB_shader_image_size", GLEW_ARB_shader_image_size, glewIsSupported("GL_ARB_shader_image_size"), glewGetExtension("GL_ARB_shader_image_size"));

}


#endif /* GL_ARB_shader_image_size */


#ifdef GL_ARB_shader_objects


static void _glewInfo_GL_ARB_shader_objects (void)

{

  glewPrintExt("GL_ARB_shader_objects", GLEW_ARB_shader_objects, glewIsSupported("GL_ARB_shader_objects"), glewGetExtension("GL_ARB_shader_objects"));


  glewInfoFunc("glAttachObjectARB", glAttachObjectARB == NULL);

  glewInfoFunc("glCompileShaderARB", glCompileShaderARB == NULL);

  glewInfoFunc("glCreateProgramObjectARB", glCreateProgramObjectARB == NULL);

  glewInfoFunc("glCreateShaderObjectARB", glCreateShaderObjectARB == NULL);

  glewInfoFunc("glDeleteObjectARB", glDeleteObjectARB == NULL);

  glewInfoFunc("glDetachObjectARB", glDetachObjectARB == NULL);

  glewInfoFunc("glGetActiveUniformARB", glGetActiveUniformARB == NULL);

  glewInfoFunc("glGetAttachedObjectsARB", glGetAttachedObjectsARB == NULL);

  glewInfoFunc("glGetHandleARB", glGetHandleARB == NULL);

  glewInfoFunc("glGetInfoLogARB", glGetInfoLogARB == NULL);

  glewInfoFunc("glGetObjectParameterfvARB", glGetObjectParameterfvARB == NULL);

  glewInfoFunc("glGetObjectParameterivARB", glGetObjectParameterivARB == NULL);

  glewInfoFunc("glGetShaderSourceARB", glGetShaderSourceARB == NULL);

  glewInfoFunc("glGetUniformLocationARB", glGetUniformLocationARB == NULL);

  glewInfoFunc("glGetUniformfvARB", glGetUniformfvARB == NULL);

  glewInfoFunc("glGetUniformivARB", glGetUniformivARB == NULL);

  glewInfoFunc("glLinkProgramARB", glLinkProgramARB == NULL);

  glewInfoFunc("glShaderSourceARB", glShaderSourceARB == NULL);

  glewInfoFunc("glUniform1fARB", glUniform1fARB == NULL);

  glewInfoFunc("glUniform1fvARB", glUniform1fvARB == NULL);

  glewInfoFunc("glUniform1iARB", glUniform1iARB == NULL);

  glewInfoFunc("glUniform1ivARB", glUniform1ivARB == NULL);

  glewInfoFunc("glUniform2fARB", glUniform2fARB == NULL);

  glewInfoFunc("glUniform2fvARB", glUniform2fvARB == NULL);

  glewInfoFunc("glUniform2iARB", glUniform2iARB == NULL);

  glewInfoFunc("glUniform2ivARB", glUniform2ivARB == NULL);

  glewInfoFunc("glUniform3fARB", glUniform3fARB == NULL);

  glewInfoFunc("glUniform3fvARB", glUniform3fvARB == NULL);

  glewInfoFunc("glUniform3iARB", glUniform3iARB == NULL);

  glewInfoFunc("glUniform3ivARB", glUniform3ivARB == NULL);

  glewInfoFunc("glUniform4fARB", glUniform4fARB == NULL);

  glewInfoFunc("glUniform4fvARB", glUniform4fvARB == NULL);

  glewInfoFunc("glUniform4iARB", glUniform4iARB == NULL);

  glewInfoFunc("glUniform4ivARB", glUniform4ivARB == NULL);

  glewInfoFunc("glUniformMatrix2fvARB", glUniformMatrix2fvARB == NULL);

  glewInfoFunc("glUniformMatrix3fvARB", glUniformMatrix3fvARB == NULL);

  glewInfoFunc("glUniformMatrix4fvARB", glUniformMatrix4fvARB == NULL);

  glewInfoFunc("glUseProgramObjectARB", glUseProgramObjectARB == NULL);

  glewInfoFunc("glValidateProgramARB", glValidateProgramARB == NULL);

}


#endif /* GL_ARB_shader_objects */


#ifdef GL_ARB_shader_precision


static void _glewInfo_GL_ARB_shader_precision (void)

{

  glewPrintExt("GL_ARB_shader_precision", GLEW_ARB_shader_precision, glewIsSupported("GL_ARB_shader_precision"), glewGetExtension("GL_ARB_shader_precision"));

}


#endif /* GL_ARB_shader_precision */


#ifdef GL_ARB_shader_stencil_export


static void _glewInfo_GL_ARB_shader_stencil_export (void)

{

  glewPrintExt("GL_ARB_shader_stencil_export", GLEW_ARB_shader_stencil_export, glewIsSupported("GL_ARB_shader_stencil_export"), glewGetExtension("GL_ARB_shader_stencil_export"));

}


#endif /* GL_ARB_shader_stencil_export */


#ifdef GL_ARB_shader_storage_buffer_object


static void _glewInfo_GL_ARB_shader_storage_buffer_object (void)

{

  glewPrintExt("GL_ARB_shader_storage_buffer_object", GLEW_ARB_shader_storage_buffer_object, glewIsSupported("GL_ARB_shader_storage_buffer_object"), glewGetExtension("GL_ARB_shader_storage_buffer_object"));


  glewInfoFunc("glShaderStorageBlockBinding", glShaderStorageBlockBinding == NULL);

}


#endif /* GL_ARB_shader_storage_buffer_object */


#ifdef GL_ARB_shader_subroutine


static void _glewInfo_GL_ARB_shader_subroutine (void)

{

  glewPrintExt("GL_ARB_shader_subroutine", GLEW_ARB_shader_subroutine, glewIsSupported("GL_ARB_shader_subroutine"), glewGetExtension("GL_ARB_shader_subroutine"));


  glewInfoFunc("glGetActiveSubroutineName", glGetActiveSubroutineName == NULL);

  glewInfoFunc("glGetActiveSubroutineUniformName", glGetActiveSubroutineUniformName == NULL);

  glewInfoFunc("glGetActiveSubroutineUniformiv", glGetActiveSubroutineUniformiv == NULL);

  glewInfoFunc("glGetProgramStageiv", glGetProgramStageiv == NULL);

  glewInfoFunc("glGetSubroutineIndex", glGetSubroutineIndex == NULL);

  glewInfoFunc("glGetSubroutineUniformLocation", glGetSubroutineUniformLocation == NULL);

  glewInfoFunc("glGetUniformSubroutineuiv", glGetUniformSubroutineuiv == NULL);

  glewInfoFunc("glUniformSubroutinesuiv", glUniformSubroutinesuiv == NULL);

}


#endif /* GL_ARB_shader_subroutine */


#ifdef GL_ARB_shader_texture_lod


static void _glewInfo_GL_ARB_shader_texture_lod (void)

{

  glewPrintExt("GL_ARB_shader_texture_lod", GLEW_ARB_shader_texture_lod, glewIsSupported("GL_ARB_shader_texture_lod"), glewGetExtension("GL_ARB_shader_texture_lod"));

}


#endif /* GL_ARB_shader_texture_lod */


#ifdef GL_ARB_shading_language_100


static void _glewInfo_GL_ARB_shading_language_100 (void)

{

  glewPrintExt("GL_ARB_shading_language_100", GLEW_ARB_shading_language_100, glewIsSupported("GL_ARB_shading_language_100"), glewGetExtension("GL_ARB_shading_language_100"));

}


#endif /* GL_ARB_shading_language_100 */


#ifdef GL_ARB_shading_language_420pack


static void _glewInfo_GL_ARB_shading_language_420pack (void)

{

  glewPrintExt("GL_ARB_shading_language_420pack", GLEW_ARB_shading_language_420pack, glewIsSupported("GL_ARB_shading_language_420pack"), glewGetExtension("GL_ARB_shading_language_420pack"));

}


#endif /* GL_ARB_shading_language_420pack */


#ifdef GL_ARB_shading_language_include


static void _glewInfo_GL_ARB_shading_language_include (void)

{

  glewPrintExt("GL_ARB_shading_language_include", GLEW_ARB_shading_language_include, glewIsSupported("GL_ARB_shading_language_include"), glewGetExtension("GL_ARB_shading_language_include"));


  glewInfoFunc("glCompileShaderIncludeARB", glCompileShaderIncludeARB == NULL);

  glewInfoFunc("glDeleteNamedStringARB", glDeleteNamedStringARB == NULL);

  glewInfoFunc("glGetNamedStringARB", glGetNamedStringARB == NULL);

  glewInfoFunc("glGetNamedStringivARB", glGetNamedStringivARB == NULL);

  glewInfoFunc("glIsNamedStringARB", glIsNamedStringARB == NULL);

  glewInfoFunc("glNamedStringARB", glNamedStringARB == NULL);

}


#endif /* GL_ARB_shading_language_include */


#ifdef GL_ARB_shading_language_packing


static void _glewInfo_GL_ARB_shading_language_packing (void)

{

  glewPrintExt("GL_ARB_shading_language_packing", GLEW_ARB_shading_language_packing, glewIsSupported("GL_ARB_shading_language_packing"), glewGetExtension("GL_ARB_shading_language_packing"));

}


#endif /* GL_ARB_shading_language_packing */


#ifdef GL_ARB_shadow


static void _glewInfo_GL_ARB_shadow (void)

{

  glewPrintExt("GL_ARB_shadow", GLEW_ARB_shadow, glewIsSupported("GL_ARB_shadow"), glewGetExtension("GL_ARB_shadow"));

}


#endif /* GL_ARB_shadow */


#ifdef GL_ARB_shadow_ambient


static void _glewInfo_GL_ARB_shadow_ambient (void)

{

  glewPrintExt("GL_ARB_shadow_ambient", GLEW_ARB_shadow_ambient, glewIsSupported("GL_ARB_shadow_ambient"), glewGetExtension("GL_ARB_shadow_ambient"));

}


#endif /* GL_ARB_shadow_ambient */


#ifdef GL_ARB_sparse_texture


static void _glewInfo_GL_ARB_sparse_texture (void)

{

  glewPrintExt("GL_ARB_sparse_texture", GLEW_ARB_sparse_texture, glewIsSupported("GL_ARB_sparse_texture"), glewGetExtension("GL_ARB_sparse_texture"));


  glewInfoFunc("glTexPageCommitmentARB", glTexPageCommitmentARB == NULL);

  glewInfoFunc("glTexturePageCommitmentEXT", glTexturePageCommitmentEXT == NULL);

}


#endif /* GL_ARB_sparse_texture */


#ifdef GL_ARB_stencil_texturing


static void _glewInfo_GL_ARB_stencil_texturing (void)

{

  glewPrintExt("GL_ARB_stencil_texturing", GLEW_ARB_stencil_texturing, glewIsSupported("GL_ARB_stencil_texturing"), glewGetExtension("GL_ARB_stencil_texturing"));

}


#endif /* GL_ARB_stencil_texturing */


#ifdef GL_ARB_sync


static void _glewInfo_GL_ARB_sync (void)

{

  glewPrintExt("GL_ARB_sync", GLEW_ARB_sync, glewIsSupported("GL_ARB_sync"), glewGetExtension("GL_ARB_sync"));


  glewInfoFunc("glClientWaitSync", glClientWaitSync == NULL);

  glewInfoFunc("glDeleteSync", glDeleteSync == NULL);

  glewInfoFunc("glFenceSync", glFenceSync == NULL);

  glewInfoFunc("glGetInteger64v", glGetInteger64v == NULL);

  glewInfoFunc("glGetSynciv", glGetSynciv == NULL);

  glewInfoFunc("glIsSync", glIsSync == NULL);

  glewInfoFunc("glWaitSync", glWaitSync == NULL);

}


#endif /* GL_ARB_sync */


#ifdef GL_ARB_tessellation_shader


static void _glewInfo_GL_ARB_tessellation_shader (void)

{

  glewPrintExt("GL_ARB_tessellation_shader", GLEW_ARB_tessellation_shader, glewIsSupported("GL_ARB_tessellation_shader"), glewGetExtension("GL_ARB_tessellation_shader"));


  glewInfoFunc("glPatchParameterfv", glPatchParameterfv == NULL);

  glewInfoFunc("glPatchParameteri", glPatchParameteri == NULL);

}


#endif /* GL_ARB_tessellation_shader */


#ifdef GL_ARB_texture_border_clamp


static void _glewInfo_GL_ARB_texture_border_clamp (void)

{

  glewPrintExt("GL_ARB_texture_border_clamp", GLEW_ARB_texture_border_clamp, glewIsSupported("GL_ARB_texture_border_clamp"), glewGetExtension("GL_ARB_texture_border_clamp"));

}


#endif /* GL_ARB_texture_border_clamp */


#ifdef GL_ARB_texture_buffer_object


static void _glewInfo_GL_ARB_texture_buffer_object (void)

{

  glewPrintExt("GL_ARB_texture_buffer_object", GLEW_ARB_texture_buffer_object, glewIsSupported("GL_ARB_texture_buffer_object"), glewGetExtension("GL_ARB_texture_buffer_object"));


  glewInfoFunc("glTexBufferARB", glTexBufferARB == NULL);

}


#endif /* GL_ARB_texture_buffer_object */


#ifdef GL_ARB_texture_buffer_object_rgb32


static void _glewInfo_GL_ARB_texture_buffer_object_rgb32 (void)

{

  glewPrintExt("GL_ARB_texture_buffer_object_rgb32", GLEW_ARB_texture_buffer_object_rgb32, glewIsSupported("GL_ARB_texture_buffer_object_rgb32"), glewGetExtension("GL_ARB_texture_buffer_object_rgb32"));

}


#endif /* GL_ARB_texture_buffer_object_rgb32 */


#ifdef GL_ARB_texture_buffer_range


static void _glewInfo_GL_ARB_texture_buffer_range (void)

{

  glewPrintExt("GL_ARB_texture_buffer_range", GLEW_ARB_texture_buffer_range, glewIsSupported("GL_ARB_texture_buffer_range"), glewGetExtension("GL_ARB_texture_buffer_range"));


  glewInfoFunc("glTexBufferRange", glTexBufferRange == NULL);

  glewInfoFunc("glTextureBufferRangeEXT", glTextureBufferRangeEXT == NULL);

}


#endif /* GL_ARB_texture_buffer_range */


#ifdef GL_ARB_texture_compression


static void _glewInfo_GL_ARB_texture_compression (void)

{

  glewPrintExt("GL_ARB_texture_compression", GLEW_ARB_texture_compression, glewIsSupported("GL_ARB_texture_compression"), glewGetExtension("GL_ARB_texture_compression"));


  glewInfoFunc("glCompressedTexImage1DARB", glCompressedTexImage1DARB == NULL);

  glewInfoFunc("glCompressedTexImage2DARB", glCompressedTexImage2DARB == NULL);

  glewInfoFunc("glCompressedTexImage3DARB", glCompressedTexImage3DARB == NULL);

  glewInfoFunc("glCompressedTexSubImage1DARB", glCompressedTexSubImage1DARB == NULL);

  glewInfoFunc("glCompressedTexSubImage2DARB", glCompressedTexSubImage2DARB == NULL);

  glewInfoFunc("glCompressedTexSubImage3DARB", glCompressedTexSubImage3DARB == NULL);

  glewInfoFunc("glGetCompressedTexImageARB", glGetCompressedTexImageARB == NULL);

}


#endif /* GL_ARB_texture_compression */


#ifdef GL_ARB_texture_compression_bptc


static void _glewInfo_GL_ARB_texture_compression_bptc (void)

{

  glewPrintExt("GL_ARB_texture_compression_bptc", GLEW_ARB_texture_compression_bptc, glewIsSupported("GL_ARB_texture_compression_bptc"), glewGetExtension("GL_ARB_texture_compression_bptc"));

}


#endif /* GL_ARB_texture_compression_bptc */


#ifdef GL_ARB_texture_compression_rgtc


static void _glewInfo_GL_ARB_texture_compression_rgtc (void)

{

  glewPrintExt("GL_ARB_texture_compression_rgtc", GLEW_ARB_texture_compression_rgtc, glewIsSupported("GL_ARB_texture_compression_rgtc"), glewGetExtension("GL_ARB_texture_compression_rgtc"));

}


#endif /* GL_ARB_texture_compression_rgtc */


#ifdef GL_ARB_texture_cube_map


static void _glewInfo_GL_ARB_texture_cube_map (void)

{

  glewPrintExt("GL_ARB_texture_cube_map", GLEW_ARB_texture_cube_map, glewIsSupported("GL_ARB_texture_cube_map"), glewGetExtension("GL_ARB_texture_cube_map"));

}


#endif /* GL_ARB_texture_cube_map */


#ifdef GL_ARB_texture_cube_map_array


static void _glewInfo_GL_ARB_texture_cube_map_array (void)

{

  glewPrintExt("GL_ARB_texture_cube_map_array", GLEW_ARB_texture_cube_map_array, glewIsSupported("GL_ARB_texture_cube_map_array"), glewGetExtension("GL_ARB_texture_cube_map_array"));

}


#endif /* GL_ARB_texture_cube_map_array */


#ifdef GL_ARB_texture_env_add


static void _glewInfo_GL_ARB_texture_env_add (void)

{

  glewPrintExt("GL_ARB_texture_env_add", GLEW_ARB_texture_env_add, glewIsSupported("GL_ARB_texture_env_add"), glewGetExtension("GL_ARB_texture_env_add"));

}


#endif /* GL_ARB_texture_env_add */


#ifdef GL_ARB_texture_env_combine


static void _glewInfo_GL_ARB_texture_env_combine (void)

{

  glewPrintExt("GL_ARB_texture_env_combine", GLEW_ARB_texture_env_combine, glewIsSupported("GL_ARB_texture_env_combine"), glewGetExtension("GL_ARB_texture_env_combine"));

}


#endif /* GL_ARB_texture_env_combine */


#ifdef GL_ARB_texture_env_crossbar


static void _glewInfo_GL_ARB_texture_env_crossbar (void)

{

  glewPrintExt("GL_ARB_texture_env_crossbar", GLEW_ARB_texture_env_crossbar, glewIsSupported("GL_ARB_texture_env_crossbar"), glewGetExtension("GL_ARB_texture_env_crossbar"));

}


#endif /* GL_ARB_texture_env_crossbar */


#ifdef GL_ARB_texture_env_dot3


static void _glewInfo_GL_ARB_texture_env_dot3 (void)

{

  glewPrintExt("GL_ARB_texture_env_dot3", GLEW_ARB_texture_env_dot3, glewIsSupported("GL_ARB_texture_env_dot3"), glewGetExtension("GL_ARB_texture_env_dot3"));

}


#endif /* GL_ARB_texture_env_dot3 */


#ifdef GL_ARB_texture_float


static void _glewInfo_GL_ARB_texture_float (void)

{

  glewPrintExt("GL_ARB_texture_float", GLEW_ARB_texture_float, glewIsSupported("GL_ARB_texture_float"), glewGetExtension("GL_ARB_texture_float"));

}


#endif /* GL_ARB_texture_float */


#ifdef GL_ARB_texture_gather


static void _glewInfo_GL_ARB_texture_gather (void)

{

  glewPrintExt("GL_ARB_texture_gather", GLEW_ARB_texture_gather, glewIsSupported("GL_ARB_texture_gather"), glewGetExtension("GL_ARB_texture_gather"));

}


#endif /* GL_ARB_texture_gather */


#ifdef GL_ARB_texture_mirror_clamp_to_edge


static void _glewInfo_GL_ARB_texture_mirror_clamp_to_edge (void)

{

  glewPrintExt("GL_ARB_texture_mirror_clamp_to_edge", GLEW_ARB_texture_mirror_clamp_to_edge, glewIsSupported("GL_ARB_texture_mirror_clamp_to_edge"), glewGetExtension("GL_ARB_texture_mirror_clamp_to_edge"));

}


#endif /* GL_ARB_texture_mirror_clamp_to_edge */


#ifdef GL_ARB_texture_mirrored_repeat


static void _glewInfo_GL_ARB_texture_mirrored_repeat (void)

{

  glewPrintExt("GL_ARB_texture_mirrored_repeat", GLEW_ARB_texture_mirrored_repeat, glewIsSupported("GL_ARB_texture_mirrored_repeat"), glewGetExtension("GL_ARB_texture_mirrored_repeat"));

}


#endif /* GL_ARB_texture_mirrored_repeat */


#ifdef GL_ARB_texture_multisample


static void _glewInfo_GL_ARB_texture_multisample (void)

{

  glewPrintExt("GL_ARB_texture_multisample", GLEW_ARB_texture_multisample, glewIsSupported("GL_ARB_texture_multisample"), glewGetExtension("GL_ARB_texture_multisample"));


  glewInfoFunc("glGetMultisamplefv", glGetMultisamplefv == NULL);

  glewInfoFunc("glSampleMaski", glSampleMaski == NULL);

  glewInfoFunc("glTexImage2DMultisample", glTexImage2DMultisample == NULL);

  glewInfoFunc("glTexImage3DMultisample", glTexImage3DMultisample == NULL);

}


#endif /* GL_ARB_texture_multisample */


#ifdef GL_ARB_texture_non_power_of_two


static void _glewInfo_GL_ARB_texture_non_power_of_two (void)

{

  glewPrintExt("GL_ARB_texture_non_power_of_two", GLEW_ARB_texture_non_power_of_two, glewIsSupported("GL_ARB_texture_non_power_of_two"), glewGetExtension("GL_ARB_texture_non_power_of_two"));

}


#endif /* GL_ARB_texture_non_power_of_two */


#ifdef GL_ARB_texture_query_levels


static void _glewInfo_GL_ARB_texture_query_levels (void)

{

  glewPrintExt("GL_ARB_texture_query_levels", GLEW_ARB_texture_query_levels, glewIsSupported("GL_ARB_texture_query_levels"), glewGetExtension("GL_ARB_texture_query_levels"));

}


#endif /* GL_ARB_texture_query_levels */


#ifdef GL_ARB_texture_query_lod


static void _glewInfo_GL_ARB_texture_query_lod (void)

{

  glewPrintExt("GL_ARB_texture_query_lod", GLEW_ARB_texture_query_lod, glewIsSupported("GL_ARB_texture_query_lod"), glewGetExtension("GL_ARB_texture_query_lod"));

}


#endif /* GL_ARB_texture_query_lod */


#ifdef GL_ARB_texture_rectangle


static void _glewInfo_GL_ARB_texture_rectangle (void)

{

  glewPrintExt("GL_ARB_texture_rectangle", GLEW_ARB_texture_rectangle, glewIsSupported("GL_ARB_texture_rectangle"), glewGetExtension("GL_ARB_texture_rectangle"));

}


#endif /* GL_ARB_texture_rectangle */


#ifdef GL_ARB_texture_rg


static void _glewInfo_GL_ARB_texture_rg (void)

{

  glewPrintExt("GL_ARB_texture_rg", GLEW_ARB_texture_rg, glewIsSupported("GL_ARB_texture_rg"), glewGetExtension("GL_ARB_texture_rg"));

}


#endif /* GL_ARB_texture_rg */


#ifdef GL_ARB_texture_rgb10_a2ui


static void _glewInfo_GL_ARB_texture_rgb10_a2ui (void)

{

  glewPrintExt("GL_ARB_texture_rgb10_a2ui", GLEW_ARB_texture_rgb10_a2ui, glewIsSupported("GL_ARB_texture_rgb10_a2ui"), glewGetExtension("GL_ARB_texture_rgb10_a2ui"));

}


#endif /* GL_ARB_texture_rgb10_a2ui */


#ifdef GL_ARB_texture_stencil8


static void _glewInfo_GL_ARB_texture_stencil8 (void)

{

  glewPrintExt("GL_ARB_texture_stencil8", GLEW_ARB_texture_stencil8, glewIsSupported("GL_ARB_texture_stencil8"), glewGetExtension("GL_ARB_texture_stencil8"));

}


#endif /* GL_ARB_texture_stencil8 */


#ifdef GL_ARB_texture_storage


static void _glewInfo_GL_ARB_texture_storage (void)

{

  glewPrintExt("GL_ARB_texture_storage", GLEW_ARB_texture_storage, glewIsSupported("GL_ARB_texture_storage"), glewGetExtension("GL_ARB_texture_storage"));


  glewInfoFunc("glTexStorage1D", glTexStorage1D == NULL);

  glewInfoFunc("glTexStorage2D", glTexStorage2D == NULL);

  glewInfoFunc("glTexStorage3D", glTexStorage3D == NULL);

  glewInfoFunc("glTextureStorage1DEXT", glTextureStorage1DEXT == NULL);

  glewInfoFunc("glTextureStorage2DEXT", glTextureStorage2DEXT == NULL);

  glewInfoFunc("glTextureStorage3DEXT", glTextureStorage3DEXT == NULL);

}


#endif /* GL_ARB_texture_storage */


#ifdef GL_ARB_texture_storage_multisample


static void _glewInfo_GL_ARB_texture_storage_multisample (void)

{

  glewPrintExt("GL_ARB_texture_storage_multisample", GLEW_ARB_texture_storage_multisample, glewIsSupported("GL_ARB_texture_storage_multisample"), glewGetExtension("GL_ARB_texture_storage_multisample"));


  glewInfoFunc("glTexStorage2DMultisample", glTexStorage2DMultisample == NULL);

  glewInfoFunc("glTexStorage3DMultisample", glTexStorage3DMultisample == NULL);

  glewInfoFunc("glTextureStorage2DMultisampleEXT", glTextureStorage2DMultisampleEXT == NULL);

  glewInfoFunc("glTextureStorage3DMultisampleEXT", glTextureStorage3DMultisampleEXT == NULL);

}


#endif /* GL_ARB_texture_storage_multisample */


#ifdef GL_ARB_texture_swizzle


static void _glewInfo_GL_ARB_texture_swizzle (void)

{

  glewPrintExt("GL_ARB_texture_swizzle", GLEW_ARB_texture_swizzle, glewIsSupported("GL_ARB_texture_swizzle"), glewGetExtension("GL_ARB_texture_swizzle"));

}


#endif /* GL_ARB_texture_swizzle */


#ifdef GL_ARB_texture_view


static void _glewInfo_GL_ARB_texture_view (void)

{

  glewPrintExt("GL_ARB_texture_view", GLEW_ARB_texture_view, glewIsSupported("GL_ARB_texture_view"), glewGetExtension("GL_ARB_texture_view"));


  glewInfoFunc("glTextureView", glTextureView == NULL);

}


#endif /* GL_ARB_texture_view */


#ifdef GL_ARB_timer_query


static void _glewInfo_GL_ARB_timer_query (void)

{

  glewPrintExt("GL_ARB_timer_query", GLEW_ARB_timer_query, glewIsSupported("GL_ARB_timer_query"), glewGetExtension("GL_ARB_timer_query"));


  glewInfoFunc("glGetQueryObjecti64v", glGetQueryObjecti64v == NULL);

  glewInfoFunc("glGetQueryObjectui64v", glGetQueryObjectui64v == NULL);

  glewInfoFunc("glQueryCounter", glQueryCounter == NULL);

}


#endif /* GL_ARB_timer_query */


#ifdef GL_ARB_transform_feedback2


static void _glewInfo_GL_ARB_transform_feedback2 (void)

{

  glewPrintExt("GL_ARB_transform_feedback2", GLEW_ARB_transform_feedback2, glewIsSupported("GL_ARB_transform_feedback2"), glewGetExtension("GL_ARB_transform_feedback2"));


  glewInfoFunc("glBindTransformFeedback", glBindTransformFeedback == NULL);

  glewInfoFunc("glDeleteTransformFeedbacks", glDeleteTransformFeedbacks == NULL);

  glewInfoFunc("glDrawTransformFeedback", glDrawTransformFeedback == NULL);

  glewInfoFunc("glGenTransformFeedbacks", glGenTransformFeedbacks == NULL);

  glewInfoFunc("glIsTransformFeedback", glIsTransformFeedback == NULL);

  glewInfoFunc("glPauseTransformFeedback", glPauseTransformFeedback == NULL);

  glewInfoFunc("glResumeTransformFeedback", glResumeTransformFeedback == NULL);

}


#endif /* GL_ARB_transform_feedback2 */


#ifdef GL_ARB_transform_feedback3


static void _glewInfo_GL_ARB_transform_feedback3 (void)

{

  glewPrintExt("GL_ARB_transform_feedback3", GLEW_ARB_transform_feedback3, glewIsSupported("GL_ARB_transform_feedback3"), glewGetExtension("GL_ARB_transform_feedback3"));


  glewInfoFunc("glBeginQueryIndexed", glBeginQueryIndexed == NULL);

  glewInfoFunc("glDrawTransformFeedbackStream", glDrawTransformFeedbackStream == NULL);

  glewInfoFunc("glEndQueryIndexed", glEndQueryIndexed == NULL);

  glewInfoFunc("glGetQueryIndexediv", glGetQueryIndexediv == NULL);

}


#endif /* GL_ARB_transform_feedback3 */


#ifdef GL_ARB_transform_feedback_instanced


static void _glewInfo_GL_ARB_transform_feedback_instanced (void)

{

  glewPrintExt("GL_ARB_transform_feedback_instanced", GLEW_ARB_transform_feedback_instanced, glewIsSupported("GL_ARB_transform_feedback_instanced"), glewGetExtension("GL_ARB_transform_feedback_instanced"));


  glewInfoFunc("glDrawTransformFeedbackInstanced", glDrawTransformFeedbackInstanced == NULL);

  glewInfoFunc("glDrawTransformFeedbackStreamInstanced", glDrawTransformFeedbackStreamInstanced == NULL);

}


#endif /* GL_ARB_transform_feedback_instanced */


#ifdef GL_ARB_transpose_matrix


static void _glewInfo_GL_ARB_transpose_matrix (void)

{

  glewPrintExt("GL_ARB_transpose_matrix", GLEW_ARB_transpose_matrix, glewIsSupported("GL_ARB_transpose_matrix"), glewGetExtension("GL_ARB_transpose_matrix"));


  glewInfoFunc("glLoadTransposeMatrixdARB", glLoadTransposeMatrixdARB == NULL);

  glewInfoFunc("glLoadTransposeMatrixfARB", glLoadTransposeMatrixfARB == NULL);

  glewInfoFunc("glMultTransposeMatrixdARB", glMultTransposeMatrixdARB == NULL);

  glewInfoFunc("glMultTransposeMatrixfARB", glMultTransposeMatrixfARB == NULL);

}


#endif /* GL_ARB_transpose_matrix */


#ifdef GL_ARB_uniform_buffer_object


static void _glewInfo_GL_ARB_uniform_buffer_object (void)

{

  glewPrintExt("GL_ARB_uniform_buffer_object", GLEW_ARB_uniform_buffer_object, glewIsSupported("GL_ARB_uniform_buffer_object"), glewGetExtension("GL_ARB_uniform_buffer_object"));


  glewInfoFunc("glBindBufferBase", glBindBufferBase == NULL);

  glewInfoFunc("glBindBufferRange", glBindBufferRange == NULL);

  glewInfoFunc("glGetActiveUniformBlockName", glGetActiveUniformBlockName == NULL);

  glewInfoFunc("glGetActiveUniformBlockiv", glGetActiveUniformBlockiv == NULL);

  glewInfoFunc("glGetActiveUniformName", glGetActiveUniformName == NULL);

  glewInfoFunc("glGetActiveUniformsiv", glGetActiveUniformsiv == NULL);

  glewInfoFunc("glGetIntegeri_v", glGetIntegeri_v == NULL);

  glewInfoFunc("glGetUniformBlockIndex", glGetUniformBlockIndex == NULL);

  glewInfoFunc("glGetUniformIndices", glGetUniformIndices == NULL);

  glewInfoFunc("glUniformBlockBinding", glUniformBlockBinding == NULL);

}


#endif /* GL_ARB_uniform_buffer_object */


#ifdef GL_ARB_vertex_array_bgra


static void _glewInfo_GL_ARB_vertex_array_bgra (void)

{

  glewPrintExt("GL_ARB_vertex_array_bgra", GLEW_ARB_vertex_array_bgra, glewIsSupported("GL_ARB_vertex_array_bgra"), glewGetExtension("GL_ARB_vertex_array_bgra"));

}


#endif /* GL_ARB_vertex_array_bgra */


#ifdef GL_ARB_vertex_array_object


static void _glewInfo_GL_ARB_vertex_array_object (void)

{

  glewPrintExt("GL_ARB_vertex_array_object", GLEW_ARB_vertex_array_object, glewIsSupported("GL_ARB_vertex_array_object"), glewGetExtension("GL_ARB_vertex_array_object"));


  glewInfoFunc("glBindVertexArray", glBindVertexArray == NULL);

  glewInfoFunc("glDeleteVertexArrays", glDeleteVertexArrays == NULL);

  glewInfoFunc("glGenVertexArrays", glGenVertexArrays == NULL);

  glewInfoFunc("glIsVertexArray", glIsVertexArray == NULL);

}


#endif /* GL_ARB_vertex_array_object */


#ifdef GL_ARB_vertex_attrib_64bit


static void _glewInfo_GL_ARB_vertex_attrib_64bit (void)

{

  glewPrintExt("GL_ARB_vertex_attrib_64bit", GLEW_ARB_vertex_attrib_64bit, glewIsSupported("GL_ARB_vertex_attrib_64bit"), glewGetExtension("GL_ARB_vertex_attrib_64bit"));


  glewInfoFunc("glGetVertexAttribLdv", glGetVertexAttribLdv == NULL);

  glewInfoFunc("glVertexAttribL1d", glVertexAttribL1d == NULL);

  glewInfoFunc("glVertexAttribL1dv", glVertexAttribL1dv == NULL);

  glewInfoFunc("glVertexAttribL2d", glVertexAttribL2d == NULL);

  glewInfoFunc("glVertexAttribL2dv", glVertexAttribL2dv == NULL);

  glewInfoFunc("glVertexAttribL3d", glVertexAttribL3d == NULL);

  glewInfoFunc("glVertexAttribL3dv", glVertexAttribL3dv == NULL);

  glewInfoFunc("glVertexAttribL4d", glVertexAttribL4d == NULL);

  glewInfoFunc("glVertexAttribL4dv", glVertexAttribL4dv == NULL);

  glewInfoFunc("glVertexAttribLPointer", glVertexAttribLPointer == NULL);

}


#endif /* GL_ARB_vertex_attrib_64bit */


#ifdef GL_ARB_vertex_attrib_binding


static void _glewInfo_GL_ARB_vertex_attrib_binding (void)

{

  glewPrintExt("GL_ARB_vertex_attrib_binding", GLEW_ARB_vertex_attrib_binding, glewIsSupported("GL_ARB_vertex_attrib_binding"), glewGetExtension("GL_ARB_vertex_attrib_binding"));


  glewInfoFunc("glBindVertexBuffer", glBindVertexBuffer == NULL);

  glewInfoFunc("glVertexAttribBinding", glVertexAttribBinding == NULL);

  glewInfoFunc("glVertexAttribFormat", glVertexAttribFormat == NULL);

  glewInfoFunc("glVertexAttribIFormat", glVertexAttribIFormat == NULL);

  glewInfoFunc("glVertexAttribLFormat", glVertexAttribLFormat == NULL);

  glewInfoFunc("glVertexBindingDivisor", glVertexBindingDivisor == NULL);

}


#endif /* GL_ARB_vertex_attrib_binding */


#ifdef GL_ARB_vertex_blend


static void _glewInfo_GL_ARB_vertex_blend (void)

{

  glewPrintExt("GL_ARB_vertex_blend", GLEW_ARB_vertex_blend, glewIsSupported("GL_ARB_vertex_blend"), glewGetExtension("GL_ARB_vertex_blend"));


  glewInfoFunc("glVertexBlendARB", glVertexBlendARB == NULL);

  glewInfoFunc("glWeightPointerARB", glWeightPointerARB == NULL);

  glewInfoFunc("glWeightbvARB", glWeightbvARB == NULL);

  glewInfoFunc("glWeightdvARB", glWeightdvARB == NULL);

  glewInfoFunc("glWeightfvARB", glWeightfvARB == NULL);

  glewInfoFunc("glWeightivARB", glWeightivARB == NULL);

  glewInfoFunc("glWeightsvARB", glWeightsvARB == NULL);

  glewInfoFunc("glWeightubvARB", glWeightubvARB == NULL);

  glewInfoFunc("glWeightuivARB", glWeightuivARB == NULL);

  glewInfoFunc("glWeightusvARB", glWeightusvARB == NULL);

}


#endif /* GL_ARB_vertex_blend */


#ifdef GL_ARB_vertex_buffer_object


static void _glewInfo_GL_ARB_vertex_buffer_object (void)

{

  glewPrintExt("GL_ARB_vertex_buffer_object", GLEW_ARB_vertex_buffer_object, glewIsSupported("GL_ARB_vertex_buffer_object"), glewGetExtension("GL_ARB_vertex_buffer_object"));


  glewInfoFunc("glBindBufferARB", glBindBufferARB == NULL);

  glewInfoFunc("glBufferDataARB", glBufferDataARB == NULL);

  glewInfoFunc("glBufferSubDataARB", glBufferSubDataARB == NULL);

  glewInfoFunc("glDeleteBuffersARB", glDeleteBuffersARB == NULL);

  glewInfoFunc("glGenBuffersARB", glGenBuffersARB == NULL);

  glewInfoFunc("glGetBufferParameterivARB", glGetBufferParameterivARB == NULL);

  glewInfoFunc("glGetBufferPointervARB", glGetBufferPointervARB == NULL);

  glewInfoFunc("glGetBufferSubDataARB", glGetBufferSubDataARB == NULL);

  glewInfoFunc("glIsBufferARB", glIsBufferARB == NULL);

  glewInfoFunc("glMapBufferARB", glMapBufferARB == NULL);

  glewInfoFunc("glUnmapBufferARB", glUnmapBufferARB == NULL);

}


#endif /* GL_ARB_vertex_buffer_object */


#ifdef GL_ARB_vertex_program


static void _glewInfo_GL_ARB_vertex_program (void)

{

  glewPrintExt("GL_ARB_vertex_program", GLEW_ARB_vertex_program, glewIsSupported("GL_ARB_vertex_program"), glewGetExtension("GL_ARB_vertex_program"));


  glewInfoFunc("glBindProgramARB", glBindProgramARB == NULL);

  glewInfoFunc("glDeleteProgramsARB", glDeleteProgramsARB == NULL);

  glewInfoFunc("glDisableVertexAttribArrayARB", glDisableVertexAttribArrayARB == NULL);

  glewInfoFunc("glEnableVertexAttribArrayARB", glEnableVertexAttribArrayARB == NULL);

  glewInfoFunc("glGenProgramsARB", glGenProgramsARB == NULL);

  glewInfoFunc("glGetProgramEnvParameterdvARB", glGetProgramEnvParameterdvARB == NULL);

  glewInfoFunc("glGetProgramEnvParameterfvARB", glGetProgramEnvParameterfvARB == NULL);

  glewInfoFunc("glGetProgramLocalParameterdvARB", glGetProgramLocalParameterdvARB == NULL);

  glewInfoFunc("glGetProgramLocalParameterfvARB", glGetProgramLocalParameterfvARB == NULL);

  glewInfoFunc("glGetProgramStringARB", glGetProgramStringARB == NULL);

  glewInfoFunc("glGetProgramivARB", glGetProgramivARB == NULL);

  glewInfoFunc("glGetVertexAttribPointervARB", glGetVertexAttribPointervARB == NULL);

  glewInfoFunc("glGetVertexAttribdvARB", glGetVertexAttribdvARB == NULL);

  glewInfoFunc("glGetVertexAttribfvARB", glGetVertexAttribfvARB == NULL);

  glewInfoFunc("glGetVertexAttribivARB", glGetVertexAttribivARB == NULL);

  glewInfoFunc("glIsProgramARB", glIsProgramARB == NULL);

  glewInfoFunc("glProgramEnvParameter4dARB", glProgramEnvParameter4dARB == NULL);

  glewInfoFunc("glProgramEnvParameter4dvARB", glProgramEnvParameter4dvARB == NULL);

  glewInfoFunc("glProgramEnvParameter4fARB", glProgramEnvParameter4fARB == NULL);

  glewInfoFunc("glProgramEnvParameter4fvARB", glProgramEnvParameter4fvARB == NULL);

  glewInfoFunc("glProgramLocalParameter4dARB", glProgramLocalParameter4dARB == NULL);

  glewInfoFunc("glProgramLocalParameter4dvARB", glProgramLocalParameter4dvARB == NULL);

  glewInfoFunc("glProgramLocalParameter4fARB", glProgramLocalParameter4fARB == NULL);

  glewInfoFunc("glProgramLocalParameter4fvARB", glProgramLocalParameter4fvARB == NULL);

  glewInfoFunc("glProgramStringARB", glProgramStringARB == NULL);

  glewInfoFunc("glVertexAttrib1dARB", glVertexAttrib1dARB == NULL);

  glewInfoFunc("glVertexAttrib1dvARB", glVertexAttrib1dvARB == NULL);

  glewInfoFunc("glVertexAttrib1fARB", glVertexAttrib1fARB == NULL);

  glewInfoFunc("glVertexAttrib1fvARB", glVertexAttrib1fvARB == NULL);

  glewInfoFunc("glVertexAttrib1sARB", glVertexAttrib1sARB == NULL);

  glewInfoFunc("glVertexAttrib1svARB", glVertexAttrib1svARB == NULL);

  glewInfoFunc("glVertexAttrib2dARB", glVertexAttrib2dARB == NULL);

  glewInfoFunc("glVertexAttrib2dvARB", glVertexAttrib2dvARB == NULL);

  glewInfoFunc("glVertexAttrib2fARB", glVertexAttrib2fARB == NULL);

  glewInfoFunc("glVertexAttrib2fvARB", glVertexAttrib2fvARB == NULL);

  glewInfoFunc("glVertexAttrib2sARB", glVertexAttrib2sARB == NULL);

  glewInfoFunc("glVertexAttrib2svARB", glVertexAttrib2svARB == NULL);

  glewInfoFunc("glVertexAttrib3dARB", glVertexAttrib3dARB == NULL);

  glewInfoFunc("glVertexAttrib3dvARB", glVertexAttrib3dvARB == NULL);

  glewInfoFunc("glVertexAttrib3fARB", glVertexAttrib3fARB == NULL);

  glewInfoFunc("glVertexAttrib3fvARB", glVertexAttrib3fvARB == NULL);

  glewInfoFunc("glVertexAttrib3sARB", glVertexAttrib3sARB == NULL);

  glewInfoFunc("glVertexAttrib3svARB", glVertexAttrib3svARB == NULL);

  glewInfoFunc("glVertexAttrib4NbvARB", glVertexAttrib4NbvARB == NULL);

  glewInfoFunc("glVertexAttrib4NivARB", glVertexAttrib4NivARB == NULL);

  glewInfoFunc("glVertexAttrib4NsvARB", glVertexAttrib4NsvARB == NULL);

  glewInfoFunc("glVertexAttrib4NubARB", glVertexAttrib4NubARB == NULL);

  glewInfoFunc("glVertexAttrib4NubvARB", glVertexAttrib4NubvARB == NULL);

  glewInfoFunc("glVertexAttrib4NuivARB", glVertexAttrib4NuivARB == NULL);

  glewInfoFunc("glVertexAttrib4NusvARB", glVertexAttrib4NusvARB == NULL);

  glewInfoFunc("glVertexAttrib4bvARB", glVertexAttrib4bvARB == NULL);

  glewInfoFunc("glVertexAttrib4dARB", glVertexAttrib4dARB == NULL);

  glewInfoFunc("glVertexAttrib4dvARB", glVertexAttrib4dvARB == NULL);

  glewInfoFunc("glVertexAttrib4fARB", glVertexAttrib4fARB == NULL);

  glewInfoFunc("glVertexAttrib4fvARB", glVertexAttrib4fvARB == NULL);

  glewInfoFunc("glVertexAttrib4ivARB", glVertexAttrib4ivARB == NULL);

  glewInfoFunc("glVertexAttrib4sARB", glVertexAttrib4sARB == NULL);

  glewInfoFunc("glVertexAttrib4svARB", glVertexAttrib4svARB == NULL);

  glewInfoFunc("glVertexAttrib4ubvARB", glVertexAttrib4ubvARB == NULL);

  glewInfoFunc("glVertexAttrib4uivARB", glVertexAttrib4uivARB == NULL);

  glewInfoFunc("glVertexAttrib4usvARB", glVertexAttrib4usvARB == NULL);

  glewInfoFunc("glVertexAttribPointerARB", glVertexAttribPointerARB == NULL);

}


#endif /* GL_ARB_vertex_program */


#ifdef GL_ARB_vertex_shader


static void _glewInfo_GL_ARB_vertex_shader (void)

{

  glewPrintExt("GL_ARB_vertex_shader", GLEW_ARB_vertex_shader, glewIsSupported("GL_ARB_vertex_shader"), glewGetExtension("GL_ARB_vertex_shader"));


  glewInfoFunc("glBindAttribLocationARB", glBindAttribLocationARB == NULL);

  glewInfoFunc("glGetActiveAttribARB", glGetActiveAttribARB == NULL);

  glewInfoFunc("glGetAttribLocationARB", glGetAttribLocationARB == NULL);

}


#endif /* GL_ARB_vertex_shader */


#ifdef GL_ARB_vertex_type_10f_11f_11f_rev


static void _glewInfo_GL_ARB_vertex_type_10f_11f_11f_rev (void)

{

  glewPrintExt("GL_ARB_vertex_type_10f_11f_11f_rev", GLEW_ARB_vertex_type_10f_11f_11f_rev, glewIsSupported("GL_ARB_vertex_type_10f_11f_11f_rev"), glewGetExtension("GL_ARB_vertex_type_10f_11f_11f_rev"));

}


#endif /* GL_ARB_vertex_type_10f_11f_11f_rev */


#ifdef GL_ARB_vertex_type_2_10_10_10_rev


static void _glewInfo_GL_ARB_vertex_type_2_10_10_10_rev (void)

{

  glewPrintExt("GL_ARB_vertex_type_2_10_10_10_rev", GLEW_ARB_vertex_type_2_10_10_10_rev, glewIsSupported("GL_ARB_vertex_type_2_10_10_10_rev"), glewGetExtension("GL_ARB_vertex_type_2_10_10_10_rev"));


  glewInfoFunc("glColorP3ui", glColorP3ui == NULL);

  glewInfoFunc("glColorP3uiv", glColorP3uiv == NULL);

  glewInfoFunc("glColorP4ui", glColorP4ui == NULL);

  glewInfoFunc("glColorP4uiv", glColorP4uiv == NULL);

  glewInfoFunc("glMultiTexCoordP1ui", glMultiTexCoordP1ui == NULL);

  glewInfoFunc("glMultiTexCoordP1uiv", glMultiTexCoordP1uiv == NULL);

  glewInfoFunc("glMultiTexCoordP2ui", glMultiTexCoordP2ui == NULL);

  glewInfoFunc("glMultiTexCoordP2uiv", glMultiTexCoordP2uiv == NULL);

  glewInfoFunc("glMultiTexCoordP3ui", glMultiTexCoordP3ui == NULL);

  glewInfoFunc("glMultiTexCoordP3uiv", glMultiTexCoordP3uiv == NULL);

  glewInfoFunc("glMultiTexCoordP4ui", glMultiTexCoordP4ui == NULL);

  glewInfoFunc("glMultiTexCoordP4uiv", glMultiTexCoordP4uiv == NULL);

  glewInfoFunc("glNormalP3ui", glNormalP3ui == NULL);

  glewInfoFunc("glNormalP3uiv", glNormalP3uiv == NULL);

  glewInfoFunc("glSecondaryColorP3ui", glSecondaryColorP3ui == NULL);

  glewInfoFunc("glSecondaryColorP3uiv", glSecondaryColorP3uiv == NULL);

  glewInfoFunc("glTexCoordP1ui", glTexCoordP1ui == NULL);

  glewInfoFunc("glTexCoordP1uiv", glTexCoordP1uiv == NULL);

  glewInfoFunc("glTexCoordP2ui", glTexCoordP2ui == NULL);

  glewInfoFunc("glTexCoordP2uiv", glTexCoordP2uiv == NULL);

  glewInfoFunc("glTexCoordP3ui", glTexCoordP3ui == NULL);

  glewInfoFunc("glTexCoordP3uiv", glTexCoordP3uiv == NULL);

  glewInfoFunc("glTexCoordP4ui", glTexCoordP4ui == NULL);

  glewInfoFunc("glTexCoordP4uiv", glTexCoordP4uiv == NULL);

  glewInfoFunc("glVertexAttribP1ui", glVertexAttribP1ui == NULL);

  glewInfoFunc("glVertexAttribP1uiv", glVertexAttribP1uiv == NULL);

  glewInfoFunc("glVertexAttribP2ui", glVertexAttribP2ui == NULL);

  glewInfoFunc("glVertexAttribP2uiv", glVertexAttribP2uiv == NULL);

  glewInfoFunc("glVertexAttribP3ui", glVertexAttribP3ui == NULL);

  glewInfoFunc("glVertexAttribP3uiv", glVertexAttribP3uiv == NULL);

  glewInfoFunc("glVertexAttribP4ui", glVertexAttribP4ui == NULL);

  glewInfoFunc("glVertexAttribP4uiv", glVertexAttribP4uiv == NULL);

  glewInfoFunc("glVertexP2ui", glVertexP2ui == NULL);

  glewInfoFunc("glVertexP2uiv", glVertexP2uiv == NULL);

  glewInfoFunc("glVertexP3ui", glVertexP3ui == NULL);

  glewInfoFunc("glVertexP3uiv", glVertexP3uiv == NULL);

  glewInfoFunc("glVertexP4ui", glVertexP4ui == NULL);

  glewInfoFunc("glVertexP4uiv", glVertexP4uiv == NULL);

}


#endif /* GL_ARB_vertex_type_2_10_10_10_rev */


#ifdef GL_ARB_viewport_array


static void _glewInfo_GL_ARB_viewport_array (void)

{

  glewPrintExt("GL_ARB_viewport_array", GLEW_ARB_viewport_array, glewIsSupported("GL_ARB_viewport_array"), glewGetExtension("GL_ARB_viewport_array"));


  glewInfoFunc("glDepthRangeArrayv", glDepthRangeArrayv == NULL);

  glewInfoFunc("glDepthRangeIndexed", glDepthRangeIndexed == NULL);

  glewInfoFunc("glGetDoublei_v", glGetDoublei_v == NULL);

  glewInfoFunc("glGetFloati_v", glGetFloati_v == NULL);

  glewInfoFunc("glScissorArrayv", glScissorArrayv == NULL);

  glewInfoFunc("glScissorIndexed", glScissorIndexed == NULL);

  glewInfoFunc("glScissorIndexedv", glScissorIndexedv == NULL);

  glewInfoFunc("glViewportArrayv", glViewportArrayv == NULL);

  glewInfoFunc("glViewportIndexedf", glViewportIndexedf == NULL);

  glewInfoFunc("glViewportIndexedfv", glViewportIndexedfv == NULL);

}


#endif /* GL_ARB_viewport_array */


#ifdef GL_ARB_window_pos


static void _glewInfo_GL_ARB_window_pos (void)

{

  glewPrintExt("GL_ARB_window_pos", GLEW_ARB_window_pos, glewIsSupported("GL_ARB_window_pos"), glewGetExtension("GL_ARB_window_pos"));


  glewInfoFunc("glWindowPos2dARB", glWindowPos2dARB == NULL);

  glewInfoFunc("glWindowPos2dvARB", glWindowPos2dvARB == NULL);

  glewInfoFunc("glWindowPos2fARB", glWindowPos2fARB == NULL);

  glewInfoFunc("glWindowPos2fvARB", glWindowPos2fvARB == NULL);

  glewInfoFunc("glWindowPos2iARB", glWindowPos2iARB == NULL);

  glewInfoFunc("glWindowPos2ivARB", glWindowPos2ivARB == NULL);

  glewInfoFunc("glWindowPos2sARB", glWindowPos2sARB == NULL);

  glewInfoFunc("glWindowPos2svARB", glWindowPos2svARB == NULL);

  glewInfoFunc("glWindowPos3dARB", glWindowPos3dARB == NULL);

  glewInfoFunc("glWindowPos3dvARB", glWindowPos3dvARB == NULL);

  glewInfoFunc("glWindowPos3fARB", glWindowPos3fARB == NULL);

  glewInfoFunc("glWindowPos3fvARB", glWindowPos3fvARB == NULL);

  glewInfoFunc("glWindowPos3iARB", glWindowPos3iARB == NULL);

  glewInfoFunc("glWindowPos3ivARB", glWindowPos3ivARB == NULL);

  glewInfoFunc("glWindowPos3sARB", glWindowPos3sARB == NULL);

  glewInfoFunc("glWindowPos3svARB", glWindowPos3svARB == NULL);

}


#endif /* GL_ARB_window_pos */


#ifdef GL_ATIX_point_sprites


static void _glewInfo_GL_ATIX_point_sprites (void)

{

  glewPrintExt("GL_ATIX_point_sprites", GLEW_ATIX_point_sprites, glewIsSupported("GL_ATIX_point_sprites"), glewGetExtension("GL_ATIX_point_sprites"));

}


#endif /* GL_ATIX_point_sprites */


#ifdef GL_ATIX_texture_env_combine3


static void _glewInfo_GL_ATIX_texture_env_combine3 (void)

{

  glewPrintExt("GL_ATIX_texture_env_combine3", GLEW_ATIX_texture_env_combine3, glewIsSupported("GL_ATIX_texture_env_combine3"), glewGetExtension("GL_ATIX_texture_env_combine3"));

}


#endif /* GL_ATIX_texture_env_combine3 */


#ifdef GL_ATIX_texture_env_route


static void _glewInfo_GL_ATIX_texture_env_route (void)

{

  glewPrintExt("GL_ATIX_texture_env_route", GLEW_ATIX_texture_env_route, glewIsSupported("GL_ATIX_texture_env_route"), glewGetExtension("GL_ATIX_texture_env_route"));

}


#endif /* GL_ATIX_texture_env_route */


#ifdef GL_ATIX_vertex_shader_output_point_size


static void _glewInfo_GL_ATIX_vertex_shader_output_point_size (void)

{

  glewPrintExt("GL_ATIX_vertex_shader_output_point_size", GLEW_ATIX_vertex_shader_output_point_size, glewIsSupported("GL_ATIX_vertex_shader_output_point_size"), glewGetExtension("GL_ATIX_vertex_shader_output_point_size"));

}


#endif /* GL_ATIX_vertex_shader_output_point_size */


#ifdef GL_ATI_draw_buffers


static void _glewInfo_GL_ATI_draw_buffers (void)

{

  glewPrintExt("GL_ATI_draw_buffers", GLEW_ATI_draw_buffers, glewIsSupported("GL_ATI_draw_buffers"), glewGetExtension("GL_ATI_draw_buffers"));


  glewInfoFunc("glDrawBuffersATI", glDrawBuffersATI == NULL);

}


#endif /* GL_ATI_draw_buffers */


#ifdef GL_ATI_element_array


static void _glewInfo_GL_ATI_element_array (void)

{

  glewPrintExt("GL_ATI_element_array", GLEW_ATI_element_array, glewIsSupported("GL_ATI_element_array"), glewGetExtension("GL_ATI_element_array"));


  glewInfoFunc("glDrawElementArrayATI", glDrawElementArrayATI == NULL);

  glewInfoFunc("glDrawRangeElementArrayATI", glDrawRangeElementArrayATI == NULL);

  glewInfoFunc("glElementPointerATI", glElementPointerATI == NULL);

}


#endif /* GL_ATI_element_array */


#ifdef GL_ATI_envmap_bumpmap


static void _glewInfo_GL_ATI_envmap_bumpmap (void)

{

  glewPrintExt("GL_ATI_envmap_bumpmap", GLEW_ATI_envmap_bumpmap, glewIsSupported("GL_ATI_envmap_bumpmap"), glewGetExtension("GL_ATI_envmap_bumpmap"));


  glewInfoFunc("glGetTexBumpParameterfvATI", glGetTexBumpParameterfvATI == NULL);

  glewInfoFunc("glGetTexBumpParameterivATI", glGetTexBumpParameterivATI == NULL);

  glewInfoFunc("glTexBumpParameterfvATI", glTexBumpParameterfvATI == NULL);

  glewInfoFunc("glTexBumpParameterivATI", glTexBumpParameterivATI == NULL);

}


#endif /* GL_ATI_envmap_bumpmap */


#ifdef GL_ATI_fragment_shader


static void _glewInfo_GL_ATI_fragment_shader (void)

{

  glewPrintExt("GL_ATI_fragment_shader", GLEW_ATI_fragment_shader, glewIsSupported("GL_ATI_fragment_shader"), glewGetExtension("GL_ATI_fragment_shader"));


  glewInfoFunc("glAlphaFragmentOp1ATI", glAlphaFragmentOp1ATI == NULL);

  glewInfoFunc("glAlphaFragmentOp2ATI", glAlphaFragmentOp2ATI == NULL);

  glewInfoFunc("glAlphaFragmentOp3ATI", glAlphaFragmentOp3ATI == NULL);

  glewInfoFunc("glBeginFragmentShaderATI", glBeginFragmentShaderATI == NULL);

  glewInfoFunc("glBindFragmentShaderATI", glBindFragmentShaderATI == NULL);

  glewInfoFunc("glColorFragmentOp1ATI", glColorFragmentOp1ATI == NULL);

  glewInfoFunc("glColorFragmentOp2ATI", glColorFragmentOp2ATI == NULL);

  glewInfoFunc("glColorFragmentOp3ATI", glColorFragmentOp3ATI == NULL);

  glewInfoFunc("glDeleteFragmentShaderATI", glDeleteFragmentShaderATI == NULL);

  glewInfoFunc("glEndFragmentShaderATI", glEndFragmentShaderATI == NULL);

  glewInfoFunc("glGenFragmentShadersATI", glGenFragmentShadersATI == NULL);

  glewInfoFunc("glPassTexCoordATI", glPassTexCoordATI == NULL);

  glewInfoFunc("glSampleMapATI", glSampleMapATI == NULL);

  glewInfoFunc("glSetFragmentShaderConstantATI", glSetFragmentShaderConstantATI == NULL);

}


#endif /* GL_ATI_fragment_shader */


#ifdef GL_ATI_map_object_buffer


static void _glewInfo_GL_ATI_map_object_buffer (void)

{

  glewPrintExt("GL_ATI_map_object_buffer", GLEW_ATI_map_object_buffer, glewIsSupported("GL_ATI_map_object_buffer"), glewGetExtension("GL_ATI_map_object_buffer"));


  glewInfoFunc("glMapObjectBufferATI", glMapObjectBufferATI == NULL);

  glewInfoFunc("glUnmapObjectBufferATI", glUnmapObjectBufferATI == NULL);

}


#endif /* GL_ATI_map_object_buffer */


#ifdef GL_ATI_meminfo


static void _glewInfo_GL_ATI_meminfo (void)

{

  glewPrintExt("GL_ATI_meminfo", GLEW_ATI_meminfo, glewIsSupported("GL_ATI_meminfo"), glewGetExtension("GL_ATI_meminfo"));

}


#endif /* GL_ATI_meminfo */


#ifdef GL_ATI_pn_triangles


static void _glewInfo_GL_ATI_pn_triangles (void)

{

  glewPrintExt("GL_ATI_pn_triangles", GLEW_ATI_pn_triangles, glewIsSupported("GL_ATI_pn_triangles"), glewGetExtension("GL_ATI_pn_triangles"));


  glewInfoFunc("glPNTrianglesfATI", glPNTrianglesfATI == NULL);

  glewInfoFunc("glPNTrianglesiATI", glPNTrianglesiATI == NULL);

}


#endif /* GL_ATI_pn_triangles */


#ifdef GL_ATI_separate_stencil


static void _glewInfo_GL_ATI_separate_stencil (void)

{

  glewPrintExt("GL_ATI_separate_stencil", GLEW_ATI_separate_stencil, glewIsSupported("GL_ATI_separate_stencil"), glewGetExtension("GL_ATI_separate_stencil"));


  glewInfoFunc("glStencilFuncSeparateATI", glStencilFuncSeparateATI == NULL);

  glewInfoFunc("glStencilOpSeparateATI", glStencilOpSeparateATI == NULL);

}


#endif /* GL_ATI_separate_stencil */


#ifdef GL_ATI_shader_texture_lod


static void _glewInfo_GL_ATI_shader_texture_lod (void)

{

  glewPrintExt("GL_ATI_shader_texture_lod", GLEW_ATI_shader_texture_lod, glewIsSupported("GL_ATI_shader_texture_lod"), glewGetExtension("GL_ATI_shader_texture_lod"));

}


#endif /* GL_ATI_shader_texture_lod */


#ifdef GL_ATI_text_fragment_shader


static void _glewInfo_GL_ATI_text_fragment_shader (void)

{

  glewPrintExt("GL_ATI_text_fragment_shader", GLEW_ATI_text_fragment_shader, glewIsSupported("GL_ATI_text_fragment_shader"), glewGetExtension("GL_ATI_text_fragment_shader"));

}


#endif /* GL_ATI_text_fragment_shader */


#ifdef GL_ATI_texture_compression_3dc


static void _glewInfo_GL_ATI_texture_compression_3dc (void)

{

  glewPrintExt("GL_ATI_texture_compression_3dc", GLEW_ATI_texture_compression_3dc, glewIsSupported("GL_ATI_texture_compression_3dc"), glewGetExtension("GL_ATI_texture_compression_3dc"));

}


#endif /* GL_ATI_texture_compression_3dc */


#ifdef GL_ATI_texture_env_combine3


static void _glewInfo_GL_ATI_texture_env_combine3 (void)

{

  glewPrintExt("GL_ATI_texture_env_combine3", GLEW_ATI_texture_env_combine3, glewIsSupported("GL_ATI_texture_env_combine3"), glewGetExtension("GL_ATI_texture_env_combine3"));

}


#endif /* GL_ATI_texture_env_combine3 */


#ifdef GL_ATI_texture_float


static void _glewInfo_GL_ATI_texture_float (void)

{

  glewPrintExt("GL_ATI_texture_float", GLEW_ATI_texture_float, glewIsSupported("GL_ATI_texture_float"), glewGetExtension("GL_ATI_texture_float"));

}


#endif /* GL_ATI_texture_float */


#ifdef GL_ATI_texture_mirror_once


static void _glewInfo_GL_ATI_texture_mirror_once (void)

{

  glewPrintExt("GL_ATI_texture_mirror_once", GLEW_ATI_texture_mirror_once, glewIsSupported("GL_ATI_texture_mirror_once"), glewGetExtension("GL_ATI_texture_mirror_once"));

}


#endif /* GL_ATI_texture_mirror_once */


#ifdef GL_ATI_vertex_array_object


static void _glewInfo_GL_ATI_vertex_array_object (void)

{

  glewPrintExt("GL_ATI_vertex_array_object", GLEW_ATI_vertex_array_object, glewIsSupported("GL_ATI_vertex_array_object"), glewGetExtension("GL_ATI_vertex_array_object"));


  glewInfoFunc("glArrayObjectATI", glArrayObjectATI == NULL);

  glewInfoFunc("glFreeObjectBufferATI", glFreeObjectBufferATI == NULL);

  glewInfoFunc("glGetArrayObjectfvATI", glGetArrayObjectfvATI == NULL);

  glewInfoFunc("glGetArrayObjectivATI", glGetArrayObjectivATI == NULL);

  glewInfoFunc("glGetObjectBufferfvATI", glGetObjectBufferfvATI == NULL);

  glewInfoFunc("glGetObjectBufferivATI", glGetObjectBufferivATI == NULL);

  glewInfoFunc("glGetVariantArrayObjectfvATI", glGetVariantArrayObjectfvATI == NULL);

  glewInfoFunc("glGetVariantArrayObjectivATI", glGetVariantArrayObjectivATI == NULL);

  glewInfoFunc("glIsObjectBufferATI", glIsObjectBufferATI == NULL);

  glewInfoFunc("glNewObjectBufferATI", glNewObjectBufferATI == NULL);

  glewInfoFunc("glUpdateObjectBufferATI", glUpdateObjectBufferATI == NULL);

  glewInfoFunc("glVariantArrayObjectATI", glVariantArrayObjectATI == NULL);

}


#endif /* GL_ATI_vertex_array_object */


#ifdef GL_ATI_vertex_attrib_array_object


static void _glewInfo_GL_ATI_vertex_attrib_array_object (void)

{

  glewPrintExt("GL_ATI_vertex_attrib_array_object", GLEW_ATI_vertex_attrib_array_object, glewIsSupported("GL_ATI_vertex_attrib_array_object"), glewGetExtension("GL_ATI_vertex_attrib_array_object"));


  glewInfoFunc("glGetVertexAttribArrayObjectfvATI", glGetVertexAttribArrayObjectfvATI == NULL);

  glewInfoFunc("glGetVertexAttribArrayObjectivATI", glGetVertexAttribArrayObjectivATI == NULL);

  glewInfoFunc("glVertexAttribArrayObjectATI", glVertexAttribArrayObjectATI == NULL);

}


#endif /* GL_ATI_vertex_attrib_array_object */


#ifdef GL_ATI_vertex_streams


static void _glewInfo_GL_ATI_vertex_streams (void)

{

  glewPrintExt("GL_ATI_vertex_streams", GLEW_ATI_vertex_streams, glewIsSupported("GL_ATI_vertex_streams"), glewGetExtension("GL_ATI_vertex_streams"));


  glewInfoFunc("glClientActiveVertexStreamATI", glClientActiveVertexStreamATI == NULL);

  glewInfoFunc("glNormalStream3bATI", glNormalStream3bATI == NULL);

  glewInfoFunc("glNormalStream3bvATI", glNormalStream3bvATI == NULL);

  glewInfoFunc("glNormalStream3dATI", glNormalStream3dATI == NULL);

  glewInfoFunc("glNormalStream3dvATI", glNormalStream3dvATI == NULL);

  glewInfoFunc("glNormalStream3fATI", glNormalStream3fATI == NULL);

  glewInfoFunc("glNormalStream3fvATI", glNormalStream3fvATI == NULL);

  glewInfoFunc("glNormalStream3iATI", glNormalStream3iATI == NULL);

  glewInfoFunc("glNormalStream3ivATI", glNormalStream3ivATI == NULL);

  glewInfoFunc("glNormalStream3sATI", glNormalStream3sATI == NULL);

  glewInfoFunc("glNormalStream3svATI", glNormalStream3svATI == NULL);

  glewInfoFunc("glVertexBlendEnvfATI", glVertexBlendEnvfATI == NULL);

  glewInfoFunc("glVertexBlendEnviATI", glVertexBlendEnviATI == NULL);

  glewInfoFunc("glVertexStream1dATI", glVertexStream1dATI == NULL);

  glewInfoFunc("glVertexStream1dvATI", glVertexStream1dvATI == NULL);

  glewInfoFunc("glVertexStream1fATI", glVertexStream1fATI == NULL);

  glewInfoFunc("glVertexStream1fvATI", glVertexStream1fvATI == NULL);

  glewInfoFunc("glVertexStream1iATI", glVertexStream1iATI == NULL);

  glewInfoFunc("glVertexStream1ivATI", glVertexStream1ivATI == NULL);

  glewInfoFunc("glVertexStream1sATI", glVertexStream1sATI == NULL);

  glewInfoFunc("glVertexStream1svATI", glVertexStream1svATI == NULL);

  glewInfoFunc("glVertexStream2dATI", glVertexStream2dATI == NULL);

  glewInfoFunc("glVertexStream2dvATI", glVertexStream2dvATI == NULL);

  glewInfoFunc("glVertexStream2fATI", glVertexStream2fATI == NULL);

  glewInfoFunc("glVertexStream2fvATI", glVertexStream2fvATI == NULL);

  glewInfoFunc("glVertexStream2iATI", glVertexStream2iATI == NULL);

  glewInfoFunc("glVertexStream2ivATI", glVertexStream2ivATI == NULL);

  glewInfoFunc("glVertexStream2sATI", glVertexStream2sATI == NULL);

  glewInfoFunc("glVertexStream2svATI", glVertexStream2svATI == NULL);

  glewInfoFunc("glVertexStream3dATI", glVertexStream3dATI == NULL);

  glewInfoFunc("glVertexStream3dvATI", glVertexStream3dvATI == NULL);

  glewInfoFunc("glVertexStream3fATI", glVertexStream3fATI == NULL);

  glewInfoFunc("glVertexStream3fvATI", glVertexStream3fvATI == NULL);

  glewInfoFunc("glVertexStream3iATI", glVertexStream3iATI == NULL);

  glewInfoFunc("glVertexStream3ivATI", glVertexStream3ivATI == NULL);

  glewInfoFunc("glVertexStream3sATI", glVertexStream3sATI == NULL);

  glewInfoFunc("glVertexStream3svATI", glVertexStream3svATI == NULL);

  glewInfoFunc("glVertexStream4dATI", glVertexStream4dATI == NULL);

  glewInfoFunc("glVertexStream4dvATI", glVertexStream4dvATI == NULL);

  glewInfoFunc("glVertexStream4fATI", glVertexStream4fATI == NULL);

  glewInfoFunc("glVertexStream4fvATI", glVertexStream4fvATI == NULL);

  glewInfoFunc("glVertexStream4iATI", glVertexStream4iATI == NULL);

  glewInfoFunc("glVertexStream4ivATI", glVertexStream4ivATI == NULL);

  glewInfoFunc("glVertexStream4sATI", glVertexStream4sATI == NULL);

  glewInfoFunc("glVertexStream4svATI", glVertexStream4svATI == NULL);

}


#endif /* GL_ATI_vertex_streams */


#ifdef GL_EXT_422_pixels


static void _glewInfo_GL_EXT_422_pixels (void)

{

  glewPrintExt("GL_EXT_422_pixels", GLEW_EXT_422_pixels, glewIsSupported("GL_EXT_422_pixels"), glewGetExtension("GL_EXT_422_pixels"));

}


#endif /* GL_EXT_422_pixels */


#ifdef GL_EXT_Cg_shader


static void _glewInfo_GL_EXT_Cg_shader (void)

{

  glewPrintExt("GL_EXT_Cg_shader", GLEW_EXT_Cg_shader, glewIsSupported("GL_EXT_Cg_shader"), glewGetExtension("GL_EXT_Cg_shader"));

}


#endif /* GL_EXT_Cg_shader */


#ifdef GL_EXT_abgr


static void _glewInfo_GL_EXT_abgr (void)

{

  glewPrintExt("GL_EXT_abgr", GLEW_EXT_abgr, glewIsSupported("GL_EXT_abgr"), glewGetExtension("GL_EXT_abgr"));

}


#endif /* GL_EXT_abgr */


#ifdef GL_EXT_bgra


static void _glewInfo_GL_EXT_bgra (void)

{

  glewPrintExt("GL_EXT_bgra", GLEW_EXT_bgra, glewIsSupported("GL_EXT_bgra"), glewGetExtension("GL_EXT_bgra"));

}


#endif /* GL_EXT_bgra */


#ifdef GL_EXT_bindable_uniform


static void _glewInfo_GL_EXT_bindable_uniform (void)

{

  glewPrintExt("GL_EXT_bindable_uniform", GLEW_EXT_bindable_uniform, glewIsSupported("GL_EXT_bindable_uniform"), glewGetExtension("GL_EXT_bindable_uniform"));


  glewInfoFunc("glGetUniformBufferSizeEXT", glGetUniformBufferSizeEXT == NULL);

  glewInfoFunc("glGetUniformOffsetEXT", glGetUniformOffsetEXT == NULL);

  glewInfoFunc("glUniformBufferEXT", glUniformBufferEXT == NULL);

}


#endif /* GL_EXT_bindable_uniform */


#ifdef GL_EXT_blend_color


static void _glewInfo_GL_EXT_blend_color (void)

{

  glewPrintExt("GL_EXT_blend_color", GLEW_EXT_blend_color, glewIsSupported("GL_EXT_blend_color"), glewGetExtension("GL_EXT_blend_color"));


  glewInfoFunc("glBlendColorEXT", glBlendColorEXT == NULL);

}


#endif /* GL_EXT_blend_color */


#ifdef GL_EXT_blend_equation_separate


static void _glewInfo_GL_EXT_blend_equation_separate (void)

{

  glewPrintExt("GL_EXT_blend_equation_separate", GLEW_EXT_blend_equation_separate, glewIsSupported("GL_EXT_blend_equation_separate"), glewGetExtension("GL_EXT_blend_equation_separate"));


  glewInfoFunc("glBlendEquationSeparateEXT", glBlendEquationSeparateEXT == NULL);

}


#endif /* GL_EXT_blend_equation_separate */


#ifdef GL_EXT_blend_func_separate


static void _glewInfo_GL_EXT_blend_func_separate (void)

{

  glewPrintExt("GL_EXT_blend_func_separate", GLEW_EXT_blend_func_separate, glewIsSupported("GL_EXT_blend_func_separate"), glewGetExtension("GL_EXT_blend_func_separate"));


  glewInfoFunc("glBlendFuncSeparateEXT", glBlendFuncSeparateEXT == NULL);

}


#endif /* GL_EXT_blend_func_separate */


#ifdef GL_EXT_blend_logic_op


static void _glewInfo_GL_EXT_blend_logic_op (void)

{

  glewPrintExt("GL_EXT_blend_logic_op", GLEW_EXT_blend_logic_op, glewIsSupported("GL_EXT_blend_logic_op"), glewGetExtension("GL_EXT_blend_logic_op"));

}


#endif /* GL_EXT_blend_logic_op */


#ifdef GL_EXT_blend_minmax


static void _glewInfo_GL_EXT_blend_minmax (void)

{

  glewPrintExt("GL_EXT_blend_minmax", GLEW_EXT_blend_minmax, glewIsSupported("GL_EXT_blend_minmax"), glewGetExtension("GL_EXT_blend_minmax"));


  glewInfoFunc("glBlendEquationEXT", glBlendEquationEXT == NULL);

}


#endif /* GL_EXT_blend_minmax */


#ifdef GL_EXT_blend_subtract


static void _glewInfo_GL_EXT_blend_subtract (void)

{

  glewPrintExt("GL_EXT_blend_subtract", GLEW_EXT_blend_subtract, glewIsSupported("GL_EXT_blend_subtract"), glewGetExtension("GL_EXT_blend_subtract"));

}


#endif /* GL_EXT_blend_subtract */


#ifdef GL_EXT_clip_volume_hint


static void _glewInfo_GL_EXT_clip_volume_hint (void)

{

  glewPrintExt("GL_EXT_clip_volume_hint", GLEW_EXT_clip_volume_hint, glewIsSupported("GL_EXT_clip_volume_hint"), glewGetExtension("GL_EXT_clip_volume_hint"));

}


#endif /* GL_EXT_clip_volume_hint */


#ifdef GL_EXT_cmyka


static void _glewInfo_GL_EXT_cmyka (void)

{

  glewPrintExt("GL_EXT_cmyka", GLEW_EXT_cmyka, glewIsSupported("GL_EXT_cmyka"), glewGetExtension("GL_EXT_cmyka"));

}


#endif /* GL_EXT_cmyka */


#ifdef GL_EXT_color_subtable


static void _glewInfo_GL_EXT_color_subtable (void)

{

  glewPrintExt("GL_EXT_color_subtable", GLEW_EXT_color_subtable, glewIsSupported("GL_EXT_color_subtable"), glewGetExtension("GL_EXT_color_subtable"));


  glewInfoFunc("glColorSubTableEXT", glColorSubTableEXT == NULL);

  glewInfoFunc("glCopyColorSubTableEXT", glCopyColorSubTableEXT == NULL);

}


#endif /* GL_EXT_color_subtable */


#ifdef GL_EXT_compiled_vertex_array


static void _glewInfo_GL_EXT_compiled_vertex_array (void)

{

  glewPrintExt("GL_EXT_compiled_vertex_array", GLEW_EXT_compiled_vertex_array, glewIsSupported("GL_EXT_compiled_vertex_array"), glewGetExtension("GL_EXT_compiled_vertex_array"));


  glewInfoFunc("glLockArraysEXT", glLockArraysEXT == NULL);

  glewInfoFunc("glUnlockArraysEXT", glUnlockArraysEXT == NULL);

}


#endif /* GL_EXT_compiled_vertex_array */


#ifdef GL_EXT_convolution


static void _glewInfo_GL_EXT_convolution (void)

{

  glewPrintExt("GL_EXT_convolution", GLEW_EXT_convolution, glewIsSupported("GL_EXT_convolution"), glewGetExtension("GL_EXT_convolution"));


  glewInfoFunc("glConvolutionFilter1DEXT", glConvolutionFilter1DEXT == NULL);

  glewInfoFunc("glConvolutionFilter2DEXT", glConvolutionFilter2DEXT == NULL);

  glewInfoFunc("glConvolutionParameterfEXT", glConvolutionParameterfEXT == NULL);

  glewInfoFunc("glConvolutionParameterfvEXT", glConvolutionParameterfvEXT == NULL);

  glewInfoFunc("glConvolutionParameteriEXT", glConvolutionParameteriEXT == NULL);

  glewInfoFunc("glConvolutionParameterivEXT", glConvolutionParameterivEXT == NULL);

  glewInfoFunc("glCopyConvolutionFilter1DEXT", glCopyConvolutionFilter1DEXT == NULL);

  glewInfoFunc("glCopyConvolutionFilter2DEXT", glCopyConvolutionFilter2DEXT == NULL);

  glewInfoFunc("glGetConvolutionFilterEXT", glGetConvolutionFilterEXT == NULL);

  glewInfoFunc("glGetConvolutionParameterfvEXT", glGetConvolutionParameterfvEXT == NULL);

  glewInfoFunc("glGetConvolutionParameterivEXT", glGetConvolutionParameterivEXT == NULL);

  glewInfoFunc("glGetSeparableFilterEXT", glGetSeparableFilterEXT == NULL);

  glewInfoFunc("glSeparableFilter2DEXT", glSeparableFilter2DEXT == NULL);

}


#endif /* GL_EXT_convolution */


#ifdef GL_EXT_coordinate_frame


static void _glewInfo_GL_EXT_coordinate_frame (void)

{

  glewPrintExt("GL_EXT_coordinate_frame", GLEW_EXT_coordinate_frame, glewIsSupported("GL_EXT_coordinate_frame"), glewGetExtension("GL_EXT_coordinate_frame"));


  glewInfoFunc("glBinormalPointerEXT", glBinormalPointerEXT == NULL);

  glewInfoFunc("glTangentPointerEXT", glTangentPointerEXT == NULL);

}


#endif /* GL_EXT_coordinate_frame */


#ifdef GL_EXT_copy_texture


static void _glewInfo_GL_EXT_copy_texture (void)

{

  glewPrintExt("GL_EXT_copy_texture", GLEW_EXT_copy_texture, glewIsSupported("GL_EXT_copy_texture"), glewGetExtension("GL_EXT_copy_texture"));


  glewInfoFunc("glCopyTexImage1DEXT", glCopyTexImage1DEXT == NULL);

  glewInfoFunc("glCopyTexImage2DEXT", glCopyTexImage2DEXT == NULL);

  glewInfoFunc("glCopyTexSubImage1DEXT", glCopyTexSubImage1DEXT == NULL);

  glewInfoFunc("glCopyTexSubImage2DEXT", glCopyTexSubImage2DEXT == NULL);

  glewInfoFunc("glCopyTexSubImage3DEXT", glCopyTexSubImage3DEXT == NULL);

}


#endif /* GL_EXT_copy_texture */


#ifdef GL_EXT_cull_vertex


static void _glewInfo_GL_EXT_cull_vertex (void)

{

  glewPrintExt("GL_EXT_cull_vertex", GLEW_EXT_cull_vertex, glewIsSupported("GL_EXT_cull_vertex"), glewGetExtension("GL_EXT_cull_vertex"));


  glewInfoFunc("glCullParameterdvEXT", glCullParameterdvEXT == NULL);

  glewInfoFunc("glCullParameterfvEXT", glCullParameterfvEXT == NULL);

}


#endif /* GL_EXT_cull_vertex */


#ifdef GL_EXT_debug_marker


static void _glewInfo_GL_EXT_debug_marker (void)

{

  glewPrintExt("GL_EXT_debug_marker", GLEW_EXT_debug_marker, glewIsSupported("GL_EXT_debug_marker"), glewGetExtension("GL_EXT_debug_marker"));


  glewInfoFunc("glInsertEventMarkerEXT", glInsertEventMarkerEXT == NULL);

  glewInfoFunc("glPopGroupMarkerEXT", glPopGroupMarkerEXT == NULL);

  glewInfoFunc("glPushGroupMarkerEXT", glPushGroupMarkerEXT == NULL);

}


#endif /* GL_EXT_debug_marker */


#ifdef GL_EXT_depth_bounds_test


static void _glewInfo_GL_EXT_depth_bounds_test (void)

{

  glewPrintExt("GL_EXT_depth_bounds_test", GLEW_EXT_depth_bounds_test, glewIsSupported("GL_EXT_depth_bounds_test"), glewGetExtension("GL_EXT_depth_bounds_test"));


  glewInfoFunc("glDepthBoundsEXT", glDepthBoundsEXT == NULL);

}


#endif /* GL_EXT_depth_bounds_test */


#ifdef GL_EXT_direct_state_access


static void _glewInfo_GL_EXT_direct_state_access (void)

{

  glewPrintExt("GL_EXT_direct_state_access", GLEW_EXT_direct_state_access, glewIsSupported("GL_EXT_direct_state_access"), glewGetExtension("GL_EXT_direct_state_access"));


  glewInfoFunc("glBindMultiTextureEXT", glBindMultiTextureEXT == NULL);

  glewInfoFunc("glCheckNamedFramebufferStatusEXT", glCheckNamedFramebufferStatusEXT == NULL);

  glewInfoFunc("glClientAttribDefaultEXT", glClientAttribDefaultEXT == NULL);

  glewInfoFunc("glCompressedMultiTexImage1DEXT", glCompressedMultiTexImage1DEXT == NULL);

  glewInfoFunc("glCompressedMultiTexImage2DEXT", glCompressedMultiTexImage2DEXT == NULL);

  glewInfoFunc("glCompressedMultiTexImage3DEXT", glCompressedMultiTexImage3DEXT == NULL);

  glewInfoFunc("glCompressedMultiTexSubImage1DEXT", glCompressedMultiTexSubImage1DEXT == NULL);

  glewInfoFunc("glCompressedMultiTexSubImage2DEXT", glCompressedMultiTexSubImage2DEXT == NULL);

  glewInfoFunc("glCompressedMultiTexSubImage3DEXT", glCompressedMultiTexSubImage3DEXT == NULL);

  glewInfoFunc("glCompressedTextureImage1DEXT", glCompressedTextureImage1DEXT == NULL);

  glewInfoFunc("glCompressedTextureImage2DEXT", glCompressedTextureImage2DEXT == NULL);

  glewInfoFunc("glCompressedTextureImage3DEXT", glCompressedTextureImage3DEXT == NULL);

  glewInfoFunc("glCompressedTextureSubImage1DEXT", glCompressedTextureSubImage1DEXT == NULL);

  glewInfoFunc("glCompressedTextureSubImage2DEXT", glCompressedTextureSubImage2DEXT == NULL);

  glewInfoFunc("glCompressedTextureSubImage3DEXT", glCompressedTextureSubImage3DEXT == NULL);

  glewInfoFunc("glCopyMultiTexImage1DEXT", glCopyMultiTexImage1DEXT == NULL);

  glewInfoFunc("glCopyMultiTexImage2DEXT", glCopyMultiTexImage2DEXT == NULL);

  glewInfoFunc("glCopyMultiTexSubImage1DEXT", glCopyMultiTexSubImage1DEXT == NULL);

  glewInfoFunc("glCopyMultiTexSubImage2DEXT", glCopyMultiTexSubImage2DEXT == NULL);

  glewInfoFunc("glCopyMultiTexSubImage3DEXT", glCopyMultiTexSubImage3DEXT == NULL);

  glewInfoFunc("glCopyTextureImage1DEXT", glCopyTextureImage1DEXT == NULL);

  glewInfoFunc("glCopyTextureImage2DEXT", glCopyTextureImage2DEXT == NULL);

  glewInfoFunc("glCopyTextureSubImage1DEXT", glCopyTextureSubImage1DEXT == NULL);

  glewInfoFunc("glCopyTextureSubImage2DEXT", glCopyTextureSubImage2DEXT == NULL);

  glewInfoFunc("glCopyTextureSubImage3DEXT", glCopyTextureSubImage3DEXT == NULL);

  glewInfoFunc("glDisableClientStateIndexedEXT", glDisableClientStateIndexedEXT == NULL);

  glewInfoFunc("glDisableClientStateiEXT", glDisableClientStateiEXT == NULL);

  glewInfoFunc("glDisableVertexArrayAttribEXT", glDisableVertexArrayAttribEXT == NULL);

  glewInfoFunc("glDisableVertexArrayEXT", glDisableVertexArrayEXT == NULL);

  glewInfoFunc("glEnableClientStateIndexedEXT", glEnableClientStateIndexedEXT == NULL);

  glewInfoFunc("glEnableClientStateiEXT", glEnableClientStateiEXT == NULL);

  glewInfoFunc("glEnableVertexArrayAttribEXT", glEnableVertexArrayAttribEXT == NULL);

  glewInfoFunc("glEnableVertexArrayEXT", glEnableVertexArrayEXT == NULL);

  glewInfoFunc("glFlushMappedNamedBufferRangeEXT", glFlushMappedNamedBufferRangeEXT == NULL);

  glewInfoFunc("glFramebufferDrawBufferEXT", glFramebufferDrawBufferEXT == NULL);

  glewInfoFunc("glFramebufferDrawBuffersEXT", glFramebufferDrawBuffersEXT == NULL);

  glewInfoFunc("glFramebufferReadBufferEXT", glFramebufferReadBufferEXT == NULL);

  glewInfoFunc("glGenerateMultiTexMipmapEXT", glGenerateMultiTexMipmapEXT == NULL);

  glewInfoFunc("glGenerateTextureMipmapEXT", glGenerateTextureMipmapEXT == NULL);

  glewInfoFunc("glGetCompressedMultiTexImageEXT", glGetCompressedMultiTexImageEXT == NULL);

  glewInfoFunc("glGetCompressedTextureImageEXT", glGetCompressedTextureImageEXT == NULL);

  glewInfoFunc("glGetDoubleIndexedvEXT", glGetDoubleIndexedvEXT == NULL);

  glewInfoFunc("glGetDoublei_vEXT", glGetDoublei_vEXT == NULL);

  glewInfoFunc("glGetFloatIndexedvEXT", glGetFloatIndexedvEXT == NULL);

  glewInfoFunc("glGetFloati_vEXT", glGetFloati_vEXT == NULL);

  glewInfoFunc("glGetFramebufferParameterivEXT", glGetFramebufferParameterivEXT == NULL);

  glewInfoFunc("glGetMultiTexEnvfvEXT", glGetMultiTexEnvfvEXT == NULL);

  glewInfoFunc("glGetMultiTexEnvivEXT", glGetMultiTexEnvivEXT == NULL);

  glewInfoFunc("glGetMultiTexGendvEXT", glGetMultiTexGendvEXT == NULL);

  glewInfoFunc("glGetMultiTexGenfvEXT", glGetMultiTexGenfvEXT == NULL);

  glewInfoFunc("glGetMultiTexGenivEXT", glGetMultiTexGenivEXT == NULL);

  glewInfoFunc("glGetMultiTexImageEXT", glGetMultiTexImageEXT == NULL);

  glewInfoFunc("glGetMultiTexLevelParameterfvEXT", glGetMultiTexLevelParameterfvEXT == NULL);

  glewInfoFunc("glGetMultiTexLevelParameterivEXT", glGetMultiTexLevelParameterivEXT == NULL);

  glewInfoFunc("glGetMultiTexParameterIivEXT", glGetMultiTexParameterIivEXT == NULL);

  glewInfoFunc("glGetMultiTexParameterIuivEXT", glGetMultiTexParameterIuivEXT == NULL);

  glewInfoFunc("glGetMultiTexParameterfvEXT", glGetMultiTexParameterfvEXT == NULL);

  glewInfoFunc("glGetMultiTexParameterivEXT", glGetMultiTexParameterivEXT == NULL);

  glewInfoFunc("glGetNamedBufferParameterivEXT", glGetNamedBufferParameterivEXT == NULL);

  glewInfoFunc("glGetNamedBufferPointervEXT", glGetNamedBufferPointervEXT == NULL);

  glewInfoFunc("glGetNamedBufferSubDataEXT", glGetNamedBufferSubDataEXT == NULL);

  glewInfoFunc("glGetNamedFramebufferAttachmentParameterivEXT", glGetNamedFramebufferAttachmentParameterivEXT == NULL);

  glewInfoFunc("glGetNamedProgramLocalParameterIivEXT", glGetNamedProgramLocalParameterIivEXT == NULL);

  glewInfoFunc("glGetNamedProgramLocalParameterIuivEXT", glGetNamedProgramLocalParameterIuivEXT == NULL);

  glewInfoFunc("glGetNamedProgramLocalParameterdvEXT", glGetNamedProgramLocalParameterdvEXT == NULL);

  glewInfoFunc("glGetNamedProgramLocalParameterfvEXT", glGetNamedProgramLocalParameterfvEXT == NULL);

  glewInfoFunc("glGetNamedProgramStringEXT", glGetNamedProgramStringEXT == NULL);

  glewInfoFunc("glGetNamedProgramivEXT", glGetNamedProgramivEXT == NULL);

  glewInfoFunc("glGetNamedRenderbufferParameterivEXT", glGetNamedRenderbufferParameterivEXT == NULL);

  glewInfoFunc("glGetPointerIndexedvEXT", glGetPointerIndexedvEXT == NULL);

  glewInfoFunc("glGetPointeri_vEXT", glGetPointeri_vEXT == NULL);

  glewInfoFunc("glGetTextureImageEXT", glGetTextureImageEXT == NULL);

  glewInfoFunc("glGetTextureLevelParameterfvEXT", glGetTextureLevelParameterfvEXT == NULL);

  glewInfoFunc("glGetTextureLevelParameterivEXT", glGetTextureLevelParameterivEXT == NULL);

  glewInfoFunc("glGetTextureParameterIivEXT", glGetTextureParameterIivEXT == NULL);

  glewInfoFunc("glGetTextureParameterIuivEXT", glGetTextureParameterIuivEXT == NULL);

  glewInfoFunc("glGetTextureParameterfvEXT", glGetTextureParameterfvEXT == NULL);

  glewInfoFunc("glGetTextureParameterivEXT", glGetTextureParameterivEXT == NULL);

  glewInfoFunc("glGetVertexArrayIntegeri_vEXT", glGetVertexArrayIntegeri_vEXT == NULL);

  glewInfoFunc("glGetVertexArrayIntegervEXT", glGetVertexArrayIntegervEXT == NULL);

  glewInfoFunc("glGetVertexArrayPointeri_vEXT", glGetVertexArrayPointeri_vEXT == NULL);

  glewInfoFunc("glGetVertexArrayPointervEXT", glGetVertexArrayPointervEXT == NULL);

  glewInfoFunc("glMapNamedBufferEXT", glMapNamedBufferEXT == NULL);

  glewInfoFunc("glMapNamedBufferRangeEXT", glMapNamedBufferRangeEXT == NULL);

  glewInfoFunc("glMatrixFrustumEXT", glMatrixFrustumEXT == NULL);

  glewInfoFunc("glMatrixLoadIdentityEXT", glMatrixLoadIdentityEXT == NULL);

  glewInfoFunc("glMatrixLoadTransposedEXT", glMatrixLoadTransposedEXT == NULL);

  glewInfoFunc("glMatrixLoadTransposefEXT", glMatrixLoadTransposefEXT == NULL);

  glewInfoFunc("glMatrixLoaddEXT", glMatrixLoaddEXT == NULL);

  glewInfoFunc("glMatrixLoadfEXT", glMatrixLoadfEXT == NULL);

  glewInfoFunc("glMatrixMultTransposedEXT", glMatrixMultTransposedEXT == NULL);

  glewInfoFunc("glMatrixMultTransposefEXT", glMatrixMultTransposefEXT == NULL);

  glewInfoFunc("glMatrixMultdEXT", glMatrixMultdEXT == NULL);

  glewInfoFunc("glMatrixMultfEXT", glMatrixMultfEXT == NULL);

  glewInfoFunc("glMatrixOrthoEXT", glMatrixOrthoEXT == NULL);

  glewInfoFunc("glMatrixPopEXT", glMatrixPopEXT == NULL);

  glewInfoFunc("glMatrixPushEXT", glMatrixPushEXT == NULL);

  glewInfoFunc("glMatrixRotatedEXT", glMatrixRotatedEXT == NULL);

  glewInfoFunc("glMatrixRotatefEXT", glMatrixRotatefEXT == NULL);

  glewInfoFunc("glMatrixScaledEXT", glMatrixScaledEXT == NULL);

  glewInfoFunc("glMatrixScalefEXT", glMatrixScalefEXT == NULL);

  glewInfoFunc("glMatrixTranslatedEXT", glMatrixTranslatedEXT == NULL);

  glewInfoFunc("glMatrixTranslatefEXT", glMatrixTranslatefEXT == NULL);

  glewInfoFunc("glMultiTexBufferEXT", glMultiTexBufferEXT == NULL);

  glewInfoFunc("glMultiTexCoordPointerEXT", glMultiTexCoordPointerEXT == NULL);

  glewInfoFunc("glMultiTexEnvfEXT", glMultiTexEnvfEXT == NULL);

  glewInfoFunc("glMultiTexEnvfvEXT", glMultiTexEnvfvEXT == NULL);

  glewInfoFunc("glMultiTexEnviEXT", glMultiTexEnviEXT == NULL);

  glewInfoFunc("glMultiTexEnvivEXT", glMultiTexEnvivEXT == NULL);

  glewInfoFunc("glMultiTexGendEXT", glMultiTexGendEXT == NULL);

  glewInfoFunc("glMultiTexGendvEXT", glMultiTexGendvEXT == NULL);

  glewInfoFunc("glMultiTexGenfEXT", glMultiTexGenfEXT == NULL);

  glewInfoFunc("glMultiTexGenfvEXT", glMultiTexGenfvEXT == NULL);

  glewInfoFunc("glMultiTexGeniEXT", glMultiTexGeniEXT == NULL);

  glewInfoFunc("glMultiTexGenivEXT", glMultiTexGenivEXT == NULL);

  glewInfoFunc("glMultiTexImage1DEXT", glMultiTexImage1DEXT == NULL);

  glewInfoFunc("glMultiTexImage2DEXT", glMultiTexImage2DEXT == NULL);

  glewInfoFunc("glMultiTexImage3DEXT", glMultiTexImage3DEXT == NULL);

  glewInfoFunc("glMultiTexParameterIivEXT", glMultiTexParameterIivEXT == NULL);

  glewInfoFunc("glMultiTexParameterIuivEXT", glMultiTexParameterIuivEXT == NULL);

  glewInfoFunc("glMultiTexParameterfEXT", glMultiTexParameterfEXT == NULL);

  glewInfoFunc("glMultiTexParameterfvEXT", glMultiTexParameterfvEXT == NULL);

  glewInfoFunc("glMultiTexParameteriEXT", glMultiTexParameteriEXT == NULL);

  glewInfoFunc("glMultiTexParameterivEXT", glMultiTexParameterivEXT == NULL);

  glewInfoFunc("glMultiTexRenderbufferEXT", glMultiTexRenderbufferEXT == NULL);

  glewInfoFunc("glMultiTexSubImage1DEXT", glMultiTexSubImage1DEXT == NULL);

  glewInfoFunc("glMultiTexSubImage2DEXT", glMultiTexSubImage2DEXT == NULL);

  glewInfoFunc("glMultiTexSubImage3DEXT", glMultiTexSubImage3DEXT == NULL);

  glewInfoFunc("glNamedBufferDataEXT", glNamedBufferDataEXT == NULL);

  glewInfoFunc("glNamedBufferSubDataEXT",