GLee.c

void __stdcall _Lazy_glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)  {if (GLeeInit()) glFramebufferTexture1D(target, attachment, textarget, texture, level);}
void __stdcall _Lazy_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)  {if (GLeeInit()) glFramebufferTexture2D(target, attachment, textarget, texture, level);}
void __stdcall _Lazy_glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)  {if (GLeeInit()) glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);}
void __stdcall _Lazy_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)  {if (GLeeInit()) glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);}
void __stdcall _Lazy_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint * params)  {if (GLeeInit()) glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);}
void __stdcall _Lazy_glGenerateMipmap(GLenum target)                                      {if (GLeeInit()) glGenerateMipmap(target);}
void __stdcall _Lazy_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)  {if (GLeeInit()) glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);}
void __stdcall _Lazy_glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)  {if (GLeeInit()) glRenderbufferStorageMultisample(target, samples, internalformat, width, height);}
void __stdcall _Lazy_glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)  {if (GLeeInit()) glFramebufferTextureLayer(target, attachment, texture, level, layer);}
PFNGLISRENDERBUFFERPROC pglIsRenderbuffer=_Lazy_glIsRenderbuffer;
PFNGLBINDRENDERBUFFERPROC pglBindRenderbuffer=_Lazy_glBindRenderbuffer;
PFNGLDELETERENDERBUFFERSPROC pglDeleteRenderbuffers=_Lazy_glDeleteRenderbuffers;
PFNGLGENRENDERBUFFERSPROC pglGenRenderbuffers=_Lazy_glGenRenderbuffers;
PFNGLRENDERBUFFERSTORAGEPROC pglRenderbufferStorage=_Lazy_glRenderbufferStorage;
PFNGLGETRENDERBUFFERPARAMETERIVPROC pglGetRenderbufferParameteriv=_Lazy_glGetRenderbufferParameteriv;
PFNGLISFRAMEBUFFERPROC pglIsFramebuffer=_Lazy_glIsFramebuffer;
PFNGLBINDFRAMEBUFFERPROC pglBindFramebuffer=_Lazy_glBindFramebuffer;
PFNGLDELETEFRAMEBUFFERSPROC pglDeleteFramebuffers=_Lazy_glDeleteFramebuffers;
PFNGLGENFRAMEBUFFERSPROC pglGenFramebuffers=_Lazy_glGenFramebuffers;
PFNGLCHECKFRAMEBUFFERSTATUSPROC pglCheckFramebufferStatus=_Lazy_glCheckFramebufferStatus;
PFNGLFRAMEBUFFERTEXTURE1DPROC pglFramebufferTexture1D=_Lazy_glFramebufferTexture1D;
PFNGLFRAMEBUFFERTEXTURE2DPROC pglFramebufferTexture2D=_Lazy_glFramebufferTexture2D;
PFNGLFRAMEBUFFERTEXTURE3DPROC pglFramebufferTexture3D=_Lazy_glFramebufferTexture3D;
PFNGLFRAMEBUFFERRENDERBUFFERPROC pglFramebufferRenderbuffer=_Lazy_glFramebufferRenderbuffer;
PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC pglGetFramebufferAttachmentParameteriv=_Lazy_glGetFramebufferAttachmentParameteriv;
PFNGLGENERATEMIPMAPPROC pglGenerateMipmap=_Lazy_glGenerateMipmap;
PFNGLBLITFRAMEBUFFERPROC pglBlitFramebuffer=_Lazy_glBlitFramebuffer;
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC pglRenderbufferStorageMultisample=_Lazy_glRenderbufferStorageMultisample;
PFNGLFRAMEBUFFERTEXTURELAYERPROC pglFramebufferTextureLayer=_Lazy_glFramebufferTextureLayer;
#endif 

/* GL_ARB_framebuffer_sRGB */

#ifdef __GLEE_GL_ARB_framebuffer_sRGB
#endif 

/* GL_ARB_geometry_shader4 */

#ifdef __GLEE_GL_ARB_geometry_shader4
void __stdcall _Lazy_glProgramParameteriARB(GLuint program, GLenum pname, GLint value)    {if (GLeeInit()) glProgramParameteriARB(program, pname, value);}
void __stdcall _Lazy_glFramebufferTextureARB(GLenum target, GLenum attachment, GLuint texture, GLint level)  {if (GLeeInit()) glFramebufferTextureARB(target, attachment, texture, level);}
void __stdcall _Lazy_glFramebufferTextureLayerARB(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)  {if (GLeeInit()) glFramebufferTextureLayerARB(target, attachment, texture, level, layer);}
void __stdcall _Lazy_glFramebufferTextureFaceARB(GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face)  {if (GLeeInit()) glFramebufferTextureFaceARB(target, attachment, texture, level, face);}
PFNGLPROGRAMPARAMETERIARBPROC pglProgramParameteriARB=_Lazy_glProgramParameteriARB;
PFNGLFRAMEBUFFERTEXTUREARBPROC pglFramebufferTextureARB=_Lazy_glFramebufferTextureARB;
PFNGLFRAMEBUFFERTEXTURELAYERARBPROC pglFramebufferTextureLayerARB=_Lazy_glFramebufferTextureLayerARB;
PFNGLFRAMEBUFFERTEXTUREFACEARBPROC pglFramebufferTextureFaceARB=_Lazy_glFramebufferTextureFaceARB;
#endif 

/* GL_ARB_half_float_vertex */

#ifdef __GLEE_GL_ARB_half_float_vertex
#endif 

/* GL_ARB_instanced_arrays */

#ifdef __GLEE_GL_ARB_instanced_arrays
void __stdcall _Lazy_glVertexAttribDivisor(GLuint index, GLuint divisor)                  {if (GLeeInit()) glVertexAttribDivisor(index, divisor);}
PFNGLVERTEXATTRIBDIVISORPROC pglVertexAttribDivisor=_Lazy_glVertexAttribDivisor;
#endif 

/* GL_ARB_map_buffer_range */

#ifdef __GLEE_GL_ARB_map_buffer_range
void __stdcall _Lazy_glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)  {if (GLeeInit()) glMapBufferRange(target, offset, length, access);}
void __stdcall _Lazy_glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)  {if (GLeeInit()) glFlushMappedBufferRange(target, offset, length);}
PFNGLMAPBUFFERRANGEPROC pglMapBufferRange=_Lazy_glMapBufferRange;
PFNGLFLUSHMAPPEDBUFFERRANGEPROC pglFlushMappedBufferRange=_Lazy_glFlushMappedBufferRange;
#endif 

/* GL_ARB_texture_buffer_object */

#ifdef __GLEE_GL_ARB_texture_buffer_object
void __stdcall _Lazy_glTexBufferARB(GLenum target, GLenum internalformat, GLuint buffer)  {if (GLeeInit()) glTexBufferARB(target, internalformat, buffer);}
PFNGLTEXBUFFERARBPROC pglTexBufferARB=_Lazy_glTexBufferARB;
#endif 

/* GL_ARB_texture_compression_rgtc */

#ifdef __GLEE_GL_ARB_texture_compression_rgtc
#endif 

/* GL_ARB_texture_rg */

#ifdef __GLEE_GL_ARB_texture_rg
#endif 

/* GL_ARB_vertex_array_object */

#ifdef __GLEE_GL_ARB_vertex_array_object
void __stdcall _Lazy_glBindVertexArray(GLuint array)                                      {if (GLeeInit()) glBindVertexArray(array);}
void __stdcall _Lazy_glDeleteVertexArrays(GLsizei n, const GLuint * arrays)               {if (GLeeInit()) glDeleteVertexArrays(n, arrays);}
void __stdcall _Lazy_glGenVertexArrays(GLsizei n, GLuint * arrays)                        {if (GLeeInit()) glGenVertexArrays(n, arrays);}
GLboolean __stdcall _Lazy_glIsVertexArray(GLuint array)                                   {if (GLeeInit()) return glIsVertexArray(array); return (GLboolean)0;}
PFNGLBINDVERTEXARRAYPROC pglBindVertexArray=_Lazy_glBindVertexArray;
PFNGLDELETEVERTEXARRAYSPROC pglDeleteVertexArrays=_Lazy_glDeleteVertexArrays;
PFNGLGENVERTEXARRAYSPROC pglGenVertexArrays=_Lazy_glGenVertexArrays;
PFNGLISVERTEXARRAYPROC pglIsVertexArray=_Lazy_glIsVertexArray;
#endif 

/* GL_EXT_abgr */

#ifdef __GLEE_GL_EXT_abgr
#endif 

/* GL_EXT_blend_color */

#ifdef __GLEE_GL_EXT_blend_color
void __stdcall _Lazy_glBlendColorEXT(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)  {if (GLeeInit()) glBlendColorEXT(red, green, blue, alpha);}
PFNGLBLENDCOLOREXTPROC pglBlendColorEXT=_Lazy_glBlendColorEXT;
#endif 

/* GL_EXT_polygon_offset */

#ifdef __GLEE_GL_EXT_polygon_offset
void __stdcall _Lazy_glPolygonOffsetEXT(GLfloat factor, GLfloat bias)                     {if (GLeeInit()) glPolygonOffsetEXT(factor, bias);}
PFNGLPOLYGONOFFSETEXTPROC pglPolygonOffsetEXT=_Lazy_glPolygonOffsetEXT;
#endif 

/* GL_EXT_texture */

#ifdef __GLEE_GL_EXT_texture
#endif 

/* GL_EXT_texture3D */

#ifdef __GLEE_GL_EXT_texture3D
void __stdcall _Lazy_glTexImage3DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glTexImage3DEXT(target, level, internalformat, width, height, depth, border, format, type, pixels);}
void __stdcall _Lazy_glTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glTexSubImage3DEXT(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);}
PFNGLTEXIMAGE3DEXTPROC pglTexImage3DEXT=_Lazy_glTexImage3DEXT;
PFNGLTEXSUBIMAGE3DEXTPROC pglTexSubImage3DEXT=_Lazy_glTexSubImage3DEXT;
#endif 

/* GL_SGIS_texture_filter4 */

#ifdef __GLEE_GL_SGIS_texture_filter4
void __stdcall _Lazy_glGetTexFilterFuncSGIS(GLenum target, GLenum filter, GLfloat * weights)  {if (GLeeInit()) glGetTexFilterFuncSGIS(target, filter, weights);}
void __stdcall _Lazy_glTexFilterFuncSGIS(GLenum target, GLenum filter, GLsizei n, const GLfloat * weights)  {if (GLeeInit()) glTexFilterFuncSGIS(target, filter, n, weights);}
PFNGLGETTEXFILTERFUNCSGISPROC pglGetTexFilterFuncSGIS=_Lazy_glGetTexFilterFuncSGIS;
PFNGLTEXFILTERFUNCSGISPROC pglTexFilterFuncSGIS=_Lazy_glTexFilterFuncSGIS;
#endif 

/* GL_EXT_subtexture */

#ifdef __GLEE_GL_EXT_subtexture
void __stdcall _Lazy_glTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glTexSubImage1DEXT(target, level, xoffset, width, format, type, pixels);}
void __stdcall _Lazy_glTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glTexSubImage2DEXT(target, level, xoffset, yoffset, width, height, format, type, pixels);}
PFNGLTEXSUBIMAGE1DEXTPROC pglTexSubImage1DEXT=_Lazy_glTexSubImage1DEXT;
PFNGLTEXSUBIMAGE2DEXTPROC pglTexSubImage2DEXT=_Lazy_glTexSubImage2DEXT;
#endif 

/* GL_EXT_copy_texture */

#ifdef __GLEE_GL_EXT_copy_texture
void __stdcall _Lazy_glCopyTexImage1DEXT(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)  {if (GLeeInit()) glCopyTexImage1DEXT(target, level, internalformat, x, y, width, border);}
void __stdcall _Lazy_glCopyTexImage2DEXT(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)  {if (GLeeInit()) glCopyTexImage2DEXT(target, level, internalformat, x, y, width, height, border);}
void __stdcall _Lazy_glCopyTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)  {if (GLeeInit()) glCopyTexSubImage1DEXT(target, level, xoffset, x, y, width);}
void __stdcall _Lazy_glCopyTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)  {if (GLeeInit()) glCopyTexSubImage2DEXT(target, level, xoffset, yoffset, x, y, width, height);}
void __stdcall _Lazy_glCopyTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)  {if (GLeeInit()) glCopyTexSubImage3DEXT(target, level, xoffset, yoffset, zoffset, x, y, width, height);}
PFNGLCOPYTEXIMAGE1DEXTPROC pglCopyTexImage1DEXT=_Lazy_glCopyTexImage1DEXT;
PFNGLCOPYTEXIMAGE2DEXTPROC pglCopyTexImage2DEXT=_Lazy_glCopyTexImage2DEXT;
PFNGLCOPYTEXSUBIMAGE1DEXTPROC pglCopyTexSubImage1DEXT=_Lazy_glCopyTexSubImage1DEXT;
PFNGLCOPYTEXSUBIMAGE2DEXTPROC pglCopyTexSubImage2DEXT=_Lazy_glCopyTexSubImage2DEXT;
PFNGLCOPYTEXSUBIMAGE3DEXTPROC pglCopyTexSubImage3DEXT=_Lazy_glCopyTexSubImage3DEXT;
#endif 

/* GL_EXT_histogram */

#ifdef __GLEE_GL_EXT_histogram
void __stdcall _Lazy_glGetHistogramEXT(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)  {if (GLeeInit()) glGetHistogramEXT(target, reset, format, type, values);}
void __stdcall _Lazy_glGetHistogramParameterfvEXT(GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetHistogramParameterfvEXT(target, pname, params);}
void __stdcall _Lazy_glGetHistogramParameterivEXT(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetHistogramParameterivEXT(target, pname, params);}
void __stdcall _Lazy_glGetMinmaxEXT(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)  {if (GLeeInit()) glGetMinmaxEXT(target, reset, format, type, values);}
void __stdcall _Lazy_glGetMinmaxParameterfvEXT(GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetMinmaxParameterfvEXT(target, pname, params);}
void __stdcall _Lazy_glGetMinmaxParameterivEXT(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetMinmaxParameterivEXT(target, pname, params);}
void __stdcall _Lazy_glHistogramEXT(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)  {if (GLeeInit()) glHistogramEXT(target, width, internalformat, sink);}
void __stdcall _Lazy_glMinmaxEXT(GLenum target, GLenum internalformat, GLboolean sink)    {if (GLeeInit()) glMinmaxEXT(target, internalformat, sink);}
void __stdcall _Lazy_glResetHistogramEXT(GLenum target)                                   {if (GLeeInit()) glResetHistogramEXT(target);}
void __stdcall _Lazy_glResetMinmaxEXT(GLenum target)                                      {if (GLeeInit()) glResetMinmaxEXT(target);}
PFNGLGETHISTOGRAMEXTPROC pglGetHistogramEXT=_Lazy_glGetHistogramEXT;
PFNGLGETHISTOGRAMPARAMETERFVEXTPROC pglGetHistogramParameterfvEXT=_Lazy_glGetHistogramParameterfvEXT;
PFNGLGETHISTOGRAMPARAMETERIVEXTPROC pglGetHistogramParameterivEXT=_Lazy_glGetHistogramParameterivEXT;
PFNGLGETMINMAXEXTPROC pglGetMinmaxEXT=_Lazy_glGetMinmaxEXT;
PFNGLGETMINMAXPARAMETERFVEXTPROC pglGetMinmaxParameterfvEXT=_Lazy_glGetMinmaxParameterfvEXT;
PFNGLGETMINMAXPARAMETERIVEXTPROC pglGetMinmaxParameterivEXT=_Lazy_glGetMinmaxParameterivEXT;
PFNGLHISTOGRAMEXTPROC pglHistogramEXT=_Lazy_glHistogramEXT;
PFNGLMINMAXEXTPROC pglMinmaxEXT=_Lazy_glMinmaxEXT;
PFNGLRESETHISTOGRAMEXTPROC pglResetHistogramEXT=_Lazy_glResetHistogramEXT;
PFNGLRESETMINMAXEXTPROC pglResetMinmaxEXT=_Lazy_glResetMinmaxEXT;
#endif 

/* GL_EXT_convolution */

#ifdef __GLEE_GL_EXT_convolution
void __stdcall _Lazy_glConvolutionFilter1DEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image)  {if (GLeeInit()) glConvolutionFilter1DEXT(target, internalformat, width, format, type, image);}
void __stdcall _Lazy_glConvolutionFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image)  {if (GLeeInit()) glConvolutionFilter2DEXT(target, internalformat, width, height, format, type, image);}
void __stdcall _Lazy_glConvolutionParameterfEXT(GLenum target, GLenum pname, GLfloat params)  {if (GLeeInit()) glConvolutionParameterfEXT(target, pname, params);}
void __stdcall _Lazy_glConvolutionParameterfvEXT(GLenum target, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glConvolutionParameterfvEXT(target, pname, params);}
void __stdcall _Lazy_glConvolutionParameteriEXT(GLenum target, GLenum pname, GLint params)  {if (GLeeInit()) glConvolutionParameteriEXT(target, pname, params);}
void __stdcall _Lazy_glConvolutionParameterivEXT(GLenum target, GLenum pname, const GLint * params)  {if (GLeeInit()) glConvolutionParameterivEXT(target, pname, params);}
void __stdcall _Lazy_glCopyConvolutionFilter1DEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)  {if (GLeeInit()) glCopyConvolutionFilter1DEXT(target, internalformat, x, y, width);}
void __stdcall _Lazy_glCopyConvolutionFilter2DEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)  {if (GLeeInit()) glCopyConvolutionFilter2DEXT(target, internalformat, x, y, width, height);}
void __stdcall _Lazy_glGetConvolutionFilterEXT(GLenum target, GLenum format, GLenum type, GLvoid * image)  {if (GLeeInit()) glGetConvolutionFilterEXT(target, format, type, image);}
void __stdcall _Lazy_glGetConvolutionParameterfvEXT(GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetConvolutionParameterfvEXT(target, pname, params);}
void __stdcall _Lazy_glGetConvolutionParameterivEXT(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetConvolutionParameterivEXT(target, pname, params);}
void __stdcall _Lazy_glGetSeparableFilterEXT(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span)  {if (GLeeInit()) glGetSeparableFilterEXT(target, format, type, row, column, span);}
void __stdcall _Lazy_glSeparableFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column)  {if (GLeeInit()) glSeparableFilter2DEXT(target, internalformat, width, height, format, type, row, column);}
PFNGLCONVOLUTIONFILTER1DEXTPROC pglConvolutionFilter1DEXT=_Lazy_glConvolutionFilter1DEXT;
PFNGLCONVOLUTIONFILTER2DEXTPROC pglConvolutionFilter2DEXT=_Lazy_glConvolutionFilter2DEXT;
PFNGLCONVOLUTIONPARAMETERFEXTPROC pglConvolutionParameterfEXT=_Lazy_glConvolutionParameterfEXT;
PFNGLCONVOLUTIONPARAMETERFVEXTPROC pglConvolutionParameterfvEXT=_Lazy_glConvolutionParameterfvEXT;
PFNGLCONVOLUTIONPARAMETERIEXTPROC pglConvolutionParameteriEXT=_Lazy_glConvolutionParameteriEXT;
PFNGLCONVOLUTIONPARAMETERIVEXTPROC pglConvolutionParameterivEXT=_Lazy_glConvolutionParameterivEXT;
PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC pglCopyConvolutionFilter1DEXT=_Lazy_glCopyConvolutionFilter1DEXT;
PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC pglCopyConvolutionFilter2DEXT=_Lazy_glCopyConvolutionFilter2DEXT;
PFNGLGETCONVOLUTIONFILTEREXTPROC pglGetConvolutionFilterEXT=_Lazy_glGetConvolutionFilterEXT;
PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC pglGetConvolutionParameterfvEXT=_Lazy_glGetConvolutionParameterfvEXT;
PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC pglGetConvolutionParameterivEXT=_Lazy_glGetConvolutionParameterivEXT;
PFNGLGETSEPARABLEFILTEREXTPROC pglGetSeparableFilterEXT=_Lazy_glGetSeparableFilterEXT;
PFNGLSEPARABLEFILTER2DEXTPROC pglSeparableFilter2DEXT=_Lazy_glSeparableFilter2DEXT;
#endif 

/* GL_SGI_color_matrix */

#ifdef __GLEE_GL_SGI_color_matrix
#endif 

/* GL_SGI_color_table */

#ifdef __GLEE_GL_SGI_color_table
void __stdcall _Lazy_glColorTableSGI(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)  {if (GLeeInit()) glColorTableSGI(target, internalformat, width, format, type, table);}
void __stdcall _Lazy_glColorTableParameterfvSGI(GLenum target, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glColorTableParameterfvSGI(target, pname, params);}
void __stdcall _Lazy_glColorTableParameterivSGI(GLenum target, GLenum pname, const GLint * params)  {if (GLeeInit()) glColorTableParameterivSGI(target, pname, params);}
void __stdcall _Lazy_glCopyColorTableSGI(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)  {if (GLeeInit()) glCopyColorTableSGI(target, internalformat, x, y, width);}
void __stdcall _Lazy_glGetColorTableSGI(GLenum target, GLenum format, GLenum type, GLvoid * table)  {if (GLeeInit()) glGetColorTableSGI(target, format, type, table);}
void __stdcall _Lazy_glGetColorTableParameterfvSGI(GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetColorTableParameterfvSGI(target, pname, params);}
void __stdcall _Lazy_glGetColorTableParameterivSGI(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetColorTableParameterivSGI(target, pname, params);}
PFNGLCOLORTABLESGIPROC pglColorTableSGI=_Lazy_glColorTableSGI;
PFNGLCOLORTABLEPARAMETERFVSGIPROC pglColorTableParameterfvSGI=_Lazy_glColorTableParameterfvSGI;
PFNGLCOLORTABLEPARAMETERIVSGIPROC pglColorTableParameterivSGI=_Lazy_glColorTableParameterivSGI;
PFNGLCOPYCOLORTABLESGIPROC pglCopyColorTableSGI=_Lazy_glCopyColorTableSGI;
PFNGLGETCOLORTABLESGIPROC pglGetColorTableSGI=_Lazy_glGetColorTableSGI;
PFNGLGETCOLORTABLEPARAMETERFVSGIPROC pglGetColorTableParameterfvSGI=_Lazy_glGetColorTableParameterfvSGI;
PFNGLGETCOLORTABLEPARAMETERIVSGIPROC pglGetColorTableParameterivSGI=_Lazy_glGetColorTableParameterivSGI;
#endif 

/* GL_SGIS_pixel_texture */

#ifdef __GLEE_GL_SGIS_pixel_texture
void __stdcall _Lazy_glPixelTexGenParameteriSGIS(GLenum pname, GLint param)               {if (GLeeInit()) glPixelTexGenParameteriSGIS(pname, param);}
void __stdcall _Lazy_glPixelTexGenParameterivSGIS(GLenum pname, const GLint * params)     {if (GLeeInit()) glPixelTexGenParameterivSGIS(pname, params);}
void __stdcall _Lazy_glPixelTexGenParameterfSGIS(GLenum pname, GLfloat param)             {if (GLeeInit()) glPixelTexGenParameterfSGIS(pname, param);}
void __stdcall _Lazy_glPixelTexGenParameterfvSGIS(GLenum pname, const GLfloat * params)   {if (GLeeInit()) glPixelTexGenParameterfvSGIS(pname, params);}
void __stdcall _Lazy_glGetPixelTexGenParameterivSGIS(GLenum pname, GLint * params)        {if (GLeeInit()) glGetPixelTexGenParameterivSGIS(pname, params);}
void __stdcall _Lazy_glGetPixelTexGenParameterfvSGIS(GLenum pname, GLfloat * params)      {if (GLeeInit()) glGetPixelTexGenParameterfvSGIS(pname, params);}
PFNGLPIXELTEXGENPARAMETERISGISPROC pglPixelTexGenParameteriSGIS=_Lazy_glPixelTexGenParameteriSGIS;
PFNGLPIXELTEXGENPARAMETERIVSGISPROC pglPixelTexGenParameterivSGIS=_Lazy_glPixelTexGenParameterivSGIS;
PFNGLPIXELTEXGENPARAMETERFSGISPROC pglPixelTexGenParameterfSGIS=_Lazy_glPixelTexGenParameterfSGIS;
PFNGLPIXELTEXGENPARAMETERFVSGISPROC pglPixelTexGenParameterfvSGIS=_Lazy_glPixelTexGenParameterfvSGIS;
PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC pglGetPixelTexGenParameterivSGIS=_Lazy_glGetPixelTexGenParameterivSGIS;
PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC pglGetPixelTexGenParameterfvSGIS=_Lazy_glGetPixelTexGenParameterfvSGIS;
#endif 

/* GL_SGIX_pixel_texture */

#ifdef __GLEE_GL_SGIX_pixel_texture
void __stdcall _Lazy_glPixelTexGenSGIX(GLenum mode)                                       {if (GLeeInit()) glPixelTexGenSGIX(mode);}
PFNGLPIXELTEXGENSGIXPROC pglPixelTexGenSGIX=_Lazy_glPixelTexGenSGIX;
#endif 

/* GL_SGIS_texture4D */

#ifdef __GLEE_GL_SGIS_texture4D
void __stdcall _Lazy_glTexImage4DSGIS(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glTexImage4DSGIS(target, level, internalformat, width, height, depth, size4d, border, format, type, pixels);}
void __stdcall _Lazy_glTexSubImage4DSGIS(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glTexSubImage4DSGIS(target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels);}
PFNGLTEXIMAGE4DSGISPROC pglTexImage4DSGIS=_Lazy_glTexImage4DSGIS;
PFNGLTEXSUBIMAGE4DSGISPROC pglTexSubImage4DSGIS=_Lazy_glTexSubImage4DSGIS;
#endif 

/* GL_SGI_texture_color_table */

#ifdef __GLEE_GL_SGI_texture_color_table
#endif 

/* GL_EXT_cmyka */

#ifdef __GLEE_GL_EXT_cmyka
#endif 

/* GL_EXT_texture_object */

#ifdef __GLEE_GL_EXT_texture_object
GLboolean __stdcall _Lazy_glAreTexturesResidentEXT(GLsizei n, const GLuint * textures, GLboolean * residences)  {if (GLeeInit()) return glAreTexturesResidentEXT(n, textures, residences); return (GLboolean)0;}
void __stdcall _Lazy_glBindTextureEXT(GLenum target, GLuint texture)                      {if (GLeeInit()) glBindTextureEXT(target, texture);}
void __stdcall _Lazy_glDeleteTexturesEXT(GLsizei n, const GLuint * textures)              {if (GLeeInit()) glDeleteTexturesEXT(n, textures);}
void __stdcall _Lazy_glGenTexturesEXT(GLsizei n, GLuint * textures)                       {if (GLeeInit()) glGenTexturesEXT(n, textures);}
GLboolean __stdcall _Lazy_glIsTextureEXT(GLuint texture)                                  {if (GLeeInit()) return glIsTextureEXT(texture); return (GLboolean)0;}
void __stdcall _Lazy_glPrioritizeTexturesEXT(GLsizei n, const GLuint * textures, const GLclampf * priorities)  {if (GLeeInit()) glPrioritizeTexturesEXT(n, textures, priorities);}
PFNGLARETEXTURESRESIDENTEXTPROC pglAreTexturesResidentEXT=_Lazy_glAreTexturesResidentEXT;
PFNGLBINDTEXTUREEXTPROC pglBindTextureEXT=_Lazy_glBindTextureEXT;
PFNGLDELETETEXTURESEXTPROC pglDeleteTexturesEXT=_Lazy_glDeleteTexturesEXT;
PFNGLGENTEXTURESEXTPROC pglGenTexturesEXT=_Lazy_glGenTexturesEXT;
PFNGLISTEXTUREEXTPROC pglIsTextureEXT=_Lazy_glIsTextureEXT;
PFNGLPRIORITIZETEXTURESEXTPROC pglPrioritizeTexturesEXT=_Lazy_glPrioritizeTexturesEXT;
#endif 

/* GL_SGIS_detail_texture */

#ifdef __GLEE_GL_SGIS_detail_texture
void __stdcall _Lazy_glDetailTexFuncSGIS(GLenum target, GLsizei n, const GLfloat * points)  {if (GLeeInit()) glDetailTexFuncSGIS(target, n, points);}
void __stdcall _Lazy_glGetDetailTexFuncSGIS(GLenum target, GLfloat * points)              {if (GLeeInit()) glGetDetailTexFuncSGIS(target, points);}
PFNGLDETAILTEXFUNCSGISPROC pglDetailTexFuncSGIS=_Lazy_glDetailTexFuncSGIS;
PFNGLGETDETAILTEXFUNCSGISPROC pglGetDetailTexFuncSGIS=_Lazy_glGetDetailTexFuncSGIS;
#endif 

/* GL_SGIS_sharpen_texture */

#ifdef __GLEE_GL_SGIS_sharpen_texture
void __stdcall _Lazy_glSharpenTexFuncSGIS(GLenum target, GLsizei n, const GLfloat * points)  {if (GLeeInit()) glSharpenTexFuncSGIS(target, n, points);}
void __stdcall _Lazy_glGetSharpenTexFuncSGIS(GLenum target, GLfloat * points)             {if (GLeeInit()) glGetSharpenTexFuncSGIS(target, points);}
PFNGLSHARPENTEXFUNCSGISPROC pglSharpenTexFuncSGIS=_Lazy_glSharpenTexFuncSGIS;
PFNGLGETSHARPENTEXFUNCSGISPROC pglGetSharpenTexFuncSGIS=_Lazy_glGetSharpenTexFuncSGIS;
#endif 

/* GL_EXT_packed_pixels */

#ifdef __GLEE_GL_EXT_packed_pixels
#endif 

/* GL_SGIS_texture_lod */

#ifdef __GLEE_GL_SGIS_texture_lod
#endif 

/* GL_SGIS_multisample */

#ifdef __GLEE_GL_SGIS_multisample
void __stdcall _Lazy_glSampleMaskSGIS(GLclampf value, GLboolean invert)                   {if (GLeeInit()) glSampleMaskSGIS(value, invert);}
void __stdcall _Lazy_glSamplePatternSGIS(GLenum pattern)                                  {if (GLeeInit()) glSamplePatternSGIS(pattern);}
PFNGLSAMPLEMASKSGISPROC pglSampleMaskSGIS=_Lazy_glSampleMaskSGIS;
PFNGLSAMPLEPATTERNSGISPROC pglSamplePatternSGIS=_Lazy_glSamplePatternSGIS;
#endif 

/* GL_EXT_rescale_normal */

#ifdef __GLEE_GL_EXT_rescale_normal
#endif 

/* GL_EXT_vertex_array */

#ifdef __GLEE_GL_EXT_vertex_array
void __stdcall _Lazy_glArrayElementEXT(GLint i)                                           {if (GLeeInit()) glArrayElementEXT(i);}
void __stdcall _Lazy_glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)  {if (GLeeInit()) glColorPointerEXT(size, type, stride, count, pointer);}
void __stdcall _Lazy_glDrawArraysEXT(GLenum mode, GLint first, GLsizei count)             {if (GLeeInit()) glDrawArraysEXT(mode, first, count);}
void __stdcall _Lazy_glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean * pointer)  {if (GLeeInit()) glEdgeFlagPointerEXT(stride, count, pointer);}
void __stdcall _Lazy_glGetPointervEXT(GLenum pname, GLvoid* * params)                     {if (GLeeInit()) glGetPointervEXT(pname, params);}
void __stdcall _Lazy_glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)  {if (GLeeInit()) glIndexPointerEXT(type, stride, count, pointer);}
void __stdcall _Lazy_glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)  {if (GLeeInit()) glNormalPointerEXT(type, stride, count, pointer);}
void __stdcall _Lazy_glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)  {if (GLeeInit()) glTexCoordPointerEXT(size, type, stride, count, pointer);}
void __stdcall _Lazy_glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)  {if (GLeeInit()) glVertexPointerEXT(size, type, stride, count, pointer);}
PFNGLARRAYELEMENTEXTPROC pglArrayElementEXT=_Lazy_glArrayElementEXT;
PFNGLCOLORPOINTEREXTPROC pglColorPointerEXT=_Lazy_glColorPointerEXT;
PFNGLDRAWARRAYSEXTPROC pglDrawArraysEXT=_Lazy_glDrawArraysEXT;
PFNGLEDGEFLAGPOINTEREXTPROC pglEdgeFlagPointerEXT=_Lazy_glEdgeFlagPointerEXT;
PFNGLGETPOINTERVEXTPROC pglGetPointervEXT=_Lazy_glGetPointervEXT;
PFNGLINDEXPOINTEREXTPROC pglIndexPointerEXT=_Lazy_glIndexPointerEXT;
PFNGLNORMALPOINTEREXTPROC pglNormalPointerEXT=_Lazy_glNormalPointerEXT;
PFNGLTEXCOORDPOINTEREXTPROC pglTexCoordPointerEXT=_Lazy_glTexCoordPointerEXT;
PFNGLVERTEXPOINTEREXTPROC pglVertexPointerEXT=_Lazy_glVertexPointerEXT;
#endif 

/* GL_EXT_misc_attribute */

#ifdef __GLEE_GL_EXT_misc_attribute
#endif 

/* GL_SGIS_generate_mipmap */

#ifdef __GLEE_GL_SGIS_generate_mipmap
#endif 

/* GL_SGIX_clipmap */

#ifdef __GLEE_GL_SGIX_clipmap
#endif 

/* GL_SGIX_shadow */

#ifdef __GLEE_GL_SGIX_shadow
#endif 

/* GL_SGIS_texture_edge_clamp */

#ifdef __GLEE_GL_SGIS_texture_edge_clamp
#endif 

/* GL_SGIS_texture_border_clamp */

#ifdef __GLEE_GL_SGIS_texture_border_clamp
#endif 

/* GL_EXT_blend_minmax */

#ifdef __GLEE_GL_EXT_blend_minmax
void __stdcall _Lazy_glBlendEquationEXT(GLenum mode)                                      {if (GLeeInit()) glBlendEquationEXT(mode);}
PFNGLBLENDEQUATIONEXTPROC pglBlendEquationEXT=_Lazy_glBlendEquationEXT;
#endif 

/* GL_EXT_blend_subtract */

#ifdef __GLEE_GL_EXT_blend_subtract
#endif 

/* GL_EXT_blend_logic_op */

#ifdef __GLEE_GL_EXT_blend_logic_op
#endif 

/* GL_SGIX_interlace */

#ifdef __GLEE_GL_SGIX_interlace
#endif 

/* GL_SGIX_pixel_tiles */

#ifdef __GLEE_GL_SGIX_pixel_tiles
#endif 

/* GL_SGIS_texture_select */

#ifdef __GLEE_GL_SGIS_texture_select
#endif 

/* GL_SGIX_sprite */

#ifdef __GLEE_GL_SGIX_sprite
void __stdcall _Lazy_glSpriteParameterfSGIX(GLenum pname, GLfloat param)                  {if (GLeeInit()) glSpriteParameterfSGIX(pname, param);}
void __stdcall _Lazy_glSpriteParameterfvSGIX(GLenum pname, const GLfloat * params)        {if (GLeeInit()) glSpriteParameterfvSGIX(pname, params);}
void __stdcall _Lazy_glSpriteParameteriSGIX(GLenum pname, GLint param)                    {if (GLeeInit()) glSpriteParameteriSGIX(pname, param);}
void __stdcall _Lazy_glSpriteParameterivSGIX(GLenum pname, const GLint * params)          {if (GLeeInit()) glSpriteParameterivSGIX(pname, params);}
PFNGLSPRITEPARAMETERFSGIXPROC pglSpriteParameterfSGIX=_Lazy_glSpriteParameterfSGIX;
PFNGLSPRITEPARAMETERFVSGIXPROC pglSpriteParameterfvSGIX=_Lazy_glSpriteParameterfvSGIX;
PFNGLSPRITEPARAMETERISGIXPROC pglSpriteParameteriSGIX=_Lazy_glSpriteParameteriSGIX;
PFNGLSPRITEPARAMETERIVSGIXPROC pglSpriteParameterivSGIX=_Lazy_glSpriteParameterivSGIX;
#endif 

/* GL_SGIX_texture_multi_buffer */

#ifdef __GLEE_GL_SGIX_texture_multi_buffer
#endif 

/* GL_EXT_point_parameters */

#ifdef __GLEE_GL_EXT_point_parameters
void __stdcall _Lazy_glPointParameterfEXT(GLenum pname, GLfloat param)                    {if (GLeeInit()) glPointParameterfEXT(pname, param);}
void __stdcall _Lazy_glPointParameterfvEXT(GLenum pname, const GLfloat * params)          {if (GLeeInit()) glPointParameterfvEXT(pname, params);}
PFNGLPOINTPARAMETERFEXTPROC pglPointParameterfEXT=_Lazy_glPointParameterfEXT;
PFNGLPOINTPARAMETERFVEXTPROC pglPointParameterfvEXT=_Lazy_glPointParameterfvEXT;
#endif 

/* GL_SGIS_point_parameters */

#ifdef __GLEE_GL_SGIS_point_parameters
void __stdcall _Lazy_glPointParameterfSGIS(GLenum pname, GLfloat param)                   {if (GLeeInit()) glPointParameterfSGIS(pname, param);}
void __stdcall _Lazy_glPointParameterfvSGIS(GLenum pname, const GLfloat * params)         {if (GLeeInit()) glPointParameterfvSGIS(pname, params);}
PFNGLPOINTPARAMETERFSGISPROC pglPointParameterfSGIS=_Lazy_glPointParameterfSGIS;
PFNGLPOINTPARAMETERFVSGISPROC pglPointParameterfvSGIS=_Lazy_glPointParameterfvSGIS;
#endif 

/* GL_SGIX_instruments */

#ifdef __GLEE_GL_SGIX_instruments
GLint __stdcall _Lazy_glGetInstrumentsSGIX(void)                                          {if (GLeeInit()) return glGetInstrumentsSGIX(); return (GLint)0;}
void __stdcall _Lazy_glInstrumentsBufferSGIX(GLsizei size, GLint * buffer)                {if (GLeeInit()) glInstrumentsBufferSGIX(size, buffer);}
GLint __stdcall _Lazy_glPollInstrumentsSGIX(GLint * marker_p)                             {if (GLeeInit()) return glPollInstrumentsSGIX(marker_p); return (GLint)0;}
void __stdcall _Lazy_glReadInstrumentsSGIX(GLint marker)                                  {if (GLeeInit()) glReadInstrumentsSGIX(marker);}
void __stdcall _Lazy_glStartInstrumentsSGIX(void)                                         {if (GLeeInit()) glStartInstrumentsSGIX();}
void __stdcall _Lazy_glStopInstrumentsSGIX(GLint marker)                                  {if (GLeeInit()) glStopInstrumentsSGIX(marker);}
PFNGLGETINSTRUMENTSSGIXPROC pglGetInstrumentsSGIX=_Lazy_glGetInstrumentsSGIX;
PFNGLINSTRUMENTSBUFFERSGIXPROC pglInstrumentsBufferSGIX=_Lazy_glInstrumentsBufferSGIX;
PFNGLPOLLINSTRUMENTSSGIXPROC pglPollInstrumentsSGIX=_Lazy_glPollInstrumentsSGIX;
PFNGLREADINSTRUMENTSSGIXPROC pglReadInstrumentsSGIX=_Lazy_glReadInstrumentsSGIX;
PFNGLSTARTINSTRUMENTSSGIXPROC pglStartInstrumentsSGIX=_Lazy_glStartInstrumentsSGIX;
PFNGLSTOPINSTRUMENTSSGIXPROC pglStopInstrumentsSGIX=_Lazy_glStopInstrumentsSGIX;
#endif 

/* GL_SGIX_texture_scale_bias */

#ifdef __GLEE_GL_SGIX_texture_scale_bias
#endif 

/* GL_SGIX_framezoom */

#ifdef __GLEE_GL_SGIX_framezoom
void __stdcall _Lazy_glFrameZoomSGIX(GLint factor)                                        {if (GLeeInit()) glFrameZoomSGIX(factor);}
PFNGLFRAMEZOOMSGIXPROC pglFrameZoomSGIX=_Lazy_glFrameZoomSGIX;
#endif 

/* GL_SGIX_tag_sample_buffer */

#ifdef __GLEE_GL_SGIX_tag_sample_buffer
void __stdcall _Lazy_glTagSampleBufferSGIX(void)                                          {if (GLeeInit()) glTagSampleBufferSGIX();}
PFNGLTAGSAMPLEBUFFERSGIXPROC pglTagSampleBufferSGIX=_Lazy_glTagSampleBufferSGIX;
#endif 

/* GL_FfdMaskSGIX */

#ifdef __GLEE_GL_FfdMaskSGIX
#endif 

/* GL_SGIX_polynomial_ffd */

#ifdef __GLEE_GL_SGIX_polynomial_ffd
void __stdcall _Lazy_glDeformationMap3dSGIX(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, const GLdouble * points)  {if (GLeeInit()) glDeformationMap3dSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);}
void __stdcall _Lazy_glDeformationMap3fSGIX(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, const GLfloat * points)  {if (GLeeInit()) glDeformationMap3fSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);}
void __stdcall _Lazy_glDeformSGIX(GLbitfield mask)                                        {if (GLeeInit()) glDeformSGIX(mask);}
void __stdcall _Lazy_glLoadIdentityDeformationMapSGIX(GLbitfield mask)                    {if (GLeeInit()) glLoadIdentityDeformationMapSGIX(mask);}
PFNGLDEFORMATIONMAP3DSGIXPROC pglDeformationMap3dSGIX=_Lazy_glDeformationMap3dSGIX;
PFNGLDEFORMATIONMAP3FSGIXPROC pglDeformationMap3fSGIX=_Lazy_glDeformationMap3fSGIX;
PFNGLDEFORMSGIXPROC pglDeformSGIX=_Lazy_glDeformSGIX;
PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC pglLoadIdentityDeformationMapSGIX=_Lazy_glLoadIdentityDeformationMapSGIX;
#endif 

/* GL_SGIX_reference_plane */

#ifdef __GLEE_GL_SGIX_reference_plane
void __stdcall _Lazy_glReferencePlaneSGIX(const GLdouble * equation)                      {if (GLeeInit()) glReferencePlaneSGIX(equation);}
PFNGLREFERENCEPLANESGIXPROC pglReferencePlaneSGIX=_Lazy_glReferencePlaneSGIX;
#endif 

/* GL_SGIX_flush_raster */

#ifdef __GLEE_GL_SGIX_flush_raster
void __stdcall _Lazy_glFlushRasterSGIX(void)                                              {if (GLeeInit()) glFlushRasterSGIX();}
PFNGLFLUSHRASTERSGIXPROC pglFlushRasterSGIX=_Lazy_glFlushRasterSGIX;
#endif 

/* GL_SGIX_depth_texture */

#ifdef __GLEE_GL_SGIX_depth_texture
#endif 

/* GL_SGIS_fog_function */

#ifdef __GLEE_GL_SGIS_fog_function
void __stdcall _Lazy_glFogFuncSGIS(GLsizei n, const GLfloat * points)                     {if (GLeeInit()) glFogFuncSGIS(n, points);}
void __stdcall _Lazy_glGetFogFuncSGIS(GLfloat * points)                                   {if (GLeeInit()) glGetFogFuncSGIS(points);}
PFNGLFOGFUNCSGISPROC pglFogFuncSGIS=_Lazy_glFogFuncSGIS;
PFNGLGETFOGFUNCSGISPROC pglGetFogFuncSGIS=_Lazy_glGetFogFuncSGIS;
#endif 

/* GL_SGIX_fog_offset */

#ifdef __GLEE_GL_SGIX_fog_offset
#endif 

/* GL_HP_image_transform */

#ifdef __GLEE_GL_HP_image_transform
void __stdcall _Lazy_glImageTransformParameteriHP(GLenum target, GLenum pname, GLint param)  {if (GLeeInit()) glImageTransformParameteriHP(target, pname, param);}
void __stdcall _Lazy_glImageTransformParameterfHP(GLenum target, GLenum pname, GLfloat param)  {if (GLeeInit()) glImageTransformParameterfHP(target, pname, param);}
void __stdcall _Lazy_glImageTransformParameterivHP(GLenum target, GLenum pname, const GLint * params)  {if (GLeeInit()) glImageTransformParameterivHP(target, pname, params);}
void __stdcall _Lazy_glImageTransformParameterfvHP(GLenum target, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glImageTransformParameterfvHP(target, pname, params);}
void __stdcall _Lazy_glGetImageTransformParameterivHP(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetImageTransformParameterivHP(target, pname, params);}
void __stdcall _Lazy_glGetImageTransformParameterfvHP(GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetImageTransformParameterfvHP(target, pname, params);}
PFNGLIMAGETRANSFORMPARAMETERIHPPROC pglImageTransformParameteriHP=_Lazy_glImageTransformParameteriHP;
PFNGLIMAGETRANSFORMPARAMETERFHPPROC pglImageTransformParameterfHP=_Lazy_glImageTransformParameterfHP;
PFNGLIMAGETRANSFORMPARAMETERIVHPPROC pglImageTransformParameterivHP=_Lazy_glImageTransformParameterivHP;
PFNGLIMAGETRANSFORMPARAMETERFVHPPROC pglImageTransformParameterfvHP=_Lazy_glImageTransformParameterfvHP;
PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC pglGetImageTransformParameterivHP=_Lazy_glGetImageTransformParameterivHP;
PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC pglGetImageTransformParameterfvHP=_Lazy_glGetImageTransformParameterfvHP;
#endif 

/* GL_HP_convolution_border_modes */

#ifdef __GLEE_GL_HP_convolution_border_modes
#endif 

/* GL_INGR_palette_buffer */

#ifdef __GLEE_GL_INGR_palette_buffer
#endif 

/* GL_SGIX_texture_add_env */

#ifdef __GLEE_GL_SGIX_texture_add_env
#endif 

/* GL_EXT_color_subtable */

#ifdef __GLEE_GL_EXT_color_subtable
void __stdcall _Lazy_glColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data)  {if (GLeeInit()) glColorSubTableEXT(target, start, count, format, type, data);}
void __stdcall _Lazy_glCopyColorSubTableEXT(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)  {if (GLeeInit()) glCopyColorSubTableEXT(target, start, x, y, width);}
PFNGLCOLORSUBTABLEEXTPROC pglColorSubTableEXT=_Lazy_glColorSubTableEXT;
PFNGLCOPYCOLORSUBTABLEEXTPROC pglCopyColorSubTableEXT=_Lazy_glCopyColorSubTableEXT;
#endif 

/* GL_PGI_vertex_hints */

#ifdef __GLEE_GL_PGI_vertex_hints
#endif 

/* GL_PGI_misc_hints */

#ifdef __GLEE_GL_PGI_misc_hints
void __stdcall _Lazy_glHintPGI(GLenum target, GLint mode)                                 {if (GLeeInit()) glHintPGI(target, mode);}
PFNGLHINTPGIPROC pglHintPGI=_Lazy_glHintPGI;
#endif 

/* GL_EXT_paletted_texture */

#ifdef __GLEE_GL_EXT_paletted_texture
void __stdcall _Lazy_glColorTableEXT(GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)  {if (GLeeInit()) glColorTableEXT(target, internalFormat, width, format, type, table);}
void __stdcall _Lazy_glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid * data)  {if (GLeeInit()) glGetColorTableEXT(target, format, type, data);}
void __stdcall _Lazy_glGetColorTableParameterivEXT(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetColorTableParameterivEXT(target, pname, params);}
void __stdcall _Lazy_glGetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetColorTableParameterfvEXT(target, pname, params);}
PFNGLCOLORTABLEEXTPROC pglColorTableEXT=_Lazy_glColorTableEXT;
PFNGLGETCOLORTABLEEXTPROC pglGetColorTableEXT=_Lazy_glGetColorTableEXT;
PFNGLGETCOLORTABLEPARAMETERIVEXTPROC pglGetColorTableParameterivEXT=_Lazy_glGetColorTableParameterivEXT;
PFNGLGETCOLORTABLEPARAMETERFVEXTPROC pglGetColorTableParameterfvEXT=_Lazy_glGetColorTableParameterfvEXT;
#endif 

/* GL_EXT_clip_volume_hint */

#ifdef __GLEE_GL_EXT_clip_volume_hint
#endif 

/* GL_SGIX_list_priority */

#ifdef __GLEE_GL_SGIX_list_priority
void __stdcall _Lazy_glGetListParameterfvSGIX(GLuint list, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetListParameterfvSGIX(list, pname, params);}
void __stdcall _Lazy_glGetListParameterivSGIX(GLuint list, GLenum pname, GLint * params)  {if (GLeeInit()) glGetListParameterivSGIX(list, pname, params);}
void __stdcall _Lazy_glListParameterfSGIX(GLuint list, GLenum pname, GLfloat param)       {if (GLeeInit()) glListParameterfSGIX(list, pname, param);}
void __stdcall _Lazy_glListParameterfvSGIX(GLuint list, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glListParameterfvSGIX(list, pname, params);}
void __stdcall _Lazy_glListParameteriSGIX(GLuint list, GLenum pname, GLint param)         {if (GLeeInit()) glListParameteriSGIX(list, pname, param);}
void __stdcall _Lazy_glListParameterivSGIX(GLuint list, GLenum pname, const GLint * params)  {if (GLeeInit()) glListParameterivSGIX(list, pname, params);}
PFNGLGETLISTPARAMETERFVSGIXPROC pglGetListParameterfvSGIX=_Lazy_glGetListParameterfvSGIX;
PFNGLGETLISTPARAMETERIVSGIXPROC pglGetListParameterivSGIX=_Lazy_glGetListParameterivSGIX;
PFNGLLISTPARAMETERFSGIXPROC pglListParameterfSGIX=_Lazy_glListParameterfSGIX;
PFNGLLISTPARAMETERFVSGIXPROC pglListParameterfvSGIX=_Lazy_glListParameterfvSGIX;
PFNGLLISTPARAMETERISGIXPROC pglListParameteriSGIX=_Lazy_glListParameteriSGIX;
PFNGLLISTPARAMETERIVSGIXPROC pglListParameterivSGIX=_Lazy_glListParameterivSGIX;
#endif 

/* GL_SGIX_ir_instrument1 */

#ifdef __GLEE_GL_SGIX_ir_instrument1
#endif 

/* GL_SGIX_calligraphic_fragment */

#ifdef __GLEE_GL_SGIX_calligraphic_fragment
#endif 

/* GL_SGIX_texture_lod_bias */

#ifdef __GLEE_GL_SGIX_texture_lod_bias
#endif 

/* GL_SGIX_shadow_ambient */

#ifdef __GLEE_GL_SGIX_shadow_ambient
#endif 

/* GL_EXT_index_texture */

#ifdef __GLEE_GL_EXT_index_texture
#endif 

/* GL_EXT_index_material */

#ifdef __GLEE_GL_EXT_index_material
void __stdcall _Lazy_glIndexMaterialEXT(GLenum face, GLenum mode)                         {if (GLeeInit()) glIndexMaterialEXT(face, mode);}
PFNGLINDEXMATERIALEXTPROC pglIndexMaterialEXT=_Lazy_glIndexMaterialEXT;
#endif 

/* GL_EXT_index_func */

#ifdef __GLEE_GL_EXT_index_func
void __stdcall _Lazy_glIndexFuncEXT(GLenum func, GLclampf ref)                            {if (GLeeInit()) glIndexFuncEXT(func, ref);}
PFNGLINDEXFUNCEXTPROC pglIndexFuncEXT=_Lazy_glIndexFuncEXT;
#endif 

/* GL_EXT_index_array_formats */

#ifdef __GLEE_GL_EXT_index_array_formats
#endif 

/* GL_EXT_compiled_vertex_array */

#ifdef __GLEE_GL_EXT_compiled_vertex_array
void __stdcall _Lazy_glLockArraysEXT(GLint first, GLsizei count)                          {if (GLeeInit()) glLockArraysEXT(first, count);}
void __stdcall _Lazy_glUnlockArraysEXT(void)                                              {if (GLeeInit()) glUnlockArraysEXT();}
PFNGLLOCKARRAYSEXTPROC pglLockArraysEXT=_Lazy_glLockArraysEXT;
PFNGLUNLOCKARRAYSEXTPROC pglUnlockArraysEXT=_Lazy_glUnlockArraysEXT;
#endif 

/* GL_EXT_cull_vertex */

#ifdef __GLEE_GL_EXT_cull_vertex
void __stdcall _Lazy_glCullParameterdvEXT(GLenum pname, GLdouble * params)                {if (GLeeInit()) glCullParameterdvEXT(pname, params);}
void __stdcall _Lazy_glCullParameterfvEXT(GLenum pname, GLfloat * params)                 {if (GLeeInit()) glCullParameterfvEXT(pname, params);}
PFNGLCULLPARAMETERDVEXTPROC pglCullParameterdvEXT=_Lazy_glCullParameterdvEXT;
PFNGLCULLPARAMETERFVEXTPROC pglCullParameterfvEXT=_Lazy_glCullParameterfvEXT;
#endif 

/* GL_SGIX_ycrcb */

#ifdef __GLEE_GL_SGIX_ycrcb
#endif 

/* GL_SGIX_fragment_lighting */

#ifdef __GLEE_GL_SGIX_fragment_lighting
void __stdcall _Lazy_glFragmentColorMaterialSGIX(GLenum face, GLenum mode)                {if (GLeeInit()) glFragmentColorMaterialSGIX(face, mode);}
void __stdcall _Lazy_glFragmentLightfSGIX(GLenum light, GLenum pname, GLfloat param)      {if (GLeeInit()) glFragmentLightfSGIX(light, pname, param);}
void __stdcall _Lazy_glFragmentLightfvSGIX(GLenum light, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glFragmentLightfvSGIX(light, pname, params);}
void __stdcall _Lazy_glFragmentLightiSGIX(GLenum light, GLenum pname, GLint param)        {if (GLeeInit()) glFragmentLightiSGIX(light, pname, param);}
void __stdcall _Lazy_glFragmentLightivSGIX(GLenum light, GLenum pname, const GLint * params)  {if (GLeeInit()) glFragmentLightivSGIX(light, pname, params);}
void __stdcall _Lazy_glFragmentLightModelfSGIX(GLenum pname, GLfloat param)               {if (GLeeInit()) glFragmentLightModelfSGIX(pname, param);}
void __stdcall _Lazy_glFragmentLightModelfvSGIX(GLenum pname, const GLfloat * params)     {if (GLeeInit()) glFragmentLightModelfvSGIX(pname, params);}
void __stdcall _Lazy_glFragmentLightModeliSGIX(GLenum pname, GLint param)                 {if (GLeeInit()) glFragmentLightModeliSGIX(pname, param);}
void __stdcall _Lazy_glFragmentLightModelivSGIX(GLenum pname, const GLint * params)       {if (GLeeInit()) glFragmentLightModelivSGIX(pname, params);}
void __stdcall _Lazy_glFragmentMaterialfSGIX(GLenum face, GLenum pname, GLfloat param)    {if (GLeeInit()) glFragmentMaterialfSGIX(face, pname, param);}
void __stdcall _Lazy_glFragmentMaterialfvSGIX(GLenum face, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glFragmentMaterialfvSGIX(face, pname, params);}
void __stdcall _Lazy_glFragmentMaterialiSGIX(GLenum face, GLenum pname, GLint param)      {if (GLeeInit()) glFragmentMaterialiSGIX(face, pname, param);}
void __stdcall _Lazy_glFragmentMaterialivSGIX(GLenum face, GLenum pname, const GLint * params)  {if (GLeeInit()) glFragmentMaterialivSGIX(face, pname, params);}
void __stdcall _Lazy_glGetFragmentLightfvSGIX(GLenum light, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetFragmentLightfvSGIX(light, pname, params);}
void __stdcall _Lazy_glGetFragmentLightivSGIX(GLenum light, GLenum pname, GLint * params)  {if (GLeeInit()) glGetFragmentLightivSGIX(light, pname, params);}
void __stdcall _Lazy_glGetFragmentMaterialfvSGIX(GLenum face, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetFragmentMaterialfvSGIX(face, pname, params);}
void __stdcall _Lazy_glGetFragmentMaterialivSGIX(GLenum face, GLenum pname, GLint * params)  {if (GLeeInit()) glGetFragmentMaterialivSGIX(face, pname, params);}
void __stdcall _Lazy_glLightEnviSGIX(GLenum pname, GLint param)                           {if (GLeeInit()) glLightEnviSGIX(pname, param);}
PFNGLFRAGMENTCOLORMATERIALSGIXPROC pglFragmentColorMaterialSGIX=_Lazy_glFragmentColorMaterialSGIX;
PFNGLFRAGMENTLIGHTFSGIXPROC pglFragmentLightfSGIX=_Lazy_glFragmentLightfSGIX;
PFNGLFRAGMENTLIGHTFVSGIXPROC pglFragmentLightfvSGIX=_Lazy_glFragmentLightfvSGIX;
PFNGLFRAGMENTLIGHTISGIXPROC pglFragmentLightiSGIX=_Lazy_glFragmentLightiSGIX;
PFNGLFRAGMENTLIGHTIVSGIXPROC pglFragmentLightivSGIX=_Lazy_glFragmentLightivSGIX;
PFNGLFRAGMENTLIGHTMODELFSGIXPROC pglFragmentLightModelfSGIX=_Lazy_glFragmentLightModelfSGIX;
PFNGLFRAGMENTLIGHTMODELFVSGIXPROC pglFragmentLightModelfvSGIX=_Lazy_glFragmentLightModelfvSGIX;
PFNGLFRAGMENTLIGHTMODELISGIXPROC pglFragmentLightModeliSGIX=_Lazy_glFragmentLightModeliSGIX;
PFNGLFRAGMENTLIGHTMODELIVSGIXPROC pglFragmentLightModelivSGIX=_Lazy_glFragmentLightModelivSGIX;
PFNGLFRAGMENTMATERIALFSGIXPROC pglFragmentMaterialfSGIX=_Lazy_glFragmentMaterialfSGIX;
PFNGLFRAGMENTMATERIALFVSGIXPROC pglFragmentMaterialfvSGIX=_Lazy_glFragmentMaterialfvSGIX;
PFNGLFRAGMENTMATERIALISGIXPROC pglFragmentMaterialiSGIX=_Lazy_glFragmentMaterialiSGIX;
PFNGLFRAGMENTMATERIALIVSGIXPROC pglFragmentMaterialivSGIX=_Lazy_glFragmentMaterialivSGIX;
PFNGLGETFRAGMENTLIGHTFVSGIXPROC pglGetFragmentLightfvSGIX=_Lazy_glGetFragmentLightfvSGIX;
PFNGLGETFRAGMENTLIGHTIVSGIXPROC pglGetFragmentLightivSGIX=_Lazy_glGetFragmentLightivSGIX;
PFNGLGETFRAGMENTMATERIALFVSGIXPROC pglGetFragmentMaterialfvSGIX=_Lazy_glGetFragmentMaterialfvSGIX;
PFNGLGETFRAGMENTMATERIALIVSGIXPROC pglGetFragmentMaterialivSGIX=_Lazy_glGetFragmentMaterialivSGIX;
PFNGLLIGHTENVISGIXPROC pglLightEnviSGIX=_Lazy_glLightEnviSGIX;
#endif 

/* GL_IBM_rasterpos_clip */

#ifdef __GLEE_GL_IBM_rasterpos_clip
#endif 

/* GL_HP_texture_lighting */

#ifdef __GLEE_GL_HP_texture_lighting
#endif 

/* GL_EXT_draw_range_elements */

#ifdef __GLEE_GL_EXT_draw_range_elements
void __stdcall _Lazy_glDrawRangeElementsEXT(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices)  {if (GLeeInit()) glDrawRangeElementsEXT(mode, start, end, count, type, indices);}
PFNGLDRAWRANGEELEMENTSEXTPROC pglDrawRangeElementsEXT=_Lazy_glDrawRangeElementsEXT;
#endif 

/* GL_WIN_phong_shading */

#ifdef __GLEE_GL_WIN_phong_shading
#endif 

/* GL_WIN_specular_fog */

#ifdef __GLEE_GL_WIN_specular_fog
#endif 

/* GL_EXT_light_texture */

#ifdef __GLEE_GL_EXT_light_texture
void __stdcall _Lazy_glApplyTextureEXT(GLenum mode)                                       {if (GLeeInit()) glApplyTextureEXT(mode);}
void __stdcall _Lazy_glTextureLightEXT(GLenum pname)                                      {if (GLeeInit()) glTextureLightEXT(pname);}
void __stdcall _Lazy_glTextureMaterialEXT(GLenum face, GLenum mode)                       {if (GLeeInit()) glTextureMaterialEXT(face, mode);}
PFNGLAPPLYTEXTUREEXTPROC pglApplyTextureEXT=_Lazy_glApplyTextureEXT;
PFNGLTEXTURELIGHTEXTPROC pglTextureLightEXT=_Lazy_glTextureLightEXT;
PFNGLTEXTUREMATERIALEXTPROC pglTextureMaterialEXT=_Lazy_glTextureMaterialEXT;
#endif 

/* GL_SGIX_blend_alpha_minmax */

#ifdef __GLEE_GL_SGIX_blend_alpha_minmax
#endif 

/* GL_SGIX_impact_pixel_texture */

#ifdef __GLEE_GL_SGIX_impact_pixel_texture
#endif 

/* GL_EXT_bgra */

#ifdef __GLEE_GL_EXT_bgra
#endif 

/* GL_SGIX_async */

#ifdef __GLEE_GL_SGIX_async
void __stdcall _Lazy_glAsyncMarkerSGIX(GLuint marker)                                     {if (GLeeInit()) glAsyncMarkerSGIX(marker);}
GLint __stdcall _Lazy_glFinishAsyncSGIX(GLuint * markerp)                                 {if (GLeeInit()) return glFinishAsyncSGIX(markerp); return (GLint)0;}
GLint __stdcall _Lazy_glPollAsyncSGIX(GLuint * markerp)                                   {if (GLeeInit()) return glPollAsyncSGIX(markerp); return (GLint)0;}
GLuint __stdcall _Lazy_glGenAsyncMarkersSGIX(GLsizei range)                               {if (GLeeInit()) return glGenAsyncMarkersSGIX(range); return (GLuint)0;}
void __stdcall _Lazy_glDeleteAsyncMarkersSGIX(GLuint marker, GLsizei range)               {if (GLeeInit()) glDeleteAsyncMarkersSGIX(marker, range);}
GLboolean __stdcall _Lazy_glIsAsyncMarkerSGIX(GLuint marker)                              {if (GLeeInit()) return glIsAsyncMarkerSGIX(marker); return (GLboolean)0;}
PFNGLASYNCMARKERSGIXPROC pglAsyncMarkerSGIX=_Lazy_glAsyncMarkerSGIX;
PFNGLFINISHASYNCSGIXPROC pglFinishAsyncSGIX=_Lazy_glFinishAsyncSGIX;
PFNGLPOLLASYNCSGIXPROC pglPollAsyncSGIX=_Lazy_glPollAsyncSGIX;
PFNGLGENASYNCMARKERSSGIXPROC pglGenAsyncMarkersSGIX=_Lazy_glGenAsyncMarkersSGIX;
PFNGLDELETEASYNCMARKERSSGIXPROC pglDeleteAsyncMarkersSGIX=_Lazy_glDeleteAsyncMarkersSGIX;
PFNGLISASYNCMARKERSGIXPROC pglIsAsyncMarkerSGIX=_Lazy_glIsAsyncMarkerSGIX;
#endif 

/* GL_SGIX_async_pixel */

#ifdef __GLEE_GL_SGIX_async_pixel
#endif 

/* GL_SGIX_async_histogram */

#ifdef __GLEE_GL_SGIX_async_histogram
#endif 

/* GL_INTEL_texture_scissor */

#ifdef __GLEE_GL_INTEL_texture_scissor
#endif 

/* GL_INTEL_parallel_arrays */

#ifdef __GLEE_GL_INTEL_parallel_arrays
void __stdcall _Lazy_glVertexPointervINTEL(GLint size, GLenum type, const GLvoid* * pointer)  {if (GLeeInit()) glVertexPointervINTEL(size, type, pointer);}
void __stdcall _Lazy_glNormalPointervINTEL(GLenum type, const GLvoid* * pointer)          {if (GLeeInit()) glNormalPointervINTEL(type, pointer);}
void __stdcall _Lazy_glColorPointervINTEL(GLint size, GLenum type, const GLvoid* * pointer)  {if (GLeeInit()) glColorPointervINTEL(size, type, pointer);}
void __stdcall _Lazy_glTexCoordPointervINTEL(GLint size, GLenum type, const GLvoid* * pointer)  {if (GLeeInit()) glTexCoordPointervINTEL(size, type, pointer);}
PFNGLVERTEXPOINTERVINTELPROC pglVertexPointervINTEL=_Lazy_glVertexPointervINTEL;
PFNGLNORMALPOINTERVINTELPROC pglNormalPointervINTEL=_Lazy_glNormalPointervINTEL;
PFNGLCOLORPOINTERVINTELPROC pglColorPointervINTEL=_Lazy_glColorPointervINTEL;
PFNGLTEXCOORDPOINTERVINTELPROC pglTexCoordPointervINTEL=_Lazy_glTexCoordPointervINTEL;
#endif 

/* GL_HP_occlusion_test */

#ifdef __GLEE_GL_HP_occlusion_test
#endif 

/* GL_EXT_pixel_transform */

#ifdef __GLEE_GL_EXT_pixel_transform
void __stdcall _Lazy_glPixelTransformParameteriEXT(GLenum target, GLenum pname, GLint param)  {if (GLeeInit()) glPixelTransformParameteriEXT(target, pname, param);}
void __stdcall _Lazy_glPixelTransformParameterfEXT(GLenum target, GLenum pname, GLfloat param)  {if (GLeeInit()) glPixelTransformParameterfEXT(target, pname, param);}
void __stdcall _Lazy_glPixelTransformParameterivEXT(GLenum target, GLenum pname, const GLint * params)  {if (GLeeInit()) glPixelTransformParameterivEXT(target, pname, params);}
void __stdcall _Lazy_glPixelTransformParameterfvEXT(GLenum target, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glPixelTransformParameterfvEXT(target, pname, params);}
PFNGLPIXELTRANSFORMPARAMETERIEXTPROC pglPixelTransformParameteriEXT=_Lazy_glPixelTransformParameteriEXT;
PFNGLPIXELTRANSFORMPARAMETERFEXTPROC pglPixelTransformParameterfEXT=_Lazy_glPixelTransformParameterfEXT;
PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC pglPixelTransformParameterivEXT=_Lazy_glPixelTransformParameterivEXT;
PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC pglPixelTransformParameterfvEXT=_Lazy_glPixelTransformParameterfvEXT;
#endif 

/* GL_EXT_pixel_transform_color_table */

#ifdef __GLEE_GL_EXT_pixel_transform_color_table
#endif 

/* GL_EXT_shared_texture_palette */

#ifdef __GLEE_GL_EXT_shared_texture_palette
#endif 

/* GL_EXT_separate_specular_color */

#ifdef __GLEE_GL_EXT_separate_specular_color
#endif 

/* GL_EXT_secondary_color */

#ifdef __GLEE_GL_EXT_secondary_color
void __stdcall _Lazy_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue)         {if (GLeeInit()) glSecondaryColor3bEXT(red, green, blue);}
void __stdcall _Lazy_glSecondaryColor3bvEXT(const GLbyte * v)                             {if (GLeeInit()) glSecondaryColor3bvEXT(v);}
void __stdcall _Lazy_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue)   {if (GLeeInit()) glSecondaryColor3dEXT(red, green, blue);}
void __stdcall _Lazy_glSecondaryColor3dvEXT(const GLdouble * v)                           {if (GLeeInit()) glSecondaryColor3dvEXT(v);}
void __stdcall _Lazy_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue)      {if (GLeeInit()) glSecondaryColor3fEXT(red, green, blue);}
void __stdcall _Lazy_glSecondaryColor3fvEXT(const GLfloat * v)                            {if (GLeeInit()) glSecondaryColor3fvEXT(v);}
void __stdcall _Lazy_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue)            {if (GLeeInit()) glSecondaryColor3iEXT(red, green, blue);}
void __stdcall _Lazy_glSecondaryColor3ivEXT(const GLint * v)                              {if (GLeeInit()) glSecondaryColor3ivEXT(v);}
void __stdcall _Lazy_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue)      {if (GLeeInit()) glSecondaryColor3sEXT(red, green, blue);}
void __stdcall _Lazy_glSecondaryColor3svEXT(const GLshort * v)                            {if (GLeeInit()) glSecondaryColor3svEXT(v);}
void __stdcall _Lazy_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue)     {if (GLeeInit()) glSecondaryColor3ubEXT(red, green, blue);}
void __stdcall _Lazy_glSecondaryColor3ubvEXT(const GLubyte * v)                           {if (GLeeInit()) glSecondaryColor3ubvEXT(v);}
void __stdcall _Lazy_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue)        {if (GLeeInit()) glSecondaryColor3uiEXT(red, green, blue);}
void __stdcall _Lazy_glSecondaryColor3uivEXT(const GLuint * v)                            {if (GLeeInit()) glSecondaryColor3uivEXT(v);}
void __stdcall _Lazy_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue)  {if (GLeeInit()) glSecondaryColor3usEXT(red, green, blue);}
void __stdcall _Lazy_glSecondaryColor3usvEXT(const GLushort * v)                          {if (GLeeInit()) glSecondaryColor3usvEXT(v);}
void __stdcall _Lazy_glSecondaryColorPointerEXT(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)  {if (GLeeInit()) glSecondaryColorPointerEXT(size, type, stride, pointer);}
PFNGLSECONDARYCOLOR3BEXTPROC pglSecondaryColor3bEXT=_Lazy_glSecondaryColor3bEXT;
PFNGLSECONDARYCOLOR3BVEXTPROC pglSecondaryColor3bvEXT=_Lazy_glSecondaryColor3bvEXT;
PFNGLSECONDARYCOLOR3DEXTPROC pglSecondaryColor3dEXT=_Lazy_glSecondaryColor3dEXT;
PFNGLSECONDARYCOLOR3DVEXTPROC pglSecondaryColor3dvEXT=_Lazy_glSecondaryColor3dvEXT;
PFNGLSECONDARYCOLOR3FEXTPROC pglSecondaryColor3fEXT=_Lazy_glSecondaryColor3fEXT;
PFNGLSECONDARYCOLOR3FVEXTPROC pglSecondaryColor3fvEXT=_Lazy_glSecondaryColor3fvEXT;
PFNGLSECONDARYCOLOR3IEXTPROC pglSecondaryColor3iEXT=_Lazy_glSecondaryColor3iEXT;
PFNGLSECONDARYCOLOR3IVEXTPROC pglSecondaryColor3ivEXT=_Lazy_glSecondaryColor3ivEXT;
PFNGLSECONDARYCOLOR3SEXTPROC pglSecondaryColor3sEXT=_Lazy_glSecondaryColor3sEXT;
PFNGLSECONDARYCOLOR3SVEXTPROC pglSecondaryColor3svEXT=_Lazy_glSecondaryColor3svEXT;
PFNGLSECONDARYCOLOR3UBEXTPROC pglSecondaryColor3ubEXT=_Lazy_glSecondaryColor3ubEXT;
PFNGLSECONDARYCOLOR3UBVEXTPROC pglSecondaryColor3ubvEXT=_Lazy_glSecondaryColor3ubvEXT;
PFNGLSECONDARYCOLOR3UIEXTPROC pglSecondaryColor3uiEXT=_Lazy_glSecondaryColor3uiEXT;
PFNGLSECONDARYCOLOR3UIVEXTPROC pglSecondaryColor3uivEXT=_Lazy_glSecondaryColor3uivEXT;
PFNGLSECONDARYCOLOR3USEXTPROC pglSecondaryColor3usEXT=_Lazy_glSecondaryColor3usEXT;
PFNGLSECONDARYCOLOR3USVEXTPROC pglSecondaryColor3usvEXT=_Lazy_glSecondaryColor3usvEXT;
PFNGLSECONDARYCOLORPOINTEREXTPROC pglSecondaryColorPointerEXT=_Lazy_glSecondaryColorPointerEXT;
#endif 

/* GL_EXT_texture_perturb_normal */

#ifdef __GLEE_GL_EXT_texture_perturb_normal
void __stdcall _Lazy_glTextureNormalEXT(GLenum mode)                                      {if (GLeeInit()) glTextureNormalEXT(mode);}
PFNGLTEXTURENORMALEXTPROC pglTextureNormalEXT=_Lazy_glTextureNormalEXT;
#endif 

/* GL_EXT_multi_draw_arrays */

#ifdef __GLEE_GL_EXT_multi_draw_arrays
void __stdcall _Lazy_glMultiDrawArraysEXT(GLenum mode, GLint * first, GLsizei * count, GLsizei primcount)  {if (GLeeInit()) glMultiDrawArraysEXT(mode, first, count, primcount);}
void __stdcall _Lazy_glMultiDrawElementsEXT(GLenum mode, const GLsizei * count, GLenum type, const GLvoid* * indices, GLsizei primcount)  {if (GLeeInit()) glMultiDrawElementsEXT(mode, count, type, indices, primcount);}
PFNGLMULTIDRAWARRAYSEXTPROC pglMultiDrawArraysEXT=_Lazy_glMultiDrawArraysEXT;
PFNGLMULTIDRAWELEMENTSEXTPROC pglMultiDrawElementsEXT=_Lazy_glMultiDrawElementsEXT;
#endif 

/* GL_EXT_fog_coord */

#ifdef __GLEE_GL_EXT_fog_coord
void __stdcall _Lazy_glFogCoordfEXT(GLfloat coord)                                        {if (GLeeInit()) glFogCoordfEXT(coord);}
void __stdcall _Lazy_glFogCoordfvEXT(const GLfloat * coord)                               {if (GLeeInit()) glFogCoordfvEXT(coord);}
void __stdcall _Lazy_glFogCoorddEXT(GLdouble coord)                                       {if (GLeeInit()) glFogCoorddEXT(coord);}
void __stdcall _Lazy_glFogCoorddvEXT(const GLdouble * coord)                              {if (GLeeInit()) glFogCoorddvEXT(coord);}
void __stdcall _Lazy_glFogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid * pointer)  {if (GLeeInit()) glFogCoordPointerEXT(type, stride, pointer);}
PFNGLFOGCOORDFEXTPROC pglFogCoordfEXT=_Lazy_glFogCoordfEXT;
PFNGLFOGCOORDFVEXTPROC pglFogCoordfvEXT=_Lazy_glFogCoordfvEXT;
PFNGLFOGCOORDDEXTPROC pglFogCoorddEXT=_Lazy_glFogCoorddEXT;
PFNGLFOGCOORDDVEXTPROC pglFogCoorddvEXT=_Lazy_glFogCoorddvEXT;
PFNGLFOGCOORDPOINTEREXTPROC pglFogCoordPointerEXT=_Lazy_glFogCoordPointerEXT;
#endif 

/* GL_REND_screen_coordinates */

#ifdef __GLEE_GL_REND_screen_coordinates
#endif 

/* GL_EXT_coordinate_frame */

#ifdef __GLEE_GL_EXT_coordinate_frame
void __stdcall _Lazy_glTangent3bEXT(GLbyte tx, GLbyte ty, GLbyte tz)                      {if (GLeeInit()) glTangent3bEXT(tx, ty, tz);}
void __stdcall _Lazy_glTangent3bvEXT(const GLbyte * v)                                    {if (GLeeInit()) glTangent3bvEXT(v);}
void __stdcall _Lazy_glTangent3dEXT(GLdouble tx, GLdouble ty, GLdouble tz)                {if (GLeeInit()) glTangent3dEXT(tx, ty, tz);}
void __stdcall _Lazy_glTangent3dvEXT(const GLdouble * v)                                  {if (GLeeInit()) glTangent3dvEXT(v);}
void __stdcall _Lazy_glTangent3fEXT(GLfloat tx, GLfloat ty, GLfloat tz)                   {if (GLeeInit()) glTangent3fEXT(tx, ty, tz);}
void __stdcall _Lazy_glTangent3fvEXT(const GLfloat * v)                                   {if (GLeeInit()) glTangent3fvEXT(v);}
void __stdcall _Lazy_glTangent3iEXT(GLint tx, GLint ty, GLint tz)                         {if (GLeeInit()) glTangent3iEXT(tx, ty, tz);}
void __stdcall _Lazy_glTangent3ivEXT(const GLint * v)                                     {if (GLeeInit()) glTangent3ivEXT(v);}
void __stdcall _Lazy_glTangent3sEXT(GLshort tx, GLshort ty, GLshort tz)                   {if (GLeeInit()) glTangent3sEXT(tx, ty, tz);}
void __stdcall _Lazy_glTangent3svEXT(const GLshort * v)                                   {if (GLeeInit()) glTangent3svEXT(v);}
void __stdcall _Lazy_glBinormal3bEXT(GLbyte bx, GLbyte by, GLbyte bz)                     {if (GLeeInit()) glBinormal3bEXT(bx, by, bz);}
void __stdcall _Lazy_glBinormal3bvEXT(const GLbyte * v)                                   {if (GLeeInit()) glBinormal3bvEXT(v);}
void __stdcall _Lazy_glBinormal3dEXT(GLdouble bx, GLdouble by, GLdouble bz)               {if (GLeeInit()) glBinormal3dEXT(bx, by, bz);}
void __stdcall _Lazy_glBinormal3dvEXT(const GLdouble * v)                                 {if (GLeeInit()) glBinormal3dvEXT(v);}
void __stdcall _Lazy_glBinormal3fEXT(GLfloat bx, GLfloat by, GLfloat bz)                  {if (GLeeInit()) glBinormal3fEXT(bx, by, bz);}
void __stdcall _Lazy_glBinormal3fvEXT(const GLfloat * v)                                  {if (GLeeInit()) glBinormal3fvEXT(v);}
void __stdcall _Lazy_glBinormal3iEXT(GLint bx, GLint by, GLint bz)                        {if (GLeeInit()) glBinormal3iEXT(bx, by, bz);}
void __stdcall _Lazy_glBinormal3ivEXT(const GLint * v)                                    {if (GLeeInit()) glBinormal3ivEXT(v);}
void __stdcall _Lazy_glBinormal3sEXT(GLshort bx, GLshort by, GLshort bz)                  {if (GLeeInit()) glBinormal3sEXT(bx, by, bz);}
void __stdcall _Lazy_glBinormal3svEXT(const GLshort * v)                                  {if (GLeeInit()) glBinormal3svEXT(v);}
void __stdcall _Lazy_glTangentPointerEXT(GLenum type, GLsizei stride, const GLvoid * pointer)  {if (GLeeInit()) glTangentPointerEXT(type, stride, pointer);}
void __stdcall _Lazy_glBinormalPointerEXT(GLenum type, GLsizei stride, const GLvoid * pointer)  {if (GLeeInit()) glBinormalPointerEXT(type, stride, pointer);}
PFNGLTANGENT3BEXTPROC pglTangent3bEXT=_Lazy_glTangent3bEXT;
PFNGLTANGENT3BVEXTPROC pglTangent3bvEXT=_Lazy_glTangent3bvEXT;
PFNGLTANGENT3DEXTPROC pglTangent3dEXT=_Lazy_glTangent3dEXT;
PFNGLTANGENT3DVEXTPROC pglTangent3dvEXT=_Lazy_glTangent3dvEXT;
PFNGLTANGENT3FEXTPROC pglTangent3fEXT=_Lazy_glTangent3fEXT;
PFNGLTANGENT3FVEXTPROC pglTangent3fvEXT=_Lazy_glTangent3fvEXT;
PFNGLTANGENT3IEXTPROC pglTangent3iEXT=_Lazy_glTangent3iEXT;
PFNGLTANGENT3IVEXTPROC pglTangent3ivEXT=_Lazy_glTangent3ivEXT;
PFNGLTANGENT3SEXTPROC pglTangent3sEXT=_Lazy_glTangent3sEXT;
PFNGLTANGENT3SVEXTPROC pglTangent3svEXT=_Lazy_glTangent3svEXT;
PFNGLBINORMAL3BEXTPROC pglBinormal3bEXT=_Lazy_glBinormal3bEXT;
PFNGLBINORMAL3BVEXTPROC pglBinormal3bvEXT=_Lazy_glBinormal3bvEXT;
PFNGLBINORMAL3DEXTPROC pglBinormal3dEXT=_Lazy_glBinormal3dEXT;
PFNGLBINORMAL3DVEXTPROC pglBinormal3dvEXT=_Lazy_glBinormal3dvEXT;
PFNGLBINORMAL3FEXTPROC pglBinormal3fEXT=_Lazy_glBinormal3fEXT;
PFNGLBINORMAL3FVEXTPROC pglBinormal3fvEXT=_Lazy_glBinormal3fvEXT;
PFNGLBINORMAL3IEXTPROC pglBinormal3iEXT=_Lazy_glBinormal3iEXT;