GLee.c

PFNGLDRAWRANGEELEMENTARRAYATIPROC pglDrawRangeElementArrayATI=_Lazy_glDrawRangeElementArrayATI;
#endif 

/* GL_SUN_mesh_array */

#ifdef __GLEE_GL_SUN_mesh_array
void __stdcall _Lazy_glDrawMeshArraysSUN(GLenum mode, GLint first, GLsizei count, GLsizei width)  {if (GLeeInit()) glDrawMeshArraysSUN(mode, first, count, width);}
PFNGLDRAWMESHARRAYSSUNPROC pglDrawMeshArraysSUN=_Lazy_glDrawMeshArraysSUN;
#endif 

/* GL_SUN_slice_accum */

#ifdef __GLEE_GL_SUN_slice_accum
#endif 

/* GL_NV_multisample_filter_hint */

#ifdef __GLEE_GL_NV_multisample_filter_hint
#endif 

/* GL_NV_depth_clamp */

#ifdef __GLEE_GL_NV_depth_clamp
#endif 

/* GL_NV_occlusion_query */

#ifdef __GLEE_GL_NV_occlusion_query
void __stdcall _Lazy_glGenOcclusionQueriesNV(GLsizei n, GLuint * ids)                     {if (GLeeInit()) glGenOcclusionQueriesNV(n, ids);}
void __stdcall _Lazy_glDeleteOcclusionQueriesNV(GLsizei n, const GLuint * ids)            {if (GLeeInit()) glDeleteOcclusionQueriesNV(n, ids);}
GLboolean __stdcall _Lazy_glIsOcclusionQueryNV(GLuint id)                                 {if (GLeeInit()) return glIsOcclusionQueryNV(id); return (GLboolean)0;}
void __stdcall _Lazy_glBeginOcclusionQueryNV(GLuint id)                                   {if (GLeeInit()) glBeginOcclusionQueryNV(id);}
void __stdcall _Lazy_glEndOcclusionQueryNV(void)                                          {if (GLeeInit()) glEndOcclusionQueryNV();}
void __stdcall _Lazy_glGetOcclusionQueryivNV(GLuint id, GLenum pname, GLint * params)     {if (GLeeInit()) glGetOcclusionQueryivNV(id, pname, params);}
void __stdcall _Lazy_glGetOcclusionQueryuivNV(GLuint id, GLenum pname, GLuint * params)   {if (GLeeInit()) glGetOcclusionQueryuivNV(id, pname, params);}
PFNGLGENOCCLUSIONQUERIESNVPROC pglGenOcclusionQueriesNV=_Lazy_glGenOcclusionQueriesNV;
PFNGLDELETEOCCLUSIONQUERIESNVPROC pglDeleteOcclusionQueriesNV=_Lazy_glDeleteOcclusionQueriesNV;
PFNGLISOCCLUSIONQUERYNVPROC pglIsOcclusionQueryNV=_Lazy_glIsOcclusionQueryNV;
PFNGLBEGINOCCLUSIONQUERYNVPROC pglBeginOcclusionQueryNV=_Lazy_glBeginOcclusionQueryNV;
PFNGLENDOCCLUSIONQUERYNVPROC pglEndOcclusionQueryNV=_Lazy_glEndOcclusionQueryNV;
PFNGLGETOCCLUSIONQUERYIVNVPROC pglGetOcclusionQueryivNV=_Lazy_glGetOcclusionQueryivNV;
PFNGLGETOCCLUSIONQUERYUIVNVPROC pglGetOcclusionQueryuivNV=_Lazy_glGetOcclusionQueryuivNV;
#endif 

/* GL_NV_point_sprite */

#ifdef __GLEE_GL_NV_point_sprite
void __stdcall _Lazy_glPointParameteriNV(GLenum pname, GLint param)                       {if (GLeeInit()) glPointParameteriNV(pname, param);}
void __stdcall _Lazy_glPointParameterivNV(GLenum pname, const GLint * params)             {if (GLeeInit()) glPointParameterivNV(pname, params);}
PFNGLPOINTPARAMETERINVPROC pglPointParameteriNV=_Lazy_glPointParameteriNV;
PFNGLPOINTPARAMETERIVNVPROC pglPointParameterivNV=_Lazy_glPointParameterivNV;
#endif 

/* GL_NV_texture_shader3 */

#ifdef __GLEE_GL_NV_texture_shader3
#endif 

/* GL_NV_vertex_program1_1 */

#ifdef __GLEE_GL_NV_vertex_program1_1
#endif 

/* GL_EXT_shadow_funcs */

#ifdef __GLEE_GL_EXT_shadow_funcs
#endif 

/* GL_EXT_stencil_two_side */

#ifdef __GLEE_GL_EXT_stencil_two_side
void __stdcall _Lazy_glActiveStencilFaceEXT(GLenum face)                                  {if (GLeeInit()) glActiveStencilFaceEXT(face);}
PFNGLACTIVESTENCILFACEEXTPROC pglActiveStencilFaceEXT=_Lazy_glActiveStencilFaceEXT;
#endif 

/* GL_ATI_text_fragment_shader */

#ifdef __GLEE_GL_ATI_text_fragment_shader
#endif 

/* GL_APPLE_client_storage */

#ifdef __GLEE_GL_APPLE_client_storage
#endif 

/* GL_APPLE_element_array */

#ifdef __GLEE_GL_APPLE_element_array
void __stdcall _Lazy_glElementPointerAPPLE(GLenum type, const GLvoid * pointer)           {if (GLeeInit()) glElementPointerAPPLE(type, pointer);}
void __stdcall _Lazy_glDrawElementArrayAPPLE(GLenum mode, GLint first, GLsizei count)     {if (GLeeInit()) glDrawElementArrayAPPLE(mode, first, count);}
void __stdcall _Lazy_glDrawRangeElementArrayAPPLE(GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count)  {if (GLeeInit()) glDrawRangeElementArrayAPPLE(mode, start, end, first, count);}
void __stdcall _Lazy_glMultiDrawElementArrayAPPLE(GLenum mode, const GLint * first, const GLsizei * count, GLsizei primcount)  {if (GLeeInit()) glMultiDrawElementArrayAPPLE(mode, first, count, primcount);}
void __stdcall _Lazy_glMultiDrawRangeElementArrayAPPLE(GLenum mode, GLuint start, GLuint end, const GLint * first, const GLsizei * count, GLsizei primcount)  {if (GLeeInit()) glMultiDrawRangeElementArrayAPPLE(mode, start, end, first, count, primcount);}
PFNGLELEMENTPOINTERAPPLEPROC pglElementPointerAPPLE=_Lazy_glElementPointerAPPLE;
PFNGLDRAWELEMENTARRAYAPPLEPROC pglDrawElementArrayAPPLE=_Lazy_glDrawElementArrayAPPLE;
PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC pglDrawRangeElementArrayAPPLE=_Lazy_glDrawRangeElementArrayAPPLE;
PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC pglMultiDrawElementArrayAPPLE=_Lazy_glMultiDrawElementArrayAPPLE;
PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC pglMultiDrawRangeElementArrayAPPLE=_Lazy_glMultiDrawRangeElementArrayAPPLE;
#endif 

/* GL_APPLE_fence */

#ifdef __GLEE_GL_APPLE_fence
void __stdcall _Lazy_glGenFencesAPPLE(GLsizei n, GLuint * fences)                         {if (GLeeInit()) glGenFencesAPPLE(n, fences);}
void __stdcall _Lazy_glDeleteFencesAPPLE(GLsizei n, const GLuint * fences)                {if (GLeeInit()) glDeleteFencesAPPLE(n, fences);}
void __stdcall _Lazy_glSetFenceAPPLE(GLuint fence)                                        {if (GLeeInit()) glSetFenceAPPLE(fence);}
GLboolean __stdcall _Lazy_glIsFenceAPPLE(GLuint fence)                                    {if (GLeeInit()) return glIsFenceAPPLE(fence); return (GLboolean)0;}
GLboolean __stdcall _Lazy_glTestFenceAPPLE(GLuint fence)                                  {if (GLeeInit()) return glTestFenceAPPLE(fence); return (GLboolean)0;}
void __stdcall _Lazy_glFinishFenceAPPLE(GLuint fence)                                     {if (GLeeInit()) glFinishFenceAPPLE(fence);}
GLboolean __stdcall _Lazy_glTestObjectAPPLE(GLenum object, GLuint name)                   {if (GLeeInit()) return glTestObjectAPPLE(object, name); return (GLboolean)0;}
void __stdcall _Lazy_glFinishObjectAPPLE(GLenum object, GLint name)                       {if (GLeeInit()) glFinishObjectAPPLE(object, name);}
PFNGLGENFENCESAPPLEPROC pglGenFencesAPPLE=_Lazy_glGenFencesAPPLE;
PFNGLDELETEFENCESAPPLEPROC pglDeleteFencesAPPLE=_Lazy_glDeleteFencesAPPLE;
PFNGLSETFENCEAPPLEPROC pglSetFenceAPPLE=_Lazy_glSetFenceAPPLE;
PFNGLISFENCEAPPLEPROC pglIsFenceAPPLE=_Lazy_glIsFenceAPPLE;
PFNGLTESTFENCEAPPLEPROC pglTestFenceAPPLE=_Lazy_glTestFenceAPPLE;
PFNGLFINISHFENCEAPPLEPROC pglFinishFenceAPPLE=_Lazy_glFinishFenceAPPLE;
PFNGLTESTOBJECTAPPLEPROC pglTestObjectAPPLE=_Lazy_glTestObjectAPPLE;
PFNGLFINISHOBJECTAPPLEPROC pglFinishObjectAPPLE=_Lazy_glFinishObjectAPPLE;
#endif 

/* GL_APPLE_vertex_array_object */

#ifdef __GLEE_GL_APPLE_vertex_array_object
void __stdcall _Lazy_glBindVertexArrayAPPLE(GLuint array)                                 {if (GLeeInit()) glBindVertexArrayAPPLE(array);}
void __stdcall _Lazy_glDeleteVertexArraysAPPLE(GLsizei n, const GLuint * arrays)          {if (GLeeInit()) glDeleteVertexArraysAPPLE(n, arrays);}
void __stdcall _Lazy_glGenVertexArraysAPPLE(GLsizei n, GLuint * arrays)                   {if (GLeeInit()) glGenVertexArraysAPPLE(n, arrays);}
GLboolean __stdcall _Lazy_glIsVertexArrayAPPLE(GLuint array)                              {if (GLeeInit()) return glIsVertexArrayAPPLE(array); return (GLboolean)0;}
PFNGLBINDVERTEXARRAYAPPLEPROC pglBindVertexArrayAPPLE=_Lazy_glBindVertexArrayAPPLE;
PFNGLDELETEVERTEXARRAYSAPPLEPROC pglDeleteVertexArraysAPPLE=_Lazy_glDeleteVertexArraysAPPLE;
PFNGLGENVERTEXARRAYSAPPLEPROC pglGenVertexArraysAPPLE=_Lazy_glGenVertexArraysAPPLE;
PFNGLISVERTEXARRAYAPPLEPROC pglIsVertexArrayAPPLE=_Lazy_glIsVertexArrayAPPLE;
#endif 

/* GL_APPLE_vertex_array_range */

#ifdef __GLEE_GL_APPLE_vertex_array_range
void __stdcall _Lazy_glVertexArrayRangeAPPLE(GLsizei length, GLvoid * pointer)            {if (GLeeInit()) glVertexArrayRangeAPPLE(length, pointer);}
void __stdcall _Lazy_glFlushVertexArrayRangeAPPLE(GLsizei length, GLvoid * pointer)       {if (GLeeInit()) glFlushVertexArrayRangeAPPLE(length, pointer);}
void __stdcall _Lazy_glVertexArrayParameteriAPPLE(GLenum pname, GLint param)              {if (GLeeInit()) glVertexArrayParameteriAPPLE(pname, param);}
PFNGLVERTEXARRAYRANGEAPPLEPROC pglVertexArrayRangeAPPLE=_Lazy_glVertexArrayRangeAPPLE;
PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC pglFlushVertexArrayRangeAPPLE=_Lazy_glFlushVertexArrayRangeAPPLE;
PFNGLVERTEXARRAYPARAMETERIAPPLEPROC pglVertexArrayParameteriAPPLE=_Lazy_glVertexArrayParameteriAPPLE;
#endif 

/* GL_APPLE_ycbcr_422 */

#ifdef __GLEE_GL_APPLE_ycbcr_422
#endif 

/* GL_S3_s3tc */

#ifdef __GLEE_GL_S3_s3tc
#endif 

/* GL_ATI_draw_buffers */

#ifdef __GLEE_GL_ATI_draw_buffers
void __stdcall _Lazy_glDrawBuffersATI(GLsizei n, const GLenum * bufs)                     {if (GLeeInit()) glDrawBuffersATI(n, bufs);}
PFNGLDRAWBUFFERSATIPROC pglDrawBuffersATI=_Lazy_glDrawBuffersATI;
#endif 

/* GL_ATI_pixel_format_float */

#ifdef __GLEE_GL_ATI_pixel_format_float
#endif 

/* GL_ATI_texture_env_combine3 */

#ifdef __GLEE_GL_ATI_texture_env_combine3
#endif 

/* GL_ATI_texture_float */

#ifdef __GLEE_GL_ATI_texture_float
#endif 

/* GL_NV_float_buffer */

#ifdef __GLEE_GL_NV_float_buffer
#endif 

/* GL_NV_fragment_program */

#ifdef __GLEE_GL_NV_fragment_program
void __stdcall _Lazy_glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)  {if (GLeeInit()) glProgramNamedParameter4fNV(id, len, name, x, y, z, w);}
void __stdcall _Lazy_glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)  {if (GLeeInit()) glProgramNamedParameter4dNV(id, len, name, x, y, z, w);}
void __stdcall _Lazy_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v)  {if (GLeeInit()) glProgramNamedParameter4fvNV(id, len, name, v);}
void __stdcall _Lazy_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v)  {if (GLeeInit()) glProgramNamedParameter4dvNV(id, len, name, v);}
void __stdcall _Lazy_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params)  {if (GLeeInit()) glGetProgramNamedParameterfvNV(id, len, name, params);}
void __stdcall _Lazy_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params)  {if (GLeeInit()) glGetProgramNamedParameterdvNV(id, len, name, params);}
PFNGLPROGRAMNAMEDPARAMETER4FNVPROC pglProgramNamedParameter4fNV=_Lazy_glProgramNamedParameter4fNV;
PFNGLPROGRAMNAMEDPARAMETER4DNVPROC pglProgramNamedParameter4dNV=_Lazy_glProgramNamedParameter4dNV;
PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC pglProgramNamedParameter4fvNV=_Lazy_glProgramNamedParameter4fvNV;
PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC pglProgramNamedParameter4dvNV=_Lazy_glProgramNamedParameter4dvNV;
PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC pglGetProgramNamedParameterfvNV=_Lazy_glGetProgramNamedParameterfvNV;
PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC pglGetProgramNamedParameterdvNV=_Lazy_glGetProgramNamedParameterdvNV;
#endif 

/* GL_NV_half_float */

#ifdef __GLEE_GL_NV_half_float
void __stdcall _Lazy_glVertex2hNV(GLhalfNV x, GLhalfNV y)                                 {if (GLeeInit()) glVertex2hNV(x, y);}
void __stdcall _Lazy_glVertex2hvNV(const GLhalfNV * v)                                    {if (GLeeInit()) glVertex2hvNV(v);}
void __stdcall _Lazy_glVertex3hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z)                     {if (GLeeInit()) glVertex3hNV(x, y, z);}
void __stdcall _Lazy_glVertex3hvNV(const GLhalfNV * v)                                    {if (GLeeInit()) glVertex3hvNV(v);}
void __stdcall _Lazy_glVertex4hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)         {if (GLeeInit()) glVertex4hNV(x, y, z, w);}
void __stdcall _Lazy_glVertex4hvNV(const GLhalfNV * v)                                    {if (GLeeInit()) glVertex4hvNV(v);}
void __stdcall _Lazy_glNormal3hNV(GLhalfNV nx, GLhalfNV ny, GLhalfNV nz)                  {if (GLeeInit()) glNormal3hNV(nx, ny, nz);}
void __stdcall _Lazy_glNormal3hvNV(const GLhalfNV * v)                                    {if (GLeeInit()) glNormal3hvNV(v);}
void __stdcall _Lazy_glColor3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue)             {if (GLeeInit()) glColor3hNV(red, green, blue);}
void __stdcall _Lazy_glColor3hvNV(const GLhalfNV * v)                                     {if (GLeeInit()) glColor3hvNV(v);}
void __stdcall _Lazy_glColor4hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha)  {if (GLeeInit()) glColor4hNV(red, green, blue, alpha);}
void __stdcall _Lazy_glColor4hvNV(const GLhalfNV * v)                                     {if (GLeeInit()) glColor4hvNV(v);}
void __stdcall _Lazy_glTexCoord1hNV(GLhalfNV s)                                           {if (GLeeInit()) glTexCoord1hNV(s);}
void __stdcall _Lazy_glTexCoord1hvNV(const GLhalfNV * v)                                  {if (GLeeInit()) glTexCoord1hvNV(v);}
void __stdcall _Lazy_glTexCoord2hNV(GLhalfNV s, GLhalfNV t)                               {if (GLeeInit()) glTexCoord2hNV(s, t);}
void __stdcall _Lazy_glTexCoord2hvNV(const GLhalfNV * v)                                  {if (GLeeInit()) glTexCoord2hvNV(v);}
void __stdcall _Lazy_glTexCoord3hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r)                   {if (GLeeInit()) glTexCoord3hNV(s, t, r);}
void __stdcall _Lazy_glTexCoord3hvNV(const GLhalfNV * v)                                  {if (GLeeInit()) glTexCoord3hvNV(v);}
void __stdcall _Lazy_glTexCoord4hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q)       {if (GLeeInit()) glTexCoord4hNV(s, t, r, q);}
void __stdcall _Lazy_glTexCoord4hvNV(const GLhalfNV * v)                                  {if (GLeeInit()) glTexCoord4hvNV(v);}
void __stdcall _Lazy_glMultiTexCoord1hNV(GLenum target, GLhalfNV s)                       {if (GLeeInit()) glMultiTexCoord1hNV(target, s);}
void __stdcall _Lazy_glMultiTexCoord1hvNV(GLenum target, const GLhalfNV * v)              {if (GLeeInit()) glMultiTexCoord1hvNV(target, v);}
void __stdcall _Lazy_glMultiTexCoord2hNV(GLenum target, GLhalfNV s, GLhalfNV t)           {if (GLeeInit()) glMultiTexCoord2hNV(target, s, t);}
void __stdcall _Lazy_glMultiTexCoord2hvNV(GLenum target, const GLhalfNV * v)              {if (GLeeInit()) glMultiTexCoord2hvNV(target, v);}
void __stdcall _Lazy_glMultiTexCoord3hNV(GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r)  {if (GLeeInit()) glMultiTexCoord3hNV(target, s, t, r);}
void __stdcall _Lazy_glMultiTexCoord3hvNV(GLenum target, const GLhalfNV * v)              {if (GLeeInit()) glMultiTexCoord3hvNV(target, v);}
void __stdcall _Lazy_glMultiTexCoord4hNV(GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q)  {if (GLeeInit()) glMultiTexCoord4hNV(target, s, t, r, q);}
void __stdcall _Lazy_glMultiTexCoord4hvNV(GLenum target, const GLhalfNV * v)              {if (GLeeInit()) glMultiTexCoord4hvNV(target, v);}
void __stdcall _Lazy_glFogCoordhNV(GLhalfNV fog)                                          {if (GLeeInit()) glFogCoordhNV(fog);}
void __stdcall _Lazy_glFogCoordhvNV(const GLhalfNV * fog)                                 {if (GLeeInit()) glFogCoordhvNV(fog);}
void __stdcall _Lazy_glSecondaryColor3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue)    {if (GLeeInit()) glSecondaryColor3hNV(red, green, blue);}
void __stdcall _Lazy_glSecondaryColor3hvNV(const GLhalfNV * v)                            {if (GLeeInit()) glSecondaryColor3hvNV(v);}
void __stdcall _Lazy_glVertexWeighthNV(GLhalfNV weight)                                   {if (GLeeInit()) glVertexWeighthNV(weight);}
void __stdcall _Lazy_glVertexWeighthvNV(const GLhalfNV * weight)                          {if (GLeeInit()) glVertexWeighthvNV(weight);}
void __stdcall _Lazy_glVertexAttrib1hNV(GLuint index, GLhalfNV x)                         {if (GLeeInit()) glVertexAttrib1hNV(index, x);}
void __stdcall _Lazy_glVertexAttrib1hvNV(GLuint index, const GLhalfNV * v)                {if (GLeeInit()) glVertexAttrib1hvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib2hNV(GLuint index, GLhalfNV x, GLhalfNV y)             {if (GLeeInit()) glVertexAttrib2hNV(index, x, y);}
void __stdcall _Lazy_glVertexAttrib2hvNV(GLuint index, const GLhalfNV * v)                {if (GLeeInit()) glVertexAttrib2hvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib3hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z)  {if (GLeeInit()) glVertexAttrib3hNV(index, x, y, z);}
void __stdcall _Lazy_glVertexAttrib3hvNV(GLuint index, const GLhalfNV * v)                {if (GLeeInit()) glVertexAttrib3hvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib4hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)  {if (GLeeInit()) glVertexAttrib4hNV(index, x, y, z, w);}
void __stdcall _Lazy_glVertexAttrib4hvNV(GLuint index, const GLhalfNV * v)                {if (GLeeInit()) glVertexAttrib4hvNV(index, v);}
void __stdcall _Lazy_glVertexAttribs1hvNV(GLuint index, GLsizei n, const GLhalfNV * v)    {if (GLeeInit()) glVertexAttribs1hvNV(index, n, v);}
void __stdcall _Lazy_glVertexAttribs2hvNV(GLuint index, GLsizei n, const GLhalfNV * v)    {if (GLeeInit()) glVertexAttribs2hvNV(index, n, v);}
void __stdcall _Lazy_glVertexAttribs3hvNV(GLuint index, GLsizei n, const GLhalfNV * v)    {if (GLeeInit()) glVertexAttribs3hvNV(index, n, v);}
void __stdcall _Lazy_glVertexAttribs4hvNV(GLuint index, GLsizei n, const GLhalfNV * v)    {if (GLeeInit()) glVertexAttribs4hvNV(index, n, v);}
PFNGLVERTEX2HNVPROC pglVertex2hNV=_Lazy_glVertex2hNV;
PFNGLVERTEX2HVNVPROC pglVertex2hvNV=_Lazy_glVertex2hvNV;
PFNGLVERTEX3HNVPROC pglVertex3hNV=_Lazy_glVertex3hNV;
PFNGLVERTEX3HVNVPROC pglVertex3hvNV=_Lazy_glVertex3hvNV;
PFNGLVERTEX4HNVPROC pglVertex4hNV=_Lazy_glVertex4hNV;
PFNGLVERTEX4HVNVPROC pglVertex4hvNV=_Lazy_glVertex4hvNV;
PFNGLNORMAL3HNVPROC pglNormal3hNV=_Lazy_glNormal3hNV;
PFNGLNORMAL3HVNVPROC pglNormal3hvNV=_Lazy_glNormal3hvNV;
PFNGLCOLOR3HNVPROC pglColor3hNV=_Lazy_glColor3hNV;
PFNGLCOLOR3HVNVPROC pglColor3hvNV=_Lazy_glColor3hvNV;
PFNGLCOLOR4HNVPROC pglColor4hNV=_Lazy_glColor4hNV;
PFNGLCOLOR4HVNVPROC pglColor4hvNV=_Lazy_glColor4hvNV;
PFNGLTEXCOORD1HNVPROC pglTexCoord1hNV=_Lazy_glTexCoord1hNV;
PFNGLTEXCOORD1HVNVPROC pglTexCoord1hvNV=_Lazy_glTexCoord1hvNV;
PFNGLTEXCOORD2HNVPROC pglTexCoord2hNV=_Lazy_glTexCoord2hNV;
PFNGLTEXCOORD2HVNVPROC pglTexCoord2hvNV=_Lazy_glTexCoord2hvNV;
PFNGLTEXCOORD3HNVPROC pglTexCoord3hNV=_Lazy_glTexCoord3hNV;
PFNGLTEXCOORD3HVNVPROC pglTexCoord3hvNV=_Lazy_glTexCoord3hvNV;
PFNGLTEXCOORD4HNVPROC pglTexCoord4hNV=_Lazy_glTexCoord4hNV;
PFNGLTEXCOORD4HVNVPROC pglTexCoord4hvNV=_Lazy_glTexCoord4hvNV;
PFNGLMULTITEXCOORD1HNVPROC pglMultiTexCoord1hNV=_Lazy_glMultiTexCoord1hNV;
PFNGLMULTITEXCOORD1HVNVPROC pglMultiTexCoord1hvNV=_Lazy_glMultiTexCoord1hvNV;
PFNGLMULTITEXCOORD2HNVPROC pglMultiTexCoord2hNV=_Lazy_glMultiTexCoord2hNV;
PFNGLMULTITEXCOORD2HVNVPROC pglMultiTexCoord2hvNV=_Lazy_glMultiTexCoord2hvNV;
PFNGLMULTITEXCOORD3HNVPROC pglMultiTexCoord3hNV=_Lazy_glMultiTexCoord3hNV;
PFNGLMULTITEXCOORD3HVNVPROC pglMultiTexCoord3hvNV=_Lazy_glMultiTexCoord3hvNV;
PFNGLMULTITEXCOORD4HNVPROC pglMultiTexCoord4hNV=_Lazy_glMultiTexCoord4hNV;
PFNGLMULTITEXCOORD4HVNVPROC pglMultiTexCoord4hvNV=_Lazy_glMultiTexCoord4hvNV;
PFNGLFOGCOORDHNVPROC pglFogCoordhNV=_Lazy_glFogCoordhNV;
PFNGLFOGCOORDHVNVPROC pglFogCoordhvNV=_Lazy_glFogCoordhvNV;
PFNGLSECONDARYCOLOR3HNVPROC pglSecondaryColor3hNV=_Lazy_glSecondaryColor3hNV;
PFNGLSECONDARYCOLOR3HVNVPROC pglSecondaryColor3hvNV=_Lazy_glSecondaryColor3hvNV;
PFNGLVERTEXWEIGHTHNVPROC pglVertexWeighthNV=_Lazy_glVertexWeighthNV;
PFNGLVERTEXWEIGHTHVNVPROC pglVertexWeighthvNV=_Lazy_glVertexWeighthvNV;
PFNGLVERTEXATTRIB1HNVPROC pglVertexAttrib1hNV=_Lazy_glVertexAttrib1hNV;
PFNGLVERTEXATTRIB1HVNVPROC pglVertexAttrib1hvNV=_Lazy_glVertexAttrib1hvNV;
PFNGLVERTEXATTRIB2HNVPROC pglVertexAttrib2hNV=_Lazy_glVertexAttrib2hNV;
PFNGLVERTEXATTRIB2HVNVPROC pglVertexAttrib2hvNV=_Lazy_glVertexAttrib2hvNV;
PFNGLVERTEXATTRIB3HNVPROC pglVertexAttrib3hNV=_Lazy_glVertexAttrib3hNV;
PFNGLVERTEXATTRIB3HVNVPROC pglVertexAttrib3hvNV=_Lazy_glVertexAttrib3hvNV;
PFNGLVERTEXATTRIB4HNVPROC pglVertexAttrib4hNV=_Lazy_glVertexAttrib4hNV;
PFNGLVERTEXATTRIB4HVNVPROC pglVertexAttrib4hvNV=_Lazy_glVertexAttrib4hvNV;
PFNGLVERTEXATTRIBS1HVNVPROC pglVertexAttribs1hvNV=_Lazy_glVertexAttribs1hvNV;
PFNGLVERTEXATTRIBS2HVNVPROC pglVertexAttribs2hvNV=_Lazy_glVertexAttribs2hvNV;
PFNGLVERTEXATTRIBS3HVNVPROC pglVertexAttribs3hvNV=_Lazy_glVertexAttribs3hvNV;
PFNGLVERTEXATTRIBS4HVNVPROC pglVertexAttribs4hvNV=_Lazy_glVertexAttribs4hvNV;
#endif 

/* GL_NV_pixel_data_range */

#ifdef __GLEE_GL_NV_pixel_data_range
void __stdcall _Lazy_glPixelDataRangeNV(GLenum target, GLsizei length, GLvoid * pointer)  {if (GLeeInit()) glPixelDataRangeNV(target, length, pointer);}
void __stdcall _Lazy_glFlushPixelDataRangeNV(GLenum target)                               {if (GLeeInit()) glFlushPixelDataRangeNV(target);}
PFNGLPIXELDATARANGENVPROC pglPixelDataRangeNV=_Lazy_glPixelDataRangeNV;
PFNGLFLUSHPIXELDATARANGENVPROC pglFlushPixelDataRangeNV=_Lazy_glFlushPixelDataRangeNV;
#endif 

/* GL_NV_primitive_restart */

#ifdef __GLEE_GL_NV_primitive_restart
void __stdcall _Lazy_glPrimitiveRestartNV(void)                                           {if (GLeeInit()) glPrimitiveRestartNV();}
void __stdcall _Lazy_glPrimitiveRestartIndexNV(GLuint index)                              {if (GLeeInit()) glPrimitiveRestartIndexNV(index);}
PFNGLPRIMITIVERESTARTNVPROC pglPrimitiveRestartNV=_Lazy_glPrimitiveRestartNV;
PFNGLPRIMITIVERESTARTINDEXNVPROC pglPrimitiveRestartIndexNV=_Lazy_glPrimitiveRestartIndexNV;
#endif 

/* GL_NV_texture_expand_normal */

#ifdef __GLEE_GL_NV_texture_expand_normal
#endif 

/* GL_NV_vertex_program2 */

#ifdef __GLEE_GL_NV_vertex_program2
#endif 

/* GL_ATI_map_object_buffer */

#ifdef __GLEE_GL_ATI_map_object_buffer
GLvoid* __stdcall _Lazy_glMapObjectBufferATI(GLuint buffer)                               {if (GLeeInit()) return glMapObjectBufferATI(buffer); return (GLvoid*)0;}
void __stdcall _Lazy_glUnmapObjectBufferATI(GLuint buffer)                                {if (GLeeInit()) glUnmapObjectBufferATI(buffer);}
PFNGLMAPOBJECTBUFFERATIPROC pglMapObjectBufferATI=_Lazy_glMapObjectBufferATI;
PFNGLUNMAPOBJECTBUFFERATIPROC pglUnmapObjectBufferATI=_Lazy_glUnmapObjectBufferATI;
#endif 

/* GL_ATI_separate_stencil */

#ifdef __GLEE_GL_ATI_separate_stencil
void __stdcall _Lazy_glStencilOpSeparateATI(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)  {if (GLeeInit()) glStencilOpSeparateATI(face, sfail, dpfail, dppass);}
void __stdcall _Lazy_glStencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask)  {if (GLeeInit()) glStencilFuncSeparateATI(frontfunc, backfunc, ref, mask);}
PFNGLSTENCILOPSEPARATEATIPROC pglStencilOpSeparateATI=_Lazy_glStencilOpSeparateATI;
PFNGLSTENCILFUNCSEPARATEATIPROC pglStencilFuncSeparateATI=_Lazy_glStencilFuncSeparateATI;
#endif 

/* GL_ATI_vertex_attrib_array_object */

#ifdef __GLEE_GL_ATI_vertex_attrib_array_object
void __stdcall _Lazy_glVertexAttribArrayObjectATI(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset)  {if (GLeeInit()) glVertexAttribArrayObjectATI(index, size, type, normalized, stride, buffer, offset);}
void __stdcall _Lazy_glGetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetVertexAttribArrayObjectfvATI(index, pname, params);}
void __stdcall _Lazy_glGetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, GLint * params)  {if (GLeeInit()) glGetVertexAttribArrayObjectivATI(index, pname, params);}
PFNGLVERTEXATTRIBARRAYOBJECTATIPROC pglVertexAttribArrayObjectATI=_Lazy_glVertexAttribArrayObjectATI;
PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC pglGetVertexAttribArrayObjectfvATI=_Lazy_glGetVertexAttribArrayObjectfvATI;
PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC pglGetVertexAttribArrayObjectivATI=_Lazy_glGetVertexAttribArrayObjectivATI;
#endif 

/* GL_OES_read_format */

#ifdef __GLEE_GL_OES_read_format
#endif 

/* GL_EXT_depth_bounds_test */

#ifdef __GLEE_GL_EXT_depth_bounds_test
void __stdcall _Lazy_glDepthBoundsEXT(GLclampd zmin, GLclampd zmax)                       {if (GLeeInit()) glDepthBoundsEXT(zmin, zmax);}
PFNGLDEPTHBOUNDSEXTPROC pglDepthBoundsEXT=_Lazy_glDepthBoundsEXT;
#endif 

/* GL_EXT_texture_mirror_clamp */

#ifdef __GLEE_GL_EXT_texture_mirror_clamp
#endif 

/* GL_EXT_blend_equation_separate */

#ifdef __GLEE_GL_EXT_blend_equation_separate
void __stdcall _Lazy_glBlendEquationSeparateEXT(GLenum modeRGB, GLenum modeAlpha)         {if (GLeeInit()) glBlendEquationSeparateEXT(modeRGB, modeAlpha);}
PFNGLBLENDEQUATIONSEPARATEEXTPROC pglBlendEquationSeparateEXT=_Lazy_glBlendEquationSeparateEXT;
#endif 

/* GL_MESA_pack_invert */

#ifdef __GLEE_GL_MESA_pack_invert
#endif 

/* GL_MESA_ycbcr_texture */

#ifdef __GLEE_GL_MESA_ycbcr_texture
#endif 

/* GL_EXT_pixel_buffer_object */

#ifdef __GLEE_GL_EXT_pixel_buffer_object
#endif 

/* GL_NV_fragment_program_option */

#ifdef __GLEE_GL_NV_fragment_program_option
#endif 

/* GL_NV_fragment_program2 */

#ifdef __GLEE_GL_NV_fragment_program2
#endif 

/* GL_NV_vertex_program2_option */

#ifdef __GLEE_GL_NV_vertex_program2_option
#endif 

/* GL_NV_vertex_program3 */

#ifdef __GLEE_GL_NV_vertex_program3
#endif 

/* GL_EXT_framebuffer_object */

#ifdef __GLEE_GL_EXT_framebuffer_object
GLboolean __stdcall _Lazy_glIsRenderbufferEXT(GLuint renderbuffer)                        {if (GLeeInit()) return glIsRenderbufferEXT(renderbuffer); return (GLboolean)0;}
void __stdcall _Lazy_glBindRenderbufferEXT(GLenum target, GLuint renderbuffer)            {if (GLeeInit()) glBindRenderbufferEXT(target, renderbuffer);}
void __stdcall _Lazy_glDeleteRenderbuffersEXT(GLsizei n, const GLuint * renderbuffers)    {if (GLeeInit()) glDeleteRenderbuffersEXT(n, renderbuffers);}
void __stdcall _Lazy_glGenRenderbuffersEXT(GLsizei n, GLuint * renderbuffers)             {if (GLeeInit()) glGenRenderbuffersEXT(n, renderbuffers);}
void __stdcall _Lazy_glRenderbufferStorageEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)  {if (GLeeInit()) glRenderbufferStorageEXT(target, internalformat, width, height);}
void __stdcall _Lazy_glGetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetRenderbufferParameterivEXT(target, pname, params);}
GLboolean __stdcall _Lazy_glIsFramebufferEXT(GLuint framebuffer)                          {if (GLeeInit()) return glIsFramebufferEXT(framebuffer); return (GLboolean)0;}
void __stdcall _Lazy_glBindFramebufferEXT(GLenum target, GLuint framebuffer)              {if (GLeeInit()) glBindFramebufferEXT(target, framebuffer);}
void __stdcall _Lazy_glDeleteFramebuffersEXT(GLsizei n, const GLuint * framebuffers)      {if (GLeeInit()) glDeleteFramebuffersEXT(n, framebuffers);}
void __stdcall _Lazy_glGenFramebuffersEXT(GLsizei n, GLuint * framebuffers)               {if (GLeeInit()) glGenFramebuffersEXT(n, framebuffers);}
GLenum __stdcall _Lazy_glCheckFramebufferStatusEXT(GLenum target)                         {if (GLeeInit()) return glCheckFramebufferStatusEXT(target); return (GLenum)0;}
void __stdcall _Lazy_glFramebufferTexture1DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)  {if (GLeeInit()) glFramebufferTexture1DEXT(target, attachment, textarget, texture, level);}
void __stdcall _Lazy_glFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)  {if (GLeeInit()) glFramebufferTexture2DEXT(target, attachment, textarget, texture, level);}
void __stdcall _Lazy_glFramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)  {if (GLeeInit()) glFramebufferTexture3DEXT(target, attachment, textarget, texture, level, zoffset);}
void __stdcall _Lazy_glFramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)  {if (GLeeInit()) glFramebufferRenderbufferEXT(target, attachment, renderbuffertarget, renderbuffer);}
void __stdcall _Lazy_glGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, GLint * params)  {if (GLeeInit()) glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, params);}
void __stdcall _Lazy_glGenerateMipmapEXT(GLenum target)                                   {if (GLeeInit()) glGenerateMipmapEXT(target);}
PFNGLISRENDERBUFFEREXTPROC pglIsRenderbufferEXT=_Lazy_glIsRenderbufferEXT;
PFNGLBINDRENDERBUFFEREXTPROC pglBindRenderbufferEXT=_Lazy_glBindRenderbufferEXT;
PFNGLDELETERENDERBUFFERSEXTPROC pglDeleteRenderbuffersEXT=_Lazy_glDeleteRenderbuffersEXT;
PFNGLGENRENDERBUFFERSEXTPROC pglGenRenderbuffersEXT=_Lazy_glGenRenderbuffersEXT;
PFNGLRENDERBUFFERSTORAGEEXTPROC pglRenderbufferStorageEXT=_Lazy_glRenderbufferStorageEXT;
PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC pglGetRenderbufferParameterivEXT=_Lazy_glGetRenderbufferParameterivEXT;
PFNGLISFRAMEBUFFEREXTPROC pglIsFramebufferEXT=_Lazy_glIsFramebufferEXT;
PFNGLBINDFRAMEBUFFEREXTPROC pglBindFramebufferEXT=_Lazy_glBindFramebufferEXT;
PFNGLDELETEFRAMEBUFFERSEXTPROC pglDeleteFramebuffersEXT=_Lazy_glDeleteFramebuffersEXT;
PFNGLGENFRAMEBUFFERSEXTPROC pglGenFramebuffersEXT=_Lazy_glGenFramebuffersEXT;
PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC pglCheckFramebufferStatusEXT=_Lazy_glCheckFramebufferStatusEXT;
PFNGLFRAMEBUFFERTEXTURE1DEXTPROC pglFramebufferTexture1DEXT=_Lazy_glFramebufferTexture1DEXT;
PFNGLFRAMEBUFFERTEXTURE2DEXTPROC pglFramebufferTexture2DEXT=_Lazy_glFramebufferTexture2DEXT;
PFNGLFRAMEBUFFERTEXTURE3DEXTPROC pglFramebufferTexture3DEXT=_Lazy_glFramebufferTexture3DEXT;
PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC pglFramebufferRenderbufferEXT=_Lazy_glFramebufferRenderbufferEXT;
PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC pglGetFramebufferAttachmentParameterivEXT=_Lazy_glGetFramebufferAttachmentParameterivEXT;
PFNGLGENERATEMIPMAPEXTPROC pglGenerateMipmapEXT=_Lazy_glGenerateMipmapEXT;
#endif 

/* GL_GREMEDY_string_marker */

#ifdef __GLEE_GL_GREMEDY_string_marker
void __stdcall _Lazy_glStringMarkerGREMEDY(GLsizei len, const GLvoid * string)            {if (GLeeInit()) glStringMarkerGREMEDY(len, string);}
PFNGLSTRINGMARKERGREMEDYPROC pglStringMarkerGREMEDY=_Lazy_glStringMarkerGREMEDY;
#endif 

/* GL_EXT_packed_depth_stencil */

#ifdef __GLEE_GL_EXT_packed_depth_stencil
#endif 

/* GL_EXT_stencil_clear_tag */

#ifdef __GLEE_GL_EXT_stencil_clear_tag
void __stdcall _Lazy_glStencilClearTagEXT(GLsizei stencilTagBits, GLuint stencilClearTag)  {if (GLeeInit()) glStencilClearTagEXT(stencilTagBits, stencilClearTag);}
PFNGLSTENCILCLEARTAGEXTPROC pglStencilClearTagEXT=_Lazy_glStencilClearTagEXT;
#endif 

/* GL_EXT_texture_sRGB */

#ifdef __GLEE_GL_EXT_texture_sRGB
#endif 

/* GL_EXT_framebuffer_blit */

#ifdef __GLEE_GL_EXT_framebuffer_blit
void __stdcall _Lazy_glBlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)  {if (GLeeInit()) glBlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);}
PFNGLBLITFRAMEBUFFEREXTPROC pglBlitFramebufferEXT=_Lazy_glBlitFramebufferEXT;
#endif 

/* GL_EXT_framebuffer_multisample */

#ifdef __GLEE_GL_EXT_framebuffer_multisample
void __stdcall _Lazy_glRenderbufferStorageMultisampleEXT(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)  {if (GLeeInit()) glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);}
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC pglRenderbufferStorageMultisampleEXT=_Lazy_glRenderbufferStorageMultisampleEXT;
#endif 

/* GL_MESAX_texture_stack */

#ifdef __GLEE_GL_MESAX_texture_stack
#endif 

/* GL_EXT_timer_query */

#ifdef __GLEE_GL_EXT_timer_query
void __stdcall _Lazy_glGetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64EXT * params)  {if (GLeeInit()) glGetQueryObjecti64vEXT(id, pname, params);}
void __stdcall _Lazy_glGetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64EXT * params)  {if (GLeeInit()) glGetQueryObjectui64vEXT(id, pname, params);}
PFNGLGETQUERYOBJECTI64VEXTPROC pglGetQueryObjecti64vEXT=_Lazy_glGetQueryObjecti64vEXT;
PFNGLGETQUERYOBJECTUI64VEXTPROC pglGetQueryObjectui64vEXT=_Lazy_glGetQueryObjectui64vEXT;
#endif 

/* GL_EXT_gpu_program_parameters */

#ifdef __GLEE_GL_EXT_gpu_program_parameters
void __stdcall _Lazy_glProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, const GLfloat * params)  {if (GLeeInit()) glProgramEnvParameters4fvEXT(target, index, count, params);}
void __stdcall _Lazy_glProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, const GLfloat * params)  {if (GLeeInit()) glProgramLocalParameters4fvEXT(target, index, count, params);}
PFNGLPROGRAMENVPARAMETERS4FVEXTPROC pglProgramEnvParameters4fvEXT=_Lazy_glProgramEnvParameters4fvEXT;
PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC pglProgramLocalParameters4fvEXT=_Lazy_glProgramLocalParameters4fvEXT;
#endif 

/* GL_APPLE_flush_buffer_range */

#ifdef __GLEE_GL_APPLE_flush_buffer_range
void __stdcall _Lazy_glBufferParameteriAPPLE(GLenum target, GLenum pname, GLint param)    {if (GLeeInit()) glBufferParameteriAPPLE(target, pname, param);}
void __stdcall _Lazy_glFlushMappedBufferRangeAPPLE(GLenum target, GLintptr offset, GLsizeiptr size)  {if (GLeeInit()) glFlushMappedBufferRangeAPPLE(target, offset, size);}
PFNGLBUFFERPARAMETERIAPPLEPROC pglBufferParameteriAPPLE=_Lazy_glBufferParameteriAPPLE;
PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC pglFlushMappedBufferRangeAPPLE=_Lazy_glFlushMappedBufferRangeAPPLE;
#endif 

/* GL_NV_gpu_program4 */

#ifdef __GLEE_GL_NV_gpu_program4
void __stdcall _Lazy_glProgramLocalParameterI4iNV(GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w)  {if (GLeeInit()) glProgramLocalParameterI4iNV(target, index, x, y, z, w);}
void __stdcall _Lazy_glProgramLocalParameterI4ivNV(GLenum target, GLuint index, const GLint * params)  {if (GLeeInit()) glProgramLocalParameterI4ivNV(target, index, params);}
void __stdcall _Lazy_glProgramLocalParametersI4ivNV(GLenum target, GLuint index, GLsizei count, const GLint * params)  {if (GLeeInit()) glProgramLocalParametersI4ivNV(target, index, count, params);}
void __stdcall _Lazy_glProgramLocalParameterI4uiNV(GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)  {if (GLeeInit()) glProgramLocalParameterI4uiNV(target, index, x, y, z, w);}
void __stdcall _Lazy_glProgramLocalParameterI4uivNV(GLenum target, GLuint index, const GLuint * params)  {if (GLeeInit()) glProgramLocalParameterI4uivNV(target, index, params);}
void __stdcall _Lazy_glProgramLocalParametersI4uivNV(GLenum target, GLuint index, GLsizei count, const GLuint * params)  {if (GLeeInit()) glProgramLocalParametersI4uivNV(target, index, count, params);}
void __stdcall _Lazy_glProgramEnvParameterI4iNV(GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w)  {if (GLeeInit()) glProgramEnvParameterI4iNV(target, index, x, y, z, w);}
void __stdcall _Lazy_glProgramEnvParameterI4ivNV(GLenum target, GLuint index, const GLint * params)  {if (GLeeInit()) glProgramEnvParameterI4ivNV(target, index, params);}
void __stdcall _Lazy_glProgramEnvParametersI4ivNV(GLenum target, GLuint index, GLsizei count, const GLint * params)  {if (GLeeInit()) glProgramEnvParametersI4ivNV(target, index, count, params);}
void __stdcall _Lazy_glProgramEnvParameterI4uiNV(GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)  {if (GLeeInit()) glProgramEnvParameterI4uiNV(target, index, x, y, z, w);}
void __stdcall _Lazy_glProgramEnvParameterI4uivNV(GLenum target, GLuint index, const GLuint * params)  {if (GLeeInit()) glProgramEnvParameterI4uivNV(target, index, params);}
void __stdcall _Lazy_glProgramEnvParametersI4uivNV(GLenum target, GLuint index, GLsizei count, const GLuint * params)  {if (GLeeInit()) glProgramEnvParametersI4uivNV(target, index, count, params);}
void __stdcall _Lazy_glGetProgramLocalParameterIivNV(GLenum target, GLuint index, GLint * params)  {if (GLeeInit()) glGetProgramLocalParameterIivNV(target, index, params);}
void __stdcall _Lazy_glGetProgramLocalParameterIuivNV(GLenum target, GLuint index, GLuint * params)  {if (GLeeInit()) glGetProgramLocalParameterIuivNV(target, index, params);}
void __stdcall _Lazy_glGetProgramEnvParameterIivNV(GLenum target, GLuint index, GLint * params)  {if (GLeeInit()) glGetProgramEnvParameterIivNV(target, index, params);}
void __stdcall _Lazy_glGetProgramEnvParameterIuivNV(GLenum target, GLuint index, GLuint * params)  {if (GLeeInit()) glGetProgramEnvParameterIuivNV(target, index, params);}
PFNGLPROGRAMLOCALPARAMETERI4INVPROC pglProgramLocalParameterI4iNV=_Lazy_glProgramLocalParameterI4iNV;
PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC pglProgramLocalParameterI4ivNV=_Lazy_glProgramLocalParameterI4ivNV;
PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC pglProgramLocalParametersI4ivNV=_Lazy_glProgramLocalParametersI4ivNV;
PFNGLPROGRAMLOCALPARAMETERI4UINVPROC pglProgramLocalParameterI4uiNV=_Lazy_glProgramLocalParameterI4uiNV;
PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC pglProgramLocalParameterI4uivNV=_Lazy_glProgramLocalParameterI4uivNV;
PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC pglProgramLocalParametersI4uivNV=_Lazy_glProgramLocalParametersI4uivNV;
PFNGLPROGRAMENVPARAMETERI4INVPROC pglProgramEnvParameterI4iNV=_Lazy_glProgramEnvParameterI4iNV;
PFNGLPROGRAMENVPARAMETERI4IVNVPROC pglProgramEnvParameterI4ivNV=_Lazy_glProgramEnvParameterI4ivNV;
PFNGLPROGRAMENVPARAMETERSI4IVNVPROC pglProgramEnvParametersI4ivNV=_Lazy_glProgramEnvParametersI4ivNV;
PFNGLPROGRAMENVPARAMETERI4UINVPROC pglProgramEnvParameterI4uiNV=_Lazy_glProgramEnvParameterI4uiNV;
PFNGLPROGRAMENVPARAMETERI4UIVNVPROC pglProgramEnvParameterI4uivNV=_Lazy_glProgramEnvParameterI4uivNV;
PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC pglProgramEnvParametersI4uivNV=_Lazy_glProgramEnvParametersI4uivNV;
PFNGLGETPROGRAMLOCALPARAMETERIIVNVPROC pglGetProgramLocalParameterIivNV=_Lazy_glGetProgramLocalParameterIivNV;
PFNGLGETPROGRAMLOCALPARAMETERIUIVNVPROC pglGetProgramLocalParameterIuivNV=_Lazy_glGetProgramLocalParameterIuivNV;
PFNGLGETPROGRAMENVPARAMETERIIVNVPROC pglGetProgramEnvParameterIivNV=_Lazy_glGetProgramEnvParameterIivNV;
PFNGLGETPROGRAMENVPARAMETERIUIVNVPROC pglGetProgramEnvParameterIuivNV=_Lazy_glGetProgramEnvParameterIuivNV;
#endif 

/* GL_NV_geometry_program4 */

#ifdef __GLEE_GL_NV_geometry_program4
void __stdcall _Lazy_glProgramVertexLimitNV(GLenum target, GLint limit)                   {if (GLeeInit()) glProgramVertexLimitNV(target, limit);}
void __stdcall _Lazy_glFramebufferTextureEXT(GLenum target, GLenum attachment, GLuint texture, GLint level)  {if (GLeeInit()) glFramebufferTextureEXT(target, attachment, texture, level);}
void __stdcall _Lazy_glFramebufferTextureLayerEXT(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)  {if (GLeeInit()) glFramebufferTextureLayerEXT(target, attachment, texture, level, layer);}
void __stdcall _Lazy_glFramebufferTextureFaceEXT(GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face)  {if (GLeeInit()) glFramebufferTextureFaceEXT(target, attachment, texture, level, face);}
PFNGLPROGRAMVERTEXLIMITNVPROC pglProgramVertexLimitNV=_Lazy_glProgramVertexLimitNV;
PFNGLFRAMEBUFFERTEXTUREEXTPROC pglFramebufferTextureEXT=_Lazy_glFramebufferTextureEXT;
PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC pglFramebufferTextureLayerEXT=_Lazy_glFramebufferTextureLayerEXT;
PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC pglFramebufferTextureFaceEXT=_Lazy_glFramebufferTextureFaceEXT;
#endif 

/* GL_EXT_geometry_shader4 */

#ifdef __GLEE_GL_EXT_geometry_shader4
void __stdcall _Lazy_glProgramParameteriEXT(GLuint program, GLenum pname, GLint value)    {if (GLeeInit()) glProgramParameteriEXT(program, pname, value);}
PFNGLPROGRAMPARAMETERIEXTPROC pglProgramParameteriEXT=_Lazy_glProgramParameteriEXT;
#endif 

/* GL_NV_vertex_program4 */

#ifdef __GLEE_GL_NV_vertex_program4
void __stdcall _Lazy_glVertexAttribI1iEXT(GLuint index, GLint x)                          {if (GLeeInit()) glVertexAttribI1iEXT(index, x);}
void __stdcall _Lazy_glVertexAttribI2iEXT(GLuint index, GLint x, GLint y)                 {if (GLeeInit()) glVertexAttribI2iEXT(index, x, y);}
void __stdcall _Lazy_glVertexAttribI3iEXT(GLuint index, GLint x, GLint y, GLint z)        {if (GLeeInit()) glVertexAttribI3iEXT(index, x, y, z);}
void __stdcall _Lazy_glVertexAttribI4iEXT(GLuint index, GLint x, GLint y, GLint z, GLint w)  {if (GLeeInit()) glVertexAttribI4iEXT(index, x, y, z, w);}
void __stdcall _Lazy_glVertexAttribI1uiEXT(GLuint index, GLuint x)                        {if (GLeeInit()) glVertexAttribI1uiEXT(index, x);}
void __stdcall _Lazy_glVertexAttribI2uiEXT(GLuint index, GLuint x, GLuint y)              {if (GLeeInit()) glVertexAttribI2uiEXT(index, x, y);}
void __stdcall _Lazy_glVertexAttribI3uiEXT(GLuint index, GLuint x, GLuint y, GLuint z)    {if (GLeeInit()) glVertexAttribI3uiEXT(index, x, y, z);}
void __stdcall _Lazy_glVertexAttribI4uiEXT(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)  {if (GLeeInit()) glVertexAttribI4uiEXT(index, x, y, z, w);}
void __stdcall _Lazy_glVertexAttribI1ivEXT(GLuint index, const GLint * v)                 {if (GLeeInit()) glVertexAttribI1ivEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI2ivEXT(GLuint index, const GLint * v)                 {if (GLeeInit()) glVertexAttribI2ivEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI3ivEXT(GLuint index, const GLint * v)                 {if (GLeeInit()) glVertexAttribI3ivEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI4ivEXT(GLuint index, const GLint * v)                 {if (GLeeInit()) glVertexAttribI4ivEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI1uivEXT(GLuint index, const GLuint * v)               {if (GLeeInit()) glVertexAttribI1uivEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI2uivEXT(GLuint index, const GLuint * v)               {if (GLeeInit()) glVertexAttribI2uivEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI3uivEXT(GLuint index, const GLuint * v)               {if (GLeeInit()) glVertexAttribI3uivEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI4uivEXT(GLuint index, const GLuint * v)               {if (GLeeInit()) glVertexAttribI4uivEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI4bvEXT(GLuint index, const GLbyte * v)                {if (GLeeInit()) glVertexAttribI4bvEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI4svEXT(GLuint index, const GLshort * v)               {if (GLeeInit()) glVertexAttribI4svEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI4ubvEXT(GLuint index, const GLubyte * v)              {if (GLeeInit()) glVertexAttribI4ubvEXT(index, v);}
void __stdcall _Lazy_glVertexAttribI4usvEXT(GLuint index, const GLushort * v)             {if (GLeeInit()) glVertexAttribI4usvEXT(index, v);}
void __stdcall _Lazy_glVertexAttribIPointerEXT(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)  {if (GLeeInit()) glVertexAttribIPointerEXT(index, size, type, stride, pointer);}
void __stdcall _Lazy_glGetVertexAttribIivEXT(GLuint index, GLenum pname, GLint * params)  {if (GLeeInit()) glGetVertexAttribIivEXT(index, pname, params);}
void __stdcall _Lazy_glGetVertexAttribIuivEXT(GLuint index, GLenum pname, GLuint * params)  {if (GLeeInit()) glGetVertexAttribIuivEXT(index, pname, params);}
PFNGLVERTEXATTRIBI1IEXTPROC pglVertexAttribI1iEXT=_Lazy_glVertexAttribI1iEXT;
PFNGLVERTEXATTRIBI2IEXTPROC pglVertexAttribI2iEXT=_Lazy_glVertexAttribI2iEXT;
PFNGLVERTEXATTRIBI3IEXTPROC pglVertexAttribI3iEXT=_Lazy_glVertexAttribI3iEXT;
PFNGLVERTEXATTRIBI4IEXTPROC pglVertexAttribI4iEXT=_Lazy_glVertexAttribI4iEXT;
PFNGLVERTEXATTRIBI1UIEXTPROC pglVertexAttribI1uiEXT=_Lazy_glVertexAttribI1uiEXT;
PFNGLVERTEXATTRIBI2UIEXTPROC pglVertexAttribI2uiEXT=_Lazy_glVertexAttribI2uiEXT;
PFNGLVERTEXATTRIBI3UIEXTPROC pglVertexAttribI3uiEXT=_Lazy_glVertexAttribI3uiEXT;
PFNGLVERTEXATTRIBI4UIEXTPROC pglVertexAttribI4uiEXT=_Lazy_glVertexAttribI4uiEXT;
PFNGLVERTEXATTRIBI1IVEXTPROC pglVertexAttribI1ivEXT=_Lazy_glVertexAttribI1ivEXT;
PFNGLVERTEXATTRIBI2IVEXTPROC pglVertexAttribI2ivEXT=_Lazy_glVertexAttribI2ivEXT;
PFNGLVERTEXATTRIBI3IVEXTPROC pglVertexAttribI3ivEXT=_Lazy_glVertexAttribI3ivEXT;
PFNGLVERTEXATTRIBI4IVEXTPROC pglVertexAttribI4ivEXT=_Lazy_glVertexAttribI4ivEXT;
PFNGLVERTEXATTRIBI1UIVEXTPROC pglVertexAttribI1uivEXT=_Lazy_glVertexAttribI1uivEXT;
PFNGLVERTEXATTRIBI2UIVEXTPROC pglVertexAttribI2uivEXT=_Lazy_glVertexAttribI2uivEXT;
PFNGLVERTEXATTRIBI3UIVEXTPROC pglVertexAttribI3uivEXT=_Lazy_glVertexAttribI3uivEXT;
PFNGLVERTEXATTRIBI4UIVEXTPROC pglVertexAttribI4uivEXT=_Lazy_glVertexAttribI4uivEXT;
PFNGLVERTEXATTRIBI4BVEXTPROC pglVertexAttribI4bvEXT=_Lazy_glVertexAttribI4bvEXT;
PFNGLVERTEXATTRIBI4SVEXTPROC pglVertexAttribI4svEXT=_Lazy_glVertexAttribI4svEXT;
PFNGLVERTEXATTRIBI4UBVEXTPROC pglVertexAttribI4ubvEXT=_Lazy_glVertexAttribI4ubvEXT;
PFNGLVERTEXATTRIBI4USVEXTPROC pglVertexAttribI4usvEXT=_Lazy_glVertexAttribI4usvEXT;
PFNGLVERTEXATTRIBIPOINTEREXTPROC pglVertexAttribIPointerEXT=_Lazy_glVertexAttribIPointerEXT;
PFNGLGETVERTEXATTRIBIIVEXTPROC pglGetVertexAttribIivEXT=_Lazy_glGetVertexAttribIivEXT;
PFNGLGETVERTEXATTRIBIUIVEXTPROC pglGetVertexAttribIuivEXT=_Lazy_glGetVertexAttribIuivEXT;
#endif 

/* GL_EXT_gpu_shader4 */

#ifdef __GLEE_GL_EXT_gpu_shader4
void __stdcall _Lazy_glGetUniformuivEXT(GLuint program, GLint location, GLuint * params)  {if (GLeeInit()) glGetUniformuivEXT(program, location, params);}
void __stdcall _Lazy_glBindFragDataLocationEXT(GLuint program, GLuint color, const GLchar * name)  {if (GLeeInit()) glBindFragDataLocationEXT(program, color, name);}
GLint __stdcall _Lazy_glGetFragDataLocationEXT(GLuint program, const GLchar * name)       {if (GLeeInit()) return glGetFragDataLocationEXT(program, name); return (GLint)0;}
void __stdcall _Lazy_glUniform1uiEXT(GLint location, GLuint v0)                           {if (GLeeInit()) glUniform1uiEXT(location, v0);}
void __stdcall _Lazy_glUniform2uiEXT(GLint location, GLuint v0, GLuint v1)                {if (GLeeInit()) glUniform2uiEXT(location, v0, v1);}
void __stdcall _Lazy_glUniform3uiEXT(GLint location, GLuint v0, GLuint v1, GLuint v2)     {if (GLeeInit()) glUniform3uiEXT(location, v0, v1, v2);}
void __stdcall _Lazy_glUniform4uiEXT(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)  {if (GLeeInit()) glUniform4uiEXT(location, v0, v1, v2, v3);}
void __stdcall _Lazy_glUniform1uivEXT(GLint location, GLsizei count, const GLuint * value)  {if (GLeeInit()) glUniform1uivEXT(location, count, value);}
void __stdcall _Lazy_glUniform2uivEXT(GLint location, GLsizei count, const GLuint * value)  {if (GLeeInit()) glUniform2uivEXT(location, count, value);}
void __stdcall _Lazy_glUniform3uivEXT(GLint location, GLsizei count, const GLuint * value)  {if (GLeeInit()) glUniform3uivEXT(location, count, value);}
void __stdcall _Lazy_glUniform4uivEXT(GLint location, GLsizei count, const GLuint * value)  {if (GLeeInit()) glUniform4uivEXT(location, count, value);}
PFNGLGETUNIFORMUIVEXTPROC pglGetUniformuivEXT=_Lazy_glGetUniformuivEXT;
PFNGLBINDFRAGDATALOCATIONEXTPROC pglBindFragDataLocationEXT=_Lazy_glBindFragDataLocationEXT;
PFNGLGETFRAGDATALOCATIONEXTPROC pglGetFragDataLocationEXT=_Lazy_glGetFragDataLocationEXT;
PFNGLUNIFORM1UIEXTPROC pglUniform1uiEXT=_Lazy_glUniform1uiEXT;
PFNGLUNIFORM2UIEXTPROC pglUniform2uiEXT=_Lazy_glUniform2uiEXT;
PFNGLUNIFORM3UIEXTPROC pglUniform3uiEXT=_Lazy_glUniform3uiEXT;
PFNGLUNIFORM4UIEXTPROC pglUniform4uiEXT=_Lazy_glUniform4uiEXT;
PFNGLUNIFORM1UIVEXTPROC pglUniform1uivEXT=_Lazy_glUniform1uivEXT;
PFNGLUNIFORM2UIVEXTPROC pglUniform2uivEXT=_Lazy_glUniform2uivEXT;
PFNGLUNIFORM3UIVEXTPROC pglUniform3uivEXT=_Lazy_glUniform3uivEXT;
PFNGLUNIFORM4UIVEXTPROC pglUniform4uivEXT=_Lazy_glUniform4uivEXT;
#endif 

/* GL_EXT_draw_instanced */

#ifdef __GLEE_GL_EXT_draw_instanced
void __stdcall _Lazy_glDrawArraysInstancedEXT(GLenum mode, GLint start, GLsizei count, GLsizei primcount)  {if (GLeeInit()) glDrawArraysInstancedEXT(mode, start, count, primcount);}
void __stdcall _Lazy_glDrawElementsInstancedEXT(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLsizei primcount)  {if (GLeeInit()) glDrawElementsInstancedEXT(mode, count, type, indices, primcount);}
PFNGLDRAWARRAYSINSTANCEDEXTPROC pglDrawArraysInstancedEXT=_Lazy_glDrawArraysInstancedEXT;
PFNGLDRAWELEMENTSINSTANCEDEXTPROC pglDrawElementsInstancedEXT=_Lazy_glDrawElementsInstancedEXT;
#endif 

/* GL_EXT_packed_float */

#ifdef __GLEE_GL_EXT_packed_float
#endif 

/* GL_EXT_texture_array */

#ifdef __GLEE_GL_EXT_texture_array
#endif 

/* GL_EXT_texture_buffer_object */

#ifdef __GLEE_GL_EXT_texture_buffer_object
void __stdcall _Lazy_glTexBufferEXT(GLenum target, GLenum internalformat, GLuint buffer)  {if (GLeeInit()) glTexBufferEXT(target, internalformat, buffer);}
PFNGLTEXBUFFEREXTPROC pglTexBufferEXT=_Lazy_glTexBufferEXT;
#endif 

/* GL_EXT_texture_compression_latc */

#ifdef __GLEE_GL_EXT_texture_compression_latc
#endif 

/* GL_EXT_texture_compression_rgtc */

#ifdef __GLEE_GL_EXT_texture_compression_rgtc
#endif 

/* GL_EXT_texture_shared_exponent */

#ifdef __GLEE_GL_EXT_texture_shared_exponent
#endif 

/* GL_NV_depth_buffer_float */

#ifdef __GLEE_GL_NV_depth_buffer_float
void __stdcall _Lazy_glDepthRangedNV(GLdouble zNear, GLdouble zFar)                       {if (GLeeInit()) glDepthRangedNV(zNear, zFar);}
void __stdcall _Lazy_glClearDepthdNV(GLdouble depth)                                      {if (GLeeInit()) glClearDepthdNV(depth);}
void __stdcall _Lazy_glDepthBoundsdNV(GLdouble zmin, GLdouble zmax)                       {if (GLeeInit()) glDepthBoundsdNV(zmin, zmax);}
PFNGLDEPTHRANGEDNVPROC pglDepthRangedNV=_Lazy_glDepthRangedNV;
PFNGLCLEARDEPTHDNVPROC pglClearDepthdNV=_Lazy_glClearDepthdNV;
PFNGLDEPTHBOUNDSDNVPROC pglDepthBoundsdNV=_Lazy_glDepthBoundsdNV;
#endif 

/* GL_NV_fragment_program4 */

#ifdef __GLEE_GL_NV_fragment_program4
#endif 

/* GL_NV_framebuffer_multisample_coverage */

#ifdef __GLEE_GL_NV_framebuffer_multisample_coverage
void __stdcall _Lazy_glRenderbufferStorageMultisampleCoverageNV(GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height)  {if (GLeeInit()) glRenderbufferStorageMultisampleCoverageNV(target, coverageSamples, colorSamples, internalformat, width, height);}
PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC pglRenderbufferStorageMultisampleCoverageNV=_Lazy_glRenderbufferStorageMultisampleCoverageNV;
#endif 

/* GL_EXT_framebuffer_sRGB */

#ifdef __GLEE_GL_EXT_framebuffer_sRGB
#endif 

/* GL_NV_geometry_shader4 */

#ifdef __GLEE_GL_NV_geometry_shader4
#endif 

/* GL_NV_parameter_buffer_object */

#ifdef __GLEE_GL_NV_parameter_buffer_object
void __stdcall _Lazy_glProgramBufferParametersfvNV(GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLfloat * params)  {if (GLeeInit()) glProgramBufferParametersfvNV(target, buffer, index, count, params);}
void __stdcall _Lazy_glProgramBufferParametersIivNV(GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLint * params)  {if (GLeeInit()) glProgramBufferParametersIivNV(target, buffer, index, count, params);}
void __stdcall _Lazy_glProgramBufferParametersIuivNV(GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLuint * params)  {if (GLeeInit()) glProgramBufferParametersIuivNV(target, buffer, index, count, params);}
PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC pglProgramBufferParametersfvNV=_Lazy_glProgramBufferParametersfvNV;
PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC pglProgramBufferParametersIivNV=_Lazy_glProgramBufferParametersIivNV;
PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC pglProgramBufferParametersIuivNV=_Lazy_glProgramBufferParametersIuivNV;
#endif 

/* GL_EXT_draw_buffers2 */

#ifdef __GLEE_GL_EXT_draw_buffers2
void __stdcall _Lazy_glColorMaskIndexedEXT(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)  {if (GLeeInit()) glColorMaskIndexedEXT(index, r, g, b, a);}
void __stdcall _Lazy_glGetBooleanIndexedvEXT(GLenum target, GLuint index, GLboolean * data)  {if (GLeeInit()) glGetBooleanIndexedvEXT(target, index, data);}
void __stdcall _Lazy_glGetIntegerIndexedvEXT(GLenum target, GLuint index, GLint * data)   {if (GLeeInit()) glGetIntegerIndexedvEXT(target, index, data);}
void __stdcall _Lazy_glEnableIndexedEXT(GLenum target, GLuint index)                      {if (GLeeInit()) glEnableIndexedEXT(target, index);}
void __stdcall _Lazy_glDisableIndexedEXT(GLenum target, GLuint index)                     {if (GLeeInit()) glDisableIndexedEXT(target, index);}
GLboolean __stdcall _Lazy_glIsEnabledIndexedEXT(GLenum target, GLuint index)              {if (GLeeInit()) return glIsEnabledIndexedEXT(target, index); return (GLboolean)0;}
PFNGLCOLORMASKINDEXEDEXTPROC pglColorMaskIndexedEXT=_Lazy_glColorMaskIndexedEXT;
PFNGLGETBOOLEANINDEXEDVEXTPROC pglGetBooleanIndexedvEXT=_Lazy_glGetBooleanIndexedvEXT;
PFNGLGETINTEGERINDEXEDVEXTPROC pglGetIntegerIndexedvEXT=_Lazy_glGetIntegerIndexedvEXT;
PFNGLENABLEINDEXEDEXTPROC pglEnableIndexedEXT=_Lazy_glEnableIndexedEXT;
PFNGLDISABLEINDEXEDEXTPROC pglDisableIndexedEXT=_Lazy_glDisableIndexedEXT;
PFNGLISENABLEDINDEXEDEXTPROC pglIsEnabledIndexedEXT=_Lazy_glIsEnabledIndexedEXT;
#endif 

/* GL_NV_transform_feedback */

#ifdef __GLEE_GL_NV_transform_feedback
void __stdcall _Lazy_glBeginTransformFeedbackNV(GLenum primitiveMode)                     {if (GLeeInit()) glBeginTransformFeedbackNV(primitiveMode);}
void __stdcall _Lazy_glEndTransformFeedbackNV(void)                                       {if (GLeeInit()) glEndTransformFeedbackNV();}
void __stdcall _Lazy_glTransformFeedbackAttribsNV(GLuint count, const GLint * attribs, GLenum bufferMode)  {if (GLeeInit()) glTransformFeedbackAttribsNV(count, attribs, bufferMode);}
void __stdcall _Lazy_glBindBufferRangeNV(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)  {if (GLeeInit()) glBindBufferRangeNV(target, index, buffer, offset, size);}
void __stdcall _Lazy_glBindBufferOffsetNV(GLenum target, GLuint index, GLuint buffer, GLintptr offset)  {if (GLeeInit()) glBindBufferOffsetNV(target, index, buffer, offset);}
void __stdcall _Lazy_glBindBufferBaseNV(GLenum target, GLuint index, GLuint buffer)       {if (GLeeInit()) glBindBufferBaseNV(target, index, buffer);}
void __stdcall _Lazy_glTransformFeedbackVaryingsNV(GLuint program, GLsizei count, const GLint * locations, GLenum bufferMode)  {if (GLeeInit()) glTransformFeedbackVaryingsNV(program, count, locations, bufferMode);}
void __stdcall _Lazy_glActiveVaryingNV(GLuint program, const GLchar * name)               {if (GLeeInit()) glActiveVaryingNV(program, name);}
GLint __stdcall _Lazy_glGetVaryingLocationNV(GLuint program, const GLchar * name)         {if (GLeeInit()) return glGetVaryingLocationNV(program, name); return (GLint)0;}
void __stdcall _Lazy_glGetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name)  {if (GLeeInit()) glGetActiveVaryingNV(program, index, bufSize, length, size, type, name);}
void __stdcall _Lazy_glGetTransformFeedbackVaryingNV(GLuint program, GLuint index, GLint * location)  {if (GLeeInit()) glGetTransformFeedbackVaryingNV(program, index, location);}
PFNGLBEGINTRANSFORMFEEDBACKNVPROC pglBeginTransformFeedbackNV=_Lazy_glBeginTransformFeedbackNV;
PFNGLENDTRANSFORMFEEDBACKNVPROC pglEndTransformFeedbackNV=_Lazy_glEndTransformFeedbackNV;
PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC pglTransformFeedbackAttribsNV=_Lazy_glTransformFeedbackAttribsNV;
PFNGLBINDBUFFERRANGENVPROC pglBindBufferRangeNV=_Lazy_glBindBufferRangeNV;
PFNGLBINDBUFFEROFFSETNVPROC pglBindBufferOffsetNV=_Lazy_glBindBufferOffsetNV;
PFNGLBINDBUFFERBASENVPROC pglBindBufferBaseNV=_Lazy_glBindBufferBaseNV;
PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC pglTransformFeedbackVaryingsNV=_Lazy_glTransformFeedbackVaryingsNV;
PFNGLACTIVEVARYINGNVPROC pglActiveVaryingNV=_Lazy_glActiveVaryingNV;
PFNGLGETVARYINGLOCATIONNVPROC pglGetVaryingLocationNV=_Lazy_glGetVaryingLocationNV;
PFNGLGETACTIVEVARYINGNVPROC pglGetActiveVaryingNV=_Lazy_glGetActiveVaryingNV;
PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC pglGetTransformFeedbackVaryingNV=_Lazy_glGetTransformFeedbackVaryingNV;
#endif 

/* GL_EXT_bindable_uniform */

#ifdef __GLEE_GL_EXT_bindable_uniform
void __stdcall _Lazy_glUniformBufferEXT(GLuint program, GLint location, GLuint buffer)    {if (GLeeInit()) glUniformBufferEXT(program, location, buffer);}
GLint __stdcall _Lazy_glGetUniformBufferSizeEXT(GLuint program, GLint location)           {if (GLeeInit()) return glGetUniformBufferSizeEXT(program, location); return (GLint)0;}
GLintptr __stdcall _Lazy_glGetUniformOffsetEXT(GLuint program, GLint location)            {if (GLeeInit()) return glGetUniformOffsetEXT(program, location); return (GLintptr)0;}
PFNGLUNIFORMBUFFEREXTPROC pglUniformBufferEXT=_Lazy_glUniformBufferEXT;
PFNGLGETUNIFORMBUFFERSIZEEXTPROC pglGetUniformBufferSizeEXT=_Lazy_glGetUniformBufferSizeEXT;
PFNGLGETUNIFORMOFFSETEXTPROC pglGetUniformOffsetEXT=_Lazy_glGetUniformOffsetEXT;
#endif 

/* GL_EXT_texture_integer */

#ifdef __GLEE_GL_EXT_texture_integer
void __stdcall _Lazy_glTexParameterIivEXT(GLenum target, GLenum pname, const GLint * params)  {if (GLeeInit()) glTexParameterIivEXT(target, pname, params);}
void __stdcall _Lazy_glTexParameterIuivEXT(GLenum target, GLenum pname, const GLuint * params)  {if (GLeeInit()) glTexParameterIuivEXT(target, pname, params);}
void __stdcall _Lazy_glGetTexParameterIivEXT(GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetTexParameterIivEXT(target, pname, params);}
void __stdcall _Lazy_glGetTexParameterIuivEXT(GLenum target, GLenum pname, GLuint * params)  {if (GLeeInit()) glGetTexParameterIuivEXT(target, pname, params);}
void __stdcall _Lazy_glClearColorIiEXT(GLint red, GLint green, GLint blue, GLint alpha)   {if (GLeeInit()) glClearColorIiEXT(red, green, blue, alpha);}
void __stdcall _Lazy_glClearColorIuiEXT(GLuint red, GLuint green, GLuint blue, GLuint alpha)  {if (GLeeInit()) glClearColorIuiEXT(red, green, blue, alpha);}
PFNGLTEXPARAMETERIIVEXTPROC pglTexParameterIivEXT=_Lazy_glTexParameterIivEXT;
PFNGLTEXPARAMETERIUIVEXTPROC pglTexParameterIuivEXT=_Lazy_glTexParameterIuivEXT;
PFNGLGETTEXPARAMETERIIVEXTPROC pglGetTexParameterIivEXT=_Lazy_glGetTexParameterIivEXT;
PFNGLGETTEXPARAMETERIUIVEXTPROC pglGetTexParameterIuivEXT=_Lazy_glGetTexParameterIuivEXT;
PFNGLCLEARCOLORIIEXTPROC pglClearColorIiEXT=_Lazy_glClearColorIiEXT;
PFNGLCLEARCOLORIUIEXTPROC pglClearColorIuiEXT=_Lazy_glClearColorIuiEXT;
#endif 

/* GL_GREMEDY_frame_terminator */

#ifdef __GLEE_GL_GREMEDY_frame_terminator
void __stdcall _Lazy_glFrameTerminatorGREMEDY(void)                                       {if (GLeeInit()) glFrameTerminatorGREMEDY();}
PFNGLFRAMETERMINATORGREMEDYPROC pglFrameTerminatorGREMEDY=_Lazy_glFrameTerminatorGREMEDY;
#endif 

/* GL_NV_conditional_render */

#ifdef __GLEE_GL_NV_conditional_render
void __stdcall _Lazy_glBeginConditionalRenderNV(GLuint id, GLenum mode)                   {if (GLeeInit()) glBeginConditionalRenderNV(id, mode);}
void __stdcall _Lazy_glEndConditionalRenderNV(void)                                       {if (GLeeInit()) glEndConditionalRenderNV();}
PFNGLBEGINCONDITIONALRENDERNVPROC pglBeginConditionalRenderNV=_Lazy_glBeginConditionalRenderNV;
PFNGLENDCONDITIONALRENDERNVPROC pglEndConditionalRenderNV=_Lazy_glEndConditionalRenderNV;
#endif 

/* GL_NV_present_video */

#ifdef __GLEE_GL_NV_present_video
#endif 

/* GL_EXT_transform_feedback */

#ifdef __GLEE_GL_EXT_transform_feedback
void __stdcall _Lazy_glBeginTransformFeedbackEXT(GLenum primitiveMode)                    {if (GLeeInit()) glBeginTransformFeedbackEXT(primitiveMode);}
void __stdcall _Lazy_glEndTransformFeedbackEXT(void)                                      {if (GLeeInit()) glEndTransformFeedbackEXT();}
void __stdcall _Lazy_glBindBufferRangeEXT(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)  {if (GLeeInit()) glBindBufferRangeEXT(target, index, buffer, offset, size);}
void __stdcall _Lazy_glBindBufferOffsetEXT(GLenum target, GLuint index, GLuint buffer, GLintptr offset)  {if (GLeeInit()) glBindBufferOffsetEXT(target, index, buffer, offset);}
void __stdcall _Lazy_glBindBufferBaseEXT(GLenum target, GLuint index, GLuint buffer)      {if (GLeeInit()) glBindBufferBaseEXT(target, index, buffer);}
void __stdcall _Lazy_glTransformFeedbackVaryingsEXT(GLuint program, GLsizei count, const GLint * locations, GLenum bufferMode)  {if (GLeeInit()) glTransformFeedbackVaryingsEXT(program, count, locations, bufferMode);}
void __stdcall _Lazy_glGetTransformFeedbackVaryingEXT(GLuint program, GLuint index, GLint * location)  {if (GLeeInit()) glGetTransformFeedbackVaryingEXT(program, index, location);}
PFNGLBEGINTRANSFORMFEEDBACKEXTPROC pglBeginTransformFeedbackEXT=_Lazy_glBeginTransformFeedbackEXT;
PFNGLENDTRANSFORMFEEDBACKEXTPROC pglEndTransformFeedbackEXT=_Lazy_glEndTransformFeedbackEXT;
PFNGLBINDBUFFERRANGEEXTPROC pglBindBufferRangeEXT=_Lazy_glBindBufferRangeEXT;
PFNGLBINDBUFFEROFFSETEXTPROC pglBindBufferOffsetEXT=_Lazy_glBindBufferOffsetEXT;
PFNGLBINDBUFFERBASEEXTPROC pglBindBufferBaseEXT=_Lazy_glBindBufferBaseEXT;
PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC pglTransformFeedbackVaryingsEXT=_Lazy_glTransformFeedbackVaryingsEXT;
PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC pglGetTransformFeedbackVaryingEXT=_Lazy_glGetTransformFeedbackVaryingEXT;
#endif 

/* GL_EXT_direct_state_access */

#ifdef __GLEE_GL_EXT_direct_state_access
void __stdcall _Lazy_glClientAttribDefaultEXT(GLbitfield mask)                            {if (GLeeInit()) glClientAttribDefaultEXT(mask);}
void __stdcall _Lazy_glPushClientAttribDefaultEXT(GLbitfield mask)                        {if (GLeeInit()) glPushClientAttribDefaultEXT(mask);}
void __stdcall _Lazy_glMatrixLoadfEXT(GLenum mode, const GLfloat * m)                     {if (GLeeInit()) glMatrixLoadfEXT(mode, m);}
void __stdcall _Lazy_glMatrixLoaddEXT(GLenum mode, const GLdouble * m)                    {if (GLeeInit()) glMatrixLoaddEXT(mode, m);}
void __stdcall _Lazy_glMatrixMultfEXT(GLenum mode, const GLfloat * m)                     {if (GLeeInit()) glMatrixMultfEXT(mode, m);}
void __stdcall _Lazy_glMatrixMultdEXT(GLenum mode, const GLdouble * m)                    {if (GLeeInit()) glMatrixMultdEXT(mode, m);}
void __stdcall _Lazy_glMatrixLoadIdentityEXT(GLenum mode)                                 {if (GLeeInit()) glMatrixLoadIdentityEXT(mode);}
void __stdcall _Lazy_glMatrixRotatefEXT(GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glMatrixRotatefEXT(mode, angle, x, y, z);}
void __stdcall _Lazy_glMatrixRotatedEXT(GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z)  {if (GLeeInit()) glMatrixRotatedEXT(mode, angle, x, y, z);}
void __stdcall _Lazy_glMatrixScalefEXT(GLenum mode, GLfloat x, GLfloat y, GLfloat z)      {if (GLeeInit()) glMatrixScalefEXT(mode, x, y, z);}
void __stdcall _Lazy_glMatrixScaledEXT(GLenum mode, GLdouble x, GLdouble y, GLdouble z)   {if (GLeeInit()) glMatrixScaledEXT(mode, x, y, z);}
void __stdcall _Lazy_glMatrixTranslatefEXT(GLenum mode, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glMatrixTranslatefEXT(mode, x, y, z);}
void __stdcall _Lazy_glMatrixTranslatedEXT(GLenum mode, GLdouble x, GLdouble y, GLdouble z)  {if (GLeeInit()) glMatrixTranslatedEXT(mode, x, y, z);}
void __stdcall _Lazy_glMatrixFrustumEXT(GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)  {if (GLeeInit()) glMatrixFrustumEXT(mode, left, right, bottom, top, zNear, zFar);}
void __stdcall _Lazy_glMatrixOrthoEXT(GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)  {if (GLeeInit()) glMatrixOrthoEXT(mode, left, right, bottom, top, zNear, zFar);}
void __stdcall _Lazy_glMatrixPopEXT(GLenum mode)                                          {if (GLeeInit()) glMatrixPopEXT(mode);}
void __stdcall _Lazy_glMatrixPushEXT(GLenum mode)                                         {if (GLeeInit()) glMatrixPushEXT(mode);}
void __stdcall _Lazy_glMatrixLoadTransposefEXT(GLenum mode, const GLfloat * m)            {if (GLeeInit()) glMatrixLoadTransposefEXT(mode, m);}
void __stdcall _Lazy_glMatrixLoadTransposedEXT(GLenum mode, const GLdouble * m)           {if (GLeeInit()) glMatrixLoadTransposedEXT(mode, m);}
void __stdcall _Lazy_glMatrixMultTransposefEXT(GLenum mode, const GLfloat * m)            {if (GLeeInit()) glMatrixMultTransposefEXT(mode, m);}
void __stdcall _Lazy_glMatrixMultTransposedEXT(GLenum mode, const GLdouble * m)           {if (GLeeInit()) glMatrixMultTransposedEXT(mode, m);}
void __stdcall _Lazy_glTextureParameterfEXT(GLuint texture, GLenum target, GLenum pname, GLfloat param)  {if (GLeeInit()) glTextureParameterfEXT(texture, target, pname, param);}
void __stdcall _Lazy_glTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glTextureParameterfvEXT(texture, target, pname, params);}
void __stdcall _Lazy_glTextureParameteriEXT(GLuint texture, GLenum target, GLenum pname, GLint param)  {if (GLeeInit()) glTextureParameteriEXT(texture, target, pname, param);}
void __stdcall _Lazy_glTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, const GLint * params)  {if (GLeeInit()) glTextureParameterivEXT(texture, target, pname, params);}
void __stdcall _Lazy_glTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glTextureImage1DEXT(texture, target, level, internalformat, width, border, format, type, pixels);}
void __stdcall _Lazy_glTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glTextureImage2DEXT(texture, target, level, internalformat, width, height, border, format, type, pixels);}
void __stdcall _Lazy_glTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glTextureSubImage1DEXT(texture, target, level, xoffset, width, format, type, pixels);}
void __stdcall _Lazy_glTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, type, pixels);}
void __stdcall _Lazy_glCopyTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)  {if (GLeeInit()) glCopyTextureImage1DEXT(texture, target, level, internalformat, x, y, width, border);}
void __stdcall _Lazy_glCopyTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)  {if (GLeeInit()) glCopyTextureImage2DEXT(texture, target, level, internalformat, x, y, width, height, border);}
void __stdcall _Lazy_glCopyTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)  {if (GLeeInit()) glCopyTextureSubImage1DEXT(texture, target, level, xoffset, x, y, width);}
void __stdcall _Lazy_glCopyTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)  {if (GLeeInit()) glCopyTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, x, y, width, height);}
void __stdcall _Lazy_glGetTextureImageEXT(GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels)  {if (GLeeInit()) glGetTextureImageEXT(texture, target, level, format, type, pixels);}
void __stdcall _Lazy_glGetTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetTextureParameterfvEXT(texture, target, pname, params);}
void __stdcall _Lazy_glGetTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetTextureParameterivEXT(texture, target, pname, params);}
void __stdcall _Lazy_glGetTextureLevelParameterfvEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetTextureLevelParameterfvEXT(texture, target, level, pname, params);}
void __stdcall _Lazy_glGetTextureLevelParameterivEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLint * params)  {if (GLeeInit()) glGetTextureLevelParameterivEXT(texture, target, level, pname, params);}
void __stdcall _Lazy_glTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, format, type, pixels);}
void __stdcall _Lazy_glTextureSubImage3DEXT(GLuint texture, 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()) glTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);}
void __stdcall _Lazy_glCopyTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)  {if (GLeeInit()) glCopyTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, x, y, width, height);}
void __stdcall _Lazy_glMultiTexParameterfEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat param)  {if (GLeeInit()) glMultiTexParameterfEXT(texunit, target, pname, param);}
void __stdcall _Lazy_glMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glMultiTexParameterfvEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glMultiTexParameteriEXT(GLenum texunit, GLenum target, GLenum pname, GLint param)  {if (GLeeInit()) glMultiTexParameteriEXT(texunit, target, pname, param);}
void __stdcall _Lazy_glMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint * params)  {if (GLeeInit()) glMultiTexParameterivEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glMultiTexImage1DEXT(texunit, target, level, internalformat, width, border, format, type, pixels);}
void __stdcall _Lazy_glMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glMultiTexImage2DEXT(texunit, target, level, internalformat, width, height, border, format, type, pixels);}
void __stdcall _Lazy_glMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glMultiTexSubImage1DEXT(texunit, target, level, xoffset, width, format, type, pixels);}
void __stdcall _Lazy_glMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, type, pixels);}
void __stdcall _Lazy_glCopyMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)  {if (GLeeInit()) glCopyMultiTexImage1DEXT(texunit, target, level, internalformat, x, y, width, border);}
void __stdcall _Lazy_glCopyMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)  {if (GLeeInit()) glCopyMultiTexImage2DEXT(texunit, target, level, internalformat, x, y, width, height, border);}
void __stdcall _Lazy_glCopyMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)  {if (GLeeInit()) glCopyMultiTexSubImage1DEXT(texunit, target, level, xoffset, x, y, width);}
void __stdcall _Lazy_glCopyMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)  {if (GLeeInit()) glCopyMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, x, y, width, height);}
void __stdcall _Lazy_glGetMultiTexImageEXT(GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels)  {if (GLeeInit()) glGetMultiTexImageEXT(texunit, target, level, format, type, pixels);}
void __stdcall _Lazy_glGetMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetMultiTexParameterfvEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glGetMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetMultiTexParameterivEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glGetMultiTexLevelParameterfvEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetMultiTexLevelParameterfvEXT(texunit, target, level, pname, params);}
void __stdcall _Lazy_glGetMultiTexLevelParameterivEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, GLint * params)  {if (GLeeInit()) glGetMultiTexLevelParameterivEXT(texunit, target, level, pname, params);}
void __stdcall _Lazy_glMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)  {if (GLeeInit()) glMultiTexImage3DEXT(texunit, target, level, internalformat, width, height, depth, border, format, type, pixels);}
void __stdcall _Lazy_glMultiTexSubImage3DEXT(GLenum texunit, 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()) glMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);}
void __stdcall _Lazy_glCopyMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)  {if (GLeeInit()) glCopyMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height);}
void __stdcall _Lazy_glBindMultiTextureEXT(GLenum texunit, GLenum target, GLuint texture)  {if (GLeeInit()) glBindMultiTextureEXT(texunit, target, texture);}
void __stdcall _Lazy_glEnableClientStateIndexedEXT(GLenum array, GLuint index)            {if (GLeeInit()) glEnableClientStateIndexedEXT(array, index);}
void __stdcall _Lazy_glDisableClientStateIndexedEXT(GLenum array, GLuint index)           {if (GLeeInit()) glDisableClientStateIndexedEXT(array, index);}
void __stdcall _Lazy_glMultiTexCoordPointerEXT(GLenum texunit, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)  {if (GLeeInit()) glMultiTexCoordPointerEXT(texunit, size, type, stride, pointer);}
void __stdcall _Lazy_glMultiTexEnvfEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat param)  {if (GLeeInit()) glMultiTexEnvfEXT(texunit, target, pname, param);}
void __stdcall _Lazy_glMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glMultiTexEnvfvEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glMultiTexEnviEXT(GLenum texunit, GLenum target, GLenum pname, GLint param)  {if (GLeeInit()) glMultiTexEnviEXT(texunit, target, pname, param);}
void __stdcall _Lazy_glMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint * params)  {if (GLeeInit()) glMultiTexEnvivEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glMultiTexGendEXT(GLenum texunit, GLenum coord, GLenum pname, GLdouble param)  {if (GLeeInit()) glMultiTexGendEXT(texunit, coord, pname, param);}
void __stdcall _Lazy_glMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, const GLdouble * params)  {if (GLeeInit()) glMultiTexGendvEXT(texunit, coord, pname, params);}
void __stdcall _Lazy_glMultiTexGenfEXT(GLenum texunit, GLenum coord, GLenum pname, GLfloat param)  {if (GLeeInit()) glMultiTexGenfEXT(texunit, coord, pname, param);}
void __stdcall _Lazy_glMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glMultiTexGenfvEXT(texunit, coord, pname, params);}
void __stdcall _Lazy_glMultiTexGeniEXT(GLenum texunit, GLenum coord, GLenum pname, GLint param)  {if (GLeeInit()) glMultiTexGeniEXT(texunit, coord, pname, param);}
void __stdcall _Lazy_glMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, const GLint * params)  {if (GLeeInit()) glMultiTexGenivEXT(texunit, coord, pname, params);}
void __stdcall _Lazy_glGetMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetMultiTexEnvfvEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glGetMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetMultiTexEnvivEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glGetMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, GLdouble * params)  {if (GLeeInit()) glGetMultiTexGendvEXT(texunit, coord, pname, params);}
void __stdcall _Lazy_glGetMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetMultiTexGenfvEXT(texunit, coord, pname, params);}
void __stdcall _Lazy_glGetMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, GLint * params)  {if (GLeeInit()) glGetMultiTexGenivEXT(texunit, coord, pname, params);}
void __stdcall _Lazy_glGetFloatIndexedvEXT(GLenum target, GLuint index, GLfloat * data)   {if (GLeeInit()) glGetFloatIndexedvEXT(target, index, data);}
void __stdcall _Lazy_glGetDoubleIndexedvEXT(GLenum target, GLuint index, GLdouble * data)  {if (GLeeInit()) glGetDoubleIndexedvEXT(target, index, data);}
void __stdcall _Lazy_glGetPointerIndexedvEXT(GLenum target, GLuint index, GLvoid* * data)  {if (GLeeInit()) glGetPointerIndexedvEXT(target, index, data);}
void __stdcall _Lazy_glCompressedTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * bits)  {if (GLeeInit()) glCompressedTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, imageSize, bits);}
void __stdcall _Lazy_glCompressedTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * bits)  {if (GLeeInit()) glCompressedTextureImage2DEXT(texture, target, level, internalformat, width, height, border, imageSize, bits);}
void __stdcall _Lazy_glCompressedTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * bits)  {if (GLeeInit()) glCompressedTextureImage1DEXT(texture, target, level, internalformat, width, border, imageSize, bits);}
void __stdcall _Lazy_glCompressedTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * bits)  {if (GLeeInit()) glCompressedTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);}
void __stdcall _Lazy_glCompressedTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * bits)  {if (GLeeInit()) glCompressedTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits);}
void __stdcall _Lazy_glCompressedTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * bits)  {if (GLeeInit()) glCompressedTextureSubImage1DEXT(texture, target, level, xoffset, width, format, imageSize, bits);}
void __stdcall _Lazy_glGetCompressedTextureImageEXT(GLuint texture, GLenum target, GLint lod, GLvoid * img)  {if (GLeeInit()) glGetCompressedTextureImageEXT(texture, target, lod, img);}
void __stdcall _Lazy_glCompressedMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * bits)  {if (GLeeInit()) glCompressedMultiTexImage3DEXT(texunit, target, level, internalformat, width, height, depth, border, imageSize, bits);}
void __stdcall _Lazy_glCompressedMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * bits)  {if (GLeeInit()) glCompressedMultiTexImage2DEXT(texunit, target, level, internalformat, width, height, border, imageSize, bits);}
void __stdcall _Lazy_glCompressedMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * bits)  {if (GLeeInit()) glCompressedMultiTexImage1DEXT(texunit, target, level, internalformat, width, border, imageSize, bits);}
void __stdcall _Lazy_glCompressedMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * bits)  {if (GLeeInit()) glCompressedMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);}
void __stdcall _Lazy_glCompressedMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * bits)  {if (GLeeInit()) glCompressedMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits);}
void __stdcall _Lazy_glCompressedMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * bits)  {if (GLeeInit()) glCompressedMultiTexSubImage1DEXT(texunit, target, level, xoffset, width, format, imageSize, bits);}
void __stdcall _Lazy_glGetCompressedMultiTexImageEXT(GLenum texunit, GLenum target, GLint lod, GLvoid * img)  {if (GLeeInit()) glGetCompressedMultiTexImageEXT(texunit, target, lod, img);}
void __stdcall _Lazy_glNamedProgramStringEXT(GLuint program, GLenum target, GLenum format, GLsizei len, const GLvoid * string)  {if (GLeeInit()) glNamedProgramStringEXT(program, target, format, len, string);}
void __stdcall _Lazy_glNamedProgramLocalParameter4dEXT(GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)  {if (GLeeInit()) glNamedProgramLocalParameter4dEXT(program, target, index, x, y, z, w);}
void __stdcall _Lazy_glNamedProgramLocalParameter4dvEXT(GLuint program, GLenum target, GLuint index, const GLdouble * params)  {if (GLeeInit()) glNamedProgramLocalParameter4dvEXT(program, target, index, params);}
void __stdcall _Lazy_glNamedProgramLocalParameter4fEXT(GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)  {if (GLeeInit()) glNamedProgramLocalParameter4fEXT(program, target, index, x, y, z, w);}
void __stdcall _Lazy_glNamedProgramLocalParameter4fvEXT(GLuint program, GLenum target, GLuint index, const GLfloat * params)  {if (GLeeInit()) glNamedProgramLocalParameter4fvEXT(program, target, index, params);}
void __stdcall _Lazy_glGetNamedProgramLocalParameterdvEXT(GLuint program, GLenum target, GLuint index, GLdouble * params)  {if (GLeeInit()) glGetNamedProgramLocalParameterdvEXT(program, target, index, params);}
void __stdcall _Lazy_glGetNamedProgramLocalParameterfvEXT(GLuint program, GLenum target, GLuint index, GLfloat * params)  {if (GLeeInit()) glGetNamedProgramLocalParameterfvEXT(program, target, index, params);}
void __stdcall _Lazy_glGetNamedProgramivEXT(GLuint program, GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetNamedProgramivEXT(program, target, pname, params);}
void __stdcall _Lazy_glGetNamedProgramStringEXT(GLuint program, GLenum target, GLenum pname, GLvoid * string)  {if (GLeeInit()) glGetNamedProgramStringEXT(program, target, pname, string);}
void __stdcall _Lazy_glNamedProgramLocalParameters4fvEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat * params)  {if (GLeeInit()) glNamedProgramLocalParameters4fvEXT(program, target, index, count, params);}
void __stdcall _Lazy_glNamedProgramLocalParameterI4iEXT(GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w)  {if (GLeeInit()) glNamedProgramLocalParameterI4iEXT(program, target, index, x, y, z, w);}
void __stdcall _Lazy_glNamedProgramLocalParameterI4ivEXT(GLuint program, GLenum target, GLuint index, const GLint * params)  {if (GLeeInit()) glNamedProgramLocalParameterI4ivEXT(program, target, index, params);}
void __stdcall _Lazy_glNamedProgramLocalParametersI4ivEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLint * params)  {if (GLeeInit()) glNamedProgramLocalParametersI4ivEXT(program, target, index, count, params);}
void __stdcall _Lazy_glNamedProgramLocalParameterI4uiEXT(GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)  {if (GLeeInit()) glNamedProgramLocalParameterI4uiEXT(program, target, index, x, y, z, w);}
void __stdcall _Lazy_glNamedProgramLocalParameterI4uivEXT(GLuint program, GLenum target, GLuint index, const GLuint * params)  {if (GLeeInit()) glNamedProgramLocalParameterI4uivEXT(program, target, index, params);}
void __stdcall _Lazy_glNamedProgramLocalParametersI4uivEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint * params)  {if (GLeeInit()) glNamedProgramLocalParametersI4uivEXT(program, target, index, count, params);}
void __stdcall _Lazy_glGetNamedProgramLocalParameterIivEXT(GLuint program, GLenum target, GLuint index, GLint * params)  {if (GLeeInit()) glGetNamedProgramLocalParameterIivEXT(program, target, index, params);}
void __stdcall _Lazy_glGetNamedProgramLocalParameterIuivEXT(GLuint program, GLenum target, GLuint index, GLuint * params)  {if (GLeeInit()) glGetNamedProgramLocalParameterIuivEXT(program, target, index, params);}
void __stdcall _Lazy_glTextureParameterIivEXT(GLuint texture, GLenum target, GLenum pname, const GLint * params)  {if (GLeeInit()) glTextureParameterIivEXT(texture, target, pname, params);}
void __stdcall _Lazy_glTextureParameterIuivEXT(GLuint texture, GLenum target, GLenum pname, const GLuint * params)  {if (GLeeInit()) glTextureParameterIuivEXT(texture, target, pname, params);}
void __stdcall _Lazy_glGetTextureParameterIivEXT(GLuint texture, GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetTextureParameterIivEXT(texture, target, pname, params);}
void __stdcall _Lazy_glGetTextureParameterIuivEXT(GLuint texture, GLenum target, GLenum pname, GLuint * params)  {if (GLeeInit()) glGetTextureParameterIuivEXT(texture, target, pname, params);}
void __stdcall _Lazy_glMultiTexParameterIivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint * params)  {if (GLeeInit()) glMultiTexParameterIivEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glMultiTexParameterIuivEXT(GLenum texunit, GLenum target, GLenum pname, const GLuint * params)  {if (GLeeInit()) glMultiTexParameterIuivEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glGetMultiTexParameterIivEXT(GLenum texunit, GLenum target, GLenum pname, GLint * params)  {if (GLeeInit()) glGetMultiTexParameterIivEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glGetMultiTexParameterIuivEXT(GLenum texunit, GLenum target, GLenum pname, GLuint * params)  {if (GLeeInit()) glGetMultiTexParameterIuivEXT(texunit, target, pname, params);}
void __stdcall _Lazy_glProgramUniform1fEXT(GLuint program, GLint location, GLfloat v0)    {if (GLeeInit()) glProgramUniform1fEXT(program, location, v0);}
void __stdcall _Lazy_glProgramUniform2fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1)  {if (GLeeInit()) glProgramUniform2fEXT(program, location, v0, v1);}
void __stdcall _Lazy_glProgramUniform3fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)  {if (GLeeInit()) glProgramUniform3fEXT(program, location, v0, v1, v2);}
void __stdcall _Lazy_glProgramUniform4fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)  {if (GLeeInit()) glProgramUniform4fEXT(program, location, v0, v1, v2, v3);}
void __stdcall _Lazy_glProgramUniform1iEXT(GLuint program, GLint location, GLint v0)      {if (GLeeInit()) glProgramUniform1iEXT(program, location, v0);}
void __stdcall _Lazy_glProgramUniform2iEXT(GLuint program, GLint location, GLint v0, GLint v1)  {if (GLeeInit()) glProgramUniform2iEXT(program, location, v0, v1);}
void __stdcall _Lazy_glProgramUniform3iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)  {if (GLeeInit()) glProgramUniform3iEXT(program, location, v0, v1, v2);}
void __stdcall _Lazy_glProgramUniform4iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)  {if (GLeeInit()) glProgramUniform4iEXT(program, location, v0, v1, v2, v3);}
void __stdcall _Lazy_glProgramUniform1fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat * value)  {if (GLeeInit()) glProgramUniform1fvEXT(program, location, count, value);}
void __stdcall _Lazy_glProgramUniform2fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat * value)  {if (GLeeInit()) glProgramUniform2fvEXT(program, location, count, value);}
void __stdcall _Lazy_glProgramUniform3fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat * value)  {if (GLeeInit()) glProgramUniform3fvEXT(program, location, count, value);}
void __stdcall _Lazy_glProgramUniform4fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat * value)  {if (GLeeInit()) glProgramUniform4fvEXT(program, location, count, value);}
void __stdcall _Lazy_glProgramUniform1ivEXT(GLuint program, GLint location, GLsizei count, const GLint * value)  {if (GLeeInit()) glProgramUniform1ivEXT(program, location, count, value);}
void __stdcall _Lazy_glProgramUniform2ivEXT(GLuint program, GLint location, GLsizei count, const GLint * value)  {if (GLeeInit()) glProgramUniform2ivEXT(program, location, count, value);}
void __stdcall _Lazy_glProgramUniform3ivEXT(GLuint program, GLint location, GLsizei count, const GLint * value)  {if (GLeeInit()) glProgramUniform3ivEXT(program, location, count, value);}
void __stdcall _Lazy_glProgramUniform4ivEXT(GLuint program, GLint location, GLsizei count, const GLint * value)  {if (GLeeInit()) glProgramUniform4ivEXT(program, location, count, value);}
void __stdcall _Lazy_glProgramUniformMatrix2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)  {if (GLeeInit()) glProgramUniformMatrix2fvEXT(program, location, count, transpose, value);}
void __stdcall _Lazy_glProgramUniformMatrix3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)  {if (GLeeInit()) glProgramUniformMatrix3fvEXT(program, location, count, transpose, value);}
void __stdcall _Lazy_glProgramUniformMatrix4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)  {if (GLeeInit()) glProgramUniformMatrix4fvEXT(program, location, count, transpose, value);}
void __stdcall _Lazy_glProgramUniformMatrix2x3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)  {if (GLeeInit()) glProgramUniformMatrix2x3fvEXT(program, location, count, transpose, value);}
void __stdcall _Lazy_glProgramUniformMatrix3x2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)  {if (GLeeInit()) glProgramUniformMatrix3x2fvEXT(program, location, count, transpose, value);}