/RenderSystems/GL/src/glew.cpp

https://bitbucket.org/CaptainOz/ogre · C++ · 15975 lines · 13635 code · 2237 blank · 103 comment · 5788 complexity · 03c7f59172b941e4b5970c33eb19765f MD5 · raw file 

    

  1. /*
    2. 

  2. ** The OpenGL Extension Wrangler Library
    3. 

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

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

  5. ** Copyright (C) 2002, Lev Povalahev
    6. 

  6. ** All rights reserved.
    7. 

  7. ** 
    8. 

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

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

  10. ** 
    11. 

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

  12. **   this list of conditions and the following disclaimer.
    13. 

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

  14. **   this list of conditions and the following disclaimer in the documentation 
    15. 

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

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

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

  18. **
    19. 

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

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

  21. ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    22. 

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

  23. ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
    24. 

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

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

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

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

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

  29. ** THE POSSIBILITY OF SUCH DAMAGE.
    30. 

  30. */
    31. 

  31. 

  32. // SJS
    33. 

  33. #include "OgreGLSupport.h"
    34. 

  34. // SJS
    35. 

  35. 

  36. #include <GL/glew.h>
    37. 

  37. #if defined(_WIN32)
    38. 

  38. #  include <GL/wglew.h>
    39. 

  39. #elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)
    40. 

  40. #  include <GL/glxew.h>
    41. 

  41. #endif
    42. 

  42. 

  43. /*
    44. 

  44.  * Define glewGetContext and related helper macros.
    45. 

  45.  */
    46. 

  46. #ifdef GLEW_MX
    47. 

  47. #  define glewGetContext() ctx
    48. 

  48. #  ifdef _WIN32
    49. 

  49. #    define GLEW_CONTEXT_ARG_DEF_INIT GLEWContext* ctx
    50. 

  50. #    define GLEW_CONTEXT_ARG_VAR_INIT ctx
    51. 

  51. #    define wglewGetContext() ctx
    52. 

  52. #    define WGLEW_CONTEXT_ARG_DEF_INIT WGLEWContext* ctx
    53. 

  53. #    define WGLEW_CONTEXT_ARG_DEF_LIST WGLEWContext* ctx
    54. 

  54. #  else /* _WIN32 */
    55. 

  55. #    define GLEW_CONTEXT_ARG_DEF_INIT void
    56. 

  56. #    define GLEW_CONTEXT_ARG_VAR_INIT
    57. 

  57. #    define glxewGetContext() ctx
    58. 

  58. #    define GLXEW_CONTEXT_ARG_DEF_INIT void
    59. 

  59. #    define GLXEW_CONTEXT_ARG_DEF_LIST GLXEWContext* ctx
    60. 

  60. #  endif /* _WIN32 */
    61. 

  61. #  define GLEW_CONTEXT_ARG_DEF_LIST GLEWContext* ctx
    62. 

  62. #else /* GLEW_MX */
    63. 

  63. // SJS
    64. 

  64. #  define GLEW_CONTEXT_ARG_DEF_INIT Ogre::GLSupport *glSupport
    65. 

  65. #  define GLEW_CONTEXT_ARG_VAR_INIT glSupport
    66. 

  66. #  define GLEW_CONTEXT_ARG_DEF_LIST Ogre::GLSupport *glSupport
    67. 

  67. #  define WGLEW_CONTEXT_ARG_DEF_INIT Ogre::GLSupport *glSupport
    68. 

  68. #  define WGLEW_CONTEXT_ARG_DEF_LIST Ogre::GLSupport *glSupport
    69. 

  69. #  define GLXEW_CONTEXT_ARG_DEF_INIT Ogre::GLSupport *glSupport
    70. 

  70. #  define GLXEW_CONTEXT_ARG_DEF_LIST Ogre::GLSupport *glSupport
    71. 

  71. //#  define GLEW_CONTEXT_ARG_DEF_INIT void
    72. 

  72. //#  define GLEW_CONTEXT_ARG_VAR_INIT
    73. 

  73. //#  define GLEW_CONTEXT_ARG_DEF_LIST void
    74. 

  74. //#  define WGLEW_CONTEXT_ARG_DEF_INIT void
    75. 

  75. //#  define WGLEW_CONTEXT_ARG_DEF_LIST void
    76. 

  76. //#  define GLXEW_CONTEXT_ARG_DEF_INIT void
    77. 

  77. //#  define GLXEW_CONTEXT_ARG_DEF_LIST void
    78. 

  78. // SJS
    79. 

  79. #endif /* GLEW_MX */
    80. 

  80. 

  81. #if defined(__sgi) || defined (__sun) || defined(GLEW_APPLE_GLX)
    82. 

  82. #include <dlfcn.h>
    83. 

  83. #include <stdio.h>
    84. 

  84. #include <stdlib.h>
    85. 

  85. 

  86. void* dlGetProcAddress (const GLubyte* name)
    87. 

  87. {
    88. 

  88.   static void* h = NULL;
    89. 

  89.   static void* gpa;
    90. 

  90. 

  91.   if (h == NULL)
    92. 

  92.   {
    93. 

  93.     if ((h = dlopen(NULL, RTLD_LAZY | RTLD_LOCAL)) == NULL) return NULL;
    94. 

  94.     gpa = dlsym(h, "glXGetProcAddress");
    95. 

  95.   }
    96. 

  96. 

  97.   if (gpa != NULL)
    98. 

  98.     return ((void*(*)(const GLubyte*))gpa)(name);
    99. 

  99.   else
    100. 

  100.     return dlsym(h, (const char*)name);
    101. 

  101. }
    102. 

  102. #endif /* __sgi || __sun || GLEW_APPLE_GLX */
    103. 

  103. 

  104. #if defined(__APPLE__)
    105. 

  105. #include <stdlib.h>
    106. 

  106. #include <string.h>
    107. 

  107. #include <AvailabilityMacros.h>
    108. 

  108. 

  109. #ifdef MAC_OS_X_VERSION_10_3
    110. 

  110. 

  111. #include <dlfcn.h>
    112. 

  112. 

  113. void* NSGLGetProcAddress (const GLubyte *name)
    114. 

  114. {
    115. 

  115.   static void* image = NULL;
    116. 

  116.   if (NULL == image) 
    117. 

  117.   {
    118. 

  118.     image = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY);
    119. 

  119.   }
    120. 

  120.   if( !image ) return NULL;
    121. 

  121.   void* addr = dlsym(image, (const char*)name);
    122. 

  122.   if( addr ) return addr;
    123. 

  123. #ifdef GLEW_APPLE_GLX
    124. 

  124.   return dlGetProcAddress( name ); // try next for glx symbols
    125. 

  125. #else
    126. 

  126.   return NULL;
    127. 

  127. #endif
    128. 

  128. }
    129. 

  129. #else
    130. 

  130. 

  131. #include <mach-o/dyld.h>
    132. 

  132. 

  133. void* NSGLGetProcAddress (const GLubyte *name)
    134. 

  134. {
    135. 

  135.   static const struct mach_header* image = NULL;
    136. 

  136.   NSSymbol symbol;
    137. 

  137.   char* symbolName;
    138. 

  138.   if (NULL == image)
    139. 

  139.   {
    140. 

  140.     image = NSAddImage("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", NSADDIMAGE_OPTION_RETURN_ON_ERROR);
    141. 

  141.   }
    142. 

  142.   /* prepend a '_' for the Unix C symbol mangling convention */
    143. 

  143.   symbolName = malloc(strlen((const char*)name) + 2);
    144. 

  144.   strcpy(symbolName+1, (const char*)name);
    145. 

  145.   symbolName[0] = '_';
    146. 

  146.   symbol = NULL;
    147. 

  147.   /* if (NSIsSymbolNameDefined(symbolName))
    148. 

  148. 	 symbol = NSLookupAndBindSymbol(symbolName); */
    149. 

  149.   symbol = image ? NSLookupSymbolInImage(image, symbolName, NSLOOKUPSYMBOLINIMAGE_OPTION_BIND | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR) : NULL;
    150. 

  150.   free(symbolName);
    151. 

  151.   if( symbol ) return NSAddressOfSymbol(symbol);
    152. 

  152. #ifdef GLEW_APPLE_GLX
    153. 

  153.   return dlGetProcAddress( name ); // try next for glx symbols
    154. 

  154. #else
    155. 

  155.   return NULL;
    156. 

  156. #endif
    157. 

  157. }
    158. 

  158. #endif /* MAC_OS_X_VERSION_10_3 */
    159. 

  159. #endif /* __APPLE__ */
    160. 

  160. 

  161. /*
    162. 

  162.  * Define glewGetProcAddress.
    163. 

  163.  */
    164. 

  164. #if defined(_WIN32)
    165. 

  165. #  define glewGetProcAddress(name) wglGetProcAddress((LPCSTR)name)
    166. 

  166. #else
    167. 

  167. #  if defined(__APPLE__)
    168. 

  168. #    define glewGetProcAddress(name) NSGLGetProcAddress(name)
    169. 

  169. #  else
    170. 

  170. #    if defined(__sgi) || defined(__sun)
    171. 

  171. #      define glewGetProcAddress(name) dlGetProcAddress(name)
    172. 

  172. #    else /* __linux */
    173. 

  173. #      define glewGetProcAddress(name) (*glXGetProcAddressARB)(name)
    174. 

  174. #    endif
    175. 

  175. #  endif
    176. 

  176. #endif
    177. 

  177. 

  178. /*
    179. 

  179.  * Define GLboolean const cast.
    180. 

  180.  */
    181. 

  181. #define CONST_CAST(x) (*(GLboolean*)&x)
    182. 

  182. 

  183. /*
    184. 

  184.  * GLEW, just like OpenGL or GLU, does not rely on the standard C library.
    185. 

  185.  * These functions implement the functionality required in this file.
    186. 

  186.  */
    187. 

  187. static GLuint _glewStrLen (const GLubyte* s)
    188. 

  188. {
    189. 

  189.   GLuint i=0;
    190. 

  190.   if (s == NULL) return 0;
    191. 

  191.   while (s[i] != '\0') i++;
    192. 

  192.   return i;
    193. 

  193. }
    194. 

  194. 

  195. static GLuint _glewStrCLen (const GLubyte* s, GLubyte c)
    196. 

  196. {
    197. 

  197.   GLuint i=0;
    198. 

  198.   if (s == NULL) return 0;
    199. 

  199.   while (s[i] != '\0' && s[i] != c) i++;
    200. 

  200.   return (s[i] == '\0' || s[i] == c) ? i : 0;
    201. 

  201. }
    202. 

  202. 

  203. static GLboolean _glewStrSame (const GLubyte* a, const GLubyte* b, GLuint n)
    204. 

  204. {
    205. 

  205.   GLuint i=0;
    206. 

  206.   if(a == NULL || b == NULL)
    207. 

  207.     return (a == NULL && b == NULL && n == 0) ? GL_TRUE : GL_FALSE;
    208. 

  208.   while (i < n && a[i] != '\0' && b[i] != '\0' && a[i] == b[i]) i++;
    209. 

  209.   return i == n ? GL_TRUE : GL_FALSE;
    210. 

  210. }
    211. 

  211. 

  212. static GLboolean _glewStrSame1 (GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb)
    213. 

  213. {
    214. 

  214.   while (*na > 0 && (**a == ' ' || **a == '\n' || **a == '\r' || **a == '\t'))
    215. 

  215.   {
    216. 

  216.     (*a)++;
    217. 

  217.     (*na)--;
    218. 

  218.   }
    219. 

  219.   if(*na >= nb)
    220. 

  220.   {
    221. 

  221.     GLuint i=0;
    222. 

  222.     while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++;
    223. 

  223.     if(i == nb)
    224. 

  224.     {
    225. 

  225.       *a = *a + nb;
    226. 

  226.       *na = *na - nb;
    227. 

  227.       return GL_TRUE;
    228. 

  228.     }
    229. 

  229.   }
    230. 

  230.   return GL_FALSE;
    231. 

  231. }
    232. 

  232. 

  233. static GLboolean _glewStrSame2 (GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb)
    234. 

  234. {
    235. 

  235.   if(*na >= nb)
    236. 

  236.   {
    237. 

  237.     GLuint i=0;
    238. 

  238.     while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++;
    239. 

  239.     if(i == nb)
    240. 

  240.     {
    241. 

  241.       *a = *a + nb;
    242. 

  242.       *na = *na - nb;
    243. 

  243.       return GL_TRUE;
    244. 

  244.     }
    245. 

  245.   }
    246. 

  246.   return GL_FALSE;
    247. 

  247. }
    248. 

  248. 

  249. static GLboolean _glewStrSame3 (GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb)
    250. 

  250. {
    251. 

  251.   if(*na >= nb)
    252. 

  252.   {
    253. 

  253.     GLuint i=0;
    254. 

  254.     while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++;
    255. 

  255.     if (i == nb && (*na == nb || (*a)[i] == ' ' || (*a)[i] == '\n' || (*a)[i] == '\r' || (*a)[i] == '\t'))
    256. 

  256.     {
    257. 

  257.       *a = *a + nb;
    258. 

  258.       *na = *na - nb;
    259. 

  259.       return GL_TRUE;
    260. 

  260.     }
    261. 

  261.   }
    262. 

  262.   return GL_FALSE;
    263. 

  263. }
    264. 

  264. 

  265. /*
    266. 

  266.  * Search for name in the extensions string. Use of strstr()
    267. 

  267.  * is not sufficient because extension names can be prefixes of
    268. 

  268.  * other extension names. Could use strtok() but the constant
    269. 

  269.  * string returned by glGetString might be in read-only memory.
    270. 

  270.  */
    271. 

  271. static GLboolean _glewSearchExtension (const char* name, const GLubyte *start, const GLubyte *end)
    272. 

  272. {
    273. 

  273.   const GLubyte* p;
    274. 

  274.   GLuint len = _glewStrLen((const GLubyte*)name);
    275. 

  275.   p = start;
    276. 

  276.   while (p < end)
    277. 

  277.   {
    278. 

  278.     GLuint n = _glewStrCLen(p, ' ');
    279. 

  279.     if (len == n && _glewStrSame((const GLubyte*)name, p, n)) return GL_TRUE;
    280. 

  280.     p += n+1;
    281. 

  281.   }
    282. 

  282.   return GL_FALSE;
    283. 

  283. }
    284. 

  284. 

  285. #if !defined(_WIN32) || !defined(GLEW_MX)
    286. 

  286. 

  287. PFNGLCOPYTEXSUBIMAGE3DPROC __glewCopyTexSubImage3D = NULL;
    288. 

  288. PFNGLDRAWRANGEELEMENTSPROC __glewDrawRangeElements = NULL;
    289. 

  289. PFNGLTEXIMAGE3DPROC __glewTexImage3D = NULL;
    290. 

  290. PFNGLTEXSUBIMAGE3DPROC __glewTexSubImage3D = NULL;
    291. 

  291. 

  292. PFNGLACTIVETEXTUREPROC __glewActiveTexture = NULL;
    293. 

  293. PFNGLCLIENTACTIVETEXTUREPROC __glewClientActiveTexture = NULL;
    294. 

  294. PFNGLCOMPRESSEDTEXIMAGE1DPROC __glewCompressedTexImage1D = NULL;
    295. 

  295. PFNGLCOMPRESSEDTEXIMAGE2DPROC __glewCompressedTexImage2D = NULL;
    296. 

  296. PFNGLCOMPRESSEDTEXIMAGE3DPROC __glewCompressedTexImage3D = NULL;
    297. 

  297. PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC __glewCompressedTexSubImage1D = NULL;
    298. 

  298. PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC __glewCompressedTexSubImage2D = NULL;
    299. 

  299. PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC __glewCompressedTexSubImage3D = NULL;
    300. 

  300. PFNGLGETCOMPRESSEDTEXIMAGEPROC __glewGetCompressedTexImage = NULL;
    301. 

  301. PFNGLLOADTRANSPOSEMATRIXDPROC __glewLoadTransposeMatrixd = NULL;
    302. 

  302. PFNGLLOADTRANSPOSEMATRIXFPROC __glewLoadTransposeMatrixf = NULL;
    303. 

  303. PFNGLMULTTRANSPOSEMATRIXDPROC __glewMultTransposeMatrixd = NULL;
    304. 

  304. PFNGLMULTTRANSPOSEMATRIXFPROC __glewMultTransposeMatrixf = NULL;
    305. 

  305. PFNGLMULTITEXCOORD1DPROC __glewMultiTexCoord1d = NULL;
    306. 

  306. PFNGLMULTITEXCOORD1DVPROC __glewMultiTexCoord1dv = NULL;
    307. 

  307. PFNGLMULTITEXCOORD1FPROC __glewMultiTexCoord1f = NULL;
    308. 

  308. PFNGLMULTITEXCOORD1FVPROC __glewMultiTexCoord1fv = NULL;
    309. 

  309. PFNGLMULTITEXCOORD1IPROC __glewMultiTexCoord1i = NULL;
    310. 

  310. PFNGLMULTITEXCOORD1IVPROC __glewMultiTexCoord1iv = NULL;
    311. 

  311. PFNGLMULTITEXCOORD1SPROC __glewMultiTexCoord1s = NULL;
    312. 

  312. PFNGLMULTITEXCOORD1SVPROC __glewMultiTexCoord1sv = NULL;
    313. 

  313. PFNGLMULTITEXCOORD2DPROC __glewMultiTexCoord2d = NULL;
    314. 

  314. PFNGLMULTITEXCOORD2DVPROC __glewMultiTexCoord2dv = NULL;
    315. 

  315. PFNGLMULTITEXCOORD2FPROC __glewMultiTexCoord2f = NULL;
    316. 

  316. PFNGLMULTITEXCOORD2FVPROC __glewMultiTexCoord2fv = NULL;
    317. 

  317. PFNGLMULTITEXCOORD2IPROC __glewMultiTexCoord2i = NULL;
    318. 

  318. PFNGLMULTITEXCOORD2IVPROC __glewMultiTexCoord2iv = NULL;
    319. 

  319. PFNGLMULTITEXCOORD2SPROC __glewMultiTexCoord2s = NULL;
    320. 

  320. PFNGLMULTITEXCOORD2SVPROC __glewMultiTexCoord2sv = NULL;
    321. 

  321. PFNGLMULTITEXCOORD3DPROC __glewMultiTexCoord3d = NULL;
    322. 

  322. PFNGLMULTITEXCOORD3DVPROC __glewMultiTexCoord3dv = NULL;
    323. 

  323. PFNGLMULTITEXCOORD3FPROC __glewMultiTexCoord3f = NULL;
    324. 

  324. PFNGLMULTITEXCOORD3FVPROC __glewMultiTexCoord3fv = NULL;
    325. 

  325. PFNGLMULTITEXCOORD3IPROC __glewMultiTexCoord3i = NULL;
    326. 

  326. PFNGLMULTITEXCOORD3IVPROC __glewMultiTexCoord3iv = NULL;
    327. 

  327. PFNGLMULTITEXCOORD3SPROC __glewMultiTexCoord3s = NULL;
    328. 

  328. PFNGLMULTITEXCOORD3SVPROC __glewMultiTexCoord3sv = NULL;
    329. 

  329. PFNGLMULTITEXCOORD4DPROC __glewMultiTexCoord4d = NULL;
    330. 

  330. PFNGLMULTITEXCOORD4DVPROC __glewMultiTexCoord4dv = NULL;
    331. 

  331. PFNGLMULTITEXCOORD4FPROC __glewMultiTexCoord4f = NULL;
    332. 

  332. PFNGLMULTITEXCOORD4FVPROC __glewMultiTexCoord4fv = NULL;
    333. 

  333. PFNGLMULTITEXCOORD4IPROC __glewMultiTexCoord4i = NULL;
    334. 

  334. PFNGLMULTITEXCOORD4IVPROC __glewMultiTexCoord4iv = NULL;
    335. 

  335. PFNGLMULTITEXCOORD4SPROC __glewMultiTexCoord4s = NULL;
    336. 

  336. PFNGLMULTITEXCOORD4SVPROC __glewMultiTexCoord4sv = NULL;
    337. 

  337. PFNGLSAMPLECOVERAGEPROC __glewSampleCoverage = NULL;
    338. 

  338. 

  339. PFNGLBLENDCOLORPROC __glewBlendColor = NULL;
    340. 

  340. PFNGLBLENDEQUATIONPROC __glewBlendEquation = NULL;
    341. 

  341. PFNGLBLENDFUNCSEPARATEPROC __glewBlendFuncSeparate = NULL;
    342. 

  342. PFNGLFOGCOORDPOINTERPROC __glewFogCoordPointer = NULL;
    343. 

  343. PFNGLFOGCOORDDPROC __glewFogCoordd = NULL;
    344. 

  344. PFNGLFOGCOORDDVPROC __glewFogCoorddv = NULL;
    345. 

  345. PFNGLFOGCOORDFPROC __glewFogCoordf = NULL;
    346. 

  346. PFNGLFOGCOORDFVPROC __glewFogCoordfv = NULL;
    347. 

  347. PFNGLMULTIDRAWARRAYSPROC __glewMultiDrawArrays = NULL;
    348. 

  348. PFNGLMULTIDRAWELEMENTSPROC __glewMultiDrawElements = NULL;
    349. 

  349. PFNGLPOINTPARAMETERFPROC __glewPointParameterf = NULL;
    350. 

  350. PFNGLPOINTPARAMETERFVPROC __glewPointParameterfv = NULL;
    351. 

  351. PFNGLPOINTPARAMETERIPROC __glewPointParameteri = NULL;
    352. 

  352. PFNGLPOINTPARAMETERIVPROC __glewPointParameteriv = NULL;
    353. 

  353. PFNGLSECONDARYCOLOR3BPROC __glewSecondaryColor3b = NULL;
    354. 

  354. PFNGLSECONDARYCOLOR3BVPROC __glewSecondaryColor3bv = NULL;
    355. 

  355. PFNGLSECONDARYCOLOR3DPROC __glewSecondaryColor3d = NULL;
    356. 

  356. PFNGLSECONDARYCOLOR3DVPROC __glewSecondaryColor3dv = NULL;
    357. 

  357. PFNGLSECONDARYCOLOR3FPROC __glewSecondaryColor3f = NULL;
    358. 

  358. PFNGLSECONDARYCOLOR3FVPROC __glewSecondaryColor3fv = NULL;
    359. 

  359. PFNGLSECONDARYCOLOR3IPROC __glewSecondaryColor3i = NULL;
    360. 

  360. PFNGLSECONDARYCOLOR3IVPROC __glewSecondaryColor3iv = NULL;
    361. 

  361. PFNGLSECONDARYCOLOR3SPROC __glewSecondaryColor3s = NULL;
    362. 

  362. PFNGLSECONDARYCOLOR3SVPROC __glewSecondaryColor3sv = NULL;
    363. 

  363. PFNGLSECONDARYCOLOR3UBPROC __glewSecondaryColor3ub = NULL;
    364. 

  364. PFNGLSECONDARYCOLOR3UBVPROC __glewSecondaryColor3ubv = NULL;
    365. 

  365. PFNGLSECONDARYCOLOR3UIPROC __glewSecondaryColor3ui = NULL;
    366. 

  366. PFNGLSECONDARYCOLOR3UIVPROC __glewSecondaryColor3uiv = NULL;
    367. 

  367. PFNGLSECONDARYCOLOR3USPROC __glewSecondaryColor3us = NULL;
    368. 

  368. PFNGLSECONDARYCOLOR3USVPROC __glewSecondaryColor3usv = NULL;
    369. 

  369. PFNGLSECONDARYCOLORPOINTERPROC __glewSecondaryColorPointer = NULL;
    370. 

  370. PFNGLWINDOWPOS2DPROC __glewWindowPos2d = NULL;
    371. 

  371. PFNGLWINDOWPOS2DVPROC __glewWindowPos2dv = NULL;
    372. 

  372. PFNGLWINDOWPOS2FPROC __glewWindowPos2f = NULL;
    373. 

  373. PFNGLWINDOWPOS2FVPROC __glewWindowPos2fv = NULL;
    374. 

  374. PFNGLWINDOWPOS2IPROC __glewWindowPos2i = NULL;
    375. 

  375. PFNGLWINDOWPOS2IVPROC __glewWindowPos2iv = NULL;
    376. 

  376. PFNGLWINDOWPOS2SPROC __glewWindowPos2s = NULL;
    377. 

  377. PFNGLWINDOWPOS2SVPROC __glewWindowPos2sv = NULL;
    378. 

  378. PFNGLWINDOWPOS3DPROC __glewWindowPos3d = NULL;
    379. 

  379. PFNGLWINDOWPOS3DVPROC __glewWindowPos3dv = NULL;
    380. 

  380. PFNGLWINDOWPOS3FPROC __glewWindowPos3f = NULL;
    381. 

  381. PFNGLWINDOWPOS3FVPROC __glewWindowPos3fv = NULL;
    382. 

  382. PFNGLWINDOWPOS3IPROC __glewWindowPos3i = NULL;
    383. 

  383. PFNGLWINDOWPOS3IVPROC __glewWindowPos3iv = NULL;
    384. 

  384. PFNGLWINDOWPOS3SPROC __glewWindowPos3s = NULL;
    385. 

  385. PFNGLWINDOWPOS3SVPROC __glewWindowPos3sv = NULL;
    386. 

  386. 

  387. PFNGLBEGINQUERYPROC __glewBeginQuery = NULL;
    388. 

  388. PFNGLBINDBUFFERPROC __glewBindBuffer = NULL;
    389. 

  389. PFNGLBUFFERDATAPROC __glewBufferData = NULL;
    390. 

  390. PFNGLBUFFERSUBDATAPROC __glewBufferSubData = NULL;
    391. 

  391. PFNGLDELETEBUFFERSPROC __glewDeleteBuffers = NULL;
    392. 

  392. PFNGLDELETEQUERIESPROC __glewDeleteQueries = NULL;
    393. 

  393. PFNGLENDQUERYPROC __glewEndQuery = NULL;
    394. 

  394. PFNGLGENBUFFERSPROC __glewGenBuffers = NULL;
    395. 

  395. PFNGLGENQUERIESPROC __glewGenQueries = NULL;
    396. 

  396. PFNGLGETBUFFERPARAMETERIVPROC __glewGetBufferParameteriv = NULL;
    397. 

  397. PFNGLGETBUFFERPOINTERVPROC __glewGetBufferPointerv = NULL;
    398. 

  398. PFNGLGETBUFFERSUBDATAPROC __glewGetBufferSubData = NULL;
    399. 

  399. PFNGLGETQUERYOBJECTIVPROC __glewGetQueryObjectiv = NULL;
    400. 

  400. PFNGLGETQUERYOBJECTUIVPROC __glewGetQueryObjectuiv = NULL;
    401. 

  401. PFNGLGETQUERYIVPROC __glewGetQueryiv = NULL;
    402. 

  402. PFNGLISBUFFERPROC __glewIsBuffer = NULL;
    403. 

  403. PFNGLISQUERYPROC __glewIsQuery = NULL;
    404. 

  404. PFNGLMAPBUFFERPROC __glewMapBuffer = NULL;
    405. 

  405. PFNGLUNMAPBUFFERPROC __glewUnmapBuffer = NULL;
    406. 

  406. 

  407. PFNGLATTACHSHADERPROC __glewAttachShader = NULL;
    408. 

  408. PFNGLBINDATTRIBLOCATIONPROC __glewBindAttribLocation = NULL;
    409. 

  409. PFNGLBLENDEQUATIONSEPARATEPROC __glewBlendEquationSeparate = NULL;
    410. 

  410. PFNGLCOMPILESHADERPROC __glewCompileShader = NULL;
    411. 

  411. PFNGLCREATEPROGRAMPROC __glewCreateProgram = NULL;
    412. 

  412. PFNGLCREATESHADERPROC __glewCreateShader = NULL;
    413. 

  413. PFNGLDELETEPROGRAMPROC __glewDeleteProgram = NULL;
    414. 

  414. PFNGLDELETESHADERPROC __glewDeleteShader = NULL;
    415. 

  415. PFNGLDETACHSHADERPROC __glewDetachShader = NULL;
    416. 

  416. PFNGLDISABLEVERTEXATTRIBARRAYPROC __glewDisableVertexAttribArray = NULL;
    417. 

  417. PFNGLDRAWBUFFERSPROC __glewDrawBuffers = NULL;
    418. 

  418. PFNGLENABLEVERTEXATTRIBARRAYPROC __glewEnableVertexAttribArray = NULL;
    419. 

  419. PFNGLGETACTIVEATTRIBPROC __glewGetActiveAttrib = NULL;
    420. 

  420. PFNGLGETACTIVEUNIFORMPROC __glewGetActiveUniform = NULL;
    421. 

  421. PFNGLGETATTACHEDSHADERSPROC __glewGetAttachedShaders = NULL;
    422. 

  422. PFNGLGETATTRIBLOCATIONPROC __glewGetAttribLocation = NULL;
    423. 

  423. PFNGLGETPROGRAMINFOLOGPROC __glewGetProgramInfoLog = NULL;
    424. 

  424. PFNGLGETPROGRAMIVPROC __glewGetProgramiv = NULL;
    425. 

  425. PFNGLGETSHADERINFOLOGPROC __glewGetShaderInfoLog = NULL;
    426. 

  426. PFNGLGETSHADERSOURCEPROC __glewGetShaderSource = NULL;
    427. 

  427. PFNGLGETSHADERIVPROC __glewGetShaderiv = NULL;
    428. 

  428. PFNGLGETUNIFORMLOCATIONPROC __glewGetUniformLocation = NULL;
    429. 

  429. PFNGLGETUNIFORMFVPROC __glewGetUniformfv = NULL;
    430. 

  430. PFNGLGETUNIFORMIVPROC __glewGetUniformiv = NULL;
    431. 

  431. PFNGLGETVERTEXATTRIBPOINTERVPROC __glewGetVertexAttribPointerv = NULL;
    432. 

  432. PFNGLGETVERTEXATTRIBDVPROC __glewGetVertexAttribdv = NULL;
    433. 

  433. PFNGLGETVERTEXATTRIBFVPROC __glewGetVertexAttribfv = NULL;
    434. 

  434. PFNGLGETVERTEXATTRIBIVPROC __glewGetVertexAttribiv = NULL;
    435. 

  435. PFNGLISPROGRAMPROC __glewIsProgram = NULL;
    436. 

  436. PFNGLISSHADERPROC __glewIsShader = NULL;
    437. 

  437. PFNGLLINKPROGRAMPROC __glewLinkProgram = NULL;
    438. 

  438. PFNGLSHADERSOURCEPROC __glewShaderSource = NULL;
    439. 

  439. PFNGLSTENCILFUNCSEPARATEPROC __glewStencilFuncSeparate = NULL;
    440. 

  440. PFNGLSTENCILMASKSEPARATEPROC __glewStencilMaskSeparate = NULL;
    441. 

  441. PFNGLSTENCILOPSEPARATEPROC __glewStencilOpSeparate = NULL;
    442. 

  442. PFNGLUNIFORM1FPROC __glewUniform1f = NULL;
    443. 

  443. PFNGLUNIFORM1FVPROC __glewUniform1fv = NULL;
    444. 

  444. PFNGLUNIFORM1IPROC __glewUniform1i = NULL;
    445. 

  445. PFNGLUNIFORM1IVPROC __glewUniform1iv = NULL;
    446. 

  446. PFNGLUNIFORM2FPROC __glewUniform2f = NULL;
    447. 

  447. PFNGLUNIFORM2FVPROC __glewUniform2fv = NULL;
    448. 

  448. PFNGLUNIFORM2IPROC __glewUniform2i = NULL;
    449. 

  449. PFNGLUNIFORM2IVPROC __glewUniform2iv = NULL;
    450. 

  450. PFNGLUNIFORM3FPROC __glewUniform3f = NULL;
    451. 

  451. PFNGLUNIFORM3FVPROC __glewUniform3fv = NULL;
    452. 

  452. PFNGLUNIFORM3IPROC __glewUniform3i = NULL;
    453. 

  453. PFNGLUNIFORM3IVPROC __glewUniform3iv = NULL;
    454. 

  454. PFNGLUNIFORM4FPROC __glewUniform4f = NULL;
    455. 

  455. PFNGLUNIFORM4FVPROC __glewUniform4fv = NULL;
    456. 

  456. PFNGLUNIFORM4IPROC __glewUniform4i = NULL;
    457. 

  457. PFNGLUNIFORM4IVPROC __glewUniform4iv = NULL;
    458. 

  458. PFNGLUNIFORMMATRIX2FVPROC __glewUniformMatrix2fv = NULL;
    459. 

  459. PFNGLUNIFORMMATRIX3FVPROC __glewUniformMatrix3fv = NULL;
    460. 

  460. PFNGLUNIFORMMATRIX4FVPROC __glewUniformMatrix4fv = NULL;
    461. 

  461. PFNGLUSEPROGRAMPROC __glewUseProgram = NULL;
    462. 

  462. PFNGLVALIDATEPROGRAMPROC __glewValidateProgram = NULL;
    463. 

  463. PFNGLVERTEXATTRIB1DPROC __glewVertexAttrib1d = NULL;
    464. 

  464. PFNGLVERTEXATTRIB1DVPROC __glewVertexAttrib1dv = NULL;
    465. 

  465. PFNGLVERTEXATTRIB1FPROC __glewVertexAttrib1f = NULL;
    466. 

  466. PFNGLVERTEXATTRIB1FVPROC __glewVertexAttrib1fv = NULL;
    467. 

  467. PFNGLVERTEXATTRIB1SPROC __glewVertexAttrib1s = NULL;
    468. 

  468. PFNGLVERTEXATTRIB1SVPROC __glewVertexAttrib1sv = NULL;
    469. 

  469. PFNGLVERTEXATTRIB2DPROC __glewVertexAttrib2d = NULL;
    470. 

  470. PFNGLVERTEXATTRIB2DVPROC __glewVertexAttrib2dv = NULL;
    471. 

  471. PFNGLVERTEXATTRIB2FPROC __glewVertexAttrib2f = NULL;
    472. 

  472. PFNGLVERTEXATTRIB2FVPROC __glewVertexAttrib2fv = NULL;
    473. 

  473. PFNGLVERTEXATTRIB2SPROC __glewVertexAttrib2s = NULL;
    474. 

  474. PFNGLVERTEXATTRIB2SVPROC __glewVertexAttrib2sv = NULL;
    475. 

  475. PFNGLVERTEXATTRIB3DPROC __glewVertexAttrib3d = NULL;
    476. 

  476. PFNGLVERTEXATTRIB3DVPROC __glewVertexAttrib3dv = NULL;
    477. 

  477. PFNGLVERTEXATTRIB3FPROC __glewVertexAttrib3f = NULL;
    478. 

  478. PFNGLVERTEXATTRIB3FVPROC __glewVertexAttrib3fv = NULL;
    479. 

  479. PFNGLVERTEXATTRIB3SPROC __glewVertexAttrib3s = NULL;
    480. 

  480. PFNGLVERTEXATTRIB3SVPROC __glewVertexAttrib3sv = NULL;
    481. 

  481. PFNGLVERTEXATTRIB4NBVPROC __glewVertexAttrib4Nbv = NULL;
    482. 

  482. PFNGLVERTEXATTRIB4NIVPROC __glewVertexAttrib4Niv = NULL;
    483. 

  483. PFNGLVERTEXATTRIB4NSVPROC __glewVertexAttrib4Nsv = NULL;
    484. 

  484. PFNGLVERTEXATTRIB4NUBPROC __glewVertexAttrib4Nub = NULL;
    485. 

  485. PFNGLVERTEXATTRIB4NUBVPROC __glewVertexAttrib4Nubv = NULL;
    486. 

  486. PFNGLVERTEXATTRIB4NUIVPROC __glewVertexAttrib4Nuiv = NULL;
    487. 

  487. PFNGLVERTEXATTRIB4NUSVPROC __glewVertexAttrib4Nusv = NULL;
    488. 

  488. PFNGLVERTEXATTRIB4BVPROC __glewVertexAttrib4bv = NULL;
    489. 

  489. PFNGLVERTEXATTRIB4DPROC __glewVertexAttrib4d = NULL;
    490. 

  490. PFNGLVERTEXATTRIB4DVPROC __glewVertexAttrib4dv = NULL;
    491. 

  491. PFNGLVERTEXATTRIB4FPROC __glewVertexAttrib4f = NULL;
    492. 

  492. PFNGLVERTEXATTRIB4FVPROC __glewVertexAttrib4fv = NULL;
    493. 

  493. PFNGLVERTEXATTRIB4IVPROC __glewVertexAttrib4iv = NULL;
    494. 

  494. PFNGLVERTEXATTRIB4SPROC __glewVertexAttrib4s = NULL;
    495. 

  495. PFNGLVERTEXATTRIB4SVPROC __glewVertexAttrib4sv = NULL;
    496. 

  496. PFNGLVERTEXATTRIB4UBVPROC __glewVertexAttrib4ubv = NULL;
    497. 

  497. PFNGLVERTEXATTRIB4UIVPROC __glewVertexAttrib4uiv = NULL;
    498. 

  498. PFNGLVERTEXATTRIB4USVPROC __glewVertexAttrib4usv = NULL;
    499. 

  499. PFNGLVERTEXATTRIBPOINTERPROC __glewVertexAttribPointer = NULL;
    500. 

  500. 

  501. PFNGLUNIFORMMATRIX2X3FVPROC __glewUniformMatrix2x3fv = NULL;
    502. 

  502. PFNGLUNIFORMMATRIX2X4FVPROC __glewUniformMatrix2x4fv = NULL;
    503. 

  503. PFNGLUNIFORMMATRIX3X2FVPROC __glewUniformMatrix3x2fv = NULL;
    504. 

  504. PFNGLUNIFORMMATRIX3X4FVPROC __glewUniformMatrix3x4fv = NULL;
    505. 

  505. PFNGLUNIFORMMATRIX4X2FVPROC __glewUniformMatrix4x2fv = NULL;
    506. 

  506. PFNGLUNIFORMMATRIX4X3FVPROC __glewUniformMatrix4x3fv = NULL;
    507. 

  507. 

  508. PFNGLBEGINCONDITIONALRENDERPROC __glewBeginConditionalRender = NULL;
    509. 

  509. PFNGLBEGINTRANSFORMFEEDBACKPROC __glewBeginTransformFeedback = NULL;
    510. 

  510. PFNGLBINDFRAGDATALOCATIONPROC __glewBindFragDataLocation = NULL;
    511. 

  511. PFNGLCLAMPCOLORPROC __glewClampColor = NULL;
    512. 

  512. PFNGLCLEARBUFFERFIPROC __glewClearBufferfi = NULL;
    513. 

  513. PFNGLCLEARBUFFERFVPROC __glewClearBufferfv = NULL;
    514. 

  514. PFNGLCLEARBUFFERIVPROC __glewClearBufferiv = NULL;
    515. 

  515. PFNGLCLEARBUFFERUIVPROC __glewClearBufferuiv = NULL;
    516. 

  516. PFNGLCOLORMASKIPROC __glewColorMaski = NULL;
    517. 

  517. PFNGLDISABLEIPROC __glewDisablei = NULL;
    518. 

  518. PFNGLENABLEIPROC __glewEnablei = NULL;
    519. 

  519. PFNGLENDCONDITIONALRENDERPROC __glewEndConditionalRender = NULL;
    520. 

  520. PFNGLENDTRANSFORMFEEDBACKPROC __glewEndTransformFeedback = NULL;
    521. 

  521. PFNGLGETBOOLEANI_VPROC __glewGetBooleani_v = NULL;
    522. 

  522. PFNGLGETFRAGDATALOCATIONPROC __glewGetFragDataLocation = NULL;
    523. 

  523. PFNGLGETSTRINGIPROC __glewGetStringi = NULL;
    524. 

  524. PFNGLGETTEXPARAMETERIIVPROC __glewGetTexParameterIiv = NULL;
    525. 

  525. PFNGLGETTEXPARAMETERIUIVPROC __glewGetTexParameterIuiv = NULL;
    526. 

  526. PFNGLGETTRANSFORMFEEDBACKVARYINGPROC __glewGetTransformFeedbackVarying = NULL;
    527. 

  527. PFNGLGETUNIFORMUIVPROC __glewGetUniformuiv = NULL;
    528. 

  528. PFNGLGETVERTEXATTRIBIIVPROC __glewGetVertexAttribIiv = NULL;
    529. 

  529. PFNGLGETVERTEXATTRIBIUIVPROC __glewGetVertexAttribIuiv = NULL;
    530. 

  530. PFNGLISENABLEDIPROC __glewIsEnabledi = NULL;
    531. 

  531. PFNGLTEXPARAMETERIIVPROC __glewTexParameterIiv = NULL;
    532. 

  532. PFNGLTEXPARAMETERIUIVPROC __glewTexParameterIuiv = NULL;
    533. 

  533. PFNGLTRANSFORMFEEDBACKVARYINGSPROC __glewTransformFeedbackVaryings = NULL;
    534. 

  534. PFNGLUNIFORM1UIPROC __glewUniform1ui = NULL;
    535. 

  535. PFNGLUNIFORM1UIVPROC __glewUniform1uiv = NULL;
    536. 

  536. PFNGLUNIFORM2UIPROC __glewUniform2ui = NULL;
    537. 

  537. PFNGLUNIFORM2UIVPROC __glewUniform2uiv = NULL;
    538. 

  538. PFNGLUNIFORM3UIPROC __glewUniform3ui = NULL;
    539. 

  539. PFNGLUNIFORM3UIVPROC __glewUniform3uiv = NULL;
    540. 

  540. PFNGLUNIFORM4UIPROC __glewUniform4ui = NULL;
    541. 

  541. PFNGLUNIFORM4UIVPROC __glewUniform4uiv = NULL;
    542. 

  542. PFNGLVERTEXATTRIBI1IPROC __glewVertexAttribI1i = NULL;
    543. 

  543. PFNGLVERTEXATTRIBI1IVPROC __glewVertexAttribI1iv = NULL;
    544. 

  544. PFNGLVERTEXATTRIBI1UIPROC __glewVertexAttribI1ui = NULL;
    545. 

  545. PFNGLVERTEXATTRIBI1UIVPROC __glewVertexAttribI1uiv = NULL;
    546. 

  546. PFNGLVERTEXATTRIBI2IPROC __glewVertexAttribI2i = NULL;
    547. 

  547. PFNGLVERTEXATTRIBI2IVPROC __glewVertexAttribI2iv = NULL;
    548. 

  548. PFNGLVERTEXATTRIBI2UIPROC __glewVertexAttribI2ui = NULL;
    549. 

  549. PFNGLVERTEXATTRIBI2UIVPROC __glewVertexAttribI2uiv = NULL;
    550. 

  550. PFNGLVERTEXATTRIBI3IPROC __glewVertexAttribI3i = NULL;
    551. 

  551. PFNGLVERTEXATTRIBI3IVPROC __glewVertexAttribI3iv = NULL;
    552. 

  552. PFNGLVERTEXATTRIBI3UIPROC __glewVertexAttribI3ui = NULL;
    553. 

  553. PFNGLVERTEXATTRIBI3UIVPROC __glewVertexAttribI3uiv = NULL;
    554. 

  554. PFNGLVERTEXATTRIBI4BVPROC __glewVertexAttribI4bv = NULL;
    555. 

  555. PFNGLVERTEXATTRIBI4IPROC __glewVertexAttribI4i = NULL;
    556. 

  556. PFNGLVERTEXATTRIBI4IVPROC __glewVertexAttribI4iv = NULL;
    557. 

  557. PFNGLVERTEXATTRIBI4SVPROC __glewVertexAttribI4sv = NULL;
    558. 

  558. PFNGLVERTEXATTRIBI4UBVPROC __glewVertexAttribI4ubv = NULL;
    559. 

  559. PFNGLVERTEXATTRIBI4UIPROC __glewVertexAttribI4ui = NULL;
    560. 

  560. PFNGLVERTEXATTRIBI4UIVPROC __glewVertexAttribI4uiv = NULL;
    561. 

  561. PFNGLVERTEXATTRIBI4USVPROC __glewVertexAttribI4usv = NULL;
    562. 

  562. PFNGLVERTEXATTRIBIPOINTERPROC __glewVertexAttribIPointer = NULL;
    563. 

  563. 

  564. PFNGLDRAWARRAYSINSTANCEDPROC __glewDrawArraysInstanced = NULL;
    565. 

  565. PFNGLDRAWELEMENTSINSTANCEDPROC __glewDrawElementsInstanced = NULL;
    566. 

  566. PFNGLPRIMITIVERESTARTINDEXPROC __glewPrimitiveRestartIndex = NULL;
    567. 

  567. PFNGLTEXBUFFERPROC __glewTexBuffer = NULL;
    568. 

  568. 

  569. PFNGLFRAMEBUFFERTEXTUREPROC __glewFramebufferTexture = NULL;
    570. 

  570. PFNGLGETBUFFERPARAMETERI64VPROC __glewGetBufferParameteri64v = NULL;
    571. 

  571. PFNGLGETINTEGER64I_VPROC __glewGetInteger64i_v = NULL;
    572. 

  572. 

  573. PFNGLVERTEXATTRIBDIVISORPROC __glewVertexAttribDivisor = NULL;
    574. 

  574. 

  575. PFNGLBLENDEQUATIONSEPARATEIPROC __glewBlendEquationSeparatei = NULL;
    576. 

  576. PFNGLBLENDEQUATIONIPROC __glewBlendEquationi = NULL;
    577. 

  577. PFNGLBLENDFUNCSEPARATEIPROC __glewBlendFuncSeparatei = NULL;
    578. 

  578. PFNGLBLENDFUNCIPROC __glewBlendFunci = NULL;
    579. 

  579. PFNGLMINSAMPLESHADINGPROC __glewMinSampleShading = NULL;
    580. 

  580. 

  581. PFNGLTBUFFERMASK3DFXPROC __glewTbufferMask3DFX = NULL;
    582. 

  582. 

  583. PFNGLDEBUGMESSAGECALLBACKAMDPROC __glewDebugMessageCallbackAMD = NULL;
    584. 

  584. PFNGLDEBUGMESSAGEENABLEAMDPROC __glewDebugMessageEnableAMD = NULL;
    585. 

  585. PFNGLDEBUGMESSAGEINSERTAMDPROC __glewDebugMessageInsertAMD = NULL;
    586. 

  586. PFNGLGETDEBUGMESSAGELOGAMDPROC __glewGetDebugMessageLogAMD = NULL;
    587. 

  587. 

  588. PFNGLBLENDEQUATIONINDEXEDAMDPROC __glewBlendEquationIndexedAMD = NULL;
    589. 

  589. PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC __glewBlendEquationSeparateIndexedAMD = NULL;
    590. 

  590. PFNGLBLENDFUNCINDEXEDAMDPROC __glewBlendFuncIndexedAMD = NULL;
    591. 

  591. PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC __glewBlendFuncSeparateIndexedAMD = NULL;
    592. 

  592. 

  593. PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC __glewMultiDrawArraysIndirectAMD = NULL;
    594. 

  594. PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC __glewMultiDrawElementsIndirectAMD = NULL;
    595. 

  595. 

  596. PFNGLDELETENAMESAMDPROC __glewDeleteNamesAMD = NULL;
    597. 

  597. PFNGLGENNAMESAMDPROC __glewGenNamesAMD = NULL;
    598. 

  598. PFNGLISNAMEAMDPROC __glewIsNameAMD = NULL;
    599. 

  599. 

  600. PFNGLBEGINPERFMONITORAMDPROC __glewBeginPerfMonitorAMD = NULL;
    601. 

  601. PFNGLDELETEPERFMONITORSAMDPROC __glewDeletePerfMonitorsAMD = NULL;
    602. 

  602. PFNGLENDPERFMONITORAMDPROC __glewEndPerfMonitorAMD = NULL;
    603. 

  603. PFNGLGENPERFMONITORSAMDPROC __glewGenPerfMonitorsAMD = NULL;
    604. 

  604. PFNGLGETPERFMONITORCOUNTERDATAAMDPROC __glewGetPerfMonitorCounterDataAMD = NULL;
    605. 

  605. PFNGLGETPERFMONITORCOUNTERINFOAMDPROC __glewGetPerfMonitorCounterInfoAMD = NULL;
    606. 

  606. PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC __glewGetPerfMonitorCounterStringAMD = NULL;
    607. 

  607. PFNGLGETPERFMONITORCOUNTERSAMDPROC __glewGetPerfMonitorCountersAMD = NULL;
    608. 

  608. PFNGLGETPERFMONITORGROUPSTRINGAMDPROC __glewGetPerfMonitorGroupStringAMD = NULL;
    609. 

  609. PFNGLGETPERFMONITORGROUPSAMDPROC __glewGetPerfMonitorGroupsAMD = NULL;
    610. 

  610. PFNGLSELECTPERFMONITORCOUNTERSAMDPROC __glewSelectPerfMonitorCountersAMD = NULL;
    611. 

  611. 

  612. PFNGLSETMULTISAMPLEFVAMDPROC __glewSetMultisamplefvAMD = NULL;
    613. 

  613. 

  614. PFNGLTESSELLATIONFACTORAMDPROC __glewTessellationFactorAMD = NULL;
    615. 

  615. PFNGLTESSELLATIONMODEAMDPROC __glewTessellationModeAMD = NULL;
    616. 

  616. 

  617. PFNGLDRAWELEMENTARRAYAPPLEPROC __glewDrawElementArrayAPPLE = NULL;
    618. 

  618. PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC __glewDrawRangeElementArrayAPPLE = NULL;
    619. 

  619. PFNGLELEMENTPOINTERAPPLEPROC __glewElementPointerAPPLE = NULL;
    620. 

  620. PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC __glewMultiDrawElementArrayAPPLE = NULL;
    621. 

  621. PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC __glewMultiDrawRangeElementArrayAPPLE = NULL;
    622. 

  622. 

  623. PFNGLDELETEFENCESAPPLEPROC __glewDeleteFencesAPPLE = NULL;
    624. 

  624. PFNGLFINISHFENCEAPPLEPROC __glewFinishFenceAPPLE = NULL;
    625. 

  625. PFNGLFINISHOBJECTAPPLEPROC __glewFinishObjectAPPLE = NULL;
    626. 

  626. PFNGLGENFENCESAPPLEPROC __glewGenFencesAPPLE = NULL;
    627. 

  627. PFNGLISFENCEAPPLEPROC __glewIsFenceAPPLE = NULL;
    628. 

  628. PFNGLSETFENCEAPPLEPROC __glewSetFenceAPPLE = NULL;
    629. 

  629. PFNGLTESTFENCEAPPLEPROC __glewTestFenceAPPLE = NULL;
    630. 

  630. PFNGLTESTOBJECTAPPLEPROC __glewTestObjectAPPLE = NULL;
    631. 

  631. 

  632. PFNGLBUFFERPARAMETERIAPPLEPROC __glewBufferParameteriAPPLE = NULL;
    633. 

  633. PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC __glewFlushMappedBufferRangeAPPLE = NULL;
    634. 

  634. 

  635. PFNGLGETOBJECTPARAMETERIVAPPLEPROC __glewGetObjectParameterivAPPLE = NULL;
    636. 

  636. PFNGLOBJECTPURGEABLEAPPLEPROC __glewObjectPurgeableAPPLE = NULL;
    637. 

  637. PFNGLOBJECTUNPURGEABLEAPPLEPROC __glewObjectUnpurgeableAPPLE = NULL;
    638. 

  638. 

  639. PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC __glewGetTexParameterPointervAPPLE = NULL;
    640. 

  640. PFNGLTEXTURERANGEAPPLEPROC __glewTextureRangeAPPLE = NULL;
    641. 

  641. 

  642. PFNGLBINDVERTEXARRAYAPPLEPROC __glewBindVertexArrayAPPLE = NULL;
    643. 

  643. PFNGLDELETEVERTEXARRAYSAPPLEPROC __glewDeleteVertexArraysAPPLE = NULL;
    644. 

  644. PFNGLGENVERTEXARRAYSAPPLEPROC __glewGenVertexArraysAPPLE = NULL;
    645. 

  645. PFNGLISVERTEXARRAYAPPLEPROC __glewIsVertexArrayAPPLE = NULL;
    646. 

  646. 

  647. PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC __glewFlushVertexArrayRangeAPPLE = NULL;
    648. 

  648. PFNGLVERTEXARRAYPARAMETERIAPPLEPROC __glewVertexArrayParameteriAPPLE = NULL;
    649. 

  649. PFNGLVERTEXARRAYRANGEAPPLEPROC __glewVertexArrayRangeAPPLE = NULL;
    650. 

  650. 

  651. PFNGLDISABLEVERTEXATTRIBAPPLEPROC __glewDisableVertexAttribAPPLE = NULL;
    652. 

  652. PFNGLENABLEVERTEXATTRIBAPPLEPROC __glewEnableVertexAttribAPPLE = NULL;
    653. 

  653. PFNGLISVERTEXATTRIBENABLEDAPPLEPROC __glewIsVertexAttribEnabledAPPLE = NULL;
    654. 

  654. PFNGLMAPVERTEXATTRIB1DAPPLEPROC __glewMapVertexAttrib1dAPPLE = NULL;
    655. 

  655. PFNGLMAPVERTEXATTRIB1FAPPLEPROC __glewMapVertexAttrib1fAPPLE = NULL;
    656. 

  656. PFNGLMAPVERTEXATTRIB2DAPPLEPROC __glewMapVertexAttrib2dAPPLE = NULL;
    657. 

  657. PFNGLMAPVERTEXATTRIB2FAPPLEPROC __glewMapVertexAttrib2fAPPLE = NULL;
    658. 

  658. 

  659. PFNGLCLEARDEPTHFPROC __glewClearDepthf = NULL;
    660. 

  660. PFNGLDEPTHRANGEFPROC __glewDepthRangef = NULL;
    661. 

  661. PFNGLGETSHADERPRECISIONFORMATPROC __glewGetShaderPrecisionFormat = NULL;
    662. 

  662. PFNGLRELEASESHADERCOMPILERPROC __glewReleaseShaderCompiler = NULL;
    663. 

  663. PFNGLSHADERBINARYPROC __glewShaderBinary = NULL;
    664. 

  664. 

  665. PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC __glewDrawArraysInstancedBaseInstance = NULL;
    666. 

  666. PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC __glewDrawElementsInstancedBaseInstance = NULL;
    667. 

  667. PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC __glewDrawElementsInstancedBaseVertexBaseInstance = NULL;
    668. 

  668. 

  669. PFNGLBINDFRAGDATALOCATIONINDEXEDPROC __glewBindFragDataLocationIndexed = NULL;
    670. 

  670. PFNGLGETFRAGDATAINDEXPROC __glewGetFragDataIndex = NULL;
    671. 

  671. 

  672. PFNGLCREATESYNCFROMCLEVENTARBPROC __glewCreateSyncFromCLeventARB = NULL;
    673. 

  673. 

  674. PFNGLCLAMPCOLORARBPROC __glewClampColorARB = NULL;
    675. 

  675. 

  676. PFNGLCOPYBUFFERSUBDATAPROC __glewCopyBufferSubData = NULL;
    677. 

  677. 

  678. PFNGLDEBUGMESSAGECALLBACKARBPROC __glewDebugMessageCallbackARB = NULL;
    679. 

  679. PFNGLDEBUGMESSAGECONTROLARBPROC __glewDebugMessageControlARB = NULL;
    680. 

  680. PFNGLDEBUGMESSAGEINSERTARBPROC __glewDebugMessageInsertARB = NULL;
    681. 

  681. PFNGLGETDEBUGMESSAGELOGARBPROC __glewGetDebugMessageLogARB = NULL;
    682. 

  682. 

  683. PFNGLDRAWBUFFERSARBPROC __glewDrawBuffersARB = NULL;
    684. 

  684. 

  685. PFNGLBLENDEQUATIONSEPARATEIARBPROC __glewBlendEquationSeparateiARB = NULL;
    686. 

  686. PFNGLBLENDEQUATIONIARBPROC __glewBlendEquationiARB = NULL;
    687. 

  687. PFNGLBLENDFUNCSEPARATEIARBPROC __glewBlendFuncSeparateiARB = NULL;
    688. 

  688. PFNGLBLENDFUNCIARBPROC __glewBlendFunciARB = NULL;
    689. 

  689. 

  690. PFNGLDRAWELEMENTSBASEVERTEXPROC __glewDrawElementsBaseVertex = NULL;
    691. 

  691. PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC __glewDrawElementsInstancedBaseVertex = NULL;
    692. 

  692. PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC __glewDrawRangeElementsBaseVertex = NULL;
    693. 

  693. PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC __glewMultiDrawElementsBaseVertex = NULL;
    694. 

  694. 

  695. PFNGLDRAWARRAYSINDIRECTPROC __glewDrawArraysIndirect = NULL;
    696. 

  696. PFNGLDRAWELEMENTSINDIRECTPROC __glewDrawElementsIndirect = NULL;
    697. 

  697. 

  698. PFNGLBINDFRAMEBUFFERPROC __glewBindFramebuffer = NULL;
    699. 

  699. PFNGLBINDRENDERBUFFERPROC __glewBindRenderbuffer = NULL;
    700. 

  700. PFNGLBLITFRAMEBUFFERPROC __glewBlitFramebuffer = NULL;
    701. 

  701. PFNGLCHECKFRAMEBUFFERSTATUSPROC __glewCheckFramebufferStatus = NULL;
    702. 

  702. PFNGLDELETEFRAMEBUFFERSPROC __glewDeleteFramebuffers = NULL;
    703. 

  703. PFNGLDELETERENDERBUFFERSPROC __glewDeleteRenderbuffers = NULL;
    704. 

  704. PFNGLFRAMEBUFFERRENDERBUFFERPROC __glewFramebufferRenderbuffer = NULL;
    705. 

  705. PFNGLFRAMEBUFFERTEXTURE1DPROC __glewFramebufferTexture1D = NULL;
    706. 

  706. PFNGLFRAMEBUFFERTEXTURE2DPROC __glewFramebufferTexture2D = NULL;
    707. 

  707. PFNGLFRAMEBUFFERTEXTURE3DPROC __glewFramebufferTexture3D = NULL;
    708. 

  708. PFNGLFRAMEBUFFERTEXTURELAYERPROC __glewFramebufferTextureLayer = NULL;
    709. 

  709. PFNGLGENFRAMEBUFFERSPROC __glewGenFramebuffers = NULL;
    710. 

  710. PFNGLGENRENDERBUFFERSPROC __glewGenRenderbuffers = NULL;
    711. 

  711. PFNGLGENERATEMIPMAPPROC __glewGenerateMipmap = NULL;
    712. 

  712. PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC __glewGetFramebufferAttachmentParameteriv = NULL;
    713. 

  713. PFNGLGETRENDERBUFFERPARAMETERIVPROC __glewGetRenderbufferParameteriv = NULL;
    714. 

  714. PFNGLISFRAMEBUFFERPROC __glewIsFramebuffer = NULL;
    715. 

  715. PFNGLISRENDERBUFFERPROC __glewIsRenderbuffer = NULL;
    716. 

  716. PFNGLRENDERBUFFERSTORAGEPROC __glewRenderbufferStorage = NULL;
    717. 

  717. PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC __glewRenderbufferStorageMultisample = NULL;
    718. 

  718. 

  719. PFNGLFRAMEBUFFERTEXTUREARBPROC __glewFramebufferTextureARB = NULL;
    720. 

  720. PFNGLFRAMEBUFFERTEXTUREFACEARBPROC __glewFramebufferTextureFaceARB = NULL;
    721. 

  721. PFNGLFRAMEBUFFERTEXTURELAYERARBPROC __glewFramebufferTextureLayerARB = NULL;
    722. 

  722. PFNGLPROGRAMPARAMETERIARBPROC __glewProgramParameteriARB = NULL;
    723. 

  723. 

  724. PFNGLGETPROGRAMBINARYPROC __glewGetProgramBinary = NULL;
    725. 

  725. PFNGLPROGRAMBINARYPROC __glewProgramBinary = NULL;
    726. 

  726. PFNGLPROGRAMPARAMETERIPROC __glewProgramParameteri = NULL;
    727. 

  727. 

  728. PFNGLGETUNIFORMDVPROC __glewGetUniformdv = NULL;
    729. 

  729. PFNGLPROGRAMUNIFORM1DEXTPROC __glewProgramUniform1dEXT = NULL;
    730. 

  730. PFNGLPROGRAMUNIFORM1DVEXTPROC __glewProgramUniform1dvEXT = NULL;
    731. 

  731. PFNGLPROGRAMUNIFORM2DEXTPROC __glewProgramUniform2dEXT = NULL;
    732. 

  732. PFNGLPROGRAMUNIFORM2DVEXTPROC __glewProgramUniform2dvEXT = NULL;
    733. 

  733. PFNGLPROGRAMUNIFORM3DEXTPROC __glewProgramUniform3dEXT = NULL;
    734. 

  734. PFNGLPROGRAMUNIFORM3DVEXTPROC __glewProgramUniform3dvEXT = NULL;
    735. 

  735. PFNGLPROGRAMUNIFORM4DEXTPROC __glewProgramUniform4dEXT = NULL;
    736. 

  736. PFNGLPROGRAMUNIFORM4DVEXTPROC __glewProgramUniform4dvEXT = NULL;
    737. 

  737. PFNGLPROGRAMUNIFORMMATRIX2DVEXTPROC __glewProgramUniformMatrix2dvEXT = NULL;
    738. 

  738. PFNGLPROGRAMUNIFORMMATRIX2X3DVEXTPROC __glewProgramUniformMatrix2x3dvEXT = NULL;
    739. 

  739. PFNGLPROGRAMUNIFORMMATRIX2X4DVEXTPROC __glewProgramUniformMatrix2x4dvEXT = NULL;
    740. 

  740. PFNGLPROGRAMUNIFORMMATRIX3DVEXTPROC __glewProgramUniformMatrix3dvEXT = NULL;
    741. 

  741. PFNGLPROGRAMUNIFORMMATRIX3X2DVEXTPROC __glewProgramUniformMatrix3x2dvEXT = NULL;
    742. 

  742. PFNGLPROGRAMUNIFORMMATRIX3X4DVEXTPROC __glewProgramUniformMatrix3x4dvEXT = NULL;
    743. 

  743. PFNGLPROGRAMUNIFORMMATRIX4DVEXTPROC __glewProgramUniformMatrix4dvEXT = NULL;
    744. 

  744. PFNGLPROGRAMUNIFORMMATRIX4X2DVEXTPROC __glewProgramUniformMatrix4x2dvEXT = NULL;
    745. 

  745. PFNGLPROGRAMUNIFORMMATRIX4X3DVEXTPROC __glewProgramUniformMatrix4x3dvEXT = NULL;
    746. 

  746. PFNGLUNIFORM1DPROC __glewUniform1d = NULL;
    747. 

  747. PFNGLUNIFORM1DVPROC __glewUniform1dv = NULL;
    748. 

  748. PFNGLUNIFORM2DPROC __glewUniform2d = NULL;
    749. 

  749. PFNGLUNIFORM2DVPROC __glewUniform2dv = NULL;
    750. 

  750. PFNGLUNIFORM3DPROC __glewUniform3d = NULL;
    751. 

  751. PFNGLUNIFORM3DVPROC __glewUniform3dv = NULL;
    752. 

  752. PFNGLUNIFORM4DPROC __glewUniform4d = NULL;
    753. 

  753. PFNGLUNIFORM4DVPROC __glewUniform4dv = NULL;
    754. 

  754. PFNGLUNIFORMMATRIX2DVPROC __glewUniformMatrix2dv = NULL;
    755. 

  755. PFNGLUNIFORMMATRIX2X3DVPROC __glewUniformMatrix2x3dv = NULL;
    756. 

  756. PFNGLUNIFORMMATRIX2X4DVPROC __glewUniformMatrix2x4dv = NULL;
    757. 

  757. PFNGLUNIFORMMATRIX3DVPROC __glewUniformMatrix3dv = NULL;
    758. 

  758. PFNGLUNIFORMMATRIX3X2DVPROC __glewUniformMatrix3x2dv = NULL;
    759. 

  759. PFNGLUNIFORMMATRIX3X4DVPROC __glewUniformMatrix3x4dv = NULL;
    760. 

  760. PFNGLUNIFORMMATRIX4DVPROC __glewUniformMatrix4dv = NULL;
    761. 

  761. PFNGLUNIFORMMATRIX4X2DVPROC __glewUniformMatrix4x2dv = NULL;
    762. 

  762. PFNGLUNIFORMMATRIX4X3DVPROC __glewUniformMatrix4x3dv = NULL;
    763. 

  763. 

  764. PFNGLCOLORSUBTABLEPROC __glewColorSubTable = NULL;
    765. 

  765. PFNGLCOLORTABLEPROC __glewColorTable = NULL;
    766. 

  766. PFNGLCOLORTABLEPARAMETERFVPROC __glewColorTableParameterfv = NULL;
    767. 

  767. PFNGLCOLORTABLEPARAMETERIVPROC __glewColorTableParameteriv = NULL;
    768. 

  768. PFNGLCONVOLUTIONFILTER1DPROC __glewConvolutionFilter1D = NULL;
    769. 

  769. PFNGLCONVOLUTIONFILTER2DPROC __glewConvolutionFilter2D = NULL;
    770. 

  770. PFNGLCONVOLUTIONPARAMETERFPROC __glewConvolutionParameterf = NULL;
    771. 

  771. PFNGLCONVOLUTIONPARAMETERFVPROC __glewConvolutionParameterfv = NULL;
    772. 

  772. PFNGLCONVOLUTIONPARAMETERIPROC __glewConvolutionParameteri = NULL;
    773. 

  773. PFNGLCONVOLUTIONPARAMETERIVPROC __glewConvolutionParameteriv = NULL;
    774. 

  774. PFNGLCOPYCOLORSUBTABLEPROC __glewCopyColorSubTable = NULL;
    775. 

  775. PFNGLCOPYCOLORTABLEPROC __glewCopyColorTable = NULL;
    776. 

  776. PFNGLCOPYCONVOLUTIONFILTER1DPROC __glewCopyConvolutionFilter1D = NULL;
    777. 

  777. PFNGLCOPYCONVOLUTIONFILTER2DPROC __glewCopyConvolutionFilter2D = NULL;
    778. 

  778. PFNGLGETCOLORTABLEPROC __glewGetColorTable = NULL;
    779. 

  779. PFNGLGETCOLORTABLEPARAMETERFVPROC __glewGetColorTableParameterfv = NULL;
    780. 

  780. PFNGLGETCOLORTABLEPARAMETERIVPROC __glewGetColorTableParameteriv = NULL;
    781. 

  781. PFNGLGETCONVOLUTIONFILTERPROC __glewGetConvolutionFilter = NULL;
    782. 

  782. PFNGLGETCONVOLUTIONPARAMETERFVPROC __glewGetConvolutionParameterfv = NULL;
    783. 

  783. PFNGLGETCONVOLUTIONPARAMETERIVPROC __glewGetConvolutionParameteriv = NULL;
    784. 

  784. PFNGLGETHISTOGRAMPROC __glewGetHistogram = NULL;
    785. 

  785. PFNGLGETHISTOGRAMPARAMETERFVPROC __glewGetHistogramParameterfv = NULL;
    786. 

  786. PFNGLGETHISTOGRAMPARAMETERIVPROC __glewGetHistogramParameteriv = NULL;
    787. 

  787. PFNGLGETMINMAXPROC __glewGetMinmax = NULL;
    788. 

  788. PFNGLGETMINMAXPARAMETERFVPROC __glewGetMinmaxParameterfv = NULL;
    789. 

  789. PFNGLGETMINMAXPARAMETERIVPROC __glewGetMinmaxParameteriv = NULL;
    790. 

  790. PFNGLGETSEPARABLEFILTERPROC __glewGetSeparableFilter = NULL;
    791. 

  791. PFNGLHISTOGRAMPROC __glewHistogram = NULL;
    792. 

  792. PFNGLMINMAXPROC __glewMinmax = NULL;
    793. 

  793. PFNGLRESETHISTOGRAMPROC __glewResetHistogram = NULL;
    794. 

  794. PFNGLRESETMINMAXPROC __glewResetMinmax = NULL;
    795. 

  795. PFNGLSEPARABLEFILTER2DPROC __glewSeparableFilter2D = NULL;
    796. 

  796. 

  797. PFNGLDRAWARRAYSINSTANCEDARBPROC __glewDrawArraysInstancedARB = NULL;
    798. 

  798. PFNGLDRAWELEMENTSINSTANCEDARBPROC __glewDrawElementsInstancedARB = NULL;
    799. 

  799. PFNGLVERTEXATTRIBDIVISORARBPROC __glewVertexAttribDivisorARB = NULL;
    800. 

  800. 

  801. PFNGLGETINTERNALFORMATIVPROC __glewGetInternalformativ = NULL;
    802. 

  802. 

  803. PFNGLFLUSHMAPPEDBUFFERRANGEPROC __glewFlushMappedBufferRange = NULL;
    804. 

  804. PFNGLMAPBUFFERRANGEPROC __glewMapBufferRange = NULL;
    805. 

  805. 

  806. PFNGLCURRENTPALETTEMATRIXARBPROC __glewCurrentPaletteMatrixARB = NULL;
    807. 

  807. PFNGLMATRIXINDEXPOINTERARBPROC __glewMatrixIndexPointerARB = NULL;
    808. 

  808. PFNGLMATRIXINDEXUBVARBPROC __glewMatrixIndexubvARB = NULL;
    809. 

  809. PFNGLMATRIXINDEXUIVARBPROC __glewMatrixIndexuivARB = NULL;
    810. 

  810. PFNGLMATRIXINDEXUSVARBPROC __glewMatrixIndexusvARB = NULL;
    811. 

  811. 

  812. PFNGLSAMPLECOVERAGEARBPROC __glewSampleCoverageARB = NULL;
    813. 

  813. 

  814. PFNGLACTIVETEXTUREARBPROC __glewActiveTextureARB = NULL;
    815. 

  815. PFNGLCLIENTACTIVETEXTUREARBPROC __glewClientActiveTextureARB = NULL;
    816. 

  816. PFNGLMULTITEXCOORD1DARBPROC __glewMultiTexCoord1dARB = NULL;
    817. 

  817. PFNGLMULTITEXCOORD1DVARBPROC __glewMultiTexCoord1dvARB = NULL;
    818. 

  818. PFNGLMULTITEXCOORD1FARBPROC __glewMultiTexCoord1fARB = NULL;
    819. 

  819. PFNGLMULTITEXCOORD1FVARBPROC __glewMultiTexCoord1fvARB = NULL;
    820. 

  820. PFNGLMULTITEXCOORD1IARBPROC __glewMultiTexCoord1iARB = NULL;
    821. 

  821. PFNGLMULTITEXCOORD1IVARBPROC __glewMultiTexCoord1ivARB = NULL;
    822. 

  822. PFNGLMULTITEXCOORD1SARBPROC __glewMultiTexCoord1sARB = NULL;
    823. 

  823. PFNGLMULTITEXCOORD1SVARBPROC __glewMultiTexCoord1svARB = NULL;
    824. 

  824. PFNGLMULTITEXCOORD2DARBPROC __glewMultiTexCoord2dARB = NULL;
    825. 

  825. PFNGLMULTITEXCOORD2DVARBPROC __glewMultiTexCoord2dvARB = NULL;
    826. 

  826. PFNGLMULTITEXCOORD2FARBPROC __glewMultiTexCoord2fARB = NULL;
    827. 

  827. PFNGLMULTITEXCOORD2FVARBPROC __glewMultiTexCoord2fvARB = NULL;
    828. 

  828. PFNGLMULTITEXCOORD2IARBPROC __glewMultiTexCoord2iARB = NULL;
    829. 

  829. PFNGLMULTITEXCOORD2IVARBPROC __glewMultiTexCoord2ivARB = NULL;
    830. 

  830. PFNGLMULTITEXCOORD2SARBPROC __glewMultiTexCoord2sARB = NULL;
    831. 

  831. PFNGLMULTITEXCOORD2SVARBPROC __glewMultiTexCoord2svARB = NULL;
    832. 

  832. PFNGLMULTITEXCOORD3DARBPROC __glewMultiTexCoord3dARB = NULL;
    833. 

  833. PFNGLMULTITEXCOORD3DVARBPROC __glewMultiTexCoord3dvARB = NULL;
    834. 

  834. PFNGLMULTITEXCOORD3FARBPROC __glewMultiTexCoord3fARB = NULL;
    835. 

  835. PFNGLMULTITEXCOORD3FVARBPROC __glewMultiTexCoord3fvARB = NULL;
    836. 

  836. PFNGLMULTITEXCOORD3IARBPROC __glewMultiTexCoord3iARB = NULL;
    837. 

  837. PFNGLMULTITEXCOORD3IVARBPROC __glewMultiTexCoord3ivARB = NULL;
    838. 

  838. PFNGLMULTITEXCOORD3SARBPROC __glewMultiTexCoord3sARB = NULL;
    839. 

  839. PFNGLMULTITEXCOORD3SVARBPROC __glewMultiTexCoord3svARB = NULL;
    840. 

  840. PFNGLMULTITEXCOORD4DARBPROC __glewMultiTexCoord4dARB = NULL;
    841. 

  841. PFNGLMULTITEXCOORD4DVARBPROC __glewMultiTexCoord4dvARB = NULL;
    842. 

  842. PFNGLMULTITEXCOORD4FARBPROC __glewMultiTexCoord4fARB = NULL;
    843. 

  843. PFNGLMULTITEXCOORD4FVARBPROC __glewMultiTexCoord4fvARB = NULL;
    844. 

  844. PFNGLMULTITEXCOORD4IARBPROC __glewMultiTexCoord4iARB = NULL;
    845. 

  845. PFNGLMULTITEXCOORD4IVARBPROC __glewMultiTexCoord4ivARB = NULL;
    846. 

  846. PFNGLMULTITEXCOORD4SARBPROC __glewMultiTexCoord4sARB = NULL;
    847. 

  847. PFNGLMULTITEXCOORD4SVARBPROC __glewMultiTexCoord4svARB = NULL;
    848. 

  848. 

  849. PFNGLBEGINQUERYARBPROC __glewBeginQueryARB = NULL;
    850. 

  850. PFNGLDELETEQUERIESARBPROC __glewDeleteQueriesARB = NULL;
    851. 

  851. PFNGLENDQUERYARBPROC __glewEndQueryARB = NULL;
    852. 

  852. PFNGLGENQUERIESARBPROC __glewGenQueriesARB = NULL;
    853. 

  853. PFNGLGETQUERYOBJECTIVARBPROC __glewGetQueryObjectivARB = NULL;
    854. 

  854. PFNGLGETQUERYOBJECTUIVARBPROC __glewGetQueryObjectuivARB = NULL;
    855. 

  855. PFNGLGETQUERYIVARBPROC __glewGetQueryivARB = NULL;
    856. 

  856. PFNGLISQUERYARBPROC __glewIsQueryARB = NULL;
    857. 

  857. 

  858. PFNGLPOINTPARAMETERFARBPROC __glewPointParameterfARB = NULL;
    859. 

  859. PFNGLPOINTPARAMETERFVARBPROC __glewPointParameterfvARB = NULL;
    860. 

  860. 

  861. PFNGLPROVOKINGVERTEXPROC __glewProvokingVertex = NULL;
    862. 

  862. 

  863. PFNGLGETGRAPHICSRESETSTATUSARBPROC __glewGetGraphicsResetStatusARB = NULL;
    864. 

  864. PFNGLGETNCOLORTABLEARBPROC __glewGetnColorTableARB = NULL;
    865. 

  865. PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC __glewGetnCompressedTexImageARB = NULL;
    866. 

  866. PFNGLGETNCONVOLUTIONFILTERARBPROC __glewGetnConvolutionFilterARB = NULL;
    867. 

  867. PFNGLGETNHISTOGRAMARBPROC __glewGetnHistogramARB = NULL;
    868. 

  868. PFNGLGETNMAPDVARBPROC __glewGetnMapdvARB = NULL;
    869. 

  869. PFNGLGETNMAPFVARBPROC __glewGetnMapfvARB = NULL;
    870. 

  870. PFNGLGETNMAPIVARBPROC __glewGetnMapivARB = NULL;
    871. 

  871. PFNGLGETNMINMAXARBPROC __glewGetnMinmaxARB = NULL;
    872. 

  872. PFNGLGETNPIXELMAPFVARBPROC __glewGetnPixelMapfvARB = NULL;
    873. 

  873. PFNGLGETNPIXELMAPUIVARBPROC __glewGetnPixelMapuivARB = NULL;
    874. 

  874. PFNGLGETNPIXELMAPUSVARBPROC __glewGetnPixelMapusvARB = NULL;
    875. 

  875. PFNGLGETNPOLYGONSTIPPLEARBPROC __glewGetnPolygonStippleARB = NULL;
    876. 

  876. PFNGLGETNSEPARABLEFILTERARBPROC __glewGetnSeparableFilterARB = NULL;
    877. 

  877. PFNGLGETNTEXIMAGEARBPROC __glewGetnTexImageARB = NULL;
    878. 

  878. PFNGLGETNUNIFORMDVARBPROC __glewGetnUniformdvARB = NULL;
    879. 

  879. PFNGLGETNUNIFORMFVARBPROC __glewGetnUniformfvARB = NULL;
    880. 

  880. PFNGLGETNUNIFORMIVARBPROC __glewGetnUniformivARB = NULL;
    881. 

  881. PFNGLGETNUNIFORMUIVARBPROC __glewGetnUniformuivARB = NULL;
    882. 

  882. PFNGLREADNPIXELSARBPROC __glewReadnPixelsARB = NULL;
    883. 

  883. 

  884. PFNGLMINSAMPLESHADINGARBPROC __glewMinSampleShadingARB = NULL;
    885. 

  885. 

  886. PFNGLBINDSAMPLERPROC __glewBindSampler = NULL;
    887. 

  887. PFNGLDELETESAMPLERSPROC __glewDeleteSamplers = NULL;
    888. 

  888. PFNGLGENSAMPLERSPROC __glewGenSamplers = NULL;
    889. 

  889. PFNGLGETSAMPLERPARAMETERIIVPROC __glewGetSamplerParameterIiv = NULL;
    890. 

  890. PFNGLGETSAMPLERPARAMETERIUIVPROC __glewGetSamplerParameterIuiv = NULL;
    891. 

  891. PFNGLGETSAMPLERPARAMETERFVPROC __glewGetSamplerParameterfv = NULL;
    892. 

  892. PFNGLGETSAMPLERPARAMETERIVPROC __glewGetSamplerParameteriv = NULL;
    893. 

  893. PFNGLISSAMPLERPROC __glewIsSampler = NULL;
    894. 

  894. PFNGLSAMPLERPARAMETERIIVPROC __glewSamplerParameterIiv = NULL;
    895. 

  895. PFNGLSAMPLERPARAMETERIUIVPROC __glewSamplerParameterIuiv = NULL;
    896. 

  896. PFNGLSAMPLERPARAMETERFPROC __glewSamplerParameterf = NULL;
    897. 

  897. PFNGLSAMPLERPARAMETERFVPROC __glewSamplerParameterfv = NULL;
    898. 

  898. PFNGLSAMPLERPARAMETERIPROC __glewSamplerParameteri = NULL;
    899. 

  899. PFNGLSAMPLERPARAMETERIVPROC __glewSamplerParameteriv = NULL;
    900. 

  900. 

  901. PFNGLACTIVESHADERPROGRAMPROC __glewActiveShaderProgram = NULL;
    902. 

  902. PFNGLBINDPROGRAMPIPELINEPROC __glewBindProgramPipeline = NULL;
    903. 

  903. PFNGLCREATESHADERPROGRAMVPROC __glewCreateShaderProgramv = NULL;
    904. 

  904. PFNGLDELETEPROGRAMPIPELINESPROC __glewDeleteProgramPipelines = NULL;
    905. 

  905. PFNGLGENPROGRAMPIPELINESPROC __glewGenProgramPipelines = NULL;
    906. 

  906. PFNGLGETPROGRAMPIPELINEINFOLOGPROC __glewGetProgramPipelineInfoLog = NULL;
    907. 

  907. PFNGLGETPROGRAMPIPELINEIVPROC __glewGetProgramPipelineiv = NULL;
    908. 

  908. PFNGLISPROGRAMPIPELINEPROC __glewIsProgramPipeline = NULL;
    909. 

  909. PFNGLPROGRAMUNIFORM1DPROC __glewProgramUniform1d = NULL;
    910. 

  910. PFNGLPROGRAMUNIFORM1DVPROC __glewProgramUniform1dv = NULL;
    911. 

  911. PFNGLPROGRAMUNIFORM1FPROC __glewProgramUniform1f = NULL;
    912. 

  912. PFNGLPROGRAMUNIFORM1FVPROC __glewProgramUniform1fv = NULL;
    913. 

  913. PFNGLPROGRAMUNIFORM1IPROC __glewProgramUniform1i = NULL;
    914. 

  914. PFNGLPROGRAMUNIFORM1IVPROC __glewProgramUniform1iv = NULL;
    915. 

  915. PFNGLPROGRAMUNIFORM1UIPROC __glewProgramUniform1ui = NULL;
    916. 

  916. PFNGLPROGRAMUNIFORM1UIVPROC __glewProgramUniform1uiv = NULL;
    917. 

  917. PFNGLPROGRAMUNIFORM2DPROC __glewProgramUniform2d = NULL;
    918. 

  918. PFNGLPROGRAMUNIFORM2DVPROC __glewProgramUniform2dv = NULL;
    919. 

  919. PFNGLPROGRAMUNIFORM2FPROC __glewProgramUniform2f = NULL;
    920. 

  920. PFNGLPROGRAMUNIFORM2FVPROC __glewProgramUniform2fv = NULL;
    921. 

  921. PFNGLPROGRAMUNIFORM2IPROC __glewProgramUniform2i = NULL;
    922. 

  922. PFNGLPROGRAMUNIFORM2IVPROC __glewProgramUniform2iv = NULL;
    923. 

  923. PFNGLPROGRAMUNIFORM2UIPROC __glewProgramUniform2ui = NULL;
    924. 

  924. PFNGLPROGRAMUNIFORM2UIVPROC __glewProgramUniform2uiv = NULL;
    925. 

  925. PFNGLPROGRAMUNIFORM3DPROC __glewProgramUniform3d = NULL;
    926. 

  926. PFNGLPROGRAMUNIFORM3DVPROC __glewProgramUniform3dv = NULL;
    927. 

  927. PFNGLPROGRAMUNIFORM3FPROC __glewProgramUniform3f = NULL;
    928. 

  928. PFNGLPROGRAMUNIFORM3FVPROC __glewProgramUniform3fv = NULL;
    929. 

  929. PFNGLPROGRAMUNIFORM3IPROC __glewProgramUniform3i = NULL;
    930. 

  930. PFNGLPROGRAMUNIFORM3IVPROC __glewProgramUniform3iv = NULL;
    931. 

  931. PFNGLPROGRAMUNIFORM3UIPROC __glewProgramUniform3ui = NULL;
    932. 

  932. PFNGLPROGRAMUNIFORM3UIVPROC __glewProgramUniform3uiv = NULL;
    933. 

  933. PFNGLPROGRAMUNIFORM4DPROC __glewProgramUniform4d = NULL;
    934. 

  934. PFNGLPROGRAMUNIFORM4DVPROC __glewProgramUniform4dv = NULL;
    935. 

  935. PFNGLPROGRAMUNIFORM4FPROC __glewProgramUniform4f = NULL;
    936. 

  936. PFNGLPROGRAMUNIFORM4FVPROC __glewProgramUniform4fv = NULL;
    937. 

  937. PFNGLPROGRAMUNIFORM4IPROC __glewProgramUniform4i = NULL;
    938. 

  938. PFNGLPROGRAMUNIFORM4IVPROC __glewProgramUniform4iv = NULL;
    939. 

  939. PFNGLPROGRAMUNIFORM4UIPROC __glewProgramUniform4ui = NULL;
    940. 

  940. PFNGLPROGRAMUNIFORM4UIVPROC __glewProgramUniform4uiv = NULL;
    941. 

  941. PFNGLPROGRAMUNIFORMMATRIX2DVPROC __glewProgramUniformMatrix2dv = NULL;
    942. 

  942. PFNGLPROGRAMUNIFORMMATRIX2FVPROC __glewProgramUniformMatrix2fv = NULL;
    943. 

  943. PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC __glewProgramUniformMatrix2x3dv = NULL;
    944. 

  944. PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC __glewProgramUniformMatrix2x3fv = NULL;
    945. 

  945. PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC __glewProgramUniformMatrix2x4dv = NULL;
    946. 

  946. PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC __glewProgramUniformMatrix2x4fv = NULL;
    947. 

  947. PFNGLPROGRAMUNIFORMMATRIX3DVPROC __glewProgramUniformMatrix3dv = NULL;
    948. 

  948. PFNGLPROGRAMUNIFORMMATRIX3FVPROC __glewProgramUniformMatrix3fv = NULL;
    949. 

  949. PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC __glewProgramUniformMatrix3x2dv = NULL;
    950. 

  950. PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC __glewProgramUniformMatrix3x2fv = NULL;
    951. 

  951. PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC __glewProgramUniformMatrix3x4dv = NULL;
    952. 

  952. PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC __glewProgramUniformMatrix3x4fv = NULL;
    953. 

  953. PFNGLPROGRAMUNIFORMMATRIX4DVPROC __glewProgramUniformMatrix4dv = NULL;
    954. 

  954. PFNGLPROGRAMUNIFORMMATRIX4FVPROC __glewProgramUniformMatrix4fv = NULL;
    955. 

  955. PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC __glewProgramUniformMatrix4x2dv = NULL;
    956. 

  956. PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC __glewProgramUniformMatrix4x2fv = NULL;
    957. 

  957. PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC __glewProgramUniformMatrix4x3dv = NULL;
    958. 

  958. PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC __glewProgramUniformMatrix4x3fv = NULL;
    959. 

  959. PFNGLUSEPROGRAMSTAGESPROC __glewUseProgramStages = NULL;
    960. 

  960. PFNGLVALIDATEPROGRAMPIPELINEPROC __glewValidateProgramPipeline = NULL;
    961. 

  961. 

  962. PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC __glewGetActiveAtomicCounterBufferiv = NULL;
    963. 

  963. 

  964. PFNGLBINDIMAGETEXTUREPROC __glewBindImageTexture = NULL;
    965. 

  965. PFNGLMEMORYBARRIERPROC __glewMemoryBarrier = NULL;
    966. 

  966. 

  967. PFNGLATTACHOBJECTARBPROC __glewAttachObjectARB = NULL;
    968. 

  968. PFNGLCOMPILESHADERARBPROC __glewCompileShaderARB = NULL;
    969. 

  969. PFNGLCREATEPROGRAMOBJECTARBPROC __glewCreateProgramObjectARB = NULL;
    970. 

  970. PFNGLCREATESHADEROBJECTARBPROC __glewCreateShaderObjectARB = NULL;
    971. 

  971. PFNGLDELETEOBJECTARBPROC __glewDeleteObjectARB = NULL;
    972. 

  972. PFNGLDETACHOBJECTARBPROC __glewDetachObjectARB = NULL;
    973. 

  973. PFNGLGETACTIVEUNIFORMARBPROC __glewGetActiveUniformARB = NULL;
    974. 

  974. PFNGLGETATTACHEDOBJECTSARBPROC __glewGetAttachedObjectsARB = NULL;
    975. 

  975. PFNGLGETHANDLEARBPROC __glewGetHandleARB = NULL;
    976. 

  976. PFNGLGETINFOLOGARBPROC __glewGetInfoLogARB = NULL;
    977. 

  977. PFNGLGETOBJECTPARAMETERFVARBPROC __glewGetObjectParameterfvARB = NULL;
    978. 

  978. PFNGLGETOBJECTPARAMETERIVARBPROC __glewGetObjectParameterivARB = NULL;
    979. 

  979. PFNGLGETSHADERSOURCEARBPROC __glewGetShaderSourceARB = NULL;
    980. 

  980. PFNGLGETUNIFORMLOCATIONARBPROC __glewGetUniformLocationARB = NULL;
    981. 

  981. PFNGLGETUNIFORMFVARBPROC __glewGetUniformfvARB = NULL;
    982. 

  982. PFNGLGETUNIFORMIVARBPROC __glewGetUniformivARB = NULL;
    983. 

  983. PFNGLLINKPROGRAMARBPROC __glewLinkProgramARB = NULL;
    984. 

  984. PFNGLSHADERSOURCEARBPROC __glewShaderSourceARB = NULL;
    985. 

  985. PFNGLUNIFORM1FARBPROC __glewUniform1fARB = NULL;
    986. 

  986. PFNGLUNIFORM1FVARBPROC __glewUniform1fvARB = NULL;
    987. 

  987. PFNGLUNIFORM1IARBPROC __glewUniform1iARB = NULL;
    988. 

  988. PFNGLUNIFORM1IVARBPROC __glewUniform1ivARB = NULL;
    989. 

  989. PFNGLUNIFORM2FARBPROC __glewUniform2fARB = NULL;
    990. 

  990. PFNGLUNIFORM2FVARBPROC __glewUniform2fvARB = NULL;
    991. 

  991. PFNGLUNIFORM2IARBPROC __glewUniform2iARB = NULL;
    992. 

  992. PFNGLUNIFORM2IVARBPROC __glewUniform2ivARB = NULL;
    993. 

  993. PFNGLUNIFORM3FARBPROC __glewUniform3fARB = NULL;
    994. 

  994. PFNGLUNIFORM3FVARBPROC __glewUniform3fvARB = NULL;
    995. 

  995. PFNGLUNIFORM3IARBPROC __glewUniform3iARB = NULL;
    996. 

  996. PFNGLUNIFORM3IVARBPROC __glewUniform3ivARB = NULL;
    997. 

  997. PFNGLUNIFORM4FARBPROC __glewUniform4fARB = NULL;
    998. 

  998. PFNGLUNIFORM4FVARBPROC __glewUniform4fvARB = NULL;
    999. 

  999. PFNGLUNIFORM4IARBPROC __glewUniform4iARB = NULL;
    1000. 

  1000. PFNGLUNIFORM4IVARBPROC __glewUniform4ivARB = NULL;
    1001. 

  1001. PFNGLUNIFORMMATRIX2FVARBPROC __glewUniformMatrix2fvARB = NULL;
    1002. 

  1002. PFNGLUNIFORMMATRIX3FVARBPROC __glewUniformMatrix3fvARB = NULL;
    1003. 

  1003. PFNGLUNIFORMMATRIX4FVARBPROC __glewUniformMatrix4fvARB = NULL;
    1004. 

  1004. PFNGLUSEPROGRAMOBJECTARBPROC __glewUseProgramObjectARB = NULL;
    1005. 

  1005. PFNGLVALIDATEPROGRAMARBPROC __glewValidateProgramARB = NULL;
    1006. 

  1006. 

  1007. PFNGLGETACTIVESUBROUTINENAMEPROC __glewGetActiveSubroutineName = NULL;
    1008. 

  1008. PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC __glewGetActiveSubroutineUniformName = NULL;
    1009. 

  1009. PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC __glewGetActiveSubroutineUniformiv = NULL;
    1010. 

  1010. PFNGLGETPROGRAMSTAGEIVPROC __glewGetProgramStageiv = NULL;
    1011. 

  1011. PFNGLGETSUBROUTINEINDEXPROC __glewGetSubroutineIndex = NULL;
    1012. 

  1012. PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC __glewGetSubroutineUniformLocation = NULL;
    1013. 

  1013. PFNGLGETUNIFORMSUBROUTINEUIVPROC __glewGetUniformSubroutineuiv = NULL;
    1014. 

  1014. PFNGLUNIFORMSUBROUTINESUIVPROC __glewUniformSubroutinesuiv = NULL;
    1015. 

  1015. 

  1016. PFNGLCOMPILESHADERINCLUDEARBPROC __glewCompileShaderIncludeARB = NULL;
    1017. 

  1017. PFNGLDELETENAMEDSTRINGARBPROC __glewDeleteNamedStringARB = NULL;
    1018. 

  1018. PFNGLGETNAMEDSTRINGARBPROC __glewGetNamedStringARB = NULL;
    1019. 

  1019. PFNGLGETNAMEDSTRINGIVARBPROC __glewGetNamedStringivARB = NULL;
    1020. 

  1020. PFNGLISNAMEDSTRINGARBPROC __glewIsNamedStringARB = NULL;
    1021. 

  1021. PFNGLNAMEDSTRINGARBPROC __glewNamedStringARB = NULL;
    1022. 

  1022. 

  1023. PFNGLCLIENTWAITSYNCPROC __glewClientWaitSync = NULL;
    1024. 

  1024. PFNGLDELETESYNCPROC __glewDeleteSync = NULL;
    1025. 

  1025. PFNGLFENCESYNCPROC __glewFenceSync = NULL;
    1026. 

  1026. PFNGLGETINTEGER64VPROC __glewGetInteger64v = NULL;
    1027. 

  1027. PFNGLGETSYNCIVPROC __glewGetSynciv = NULL;
    1028. 

  1028. PFNGLISSYNCPROC __glewIsSync = NULL;
    1029. 

  1029. PFNGLWAITSYNCPROC __glewWaitSync = NULL;
    1030. 

  1030. 

  1031. PFNGLPATCHPARAMETERFVPROC __glewPatchParameterfv = NULL;
    1032. 

  1032. PFNGLPATCHPARAMETERIPROC __glewPatchParameteri = NULL;
    1033. 

  1033. 

  1034. PFNGLTEXBUFFERARBPROC __glewTexBufferARB = NULL;
    1035. 

  1035. 

  1036. PFNGLCOMPRESSEDTEXIMAGE1DARBPROC __glewCompressedTexImage1DARB = NULL;
    1037. 

  1037. PFNGLCOMPRESSEDTEXIMAGE2DARBPROC __glewCompressedTexImage2DARB = NULL;
    1038. 

  1038. PFNGLCOMPRESSEDTEXIMAGE3DARBPROC __glewCompressedTexImage3DARB = NULL;
    1039. 

  1039. PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC __glewCompressedTexSubImage1DARB = NULL;
    1040. 

  1040. PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC __glewCompressedTexSubImage2DARB = NULL;
    1041. 

  1041. PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC __glewCompressedTexSubImage3DARB = NULL;
    1042. 

  1042. PFNGLGETCOMPRESSEDTEXIMAGEARBPROC __glewGetCompressedTexImageARB = NULL;
    1043. 

  1043. 

  1044. PFNGLGETMULTISAMPLEFVPROC __glewGetMultisamplefv = NULL;
    1045. 

  1045. PFNGLSAMPLEMASKIPROC __glewSampleMaski = NULL;
    1046. 

  1046. PFNGLTEXIMAGE2DMULTISAMPLEPROC __glewTexImage2DMultisample = NULL;
    1047. 

  1047. PFNGLTEXIMAGE3DMULTISAMPLEPROC __glewTexImage3DMultisample = NULL;
    1048. 

  1048. 

  1049. PFNGLTEXSTORAGE1DPROC __glewTexStorage1D = NULL;
    1050. 

  1050. PFNGLTEXSTORAGE2DPROC __glewTexStorage2D = NULL;
    1051. 

  1051. PFNGLTEXSTORAGE3DPROC __glewTexStorage3D = NULL;
    1052. 

  1052. PFNGLTEXTURESTORAGE1DEXTPROC __glewTextureStorage1DEXT = NULL;
    1053. 

  1053. PFNGLTEXTURESTORAGE2DEXTPROC __glewTextureStorage2DEXT = NULL;
    1054. 

  1054. PFNGLTEXTURESTORAGE3DEXTPROC __glewTextureStorage3DEXT = NULL;
    1055. 

  1055. 

  1056. PFNGLGETQUERYOBJECTI64VPROC __glewGetQueryObjecti64v = NULL;
    1057. 

  1057. PFNGLGETQUERYOBJECTUI64VPROC __glewGetQueryObjectui64v = NULL;
    1058. 

  1058. PFNGLQUERYCOUNTERPROC __glewQueryCounter = NULL;
    1059. 

  1059. 

  1060. PFNGLBINDTRANSFORMFEEDBACKPROC __glewBindTransformFeedback = NULL;
    1061. 

  1061. PFNGLDELETETRANSFORMFEEDBACKSPROC __glewDeleteTransformFeedbacks = NULL;
    1062. 

  1062. PFNGLDRAWTRANSFORMFEEDBACKPROC __glewDrawTransformFeedback = NULL;
    1063. 

  1063. PFNGLGENTRANSFORMFEEDBACKSPROC __glewGenTransformFeedbacks = NULL;
    1064. 

  1064. PFNGLISTRANSFORMFEEDBACKPROC __glewIsTransformFeedback = NULL;
    1065. 

  1065. PFNGLPAUSETRANSFORMFEEDBACKPROC __glewPauseTransformFeedback = NULL;
    1066. 

  1066. PFNGLRESUMETRANSFORMFEEDBACKPROC __glewResumeTransformFeedback = NULL;
    1067. 

  1067. 

  1068. PFNGLBEGINQUERYINDEXEDPROC __glewBeginQueryIndexed = NULL;
    1069. 

  1069. PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC __glewDrawTransformFeedbackStream = NULL;
    1070. 

  1070. PFNGLENDQUERYINDEXEDPROC __glewEndQueryIndexed = NULL;
    1071. 

  1071. PFNGLGETQUERYINDEXEDIVPROC __glewGetQueryIndexediv = NULL;
    1072. 

  1072. 

  1073. PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC __glewDrawTransformFeedbackInstanced = NULL;
    1074. 

  1074. PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC __glewDrawTransformFeedbackStreamInstanced = NULL;
    1075. 

  1075. 

  1076. PFNGLLOADTRANSPOSEMATRIXDARBPROC __glewLoadTransposeMatrixdARB = NULL;
    1077. 

  1077. PFNGLLOADTRANSPOSEMATRIXFARBPROC __glewLoadTransposeMatrixfARB = NULL;
    1078. 

  1078. PFNGLMULTTRANSPOSEMATRIXDARBPROC __glewMultTransposeMatrixdARB = NULL;
    1079. 

  1079. PFNGLMULTTRANSPOSEMATRIXFARBPROC __glewMultTransposeMatrixfARB = NULL;
    1080. 

  1080. 

  1081. PFNGLBINDBUFFERBASEPROC __glewBindBufferBase = NULL;
    1082. 

  1082. PFNGLBINDBUFFERRANGEPROC __glewBindBufferRange = NULL;
    1083. 

  1083. PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC __glewGetActiveUniformBlockName = NULL;
    1084. 

  1084. PFNGLGETACTIVEUNIFORMBLOCKIVPROC __glewGetActiveUniformBlockiv = NULL;
    1085. 

  1085. PFNGLGETACTIVEUNIFORMNAMEPROC __glewGetActiveUniformName = NULL;
    1086. 

  1086. PFNGLGETACTIVEUNIFORMSIVPROC __glewGetActiveUniformsiv = NULL;
    1087. 

  1087. PFNGLGETINTEGERI_VPROC __glewGetIntegeri_v = NULL;
    1088. 

  1088. PFNGLGETUNIFORMBLOCKINDEXPROC __glewGetUniformBlockIndex = NULL;
    1089. 

  1089. PFNGLGETUNIFORMINDICESPROC __glewGetUniformIndices = NULL;
    1090. 

  1090. PFNGLUNIFORMBLOCKBINDINGPROC __glewUniformBlockBinding = NULL;
    1091. 

  1091. 

  1092. PFNGLBINDVERTEXARRAYPROC __glewBindVertexArray = NULL;
    1093. 

  1093. PFNGLDELETEVERTEXARRAYSPROC __glewDeleteVertexArrays = NULL;
    1094. 

  1094. PFNGLGENVERTEXARRAYSPROC __glewGenVertexArrays = NULL;
    1095. 

  1095. PFNGLISVERTEXARRAYPROC __glewIsVertexArray = NULL;
    1096. 

  1096. 

  1097. PFNGLGETVERTEXATTRIBLDVPROC __glewGetVertexAttribLdv = NULL;
    1098. 

  1098. PFNGLVERTEXATTRIBL1DPROC __glewVertexAttribL1d = NULL;
    1099. 

  1099. PFNGLVERTEXATTRIBL1DVPROC __glewVertexAttribL1dv = NULL;
    1100. 

  1100. PFNGLVERTEXATTRIBL2DPROC __glewVertexAttribL2d = NULL;
    1101. 

  1101. PFNGLVERTEXATTRIBL2DVPROC __glewVertexAttribL2dv = NULL;
    1102. 

  1102. PFNGLVERTEXATTRIBL3DPROC __glewVertexAttribL3d = NULL;
    1103. 

  1103. PFNGLVERTEXATTRIBL3DVPROC __glewVertexAttribL3dv = NULL;
    1104. 

  1104. PFNGLVERTEXATTRIBL4DPROC __glewVertexAttribL4d = NULL;
    1105. 

  1105. PFNGLVERTEXATTRIBL4DVPROC __glewVertexAttribL4dv = NULL;
    1106. 

  1106. PFNGLVERTEXATTRIBLPOINTERPROC __glewVertexAttribLPointer = NULL;
    1107. 

  1107. 

  1108. PFNGLVERTEXBLENDARBPROC __glewVertexBlendARB = NULL;
    1109. 

  1109. PFNGLWEIGHTPOINTERARBPROC __glewWeightPointerARB = NULL;
    1110. 

  1110. PFNGLWEIGHTBVARBPROC __glewWeightbvARB = NULL;
    1111. 

  1111. PFNGLWEIGHTDVARBPROC __glewWeightdvARB = NULL;
    1112. 

  1112. PFNGLWEIGHTFVARBPROC __glewWeightfvARB = NULL;
    1113. 

  1113. PFNGLWEIGHTIVARBPROC __glewWeightivARB = NULL;
    1114. 

  1114. PFNGLWEIGHTSVARBPROC __glewWeightsvARB = NULL;
    1115. 

  1115. PFNGLWEIGHTUBVARBPROC __glewWeightubvARB = NULL;
    1116. 

  1116. PFNGLWEIGHTUIVARBPROC __glewWeightuivARB = NULL;
    1117. 

  1117. PFNGLWEIGHTUSVARBPROC __glewWeightusvARB = NULL;
    1118. 

  1118. 

  1119. PFNGLBINDBUFFERARBPROC __glewBindBufferARB = NULL;
    1120. 

  1120. PFNGLBUFFERDATAARBPROC __glewBufferDataARB = NULL;
    1121. 

  1121. PFNGLBUFFERSUBDATAARBPROC __glewBufferSubDataARB = NULL;
    1122. 

  1122. PFNGLDELETEBUFFERSARBPROC __glewDeleteBuffersARB = NULL;
    1123. 

  1123. PFNGLGENBUFFERSARBPROC __glewGenBuffersARB = NULL;
    1124. 

  1124. PFNGLGETBUFFERPARAMETERIVARBPROC __glewGetBufferParameterivARB = NULL;
    1125. 

  1125. PFNGLGETBUFFERPOINTERVARBPROC __glewGetBufferPointervARB = NULL;
    1126. 

  1126. PFNGLGETBUFFERSUBDATAARBPROC __glewGetBufferSubDataARB = NULL;
    1127. 

  1127. PFNGLISBUFFERARBPROC __glewIsBufferARB = NULL;
    1128. 

  1128. PFNGLMAPBUFFERARBPROC __glewMapBufferARB = NULL;
    1129. 

  1129. PFNGLUNMAPBUFFERARBPROC __glewUnmapBufferARB = NULL;
    1130. 

  1130. 

  1131. PFNGLBINDPROGRAMARBPROC __glewBindProgramARB = NULL;
    1132. 

  1132. PFNGLDELETEPROGRAMSARBPROC __glewDeleteProgramsARB = NULL;
    1133. 

  1133. PFNGLDISABLEVERTEXATTRIBARRAYARBPROC __glewDisableVertexAttribArrayARB = NULL;
    1134. 

  1134. PFNGLENABLEVERTEXATTRIBARRAYARBPROC __glewEnableVertexAttribArrayARB = NULL;
    1135. 

  1135. PFNGLGENPROGRAMSARBPROC __glewGenProgramsARB = NULL;
    1136. 

  1136. PFNGLGETPROGRAMENVPARAMETERDVARBPROC __glewGetProgramEnvParameterdvARB = NULL;
    1137. 

  1137. PFNGLGETPROGRAMENVPARAMETERFVARBPROC __glewGetProgramEnvParameterfvARB = NULL;
    1138. 

  1138. PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC __glewGetProgramLocalParameterdvARB = NULL;
    1139. 

  1139. PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC __glewGetProgramLocalParameterfvARB = NULL;
    1140. 

  1140. PFNGLGETPROGRAMSTRINGARBPROC __glewGetProgramStringARB = NULL;
    1141. 

  1141. PFNGLGETPROGRAMIVARBPROC __glewGetProgramivARB = NULL;
    1142. 

  1142. PFNGLGETVERTEXATTRIBPOINTERVARBPROC __glewGetVertexAttribPointervARB = NULL;
    1143. 

  1143. PFNGLGETVERTEXATTRIBDVARBPROC __glewGetVertexAttribdvARB = NULL;
    1144. 

  1144. PFNGLGETVERTEXATTRIBFVARBPROC __glewGetVertexAttribfvARB = NULL;
    1145. 

  1145. PFNGLGETVERTEXATTRIBIVARBPROC __glewGetVertexAttribivARB = NULL;
    1146. 

  1146. PFNGLISPROGRAMARBPROC __glewIsProgramARB = NULL;
    1147. 

  1147. PFNGLPROGRAMENVPARAMETER4DARBPROC __glewProgramEnvParameter4dARB = NULL;
    1148. 

  1148. PFNGLPROGRAMENVPARAMETER4DVARBPROC __glewProgramEnvParameter4dvARB = NULL;
    1149. 

  1149. PFNGLPROGRAMENVPARAMETER4FARBPROC __glewProgramEnvParameter4fARB = NULL;
    1150. 

  1150. PFNGLPROGRAMENVPARAMETER4FVARBPROC __glewProgramEnvParameter4fvARB = NULL;
    1151. 

  1151. PFNGLPROGRAMLOCALPARAMETER4DARBPROC __glewProgramLocalParameter4dARB = NULL;
    1152. 

  1152. PFNGLPROGRAMLOCALPARAMETER4DVARBPROC __glewProgramLocalParameter4dvARB = NULL;
    1153. 

  1153. PFNGLPROGRAMLOCALPARAMETER4FARBPROC __glewProgramLocalParameter4fARB = NULL;
    1154. 

  1154. PFNGLPROGRAMLOCALPARAMETER4FVARBPROC __glewProgramLocalParameter4fvARB = NULL;
    1155. 

  1155. PFNGLPROGRAMSTRINGARBPROC __glewProgramStringARB = NULL;
    1156. 

  1156. PFNGLVERTEXATTRIB1DARBPROC __glewVertexAttrib1dARB = NULL;
    1157. 

  1157. PFNGLVERTEXATTRIB1DVARBPROC __glewVertexAttrib1dvARB = NULL;
    1158. 

  1158. PFNGLVERTEXATTRIB1FARBPROC __glewVertexAttrib1fARB = NULL;
    1159. 

  1159. PFNGLVERTEXATTRIB1FVARBPROC __glewVertexAttrib1fvARB = NULL;
    1160. 

  1160. PFNGLVERTEXATTRIB1SARBPROC __glewVertexAttrib1sARB = NULL;
    1161. 

  1161. PFNGLVERTEXATTRIB1SVARBPROC __glewVertexAttrib1svARB = NULL;
    1162. 

  1162. PFNGLVERTEXATTRIB2DARBPROC __glewVertexAttrib2dARB = NULL;
    1163. 

  1163. PFNGLVERTEXATTRIB2DVARBPROC __glewVertexAttrib2dvARB = NULL;
    1164. 

  1164. PFNGLVERTEXATTRIB2FARBPROC __glewVertexAttrib2fARB = NULL;
    1165. 

  1165. PFNGLVERTEXATTRIB2FVARBPROC __glewVertexAttrib2fvARB = NULL;
    1166. 

  1166. PFNGLVERTEXATTRIB2SARBPROC __glewVertexAttrib2sARB = NULL;
    1167. 

  1167. PFNGLVERTEXATTRIB2SVARBPROC __glewVertexAttrib2svARB = NULL;
    1168. 

  1168. PFNGLVERTEXATTRIB3DARBPROC __glewVertexAttrib3dARB = NULL;
    1169. 

  1169. PFNGLVERTEXATTRIB3DVARBPROC __glewVertexAttrib3dvARB = NULL;
    1170. 

  1170. PFNGLVERTEXATTRIB3FARBPROC __glewVertexAttrib3fARB = NULL;
    1171. 

  1171. PFNGLVERTEXATTRIB3FVARBPROC __glewVertexAttrib3fvARB = NULL;
    1172. 

  1172. PFNGLVERTEXATTRIB3SARBPROC __glewVertexAttrib3sARB = NULL;
    1173. 

  1173. PFNGLVERTEXATTRIB3SVARBPROC __glewVertexAttrib3svARB = NULL;
    1174. 

  1174. PFNGLVERTEXATTRIB4NBVARBPROC __glewVertexAttrib4NbvARB = NULL;
    1175. 

  1175. PFNGLVERTEXATTRIB4NIVARBPROC __glewVertexAttrib4NivARB = NULL;
    1176. 

  1176. PFNGLVERTEXATTRIB4NSVARBPROC __glewVertexAttrib4NsvARB = NULL;
    1177. 

  1177. PFNGLVERTEXATTRIB4NUBARBPROC __glewVertexAttrib4NubARB = NULL;
    1178. 

  1178. PFNGLVERTEXATTRIB4NUBVARBPROC __glewVertexAttrib4NubvARB = NULL;
    1179. 

  1179. PFNGLVERTEXATTRIB4NUIVARBPROC __glewVertexAttrib4NuivARB = NULL;
    1180. 

  1180. PFNGLVERTEXATTRIB4NUSVARBPROC __glewVertexAttrib4NusvARB = NULL;
    1181. 

  1181. PFNGLVERTEXATTRIB4BVARBPROC __glewVertexAttrib4bvARB = NULL;
    1182. 

  1182. PFNGLVERTEXATTRIB4DARBPROC __glewVertexAttrib4dARB = NULL;
    1183. 

  1183. PFNGLVERTEXATTRIB4DVARBPROC __glewVertexAttrib4dvARB = NULL;
    1184. 

  1184. PFNGLVERTEXATTRIB4FARBPROC __glewVertexAttrib4fARB = NULL;
    1185. 

  1185. PFNGLVERTEXATTRIB4FVARBPROC __glewVertexAttrib4fvARB = NULL;
    1186. 

  1186. PFNGLVERTEXATTRIB4IVARBPROC __glewVertexAttrib4ivARB = NULL;
    1187. 

  1187. PFNGLVERTEXATTRIB4SARBPROC __glewVertexAttrib4sARB = NULL;
    1188. 

  1188. PFNGLVERTEXATTRIB4SVARBPROC __glewVertexAttrib4svARB = NULL;
    1189. 

  1189. PFNGLVERTEXATTRIB4UBVARBPROC __glewVertexAttrib4ubvARB = NULL;
    1190. 

  1190. PFNGLVERTEXATTRIB4UIVARBPROC __glewVertexAttrib4uivARB = NULL;
    1191. 

  1191. PFNGLVERTEXATTRIB4USVARBPROC __glewVertexAttrib4usvARB = NULL;
    1192. 

  1192. PFNGLVERTEXATTRIBPOINTERARBPROC __glewVertexAttribPointerARB = NULL;
    1193. 

  1193. 

  1194. PFNGLBINDATTRIBLOCATIONARBPROC __glewBindAttribLocationARB = NULL;
    1195. 

  1195. PFNGLGETACTIVEATTRIBARBPROC __glewGetActiveAttribARB = NULL;
    1196. 

  1196. PFNGLGETATTRIBLOCATIONARBPROC __glewGetAttribLocationARB = NULL;
    1197. 

  1197. 

  1198. PFNGLCOLORP3UIPROC __glewColorP3ui = NULL;
    1199. 

  1199. PFNGLCOLORP3UIVPROC __glewColorP3uiv = NULL;
    1200. 

  1200. PFNGLCOLORP4UIPROC __glewColorP4ui = NULL;
    1201. 

  1201. PFNGLCOLORP4UIVPROC __glewColorP4uiv = NULL;
    1202. 

  1202. PFNGLMULTITEXCOORDP1UIPROC __glewMultiTexCoordP1ui = NULL;
    1203. 

  1203. PFNGLMULTITEXCOORDP1UIVPROC __glewMultiTexCoordP1uiv = NULL;
    1204. 

  1204. PFNGLMULTITEXCOORDP2UIPROC __glewMultiTexCoordP2ui = NULL;
    1205. 

  1205. PFNGLMULTITEXCOORDP2UIVPROC __glewMultiTexCoordP2uiv = NULL;
    1206. 

  1206. PFNGLMULTITEXCOORDP3UIPROC __glewMultiTexCoordP3ui = NULL;
    1207. 

  1207. PFNGLMULTITEXCOORDP3UIVPROC __glewMultiTexCoordP3uiv = NULL;
    1208. 

  1208. PFNGLMULTITEXCOORDP4UIPROC __glewMultiTexCoordP4ui = NULL;
    1209. 

  1209. PFNGLMULTITEXCOORDP4UIVPROC __glewMultiTexCoordP4uiv = NULL;
    1210. 

  1210. PFNGLNORMALP3UIPROC __glewNormalP3ui = NULL;
    1211. 

  1211. PFNGLNORMALP3UIVPROC __glewNormalP3uiv = NULL;
    1212. 

  1212. PFNGLSECONDARYCOLORP3UIPROC __glewSecondaryColorP3ui = NULL;
    1213. 

  1213. PFNGLSECONDARYCOLORP3UIVPROC __glewSecondaryColorP3uiv = NULL;
    1214. 

  1214. PFNGLTEXCOORDP1UIPROC __glewTexCoordP1ui = NULL;
    1215. 

  1215. PFNGLTEXCOORDP1UIVPROC __glewTexCoordP1uiv = NULL;
    1216. 

  1216. PFNGLTEXCOORDP2UIPROC __glewTexCoordP2ui = NULL;
    1217. 

  1217. PFNGLTEXCOORDP2UIVPROC __glewTexCoordP2uiv = NULL;
    1218. 

  1218. PFNGLTEXCOORDP3UIPROC __glewTexCoordP3ui = NULL;
    1219. 

  1219. PFNGLTEXCOORDP3UIVPROC __glewTexCoordP3uiv = NULL;
    1220. 

  1220. PFNGLTEXCOORDP4UIPROC __glewTexCoordP4ui = NULL;
    1221. 

  1221. PFNGLTEXCOORDP4UIVPROC __glewTexCoordP4uiv = NULL;
    1222. 

  1222. PFNGLVERTEXATTRIBP1UIPROC __glewVertexAttribP1ui = NULL;
    1223. 

  1223. PFNGLVERTEXATTRIBP1UIVPROC __glewVertexAttribP1uiv = NULL;
    1224. 

  1224. PFNGLVERTEXATTRIBP2UIPROC __glewVertexAttribP2ui = NULL;
    1225. 

  1225. PFNGLVERTEXATTRIBP2UIVPROC __glewVertexAttribP2uiv = NULL;
    1226. 

  1226. PFNGLVERTEXATTRIBP3UIPROC __glewVertexAttribP3ui = NULL;
    1227. 

  1227. PFNGLVERTEXATTRIBP3UIVPROC __glewVertexAttribP3uiv = NULL;
    1228. 

  1228. PFNGLVERTEXATTRIBP4UIPROC __glewVertexAttribP4ui = NULL;
    1229. 

  1229. PFNGLVERTEXATTRIBP4UIVPROC __glewVertexAttribP4uiv = NULL;
    1230. 

  1230. PFNGLVERTEXP2UIPROC __glewVertexP2ui = NULL;
    1231. 

  1231. PFNGLVERTEXP2UIVPROC __glewVertexP2uiv = NULL;
    1232. 

  1232. PFNGLVERTEXP3UIPROC __glewVertexP3ui = NULL;
    1233. 

  1233. PFNGLVERTEXP3UIVPROC __glewVertexP3uiv = NULL;
    1234. 

  1234. PFNGLVERTEXP4UIPROC __glewVertexP4ui = NULL;
    1235. 

  1235. PFNGLVERTEXP4UIVPROC __glewVertexP4uiv = NULL;
    1236. 

  1236. 

  1237. PFNGLDEPTHRANGEARRAYVPROC __glewDepthRangeArrayv = NULL;
    1238. 

  1238. PFNGLDEPTHRANGEINDEXEDPROC __glewDepthRangeIndexed = NULL;
    1239. 

  1239. PFNGLGETDOUBLEI_VPROC __glewGetDoublei_v = NULL;
    1240. 

  1240. PFNGLGETFLOATI_VPROC __glewGetFloati_v = NULL;
    1241. 

  1241. PFNGLSCISSORARRAYVPROC __glewScissorArrayv = NULL;
    1242. 

  1242. PFNGLSCISSORINDEXEDPROC __glewScissorIndexed = NULL;
    1243. 

  1243. PFNGLSCISSORINDEXEDVPROC __glewScissorIndexedv = NULL;
    1244. 

  1244. PFNGLVIEWPORTARRAYVPROC __glewViewportArrayv = NULL;
    1245. 

  1245. PFNGLVIEWPORTINDEXEDFPROC __glewViewportIndexedf = NULL;
    1246. 

  1246. PFNGLVIEWPORTINDEXEDFVPROC __glewViewportIndexedfv = NULL;
    1247. 

  1247. 

  1248. PFNGLWINDOWPOS2DARBPROC __glewWindowPos2dARB = NULL;
    1249. 

  1249. PFNGLWINDOWPOS2DVARBPROC __glewWindowPos2dvARB = NULL;
    1250. 

  1250. PFNGLWINDOWPOS2FARBPROC __glewWindowPos2fARB = NULL;
    1251. 

  1251. PFNGLWINDOWPOS2FVARBPROC __glewWindowPos2fvARB = NULL;
    1252. 

  1252. PFNGLWINDOWPOS2IARBPROC __glewWindowPos2iARB = NULL;
    1253. 

  1253. PFNGLWINDOWPOS2IVARBPROC __glewWindowPos2ivARB = NULL;
    1254. 

  1254. PFNGLWINDOWPOS2SARBPROC __glewWindowPos2sARB = NULL;
    1255. 

  1255. PFNGLWINDOWPOS2SVARBPROC __glewWindowPos2svARB = NULL;
    1256. 

  1256. PFNGLWINDOWPOS3DARBPROC __glewWindowPos3dARB = NULL;
    1257. 

  1257. PFNGLWINDOWPOS3DVARBPROC __glewWindowPos3dvARB = NULL;
    1258. 

  1258. PFNGLWINDOWPOS3FARBPROC __glewWindowPos3fARB = NULL;
    1259. 

  1259. PFNGLWINDOWPOS3FVARBPROC __glewWindowPos3fvARB = NULL;
    1260. 

  1260. PFNGLWINDOWPOS3IARBPROC __glewWindowPos3iARB = NULL;
    1261. 

  1261. PFNGLWINDOWPOS3IVARBPROC __glewWindowPos3ivARB = NULL;
    1262. 

  1262. PFNGLWINDOWPOS3SARBPROC __glewWindowPos3sARB = NULL;
    1263. 

  1263. PFNGLWINDOWPOS3SVARBPROC __glewWindowPos3svARB = NULL;
    1264. 

  1264. 

  1265. PFNGLDRAWBUFFERSATIPROC __glewDrawBuffersATI = NULL;
    1266. 

  1266. 

  1267. PFNGLDRAWELEMENTARRAYATIPROC __glewDrawElementArrayATI = NULL;
    1268. 

  1268. PFNGLDRAWRANGEELEMENTARRAYATIPROC __glewDrawRangeElementArrayATI = NULL;
    1269. 

  1269. PFNGLELEMENTPOINTERATIPROC __glewElementPointerATI = NULL;
    1270. 

  1270. 

  1271. PFNGLGETTEXBUMPPARAMETERFVATIPROC __glewGetTexBumpParameterfvATI = NULL;
    1272. 

  1272. PFNGLGETTEXBUMPPARAMETERIVATIPROC __glewGetTexBumpParameterivATI = NULL;
    1273. 

  1273. PFNGLTEXBUMPPARAMETERFVATIPROC __glewTexBumpParameterfvATI = NULL;
    1274. 

  1274. PFNGLTEXBUMPPARAMETERIVATIPROC __glewTexBumpParameterivATI = NULL;
    1275. 

  1275. 

  1276. PFNGLALPHAFRAGMENTOP1ATIPROC __glewAlphaFragmentOp1ATI = NULL;
    1277. 

  1277. PFNGLALPHAFRAGMENTOP2ATIPROC __glewAlphaFragmentOp2ATI = NULL;
    1278. 

  1278. PFNGLALPHAFRAGMENTOP3ATIPROC __glewAlphaFragmentOp3ATI = NULL;
    1279. 

  1279. PFNGLBEGINFRAGMENTSHADERATIPROC __glewBeginFragmentShaderATI = NULL;
    1280. 

  1280. PFNGLBINDFRAGMENTSHADERATIPROC __glewBindFragmentShaderATI = NULL;
    1281. 

  1281. PFNGLCOLORFRAGMENTOP1ATIPROC __glewColorFragmentOp1ATI = NULL;
    1282. 

  1282. PFNGLCOLORFRAGMENTOP2ATIPROC __glewColorFragmentOp2ATI = NULL;
    1283. 

  1283. PFNGLCOLORFRAGMENTOP3ATIPROC __glewColorFragmentOp3ATI = NULL;
    1284. 

  1284. PFNGLDELETEFRAGMENTSHADERATIPROC __glewDeleteFragmentShaderATI = NULL;
    1285. 

  1285. PFNGLENDFRAGMENTSHADERATIPROC __glewEndFragmentShaderATI = NULL;
    1286. 

  1286. PFNGLGENFRAGMENTSHADERSATIPROC __glewGenFragmentShadersATI = NULL;
    1287. 

  1287. PFNGLPASSTEXCOORDATIPROC __glewPassTexCoordATI = NULL;
    1288. 

  1288. PFNGLSAMPLEMAPATIPROC __glewSampleMapATI = NULL;
    1289. 

  1289. PFNGLSETFRAGMENTSHADERCONSTANTATIPROC __glewSetFragmentShaderConstantATI = NULL;
    1290. 

  1290. 

  1291. PFNGLMAPOBJECTBUFFERATIPROC __glewMapObjectBufferATI = NULL;
    1292. 

  1292. PFNGLUNMAPOBJECTBUFFERATIPROC __glewUnmapObjectBufferATI = NULL;
    1293. 

  1293. 

  1294. PFNGLPNTRIANGLESFATIPROC __glewPNTrianglesfATI = NULL;
    1295. 

  1295. PFNGLPNTRIANGLESIATIPROC __glewPNTrianglesiATI = NULL;
    1296. 

  1296. 

  1297. PFNGLSTENCILFUNCSEPARATEATIPROC __glewStencilFuncSeparateATI = NULL;
    1298. 

  1298. PFNGLSTENCILOPSEPARATEATIPROC __glewStencilOpSeparateATI = NULL;
    1299. 

  1299. 

  1300. PFNGLARRAYOBJECTATIPROC __glewArrayObjectATI = NULL;
    1301. 

  1301. PFNGLFREEOBJECTBUFFERATIPROC __glewFreeObjectBufferATI = NULL;
    1302. 

  1302. PFNGLGETARRAYOBJECTFVATIPROC __glewGetArrayObjectfvATI = NULL;
    1303. 

  1303. PFNGLGETARRAYOBJECTIVATIPROC __glewGetArrayObjectivATI = NULL;
    1304. 

  1304. PFNGLGETOBJECTBUFFERFVATIPROC __glewGetObjectBufferfvATI = NULL;
    1305. 

  1305. PFNGLGETOBJECTBUFFERIVATIPROC __glewGetObjectBufferivATI = NULL;
    1306. 

  1306. PFNGLGETVARIANTARRAYOBJECTFVATIPROC __glewGetVariantArrayObjectfvATI = NULL;
    1307. 

  1307. PFNGLGETVARIANTARRAYOBJECTIVATIPROC __glewGetVariantArrayObjectivATI = NULL;
    1308. 

  1308. PFNGLISOBJECTBUFFERATIPROC __glewIsObjectBufferATI = NULL;
    1309. 

  1309. PFNGLNEWOBJECTBUFFERATIPROC __glewNewObjectBufferATI = NULL;
    1310. 

  1310. PFNGLUPDATEOBJECTBUFFERATIPROC __glewUpdateObjectBufferATI = NULL;
    1311. 

  1311. PFNGLVARIANTARRAYOBJECTATIPROC __glewVariantArrayObjectATI = NULL;
    1312. 

  1312. 

  1313. PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC __glewGetVertexAttribArrayObjectfvATI = NULL;
    1314. 

  1314. PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC __glewGetVertexAttribArrayObjectivATI = NULL;
    1315. 

  1315. PFNGLVERTEXATTRIBARRAYOBJECTATIPROC __glewVertexAttribArrayObjectATI = NULL;
    1316. 

  1316. 

  1317. PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC __glewClientActiveVertexStreamATI = NULL;
    1318. 

  1318. PFNGLNORMALSTREAM3BATIPROC __glewNormalStream3bATI = NULL;
    1319. 

  1319. PFNGLNORMALSTREAM3BVATIPROC __glewNormalStream3bvATI = NULL;
    1320. 

  1320. PFNGLNORMALSTREAM3DATIPROC __glewNormalStream3dATI = NULL;
    1321. 

  1321. PFNGLNORMALSTREAM3DVATIPROC __glewNormalStream3dvATI = NULL;
    1322. 

  1322. PFNGLNORMALSTREAM3FATIPROC __glewNormalStream3fATI = NULL;
    1323. 

  1323. PFNGLNORMALSTREAM3FVATIPROC __glewNormalStream3fvATI = NULL;
    1324. 

  1324. PFNGLNORMALSTREAM3IATIPROC __glewNormalStream3iATI = NULL;
    1325. 

  1325. PFNGLNORMALSTREAM3IVATIPROC __glewNormalStream3ivATI = NULL;
    1326. 

  1326. PFNGLNORMALSTREAM3SATIPROC __glewNormalStream3sATI = NULL;
    1327. 

  1327. PFNGLNORMALSTREAM3SVATIPROC __glewNormalStream3svATI = NULL;
    1328. 

  1328. PFNGLVERTEXBLENDENVFATIPROC __glewVertexBlendEnvfATI = NULL;
    1329. 

  1329. PFNGLVERTEXBLENDENVIATIPROC __glewVertexBlendEnviATI = NULL;
    1330. 

  1330. PFNGLVERTEXSTREAM2DATIPROC __glewVertexStream2dATI = NULL;
    1331. 

  1331. PFNGLVERTEXSTREAM2DVATIPROC __glewVertexStream2dvATI = NULL;
    1332. 

  1332. PFNGLVERTEXSTREAM2FATIPROC __glewVertexStream2fATI = NULL;
    1333. 

  1333. PFNGLVERTEXSTREAM2FVATIPROC __glewVertexStream2fvATI = NULL;
    1334. 

  1334. PFNGLVERTEXSTREAM2IATIPROC __glewVertexStream2iATI = NULL;
    1335. 

  1335. PFNGLVERTEXSTREAM2IVATIPROC __glewVertexStream2ivATI = NULL;
    1336. 

  1336. PFNGLVERTEXSTREAM2SATIPROC __glewVertexStream2sATI = NULL;
    1337. 

  1337. PFNGLVERTEXSTREAM2SVATIPROC __glewVertexStream2svATI = NULL;
    1338. 

  1338. PFNGLVERTEXSTREAM3DATIPROC __glewVertexStream3dATI = NULL;
    1339. 

  1339. PFNGLVERTEXSTREAM3DVATIPROC __glewVertexStream3dvATI = NULL;
    1340. 

  1340. PFNGLVERTEXSTREAM3FATIPROC __glewVertexStream3fATI = NULL;
    1341. 

  1341. PFNGLVERTEXSTREAM3FVATIPROC __glewVertexStream3fvATI = NULL;
    1342. 

  1342. PFNGLVERTEXSTREAM3IATIPROC __glewVertexStream3iATI = NULL;
    1343. 

  1343. PFNGLVERTEXSTREAM3IVATIPROC __glewVertexStream3ivATI = NULL;
    1344. 

  1344. PFNGLVERTEXSTREAM3SATIPROC __glewVertexStream3sATI = NULL;
    1345. 

  1345. PFNGLVERTEXSTREAM3SVATIPROC __glewVertexStream3svATI = NULL;
    1346. 

  1346. PFNGLVERTEXSTREAM4DATIPROC __glewVertexStream4dATI = NULL;
    1347. 

  1347. PFNGLVERTEXSTREAM4DVATIPROC __glewVertexStream4dvATI = NULL;
    1348. 

  1348. PFNGLVERTEXSTREAM4FATIPROC __glewVertexStream4fATI = NULL;
    1349. 

  1349. PFNGLVERTEXSTREAM4FVATIPROC __glewVertexStream4fvATI = NULL;
    1350. 

  1350. PFNGLVERTEXSTREAM4IATIPROC __glewVertexStream4iATI = NULL;
    1351. 

  1351. PFNGLVERTEXSTREAM4IVATIPROC __glewVertexStream4ivATI = NULL;
    1352. 

  1352. PFNGLVERTEXSTREAM4SATIPROC __glewVertexStream4sATI = NULL;
    1353. 

  1353. PFNGLVERTEXSTREAM4SVATIPROC __glewVertexStream4svATI = NULL;
    1354. 

  1354. 

  1355. PFNGLGETUNIFORMBUFFERSIZEEXTPROC __glewGetUniformBufferSizeEXT = NULL;
    1356. 

  1356. PFNGLGETUNIFORMOFFSETEXTPROC __glewGetUniformOffsetEXT = NULL;
    1357. 

  1357. PFNGLUNIFORMBUFFEREXTPROC __glewUniformBufferEXT = NULL;
    1358. 

  1358. 

  1359. PFNGLBLENDCOLOREXTPROC __glewBlendColorEXT = NULL;
    1360. 

  1360. 

  1361. PFNGLBLENDEQUATIONSEPARATEEXTPROC __glewBlendEquationSeparateEXT = NULL;
    1362. 

  1362. 

  1363. PFNGLBLENDFUNCSEPARATEEXTPROC __glewBlendFuncSeparateEXT = NULL;
    1364. 

  1364. 

  1365. PFNGLBLENDEQUATIONEXTPROC __glewBlendEquationEXT = NULL;
    1366. 

  1366. 

  1367. PFNGLCOLORSUBTABLEEXTPROC __glewColorSubTableEXT = NULL;
    1368. 

  1368. PFNGLCOPYCOLORSUBTABLEEXTPROC __glewCopyColorSubTableEXT = NULL;
    1369. 

  1369. 

  1370. PFNGLLOCKARRAYSEXTPROC __glewLockArraysEXT = NULL;
    1371. 

  1371. PFNGLUNLOCKARRAYSEXTPROC __glewUnlockArraysEXT = NULL;
    1372. 

  1372. 

  1373. PFNGLCONVOLUTIONFILTER1DEXTPROC __glewConvolutionFilter1DEXT = NULL;
    1374. 

  1374. PFNGLCONVOLUTIONFILTER2DEXTPROC __glewConvolutionFilter2DEXT = NULL;
    1375. 

  1375. PFNGLCONVOLUTIONPARAMETERFEXTPROC __glewConvolutionParameterfEXT = NULL;
    1376. 

  1376. PFNGLCONVOLUTIONPARAMETERFVEXTPROC __glewConvolutionParameterfvEXT = NULL;
    1377. 

  1377. PFNGLCONVOLUTIONPARAMETERIEXTPROC __glewConvolutionParameteriEXT = NULL;
    1378. 

  1378. PFNGLCONVOLUTIONPARAMETERIVEXTPROC __glewConvolutionParameterivEXT = NULL;
    1379. 

  1379. PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC __glewCopyConvolutionFilter1DEXT = NULL;
    1380. 

  1380. PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC __glewCopyConvolutionFilter2DEXT = NULL;
    1381. 

  1381. PFNGLGETCONVOLUTIONFILTEREXTPROC __glewGetConvolutionFilterEXT = NULL;
    1382. 

  1382. PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC __glewGetConvolutionParameterfvEXT = NULL;
    1383. 

  1383. PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC __glewGetConvolutionParameterivEXT = NULL;
    1384. 

  1384. PFNGLGETSEPARABLEFILTEREXTPROC __glewGetSeparableFilterEXT = NULL;
    1385. 

  1385. PFNGLSEPARABLEFILTER2DEXTPROC __glewSeparableFilter2DEXT = NULL;
    1386. 

  1386. 

  1387. PFNGLBINORMALPOINTEREXTPROC __glewBinormalPointerEXT = NULL;
    1388. 

  1388. PFNGLTANGENTPOINTEREXTPROC __glewTangentPointerEXT = NULL;
    1389. 

  1389. 

  1390. PFNGLCOPYTEXIMAGE1DEXTPROC __glewCopyTexImage1DEXT = NULL;
    1391. 

  1391. PFNGLCOPYTEXIMAGE2DEXTPROC __glewCopyTexImage2DEXT = NULL;
    1392. 

  1392. PFNGLCOPYTEXSUBIMAGE1DEXTPROC __glewCopyTexSubImage1DEXT = NULL;
    1393. 

  1393. PFNGLCOPYTEXSUBIMAGE2DEXTPROC __glewCopyTexSubImage2DEXT = NULL;
    1394. 

  1394. PFNGLCOPYTEXSUBIMAGE3DEXTPROC __glewCopyTexSubImage3DEXT = NULL;
    1395. 

  1395. 

  1396. PFNGLCULLPARAMETERDVEXTPROC __glewCullParameterdvEXT = NULL;
    1397. 

  1397. PFNGLCULLPARAMETERFVEXTPROC __glewCullParameterfvEXT = NULL;
    1398. 

  1398. 

  1399. PFNGLDEPTHBOUNDSEXTPROC __glewDepthBoundsEXT = NULL;
    1400. 

  1400. 

  1401. PFNGLBINDMULTITEXTUREEXTPROC __glewBindMultiTextureEXT = NULL;
    1402. 

  1402. PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC __glewCheckNamedFramebufferStatusEXT = NULL;
    1403. 

  1403. PFNGLCLIENTATTRIBDEFAULTEXTPROC __glewClientAttribDefaultEXT = NULL;
    1404. 

  1404. PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC __glewCompressedMultiTexImage1DEXT = NULL;
    1405. 

  1405. PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC __glewCompressedMultiTexImage2DEXT = NULL;
    1406. 

  1406. PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC __glewCompressedMultiTexImage3DEXT = NULL;
    1407. 

  1407. PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC __glewCompressedMultiTexSubImage1DEXT = NULL;
    1408. 

  1408. PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC __glewCompressedMultiTexSubImage2DEXT = NULL;
    1409. 

  1409. PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC __glewCompressedMultiTexSubImage3DEXT = NULL;
    1410. 

  1410. PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC __glewCompressedTextureImage1DEXT = NULL;
    1411. 

  1411. PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC __glewCompressedTextureImage2DEXT = NULL;
    1412. 

  1412. PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC __glewCompressedTextureImage3DEXT = NULL;
    1413. 

  1413. PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC __glewCompressedTextureSubImage1DEXT = NULL;
    1414. 

  1414. PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC __glewCompressedTextureSubImage2DEXT = NULL;
    1415. 

  1415. PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC __glewCompressedTextureSubImage3DEXT = NULL;
    1416. 

  1416. PFNGLCOPYMULTITEXIMAGE1DEXTPROC __glewCopyMultiTexImage1DEXT = NULL;
    1417. 

  1417. PFNGLCOPYMULTITEXIMAGE2DEXTPROC __glewCopyMultiTexImage2DEXT = NULL;
    1418. 

  1418. PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC __glewCopyMultiTexSubImage1DEXT = NULL;
    1419. 

  1419. PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC __glewCopyMultiTexSubImage2DEXT = NULL;
    1420. 

  1420. PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC __glewCopyMultiTexSubImage3DEXT = NULL;
    1421. 

  1421. PFNGLCOPYTEXTUREIMAGE1DEXTPROC __glewCopyTextureImage1DEXT = NULL;
    1422. 

  1422. PFNGLCOPYTEXTUREIMAGE2DEXTPROC __glewCopyTextureImage2DEXT = NULL;
    1423. 

  1423. PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC __glewCopyTextureSubImage1DEXT = NULL;
    1424. 

  1424. PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC __glewCopyTextureSubImage2DEXT = NULL;
    1425. 

  1425. PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC __glewCopyTextureSubImage3DEXT = NULL;
    1426. 

  1426. PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC __glewDisableClientStateIndexedEXT = NULL;
    1427. 

  1427. PFNGLDISABLECLIENTSTATEIEXTPROC __glewDisableClientStateiEXT = NULL;
    1428. 

  1428. PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC __glewDisableVertexArrayAttribEXT = NULL;
    1429. 

  1429. PFNGLDISABLEVERTEXARRAYEXTPROC __glewDisableVertexArrayEXT = NULL;
    1430. 

  1430. PFNGLENABLECLIENTSTATEINDEXEDEXTPROC __glewEnableClientStateIndexedEXT = NULL;
    1431. 

  1431. PFNGLENABLECLIENTSTATEIEXTPROC __glewEnableClientStateiEXT = NULL;
    1432. 

  1432. PFNGLENABLEVERTEXARRAYATTRIBEXTPROC __glewEnableVertexArrayAttribEXT = NULL;
    1433. 

  1433. PFNGLENABLEVERTEXARRAYEXTPROC __glewEnableVertexArrayEXT = NULL;
    1434. 

  1434. PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC __glewFlushMappedNamedBufferRangeEXT = NULL;
    1435. 

  1435. PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC __glewFramebufferDrawBufferEXT = NULL;
    1436. 

  1436. PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC __glewFramebufferDrawBuffersEXT = NULL;
    1437. 

  1437. PFNGLFRAMEBUFFERREADBUFFEREXTPROC __glewFramebufferReadBufferEXT = NULL;
    1438. 

  1438. PFNGLGENERATEMULTITEXMIPMAPEXTPROC __glewGenerateMultiTexMipmapEXT = NULL;
    1439. 

  1439. PFNGLGENERATETEXTUREMIPMAPEXTPROC __glewGenerateTextureMipmapEXT = NULL;
    1440. 

  1440. PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC __glewGetCompressedMultiTexImageEXT = NULL;
    1441. 

  1441. PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC __glewGetCompressedTextureImageEXT = NULL;
    1442. 

  1442. PFNGLGETDOUBLEINDEXEDVEXTPROC __glewGetDoubleIndexedvEXT = NULL;
    1443. 

  1443. PFNGLGETDOUBLEI_VEXTPROC __glewGetDoublei_vEXT = NULL;
    1444. 

  1444. PFNGLGETFLOATINDEXEDVEXTPROC __glewGetFloatIndexedvEXT = NULL;
    1445. 

  1445. PFNGLGETFLOATI_VEXTPROC __glewGetFloati_vEXT = NULL;
    1446. 

  1446. PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC __glewGetFramebufferParameterivEXT = NULL;
    1447. 

  1447. PFNGLGETMULTITEXENVFVEXTPROC __glewGetMultiTexEnvfvEXT = NULL;
    1448. 

  1448. PFNGLGETMULTITEXENVIVEXTPROC __glewGetMultiTexEnvivEXT = NULL;
    1449. 

  1449. PFNGLGETMULTITEXGENDVEXTPROC __glewGetMultiTexGendvEXT = NULL;
    1450. 

  1450. PFNGLGETMULTITEXGENFVEXTPROC __glewGetMultiTexGenfvEXT = NULL;
    1451. 

  1451. PFNGLGETMULTITEXGENIVEXTPROC __glewGetMultiTexGenivEXT = NULL;
    1452. 

  1452. PFNGLGETMULTITEXIMAGEEXTPROC __glewGetMultiTexImageEXT = NULL;
    1453. 

  1453. PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC __glewGetMultiTexLevelParameterfvEXT = NULL;
    1454. 

  1454. PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC __glewGetMultiTexLevelParameterivEXT = NULL;
    1455. 

  1455. PFNGLGETMULTITEXPARAMETERIIVEXTPROC __glewGetMultiTexParameterIivEXT = NULL;
    1456. 

  1456. PFNGLGETMULTITEXPARAMETERIUIVEXTPROC __glewGetMultiTexParameterIuivEXT = NULL;
    1457. 

  1457. PFNGLGETMULTITEXPARAMETERFVEXTPROC __glewGetMultiTexParameterfvEXT = NULL;
    1458. 

  1458. PFNGLGETMULTITEXPARAMETERIVEXTPROC __glewGetMultiTexParameterivEXT = NULL;
    1459. 

  1459. PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC __glewGetNamedBufferParameterivEXT = NULL;
    1460. 

  1460. PFNGLGETNAMEDBUFFERPOINTERVEXTPROC __glewGetNamedBufferPointervEXT = NULL;
    1461. 

  1461. PFNGLGETNAMEDBUFFERSUBDATAEXTPROC __glewGetNamedBufferSubDataEXT = NULL;
    1462. 

  1462. PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetNamedFramebufferAttachmentParameterivEXT = NULL;
    1463. 

  1463. PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC __glewGetNamedProgramLocalParameterIivEXT = NULL;
    1464. 

  1464. PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC __glewGetNamedProgramLocalParameterIuivEXT = NULL;
    1465. 

  1465. PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC __glewGetNamedProgramLocalParameterdvEXT = NULL;
    1466. 

  1466. PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC __glewGetNamedProgramLocalParameterfvEXT = NULL;
    1467. 

  1467. PFNGLGETNAMEDPROGRAMSTRINGEXTPROC __glewGetNamedProgramStringEXT = NULL;
    1468. 

  1468. PFNGLGETNAMEDPROGRAMIVEXTPROC __glewGetNamedProgramivEXT = NULL;
    1469. 

  1469. PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC __glewGetNamedRenderbufferParameterivEXT = NULL;
    1470. 

  1470. PFNGLGETPOINTERINDEXEDVEXTPROC __glewGetPointerIndexedvEXT = NULL;
    1471. 

  1471. PFNGLGETPOINTERI_VEXTPROC __glewGetPointeri_vEXT = NULL;
    1472. 

  1472. PFNGLGETTEXTUREIMAGEEXTPROC __glewGetTextureImageEXT = NULL;
    1473. 

  1473. PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC __glewGetTextureLevelParameterfvEXT = NULL;
    1474. 

  1474. PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC __glewGetTextureLevelParameterivEXT = NULL;
    1475. 

  1475. PFNGLGETTEXTUREPARAMETERIIVEXTPROC __glewGetTextureParameterIivEXT = NULL;
    1476. 

  1476. PFNGLGETTEXTUREPARAMETERIUIVEXTPROC __glewGetTextureParameterIuivEXT = NULL;
    1477. 

  1477. PFNGLGETTEXTUREPARAMETERFVEXTPROC __glewGetTextureParameterfvEXT = NULL;
    1478. 

  1478. PFNGLGETTEXTUREPARAMETERIVEXTPROC __glewGetTextureParameterivEXT = NULL;
    1479. 

  1479. PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC __glewGetVertexArrayIntegeri_vEXT = NULL;
    1480. 

  1480. PFNGLGETVERTEXARRAYINTEGERVEXTPROC __glewGetVertexArrayIntegervEXT = NULL;
    1481. 

  1481. PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC __glewGetVertexArrayPointeri_vEXT = NULL;
    1482. 

  1482. PFNGLGETVERTEXARRAYPOINTERVEXTPROC __glewGetVertexArrayPointervEXT = NULL;
    1483. 

  1483. PFNGLMAPNAMEDBUFFEREXTPROC __glewMapNamedBufferEXT = NULL;
    1484. 

  1484. PFNGLMAPNAMEDBUFFERRANGEEXTPROC __glewMapNamedBufferRangeEXT = NULL;
    1485. 

  1485. PFNGLMATRIXFRUSTUMEXTPROC __glewMatrixFrustumEXT = NULL;
    1486. 

  1486. PFNGLMATRIXLOADIDENTITYEXTPROC __glewMatrixLoadIdentityEXT = NULL;
    1487. 

  1487. PFNGLMATRIXLOADTRANSPOSEDEXTPROC __glewMatrixLoadTransposedEXT = NULL;
    1488. 

  1488. PFNGLMATRIXLOADTRANSPOSEFEXTPROC __glewMatrixLoadTransposefEXT = NULL;
    1489. 

  1489. PFNGLMATRIXLOADDEXTPROC __glewMatrixLoaddEXT = NULL;
    1490. 

  1490. PFNGLMATRIXLOADFEXTPROC __glewMatrixLoadfEXT = NULL;
    1491. 

  1491. PFNGLMATRIXMULTTRANSPOSEDEXTPROC __glewMatrixMultTransposedEXT = NULL;
    1492. 

  1492. PFNGLMATRIXMULTTRANSPOSEFEXTPROC __glewMatrixMultTransposefEXT = NULL;
    1493. 

  1493. PFNGLMATRIXMULTDEXTPROC __glewMatrixMultdEXT = NULL;
    1494. 

  1494. PFNGLMATRIXMULTFEXTPROC __glewMatrixMultfEXT = NULL;
    1495. 

  1495. PFNGLMATRIXORTHOEXTPROC __glewMatrixOrthoEXT = NULL;
    1496. 

  1496. PFNGLMATRIXPOPEXTPROC __glewMatrixPopEXT = NULL;
    1497. 

  1497. PFNGLMATRIXPUSHEXTPROC __glewMatrixPushEXT = NULL;
    1498. 

  1498. PFNGLMATRIXROTATEDEXTPROC __glewMatrixRotatedEXT = NULL;
    1499. 

  1499. PFNGLMATRIXROTATEFEXTPROC __glewMatrixRotatefEXT = NULL;
    1500. 

  1500. PFNGLMATRIXSCALEDEXTPROC __glewMatrixScaledEXT = NULL;
    1501. 

  1501. PFNGLMATRIXSCALEFEXTPROC __glewMatrixScalefEXT = NULL;
    1502. 

  1502. PFNGLMATRIXTRANSLATEDEXTPROC __glewMatrixTranslatedEXT = NULL;
    1503. 

  1503. PFNGLMATRIXTRANSLATEFEXTPROC __glewMatrixTranslatefEXT = NULL;
    1504. 

  1504. PFNGLMULTITEXBUFFEREXTPROC __glewMultiTexBufferEXT = NULL;
    1505. 

  1505. PFNGLMULTITEXCOORDPOINTEREXTPROC __glewMultiTexCoordPointerEXT = NULL;
    1506. 

  1506. PFNGLMULTITEXENVFEXTPROC __glewMultiTexEnvfEXT = NULL;
    1507. 

  1507. PFNGLMULTITEXENVFVEXTPROC __glewMultiTexEnvfvEXT = NULL;
    1508. 

  1508. PFNGLMULTITEXENVIEXTPROC __glewMultiTexEnviEXT = NULL;
    1509. 

  1509. PFNGLMULTITEXENVIVEXTPROC __glewMultiTexEnvivEXT = NULL;
    1510. 

  1510. PFNGLMULTITEXGENDEXTPROC __glewMultiTexGendEXT = NULL;
    1511. 

  1511. PFNGLMULTITEXGENDVEXTPROC __glewMultiTexGendvEXT = NULL;
    1512. 

  1512. PFNGLMULTITEXGENFEXTPROC __glewMultiTexGenfEXT = NULL;
    1513. 

  1513. PFNGLMULTITEXGENFVEXTPROC __glewMultiTexGenfvEXT = NULL;
    1514. 

  1514. PFNGLMULTITEXGENIEXTPROC __glewMultiTexGeniEXT = NULL;
    1515. 

  1515. PFNGLMULTITEXGENIVEXTPROC __glewMultiTexGenivEXT = NULL;
    1516. 

  1516. PFNGLMULTITEXIMAGE1DEXTPROC __glewMultiTexImage1DEXT = NULL;
    1517. 

  1517. PFNGLMULTITEXIMAGE2DEXTPROC __glewMultiTexImage2DEXT = NULL;
    1518. 

  1518. PFNGLMULTITEXIMAGE3DEXTPROC __glewMultiTexImage3DEXT = NULL;
    1519. 

  1519. PFNGLMULTITEXPARAMETERIIVEXTPROC __glewMultiTexParameterIivEXT = NULL;
    1520. 

  1520. PFNGLMULTITEXPARAMETERIUIVEXTPROC __glewMultiTexParameterIuivEXT = NULL;
    1521. 

  1521. PFNGLMULTITEXPARAMETERFEXTPROC __glewMultiTexParameterfEXT = NULL;
    1522. 

  1522. PFNGLMULTITEXPARAMETERFVEXTPROC __glewMultiTexParameterfvEXT = NULL;
    1523. 

  1523. PFNGLMULTITEXPARAMETERIEXTPROC __glewMultiTexParameteriEXT = NULL;
    1524. 

  1524. PFNGLMULTITEXPARAMETERIVEXTPROC __glewMultiTexParameterivEXT = NULL;
    1525. 

  1525. PFNGLMULTITEXRENDERBUFFEREXTPROC __glewMultiTexRenderbufferEXT = NULL;
    1526. 

  1526. PFNGLMULTITEXSUBIMAGE1DEXTPROC __glewMultiTexSubImage1DEXT = NULL;
    1527. 

  1527. PFNGLMULTITEXSUBIMAGE2DEXTPROC __glewMultiTexSubImage2DEXT = NULL;
    1528. 

  1528. PFNGLMULTITEXSUBIMAGE3DEXTPROC __glewMultiTexSubImage3DEXT = NULL;
    1529. 

  1529. PFNGLNAMEDBUFFERDATAEXTPROC __glewNamedBufferDataEXT = NULL;
    1530. 

  1530. PFNGLNAMEDBUFFERSUBDATAEXTPROC __glewNamedBufferSubDataEXT = NULL;
    1531. 

  1531. PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC __glewNamedCopyBufferSubDataEXT = NULL;
    1532. 

  1532. PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC __glewNamedFramebufferRenderbufferEXT = NULL;
    1533. 

  1533. PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC __glewNamedFramebufferTexture1DEXT = NULL;
    1534. 

  1534. PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC __glewNamedFramebufferTexture2DEXT = NULL;
    1535. 

  1535. PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC __glewNamedFramebufferTexture3DEXT = NULL;
    1536. 

  1536. PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC __glewNamedFramebufferTextureEXT = NULL;
    1537. 

  1537. PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC __glewNamedFramebufferTextureFaceEXT = NULL;
    1538. 

  1538. PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC __glewNamedFramebufferTextureLayerEXT = NULL;
    1539. 

  1539. PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC __glewNamedProgramLocalParameter4dEXT = NULL;
    1540. 

  1540. PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC __glewNamedProgramLocalParameter4dvEXT = NULL;
    1541. 

  1541. PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC __glewNamedProgramLocalParameter4fEXT = NULL;
    1542. 

  1542. PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC __glewNamedProgramLocalParameter4fvEXT = NULL;
    1543. 

  1543. PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC __glewNamedProgramLocalParameterI4iEXT = NULL;
    1544. 

  1544. PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC __glewNamedProgramLocalParameterI4ivEXT = NULL;
    1545. 

  1545. PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC __glewNamedProgramLocalParameterI4uiEXT = NULL;
    1546. 

  1546. PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC __glewNamedProgramLocalParameterI4uivEXT = NULL;
    1547. 

  1547. PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC __glewNamedProgramLocalParameters4fvEXT = NULL;
    1548. 

  1548. PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC __glewNamedProgramLocalParametersI4ivEXT = NULL;
    1549. 

  1549. PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC __glewNamedProgramLocalParametersI4uivEXT = NULL;
    1550. 

  1550. PFNGLNAMEDPROGRAMSTRINGEXTPROC __glewNamedProgramStringEXT = NULL;
    1551. 

  1551. PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC __glewNamedRenderbufferStorageEXT = NULL;
    1552. 

  1552. PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC __glewNamedRenderbufferStorageMultisampleCoverageEXT = NULL;
    1553. 

  1553. PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewNamedRenderbufferStorageMultisampleEXT = NULL;
    1554. 

  1554. PFNGLPROGRAMUNIFORM1FEXTPROC __glewProgramUniform1fEXT = NULL;
    1555. 

  1555. PFNGLPROGRAMUNIFORM1FVEXTPROC __glewProgramUniform1fvEXT = NULL;
    1556. 

  1556. PFNGLPROGRAMUNIFORM1IEXTPROC __glewProgramUniform1iEXT = NULL;
    1557. 

  1557. PFNGLPROGRAMUNIFORM1IVEXTPROC __glewProgramUniform1ivEXT = NULL;
    1558. 

  1558. PFNGLPROGRAMUNIFORM1UIEXTPROC __glewProgramUniform1uiEXT = NULL;
    1559. 

  1559. PFNGLPROGRAMUNIFORM1UIVEXTPROC __glewProgramUniform1uivEXT = NULL;
    1560. 

  1560. PFNGLPROGRAMUNIFORM2FEXTPROC __glewProgramUniform2fEXT = NULL;
    1561. 

  1561. PFNGLPROGRAMUNIFORM2FVEXTPROC __glewProgramUniform2fvEXT = NULL;
    1562. 

  1562. PFNGLPROGRAMUNIFORM2IEXTPROC __glewProgramUniform2iEXT = NULL;
    1563. 

  1563. PFNGLPROGRAMUNIFORM2IVEXTPROC __glewProgramUniform2ivEXT = NULL;
    1564. 

  1564. PFNGLPROGRAMUNIFORM2UIEXTPROC __glewProgramUniform2uiEXT = NULL;
    1565. 

  1565. PFNGLPROGRAMUNIFORM2UIVEXTPROC __glewProgramUniform2uivEXT = NULL;
    1566. 

  1566. PFNGLPROGRAMUNIFORM3FEXTPROC __glewProgramUniform3fEXT = NULL;
    1567. 

  1567. PFNGLPROGRAMUNIFORM3FVEXTPROC __glewProgramUniform3fvEXT = NULL;
    1568. 

  1568. PFNGLPROGRAMUNIFORM3IEXTPROC __glewProgramUniform3iEXT = NULL;
    1569. 

  1569. PFNGLPROGRAMUNIFORM3IVEXTPROC __glewProgramUniform3ivEXT = NULL;
    1570. 

  1570. PFNGLPROGRAMUNIFORM3UIEXTPROC __glewProgramUniform3uiEXT = NULL;
    1571. 

  1571. PFNGLPROGRAMUNIFORM3UIVEXTPROC __glewProgramUniform3uivEXT = NULL;
    1572. 

  1572. PFNGLPROGRAMUNIFORM4FEXTPROC __glewProgramUniform4fEXT = NULL;
    1573. 

  1573. PFNGLPROGRAMUNIFORM4FVEXTPROC __glewProgramUniform4fvEXT = NULL;
    1574. 

  1574. PFNGLPROGRAMUNIFORM4IEXTPROC __glewProgramUniform4iEXT = NULL;
    1575. 

  1575. PFNGLPROGRAMUNIFORM4IVEXTPROC __glewProgramUniform4ivEXT = NULL;
    1576. 

  1576. PFNGLPROGRAMUNIFORM4UIEXTPROC __glewProgramUniform4uiEXT = NULL;
    1577. 

  1577. PFNGLPROGRAMUNIFORM4UIVEXTPROC __glewProgramUniform4uivEXT = NULL;
    1578. 

  1578. PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC __glewProgramUniformMatrix2fvEXT = NULL;
    1579. 

  1579. PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC __glewProgramUniformMatrix2x3fvEXT = NULL;
    1580. 

  1580. PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC __glewProgramUniformMatrix2x4fvEXT = NULL;
    1581. 

  1581. PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC __glewProgramUniformMatrix3fvEXT = NULL;
    1582. 

  1582. PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC __glewProgramUniformMatrix3x2fvEXT = NULL;
    1583. 

  1583. PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC __glewProgramUniformMatrix3x4fvEXT = NULL;
    1584. 

  1584. PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC __glewProgramUniformMatrix4fvEXT = NULL;
    1585. 

  1585. PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC __glewProgramUniformMatrix4x2fvEXT = NULL;
    1586. 

  1586. PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC __glewProgramUniformMatrix4x3fvEXT = NULL;
    1587. 

  1587. PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC __glewPushClientAttribDefaultEXT = NULL;
    1588. 

  1588. PFNGLTEXTUREBUFFEREXTPROC __glewTextureBufferEXT = NULL;
    1589. 

  1589. PFNGLTEXTUREIMAGE1DEXTPROC __glewTextureImage1DEXT = NULL;
    1590. 

  1590. PFNGLTEXTUREIMAGE2DEXTPROC __glewTextureImage2DEXT = NULL;
    1591. 

  1591. PFNGLTEXTUREIMAGE3DEXTPROC __glewTextureImage3DEXT = NULL;
    1592. 

  1592. PFNGLTEXTUREPARAMETERIIVEXTPROC __glewTextureParameterIivEXT = NULL;
    1593. 

  1593. PFNGLTEXTUREPARAMETERIUIVEXTPROC __glewTextureParameterIuivEXT = NULL;
    1594. 

  1594. PFNGLTEXTUREPARAMETERFEXTPROC __glewTextureParameterfEXT = NULL;
    1595. 

  1595. PFNGLTEXTUREPARAMETERFVEXTPROC __glewTextureParameterfvEXT = NULL;
    1596. 

  1596. PFNGLTEXTUREPARAMETERIEXTPROC __glewTextureParameteriEXT = NULL;
    1597. 

  1597. PFNGLTEXTUREPARAMETERIVEXTPROC __glewTextureParameterivEXT = NULL;
    1598. 

  1598. PFNGLTEXTURERENDERBUFFEREXTPROC __glewTextureRenderbufferEXT = NULL;
    1599. 

  1599. PFNGLTEXTURESUBIMAGE1DEXTPROC __glewTextureSubImage1DEXT = NULL;
    1600. 

  1600. PFNGLTEXTURESUBIMAGE2DEXTPROC __glewTextureSubImage2DEXT = NULL;
    1601. 

  1601. PFNGLTEXTURESUBIMAGE3DEXTPROC __glewTextureSubImage3DEXT = NULL;
    1602. 

  1602. PFNGLUNMAPNAMEDBUFFEREXTPROC __glewUnmapNamedBufferEXT = NULL;
    1603. 

  1603. PFNGLVERTEXARRAYCOLOROFFSETEXTPROC __glewVertexArrayColorOffsetEXT = NULL;
    1604. 

  1604. PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC __glewVertexArrayEdgeFlagOffsetEXT = NULL;
    1605. 

  1605. PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC __glewVertexArrayFogCoordOffsetEXT = NULL;
    1606. 

  1606. PFNGLVERTEXARRAYINDEXOFFSETEXTPROC __glewVertexArrayIndexOffsetEXT = NULL;
    1607. 

  1607. PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC __glewVertexArrayMultiTexCoordOffsetEXT = NULL;
    1608. 

  1608. PFNGLVERTEXARRAYNORMALOFFSETEXTPROC __glewVertexArrayNormalOffsetEXT = NULL;
    1609. 

  1609. PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC __glewVertexArraySecondaryColorOffsetEXT = NULL;
    1610. 

  1610. PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC __glewVertexArrayTexCoordOffsetEXT = NULL;
    1611. 

  1611. PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC __glewVertexArrayVertexAttribIOffsetEXT = NULL;
    1612. 

  1612. PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC __glewVertexArrayVertexAttribOffsetEXT = NULL;
    1613. 

  1613. PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC __glewVertexArrayVertexOffsetEXT = NULL;
    1614. 

  1614. 

  1615. PFNGLCOLORMASKINDEXEDEXTPROC __glewColorMaskIndexedEXT = NULL;
    1616. 

  1616. PFNGLDISABLEINDEXEDEXTPROC __glewDisableIndexedEXT = NULL;
    1617. 

  1617. PFNGLENABLEINDEXEDEXTPROC __glewEnableIndexedEXT = NULL;
    1618. 

  1618. PFNGLGETBOOLEANINDEXEDVEXTPROC __glewGetBooleanIndexedvEXT = NULL;
    1619. 

  1619. PFNGLGETINTEGERINDEXEDVEXTPROC __glewGetIntegerIndexedvEXT = NULL;
    1620. 

  1620. PFNGLISENABLEDINDEXEDEXTPROC __glewIsEnabledIndexedEXT = NULL;
    1621. 

  1621. 

  1622. PFNGLDRAWARRAYSINSTANCEDEXTPROC __glewDrawArraysInstancedEXT = NULL;
    1623. 

  1623. PFNGLDRAWELEMENTSINSTANCEDEXTPROC __glewDrawElementsInstancedEXT = NULL;
    1624. 

  1624. 

  1625. PFNGLDRAWRANGEELEMENTSEXTPROC __glewDrawRangeElementsEXT = NULL;
    1626. 

  1626. 

  1627. PFNGLFOGCOORDPOINTEREXTPROC __glewFogCoordPointerEXT = NULL;
    1628. 

  1628. PFNGLFOGCOORDDEXTPROC __glewFogCoorddEXT = NULL;
    1629. 

  1629. PFNGLFOGCOORDDVEXTPROC __glewFogCoorddvEXT = NULL;
    1630. 

  1630. PFNGLFOGCOORDFEXTPROC __glewFogCoordfEXT = NULL;
    1631. 

  1631. PFNGLFOGCOORDFVEXTPROC __glewFogCoordfvEXT = NULL;
    1632. 

  1632. 

  1633. PFNGLFRAGMENTCOLORMATERIALEXTPROC __glewFragmentColorMaterialEXT = NULL;
    1634. 

  1634. PFNGLFRAGMENTLIGHTMODELFEXTPROC __glewFragmentLightModelfEXT = NULL;
    1635. 

  1635. PFNGLFRAGMENTLIGHTMODELFVEXTPROC __glewFragmentLightModelfvEXT = NULL;
    1636. 

  1636. PFNGLFRAGMENTLIGHTMODELIEXTPROC __glewFragmentLightModeliEXT = NULL;
    1637. 

  1637. PFNGLFRAGMENTLIGHTMODELIVEXTPROC __glewFragmentLightModelivEXT = NULL;
    1638. 

  1638. PFNGLFRAGMENTLIGHTFEXTPROC __glewFragmentLightfEXT = NULL;
    1639. 

  1639. PFNGLFRAGMENTLIGHTFVEXTPROC __glewFragmentLightfvEXT = NULL;
    1640. 

  1640. PFNGLFRAGMENTLIGHTIEXTPROC __glewFragmentLightiEXT = NULL;
    1641. 

  1641. PFNGLFRAGMENTLIGHTIVEXTPROC __glewFragmentLightivEXT = NULL;
    1642. 

  1642. PFNGLFRAGMENTMATERIALFEXTPROC __glewFragmentMaterialfEXT = NULL;
    1643. 

  1643. PFNGLFRAGMENTMATERIALFVEXTPROC __glewFragmentMaterialfvEXT = NULL;
    1644. 

  1644. PFNGLFRAGMENTMATERIALIEXTPROC __glewFragmentMaterialiEXT = NULL;
    1645. 

  1645. PFNGLFRAGMENTMATERIALIVEXTPROC __glewFragmentMaterialivEXT = NULL;
    1646. 

  1646. PFNGLGETFRAGMENTLIGHTFVEXTPROC __glewGetFragmentLightfvEXT = NULL;
    1647. 

  1647. PFNGLGETFRAGMENTLIGHTIVEXTPROC __glewGetFragmentLightivEXT = NULL;
    1648. 

  1648. PFNGLGETFRAGMENTMATERIALFVEXTPROC __glewGetFragmentMaterialfvEXT = NULL;
    1649. 

  1649. PFNGLGETFRAGMENTMATERIALIVEXTPROC __glewGetFragmentMaterialivEXT = NULL;
    1650. 

  1650. PFNGLLIGHTENVIEXTPROC __glewLightEnviEXT = NULL;
    1651. 

  1651. 

  1652. PFNGLBLITFRAMEBUFFEREXTPROC __glewBlitFramebufferEXT = NULL;
    1653. 

  1653. 

  1654. PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewRenderbufferStorageMultisampleEXT = NULL;
    1655. 

  1655. 

  1656. PFNGLBINDFRAMEBUFFEREXTPROC __glewBindFramebufferEXT = NULL;
    1657. 

  1657. PFNGLBINDRENDERBUFFEREXTPROC __glewBindRenderbufferEXT = NULL;
    1658. 

  1658. PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC __glewCheckFramebufferStatusEXT = NULL;
    1659. 

  1659. PFNGLDELETEFRAMEBUFFERSEXTPROC __glewDeleteFramebuffersEXT = NULL;
    1660. 

  1660. PFNGLDELETERENDERBUFFERSEXTPROC __glewDeleteRenderbuffersEXT = NULL;
    1661. 

  1661. PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC __glewFramebufferRenderbufferEXT = NULL;
    1662. 

  1662. PFNGLFRAMEBUFFERTEXTURE1DEXTPROC __glewFramebufferTexture1DEXT = NULL;
    1663. 

  1663. PFNGLFRAMEBUFFERTEXTURE2DEXTPROC __glewFramebufferTexture2DEXT = NULL;
    1664. 

  1664. PFNGLFRAMEBUFFERTEXTURE3DEXTPROC __glewFramebufferTexture3DEXT = NULL;
    1665. 

  1665. PFNGLGENFRAMEBUFFERSEXTPROC __glewGenFramebuffersEXT = NULL;
    1666. 

  1666. PFNGLGENRENDERBUFFERSEXTPROC __glewGenRenderbuffersEXT = NULL;
    1667. 

  1667. PFNGLGENERATEMIPMAPEXTPROC __glewGenerateMipmapEXT = NULL;
    1668. 

  1668. PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetFramebufferAttachmentParameterivEXT = NULL;
    1669. 

  1669. PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC __glewGetRenderbufferParameterivEXT = NULL;
    1670. 

  1670. PFNGLISFRAMEBUFFEREXTPROC __glewIsFramebufferEXT = NULL;
    1671. 

  1671. PFNGLISRENDERBUFFEREXTPROC __glewIsRenderbufferEXT = NULL;
    1672. 

  1672. PFNGLRENDERBUFFERSTORAGEEXTPROC __glewRenderbufferStorageEXT = NULL;
    1673. 

  1673. 

  1674. PFNGLFRAMEBUFFERTEXTUREEXTPROC __glewFramebufferTextureEXT = NULL;
    1675. 

  1675. PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC __glewFramebufferTextureFaceEXT = NULL;
    1676. 

  1676. PFNGLPROGRAMPARAMETERIEXTPROC __glewProgramParameteriEXT = NULL;
    1677. 

  1677. 

  1678. PFNGLPROGRAMENVPARAMETERS4FVEXTPROC __glewProgramEnvParameters4fvEXT = NULL;
    1679. 

  1679. PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC __glewProgramLocalParameters4fvEXT = NULL;
    1680. 

  1680. 

  1681. PFNGLBINDFRAGDATALOCATIONEXTPROC __glewBindFragDataLocationEXT = NULL;
    1682. 

  1682. PFNGLGETFRAGDATALOCATIONEXTPROC __glewGetFragDataLocationEXT = NULL;
    1683. 

  1683. PFNGLGETUNIFORMUIVEXTPROC __glewGetUniformuivEXT = NULL;
    1684. 

  1684. PFNGLGETVERTEXATTRIBIIVEXTPROC __glewGetVertexAttribIivEXT = NULL;
    1685. 

  1685. PFNGLGETVERTEXATTRIBIUIVEXTPROC __glewGetVertexAttribIuivEXT = NULL;
    1686. 

  1686. PFNGLUNIFORM1UIEXTPROC __glewUniform1uiEXT = NULL;
    1687. 

  1687. PFNGLUNIFORM1UIVEXTPROC __glewUniform1uivEXT = NULL;
    1688. 

  1688. PFNGLUNIFORM2UIEXTPROC __glewUniform2uiEXT = NULL;
    1689. 

  1689. PFNGLUNIFORM2UIVEXTPROC __glewUniform2uivEXT = NULL;
    1690. 

  1690. PFNGLUNIFORM3UIEXTPROC __glewUniform3uiEXT = NULL;
    1691. 

  1691. PFNGLUNIFORM3UIVEXTPROC __glewUniform3uivEXT = NULL;
    1692. 

  1692. PFNGLUNIFORM4UIEXTPROC __glewUniform4uiEXT = NULL;
    1693. 

  1693. PFNGLUNIFORM4UIVEXTPROC __glewUniform4uivEXT = NULL;
    1694. 

  1694. PFNGLVERTEXATTRIBI1IEXTPROC __glewVertexAttribI1iEXT = NULL;
    1695. 

  1695. PFNGLVERTEXATTRIBI1IVEXTPROC __glewVertexAttribI1ivEXT = NULL;
    1696. 

  1696. PFNGLVERTEXATTRIBI1UIEXTPROC __glewVertexAttribI1uiEXT = NULL;
    1697. 

  1697. PFNGLVERTEXATTRIBI1UIVEXTPROC __glewVertexAttribI1uivEXT = NULL;
    1698. 

  1698. PFNGLVERTEXATTRIBI2IEXTPROC __glewVertexAttribI2iEXT = NULL;
    1699. 

  1699. PFNGLVERTEXATTRIBI2IVEXTPROC __glewVertexAttribI2ivEXT = NULL;
    1700. 

  1700. PFNGLVERTEXATTRIBI2UIEXTPROC __glewVertexAttribI2uiEXT = NULL;
    1701. 

  1701. PFNGLVERTEXATTRIBI2UIVEXTPROC __glewVertexAttribI2uivEXT = NULL;
    1702. 

  1702. PFNGLVERTEXATTRIBI3IEXTPROC __glewVertexAttribI3iEXT = NULL;
    1703. 

  1703. PFNGLVERTEXATTRIBI3IVEXTPROC __glewVertexAttribI3ivEXT = NULL;
    1704. 

  1704. PFNGLVERTEXATTRIBI3UIEXTPROC __glewVertexAttribI3uiEXT = NULL;
    1705. 

  1705. PFNGLVERTEXATTRIBI3UIVEXTPROC __glewVertexAttribI3uivEXT = NULL;
    1706. 

  1706. PFNGLVERTEXATTRIBI4BVEXTPROC __glewVertexAttribI4bvEXT = NULL;
    1707. 

  1707. PFNGLVERTEXATTRIBI4IEXTPROC __glewVertexAttribI4iEXT = NULL;
    1708. 

  1708. PFNGLVERTEXATTRIBI4IVEXTPROC __glewVertexAttribI4ivEXT = NULL;
    1709. 

  1709. PFNGLVERTEXATTRIBI4SVEXTPROC __glewVertexAttribI4svEXT = NULL;
    1710. 

  1710. PFNGLVERTEXATTRIBI4UBVEXTPROC __glewVertexAttribI4ubvEXT = NULL;
    1711. 

  1711. PFNGLVERTEXATTRIBI4UIEXTPROC __glewVertexAttribI4uiEXT = NULL;
    1712. 

  1712. PFNGLVERTEXATTRIBI4UIVEXTPROC __glewVertexAttribI4uivEXT = NULL;
    1713. 

  1713. PFNGLVERTEXATTRIBI4USVEXTPROC __glewVertexAttribI4usvEXT = NULL;
    1714. 

  1714. PFNGLVERTEXATTRIBIPOINTEREXTPROC __glewVertexAttribIPointerEXT = NULL;
    1715. 

  1715. 

  1716. PFNGLGETHISTOGRAMEXTPROC __glewGetHistogramEXT = NULL;
    1717. 

  1717. PFNGLGETHISTOGRAMPARAMETERFVEXTPROC __glewGetHistogramParameterfvEXT = NULL;
    1718. 

  1718. PFNGLGETHISTOGRAMPARAMETERIVEXTPROC __glewGetHistogramParameterivEXT = NULL;
    1719. 

  1719. PFNGLGETMINMAXEXTPROC __glewGetMinmaxEXT = NULL;
    1720. 

  1720. PFNGLGETMINMAXPARAMETERFVEXTPROC __glewGetMinmaxParameterfvEXT = NULL;
    1721. 

  1721. PFNGLGETMINMAXPARAMETERIVEXTPROC __glewGetMinmaxParameterivEXT = NULL;
    1722. 

  1722. PFNGLHISTOGRAMEXTPROC __glewHistogramEXT = NULL;
    1723. 

  1723. PFNGLMINMAXEXTPROC __glewMinmaxEXT = NULL;
    1724. 

  1724. PFNGLRESETHISTOGRAMEXTPROC __glewResetHistogramEXT = NULL;
    1725. 

  1725. PFNGLRESETMINMAXEXTPROC __glewResetMinmaxEXT = NULL;
    1726. 

  1726. 

  1727. PFNGLINDEXFUNCEXTPROC __glewIndexFuncEXT = NULL;
    1728. 

  1728. 

  1729. PFNGLINDEXMATERIALEXTPROC __glewIndexMaterialEXT = NULL;
    1730. 

  1730. 

  1731. PFNGLAPPLYTEXTUREEXTPROC __glewApplyTextureEXT = NULL;
    1732. 

  1732. PFNGLTEXTURELIGHTEXTPROC __glewTextureLightEXT = NULL;
    1733. 

  1733. PFNGLTEXTUREMATERIALEXTPROC __glewTextureMaterialEXT = NULL;
    1734. 

  1734. 

  1735. PFNGLMULTIDRAWARRAYSEXTPROC __glewMultiDrawArraysEXT = NULL;
    1736. 

  1736. PFNGLMULTIDRAWELEMENTSEXTPROC __glewMultiDrawElementsEXT = NULL;
    1737. 

  1737. 

  1738. PFNGLSAMPLEMASKEXTPROC __glewSampleMaskEXT = NULL;
    1739. 

  1739. PFNGLSAMPLEPATTERNEXTPROC __glewSamplePatternEXT = NULL;
    1740. 

  1740. 

  1741. PFNGLCOLORTABLEEXTPROC __glewColorTableEXT = NULL;
    1742. 

  1742. PFNGLGETCOLORTABLEEXTPROC __glewGetColorTableEXT = NULL;
    1743. 

  1743. PFNGLGETCOLORTABLEPARAMETERFVEXTPROC __glewGetColorTableParameterfvEXT = NULL;
    1744. 

  1744. PFNGLGETCOLORTABLEPARAMETERIVEXTPROC __glewGetColorTableParameterivEXT = NULL;
    1745. 

  1745. 

  1746. PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC __glewGetPixelTransformParameterfvEXT = NULL;
    1747. 

  1747. PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC __glewGetPixelTransformParameterivEXT = NULL;
    1748. 

  1748. PFNGLPIXELTRANSFORMPARAMETERFEXTPROC __glewPixelTransformParameterfEXT = NULL;
    1749. 

  1749. PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC __glewPixelTransformParameterfvEXT = NULL;
    1750. 

  1750. PFNGLPIXELTRANSFORMPARAMETERIEXTPROC __glewPixelTransformParameteriEXT = NULL;
    1751. 

  1751. PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC __glewPixelTransformParameterivEXT = NULL;
    1752. 

  1752. 

  1753. PFNGLPOINTPARAMETERFEXTPROC __glewPointParameterfEXT = NULL;
    1754. 

  1754. PFNGLPOINTPARAMETERFVEXTPROC __glewPointParameterfvEXT = NULL;
    1755. 

  1755. 

  1756. PFNGLPOLYGONOFFSETEXTPROC __glewPolygonOffsetEXT = NULL;
    1757. 

  1757. 

  1758. PFNGLPROVOKINGVERTEXEXTPROC __glewProvokingVertexEXT = NULL;
    1759. 

  1759. 

  1760. PFNGLBEGINSCENEEXTPROC __glewBeginSceneEXT = NULL;
    1761. 

  1761. PFNGLENDSCENEEXTPROC __glewEndSceneEXT = NULL;
    1762. 

  1762. 

  1763. PFNGLSECONDARYCOLOR3BEXTPROC __glewSecondaryColor3bEXT = NULL;
    1764. 

  1764. PFNGLSECONDARYCOLOR3BVEXTPROC __glewSecondaryColor3bvEXT = NULL;
    1765. 

  1765. PFNGLSECONDARYCOLOR3DEXTPROC __glewSecondaryColor3dEXT = NULL;
    1766. 

  1766. PFNGLSECONDARYCOLOR3DVEXTPROC __glewSecondaryColor3dvEXT = NULL;
    1767. 

  1767. PFNGLSECONDARYCOLOR3FEXTPROC __glewSecondaryColor3fEXT = NULL;
    1768. 

  1768. PFNGLSECONDARYCOLOR3FVEXTPROC __glewSecondaryColor3fvEXT = NULL;
    1769. 

  1769. PFNGLSECONDARYCOLOR3IEXTPROC __glewSecondaryColor3iEXT = NULL;
    1770. 

  1770. PFNGLSECONDARYCOLOR3IVEXTPROC __glewSecondaryColor3ivEXT = NULL;
    1771. 

  1771. PFNGLSECONDARYCOLOR3SEXTPROC __glewSecondaryColor3sEXT = NULL;
    1772. 

  1772. PFNGLSECONDARYCOLOR3SVEXTPROC __glewSecondaryColor3svEXT = NULL;
    1773. 

  1773. PFNGLSECONDARYCOLOR3UBEXTPROC __glewSecondaryColor3ubEXT = NULL;
    1774. 

  1774. PFNGLSECONDARYCOLOR3UBVEXTPROC __glewSecondaryColor3ubvEXT = NULL;
    1775. 

  1775. PFNGLSECONDARYCOLOR3UIEXTPROC __glewSecondaryColor3uiEXT = NULL;
    1776. 

  1776. PFNGLSECONDARYCOLOR3UIVEXTPROC __glewSecondaryColor3uivEXT = NULL;
    1777. 

  1777. PFNGLSECONDARYCOLOR3USEXTPROC __glewSecondaryColor3usEXT = NULL;
    1778. 

  1778. PFNGLSECONDARYCOLOR3USVEXTPROC __glewSecondaryColor3usvEXT = NULL;
    1779. 

  1779. PFNGLSECONDARYCOLORPOINTEREXTPROC __glewSecondaryColorPointerEXT = NULL;
    1780. 

  1780. 

  1781. PFNGLACTIVEPROGRAMEXTPROC __glewActiveProgramEXT = NULL;
    1782. 

  1782. PFNGLCREATESHADERPROGRAMEXTPROC __glewCreateShaderProgramEXT = NULL;
    1783. 

  1783. PFNGLUSESHADERPROGRAMEXTPROC __glewUseShaderProgramEXT = NULL;
    1784. 

  1784. 

  1785. PFNGLBINDIMAGETEXTUREEXTPROC __glewBindImageTextureEXT = NULL;
    1786. 

  1786. PFNGLMEMORYBARRIEREXTPROC __glewMemoryBarrierEXT = NULL;
    1787. 

  1787. 

  1788. PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT = NULL;
    1789. 

  1789. 

  1790. PFNGLTEXSUBIMAGE1DEXTPROC __glewTexSubImage1DEXT = NULL;
    1791. 

  1791. PFNGLTEXSUBIMAGE2DEXTPROC __glewTexSubImage2DEXT = NULL;
    1792. 

  1792. PFNGLTEXSUBIMAGE3DEXTPROC __glewTexSubImage3DEXT = NULL;
    1793. 

  1793. 

  1794. PFNGLTEXIMAGE3DEXTPROC __glewTexImage3DEXT = NULL;
    1795. 

  1795. 

  1796. PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC __glewFramebufferTextureLayerEXT = NULL;
    1797. 

  1797. 

  1798. PFNGLTEXBUFFEREXTPROC __glewTexBufferEXT = NULL;
    1799. 

  1799. 

  1800. PFNGLCLEARCOLORIIEXTPROC __glewClearColorIiEXT = NULL;
    1801. 

  1801. PFNGLCLEARCOLORIUIEXTPROC __glewClearColorIuiEXT = NULL;
    1802. 

  1802. PFNGLGETTEXPARAMETERIIVEXTPROC __glewGetTexParameterIivEXT = NULL;
    1803. 

  1803. PFNGLGETTEXPARAMETERIUIVEXTPROC __glewGetTexParameterIuivEXT = NULL;
    1804. 

  1804. PFNGLTEXPARAMETERIIVEXTPROC __glewTexParameterIivEXT = NULL;
    1805. 

  1805. PFNGLTEXPARAMETERIUIVEXTPROC __glewTexParameterIuivEXT = NULL;
    1806. 

  1806. 

  1807. PFNGLARETEXTURESRESIDENTEXTPROC __glewAreTexturesResidentEXT = NULL;
    1808. 

  1808. PFNGLBINDTEXTUREEXTPROC __glewBindTextureEXT = NULL;
    1809. 

  1809. PFNGLDELETETEXTURESEXTPROC __glewDeleteTexturesEXT = NULL;
    1810. 

  1810. PFNGLGENTEXTURESEXTPROC __glewGenTexturesEXT = NULL;
    1811. 

  1811. PFNGLISTEXTUREEXTPROC __glewIsTextureEXT = NULL;
    1812. 

  1812. PFNGLPRIORITIZETEXTURESEXTPROC __glewPrioritizeTexturesEXT = NULL;
    1813. 

  1813. 

  1814. PFNGLTEXTURENORMALEXTPROC __glewTextureNormalEXT = NULL;
    1815. 

  1815. 

  1816. PFNGLGETQUERYOBJECTI64VEXTPROC __glewGetQueryObjecti64vEXT = NULL;
    1817. 

  1817. PFNGLGETQUERYOBJECTUI64VEXTPROC __glewGetQueryObjectui64vEXT = NULL;
    1818. 

  1818. 

  1819. PFNGLBEGINTRANSFORMFEEDBACKEXTPROC __glewBeginTransformFeedbackEXT = NULL;
    1820. 

  1820. PFNGLBINDBUFFERBASEEXTPROC __glewBindBufferBaseEXT = NULL;
    1821. 

  1821. PFNGLBINDBUFFEROFFSETEXTPROC __glewBindBufferOffsetEXT = NULL;
    1822. 

  1822. PFNGLBINDBUFFERRANGEEXTPROC __glewBindBufferRangeEXT = NULL;
    1823. 

  1823. PFNGLENDTRANSFORMFEEDBACKEXTPROC __glewEndTransformFeedbackEXT = NULL;
    1824. 

  1824. PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC __glewGetTransformFeedbackVaryingEXT = NULL;
    1825. 

  1825. PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC __glewTransformFeedbackVaryingsEXT = NULL;
    1826. 

  1826. 

  1827. PFNGLARRAYELEMENTEXTPROC __glewArrayElementEXT = NULL;
    1828. 

  1828. PFNGLCOLORPOINTEREXTPROC __glewColorPointerEXT = NULL;
    1829. 

  1829. PFNGLDRAWARRAYSEXTPROC __glewDrawArraysEXT = NULL;
    1830. 

  1830. PFNGLEDGEFLAGPOINTEREXTPROC __glewEdgeFlagPointerEXT = NULL;
    1831. 

  1831. PFNGLINDEXPOINTEREXTPROC __glewIndexPointerEXT = NULL;
    1832. 

  1832. PFNGLNORMALPOINTEREXTPROC __glewNormalPointerEXT = NULL;
    1833. 

  1833. PFNGLTEXCOORDPOINTEREXTPROC __glewTexCoordPointerEXT = NULL;
    1834. 

  1834. PFNGLVERTEXPOINTEREXTPROC __glewVertexPointerEXT = NULL;
    1835. 

  1835. 

  1836. PFNGLGETVERTEXATTRIBLDVEXTPROC __glewGetVertexAttribLdvEXT = NULL;
    1837. 

  1837. PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC __glewVertexArrayVertexAttribLOffsetEXT = NULL;
    1838. 

  1838. PFNGLVERTEXATTRIBL1DEXTPROC __glewVertexAttribL1dEXT = NULL;
    1839. 

  1839. PFNGLVERTEXATTRIBL1DVEXTPROC __glewVertexAttribL1dvEXT = NULL;
    1840. 

  1840. PFNGLVERTEXATTRIBL2DEXTPROC __glewVertexAttribL2dEXT = NULL;
    1841. 

  1841. PFNGLVERTEXATTRIBL2DVEXTPROC __glewVertexAttribL2dvEXT = NULL;
    1842. 

  1842. PFNGLVERTEXATTRIBL3DEXTPROC __glewVertexAttribL3dEXT = NULL;
    1843. 

  1843. PFNGLVERTEXATTRIBL3DVEXTPROC __glewVertexAttribL3dvEXT = NULL;
    1844. 

  1844. PFNGLVERTEXATTRIBL4DEXTPROC __glewVertexAttribL4dEXT = NULL;
    1845. 

  1845. PFNGLVERTEXATTRIBL4DVEXTPROC __glewVertexAttribL4dvEXT = NULL;
    1846. 

  1846. PFNGLVERTEXATTRIBLPOINTEREXTPROC __glewVertexAttribLPointerEXT = NULL;
    1847. 

  1847. 

  1848. PFNGLBEGINVERTEXSHADEREXTPROC __glewBeginVertexShaderEXT = NULL;
    1849. 

  1849. PFNGLBINDLIGHTPARAMETEREXTPROC __glewBindLightParameterEXT = NULL;
    1850. 

  1850. PFNGLBINDMATERIALPARAMETEREXTPROC __glewBindMaterialParameterEXT = NULL;
    1851. 

  1851. PFNGLBINDPARAMETEREXTPROC __glewBindParameterEXT = NULL;
    1852. 

  1852. PFNGLBINDTEXGENPARAMETEREXTPROC __glewBindTexGenParameterEXT = NULL;
    1853. 

  1853. PFNGLBINDTEXTUREUNITPARAMETEREXTPROC __glewBindTextureUnitParameterEXT = NULL;
    1854. 

  1854. PFNGLBINDVERTEXSHADEREXTPROC __glewBindVertexShaderEXT = NULL;
    1855. 

  1855. PFNGLDELETEVERTEXSHADEREXTPROC __glewDeleteVertexShaderEXT = NULL;
    1856. 

  1856. PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC __glewDisableVariantClientStateEXT = NULL;
    1857. 

  1857. PFNGLENABLEVARIANTCLIENTSTATEEXTPROC __glewEnableVariantClientStateEXT = NULL;
    1858. 

  1858. PFNGLENDVERTEXSHADEREXTPROC __glewEndVertexShaderEXT = NULL;
    1859. 

  1859. PFNGLEXTRACTCOMPONENTEXTPROC __glewExtractComponentEXT = NULL;
    1860. 

  1860. PFNGLGENSYMBOLSEXTPROC __glewGenSymbolsEXT = NULL;
    1861. 

  1861. PFNGLGENVERTEXSHADERSEXTPROC __glewGenVertexShadersEXT = NULL;
    1862. 

  1862. PFNGLGETINVARIANTBOOLEANVEXTPROC __glewGetInvariantBooleanvEXT = NULL;
    1863. 

  1863. PFNGLGETINVARIANTFLOATVEXTPROC __glewGetInvariantFloatvEXT = NULL;
    1864. 

  1864. PFNGLGETINVARIANTINTEGERVEXTPROC __glewGetInvariantIntegervEXT = NULL;
    1865. 

  1865. PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC __glewGetLocalConstantBooleanvEXT = NULL;
    1866. 

  1866. PFNGLGETLOCALCONSTANTFLOATVEXTPROC __glewGetLocalConstantFloatvEXT = NULL;
    1867. 

  1867. PFNGLGETLOCALCONSTANTINTEGERVEXTPROC __glewGetLocalConstantIntegervEXT = NULL;
    1868. 

  1868. PFNGLGETVARIANTBOOLEANVEXTPROC __glewGetVariantBooleanvEXT = NULL;
    1869. 

  1869. PFNGLGETVARIANTFLOATVEXTPROC __glewGetVariantFloatvEXT = NULL;
    1870. 

  1870. PFNGLGETVARIANTINTEGERVEXTPROC __glewGetVariantIntegervEXT = NULL;
    1871. 

  1871. PFNGLGETVARIANTPOINTERVEXTPROC __glewGetVariantPointervEXT = NULL;
    1872. 

  1872. PFNGLINSERTCOMPONENTEXTPROC __glewInsertComponentEXT = NULL;
    1873. 

  1873. PFNGLISVARIANTENABLEDEXTPROC __glewIsVariantEnabledEXT = NULL;
    1874. 

  1874. PFNGLSETINVARIANTEXTPROC __glewSetInvariantEXT = NULL;
    1875. 

  1875. PFNGLSETLOCALCONSTANTEXTPROC __glewSetLocalConstantEXT = NULL;
    1876. 

  1876. PFNGLSHADEROP1EXTPROC __glewShaderOp1EXT = NULL;
    1877. 

  1877. PFNGLSHADEROP2EXTPROC __glewShaderOp2EXT = NULL;
    1878. 

  1878. PFNGLSHADEROP3EXTPROC __glewShaderOp3EXT = NULL;
    1879. 

  1879. PFNGLSWIZZLEEXTPROC __glewSwizzleEXT = NULL;
    1880. 

  1880. PFNGLVARIANTPOINTEREXTPROC __glewVariantPointerEXT = NULL;
    1881. 

  1881. PFNGLVARIANTBVEXTPROC __glewVariantbvEXT = NULL;
    1882. 

  1882. PFNGLVARIANTDVEXTPROC __glewVariantdvEXT = NULL;
    1883. 

  1883. PFNGLVARIANTFVEXTPROC __glewVariantfvEXT = NULL;
    1884. 

  1884. PFNGLVARIANTIVEXTPROC __glewVariantivEXT = NULL;
    1885. 

  1885. PFNGLVARIANTSVEXTPROC __glewVariantsvEXT = NULL;
    1886. 

  1886. PFNGLVARIANTUBVEXTPROC __glewVariantubvEXT = NULL;
    1887. 

  1887. PFNGLVARIANTUIVEXTPROC __glewVariantuivEXT = NULL;
    1888. 

  1888. PFNGLVARIANTUSVEXTPROC __glewVariantusvEXT = NULL;
    1889. 

  1889. PFNGLWRITEMASKEXTPROC __glewWriteMaskEXT = NULL;
    1890. 

  1890. 

  1891. PFNGLVERTEXWEIGHTPOINTEREXTPROC __glewVertexWeightPointerEXT = NULL;
    1892. 

  1892. PFNGLVERTEXWEIGHTFEXTPROC __glewVertexWeightfEXT = NULL;
    1893. 

  1893. PFNGLVERTEXWEIGHTFVEXTPROC __glewVertexWeightfvEXT = NULL;
    1894. 

  1894. 

  1895. PFNGLIMPORTSYNCEXTPROC __glewImportSyncEXT = NULL;
    1896. 

  1896. 

  1897. PFNGLFRAMETERMINATORGREMEDYPROC __glewFrameTerminatorGREMEDY = NULL;
    1898. 

  1898. 

  1899. PFNGLSTRINGMARKERGREMEDYPROC __glewStringMarkerGREMEDY = NULL;
    1900. 

  1900. 

  1901. PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC __glewGetImageTransformParameterfvHP = NULL;
    1902. 

  1902. PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC __glewGetImageTransformParameterivHP = NULL;
    1903. 

  1903. PFNGLIMAGETRANSFORMPARAMETERFHPPROC __glewImageTransformParameterfHP = NULL;
    1904. 

  1904. PFNGLIMAGETRANSFORMPARAMETERFVHPPROC __glewImageTransformParameterfvHP = NULL;
    1905. 

  1905. PFNGLIMAGETRANSFORMPARAMETERIHPPROC __glewImageTransformParameteriHP = NULL;
    1906. 

  1906. PFNGLIMAGETRANSFORMPARAMETERIVHPPROC __glewImageTransformParameterivHP = NULL;
    1907. 

  1907. 

  1908. PFNGLMULTIMODEDRAWARRAYSIBMPROC __glewMultiModeDrawArraysIBM = NULL;
    1909. 

  1909. PFNGLMULTIMODEDRAWELEMENTSIBMPROC __glewMultiModeDrawElementsIBM = NULL;
    1910. 

  1910. 

  1911. PFNGLCOLORPOINTERLISTIBMPROC __glewColorPointerListIBM = NULL;
    1912. 

  1912. PFNGLEDGEFLAGPOINTERLISTIBMPROC __glewEdgeFlagPointerListIBM = NULL;
    1913. 

  1913. PFNGLFOGCOORDPOINTERLISTIBMPROC __glewFogCoordPointerListIBM = NULL;
    1914. 

  1914. PFNGLINDEXPOINTERLISTIBMPROC __glewIndexPointerListIBM = NULL;
    1915. 

  1915. PFNGLNORMALPOINTERLISTIBMPROC __glewNormalPointerListIBM = NULL;
    1916. 

  1916. PFNGLSECONDARYCOLORPOINTERLISTIBMPROC __glewSecondaryColorPointerListIBM = NULL;
    1917. 

  1917. PFNGLTEXCOORDPOINTERLISTIBMPROC __glewTexCoordPointerListIBM = NULL;
    1918. 

  1918. PFNGLVERTEXPOINTERLISTIBMPROC __glewVertexPointerListIBM = NULL;
    1919. 

  1919. 

  1920. PFNGLCOLORPOINTERVINTELPROC __glewColorPointervINTEL = NULL;
    1921. 

  1921. PFNGLNORMALPOINTERVINTELPROC __glewNormalPointervINTEL = NULL;
    1922. 

  1922. PFNGLTEXCOORDPOINTERVINTELPROC __glewTexCoordPointervINTEL = NULL;
    1923. 

  1923. PFNGLVERTEXPOINTERVINTELPROC __glewVertexPointervINTEL = NULL;
    1924. 

  1924. 

  1925. PFNGLTEXSCISSORFUNCINTELPROC __glewTexScissorFuncINTEL = NULL;
    1926. 

  1926. PFNGLTEXSCISSORINTELPROC __glewTexScissorINTEL = NULL;
    1927. 

  1927. 

  1928. PFNGLBUFFERREGIONENABLEDPROC __glewBufferRegionEnabled = NULL;
    1929. 

  1929. PFNGLDELETEBUFFERREGIONPROC __glewDeleteBufferRegion = NULL;
    1930. 

  1930. PFNGLDRAWBUFFERREGIONPROC __glewDrawBufferRegion = NULL;
    1931. 

  1931. PFNGLNEWBUFFERREGIONPROC __glewNewBufferRegion = NULL;
    1932. 

  1932. PFNGLREADBUFFERREGIONPROC __glewReadBufferRegion = NULL;
    1933. 

  1933. 

  1934. PFNGLRESIZEBUFFERSMESAPROC __glewResizeBuffersMESA = NULL;
    1935. 

  1935. 

  1936. PFNGLWINDOWPOS2DMESAPROC __glewWindowPos2dMESA = NULL;
    1937. 

  1937. PFNGLWINDOWPOS2DVMESAPROC __glewWindowPos2dvMESA = NULL;
    1938. 

  1938. PFNGLWINDOWPOS2FMESAPROC __glewWindowPos2fMESA = NULL;
    1939. 

  1939. PFNGLWINDOWPOS2FVMESAPROC __glewWindowPos2fvMESA = NULL;
    1940. 

  1940. PFNGLWINDOWPOS2IMESAPROC __glewWindowPos2iMESA = NULL;
    1941. 

  1941. PFNGLWINDOWPOS2IVMESAPROC __glewWindowPos2ivMESA = NULL;
    1942. 

  1942. PFNGLWINDOWPOS2SMESAPROC __glewWindowPos2sMESA = NULL;
    1943. 

  1943. PFNGLWINDOWPOS2SVMESAPROC __glewWindowPos2svMESA = NULL;
    1944. 

  1944. PFNGLWINDOWPOS3DMESAPROC __glewWindowPos3dMESA = NULL;
    1945. 

  1945. PFNGLWINDOWPOS3DVMESAPROC __glewWindowPos3dvMESA = NULL;
    1946. 

  1946. PFNGLWINDOWPOS3FMESAPROC __glewWindowPos3fMESA = NULL;
    1947. 

  1947. PFNGLWINDOWPOS3FVMESAPROC __glewWindowPos3fvMESA = NULL;
    1948. 

  1948. PFNGLWINDOWPOS3IMESAPROC __glewWindowPos3iMESA = NULL;
    1949. 

  1949. PFNGLWINDOWPOS3IVMESAPROC __glewWindowPos3ivMESA = NULL;
    1950. 

  1950. PFNGLWINDOWPOS3SMESAPROC __glewWindowPos3sMESA = NULL;
    1951. 

  1951. PFNGLWINDOWPOS3SVMESAPROC __glewWindowPos3svMESA = NULL;
    1952. 

  1952. PFNGLWINDOWPOS4DMESAPROC __glewWindowPos4dMESA = NULL;
    1953. 

  1953. PFNGLWINDOWPOS4DVMESAPROC __glewWindowPos4dvMESA = NULL;
    1954. 

  1954. PFNGLWINDOWPOS4FMESAPROC __glewWindowPos4fMESA = NULL;
    1955. 

  1955. PFNGLWINDOWPOS4FVMESAPROC __glewWindowPos4fvMESA = NULL;
    1956. 

  1956. PFNGLWINDOWPOS4IMESAPROC __glewWindowPos4iMESA = NULL;
    1957. 

  1957. PFNGLWINDOWPOS4IVMESAPROC __glewWindowPos4ivMESA = NULL;
    1958. 

  1958. PFNGLWINDOWPOS4SMESAPROC __glewWindowPos4sMESA = NULL;
    1959. 

  1959. PFNGLWINDOWPOS4SVMESAPROC __glewWindowPos4svMESA = NULL;
    1960. 

  1960. 

  1961. PFNGLBEGINCONDITIONALRENDERNVPROC __glewBeginConditionalRenderNV = NULL;
    1962. 

  1962. PFNGLENDCONDITIONALRENDERNVPROC __glewEndConditionalRenderNV = NULL;
    1963. 

  1963. 

  1964. PFNGLCOPYIMAGESUBDATANVPROC __glewCopyImageSubDataNV = NULL;
    1965. 

  1965. 

  1966. PFNGLCLEARDEPTHDNVPROC __glewClearDepthdNV = NULL;
    1967. 

  1967. PFNGLDEPTHBOUNDSDNVPROC __glewDepthBoundsdNV = NULL;
    1968. 

  1968. PFNGLDEPTHRANGEDNVPROC __glewDepthRangedNV = NULL;
    1969. 

  1969. 

  1970. PFNGLEVALMAPSNVPROC __glewEvalMapsNV = NULL;
    1971. 

  1971. PFNGLGETMAPATTRIBPARAMETERFVNVPROC __glewGetMapAttribParameterfvNV = NULL;
    1972. 

  1972. PFNGLGETMAPATTRIBPARAMETERIVNVPROC __glewGetMapAttribParameterivNV = NULL;
    1973. 

  1973. PFNGLGETMAPCONTROLPOINTSNVPROC __glewGetMapControlPointsNV = NULL;
    1974. 

  1974. PFNGLGETMAPPARAMETERFVNVPROC __glewGetMapParameterfvNV = NULL;
    1975. 

  1975. PFNGLGETMAPPARAMETERIVNVPROC __glewGetMapParameterivNV = NULL;
    1976. 

  1976. PFNGLMAPCONTROLPOINTSNVPROC __glewMapControlPointsNV = NULL;
    1977. 

  1977. PFNGLMAPPARAMETERFVNVPROC __glewMapParameterfvNV = NULL;
    1978. 

  1978. PFNGLMAPPARAMETERIVNVPROC __glewMapParameterivNV = NULL;
    1979. 

  1979. 

  1980. PFNGLGETMULTISAMPLEFVNVPROC __glewGetMultisamplefvNV = NULL;
    1981. 

  1981. PFNGLSAMPLEMASKINDEXEDNVPROC __glewSampleMaskIndexedNV = NULL;
    1982. 

  1982. PFNGLTEXRENDERBUFFERNVPROC __glewTexRenderbufferNV = NULL;
    1983. 

  1983. 

  1984. PFNGLDELETEFENCESNVPROC __glewDeleteFencesNV = NULL;
    1985. 

  1985. PFNGLFINISHFENCENVPROC __glewFinishFenceNV = NULL;
    1986. 

  1986. PFNGLGENFENCESNVPROC __glewGenFencesNV = NULL;
    1987. 

  1987. PFNGLGETFENCEIVNVPROC __glewGetFenceivNV = NULL;
    1988. 

  1988. PFNGLISFENCENVPROC __glewIsFenceNV = NULL;
    1989. 

  1989. PFNGLSETFENCENVPROC __glewSetFenceNV = NULL;
    1990. 

  1990. PFNGLTESTFENCENVPROC __glewTestFenceNV = NULL;
    1991. 

  1991. 

  1992. PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC __glewGetProgramNamedParameterdvNV = NULL;
    1993. 

  1993. PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC __glewGetProgramNamedParameterfvNV = NULL;
    1994. 

  1994. PFNGLPROGRAMNAMEDPARAMETER4DNVPROC __glewProgramNamedParameter4dNV = NULL;
    1995. 

  1995. PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC __glewProgramNamedParameter4dvNV = NULL;
    1996. 

  1996. PFNGLPROGRAMNAMEDPARAMETER4FNVPROC __glewProgramNamedParameter4fNV = NULL;
    1997. 

  1997. PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC __glewProgramNamedParameter4fvNV = NULL;
    1998. 

  1998. 

  1999. PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC __glewRenderbufferStorageMultisampleCoverageNV = NULL;
    2000. 

  2000. 

  2001. PFNGLPROGRAMVERTEXLIMITNVPROC __glewProgramVertexLimitNV = NULL;
    2002. 

  2002. 

  2003. PFNGLPROGRAMENVPARAMETERI4INVPROC __glewProgramEnvParameterI4iNV = NULL;
    2004. 

  2004. PFNGLPROGRAMENVPARAMETERI4IVNVPROC __glewProgramEnvParameterI4ivNV = NULL;
    2005. 

  2005. PFNGLPROGRAMENVPARAMETERI4UINVPROC __glewProgramEnvParameterI4uiNV = NULL;
    2006. 

  2006. PFNGLPROGRAMENVPARAMETERI4UIVNVPROC __glewProgramEnvParameterI4uivNV = NULL;
    2007. 

  2007. PFNGLPROGRAMENVPARAMETERSI4IVNVPROC __glewProgramEnvParametersI4ivNV = NULL;
    2008. 

  2008. PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC __glewProgramEnvParametersI4uivNV = NULL;
    2009. 

  2009. PFNGLPROGRAMLOCALPARAMETERI4INVPROC __glewProgramLocalParameterI4iNV = NULL;
    2010. 

  2010. PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC __glewProgramLocalParameterI4ivNV = NULL;
    2011. 

  2011. PFNGLPROGRAMLOCALPARAMETERI4UINVPROC __glewProgramLocalParameterI4uiNV = NULL;
    2012. 

  2012. PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC __glewProgramLocalParameterI4uivNV = NULL;
    2013. 

  2013. PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC __glewProgramLocalParametersI4ivNV = NULL;
    2014. 

  2014. PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC __glewProgramLocalParametersI4uivNV = NULL;
    2015. 

  2015. 

  2016. PFNGLGETUNIFORMI64VNVPROC __glewGetUniformi64vNV = NULL;
    2017. 

  2017. PFNGLGETUNIFORMUI64VNVPROC __glewGetUniformui64vNV = NULL;
    2018. 

  2018. PFNGLPROGRAMUNIFORM1I64NVPROC __glewProgramUniform1i64NV = NULL;
    2019. 

  2019. PFNGLPROGRAMUNIFORM1I64VNVPROC __glewProgramUniform1i64vNV = NULL;
    2020. 

  2020. PFNGLPROGRAMUNIFORM1UI64NVPROC __glewProgramUniform1ui64NV = NULL;
    2021. 

  2021. PFNGLPROGRAMUNIFORM1UI64VNVPROC __glewProgramUniform1ui64vNV = NULL;
    2022. 

  2022. PFNGLPROGRAMUNIFORM2I64NVPROC __glewProgramUniform2i64NV = NULL;
    2023. 

  2023. PFNGLPROGRAMUNIFORM2I64VNVPROC __glewProgramUniform2i64vNV = NULL;
    2024. 

  2024. PFNGLPROGRAMUNIFORM2UI64NVPROC __glewProgramUniform2ui64NV = NULL;
    2025. 

  2025. PFNGLPROGRAMUNIFORM2UI64VNVPROC __glewProgramUniform2ui64vNV = NULL;
    2026. 

  2026. PFNGLPROGRAMUNIFORM3I64NVPROC __glewProgramUniform3i64NV = NULL;
    2027. 

  2027. PFNGLPROGRAMUNIFORM3I64VNVPROC __glewProgramUniform3i64vNV = NULL;
    2028. 

  2028. PFNGLPROGRAMUNIFORM3UI64NVPROC __glewProgramUniform3ui64NV = NULL;
    2029. 

  2029. PFNGLPROGRAMUNIFORM3UI64VNVPROC __glewProgramUniform3ui64vNV = NULL;
    2030. 

  2030. PFNGLPROGRAMUNIFORM4I64NVPROC __glewProgramUniform4i64NV = NULL;
    2031. 

  2031. PFNGLPROGRAMUNIFORM4I64VNVPROC __glewProgramUniform4i64vNV = NULL;
    2032. 

  2032. PFNGLPROGRAMUNIFORM4UI64NVPROC __glewProgramUniform4ui64NV = NULL;
    2033. 

  2033. PFNGLPROGRAMUNIFORM4UI64VNVPROC __glewProgramUniform4ui64vNV = NULL;
    2034. 

  2034. PFNGLUNIFORM1I64NVPROC __glewUniform1i64NV = NULL;
    2035. 

  2035. PFNGLUNIFORM1I64VNVPROC __glewUniform1i64vNV = NULL;
    2036. 

  2036. PFNGLUNIFORM1UI64NVPROC __glewUniform1ui64NV = NULL;
    2037. 

  2037. PFNGLUNIFORM1UI64VNVPROC __glewUniform1ui64vNV = NULL;
    2038. 

  2038. PFNGLUNIFORM2I64NVPROC __glewUniform2i64NV = NULL;
    2039. 

  2039. PFNGLUNIFORM2I64VNVPROC __glewUniform2i64vNV = NULL;
    2040. 

  2040. PFNGLUNIFORM2UI64NVPROC __glewUniform2ui64NV = NULL;
    2041. 

  2041. PFNGLUNIFORM2UI64VNVPROC __glewUniform2ui64vNV = NULL;
    2042. 

  2042. PFNGLUNIFORM3I64NVPROC __glewUniform3i64NV = NULL;
    2043. 

  2043. PFNGLUNIFORM3I64VNVPROC __glewUniform3i64vNV = NULL;
    2044. 

  2044. PFNGLUNIFORM3UI64NVPROC __glewUniform3ui64NV = NULL;
    2045. 

  2045. PFNGLUNIFORM3UI64VNVPROC __glewUniform3ui64vNV = NULL;
    2046. 

  2046. PFNGLUNIFORM4I64NVPROC __glewUniform4i64NV = NULL;
    2047. 

  2047. PFNGLUNIFORM4I64VNVPROC __glewUniform4i64vNV = NULL;
    2048. 

  2048. PFNGLUNIFORM4UI64NVPROC __glewUniform4ui64NV = NULL;
    2049. 

  2049. PFNGLUNIFORM4UI64VNVPROC __glewUniform4ui64vNV = NULL;
    2050. 

  2050. 

  2051. PFNGLCOLOR3HNVPROC __glewColor3hNV = NULL;
    2052. 

  2052. PFNGLCOLOR3HVNVPROC __glewColor3hvNV = NULL;
    2053. 

  2053. PFNGLCOLOR4HNVPROC __glewColor4hNV = NULL;
    2054. 

  2054. PFNGLCOLOR4HVNVPROC __glewColor4hvNV = NULL;
    2055. 

  2055. PFNGLFOGCOORDHNVPROC __glewFogCoordhNV = NULL;
    2056. 

  2056. PFNGLFOGCOORDHVNVPROC __glewFogCoordhvNV = NULL;
    2057. 

  2057. PFNGLMULTITEXCOORD1HNVPROC __glewMultiTexCoord1hNV = NULL;
    2058. 

  2058. PFNGLMULTITEXCOORD1HVNVPROC __glewMultiTexCoord1hvNV = NULL;
    2059. 

  2059. PFNGLMULTITEXCOORD2HNVPROC __glewMultiTexCoord2hNV = NULL;
    2060. 

  2060. PFNGLMULTITEXCOORD2HVNVPROC __glewMultiTexCoord2hvNV = NULL;
    2061. 

  2061. PFNGLMULTITEXCOORD3HNVPROC __glewMultiTexCoord3hNV = NULL;
    2062. 

  2062. PFNGLMULTITEXCOORD3HVNVPROC __glewMultiTexCoord3hvNV = NULL;
    2063. 

  2063. PFNGLMULTITEXCOORD4HNVPROC __glewMultiTexCoord4hNV = NULL;
    2064. 

  2064. PFNGLMULTITEXCOORD4HVNVPROC __glewMultiTexCoord4hvNV = NULL;
    2065. 

  2065. PFNGLNORMAL3HNVPROC __glewNormal3hNV = NULL;
    2066. 

  2066. PFNGLNORMAL3HVNVPROC __glewNormal3hvNV = NULL;
    2067. 

  2067. PFNGLSECONDARYCOLOR3HNVPROC __glewSecondaryColor3hNV = NULL;
    2068. 

  2068. PFNGLSECONDARYCOLOR3HVNVPROC __glewSecondaryColor3hvNV = NULL;
    2069. 

  2069. PFNGLTEXCOORD1HNVPROC __glewTexCoord1hNV = NULL;
    2070. 

  2070. PFNGLTEXCOORD1HVNVPROC __glewTexCoord1hvNV = NULL;
    2071. 

  2071. PFNGLTEXCOORD2HNVPROC __glewTexCoord2hNV = NULL;
    2072. 

  2072. PFNGLTEXCOORD2HVNVPROC __glewTexCoord2hvNV = NULL;
    2073. 

  2073. PFNGLTEXCOORD3HNVPROC __glewTexCoord3hNV = NULL;
    2074. 

  2074. PFNGLTEXCOORD3HVNVPROC __glewTexCoord3hvNV = NULL;
    2075. 

  2075. PFNGLTEXCOORD4HNVPROC __glewTexCoord4hNV = NULL;
    2076. 

  2076. PFNGLTEXCOORD4HVNVPROC __glewTexCoord4hvNV = NULL;
    2077. 

  2077. PFNGLVERTEX2HNVPROC __glewVertex2hNV = NULL;
    2078. 

  2078. PFNGLVERTEX2HVNVPROC __glewVertex2hvNV = NULL;
    2079. 

  2079. PFNGLVERTEX3HNVPROC __glewVertex3hNV = NULL;
    2080. 

  2080. PFNGLVERTEX3HVNVPROC __glewVertex3hvNV = NULL;
    2081. 

  2081. PFNGLVERTEX4HNVPROC __glewVertex4hNV = NULL;
    2082. 

  2082. PFNGLVERTEX4HVNVPROC __glewVertex4hvNV = NULL;
    2083. 

  2083. PFNGLVERTEXATTRIB1HNVPROC __glewVertexAttrib1hNV = NULL;
    2084. 

  2084. PFNGLVERTEXATTRIB1HVNVPROC __glewVertexAttrib1hvNV = NULL;
    2085. 

  2085. PFNGLVERTEXATTRIB2HNVPROC __glewVertexAttrib2hNV = NULL;
    2086. 

  2086. PFNGLVERTEXATTRIB2HVNVPROC __glewVertexAttrib2hvNV = NULL;
    2087. 

  2087. PFNGLVERTEXATTRIB3HNVPROC __glewVertexAttrib3hNV = NULL;
    2088. 

  2088. PFNGLVERTEXATTRIB3HVNVPROC __glewVertexAttrib3hvNV = NULL;
    2089. 

  2089. PFNGLVERTEXATTRIB4HNVPROC __glewVertexAttrib4hNV = NULL;
    2090. 

  2090. PFNGLVERTEXATTRIB4HVNVPROC __glewVertexAttrib4hvNV = NULL;
    2091. 

  2091. PFNGLVERTEXATTRIBS1HVNVPROC __glewVertexAttribs1hvNV = NULL;
    2092. 

  2092. PFNGLVERTEXATTRIBS2HVNVPROC __glewVertexAttribs2hvNV = NULL;
    2093. 

  2093. PFNGLVERTEXATTRIBS3HVNVPROC __glewVertexAttribs3hvNV = NULL;
    2094. 

  2094. PFNGLVERTEXATTRIBS4HVNVPROC __glewVertexAttribs4hvNV = NULL;
    2095. 

  2095. PFNGLVERTEXWEIGHTHNVPROC __glewVertexWeighthNV = NULL;
    2096. 

  2096. PFNGLVERTEXWEIGHTHVNVPROC __glewVertexWeighthvNV = NULL;
    2097. 

  2097. 

  2098. PFNGLBEGINOCCLUSIONQUERYNVPROC __glewBeginOcclusionQueryNV = NULL;
    2099. 

  2099. PFNGLDELETEOCCLUSIONQUERIESNVPROC __glewDeleteOcclusionQueriesNV = NULL;
    2100. 

  2100. PFNGLENDOCCLUSIONQUERYNVPROC __glewEndOcclusionQueryNV = NULL;
    2101. 

  2101. PFNGLGENOCCLUSIONQUERIESNVPROC __glewGenOcclusionQueriesNV = NULL;
    2102. 

  2102. PFNGLGETOCCLUSIONQUERYIVNVPROC __glewGetOcclusionQueryivNV = NULL;
    2103. 

  2103. PFNGLGETOCCLUSIONQUERYUIVNVPROC __glewGetOcclusionQueryuivNV = NULL;
    2104. 

  2104. PFNGLISOCCLUSIONQUERYNVPROC __glewIsOcclusionQueryNV = NULL;
    2105. 

  2105. 

  2106. PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC __glewProgramBufferParametersIivNV = NULL;
    2107. 

  2107. PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC __glewProgramBufferParametersIuivNV = NULL;
    2108. 

  2108. PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC __glewProgramBufferParametersfvNV = NULL;
    2109. 

  2109. 

  2110. PFNGLCOPYPATHNVPROC __glewCopyPathNV = NULL;
    2111. 

  2111. PFNGLCOVERFILLPATHINSTANCEDNVPROC __glewCoverFillPathInstancedNV = NULL;
    2112. 

  2112. PFNGLCOVERFILLPATHNVPROC __glewCoverFillPathNV = NULL;
    2113. 

  2113. PFNGLCOVERSTROKEPATHINSTANCEDNVPROC __glewCoverStrokePathInstancedNV = NULL;
    2114. 

  2114. PFNGLCOVERSTROKEPATHNVPROC __glewCoverStrokePathNV = NULL;
    2115. 

  2115. PFNGLDELETEPATHSNVPROC __glewDeletePathsNV = NULL;
    2116. 

  2116. PFNGLGENPATHSNVPROC __glewGenPathsNV = NULL;
    2117. 

  2117. PFNGLGETPATHCOLORGENFVNVPROC __glewGetPathColorGenfvNV = NULL;
    2118. 

  2118. PFNGLGETPATHCOLORGENIVNVPROC __glewGetPathColorGenivNV = NULL;
    2119. 

  2119. PFNGLGETPATHCOMMANDSNVPROC __glewGetPathCommandsNV = NULL;
    2120. 

  2120. PFNGLGETPATHCOORDSNVPROC __glewGetPathCoordsNV = NULL;
    2121. 

  2121. PFNGLGETPATHDASHARRAYNVPROC __glewGetPathDashArrayNV = NULL;
    2122. 

  2122. PFNGLGETPATHLENGTHNVPROC __glewGetPathLengthNV = NULL;
    2123. 

  2123. PFNGLGETPATHMETRICRANGENVPROC __glewGetPathMetricRangeNV = NULL;
    2124. 

  2124. PFNGLGETPATHMETRICSNVPROC __glewGetPathMetricsNV = NULL;
    2125. 

  2125. PFNGLGETPATHPARAMETERFVNVPROC __glewGetPathParameterfvNV = NULL;
    2126. 

  2126. PFNGLGETPATHPARAMETERIVNVPROC __glewGetPathParameterivNV = NULL;
    2127. 

  2127. PFNGLGETPATHSPACINGNVPROC __glewGetPathSpacingNV = NULL;
    2128. 

  2128. PFNGLGETPATHTEXGENFVNVPROC __glewGetPathTexGenfvNV = NULL;
    2129. 

  2129. PFNGLGETPATHTEXGENIVNVPROC __glewGetPathTexGenivNV = NULL;
    2130. 

  2130. PFNGLINTERPOLATEPATHSNVPROC __glewInterpolatePathsNV = NULL;
    2131. 

  2131. PFNGLISPATHNVPROC __glewIsPathNV = NULL;
    2132. 

  2132. PFNGLISPOINTINFILLPATHNVPROC __glewIsPointInFillPathNV = NULL;
    2133. 

  2133. PFNGLISPOINTINSTROKEPATHNVPROC __glewIsPointInStrokePathNV = NULL;
    2134. 

  2134. PFNGLPATHCOLORGENNVPROC __glewPathColorGenNV = NULL;
    2135. 

  2135. PFNGLPATHCOMMANDSNVPROC __glewPathCommandsNV = NULL;
    2136. 

  2136. PFNGLPATHCOORDSNVPROC __glewPathCoordsNV = NULL;
    2137. 

  2137. PFNGLPATHCOVERDEPTHFUNCNVPROC __glewPathCoverDepthFuncNV = NULL;
    2138. 

  2138. PFNGLPATHDASHARRAYNVPROC __glewPathDashArrayNV = NULL;
    2139. 

  2139. PFNGLPATHFOGGENNVPROC __glewPathFogGenNV = NULL;
    2140. 

  2140. PFNGLPATHGLYPHRANGENVPROC __glewPathGlyphRangeNV = NULL;
    2141. 

  2141. PFNGLPATHGLYPHSNVPROC __glewPathGlyphsNV = NULL;
    2142. 

  2142. PFNGLPATHPARAMETERFNVPROC __glewPathParameterfNV = NULL;
    2143. 

  2143. PFNGLPATHPARAMETERFVNVPROC __glewPathParameterfvNV = NULL;
    2144. 

  2144. PFNGLPATHPARAMETERINVPROC __glewPathParameteriNV = NULL;
    2145. 

  2145. PFNGLPATHPARAMETERIVNVPROC __glewPathParameterivNV = NULL;
    2146. 

  2146. PFNGLPATHSTENCILDEPTHOFFSETNVPROC __glewPathStencilDepthOffsetNV = NULL;
    2147. 

  2147. PFNGLPATHSTENCILFUNCNVPROC __glewPathStencilFuncNV = NULL;
    2148. 

  2148. PFNGLPATHSTRINGNVPROC __glewPathStringNV = NULL;
    2149. 

  2149. PFNGLPATHSUBCOMMANDSNVPROC __glewPathSubCommandsNV = NULL;
    2150. 

  2150. PFNGLPATHSUBCOORDSNVPROC __glewPathSubCoordsNV = NULL;
    2151. 

  2151. PFNGLPATHTEXGENNVPROC __glewPathTexGenNV = NULL;
    2152. 

  2152. PFNGLPOINTALONGPATHNVPROC __glewPointAlongPathNV = NULL;
    2153. 

  2153. PFNGLSTENCILFILLPATHINSTANCEDNVPROC __glewStencilFillPathInstancedNV = NULL;
    2154. 

  2154. PFNGLSTENCILFILLPATHNVPROC __glewStencilFillPathNV = NULL;
    2155. 

  2155. PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC __glewStencilStrokePathInstancedNV = NULL;
    2156. 

  2156. PFNGLSTENCILSTROKEPATHNVPROC __glewStencilStrokePathNV = NULL;
    2157. 

  2157. PFNGLTRANSFORMPATHNVPROC __glewTransformPathNV = NULL;
    2158. 

  2158. PFNGLWEIGHTPATHSNVPROC __glewWeightPathsNV = NULL;
    2159. 

  2159. 

  2160. PFNGLFLUSHPIXELDATARANGENVPROC __glewFlushPixelDataRangeNV = NULL;
    2161. 

  2161. PFNGLPIXELDATARANGENVPROC __glewPixelDataRangeNV = NULL;
    2162. 

  2162. 

  2163. PFNGLPOINTPARAMETERINVPROC __glewPointParameteriNV = NULL;
    2164. 

  2164. PFNGLPOINTPARAMETERIVNVPROC __glewPointParameterivNV = NULL;
    2165. 

  2165. 

  2166. PFNGLGETVIDEOI64VNVPROC __glewGetVideoi64vNV = NULL;
    2167. 

  2167. PFNGLGETVIDEOIVNVPROC __glewGetVideoivNV = NULL;
    2168. 

  2168. PFNGLGETVIDEOUI64VNVPROC __glewGetVideoui64vNV = NULL;
    2169. 

  2169. PFNGLGETVIDEOUIVNVPROC __glewGetVideouivNV = NULL;
    2170. 

  2170. PFNGLPRESENTFRAMEDUALFILLNVPROC __glewPresentFrameDualFillNV = NULL;
    2171. 

  2171. PFNGLPRESENTFRAMEKEYEDNVPROC __glewPresentFrameKeyedNV = NULL;
    2172. 

  2172. 

  2173. PFNGLPRIMITIVERESTARTINDEXNVPROC __glewPrimitiveRestartIndexNV = NULL;
    2174. 

  2174. PFNGLPRIMITIVERESTARTNVPROC __glewPrimitiveRestartNV = NULL;
    2175. 

  2175. 

  2176. PFNGLCOMBINERINPUTNVPROC __glewCombinerInputNV = NULL;
    2177. 

  2177. PFNGLCOMBINEROUTPUTNVPROC __glewCombinerOutputNV = NULL;
    2178. 

  2178. PFNGLCOMBINERPARAMETERFNVPROC __glewCombinerParameterfNV = NULL;
    2179. 

  2179. PFNGLCOMBINERPARAMETERFVNVPROC __glewCombinerParameterfvNV = NULL;
    2180. 

  2180. PFNGLCOMBINERPARAMETERINVPROC __glewCombinerParameteriNV = NULL;
    2181. 

  2181. PFNGLCOMBINERPARAMETERIVNVPROC __glewCombinerParameterivNV = NULL;
    2182. 

  2182. PFNGLFINALCOMBINERINPUTNVPROC __glewFinalCombinerInputNV = NULL;
    2183. 

  2183. PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC __glewGetCombinerInputParameterfvNV = NULL;
    2184. 

  2184. PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC __glewGetCombinerInputParameterivNV = NULL;
    2185. 

  2185. PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC __glewGetCombinerOutputParameterfvNV = NULL;
    2186. 

  2186. PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC __glewGetCombinerOutputParameterivNV = NULL;
    2187. 

  2187. PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC __glewGetFinalCombinerInputParameterfvNV = NULL;
    2188. 

  2188. PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC __glewGetFinalCombinerInputParameterivNV = NULL;
    2189. 

  2189. 

  2190. PFNGLCOMBINERSTAGEPARAMETERFVNVPROC __glewCombinerStageParameterfvNV = NULL;
    2191. 

  2191. PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC __glewGetCombinerStageParameterfvNV = NULL;
    2192. 

  2192. 

  2193. PFNGLGETBUFFERPARAMETERUI64VNVPROC __glewGetBufferParameterui64vNV = NULL;
    2194. 

  2194. PFNGLGETINTEGERUI64VNVPROC __glewGetIntegerui64vNV = NULL;
    2195. 

  2195. PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC __glewGetNamedBufferParameterui64vNV = NULL;
    2196. 

  2196. PFNGLISBUFFERRESIDENTNVPROC __glewIsBufferResidentNV = NULL;
    2197. 

  2197. PFNGLISNAMEDBUFFERRESIDENTNVPROC __glewIsNamedBufferResidentNV = NULL;
    2198. 

  2198. PFNGLMAKEBUFFERNONRESIDENTNVPROC __glewMakeBufferNonResidentNV = NULL;
    2199. 

  2199. PFNGLMAKEBUFFERRESIDENTNVPROC __glewMakeBufferResidentNV = NULL;
    2200. 

  2200. PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC __glewMakeNamedBufferNonResidentNV = NULL;
    2201. 

  2201. PFNGLMAKENAMEDBUFFERRESIDENTNVPROC __glewMakeNamedBufferResidentNV = NULL;
    2202. 

  2202. PFNGLPROGRAMUNIFORMUI64NVPROC __glewProgramUniformui64NV = NULL;
    2203. 

  2203. PFNGLPROGRAMUNIFORMUI64VNVPROC __glewProgramUniformui64vNV = NULL;
    2204. 

  2204. PFNGLUNIFORMUI64NVPROC __glewUniformui64NV = NULL;
    2205. 

  2205. PFNGLUNIFORMUI64VNVPROC __glewUniformui64vNV = NULL;
    2206. 

  2206. 

  2207. PFNGLTEXTUREBARRIERNVPROC __glewTextureBarrierNV = NULL;
    2208. 

  2208. 

  2209. PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC __glewTexImage2DMultisampleCoverageNV = NULL;
    2210. 

  2210. PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTexImage3DMultisampleCoverageNV = NULL;
    2211. 

  2211. PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC __glewTextureImage2DMultisampleCoverageNV = NULL;
    2212. 

  2212. PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC __glewTextureImage2DMultisampleNV = NULL;
    2213. 

  2213. PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC __glewTextureImage3DMultisampleCoverageNV = NULL;
    2214. 

  2214. PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC __glewTextureImage3DMultisampleNV = NULL;
    2215. 

  2215. 

  2216. PFNGLACTIVEVARYINGNVPROC __glewActiveVaryingNV = NULL;
    2217. 

  2217. PFNGLBEGINTRANSFORMFEEDBACKNVPROC __glewBeginTransformFeedbackNV = NULL;
    2218. 

  2218. PFNGLBINDBUFFERBASENVPROC __glewBindBufferBaseNV = NULL;
    2219. 

  2219. PFNGLBINDBUFFEROFFSETNVPROC __glewBindBufferOffsetNV = NULL;
    2220. 

  2220. PFNGLBINDBUFFERRANGENVPROC __glewBindBufferRangeNV = NULL;
    2221. 

  2221. PFNGLENDTRANSFORMFEEDBACKNVPROC __glewEndTransformFeedbackNV = NULL;
    2222. 

  2222. PFNGLGETACTIVEVARYINGNVPROC __glewGetActiveVaryingNV = NULL;
    2223. 

  2223. PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC __glewGetTransformFeedbackVaryingNV = NULL;
    2224. 

  2224. PFNGLGETVARYINGLOCATIONNVPROC __glewGetVaryingLocationNV = NULL;
    2225. 

  2225. PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC __glewTransformFeedbackAttribsNV = NULL;
    2226. 

  2226. PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC __glewTransformFeedbackVaryingsNV = NULL;
    2227. 

  2227. 

  2228. PFNGLBINDTRANSFORMFEEDBACKNVPROC __glewBindTransformFeedbackNV = NULL;
    2229. 

  2229. PFNGLDELETETRANSFORMFEEDBACKSNVPROC __glewDeleteTransformFeedbacksNV = NULL;
    2230. 

  2230. PFNGLDRAWTRANSFORMFEEDBACKNVPROC __glewDrawTransformFeedbackNV = NULL;
    2231. 

  2231. PFNGLGENTRANSFORMFEEDBACKSNVPROC __glewGenTransformFeedbacksNV = NULL;
    2232. 

  2232. PFNGLISTRANSFORMFEEDBACKNVPROC __glewIsTransformFeedbackNV = NULL;
    2233. 

  2233. PFNGLPAUSETRANSFORMFEEDBACKNVPROC __glewPauseTransformFeedbackNV = NULL;
    2234. 

  2234. PFNGLRESUMETRANSFORMFEEDBACKNVPROC __glewResumeTransformFeedbackNV = NULL;
    2235. 

  2235. 

  2236. PFNGLVDPAUFININVPROC __glewVDPAUFiniNV = NULL;
    2237. 

  2237. PFNGLVDPAUGETSURFACEIVNVPROC __glewVDPAUGetSurfaceivNV = NULL;
    2238. 

  2238. PFNGLVDPAUINITNVPROC __glewVDPAUInitNV = NULL;
    2239. 

  2239. PFNGLVDPAUISSURFACENVPROC __glewVDPAUIsSurfaceNV = NULL;
    2240. 

  2240. PFNGLVDPAUMAPSURFACESNVPROC __glewVDPAUMapSurfacesNV = NULL;
    2241. 

  2241. PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC __glewVDPAURegisterOutputSurfaceNV = NULL;
    2242. 

  2242. PFNGLVDPAUREGISTERVIDEOSURFACENVPROC __glewVDPAURegisterVideoSurfaceNV = NULL;
    2243. 

  2243. PFNGLVDPAUSURFACEACCESSNVPROC __glewVDPAUSurfaceAccessNV = NULL;
    2244. 

  2244. PFNGLVDPAUUNMAPSURFACESNVPROC __glewVDPAUUnmapSurfacesNV = NULL;
    2245. 

  2245. PFNGLVDPAUUNREGISTERSURFACENVPROC __glewVDPAUUnregisterSurfaceNV = NULL;
    2246. 

  2246. 

  2247. PFNGLFLUSHVERTEXARRAYRANGENVPROC __glewFlushVertexArrayRangeNV = NULL;
    2248. 

  2248. PFNGLVERTEXARRAYRANGENVPROC __glewVertexArrayRangeNV = NULL;
    2249. 

  2249. 

  2250. PFNGLGETVERTEXATTRIBLI64VNVPROC __glewGetVertexAttribLi64vNV = NULL;
    2251. 

  2251. PFNGLGETVERTEXATTRIBLUI64VNVPROC __glewGetVertexAttribLui64vNV = NULL;
    2252. 

  2252. PFNGLVERTEXATTRIBL1I64NVPROC __glewVertexAttribL1i64NV = NULL;
    2253. 

  2253. PFNGLVERTEXATTRIBL1I64VNVPROC __glewVertexAttribL1i64vNV = NULL;
    2254. 

  2254. PFNGLVERTEXATTRIBL1UI64NVPROC __glewVertexAttribL1ui64NV = NULL;
    2255. 

  2255. PFNGLVERTEXATTRIBL1UI64VNVPROC __glewVertexAttribL1ui64vNV = NULL;
    2256. 

  2256. PFNGLVERTEXATTRIBL2I64NVPROC __glewVertexAttribL2i64NV = NULL;
    2257. 

  2257. PFNGLVERTEXATTRIBL2I64VNVPROC __glewVertexAttribL2i64vNV = NULL;
    2258. 

  2258. PFNGLVERTEXATTRIBL2UI64NVPROC __glewVertexAttribL2ui64NV = NULL;
    2259. 

  2259. PFNGLVERTEXATTRIBL2UI64VNVPROC __glewVertexAttribL2ui64vNV = NULL;
    2260. 

  2260. PFNGLVERTEXATTRIBL3I64NVPROC __glewVertexAttribL3i64NV = NULL;
    2261. 

  2261. PFNGLVERTEXATTRIBL3I64VNVPROC __glewVertexAttribL3i64vNV = NULL;
    2262. 

  2262. PFNGLVERTEXATTRIBL3UI64NVPROC __glewVertexAttribL3ui64NV = NULL;
    2263. 

  2263. PFNGLVERTEXATTRIBL3UI64VNVPROC __glewVertexAttribL3ui64vNV = NULL;
    2264. 

  2264. PFNGLVERTEXATTRIBL4I64NVPROC __glewVertexAttribL4i64NV = NULL;
    2265. 

  2265. PFNGLVERTEXATTRIBL4I64VNVPROC __glewVertexAttribL4i64vNV = NULL;
    2266. 

  2266. PFNGLVERTEXATTRIBL4UI64NVPROC __glewVertexAttribL4ui64NV = NULL;
    2267. 

  2267. PFNGLVERTEXATTRIBL4UI64VNVPROC __glewVertexAttribL4ui64vNV = NULL;
    2268. 

  2268. PFNGLVERTEXATTRIBLFORMATNVPROC __glewVertexAttribLFormatNV = NULL;
    2269. 

  2269. 

  2270. PFNGLBUFFERADDRESSRANGENVPROC __glewBufferAddressRangeNV = NULL;
    2271. 

  2271. PFNGLCOLORFORMATNVPROC __glewColorFormatNV = NULL;
    2272. 

  2272. PFNGLEDGEFLAGFORMATNVPROC __glewEdgeFlagFormatNV = NULL;
    2273. 

  2273. PFNGLFOGCOORDFORMATNVPROC __glewFogCoordFormatNV = NULL;
    2274. 

  2274. PFNGLGETINTEGERUI64I_VNVPROC __glewGetIntegerui64i_vNV = NULL;
    2275. 

  2275. PFNGLINDEXFORMATNVPROC __glewIndexFormatNV = NULL;
    2276. 

  2276. PFNGLNORMALFORMATNVPROC __glewNormalFormatNV = NULL;
    2277. 

  2277. PFNGLSECONDARYCOLORFORMATNVPROC __glewSecondaryColorFormatNV = NULL;
    2278. 

  2278. PFNGLTEXCOORDFORMATNVPROC __glewTexCoordFormatNV = NULL;
    2279. 

  2279. PFNGLVERTEXATTRIBFORMATNVPROC __glewVertexAttribFormatNV = NULL;
    2280. 

  2280. PFNGLVERTEXATTRIBIFORMATNVPROC __glewVertexAttribIFormatNV = NULL;
    2281. 

  2281. PFNGLVERTEXFORMATNVPROC __glewVertexFormatNV = NULL;
    2282. 

  2282. 

  2283. PFNGLAREPROGRAMSRESIDENTNVPROC __glewAreProgramsResidentNV = NULL;
    2284. 

  2284. PFNGLBINDPROGRAMNVPROC __glewBindProgramNV = NULL;
    2285. 

  2285. PFNGLDELETEPROGRAMSNVPROC __glewDeleteProgramsNV = NULL;
    2286. 

  2286. PFNGLEXECUTEPROGRAMNVPROC __glewExecuteProgramNV = NULL;
    2287. 

  2287. PFNGLGENPROGRAMSNVPROC __glewGenProgramsNV = NULL;
    2288. 

  2288. PFNGLGETPROGRAMPARAMETERDVNVPROC __glewGetProgramParameterdvNV = NULL;
    2289. 

  2289. PFNGLGETPROGRAMPARAMETERFVNVPROC __glewGetProgramParameterfvNV = NULL;
    2290. 

  2290. PFNGLGETPROGRAMSTRINGNVPROC __glewGetProgramStringNV = NULL;
    2291. 

  2291. PFNGLGETPROGRAMIVNVPROC __glewGetProgramivNV = NULL;
    2292. 

  2292. PFNGLGETTRACKMATRIXIVNVPROC __glewGetTrackMatrixivNV = NULL;
    2293. 

  2293. PFNGLGETVERTEXATTRIBPOINTERVNVPROC __glewGetVertexAttribPointervNV = NULL;
    2294. 

  2294. PFNGLGETVERTEXATTRIBDVNVPROC __glewGetVertexAttribdvNV = NULL;
    2295. 

  2295. PFNGLGETVERTEXATTRIBFVNVPROC __glewGetVertexAttribfvNV = NULL;
    2296. 

  2296. PFNGLGETVERTEXATTRIBIVNVPROC __glewGetVertexAttribivNV = NULL;
    2297. 

  2297. PFNGLISPROGRAMNVPROC __glewIsProgramNV = NULL;
    2298. 

  2298. PFNGLLOADPROGRAMNVPROC __glewLoadProgramNV = NULL;
    2299. 

  2299. PFNGLPROGRAMPARAMETER4DNVPROC __glewProgramParameter4dNV = NULL;
    2300. 

  2300. PFNGLPROGRAMPARAMETER4DVNVPROC __glewProgramParameter4dvNV = NULL;
    2301. 

  2301. PFNGLPROGRAMPARAMETER4FNVPROC __glewProgramParameter4fNV = NULL;
    2302. 

  2302. PFNGLPROGRAMPARAMETER4FVNVPROC __glewProgramParameter4fvNV = NULL;
    2303. 

  2303. PFNGLPROGRAMPARAMETERS4DVNVPROC __glewProgramParameters4dvNV = NULL;
    2304. 

  2304. PFNGLPROGRAMPARAMETERS4FVNVPROC __glewProgramParameters4fvNV = NULL;
    2305. 

  2305. PFNGLREQUESTRESIDENTPROGRAMSNVPROC __glewRequestResidentProgramsNV = NULL;
    2306. 

  2306. PFNGLTRACKMATRIXNVPROC __glewTrackMatrixNV = NULL;
    2307. 

  2307. PFNGLVERTEXATTRIB1DNVPROC __glewVertexAttrib1dNV = NULL;
    2308. 

  2308. PFNGLVERTEXATTRIB1DVNVPROC __glewVertexAttrib1dvNV = NULL;
    2309. 

  2309. PFNGLVERTEXATTRIB1FNVPROC __glewVertexAttrib1fNV = NULL;
    2310. 

  2310. PFNGLVERTEXATTRIB1FVNVPROC __glewVertexAttrib1fvNV = NULL;
    2311. 

  2311. PFNGLVERTEXATTRIB1SNVPROC __glewVertexAttrib1sNV = NULL;
    2312. 

  2312. PFNGLVERTEXATTRIB1SVNVPROC __glewVertexAttrib1svNV = NULL;
    2313. 

  2313. PFNGLVERTEXATTRIB2DNVPROC __glewVertexAttrib2dNV = NULL;
    2314. 

  2314. PFNGLVERTEXATTRIB2DVNVPROC __glewVertexAttrib2dvNV = NULL;
    2315. 

  2315. PFNGLVERTEXATTRIB2FNVPROC __glewVertexAttrib2fNV = NULL;
    2316. 

  2316. PFNGLVERTEXATTRIB2FVNVPROC __glewVertexAttrib2fvNV = NULL;
    2317. 

  2317. PFNGLVERTEXATTRIB2SNVPROC __glewVertexAttrib2sNV = NULL;
    2318. 

  2318. PFNGLVERTEXATTRIB2SVNVPROC __glewVertexAttrib2svNV = NULL;
    2319. 

  2319. PFNGLVERTEXATTRIB3DNVPROC __glewVertexAttrib3dNV = NULL;
    2320. 

  2320. PFNGLVERTEXATTRIB3DVNVPROC __glewVertexAttrib3dvNV = NULL;
    2321. 

  2321. PFNGLVERTEXATTRIB3FNVPROC __glewVertexAttrib3fNV = NULL;
    2322. 

  2322. PFNGLVERTEXATTRIB3FVNVPROC __glewVertexAttrib3fvNV = NULL;
    2323. 

  2323. PFNGLVERTEXATTRIB3SNVPROC __glewVertexAttrib3sNV = NULL;
    2324. 

  2324. PFNGLVERTEXATTRIB3SVNVPROC __glewVertexAttrib3svNV = NULL;
    2325. 

  2325. PFNGLVERTEXATTRIB4DNVPROC __glewVertexAttrib4dNV = NULL;
    2326. 

  2326. PFNGLVERTEXATTRIB4DVNVPROC __glewVertexAttrib4dvNV = NULL;
    2327. 

  2327. PFNGLVERTEXATTRIB4FNVPROC __glewVertexAttrib4fNV = NULL;
    2328. 

  2328. PFNGLVERTEXATTRIB4FVNVPROC __glewVertexAttrib4fvNV = NULL;
    2329. 

  2329. PFNGLVERTEXATTRIB4SNVPROC __glewVertexAttrib4sNV = NULL;
    2330. 

  2330. PFNGLVERTEXATTRIB4SVNVPROC __glewVertexAttrib4svNV = NULL;
    2331. 

  2331. PFNGLVERTEXATTRIB4UBNVPROC __glewVertexAttrib4ubNV = NULL;
    2332. 

  2332. PFNGLVERTEXATTRIB4UBVNVPROC __glewVertexAttrib4ubvNV = NULL;
    2333. 

  2333. PFNGLVERTEXATTRIBPOINTERNVPROC __glewVertexAttribPointerNV = NULL;
    2334. 

  2334. PFNGLVERTEXATTRIBS1DVNVPROC __glewVertexAttribs1dvNV = NULL;
    2335. 

  2335. PFNGLVERTEXATTRIBS1FVNVPROC __glewVertexAttribs1fvNV = NULL;
    2336. 

  2336. PFNGLVERTEXATTRIBS1SVNVPROC __glewVertexAttribs1svNV = NULL;
    2337. 

  2337. PFNGLVERTEXATTRIBS2DVNVPROC __glewVertexAttribs2dvNV = NULL;
    2338. 

  2338. PFNGLVERTEXATTRIBS2FVNVPROC __glewVertexAttribs2fvNV = NULL;
    2339. 

  2339. PFNGLVERTEXATTRIBS2SVNVPROC __glewVertexAttribs2svNV = NULL;
    2340. 

  2340. PFNGLVERTEXATTRIBS3DVNVPROC __glewVertexAttribs3dvNV = NULL;
    2341. 

  2341. PFNGLVERTEXATTRIBS3FVNVPROC __glewVertexAttribs3fvNV = NULL;
    2342. 

  2342. PFNGLVERTEXATTRIBS3SVNVPROC __glewVertexAttribs3svNV = NULL;
    2343. 

  2343. PFNGLVERTEXATTRIBS4DVNVPROC __glewVertexAttribs4dvNV = NULL;
    2344. 

  2344. PFNGLVERTEXATTRIBS4FVNVPROC __glewVertexAttribs4fvNV = NULL;
    2345. 

  2345. PFNGLVERTEXATTRIBS4SVNVPROC __glewVertexAttribs4svNV = NULL;
    2346. 

  2346. PFNGLVERTEXATTRIBS4UBVNVPROC __glewVertexAttribs4ubvNV = NULL;
    2347. 

  2347. 

  2348. PFNGLBEGINVIDEOCAPTURENVPROC __glewBeginVideoCaptureNV = NULL;
    2349. 

  2349. PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC __glewBindVideoCaptureStreamBufferNV = NULL;
    2350. 

  2350. PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC __glewBindVideoCaptureStreamTextureNV = NULL;
    2351. 

  2351. PFNGLENDVIDEOCAPTURENVPROC __glewEndVideoCaptureNV = NULL;
    2352. 

  2352. PFNGLGETVIDEOCAPTURESTREAMDVNVPROC __glewGetVideoCaptureStreamdvNV = NULL;
    2353. 

  2353. PFNGLGETVIDEOCAPTURESTREAMFVNVPROC __glewGetVideoCaptureStreamfvNV = NULL;
    2354. 

  2354. PFNGLGETVIDEOCAPTURESTREAMIVNVPROC __glewGetVideoCaptureStreamivNV = NULL;
    2355. 

  2355. PFNGLGETVIDEOCAPTUREIVNVPROC __glewGetVideoCaptureivNV = NULL;
    2356. 

  2356. PFNGLVIDEOCAPTURENVPROC __glewVideoCaptureNV = NULL;
    2357. 

  2357. PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC __glewVideoCaptureStreamParameterdvNV = NULL;
    2358. 

  2358. PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC __glewVideoCaptureStreamParameterfvNV = NULL;
    2359. 

  2359. PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC __glewVideoCaptureStreamParameterivNV = NULL;
    2360. 

  2360. 

  2361. PFNGLCLEARDEPTHFOESPROC __glewClearDepthfOES = NULL;
    2362. 

  2362. PFNGLCLIPPLANEFOESPROC __glewClipPlanefOES = NULL;
    2363. 

  2363. PFNGLDEPTHRANGEFOESPROC __glewDepthRangefOES = NULL;
    2364. 

  2364. PFNGLFRUSTUMFOESPROC __glewFrustumfOES = NULL;
    2365. 

  2365. PFNGLGETCLIPPLANEFOESPROC __glewGetClipPlanefOES = NULL;
    2366. 

  2366. PFNGLORTHOFOESPROC __glewOrthofOES = NULL;
    2367. 

  2367. 

  2368. PFNGLDETAILTEXFUNCSGISPROC __glewDetailTexFuncSGIS = NULL;
    2369. 

  2369. PFNGLGETDETAILTEXFUNCSGISPROC __glewGetDetailTexFuncSGIS = NULL;
    2370. 

  2370. 

  2371. PFNGLFOGFUNCSGISPROC __glewFogFuncSGIS = NULL;
    2372. 

  2372. PFNGLGETFOGFUNCSGISPROC __glewGetFogFuncSGIS = NULL;
    2373. 

  2373. 

  2374. PFNGLSAMPLEMASKSGISPROC __glewSampleMaskSGIS = NULL;
    2375. 

  2375. PFNGLSAMPLEPATTERNSGISPROC __glewSamplePatternSGIS = NULL;
    2376. 

  2376. 

  2377. PFNGLGETSHARPENTEXFUNCSGISPROC __glewGetSharpenTexFuncSGIS = NULL;
    2378. 

  2378. PFNGLSHARPENTEXFUNCSGISPROC __glewSharpenTexFuncSGIS = NULL;
    2379. 

  2379. 

  2380. PFNGLTEXIMAGE4DSGISPROC __glewTexImage4DSGIS = NULL;
    2381. 

  2381. PFNGLTEXSUBIMAGE4DSGISPROC __glewTexSubImage4DSGIS = NULL;
    2382. 

  2382. 

  2383. PFNGLGETTEXFILTERFUNCSGISPROC __glewGetTexFilterFuncSGIS = NULL;
    2384. 

  2384. PFNGLTEXFILTERFUNCSGISPROC __glewTexFilterFuncSGIS = NULL;
    2385. 

  2385. 

  2386. PFNGLASYNCMARKERSGIXPROC __glewAsyncMarkerSGIX = NULL;
    2387. 

  2387. PFNGLDELETEASYNCMARKERSSGIXPROC __glewDeleteAsyncMarkersSGIX = NULL;
    2388. 

  2388. PFNGLFINISHASYNCSGIXPROC __glewFinishAsyncSGIX = NULL;
    2389. 

  2389. PFNGLGENASYNCMARKERSSGIXPROC __glewGenAsyncMarkersSGIX = NULL;
    2390. 

  2390. PFNGLISASYNCMARKERSGIXPROC __glewIsAsyncMarkerSGIX = NULL;
    2391. 

  2391. PFNGLPOLLASYNCSGIXPROC __glewPollAsyncSGIX = NULL;
    2392. 

  2392. 

  2393. PFNGLFLUSHRASTERSGIXPROC __glewFlushRasterSGIX = NULL;
    2394. 

  2394. 

  2395. PFNGLTEXTUREFOGSGIXPROC __glewTextureFogSGIX = NULL;
    2396. 

  2396. 

  2397. PFNGLFRAGMENTCOLORMATERIALSGIXPROC __glewFragmentColorMaterialSGIX = NULL;
    2398. 

  2398. PFNGLFRAGMENTLIGHTMODELFSGIXPROC __glewFragmentLightModelfSGIX = NULL;
    2399. 

  2399. PFNGLFRAGMENTLIGHTMODELFVSGIXPROC __glewFragmentLightModelfvSGIX = NULL;
    2400. 

  2400. PFNGLFRAGMENTLIGHTMODELISGIXPROC __glewFragmentLightModeliSGIX = NULL;
    2401. 

  2401. PFNGLFRAGMENTLIGHTMODELIVSGIXPROC __glewFragmentLightModelivSGIX = NULL;
    2402. 

  2402. PFNGLFRAGMENTLIGHTFSGIXPROC __glewFragmentLightfSGIX = NULL;
    2403. 

  2403. PFNGLFRAGMENTLIGHTFVSGIXPROC __glewFragmentLightfvSGIX = NULL;
    2404. 

  2404. PFNGLFRAGMENTLIGHTISGIXPROC __glewFragmentLightiSGIX = NULL;
    2405. 

  2405. PFNGLFRAGMENTLIGHTIVSGIXPROC __glewFragmentLightivSGIX = NULL;
    2406. 

  2406. PFNGLFRAGMENTMATERIALFSGIXPROC __glewFragmentMaterialfSGIX = NULL;
    2407. 

  2407. PFNGLFRAGMENTMATERIALFVSGIXPROC __glewFragmentMaterialfvSGIX = NULL;
    2408. 

  2408. PFNGLFRAGMENTMATERIALISGIXPROC __glewFragmentMaterialiSGIX = NULL;
    2409. 

  2409. PFNGLFRAGMENTMATERIALIVSGIXPROC __glewFragmentMaterialivSGIX = NULL;
    2410. 

  2410. PFNGLGETFRAGMENTLIGHTFVSGIXPROC __glewGetFragmentLightfvSGIX = NULL;
    2411. 

  2411. PFNGLGETFRAGMENTLIGHTIVSGIXPROC __glewGetFragmentLightivSGIX = NULL;
    2412. 

  2412. PFNGLGETFRAGMENTMATERIALFVSGIXPROC __glewGetFragmentMaterialfvSGIX = NULL;
    2413. 

  2413. PFNGLGETFRAGMENTMATERIALIVSGIXPROC __glewGetFragmentMaterialivSGIX = NULL;
    2414. 

  2414. 

  2415. PFNGLFRAMEZOOMSGIXPROC __glewFrameZoomSGIX = NULL;
    2416. 

  2416. 

  2417. PFNGLPIXELTEXGENSGIXPROC __glewPixelTexGenSGIX = NULL;
    2418. 

  2418. 

  2419. PFNGLREFERENCEPLANESGIXPROC __glewReferencePlaneSGIX = NULL;
    2420. 

  2420. 

  2421. PFNGLSPRITEPARAMETERFSGIXPROC __glewSpriteParameterfSGIX = NULL;
    2422. 

  2422. PFNGLSPRITEPARAMETERFVSGIXPROC __glewSpriteParameterfvSGIX = NULL;
    2423. 

  2423. PFNGLSPRITEPARAMETERISGIXPROC __glewSpriteParameteriSGIX = NULL;
    2424. 

  2424. PFNGLSPRITEPARAMETERIVSGIXPROC __glewSpriteParameterivSGIX = NULL;
    2425. 

  2425. 

  2426. PFNGLTAGSAMPLEBUFFERSGIXPROC __glewTagSampleBufferSGIX = NULL;
    2427. 

  2427. 

  2428. PFNGLCOLORTABLEPARAMETERFVSGIPROC __glewColorTableParameterfvSGI = NULL;
    2429. 

  2429. PFNGLCOLORTABLEPARAMETERIVSGIPROC __glewColorTableParameterivSGI = NULL;
    2430. 

  2430. PFNGLCOLORTABLESGIPROC __glewColorTableSGI = NULL;
    2431. 

  2431. PFNGLCOPYCOLORTABLESGIPROC __glewCopyColorTableSGI = NULL;
    2432. 

  2432. PFNGLGETCOLORTABLEPARAMETERFVSGIPROC __glewGetColorTableParameterfvSGI = NULL;
    2433. 

  2433. PFNGLGETCOLORTABLEPARAMETERIVSGIPROC __glewGetColorTableParameterivSGI = NULL;
    2434. 

  2434. PFNGLGETCOLORTABLESGIPROC __glewGetColorTableSGI = NULL;
    2435. 

  2435. 

  2436. PFNGLFINISHTEXTURESUNXPROC __glewFinishTextureSUNX = NULL;
    2437. 

  2437. 

  2438. PFNGLGLOBALALPHAFACTORBSUNPROC __glewGlobalAlphaFactorbSUN = NULL;
    2439. 

  2439. PFNGLGLOBALALPHAFACTORDSUNPROC __glewGlobalAlphaFactordSUN = NULL;
    2440. 

  2440. PFNGLGLOBALALPHAFACTORFSUNPROC __glewGlobalAlphaFactorfSUN = NULL;
    2441. 

  2441. PFNGLGLOBALALPHAFACTORISUNPROC __glewGlobalAlphaFactoriSUN = NULL;
    2442. 

  2442. PFNGLGLOBALALPHAFACTORSSUNPROC __glewGlobalAlphaFactorsSUN = NULL;
    2443. 

  2443. PFNGLGLOBALALPHAFACTORUBSUNPROC __glewGlobalAlphaFactorubSUN = NULL;
    2444. 

  2444. PFNGLGLOBALALPHAFACTORUISUNPROC __glewGlobalAlphaFactoruiSUN = NULL;
    2445. 

  2445. PFNGLGLOBALALPHAFACTORUSSUNPROC __glewGlobalAlphaFactorusSUN = NULL;
    2446. 

  2446. 

  2447. PFNGLREADVIDEOPIXELSSUNPROC __glewReadVideoPixelsSUN = NULL;
    2448. 

  2448. 

  2449. PFNGLREPLACEMENTCODEPOINTERSUNPROC __glewReplacementCodePointerSUN = NULL;
    2450. 

  2450. PFNGLREPLACEMENTCODEUBSUNPROC __glewReplacementCodeubSUN = NULL;
    2451. 

  2451. PFNGLREPLACEMENTCODEUBVSUNPROC __glewReplacementCodeubvSUN = NULL;
    2452. 

  2452. PFNGLREPLACEMENTCODEUISUNPROC __glewReplacementCodeuiSUN = NULL;
    2453. 

  2453. PFNGLREPLACEMENTCODEUIVSUNPROC __glewReplacementCodeuivSUN = NULL;
    2454. 

  2454. PFNGLREPLACEMENTCODEUSSUNPROC __glewReplacementCodeusSUN = NULL;
    2455. 

  2455. PFNGLREPLACEMENTCODEUSVSUNPROC __glewReplacementCodeusvSUN = NULL;
    2456. 

  2456. 

  2457. PFNGLCOLOR3FVERTEX3FSUNPROC __glewColor3fVertex3fSUN = NULL;
    2458. 

  2458. PFNGLCOLOR3FVERTEX3FVSUNPROC __glewColor3fVertex3fvSUN = NULL;
    2459. 

  2459. PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewColor4fNormal3fVertex3fSUN = NULL;
    2460. 

  2460. PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewColor4fNormal3fVertex3fvSUN = NULL;
    2461. 

  2461. PFNGLCOLOR4UBVERTEX2FSUNPROC __glewColor4ubVertex2fSUN = NULL;
    2462. 

  2462. PFNGLCOLOR4UBVERTEX2FVSUNPROC __glewColor4ubVertex2fvSUN = NULL;
    2463. 

  2463. PFNGLCOLOR4UBVERTEX3FSUNPROC __glewColor4ubVertex3fSUN = NULL;
    2464. 

  2464. PFNGLCOLOR4UBVERTEX3FVSUNPROC __glewColor4ubVertex3fvSUN = NULL;
    2465. 

  2465. PFNGLNORMAL3FVERTEX3FSUNPROC __glewNormal3fVertex3fSUN = NULL;
    2466. 

  2466. PFNGLNORMAL3FVERTEX3FVSUNPROC __glewNormal3fVertex3fvSUN = NULL;
    2467. 

  2467. PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC __glewReplacementCodeuiColor3fVertex3fSUN = NULL;
    2468. 

  2468. PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor3fVertex3fvSUN = NULL;
    2469. 

  2469. PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fSUN = NULL;
    2470. 

  2470. PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fvSUN = NULL;
    2471. 

  2471. PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC __glewReplacementCodeuiColor4ubVertex3fSUN = NULL;
    2472. 

  2472. PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC __glewReplacementCodeuiColor4ubVertex3fvSUN = NULL;
    2473. 

  2473. PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiNormal3fVertex3fSUN = NULL;
    2474. 

  2474. PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiNormal3fVertex3fvSUN = NULL;
    2475. 

  2475. PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = NULL;
    2476. 

  2476. PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = NULL;
    2477. 

  2477. PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = NULL;
    2478. 

  2478. PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = NULL;
    2479. 

  2479. PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fSUN = NULL;
    2480. 

  2480. PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fvSUN = NULL;
    2481. 

  2481. PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC __glewReplacementCodeuiVertex3fSUN = NULL;
    2482. 

  2482. PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC __glewReplacementCodeuiVertex3fvSUN = NULL;
    2483. 

  2483. PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC __glewTexCoord2fColor3fVertex3fSUN = NULL;
    2484. 

  2484. PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC __glewTexCoord2fColor3fVertex3fvSUN = NULL;
    2485. 

  2485. PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fSUN = NULL;
    2486. 

  2486. PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fvSUN = NULL;
    2487. 

  2487. PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC __glewTexCoord2fColor4ubVertex3fSUN = NULL;
    2488. 

  2488. PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC __glewTexCoord2fColor4ubVertex3fvSUN = NULL;
    2489. 

  2489. PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fNormal3fVertex3fSUN = NULL;
    2490. 

  2490. PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fNormal3fVertex3fvSUN = NULL;
    2491. 

  2491. PFNGLTEXCOORD2FVERTEX3FSUNPROC __glewTexCoord2fVertex3fSUN = NULL;
    2492. 

  2492. PFNGLTEXCOORD2FVERTEX3FVSUNPROC __glewTexCoord2fVertex3fvSUN = NULL;
    2493. 

  2493. PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fSUN = NULL;
    2494. 

  2494. PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fvSUN = NULL;
    2495. 

  2495. PFNGLTEXCOORD4FVERTEX4FSUNPROC __glewTexCoord4fVertex4fSUN = NULL;
    2496. 

  2496. PFNGLTEXCOORD4FVERTEX4FVSUNPROC __glewTexCoord4fVertex4fvSUN = NULL;
    2497. 

  2497. 

  2498. PFNGLADDSWAPHINTRECTWINPROC __glewAddSwapHintRectWIN = NULL;
    2499. 

  2499. 

  2500. #endif /* !WIN32 || !GLEW_MX */
    2501. 

  2501. 

  2502. #if !defined(GLEW_MX)
    2503. 

  2503. 

  2504. GLboolean __GLEW_VERSION_1_1 = GL_FALSE;
    2505. 

  2505. GLboolean __GLEW_VERSION_1_2 = GL_FALSE;
    2506. 

  2506. GLboolean __GLEW_VERSION_1_2_1 = GL_FALSE;
    2507. 

  2507. GLboolean __GLEW_VERSION_1_3 = GL_FALSE;
    2508. 

  2508. GLboolean __GLEW_VERSION_1_4 = GL_FALSE;
    2509. 

  2509. GLboolean __GLEW_VERSION_1_5 = GL_FALSE;
    2510. 

  2510. GLboolean __GLEW_VERSION_2_0 = GL_FALSE;
    2511. 

  2511. GLboolean __GLEW_VERSION_2_1 = GL_FALSE;
    2512. 

  2512. GLboolean __GLEW_VERSION_3_0 = GL_FALSE;
    2513. 

  2513. GLboolean __GLEW_VERSION_3_1 = GL_FALSE;
    2514. 

  2514. GLboolean __GLEW_VERSION_3_2 = GL_FALSE;
    2515. 

  2515. GLboolean __GLEW_VERSION_3_3 = GL_FALSE;
    2516. 

  2516. GLboolean __GLEW_VERSION_4_0 = GL_FALSE;
    2517. 

  2517. GLboolean __GLEW_VERSION_4_1 = GL_FALSE;
    2518. 

  2518. GLboolean __GLEW_VERSION_4_2 = GL_FALSE;
    2519. 

  2519. GLboolean __GLEW_3DFX_multisample = GL_FALSE;
    2520. 

  2520. GLboolean __GLEW_3DFX_tbuffer = GL_FALSE;
    2521. 

  2521. GLboolean __GLEW_3DFX_texture_compression_FXT1 = GL_FALSE;
    2522. 

  2522. GLboolean __GLEW_AMD_blend_minmax_factor = GL_FALSE;
    2523. 

  2523. GLboolean __GLEW_AMD_conservative_depth = GL_FALSE;
    2524. 

  2524. GLboolean __GLEW_AMD_debug_output = GL_FALSE;
    2525. 

  2525. GLboolean __GLEW_AMD_depth_clamp_separate = GL_FALSE;
    2526. 

  2526. GLboolean __GLEW_AMD_draw_buffers_blend = GL_FALSE;
    2527. 

  2527. GLboolean __GLEW_AMD_multi_draw_indirect = GL_FALSE;
    2528. 

  2528. GLboolean __GLEW_AMD_name_gen_delete = GL_FALSE;
    2529. 

  2529. GLboolean __GLEW_AMD_performance_monitor = GL_FALSE;
    2530. 

  2530. GLboolean __GLEW_AMD_sample_positions = GL_FALSE;
    2531. 

  2531. GLboolean __GLEW_AMD_seamless_cubemap_per_texture = GL_FALSE;
    2532. 

  2532. GLboolean __GLEW_AMD_shader_stencil_export = GL_FALSE;
    2533. 

  2533. GLboolean __GLEW_AMD_texture_texture4 = GL_FALSE;
    2534. 

  2534. GLboolean __GLEW_AMD_transform_feedback3_lines_triangles = GL_FALSE;
    2535. 

  2535. GLboolean __GLEW_AMD_vertex_shader_tessellator = GL_FALSE;
    2536. 

  2536. GLboolean __GLEW_APPLE_aux_depth_stencil = GL_FALSE;
    2537. 

  2537. GLboolean __GLEW_APPLE_client_storage = GL_FALSE;
    2538. 

  2538. GLboolean __GLEW_APPLE_element_array = GL_FALSE;
    2539. 

  2539. GLboolean __GLEW_APPLE_fence = GL_FALSE;
    2540. 

  2540. GLboolean __GLEW_APPLE_float_pixels = GL_FALSE;
    2541. 

  2541. GLboolean __GLEW_APPLE_flush_buffer_range = GL_FALSE;
    2542. 

  2542. GLboolean __GLEW_APPLE_object_purgeable = GL_FALSE;
    2543. 

  2543. GLboolean __GLEW_APPLE_pixel_buffer = GL_FALSE;
    2544. 

  2544. GLboolean __GLEW_APPLE_rgb_422 = GL_FALSE;
    2545. 

  2545. GLboolean __GLEW_APPLE_row_bytes = GL_FALSE;
    2546. 

  2546. GLboolean __GLEW_APPLE_specular_vector = GL_FALSE;
    2547. 

  2547. GLboolean __GLEW_APPLE_texture_range = GL_FALSE;
    2548. 

  2548. GLboolean __GLEW_APPLE_transform_hint = GL_FALSE;
    2549. 

  2549. GLboolean __GLEW_APPLE_vertex_array_object = GL_FALSE;
    2550. 

  2550. GLboolean __GLEW_APPLE_vertex_array_range = GL_FALSE;
    2551. 

  2551. GLboolean __GLEW_APPLE_vertex_program_evaluators = GL_FALSE;
    2552. 

  2552. GLboolean __GLEW_APPLE_ycbcr_422 = GL_FALSE;
    2553. 

  2553. GLboolean __GLEW_ARB_ES2_compatibility = GL_FALSE;
    2554. 

  2554. GLboolean __GLEW_ARB_base_instance = GL_FALSE;
    2555. 

  2555. GLboolean __GLEW_ARB_blend_func_extended = GL_FALSE;
    2556. 

  2556. GLboolean __GLEW_ARB_cl_event = GL_FALSE;
    2557. 

  2557. GLboolean __GLEW_ARB_color_buffer_float = GL_FALSE;
    2558. 

  2558. GLboolean __GLEW_ARB_compatibility = GL_FALSE;
    2559. 

  2559. GLboolean __GLEW_ARB_compressed_texture_pixel_storage = GL_FALSE;
    2560. 

  2560. GLboolean __GLEW_ARB_conservative_depth = GL_FALSE;
    2561. 

  2561. GLboolean __GLEW_ARB_copy_buffer = GL_FALSE;
    2562. 

  2562. GLboolean __GLEW_ARB_debug_output = GL_FALSE;
    2563. 

  2563. GLboolean __GLEW_ARB_depth_buffer_float = GL_FALSE;
    2564. 

  2564. GLboolean __GLEW_ARB_depth_clamp = GL_FALSE;
    2565. 

  2565. GLboolean __GLEW_ARB_depth_texture = GL_FALSE;
    2566. 

  2566. GLboolean __GLEW_ARB_draw_buffers = GL_FALSE;
    2567. 

  2567. GLboolean __GLEW_ARB_draw_buffers_blend = GL_FALSE;
    2568. 

  2568. GLboolean __GLEW_ARB_draw_elements_base_vertex = GL_FALSE;
    2569. 

  2569. GLboolean __GLEW_ARB_draw_indirect = GL_FALSE;
    2570. 

  2570. GLboolean __GLEW_ARB_draw_instanced = GL_FALSE;
    2571. 

  2571. GLboolean __GLEW_ARB_explicit_attrib_location = GL_FALSE;
    2572. 

  2572. GLboolean __GLEW_ARB_fragment_coord_conventions = GL_FALSE;
    2573. 

  2573. GLboolean __GLEW_ARB_fragment_program = GL_FALSE;
    2574. 

  2574. GLboolean __GLEW_ARB_fragment_program_shadow = GL_FALSE;
    2575. 

  2575. GLboolean __GLEW_ARB_fragment_shader = GL_FALSE;
    2576. 

  2576. GLboolean __GLEW_ARB_framebuffer_object = GL_FALSE;
    2577. 

  2577. GLboolean __GLEW_ARB_framebuffer_sRGB = GL_FALSE;
    2578. 

  2578. GLboolean __GLEW_ARB_geometry_shader4 = GL_FALSE;
    2579. 

  2579. GLboolean __GLEW_ARB_get_program_binary = GL_FALSE;
    2580. 

  2580. GLboolean __GLEW_ARB_gpu_shader5 = GL_FALSE;
    2581. 

  2581. GLboolean __GLEW_ARB_gpu_shader_fp64 = GL_FALSE;
    2582. 

  2582. GLboolean __GLEW_ARB_half_float_pixel = GL_FALSE;
    2583. 

  2583. GLboolean __GLEW_ARB_half_float_vertex = GL_FALSE;
    2584. 

  2584. GLboolean __GLEW_ARB_imaging = GL_FALSE;
    2585. 

  2585. GLboolean __GLEW_ARB_instanced_arrays = GL_FALSE;
    2586. 

  2586. GLboolean __GLEW_ARB_internalformat_query = GL_FALSE;
    2587. 

  2587. GLboolean __GLEW_ARB_map_buffer_alignment = GL_FALSE;
    2588. 

  2588. GLboolean __GLEW_ARB_map_buffer_range = GL_FALSE;
    2589. 

  2589. GLboolean __GLEW_ARB_matrix_palette = GL_FALSE;
    2590. 

  2590. GLboolean __GLEW_ARB_multisample = GL_FALSE;
    2591. 

  2591. GLboolean __GLEW_ARB_multitexture = GL_FALSE;
    2592. 

  2592. GLboolean __GLEW_ARB_occlusion_query = GL_FALSE;
    2593. 

  2593. GLboolean __GLEW_ARB_occlusion_query2 = GL_FALSE;
    2594. 

  2594. GLboolean __GLEW_ARB_pixel_buffer_object = GL_FALSE;
    2595. 

  2595. GLboolean __GLEW_ARB_point_parameters = GL_FALSE;
    2596. 

  2596. GLboolean __GLEW_ARB_point_sprite = GL_FALSE;
    2597. 

  2597. GLboolean __GLEW_ARB_provoking_vertex = GL_FALSE;
    2598. 

  2598. GLboolean __GLEW_ARB_robustness = GL_FALSE;
    2599. 

  2599. GLboolean __GLEW_ARB_sample_shading = GL_FALSE;
    2600. 

  2600. GLboolean __GLEW_ARB_sampler_objects = GL_FALSE;
    2601. 

  2601. GLboolean __GLEW_ARB_seamless_cube_map = GL_FALSE;
    2602. 

  2602. GLboolean __GLEW_ARB_separate_shader_objects = GL_FALSE;
    2603. 

  2603. GLboolean __GLEW_ARB_shader_atomic_counters = GL_FALSE;
    2604. 

  2604. GLboolean __GLEW_ARB_shader_bit_encoding = GL_FALSE;
    2605. 

  2605. GLboolean __GLEW_ARB_shader_image_load_store = GL_FALSE;
    2606. 

  2606. GLboolean __GLEW_ARB_shader_objects = GL_FALSE;
    2607. 

  2607. GLboolean __GLEW_ARB_shader_precision = GL_FALSE;
    2608. 

  2608. GLboolean __GLEW_ARB_shader_stencil_export = GL_FALSE;
    2609. 

  2609. GLboolean __GLEW_ARB_shader_subroutine = GL_FALSE;
    2610. 

  2610. GLboolean __GLEW_ARB_shader_texture_lod = GL_FALSE;
    2611. 

  2611. GLboolean __GLEW_ARB_shading_language_100 = GL_FALSE;
    2612. 

  2612. GLboolean __GLEW_ARB_shading_language_420pack = GL_FALSE;
    2613. 

  2613. GLboolean __GLEW_ARB_shading_language_include = GL_FALSE;
    2614. 

  2614. GLboolean __GLEW_ARB_shading_language_packing = GL_FALSE;
    2615. 

  2615. GLboolean __GLEW_ARB_shadow = GL_FALSE;
    2616. 

  2616. GLboolean __GLEW_ARB_shadow_ambient = GL_FALSE;
    2617. 

  2617. GLboolean __GLEW_ARB_sync = GL_FALSE;
    2618. 

  2618. GLboolean __GLEW_ARB_tessellation_shader = GL_FALSE;
    2619. 

  2619. GLboolean __GLEW_ARB_texture_border_clamp = GL_FALSE;
    2620. 

  2620. GLboolean __GLEW_ARB_texture_buffer_object = GL_FALSE;
    2621. 

  2621. GLboolean __GLEW_ARB_texture_buffer_object_rgb32 = GL_FALSE;
    2622. 

  2622. GLboolean __GLEW_ARB_texture_compression = GL_FALSE;
    2623. 

  2623. GLboolean __GLEW_ARB_texture_compression_bptc = GL_FALSE;
    2624. 

  2624. GLboolean __GLEW_ARB_texture_compression_rgtc = GL_FALSE;
    2625. 

  2625. GLboolean __GLEW_ARB_texture_cube_map = GL_FALSE;
    2626. 

  2626. GLboolean __GLEW_ARB_texture_cube_map_array = GL_FALSE;
    2627. 

  2627. GLboolean __GLEW_ARB_texture_env_add = GL_FALSE;
    2628. 

  2628. GLboolean __GLEW_ARB_texture_env_combine = GL_FALSE;
    2629. 

  2629. GLboolean __GLEW_ARB_texture_env_crossbar = GL_FALSE;
    2630. 

  2630. GLboolean __GLEW_ARB_texture_env_dot3 = GL_FALSE;
    2631. 

  2631. GLboolean __GLEW_ARB_texture_float = GL_FALSE;
    2632. 

  2632. GLboolean __GLEW_ARB_texture_gather = GL_FALSE;
    2633. 

  2633. GLboolean __GLEW_ARB_texture_mirrored_repeat = GL_FALSE;
    2634. 

  2634. GLboolean __GLEW_ARB_texture_multisample = GL_FALSE;
    2635. 

  2635. GLboolean __GLEW_ARB_texture_non_power_of_two = GL_FALSE;
    2636. 

  2636. GLboolean __GLEW_ARB_texture_query_lod = GL_FALSE;
    2637. 

  2637. GLboolean __GLEW_ARB_texture_rectangle = GL_FALSE;
    2638. 

  2638. GLboolean __GLEW_ARB_texture_rg = GL_FALSE;
    2639. 

  2639. GLboolean __GLEW_ARB_texture_rgb10_a2ui = GL_FALSE;
    2640. 

  2640. GLboolean __GLEW_ARB_texture_storage = GL_FALSE;
    2641. 

  2641. GLboolean __GLEW_ARB_texture_swizzle = GL_FALSE;
    2642. 

  2642. GLboolean __GLEW_ARB_timer_query = GL_FALSE;
    2643. 

  2643. GLboolean __GLEW_ARB_transform_feedback2 = GL_FALSE;
    2644. 

  2644. GLboolean __GLEW_ARB_transform_feedback3 = GL_FALSE;
    2645. 

  2645. GLboolean __GLEW_ARB_transform_feedback_instanced = GL_FALSE;
    2646. 

  2646. GLboolean __GLEW_ARB_transpose_matrix = GL_FALSE;
    2647. 

  2647. GLboolean __GLEW_ARB_uniform_buffer_object = GL_FALSE;
    2648. 

  2648. GLboolean __GLEW_ARB_vertex_array_bgra = GL_FALSE;
    2649. 

  2649. GLboolean __GLEW_ARB_vertex_array_object = GL_FALSE;
    2650. 

  2650. GLboolean __GLEW_ARB_vertex_attrib_64bit = GL_FALSE;
    2651. 

  2651. GLboolean __GLEW_ARB_vertex_blend = GL_FALSE;
    2652. 

  2652. GLboolean __GLEW_ARB_vertex_buffer_object = GL_FALSE;
    2653. 

  2653. GLboolean __GLEW_ARB_vertex_program = GL_FALSE;
    2654. 

  2654. GLboolean __GLEW_ARB_vertex_shader = GL_FALSE;
    2655. 

  2655. GLboolean __GLEW_ARB_vertex_type_2_10_10_10_rev = GL_FALSE;
    2656. 

  2656. GLboolean __GLEW_ARB_viewport_array = GL_FALSE;
    2657. 

  2657. GLboolean __GLEW_ARB_window_pos = GL_FALSE;
    2658. 

  2658. GLboolean __GLEW_ATIX_point_sprites = GL_FALSE;
    2659. 

  2659. GLboolean __GLEW_ATIX_texture_env_combine3 = GL_FALSE;
    2660. 

  2660. GLboolean __GLEW_ATIX_texture_env_route = GL_FALSE;
    2661. 

  2661. GLboolean __GLEW_ATIX_vertex_shader_output_point_size = GL_FALSE;
    2662. 

  2662. GLboolean __GLEW_ATI_draw_buffers = GL_FALSE;
    2663. 

  2663. GLboolean __GLEW_ATI_element_array = GL_FALSE;
    2664. 

  2664. GLboolean __GLEW_ATI_envmap_bumpmap = GL_FALSE;
    2665. 

  2665. GLboolean __GLEW_ATI_fragment_shader = GL_FALSE;
    2666. 

  2666. GLboolean __GLEW_ATI_map_object_buffer = GL_FALSE;
    2667. 

  2667. GLboolean __GLEW_ATI_meminfo = GL_FALSE;
    2668. 

  2668. GLboolean __GLEW_ATI_pn_triangles = GL_FALSE;
    2669. 

  2669. GLboolean __GLEW_ATI_separate_stencil = GL_FALSE;
    2670. 

  2670. GLboolean __GLEW_ATI_shader_texture_lod = GL_FALSE;
    2671. 

  2671. GLboolean __GLEW_ATI_text_fragment_shader = GL_FALSE;
    2672. 

  2672. GLboolean __GLEW_ATI_texture_compression_3dc = GL_FALSE;
    2673. 

  2673. GLboolean __GLEW_ATI_texture_env_combine3 = GL_FALSE;
    2674. 

  2674. GLboolean __GLEW_ATI_texture_float = GL_FALSE;
    2675. 

  2675. GLboolean __GLEW_ATI_texture_mirror_once = GL_FALSE;
    2676. 

  2676. GLboolean __GLEW_ATI_vertex_array_object = GL_FALSE;
    2677. 

  2677. GLboolean __GLEW_ATI_vertex_attrib_array_object = GL_FALSE;
    2678. 

  2678. GLboolean __GLEW_ATI_vertex_streams = GL_FALSE;
    2679. 

  2679. GLboolean __GLEW_EXT_422_pixels = GL_FALSE;
    2680. 

  2680. GLboolean __GLEW_EXT_Cg_shader = GL_FALSE;
    2681. 

  2681. GLboolean __GLEW_EXT_abgr = GL_FALSE;
    2682. 

  2682. GLboolean __GLEW_EXT_bgra = GL_FALSE;
    2683. 

  2683. GLboolean __GLEW_EXT_bindable_uniform = GL_FALSE;
    2684. 

  2684. GLboolean __GLEW_EXT_blend_color = GL_FALSE;
    2685. 

  2685. GLboolean __GLEW_EXT_blend_equation_separate = GL_FALSE;
    2686. 

  2686. GLboolean __GLEW_EXT_blend_func_separate = GL_FALSE;
    2687. 

  2687. GLboolean __GLEW_EXT_blend_logic_op = GL_FALSE;
    2688. 

  2688. GLboolean __GLEW_EXT_blend_minmax = GL_FALSE;
    2689. 

  2689. GLboolean __GLEW_EXT_blend_subtract = GL_FALSE;
    2690. 

  2690. GLboolean __GLEW_EXT_clip_volume_hint = GL_FALSE;
    2691. 

  2691. GLboolean __GLEW_EXT_cmyka = GL_FALSE;
    2692. 

  2692. GLboolean __GLEW_EXT_color_subtable = GL_FALSE;
    2693. 

  2693. GLboolean __GLEW_EXT_compiled_vertex_array = GL_FALSE;
    2694. 

  2694. GLboolean __GLEW_EXT_convolution = GL_FALSE;
    2695. 

  2695. GLboolean __GLEW_EXT_coordinate_frame = GL_FALSE;
    2696. 

  2696. GLboolean __GLEW_EXT_copy_texture = GL_FALSE;
    2697. 

  2697. GLboolean __GLEW_EXT_cull_vertex = GL_FALSE;
    2698. 

  2698. GLboolean __GLEW_EXT_depth_bounds_test = GL_FALSE;
    2699. 

  2699. GLboolean __GLEW_EXT_direct_state_access = GL_FALSE;
    2700. 

  2700. GLboolean __GLEW_EXT_draw_buffers2 = GL_FALSE;
    2701. 

  2701. GLboolean __GLEW_EXT_draw_instanced = GL_FALSE;
    2702. 

  2702. GLboolean __GLEW_EXT_draw_range_elements = GL_FALSE;
    2703. 

  2703. GLboolean __GLEW_EXT_fog_coord = GL_FALSE;
    2704. 

  2704. GLboolean __GLEW_EXT_fragment_lighting = GL_FALSE;
    2705. 

  2705. GLboolean __GLEW_EXT_framebuffer_blit = GL_FALSE;
    2706. 

  2706. GLboolean __GLEW_EXT_framebuffer_multisample = GL_FALSE;
    2707. 

  2707. GLboolean __GLEW_EXT_framebuffer_multisample_blit_scaled = GL_FALSE;
    2708. 

  2708. GLboolean __GLEW_EXT_framebuffer_object = GL_FALSE;
    2709. 

  2709. GLboolean __GLEW_EXT_framebuffer_sRGB = GL_FALSE;
    2710. 

  2710. GLboolean __GLEW_EXT_geometry_shader4 = GL_FALSE;
    2711. 

  2711. GLboolean __GLEW_EXT_gpu_program_parameters = GL_FALSE;
    2712. 

  2712. GLboolean __GLEW_EXT_gpu_shader4 = GL_FALSE;
    2713. 

  2713. GLboolean __GLEW_EXT_histogram = GL_FALSE;
    2714. 

  2714. GLboolean __GLEW_EXT_index_array_formats = GL_FALSE;
    2715. 

  2715. GLboolean __GLEW_EXT_index_func = GL_FALSE;
    2716. 

  2716. GLboolean __GLEW_EXT_index_material = GL_FALSE;
    2717. 

  2717. GLboolean __GLEW_EXT_index_texture = GL_FALSE;
    2718. 

  2718. GLboolean __GLEW_EXT_light_texture = GL_FALSE;
    2719. 

  2719. GLboolean __GLEW_EXT_misc_attribute = GL_FALSE;
    2720. 

  2720. GLboolean __GLEW_EXT_multi_draw_arrays = GL_FALSE;
    2721. 

  2721. GLboolean __GLEW_EXT_multisample = GL_FALSE;
    2722. 

  2722. GLboolean __GLEW_EXT_packed_depth_stencil = GL_FALSE;
    2723. 

  2723. GLboolean __GLEW_EXT_packed_float = GL_FALSE;
    2724. 

  2724. GLboolean __GLEW_EXT_packed_pixels = GL_FALSE;
    2725. 

  2725. GLboolean __GLEW_EXT_paletted_texture = GL_FALSE;
    2726. 

  2726. GLboolean __GLEW_EXT_pixel_buffer_object = GL_FALSE;
    2727. 

  2727. GLboolean __GLEW_EXT_pixel_transform = GL_FALSE;
    2728. 

  2728. GLboolean __GLEW_EXT_pixel_transform_color_table = GL_FALSE;
    2729. 

  2729. GLboolean __GLEW_EXT_point_parameters = GL_FALSE;
    2730. 

  2730. GLboolean __GLEW_EXT_polygon_offset = GL_FALSE;
    2731. 

  2731. GLboolean __GLEW_EXT_provoking_vertex = GL_FALSE;
    2732. 

  2732. GLboolean __GLEW_EXT_rescale_normal = GL_FALSE;
    2733. 

  2733. GLboolean __GLEW_EXT_scene_marker = GL_FALSE;
    2734. 

  2734. GLboolean __GLEW_EXT_secondary_color = GL_FALSE;
    2735. 

  2735. GLboolean __GLEW_EXT_separate_shader_objects = GL_FALSE;
    2736. 

  2736. GLboolean __GLEW_EXT_separate_specular_color = GL_FALSE;
    2737. 

  2737. GLboolean __GLEW_EXT_shader_image_load_store = GL_FALSE;
    2738. 

  2738. GLboolean __GLEW_EXT_shadow_funcs = GL_FALSE;
    2739. 

  2739. GLboolean __GLEW_EXT_shared_texture_palette = GL_FALSE;
    2740. 

  2740. GLboolean __GLEW_EXT_stencil_clear_tag = GL_FALSE;
    2741. 

  2741. GLboolean __GLEW_EXT_stencil_two_side = GL_FALSE;
    2742. 

  2742. GLboolean __GLEW_EXT_stencil_wrap = GL_FALSE;
    2743. 

  2743. GLboolean __GLEW_EXT_subtexture = GL_FALSE;
    2744. 

  2744. GLboolean __GLEW_EXT_texture = GL_FALSE;
    2745. 

  2745. GLboolean __GLEW_EXT_texture3D = GL_FALSE;
    2746. 

  2746. GLboolean __GLEW_EXT_texture_array = GL_FALSE;
    2747. 

  2747. GLboolean __GLEW_EXT_texture_buffer_object = GL_FALSE;
    2748. 

  2748. GLboolean __GLEW_EXT_texture_compression_dxt1 = GL_FALSE;
    2749. 

  2749. GLboolean __GLEW_EXT_texture_compression_latc = GL_FALSE;
    2750. 

  2750. GLboolean __GLEW_EXT_texture_compression_rgtc = GL_FALSE;
    2751. 

  2751. GLboolean __GLEW_EXT_texture_compression_s3tc = GL_FALSE;
    2752. 

  2752. GLboolean __GLEW_EXT_texture_cube_map = GL_FALSE;
    2753. 

  2753. GLboolean __GLEW_EXT_texture_edge_clamp = GL_FALSE;
    2754. 

  2754. GLboolean __GLEW_EXT_texture_env = GL_FALSE;
    2755. 

  2755. GLboolean __GLEW_EXT_texture_env_add = GL_FALSE;
    2756. 

  2756. GLboolean __GLEW_EXT_texture_env_combine = GL_FALSE;
    2757. 

  2757. GLboolean __GLEW_EXT_texture_env_dot3 = GL_FALSE;
    2758. 

  2758. GLboolean __GLEW_EXT_texture_filter_anisotropic = GL_FALSE;
    2759. 

  2759. GLboolean __GLEW_EXT_texture_integer = GL_FALSE;
    2760. 

  2760. GLboolean __GLEW_EXT_texture_lod_bias = GL_FALSE;
    2761. 

  2761. GLboolean __GLEW_EXT_texture_mirror_clamp = GL_FALSE;
    2762. 

  2762. GLboolean __GLEW_EXT_texture_object = GL_FALSE;
    2763. 

  2763. GLboolean __GLEW_EXT_texture_perturb_normal = GL_FALSE;
    2764. 

  2764. GLboolean __GLEW_EXT_texture_rectangle = GL_FALSE;
    2765. 

  2765. GLboolean __GLEW_EXT_texture_sRGB = GL_FALSE;
    2766. 

  2766. GLboolean __GLEW_EXT_texture_sRGB_decode = GL_FALSE;
    2767. 

  2767. GLboolean __GLEW_EXT_texture_shared_exponent = GL_FALSE;
    2768. 

  2768. GLboolean __GLEW_EXT_texture_snorm = GL_FALSE;
    2769. 

  2769. GLboolean __GLEW_EXT_texture_swizzle = GL_FALSE;
    2770. 

  2770. GLboolean __GLEW_EXT_timer_query = GL_FALSE;
    2771. 

  2771. GLboolean __GLEW_EXT_transform_feedback = GL_FALSE;
    2772. 

  2772. GLboolean __GLEW_EXT_vertex_array = GL_FALSE;
    2773. 

  2773. GLboolean __GLEW_EXT_vertex_array_bgra = GL_FALSE;
    2774. 

  2774. GLboolean __GLEW_EXT_vertex_attrib_64bit = GL_FALSE;
    2775. 

  2775. GLboolean __GLEW_EXT_vertex_shader = GL_FALSE;
    2776. 

  2776. GLboolean __GLEW_EXT_vertex_weighting = GL_FALSE;
    2777. 

  2777. GLboolean __GLEW_EXT_x11_sync_object = GL_FALSE;
    2778. 

  2778. GLboolean __GLEW_GREMEDY_frame_terminator = GL_FALSE;
    2779. 

  2779. GLboolean __GLEW_GREMEDY_string_marker = GL_FALSE;
    2780. 

  2780. GLboolean __GLEW_HP_convolution_border_modes = GL_FALSE;
    2781. 

  2781. GLboolean __GLEW_HP_image_transform = GL_FALSE;
    2782. 

  2782. GLboolean __GLEW_HP_occlusion_test = GL_FALSE;
    2783. 

  2783. GLboolean __GLEW_HP_texture_lighting = GL_FALSE;
    2784. 

  2784. GLboolean __GLEW_IBM_cull_vertex = GL_FALSE;
    2785. 

  2785. GLboolean __GLEW_IBM_multimode_draw_arrays = GL_FALSE;
    2786. 

  2786. GLboolean __GLEW_IBM_rasterpos_clip = GL_FALSE;
    2787. 

  2787. GLboolean __GLEW_IBM_static_data = GL_FALSE;
    2788. 

  2788. GLboolean __GLEW_IBM_texture_mirrored_repeat = GL_FALSE;
    2789. 

  2789. GLboolean __GLEW_IBM_vertex_array_lists = GL_FALSE;
    2790. 

  2790. GLboolean __GLEW_INGR_color_clamp = GL_FALSE;
    2791. 

  2791. GLboolean __GLEW_INGR_interlace_read = GL_FALSE;
    2792. 

  2792. GLboolean __GLEW_INTEL_parallel_arrays = GL_FALSE;
    2793. 

  2793. GLboolean __GLEW_INTEL_texture_scissor = GL_FALSE;
    2794. 

  2794. GLboolean __GLEW_KTX_buffer_region = GL_FALSE;
    2795. 

  2795. GLboolean __GLEW_MESAX_texture_stack = GL_FALSE;
    2796. 

  2796. GLboolean __GLEW_MESA_pack_invert = GL_FALSE;
    2797. 

  2797. GLboolean __GLEW_MESA_resize_buffers = GL_FALSE;
    2798. 

  2798. GLboolean __GLEW_MESA_window_pos = GL_FALSE;
    2799. 

  2799. GLboolean __GLEW_MESA_ycbcr_texture = GL_FALSE;
    2800. 

  2800. GLboolean __GLEW_NVX_gpu_memory_info = GL_FALSE;
    2801. 

  2801. GLboolean __GLEW_NV_blend_square = GL_FALSE;
    2802. 

  2802. GLboolean __GLEW_NV_conditional_render = GL_FALSE;
    2803. 

  2803. GLboolean __GLEW_NV_copy_depth_to_color = GL_FALSE;
    2804. 

  2804. GLboolean __GLEW_NV_copy_image = GL_FALSE;
    2805. 

  2805. GLboolean __GLEW_NV_depth_buffer_float = GL_FALSE;
    2806. 

  2806. GLboolean __GLEW_NV_depth_clamp = GL_FALSE;
    2807. 

  2807. GLboolean __GLEW_NV_depth_range_unclamped = GL_FALSE;
    2808. 

  2808. GLboolean __GLEW_NV_evaluators = GL_FALSE;
    2809. 

  2809. GLboolean __GLEW_NV_explicit_multisample = GL_FALSE;
    2810. 

  2810. GLboolean __GLEW_NV_fence = GL_FALSE;
    2811. 

  2811. GLboolean __GLEW_NV_float_buffer = GL_FALSE;
    2812. 

  2812. GLboolean __GLEW_NV_fog_distance = GL_FALSE;
    2813. 

  2813. GLboolean __GLEW_NV_fragment_program = GL_FALSE;
    2814. 

  2814. GLboolean __GLEW_NV_fragment_program2 = GL_FALSE;
    2815. 

  2815. GLboolean __GLEW_NV_fragment_program4 = GL_FALSE;
    2816. 

  2816. GLboolean __GLEW_NV_fragment_program_option = GL_FALSE;
    2817. 

  2817. GLboolean __GLEW_NV_framebuffer_multisample_coverage = GL_FALSE;
    2818. 

  2818. GLboolean __GLEW_NV_geometry_program4 = GL_FALSE;
    2819. 

  2819. GLboolean __GLEW_NV_geometry_shader4 = GL_FALSE;
    2820. 

  2820. GLboolean __GLEW_NV_gpu_program4 = GL_FALSE;
    2821. 

  2821. GLboolean __GLEW_NV_gpu_program5 = GL_FALSE;
    2822. 

  2822. GLboolean __GLEW_NV_gpu_program_fp64 = GL_FALSE;
    2823. 

  2823. GLboolean __GLEW_NV_gpu_shader5 = GL_FALSE;
    2824. 

  2824. GLboolean __GLEW_NV_half_float = GL_FALSE;
    2825. 

  2825. GLboolean __GLEW_NV_light_max_exponent = GL_FALSE;
    2826. 

  2826. GLboolean __GLEW_NV_multisample_coverage = GL_FALSE;
    2827. 

  2827. GLboolean __GLEW_NV_multisample_filter_hint = GL_FALSE;
    2828. 

  2828. GLboolean __GLEW_NV_occlusion_query = GL_FALSE;
    2829. 

  2829. GLboolean __GLEW_NV_packed_depth_stencil = GL_FALSE;
    2830. 

  2830. GLboolean __GLEW_NV_parameter_buffer_object = GL_FALSE;
    2831. 

  2831. GLboolean __GLEW_NV_parameter_buffer_object2 = GL_FALSE;
    2832. 

  2832. GLboolean __GLEW_NV_path_rendering = GL_FALSE;
    2833. 

  2833. GLboolean __GLEW_NV_pixel_data_range = GL_FALSE;
    2834. 

  2834. GLboolean __GLEW_NV_point_sprite = GL_FALSE;
    2835. 

  2835. GLboolean __GLEW_NV_present_video = GL_FALSE;
    2836. 

  2836. GLboolean __GLEW_NV_primitive_restart = GL_FALSE;
    2837. 

  2837. GLboolean __GLEW_NV_register_combiners = GL_FALSE;
    2838. 

  2838. GLboolean __GLEW_NV_register_combiners2 = GL_FALSE;
    2839. 

  2839. GLboolean __GLEW_NV_shader_buffer_load = GL_FALSE;
    2840. 

  2840. GLboolean __GLEW_NV_tessellation_program5 = GL_FALSE;
    2841. 

  2841. GLboolean __GLEW_NV_texgen_emboss = GL_FALSE;
    2842. 

  2842. GLboolean __GLEW_NV_texgen_reflection = GL_FALSE;
    2843. 

  2843. GLboolean __GLEW_NV_texture_barrier = GL_FALSE;
    2844. 

  2844. GLboolean __GLEW_NV_texture_compression_vtc = GL_FALSE;
    2845. 

  2845. GLboolean __GLEW_NV_texture_env_combine4 = GL_FALSE;
    2846. 

  2846. GLboolean __GLEW_NV_texture_expand_normal = GL_FALSE;
    2847. 

  2847. GLboolean __GLEW_NV_texture_multisample = GL_FALSE;
    2848. 

  2848. GLboolean __GLEW_NV_texture_rectangle = GL_FALSE;
    2849. 

  2849. GLboolean __GLEW_NV_texture_shader = GL_FALSE;
    2850. 

  2850. GLboolean __GLEW_NV_texture_shader2 = GL_FALSE;
    2851. 

  2851. GLboolean __GLEW_NV_texture_shader3 = GL_FALSE;
    2852. 

  2852. GLboolean __GLEW_NV_transform_feedback = GL_FALSE;
    2853. 

  2853. GLboolean __GLEW_NV_transform_feedback2 = GL_FALSE;
    2854. 

  2854. GLboolean __GLEW_NV_vdpau_interop = GL_FALSE;
    2855. 

  2855. GLboolean __GLEW_NV_vertex_array_range = GL_FALSE;
    2856. 

  2856. GLboolean __GLEW_NV_vertex_array_range2 = GL_FALSE;
    2857. 

  2857. GLboolean __GLEW_NV_vertex_attrib_integer_64bit = GL_FALSE;
    2858. 

  2858. GLboolean __GLEW_NV_vertex_buffer_unified_memory = GL_FALSE;
    2859. 

  2859. GLboolean __GLEW_NV_vertex_program = GL_FALSE;
    2860. 

  2860. GLboolean __GLEW_NV_vertex_program1_1 = GL_FALSE;
    2861. 

  2861. GLboolean __GLEW_NV_vertex_program2 = GL_FALSE;
    2862. 

  2862. GLboolean __GLEW_NV_vertex_program2_option = GL_FALSE;
    2863. 

  2863. GLboolean __GLEW_NV_vertex_program3 = GL_FALSE;
    2864. 

  2864. GLboolean __GLEW_NV_vertex_program4 = GL_FALSE;
    2865. 

  2865. GLboolean __GLEW_NV_video_capture = GL_FALSE;
    2866. 

  2866. GLboolean __GLEW_OES_byte_coordinates = GL_FALSE;
    2867. 

  2867. GLboolean __GLEW_OES_compressed_paletted_texture = GL_FALSE;
    2868. 

  2868. GLboolean __GLEW_OES_read_format = GL_FALSE;
    2869. 

  2869. GLboolean __GLEW_OES_single_precision = GL_FALSE;
    2870. 

  2870. GLboolean __GLEW_OML_interlace = GL_FALSE;
    2871. 

  2871. GLboolean __GLEW_OML_resample = GL_FALSE;
    2872. 

  2872. GLboolean __GLEW_OML_subsample = GL_FALSE;
    2873. 

  2873. GLboolean __GLEW_PGI_misc_hints = GL_FALSE;
    2874. 

  2874. GLboolean __GLEW_PGI_vertex_hints = GL_FALSE;
    2875. 

  2875. GLboolean __GLEW_REND_screen_coordinates = GL_FALSE;
    2876. 

  2876. GLboolean __GLEW_S3_s3tc = GL_FALSE;
    2877. 

  2877. GLboolean __GLEW_SGIS_color_range = GL_FALSE;
    2878. 

  2878. GLboolean __GLEW_SGIS_detail_texture = GL_FALSE;
    2879. 

  2879. GLboolean __GLEW_SGIS_fog_function = GL_FALSE;
    2880. 

  2880. GLboolean __GLEW_SGIS_generate_mipmap = GL_FALSE;
    2881. 

  2881. GLboolean __GLEW_SGIS_multisample = GL_FALSE;
    2882. 

  2882. GLboolean __GLEW_SGIS_pixel_texture = GL_FALSE;
    2883. 

  2883. GLboolean __GLEW_SGIS_point_line_texgen = GL_FALSE;
    2884. 

  2884. GLboolean __GLEW_SGIS_sharpen_texture = GL_FALSE;
    2885. 

  2885. GLboolean __GLEW_SGIS_texture4D = GL_FALSE;
    2886. 

  2886. GLboolean __GLEW_SGIS_texture_border_clamp = GL_FALSE;
    2887. 

  2887. GLboolean __GLEW_SGIS_texture_edge_clamp = GL_FALSE;
    2888. 

  2888. GLboolean __GLEW_SGIS_texture_filter4 = GL_FALSE;
    2889. 

  2889. GLboolean __GLEW_SGIS_texture_lod = GL_FALSE;
    2890. 

  2890. GLboolean __GLEW_SGIS_texture_select = GL_FALSE;
    2891. 

  2891. GLboolean __GLEW_SGIX_async = GL_FALSE;
    2892. 

  2892. GLboolean __GLEW_SGIX_async_histogram = GL_FALSE;
    2893. 

  2893. GLboolean __GLEW_SGIX_async_pixel = GL_FALSE;
    2894. 

  2894. GLboolean __GLEW_SGIX_blend_alpha_minmax = GL_FALSE;
    2895. 

  2895. GLboolean __GLEW_SGIX_clipmap = GL_FALSE;
    2896. 

  2896. GLboolean __GLEW_SGIX_convolution_accuracy = GL_FALSE;
    2897. 

  2897. GLboolean __GLEW_SGIX_depth_texture = GL_FALSE;
    2898. 

  2898. GLboolean __GLEW_SGIX_flush_raster = GL_FALSE;
    2899. 

  2899. GLboolean __GLEW_SGIX_fog_offset = GL_FALSE;
    2900. 

  2900. GLboolean __GLEW_SGIX_fog_texture = GL_FALSE;
    2901. 

  2901. GLboolean __GLEW_SGIX_fragment_specular_lighting = GL_FALSE;
    2902. 

  2902. GLboolean __GLEW_SGIX_framezoom = GL_FALSE;
    2903. 

  2903. GLboolean __GLEW_SGIX_interlace = GL_FALSE;
    2904. 

  2904. GLboolean __GLEW_SGIX_ir_instrument1 = GL_FALSE;
    2905. 

  2905. GLboolean __GLEW_SGIX_list_priority = GL_FALSE;
    2906. 

  2906. GLboolean __GLEW_SGIX_pixel_texture = GL_FALSE;
    2907. 

  2907. GLboolean __GLEW_SGIX_pixel_texture_bits = GL_FALSE;
    2908. 

  2908. GLboolean __GLEW_SGIX_reference_plane = GL_FALSE;
    2909. 

  2909. GLboolean __GLEW_SGIX_resample = GL_FALSE;
    2910. 

  2910. GLboolean __GLEW_SGIX_shadow = GL_FALSE;
    2911. 

  2911. GLboolean __GLEW_SGIX_shadow_ambient = GL_FALSE;
    2912. 

  2912. GLboolean __GLEW_SGIX_sprite = GL_FALSE;
    2913. 

  2913. GLboolean __GLEW_SGIX_tag_sample_buffer = GL_FALSE;
    2914. 

  2914. GLboolean __GLEW_SGIX_texture_add_env = GL_FALSE;
    2915. 

  2915. GLboolean __GLEW_SGIX_texture_coordinate_clamp = GL_FALSE;
    2916. 

  2916. GLboolean __GLEW_SGIX_texture_lod_bias = GL_FALSE;
    2917. 

  2917. GLboolean __GLEW_SGIX_texture_multi_buffer = GL_FALSE;
    2918. 

  2918. GLboolean __GLEW_SGIX_texture_range = GL_FALSE;
    2919. 

  2919. GLboolean __GLEW_SGIX_texture_scale_bias = GL_FALSE;
    2920. 

  2920. GLboolean __GLEW_SGIX_vertex_preclip = GL_FALSE;
    2921. 

  2921. GLboolean __GLEW_SGIX_vertex_preclip_hint = GL_FALSE;
    2922. 

  2922. GLboolean __GLEW_SGIX_ycrcb = GL_FALSE;
    2923. 

  2923. GLboolean __GLEW_SGI_color_matrix = GL_FALSE;
    2924. 

  2924. GLboolean __GLEW_SGI_color_table = GL_FALSE;
    2925. 

  2925. GLboolean __GLEW_SGI_texture_color_table = GL_FALSE;
    2926. 

  2926. GLboolean __GLEW_SUNX_constant_data = GL_FALSE;
    2927. 

  2927. GLboolean __GLEW_SUN_convolution_border_modes = GL_FALSE;
    2928. 

  2928. GLboolean __GLEW_SUN_global_alpha = GL_FALSE;
    2929. 

  2929. GLboolean __GLEW_SUN_mesh_array = GL_FALSE;
    2930. 

  2930. GLboolean __GLEW_SUN_read_video_pixels = GL_FALSE;
    2931. 

  2931. GLboolean __GLEW_SUN_slice_accum = GL_FALSE;
    2932. 

  2932. GLboolean __GLEW_SUN_triangle_list = GL_FALSE;
    2933. 

  2933. GLboolean __GLEW_SUN_vertex = GL_FALSE;
    2934. 

  2934. GLboolean __GLEW_WIN_phong_shading = GL_FALSE;
    2935. 

  2935. GLboolean __GLEW_WIN_specular_fog = GL_FALSE;
    2936. 

  2936. GLboolean __GLEW_WIN_swap_hint = GL_FALSE;
    2937. 

  2937. 

  2938. #endif /* !GLEW_MX */
    2939. 

  2939. 

  2940. #ifdef GL_VERSION_1_2
    2941. 

  2941. 

  2942. static GLboolean _glewInit_GL_VERSION_1_2 (GLEW_CONTEXT_ARG_DEF_INIT)
    2943. 

  2943. {
    2944. 

  2944.   GLboolean r = GL_FALSE;
    2945. 

  2945. 

  2946.   r = ((glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3D")) == NULL) || r;
    2947. 

  2947.   r = ((glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElements")) == NULL) || r;
    2948. 

  2948.   r = ((glTexImage3D = (PFNGLTEXIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexImage3D")) == NULL) || r;
    2949. 

  2949.   r = ((glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3D")) == NULL) || r;
    2950. 

  2950. 

  2951.   return r;
    2952. 

  2952. }
    2953. 

  2953. 

  2954. #endif /* GL_VERSION_1_2 */
    2955. 

  2955. 

  2956. #ifdef GL_VERSION_1_2_1
    2957. 

  2957. 

  2958. #endif /* GL_VERSION_1_2_1 */
    2959. 

  2959. 

  2960. #ifdef GL_VERSION_1_3
    2961. 

  2961. 

  2962. static GLboolean _glewInit_GL_VERSION_1_3 (GLEW_CONTEXT_ARG_DEF_INIT)
    2963. 

  2963. {
    2964. 

  2964.   GLboolean r = GL_FALSE;
    2965. 

  2965. 

  2966.   r = ((glActiveTexture = (PFNGLACTIVETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glActiveTexture")) == NULL) || r;
    2967. 

  2967.   r = ((glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glClientActiveTexture")) == NULL) || r;
    2968. 

  2968.   r = ((glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage1D")) == NULL) || r;
    2969. 

  2969.   r = ((glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage2D")) == NULL) || r;
    2970. 

  2970.   r = ((glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3D")) == NULL) || r;
    2971. 

  2971.   r = ((glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage1D")) == NULL) || r;
    2972. 

  2972.   r = ((glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage2D")) == NULL) || r;
    2973. 

  2973.   r = ((glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3D")) == NULL) || r;
    2974. 

  2974.   r = ((glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTexImage")) == NULL) || r;
    2975. 

  2975.   r = ((glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixd")) == NULL) || r;
    2976. 

  2976.   r = ((glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixf")) == NULL) || r;
    2977. 

  2977.   r = ((glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixd")) == NULL) || r;
    2978. 

  2978.   r = ((glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixf")) == NULL) || r;
    2979. 

  2979.   r = ((glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1d")) == NULL) || r;
    2980. 

  2980.   r = ((glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dv")) == NULL) || r;
    2981. 

  2981.   r = ((glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1f")) == NULL) || r;
    2982. 

  2982.   r = ((glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fv")) == NULL) || r;
    2983. 

  2983.   r = ((glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1i")) == NULL) || r;
    2984. 

  2984.   r = ((glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1iv")) == NULL) || r;
    2985. 

  2985.   r = ((glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1s")) == NULL) || r;
    2986. 

  2986.   r = ((glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1sv")) == NULL) || r;
    2987. 

  2987.   r = ((glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2d")) == NULL) || r;
    2988. 

  2988.   r = ((glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dv")) == NULL) || r;
    2989. 

  2989.   r = ((glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2f")) == NULL) || r;
    2990. 

  2990.   r = ((glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fv")) == NULL) || r;
    2991. 

  2991.   r = ((glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2i")) == NULL) || r;
    2992. 

  2992.   r = ((glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2iv")) == NULL) || r;
    2993. 

  2993.   r = ((glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2s")) == NULL) || r;
    2994. 

  2994.   r = ((glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2sv")) == NULL) || r;
    2995. 

  2995.   r = ((glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3d")) == NULL) || r;
    2996. 

  2996.   r = ((glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dv")) == NULL) || r;
    2997. 

  2997.   r = ((glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3f")) == NULL) || r;
    2998. 

  2998.   r = ((glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fv")) == NULL) || r;
    2999. 

  2999.   r = ((glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3i")) == NULL) || r;
    3000. 

  3000.   r = ((glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3iv")) == NULL) || r;
    3001. 

  3001.   r = ((glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3s")) == NULL) || r;
    3002. 

  3002.   r = ((glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3sv")) == NULL) || r;
    3003. 

  3003.   r = ((glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4d")) == NULL) || r;
    3004. 

  3004.   r = ((glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dv")) == NULL) || r;
    3005. 

  3005.   r = ((glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4f")) == NULL) || r;
    3006. 

  3006.   r = ((glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fv")) == NULL) || r;
    3007. 

  3007.   r = ((glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4i")) == NULL) || r;
    3008. 

  3008.   r = ((glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4iv")) == NULL) || r;
    3009. 

  3009.   r = ((glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4s")) == NULL) || r;
    3010. 

  3010.   r = ((glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4sv")) == NULL) || r;
    3011. 

  3011.   r = ((glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)glewGetProcAddress((const GLubyte*)"glSampleCoverage")) == NULL) || r;
    3012. 

  3012. 

  3013.   return r;
    3014. 

  3014. }
    3015. 

  3015. 

  3016. #endif /* GL_VERSION_1_3 */
    3017. 

  3017. 

  3018. #ifdef GL_VERSION_1_4
    3019. 

  3019. 

  3020. static GLboolean _glewInit_GL_VERSION_1_4 (GLEW_CONTEXT_ARG_DEF_INIT)
    3021. 

  3021. {
    3022. 

  3022.   GLboolean r = GL_FALSE;
    3023. 

  3023. 

  3024.   r = ((glBlendColor = (PFNGLBLENDCOLORPROC)glewGetProcAddress((const GLubyte*)"glBlendColor")) == NULL) || r;
    3025. 

  3025.   r = ((glBlendEquation = (PFNGLBLENDEQUATIONPROC)glewGetProcAddress((const GLubyte*)"glBlendEquation")) == NULL) || r;
    3026. 

  3026.   r = ((glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparate")) == NULL) || r;
    3027. 

  3027.   r = ((glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointer")) == NULL) || r;
    3028. 

  3028.   r = ((glFogCoordd = (PFNGLFOGCOORDDPROC)glewGetProcAddress((const GLubyte*)"glFogCoordd")) == NULL) || r;
    3029. 

  3029.   r = ((glFogCoorddv = (PFNGLFOGCOORDDVPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddv")) == NULL) || r;
    3030. 

  3030.   r = ((glFogCoordf = (PFNGLFOGCOORDFPROC)glewGetProcAddress((const GLubyte*)"glFogCoordf")) == NULL) || r;
    3031. 

  3031.   r = ((glFogCoordfv = (PFNGLFOGCOORDFVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfv")) == NULL) || r;
    3032. 

  3032.   r = ((glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArrays")) == NULL) || r;
    3033. 

  3033.   r = ((glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElements")) == NULL) || r;
    3034. 

  3034.   r = ((glPointParameterf = (PFNGLPOINTPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glPointParameterf")) == NULL) || r;
    3035. 

  3035.   r = ((glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfv")) == NULL) || r;
    3036. 

  3036.   r = ((glPointParameteri = (PFNGLPOINTPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glPointParameteri")) == NULL) || r;
    3037. 

  3037.   r = ((glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glPointParameteriv")) == NULL) || r;
    3038. 

  3038.   r = ((glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3b")) == NULL) || r;
    3039. 

  3039.   r = ((glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bv")) == NULL) || r;
    3040. 

  3040.   r = ((glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3d")) == NULL) || r;
    3041. 

  3041.   r = ((glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dv")) == NULL) || r;
    3042. 

  3042.   r = ((glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3f")) == NULL) || r;
    3043. 

  3043.   r = ((glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fv")) == NULL) || r;
    3044. 

  3044.   r = ((glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3i")) == NULL) || r;
    3045. 

  3045.   r = ((glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3iv")) == NULL) || r;
    3046. 

  3046.   r = ((glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3s")) == NULL) || r;
    3047. 

  3047.   r = ((glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3sv")) == NULL) || r;
    3048. 

  3048.   r = ((glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ub")) == NULL) || r;
    3049. 

  3049.   r = ((glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubv")) == NULL) || r;
    3050. 

  3050.   r = ((glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ui")) == NULL) || r;
    3051. 

  3051.   r = ((glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uiv")) == NULL) || r;
    3052. 

  3052.   r = ((glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3us")) == NULL) || r;
    3053. 

  3053.   r = ((glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usv")) == NULL) || r;
    3054. 

  3054.   r = ((glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointer")) == NULL) || r;
    3055. 

  3055.   r = ((glWindowPos2d = (PFNGLWINDOWPOS2DPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2d")) == NULL) || r;
    3056. 

  3056.   r = ((glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dv")) == NULL) || r;
    3057. 

  3057.   r = ((glWindowPos2f = (PFNGLWINDOWPOS2FPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2f")) == NULL) || r;
    3058. 

  3058.   r = ((glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fv")) == NULL) || r;
    3059. 

  3059.   r = ((glWindowPos2i = (PFNGLWINDOWPOS2IPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2i")) == NULL) || r;
    3060. 

  3060.   r = ((glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iv")) == NULL) || r;
    3061. 

  3061.   r = ((glWindowPos2s = (PFNGLWINDOWPOS2SPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2s")) == NULL) || r;
    3062. 

  3062.   r = ((glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sv")) == NULL) || r;
    3063. 

  3063.   r = ((glWindowPos3d = (PFNGLWINDOWPOS3DPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3d")) == NULL) || r;
    3064. 

  3064.   r = ((glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dv")) == NULL) || r;
    3065. 

  3065.   r = ((glWindowPos3f = (PFNGLWINDOWPOS3FPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3f")) == NULL) || r;
    3066. 

  3066.   r = ((glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fv")) == NULL) || r;
    3067. 

  3067.   r = ((glWindowPos3i = (PFNGLWINDOWPOS3IPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3i")) == NULL) || r;
    3068. 

  3068.   r = ((glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iv")) == NULL) || r;
    3069. 

  3069.   r = ((glWindowPos3s = (PFNGLWINDOWPOS3SPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3s")) == NULL) || r;
    3070. 

  3070.   r = ((glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sv")) == NULL) || r;
    3071. 

  3071. 

  3072.   return r;
    3073. 

  3073. }
    3074. 

  3074. 

  3075. #endif /* GL_VERSION_1_4 */
    3076. 

  3076. 

  3077. #ifdef GL_VERSION_1_5
    3078. 

  3078. 

  3079. static GLboolean _glewInit_GL_VERSION_1_5 (GLEW_CONTEXT_ARG_DEF_INIT)
    3080. 

  3080. {
    3081. 

  3081.   GLboolean r = GL_FALSE;
    3082. 

  3082. 

  3083.   r = ((glBeginQuery = (PFNGLBEGINQUERYPROC)glewGetProcAddress((const GLubyte*)"glBeginQuery")) == NULL) || r;
    3084. 

  3084.   r = ((glBindBuffer = (PFNGLBINDBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindBuffer")) == NULL) || r;
    3085. 

  3085.   r = ((glBufferData = (PFNGLBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glBufferData")) == NULL) || r;
    3086. 

  3086.   r = ((glBufferSubData = (PFNGLBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glBufferSubData")) == NULL) || r;
    3087. 

  3087.   r = ((glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteBuffers")) == NULL) || r;
    3088. 

  3088.   r = ((glDeleteQueries = (PFNGLDELETEQUERIESPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueries")) == NULL) || r;
    3089. 

  3089.   r = ((glEndQuery = (PFNGLENDQUERYPROC)glewGetProcAddress((const GLubyte*)"glEndQuery")) == NULL) || r;
    3090. 

  3090.   r = ((glGenBuffers = (PFNGLGENBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenBuffers")) == NULL) || r;
    3091. 

  3091.   r = ((glGenQueries = (PFNGLGENQUERIESPROC)glewGetProcAddress((const GLubyte*)"glGenQueries")) == NULL) || r;
    3092. 

  3092.   r = ((glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameteriv")) == NULL) || r;
    3093. 

  3093.   r = ((glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointerv")) == NULL) || r;
    3094. 

  3094.   r = ((glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glGetBufferSubData")) == NULL) || r;
    3095. 

  3095.   r = ((glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectiv")) == NULL) || r;
    3096. 

  3096.   r = ((glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuiv")) == NULL) || r;
    3097. 

  3097.   r = ((glGetQueryiv = (PFNGLGETQUERYIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryiv")) == NULL) || r;
    3098. 

  3098.   r = ((glIsBuffer = (PFNGLISBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsBuffer")) == NULL) || r;
    3099. 

  3099.   r = ((glIsQuery = (PFNGLISQUERYPROC)glewGetProcAddress((const GLubyte*)"glIsQuery")) == NULL) || r;
    3100. 

  3100.   r = ((glMapBuffer = (PFNGLMAPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glMapBuffer")) == NULL) || r;
    3101. 

  3101.   r = ((glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glUnmapBuffer")) == NULL) || r;
    3102. 

  3102. 

  3103.   return r;
    3104. 

  3104. }
    3105. 

  3105. 

  3106. #endif /* GL_VERSION_1_5 */
    3107. 

  3107. 

  3108. #ifdef GL_VERSION_2_0
    3109. 

  3109. 

  3110. static GLboolean _glewInit_GL_VERSION_2_0 (GLEW_CONTEXT_ARG_DEF_INIT)
    3111. 

  3111. {
    3112. 

  3112.   GLboolean r = GL_FALSE;
    3113. 

  3113. 

  3114.   r = ((glAttachShader = (PFNGLATTACHSHADERPROC)glewGetProcAddress((const GLubyte*)"glAttachShader")) == NULL) || r;
    3115. 

  3115.   r = ((glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glBindAttribLocation")) == NULL) || r;
    3116. 

  3116.   r = ((glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparate")) == NULL) || r;
    3117. 

  3117.   r = ((glCompileShader = (PFNGLCOMPILESHADERPROC)glewGetProcAddress((const GLubyte*)"glCompileShader")) == NULL) || r;
    3118. 

  3118.   r = ((glCreateProgram = (PFNGLCREATEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glCreateProgram")) == NULL) || r;
    3119. 

  3119.   r = ((glCreateShader = (PFNGLCREATESHADERPROC)glewGetProcAddress((const GLubyte*)"glCreateShader")) == NULL) || r;
    3120. 

  3120.   r = ((glDeleteProgram = (PFNGLDELETEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgram")) == NULL) || r;
    3121. 

  3121.   r = ((glDeleteShader = (PFNGLDELETESHADERPROC)glewGetProcAddress((const GLubyte*)"glDeleteShader")) == NULL) || r;
    3122. 

  3122.   r = ((glDetachShader = (PFNGLDETACHSHADERPROC)glewGetProcAddress((const GLubyte*)"glDetachShader")) == NULL) || r;
    3123. 

  3123.   r = ((glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribArray")) == NULL) || r;
    3124. 

  3124.   r = ((glDrawBuffers = (PFNGLDRAWBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffers")) == NULL) || r;
    3125. 

  3125.   r = ((glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribArray")) == NULL) || r;
    3126. 

  3126.   r = ((glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAttrib")) == NULL) || r;
    3127. 

  3127.   r = ((glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniform")) == NULL) || r;
    3128. 

  3128.   r = ((glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)glewGetProcAddress((const GLubyte*)"glGetAttachedShaders")) == NULL) || r;
    3129. 

  3129.   r = ((glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetAttribLocation")) == NULL) || r;
    3130. 

  3130.   r = ((glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetProgramInfoLog")) == NULL) || r;
    3131. 

  3131.   r = ((glGetProgramiv = (PFNGLGETPROGRAMIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramiv")) == NULL) || r;
    3132. 

  3132.   r = ((glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetShaderInfoLog")) == NULL) || r;
    3133. 

  3133.   r = ((glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)glewGetProcAddress((const GLubyte*)"glGetShaderSource")) == NULL) || r;
    3134. 

  3134.   r = ((glGetShaderiv = (PFNGLGETSHADERIVPROC)glewGetProcAddress((const GLubyte*)"glGetShaderiv")) == NULL) || r;
    3135. 

  3135.   r = ((glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetUniformLocation")) == NULL) || r;
    3136. 

  3136.   r = ((glGetUniformfv = (PFNGLGETUNIFORMFVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformfv")) == NULL) || r;
    3137. 

  3137.   r = ((glGetUniformiv = (PFNGLGETUNIFORMIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformiv")) == NULL) || r;
    3138. 

  3138.   r = ((glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointerv")) == NULL) || r;
    3139. 

  3139.   r = ((glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdv")) == NULL) || r;
    3140. 

  3140.   r = ((glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfv")) == NULL) || r;
    3141. 

  3141.   r = ((glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribiv")) == NULL) || r;
    3142. 

  3142.   r = ((glIsProgram = (PFNGLISPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glIsProgram")) == NULL) || r;
    3143. 

  3143.   r = ((glIsShader = (PFNGLISSHADERPROC)glewGetProcAddress((const GLubyte*)"glIsShader")) == NULL) || r;
    3144. 

  3144.   r = ((glLinkProgram = (PFNGLLINKPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glLinkProgram")) == NULL) || r;
    3145. 

  3145.   r = ((glShaderSource = (PFNGLSHADERSOURCEPROC)glewGetProcAddress((const GLubyte*)"glShaderSource")) == NULL) || r;
    3146. 

  3146.   r = ((glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilFuncSeparate")) == NULL) || r;
    3147. 

  3147.   r = ((glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilMaskSeparate")) == NULL) || r;
    3148. 

  3148.   r = ((glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilOpSeparate")) == NULL) || r;
    3149. 

  3149.   r = ((glUniform1f = (PFNGLUNIFORM1FPROC)glewGetProcAddress((const GLubyte*)"glUniform1f")) == NULL) || r;
    3150. 

  3150.   r = ((glUniform1fv = (PFNGLUNIFORM1FVPROC)glewGetProcAddress((const GLubyte*)"glUniform1fv")) == NULL) || r;
    3151. 

  3151.   r = ((glUniform1i = (PFNGLUNIFORM1IPROC)glewGetProcAddress((const GLubyte*)"glUniform1i")) == NULL) || r;
    3152. 

  3152.   r = ((glUniform1iv = (PFNGLUNIFORM1IVPROC)glewGetProcAddress((const GLubyte*)"glUniform1iv")) == NULL) || r;
    3153. 

  3153.   r = ((glUniform2f = (PFNGLUNIFORM2FPROC)glewGetProcAddress((const GLubyte*)"glUniform2f")) == NULL) || r;
    3154. 

  3154.   r = ((glUniform2fv = (PFNGLUNIFORM2FVPROC)glewGetProcAddress((const GLubyte*)"glUniform2fv")) == NULL) || r;
    3155. 

  3155.   r = ((glUniform2i = (PFNGLUNIFORM2IPROC)glewGetProcAddress((const GLubyte*)"glUniform2i")) == NULL) || r;
    3156. 

  3156.   r = ((glUniform2iv = (PFNGLUNIFORM2IVPROC)glewGetProcAddress((const GLubyte*)"glUniform2iv")) == NULL) || r;
    3157. 

  3157.   r = ((glUniform3f = (PFNGLUNIFORM3FPROC)glewGetProcAddress((const GLubyte*)"glUniform3f")) == NULL) || r;
    3158. 

  3158.   r = ((glUniform3fv = (PFNGLUNIFORM3FVPROC)glewGetProcAddress((const GLubyte*)"glUniform3fv")) == NULL) || r;
    3159. 

  3159.   r = ((glUniform3i = (PFNGLUNIFORM3IPROC)glewGetProcAddress((const GLubyte*)"glUniform3i")) == NULL) || r;
    3160. 

  3160.   r = ((glUniform3iv = (PFNGLUNIFORM3IVPROC)glewGetProcAddress((const GLubyte*)"glUniform3iv")) == NULL) || r;
    3161. 

  3161.   r = ((glUniform4f = (PFNGLUNIFORM4FPROC)glewGetProcAddress((const GLubyte*)"glUniform4f")) == NULL) || r;
    3162. 

  3162.   r = ((glUniform4fv = (PFNGLUNIFORM4FVPROC)glewGetProcAddress((const GLubyte*)"glUniform4fv")) == NULL) || r;
    3163. 

  3163.   r = ((glUniform4i = (PFNGLUNIFORM4IPROC)glewGetProcAddress((const GLubyte*)"glUniform4i")) == NULL) || r;
    3164. 

  3164.   r = ((glUniform4iv = (PFNGLUNIFORM4IVPROC)glewGetProcAddress((const GLubyte*)"glUniform4iv")) == NULL) || r;
    3165. 

  3165.   r = ((glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2fv")) == NULL) || r;
    3166. 

  3166.   r = ((glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3fv")) == NULL) || r;
    3167. 

  3167.   r = ((glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4fv")) == NULL) || r;
    3168. 

  3168.   r = ((glUseProgram = (PFNGLUSEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glUseProgram")) == NULL) || r;
    3169. 

  3169.   r = ((glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glValidateProgram")) == NULL) || r;
    3170. 

  3170.   r = ((glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1d")) == NULL) || r;
    3171. 

  3171.   r = ((glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dv")) == NULL) || r;
    3172. 

  3172.   r = ((glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1f")) == NULL) || r;
    3173. 

  3173.   r = ((glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fv")) == NULL) || r;
    3174. 

  3174.   r = ((glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1s")) == NULL) || r;
    3175. 

  3175.   r = ((glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sv")) == NULL) || r;
    3176. 

  3176.   r = ((glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2d")) == NULL) || r;
    3177. 

  3177.   r = ((glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dv")) == NULL) || r;
    3178. 

  3178.   r = ((glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2f")) == NULL) || r;
    3179. 

  3179.   r = ((glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fv")) == NULL) || r;
    3180. 

  3180.   r = ((glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2s")) == NULL) || r;
    3181. 

  3181.   r = ((glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sv")) == NULL) || r;
    3182. 

  3182.   r = ((glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3d")) == NULL) || r;
    3183. 

  3183.   r = ((glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dv")) == NULL) || r;
    3184. 

  3184.   r = ((glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3f")) == NULL) || r;
    3185. 

  3185.   r = ((glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fv")) == NULL) || r;
    3186. 

  3186.   r = ((glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3s")) == NULL) || r;
    3187. 

  3187.   r = ((glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sv")) == NULL) || r;
    3188. 

  3188.   r = ((glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nbv")) == NULL) || r;
    3189. 

  3189.   r = ((glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Niv")) == NULL) || r;
    3190. 

  3190.   r = ((glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nsv")) == NULL) || r;
    3191. 

  3191.   r = ((glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nub")) == NULL) || r;
    3192. 

  3192.   r = ((glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nubv")) == NULL) || r;
    3193. 

  3193.   r = ((glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nuiv")) == NULL) || r;
    3194. 

  3194.   r = ((glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nusv")) == NULL) || r;
    3195. 

  3195.   r = ((glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4bv")) == NULL) || r;
    3196. 

  3196.   r = ((glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4d")) == NULL) || r;
    3197. 

  3197.   r = ((glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dv")) == NULL) || r;
    3198. 

  3198.   r = ((glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4f")) == NULL) || r;
    3199. 

  3199.   r = ((glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fv")) == NULL) || r;
    3200. 

  3200.   r = ((glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4iv")) == NULL) || r;
    3201. 

  3201.   r = ((glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4s")) == NULL) || r;
    3202. 

  3202.   r = ((glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sv")) == NULL) || r;
    3203. 

  3203.   r = ((glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubv")) == NULL) || r;
    3204. 

  3204.   r = ((glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4uiv")) == NULL) || r;
    3205. 

  3205.   r = ((glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4usv")) == NULL) || r;
    3206. 

  3206.   r = ((glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointer")) == NULL) || r;
    3207. 

  3207. 

  3208.   return r;
    3209. 

  3209. }
    3210. 

  3210. 

  3211. #endif /* GL_VERSION_2_0 */
    3212. 

  3212. 

  3213. #ifdef GL_VERSION_2_1
    3214. 

  3214. 

  3215. static GLboolean _glewInit_GL_VERSION_2_1 (GLEW_CONTEXT_ARG_DEF_INIT)
    3216. 

  3216. {
    3217. 

  3217.   GLboolean r = GL_FALSE;
    3218. 

  3218. 

  3219.   r = ((glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x3fv")) == NULL) || r;
    3220. 

  3220.   r = ((glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x4fv")) == NULL) || r;
    3221. 

  3221.   r = ((glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x2fv")) == NULL) || r;
    3222. 

  3222.   r = ((glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x4fv")) == NULL) || r;
    3223. 

  3223.   r = ((glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x2fv")) == NULL) || r;
    3224. 

  3224.   r = ((glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x3fv")) == NULL) || r;
    3225. 

  3225. 

  3226.   return r;
    3227. 

  3227. }
    3228. 

  3228. 

  3229. #endif /* GL_VERSION_2_1 */
    3230. 

  3230. 

  3231. #ifdef GL_VERSION_3_0
    3232. 

  3232. 

  3233. static GLboolean _glewInit_GL_VERSION_3_0 (GLEW_CONTEXT_ARG_DEF_INIT)
    3234. 

  3234. {
    3235. 

  3235.   GLboolean r = GL_FALSE;
    3236. 

  3236. 

  3237.   r = ((glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRender")) == NULL) || r;
    3238. 

  3238.   r = ((glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedback")) == NULL) || r;
    3239. 

  3239.   r = ((glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocation")) == NULL) || r;
    3240. 

  3240.   r = ((glClampColor = (PFNGLCLAMPCOLORPROC)glewGetProcAddress((const GLubyte*)"glClampColor")) == NULL) || r;
    3241. 

  3241.   r = ((glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)glewGetProcAddress((const GLubyte*)"glClearBufferfi")) == NULL) || r;
    3242. 

  3242.   r = ((glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferfv")) == NULL) || r;
    3243. 

  3243.   r = ((glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferiv")) == NULL) || r;
    3244. 

  3244.   r = ((glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferuiv")) == NULL) || r;
    3245. 

  3245.   r = ((glColorMaski = (PFNGLCOLORMASKIPROC)glewGetProcAddress((const GLubyte*)"glColorMaski")) == NULL) || r;
    3246. 

  3246.   r = ((glDisablei = (PFNGLDISABLEIPROC)glewGetProcAddress((const GLubyte*)"glDisablei")) == NULL) || r;
    3247. 

  3247.   r = ((glEnablei = (PFNGLENABLEIPROC)glewGetProcAddress((const GLubyte*)"glEnablei")) == NULL) || r;
    3248. 

  3248.   r = ((glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)glewGetProcAddress((const GLubyte*)"glEndConditionalRender")) == NULL) || r;
    3249. 

  3249.   r = ((glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedback")) == NULL) || r;
    3250. 

  3250.   r = ((glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)glewGetProcAddress((const GLubyte*)"glGetBooleani_v")) == NULL) || r;
    3251. 

  3251.   r = ((glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataLocation")) == NULL) || r;
    3252. 

  3252.   r = ((glGetStringi = (PFNGLGETSTRINGIPROC)glewGetProcAddress((const GLubyte*)"glGetStringi")) == NULL) || r;
    3253. 

  3253.   r = ((glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIiv")) == NULL) || r;
    3254. 

  3254.   r = ((glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIuiv")) == NULL) || r;
    3255. 

  3255.   r = ((glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVarying")) == NULL) || r;
    3256. 

  3256.   r = ((glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformuiv")) == NULL) || r;
    3257. 

  3257.   r = ((glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIiv")) == NULL) || r;
    3258. 

  3258.   r = ((glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIuiv")) == NULL) || r;
    3259. 

  3259.   r = ((glIsEnabledi = (PFNGLISENABLEDIPROC)glewGetProcAddress((const GLubyte*)"glIsEnabledi")) == NULL) || r;
    3260. 

  3260.   r = ((glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIiv")) == NULL) || r;
    3261. 

  3261.   r = ((glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIuiv")) == NULL) || r;
    3262. 

  3262.   r = ((glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryings")) == NULL) || r;
    3263. 

  3263.   r = ((glUniform1ui = (PFNGLUNIFORM1UIPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui")) == NULL) || r;
    3264. 

  3264.   r = ((glUniform1uiv = (PFNGLUNIFORM1UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform1uiv")) == NULL) || r;
    3265. 

  3265.   r = ((glUniform2ui = (PFNGLUNIFORM2UIPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui")) == NULL) || r;
    3266. 

  3266.   r = ((glUniform2uiv = (PFNGLUNIFORM2UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform2uiv")) == NULL) || r;
    3267. 

  3267.   r = ((glUniform3ui = (PFNGLUNIFORM3UIPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui")) == NULL) || r;
    3268. 

  3268.   r = ((glUniform3uiv = (PFNGLUNIFORM3UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform3uiv")) == NULL) || r;
    3269. 

  3269.   r = ((glUniform4ui = (PFNGLUNIFORM4UIPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui")) == NULL) || r;
    3270. 

  3270.   r = ((glUniform4uiv = (PFNGLUNIFORM4UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform4uiv")) == NULL) || r;
    3271. 

  3271.   r = ((glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1i")) == NULL) || r;
    3272. 

  3272.   r = ((glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1iv")) == NULL) || r;
    3273. 

  3273.   r = ((glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1ui")) == NULL) || r;
    3274. 

  3274.   r = ((glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uiv")) == NULL) || r;
    3275. 

  3275.   r = ((glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2i")) == NULL) || r;
    3276. 

  3276.   r = ((glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2iv")) == NULL) || r;
    3277. 

  3277.   r = ((glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2ui")) == NULL) || r;
    3278. 

  3278.   r = ((glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uiv")) == NULL) || r;
    3279. 

  3279.   r = ((glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3i")) == NULL) || r;
    3280. 

  3280.   r = ((glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3iv")) == NULL) || r;
    3281. 

  3281.   r = ((glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3ui")) == NULL) || r;
    3282. 

  3282.   r = ((glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uiv")) == NULL) || r;
    3283. 

  3283.   r = ((glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4bv")) == NULL) || r;
    3284. 

  3284.   r = ((glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4i")) == NULL) || r;
    3285. 

  3285.   r = ((glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4iv")) == NULL) || r;
    3286. 

  3286.   r = ((glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4sv")) == NULL) || r;
    3287. 

  3287.   r = ((glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ubv")) == NULL) || r;
    3288. 

  3288.   r = ((glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ui")) == NULL) || r;
    3289. 

  3289.   r = ((glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uiv")) == NULL) || r;
    3290. 

  3290.   r = ((glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4usv")) == NULL) || r;
    3291. 

  3291.   r = ((glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIPointer")) == NULL) || r;
    3292. 

  3292. 

  3293.   return r;
    3294. 

  3294. }
    3295. 

  3295. 

  3296. #endif /* GL_VERSION_3_0 */
    3297. 

  3297. 

  3298. #ifdef GL_VERSION_3_1
    3299. 

  3299. 

  3300. static GLboolean _glewInit_GL_VERSION_3_1 (GLEW_CONTEXT_ARG_DEF_INIT)
    3301. 

  3301. {
    3302. 

  3302.   GLboolean r = GL_FALSE;
    3303. 

  3303. 

  3304.   r = ((glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstanced")) == NULL) || r;
    3305. 

  3305.   r = ((glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstanced")) == NULL) || r;
    3306. 

  3306.   r = ((glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartIndex")) == NULL) || r;
    3307. 

  3307.   r = ((glTexBuffer = (PFNGLTEXBUFFERPROC)glewGetProcAddress((const GLubyte*)"glTexBuffer")) == NULL) || r;
    3308. 

  3308. 

  3309.   return r;
    3310. 

  3310. }
    3311. 

  3311. 

  3312. #endif /* GL_VERSION_3_1 */
    3313. 

  3313. 

  3314. #ifdef GL_VERSION_3_2
    3315. 

  3315. 

  3316. static GLboolean _glewInit_GL_VERSION_3_2 (GLEW_CONTEXT_ARG_DEF_INIT)
    3317. 

  3317. {
    3318. 

  3318.   GLboolean r = GL_FALSE;
    3319. 

  3319. 

  3320.   r = ((glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture")) == NULL) || r;
    3321. 

  3321.   r = ((glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameteri64v")) == NULL) || r;
    3322. 

  3322.   r = ((glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)glewGetProcAddress((const GLubyte*)"glGetInteger64i_v")) == NULL) || r;
    3323. 

  3323. 

  3324.   return r;
    3325. 

  3325. }
    3326. 

  3326. 

  3327. #endif /* GL_VERSION_3_2 */
    3328. 

  3328. 

  3329. #ifdef GL_VERSION_3_3
    3330. 

  3330. 

  3331. static GLboolean _glewInit_GL_VERSION_3_3 (GLEW_CONTEXT_ARG_DEF_INIT)
    3332. 

  3332. {
    3333. 

  3333.   GLboolean r = GL_FALSE;
    3334. 

  3334. 

  3335.   r = ((glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisor")) == NULL) || r;
    3336. 

  3336. 

  3337.   return r;
    3338. 

  3338. }
    3339. 

  3339. 

  3340. #endif /* GL_VERSION_3_3 */
    3341. 

  3341. 

  3342. #ifdef GL_VERSION_4_0
    3343. 

  3343. 

  3344. static GLboolean _glewInit_GL_VERSION_4_0 (GLEW_CONTEXT_ARG_DEF_INIT)
    3345. 

  3345. {
    3346. 

  3346.   GLboolean r = GL_FALSE;
    3347. 

  3347. 

  3348.   r = ((glBlendEquationSeparatei = (PFNGLBLENDEQUATIONSEPARATEIPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparatei")) == NULL) || r;
    3349. 

  3349.   r = ((glBlendEquationi = (PFNGLBLENDEQUATIONIPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationi")) == NULL) || r;
    3350. 

  3350.   r = ((glBlendFuncSeparatei = (PFNGLBLENDFUNCSEPARATEIPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparatei")) == NULL) || r;
    3351. 

  3351.   r = ((glBlendFunci = (PFNGLBLENDFUNCIPROC)glewGetProcAddress((const GLubyte*)"glBlendFunci")) == NULL) || r;
    3352. 

  3352.   r = ((glMinSampleShading = (PFNGLMINSAMPLESHADINGPROC)glewGetProcAddress((const GLubyte*)"glMinSampleShading")) == NULL) || r;
    3353. 

  3353. 

  3354.   return r;
    3355. 

  3355. }
    3356. 

  3356. 

  3357. #endif /* GL_VERSION_4_0 */
    3358. 

  3358. 

  3359. #ifdef GL_VERSION_4_1
    3360. 

  3360. 

  3361. #endif /* GL_VERSION_4_1 */
    3362. 

  3362. 

  3363. #ifdef GL_VERSION_4_2
    3364. 

  3364. 

  3365. #endif /* GL_VERSION_4_2 */
    3366. 

  3366. 

  3367. #ifdef GL_3DFX_multisample
    3368. 

  3368. 

  3369. #endif /* GL_3DFX_multisample */
    3370. 

  3370. 

  3371. #ifdef GL_3DFX_tbuffer
    3372. 

  3372. 

  3373. static GLboolean _glewInit_GL_3DFX_tbuffer (GLEW_CONTEXT_ARG_DEF_INIT)
    3374. 

  3374. {
    3375. 

  3375.   GLboolean r = GL_FALSE;
    3376. 

  3376. 

  3377.   r = ((glTbufferMask3DFX = (PFNGLTBUFFERMASK3DFXPROC)glewGetProcAddress((const GLubyte*)"glTbufferMask3DFX")) == NULL) || r;
    3378. 

  3378. 

  3379.   return r;
    3380. 

  3380. }
    3381. 

  3381. 

  3382. #endif /* GL_3DFX_tbuffer */
    3383. 

  3383. 

  3384. #ifdef GL_3DFX_texture_compression_FXT1
    3385. 

  3385. 

  3386. #endif /* GL_3DFX_texture_compression_FXT1 */
    3387. 

  3387. 

  3388. #ifdef GL_AMD_blend_minmax_factor
    3389. 

  3389. 

  3390. #endif /* GL_AMD_blend_minmax_factor */
    3391. 

  3391. 

  3392. #ifdef GL_AMD_conservative_depth
    3393. 

  3393. 

  3394. #endif /* GL_AMD_conservative_depth */
    3395. 

  3395. 

  3396. #ifdef GL_AMD_debug_output
    3397. 

  3397. 

  3398. static GLboolean _glewInit_GL_AMD_debug_output (GLEW_CONTEXT_ARG_DEF_INIT)
    3399. 

  3399. {
    3400. 

  3400.   GLboolean r = GL_FALSE;
    3401. 

  3401. 

  3402.   r = ((glDebugMessageCallbackAMD = (PFNGLDEBUGMESSAGECALLBACKAMDPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageCallbackAMD")) == NULL) || r;
    3403. 

  3403.   r = ((glDebugMessageEnableAMD = (PFNGLDEBUGMESSAGEENABLEAMDPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageEnableAMD")) == NULL) || r;
    3404. 

  3404.   r = ((glDebugMessageInsertAMD = (PFNGLDEBUGMESSAGEINSERTAMDPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageInsertAMD")) == NULL) || r;
    3405. 

  3405.   r = ((glGetDebugMessageLogAMD = (PFNGLGETDEBUGMESSAGELOGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetDebugMessageLogAMD")) == NULL) || r;
    3406. 

  3406. 

  3407.   return r;
    3408. 

  3408. }
    3409. 

  3409. 

  3410. #endif /* GL_AMD_debug_output */
    3411. 

  3411. 

  3412. #ifdef GL_AMD_depth_clamp_separate
    3413. 

  3413. 

  3414. #endif /* GL_AMD_depth_clamp_separate */
    3415. 

  3415. 

  3416. #ifdef GL_AMD_draw_buffers_blend
    3417. 

  3417. 

  3418. static GLboolean _glewInit_GL_AMD_draw_buffers_blend (GLEW_CONTEXT_ARG_DEF_INIT)
    3419. 

  3419. {
    3420. 

  3420.   GLboolean r = GL_FALSE;
    3421. 

  3421. 

  3422.   r = ((glBlendEquationIndexedAMD = (PFNGLBLENDEQUATIONINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationIndexedAMD")) == NULL) || r;
    3423. 

  3423.   r = ((glBlendEquationSeparateIndexedAMD = (PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateIndexedAMD")) == NULL) || r;
    3424. 

  3424.   r = ((glBlendFuncIndexedAMD = (PFNGLBLENDFUNCINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncIndexedAMD")) == NULL) || r;
    3425. 

  3425.   r = ((glBlendFuncSeparateIndexedAMD = (PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateIndexedAMD")) == NULL) || r;
    3426. 

  3426. 

  3427.   return r;
    3428. 

  3428. }
    3429. 

  3429. 

  3430. #endif /* GL_AMD_draw_buffers_blend */
    3431. 

  3431. 

  3432. #ifdef GL_AMD_multi_draw_indirect
    3433. 

  3433. 

  3434. static GLboolean _glewInit_GL_AMD_multi_draw_indirect (GLEW_CONTEXT_ARG_DEF_INIT)
    3435. 

  3435. {
    3436. 

  3436.   GLboolean r = GL_FALSE;
    3437. 

  3437. 

  3438.   r = ((glMultiDrawArraysIndirectAMD = (PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirectAMD")) == NULL) || r;
    3439. 

  3439.   r = ((glMultiDrawElementsIndirectAMD = (PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirectAMD")) == NULL) || r;
    3440. 

  3440. 

  3441.   return r;
    3442. 

  3442. }
    3443. 

  3443. 

  3444. #endif /* GL_AMD_multi_draw_indirect */
    3445. 

  3445. 

  3446. #ifdef GL_AMD_name_gen_delete
    3447. 

  3447. 

  3448. static GLboolean _glewInit_GL_AMD_name_gen_delete (GLEW_CONTEXT_ARG_DEF_INIT)
    3449. 

  3449. {
    3450. 

  3450.   GLboolean r = GL_FALSE;
    3451. 

  3451. 

  3452.   r = ((glDeleteNamesAMD = (PFNGLDELETENAMESAMDPROC)glewGetProcAddress((const GLubyte*)"glDeleteNamesAMD")) == NULL) || r;
    3453. 

  3453.   r = ((glGenNamesAMD = (PFNGLGENNAMESAMDPROC)glewGetProcAddress((const GLubyte*)"glGenNamesAMD")) == NULL) || r;
    3454. 

  3454.   r = ((glIsNameAMD = (PFNGLISNAMEAMDPROC)glewGetProcAddress((const GLubyte*)"glIsNameAMD")) == NULL) || r;
    3455. 

  3455. 

  3456.   return r;
    3457. 

  3457. }
    3458. 

  3458. 

  3459. #endif /* GL_AMD_name_gen_delete */
    3460. 

  3460. 

  3461. #ifdef GL_AMD_performance_monitor
    3462. 

  3462. 

  3463. static GLboolean _glewInit_GL_AMD_performance_monitor (GLEW_CONTEXT_ARG_DEF_INIT)
    3464. 

  3464. {
    3465. 

  3465.   GLboolean r = GL_FALSE;
    3466. 

  3466. 

  3467.   r = ((glBeginPerfMonitorAMD = (PFNGLBEGINPERFMONITORAMDPROC)glewGetProcAddress((const GLubyte*)"glBeginPerfMonitorAMD")) == NULL) || r;
    3468. 

  3468.   r = ((glDeletePerfMonitorsAMD = (PFNGLDELETEPERFMONITORSAMDPROC)glewGetProcAddress((const GLubyte*)"glDeletePerfMonitorsAMD")) == NULL) || r;
    3469. 

  3469.   r = ((glEndPerfMonitorAMD = (PFNGLENDPERFMONITORAMDPROC)glewGetProcAddress((const GLubyte*)"glEndPerfMonitorAMD")) == NULL) || r;
    3470. 

  3470.   r = ((glGenPerfMonitorsAMD = (PFNGLGENPERFMONITORSAMDPROC)glewGetProcAddress((const GLubyte*)"glGenPerfMonitorsAMD")) == NULL) || r;
    3471. 

  3471.   r = ((glGetPerfMonitorCounterDataAMD = (PFNGLGETPERFMONITORCOUNTERDATAAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterDataAMD")) == NULL) || r;
    3472. 

  3472.   r = ((glGetPerfMonitorCounterInfoAMD = (PFNGLGETPERFMONITORCOUNTERINFOAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterInfoAMD")) == NULL) || r;
    3473. 

  3473.   r = ((glGetPerfMonitorCounterStringAMD = (PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCounterStringAMD")) == NULL) || r;
    3474. 

  3474.   r = ((glGetPerfMonitorCountersAMD = (PFNGLGETPERFMONITORCOUNTERSAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorCountersAMD")) == NULL) || r;
    3475. 

  3475.   r = ((glGetPerfMonitorGroupStringAMD = (PFNGLGETPERFMONITORGROUPSTRINGAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorGroupStringAMD")) == NULL) || r;
    3476. 

  3476.   r = ((glGetPerfMonitorGroupsAMD = (PFNGLGETPERFMONITORGROUPSAMDPROC)glewGetProcAddress((const GLubyte*)"glGetPerfMonitorGroupsAMD")) == NULL) || r;
    3477. 

  3477.   r = ((glSelectPerfMonitorCountersAMD = (PFNGLSELECTPERFMONITORCOUNTERSAMDPROC)glewGetProcAddress((const GLubyte*)"glSelectPerfMonitorCountersAMD")) == NULL) || r;
    3478. 

  3478. 

  3479.   return r;
    3480. 

  3480. }
    3481. 

  3481. 

  3482. #endif /* GL_AMD_performance_monitor */
    3483. 

  3483. 

  3484. #ifdef GL_AMD_sample_positions
    3485. 

  3485. 

  3486. static GLboolean _glewInit_GL_AMD_sample_positions (GLEW_CONTEXT_ARG_DEF_INIT)
    3487. 

  3487. {
    3488. 

  3488.   GLboolean r = GL_FALSE;
    3489. 

  3489. 

  3490.   r = ((glSetMultisamplefvAMD = (PFNGLSETMULTISAMPLEFVAMDPROC)glewGetProcAddress((const GLubyte*)"glSetMultisamplefvAMD")) == NULL) || r;
    3491. 

  3491. 

  3492.   return r;
    3493. 

  3493. }
    3494. 

  3494. 

  3495. #endif /* GL_AMD_sample_positions */
    3496. 

  3496. 

  3497. #ifdef GL_AMD_seamless_cubemap_per_texture
    3498. 

  3498. 

  3499. #endif /* GL_AMD_seamless_cubemap_per_texture */
    3500. 

  3500. 

  3501. #ifdef GL_AMD_shader_stencil_export
    3502. 

  3502. 

  3503. #endif /* GL_AMD_shader_stencil_export */
    3504. 

  3504. 

  3505. #ifdef GL_AMD_texture_texture4
    3506. 

  3506. 

  3507. #endif /* GL_AMD_texture_texture4 */
    3508. 

  3508. 

  3509. #ifdef GL_AMD_transform_feedback3_lines_triangles
    3510. 

  3510. 

  3511. #endif /* GL_AMD_transform_feedback3_lines_triangles */
    3512. 

  3512. 

  3513. #ifdef GL_AMD_vertex_shader_tessellator
    3514. 

  3514. 

  3515. static GLboolean _glewInit_GL_AMD_vertex_shader_tessellator (GLEW_CONTEXT_ARG_DEF_INIT)
    3516. 

  3516. {
    3517. 

  3517.   GLboolean r = GL_FALSE;
    3518. 

  3518. 

  3519.   r = ((glTessellationFactorAMD = (PFNGLTESSELLATIONFACTORAMDPROC)glewGetProcAddress((const GLubyte*)"glTessellationFactorAMD")) == NULL) || r;
    3520. 

  3520.   r = ((glTessellationModeAMD = (PFNGLTESSELLATIONMODEAMDPROC)glewGetProcAddress((const GLubyte*)"glTessellationModeAMD")) == NULL) || r;
    3521. 

  3521. 

  3522.   return r;
    3523. 

  3523. }
    3524. 

  3524. 

  3525. #endif /* GL_AMD_vertex_shader_tessellator */
    3526. 

  3526. 

  3527. #ifdef GL_APPLE_aux_depth_stencil
    3528. 

  3528. 

  3529. #endif /* GL_APPLE_aux_depth_stencil */
    3530. 

  3530. 

  3531. #ifdef GL_APPLE_client_storage
    3532. 

  3532. 

  3533. #endif /* GL_APPLE_client_storage */
    3534. 

  3534. 

  3535. #ifdef GL_APPLE_element_array
    3536. 

  3536. 

  3537. static GLboolean _glewInit_GL_APPLE_element_array (GLEW_CONTEXT_ARG_DEF_INIT)
    3538. 

  3538. {
    3539. 

  3539.   GLboolean r = GL_FALSE;
    3540. 

  3540. 

  3541.   r = ((glDrawElementArrayAPPLE = (PFNGLDRAWELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementArrayAPPLE")) == NULL) || r;
    3542. 

  3542.   r = ((glDrawRangeElementArrayAPPLE = (PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementArrayAPPLE")) == NULL) || r;
    3543. 

  3543.   r = ((glElementPointerAPPLE = (PFNGLELEMENTPOINTERAPPLEPROC)glewGetProcAddress((const GLubyte*)"glElementPointerAPPLE")) == NULL) || r;
    3544. 

  3544.   r = ((glMultiDrawElementArrayAPPLE = (PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementArrayAPPLE")) == NULL) || r;
    3545. 

  3545.   r = ((glMultiDrawRangeElementArrayAPPLE = (PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawRangeElementArrayAPPLE")) == NULL) || r;
    3546. 

  3546. 

  3547.   return r;
    3548. 

  3548. }
    3549. 

  3549. 

  3550. #endif /* GL_APPLE_element_array */
    3551. 

  3551. 

  3552. #ifdef GL_APPLE_fence
    3553. 

  3553. 

  3554. static GLboolean _glewInit_GL_APPLE_fence (GLEW_CONTEXT_ARG_DEF_INIT)
    3555. 

  3555. {
    3556. 

  3556.   GLboolean r = GL_FALSE;
    3557. 

  3557. 

  3558.   r = ((glDeleteFencesAPPLE = (PFNGLDELETEFENCESAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDeleteFencesAPPLE")) == NULL) || r;
    3559. 

  3559.   r = ((glFinishFenceAPPLE = (PFNGLFINISHFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFinishFenceAPPLE")) == NULL) || r;
    3560. 

  3560.   r = ((glFinishObjectAPPLE = (PFNGLFINISHOBJECTAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFinishObjectAPPLE")) == NULL) || r;
    3561. 

  3561.   r = ((glGenFencesAPPLE = (PFNGLGENFENCESAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGenFencesAPPLE")) == NULL) || r;
    3562. 

  3562.   r = ((glIsFenceAPPLE = (PFNGLISFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsFenceAPPLE")) == NULL) || r;
    3563. 

  3563.   r = ((glSetFenceAPPLE = (PFNGLSETFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glSetFenceAPPLE")) == NULL) || r;
    3564. 

  3564.   r = ((glTestFenceAPPLE = (PFNGLTESTFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTestFenceAPPLE")) == NULL) || r;
    3565. 

  3565.   r = ((glTestObjectAPPLE = (PFNGLTESTOBJECTAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTestObjectAPPLE")) == NULL) || r;
    3566. 

  3566. 

  3567.   return r;
    3568. 

  3568. }
    3569. 

  3569. 

  3570. #endif /* GL_APPLE_fence */
    3571. 

  3571. 

  3572. #ifdef GL_APPLE_float_pixels
    3573. 

  3573. 

  3574. #endif /* GL_APPLE_float_pixels */
    3575. 

  3575. 

  3576. #ifdef GL_APPLE_flush_buffer_range
    3577. 

  3577. 

  3578. static GLboolean _glewInit_GL_APPLE_flush_buffer_range (GLEW_CONTEXT_ARG_DEF_INIT)
    3579. 

  3579. {
    3580. 

  3580.   GLboolean r = GL_FALSE;
    3581. 

  3581. 

  3582.   r = ((glBufferParameteriAPPLE = (PFNGLBUFFERPARAMETERIAPPLEPROC)glewGetProcAddress((const GLubyte*)"glBufferParameteriAPPLE")) == NULL) || r;
    3583. 

  3583.   r = ((glFlushMappedBufferRangeAPPLE = (PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedBufferRangeAPPLE")) == NULL) || r;
    3584. 

  3584. 

  3585.   return r;
    3586. 

  3586. }
    3587. 

  3587. 

  3588. #endif /* GL_APPLE_flush_buffer_range */
    3589. 

  3589. 

  3590. #ifdef GL_APPLE_object_purgeable
    3591. 

  3591. 

  3592. static GLboolean _glewInit_GL_APPLE_object_purgeable (GLEW_CONTEXT_ARG_DEF_INIT)
    3593. 

  3593. {
    3594. 

  3594.   GLboolean r = GL_FALSE;
    3595. 

  3595. 

  3596.   r = ((glGetObjectParameterivAPPLE = (PFNGLGETOBJECTPARAMETERIVAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterivAPPLE")) == NULL) || r;
    3597. 

  3597.   r = ((glObjectPurgeableAPPLE = (PFNGLOBJECTPURGEABLEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glObjectPurgeableAPPLE")) == NULL) || r;
    3598. 

  3598.   r = ((glObjectUnpurgeableAPPLE = (PFNGLOBJECTUNPURGEABLEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glObjectUnpurgeableAPPLE")) == NULL) || r;
    3599. 

  3599. 

  3600.   return r;
    3601. 

  3601. }
    3602. 

  3602. 

  3603. #endif /* GL_APPLE_object_purgeable */
    3604. 

  3604. 

  3605. #ifdef GL_APPLE_pixel_buffer
    3606. 

  3606. 

  3607. #endif /* GL_APPLE_pixel_buffer */
    3608. 

  3608. 

  3609. #ifdef GL_APPLE_rgb_422
    3610. 

  3610. 

  3611. #endif /* GL_APPLE_rgb_422 */
    3612. 

  3612. 

  3613. #ifdef GL_APPLE_row_bytes
    3614. 

  3614. 

  3615. #endif /* GL_APPLE_row_bytes */
    3616. 

  3616. 

  3617. #ifdef GL_APPLE_specular_vector
    3618. 

  3618. 

  3619. #endif /* GL_APPLE_specular_vector */
    3620. 

  3620. 

  3621. #ifdef GL_APPLE_texture_range
    3622. 

  3622. 

  3623. static GLboolean _glewInit_GL_APPLE_texture_range (GLEW_CONTEXT_ARG_DEF_INIT)
    3624. 

  3624. {
    3625. 

  3625.   GLboolean r = GL_FALSE;
    3626. 

  3626. 

  3627.   r = ((glGetTexParameterPointervAPPLE = (PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterPointervAPPLE")) == NULL) || r;
    3628. 

  3628.   r = ((glTextureRangeAPPLE = (PFNGLTEXTURERANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTextureRangeAPPLE")) == NULL) || r;
    3629. 

  3629. 

  3630.   return r;
    3631. 

  3631. }
    3632. 

  3632. 

  3633. #endif /* GL_APPLE_texture_range */
    3634. 

  3634. 

  3635. #ifdef GL_APPLE_transform_hint
    3636. 

  3636. 

  3637. #endif /* GL_APPLE_transform_hint */
    3638. 

  3638. 

  3639. #ifdef GL_APPLE_vertex_array_object
    3640. 

  3640. 

  3641. static GLboolean _glewInit_GL_APPLE_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT)
    3642. 

  3642. {
    3643. 

  3643.   GLboolean r = GL_FALSE;
    3644. 

  3644. 

  3645.   r = ((glBindVertexArrayAPPLE = (PFNGLBINDVERTEXARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glBindVertexArrayAPPLE")) == NULL) || r;
    3646. 

  3646.   r = ((glDeleteVertexArraysAPPLE = (PFNGLDELETEVERTEXARRAYSAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexArraysAPPLE")) == NULL) || r;
    3647. 

  3647.   r = ((glGenVertexArraysAPPLE = (PFNGLGENVERTEXARRAYSAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGenVertexArraysAPPLE")) == NULL) || r;
    3648. 

  3648.   r = ((glIsVertexArrayAPPLE = (PFNGLISVERTEXARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsVertexArrayAPPLE")) == NULL) || r;
    3649. 

  3649. 

  3650.   return r;
    3651. 

  3651. }
    3652. 

  3652. 

  3653. #endif /* GL_APPLE_vertex_array_object */
    3654. 

  3654. 

  3655. #ifdef GL_APPLE_vertex_array_range
    3656. 

  3656. 

  3657. static GLboolean _glewInit_GL_APPLE_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT)
    3658. 

  3658. {
    3659. 

  3659.   GLboolean r = GL_FALSE;
    3660. 

  3660. 

  3661.   r = ((glFlushVertexArrayRangeAPPLE = (PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFlushVertexArrayRangeAPPLE")) == NULL) || r;
    3662. 

  3662.   r = ((glVertexArrayParameteriAPPLE = (PFNGLVERTEXARRAYPARAMETERIAPPLEPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayParameteriAPPLE")) == NULL) || r;
    3663. 

  3663.   r = ((glVertexArrayRangeAPPLE = (PFNGLVERTEXARRAYRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayRangeAPPLE")) == NULL) || r;
    3664. 

  3664. 

  3665.   return r;
    3666. 

  3666. }
    3667. 

  3667. 

  3668. #endif /* GL_APPLE_vertex_array_range */
    3669. 

  3669. 

  3670. #ifdef GL_APPLE_vertex_program_evaluators
    3671. 

  3671. 

  3672. static GLboolean _glewInit_GL_APPLE_vertex_program_evaluators (GLEW_CONTEXT_ARG_DEF_INIT)
    3673. 

  3673. {
    3674. 

  3674.   GLboolean r = GL_FALSE;
    3675. 

  3675. 

  3676.   r = ((glDisableVertexAttribAPPLE = (PFNGLDISABLEVERTEXATTRIBAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribAPPLE")) == NULL) || r;
    3677. 

  3677.   r = ((glEnableVertexAttribAPPLE = (PFNGLENABLEVERTEXATTRIBAPPLEPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribAPPLE")) == NULL) || r;
    3678. 

  3678.   r = ((glIsVertexAttribEnabledAPPLE = (PFNGLISVERTEXATTRIBENABLEDAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsVertexAttribEnabledAPPLE")) == NULL) || r;
    3679. 

  3679.   r = ((glMapVertexAttrib1dAPPLE = (PFNGLMAPVERTEXATTRIB1DAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib1dAPPLE")) == NULL) || r;
    3680. 

  3680.   r = ((glMapVertexAttrib1fAPPLE = (PFNGLMAPVERTEXATTRIB1FAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib1fAPPLE")) == NULL) || r;
    3681. 

  3681.   r = ((glMapVertexAttrib2dAPPLE = (PFNGLMAPVERTEXATTRIB2DAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib2dAPPLE")) == NULL) || r;
    3682. 

  3682.   r = ((glMapVertexAttrib2fAPPLE = (PFNGLMAPVERTEXATTRIB2FAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMapVertexAttrib2fAPPLE")) == NULL) || r;
    3683. 

  3683. 

  3684.   return r;
    3685. 

  3685. }
    3686. 

  3686. 

  3687. #endif /* GL_APPLE_vertex_program_evaluators */
    3688. 

  3688. 

  3689. #ifdef GL_APPLE_ycbcr_422
    3690. 

  3690. 

  3691. #endif /* GL_APPLE_ycbcr_422 */
    3692. 

  3692. 

  3693. #ifdef GL_ARB_ES2_compatibility
    3694. 

  3694. 

  3695. static GLboolean _glewInit_GL_ARB_ES2_compatibility (GLEW_CONTEXT_ARG_DEF_INIT)
    3696. 

  3696. {
    3697. 

  3697.   GLboolean r = GL_FALSE;
    3698. 

  3698. 

  3699.   r = ((glClearDepthf = (PFNGLCLEARDEPTHFPROC)glewGetProcAddress((const GLubyte*)"glClearDepthf")) == NULL) || r;
    3700. 

  3700.   r = ((glDepthRangef = (PFNGLDEPTHRANGEFPROC)glewGetProcAddress((const GLubyte*)"glDepthRangef")) == NULL) || r;
    3701. 

  3701.   r = ((glGetShaderPrecisionFormat = (PFNGLGETSHADERPRECISIONFORMATPROC)glewGetProcAddress((const GLubyte*)"glGetShaderPrecisionFormat")) == NULL) || r;
    3702. 

  3702.   r = ((glReleaseShaderCompiler = (PFNGLRELEASESHADERCOMPILERPROC)glewGetProcAddress((const GLubyte*)"glReleaseShaderCompiler")) == NULL) || r;
    3703. 

  3703.   r = ((glShaderBinary = (PFNGLSHADERBINARYPROC)glewGetProcAddress((const GLubyte*)"glShaderBinary")) == NULL) || r;
    3704. 

  3704. 

  3705.   return r;
    3706. 

  3706. }
    3707. 

  3707. 

  3708. #endif /* GL_ARB_ES2_compatibility */
    3709. 

  3709. 

  3710. #ifdef GL_ARB_base_instance
    3711. 

  3711. 

  3712. static GLboolean _glewInit_GL_ARB_base_instance (GLEW_CONTEXT_ARG_DEF_INIT)
    3713. 

  3713. {
    3714. 

  3714.   GLboolean r = GL_FALSE;
    3715. 

  3715. 

  3716.   r = ((glDrawArraysInstancedBaseInstance = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedBaseInstance")) == NULL) || r;
    3717. 

  3717.   r = ((glDrawElementsInstancedBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseInstance")) == NULL) || r;
    3718. 

  3718.   r = ((glDrawElementsInstancedBaseVertexBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseVertexBaseInstance")) == NULL) || r;
    3719. 

  3719. 

  3720.   return r;
    3721. 

  3721. }
    3722. 

  3722. 

  3723. #endif /* GL_ARB_base_instance */
    3724. 

  3724. 

  3725. #ifdef GL_ARB_blend_func_extended
    3726. 

  3726. 

  3727. static GLboolean _glewInit_GL_ARB_blend_func_extended (GLEW_CONTEXT_ARG_DEF_INIT)
    3728. 

  3728. {
    3729. 

  3729.   GLboolean r = GL_FALSE;
    3730. 

  3730. 

  3731.   r = ((glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocationIndexed")) == NULL) || r;
    3732. 

  3732.   r = ((glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataIndex")) == NULL) || r;
    3733. 

  3733. 

  3734.   return r;
    3735. 

  3735. }
    3736. 

  3736. 

  3737. #endif /* GL_ARB_blend_func_extended */
    3738. 

  3738. 

  3739. #ifdef GL_ARB_cl_event
    3740. 

  3740. 

  3741. static GLboolean _glewInit_GL_ARB_cl_event (GLEW_CONTEXT_ARG_DEF_INIT)
    3742. 

  3742. {
    3743. 

  3743.   GLboolean r = GL_FALSE;
    3744. 

  3744. 

  3745.   r = ((glCreateSyncFromCLeventARB = (PFNGLCREATESYNCFROMCLEVENTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateSyncFromCLeventARB")) == NULL) || r;
    3746. 

  3746. 

  3747.   return r;
    3748. 

  3748. }
    3749. 

  3749. 

  3750. #endif /* GL_ARB_cl_event */
    3751. 

  3751. 

  3752. #ifdef GL_ARB_color_buffer_float
    3753. 

  3753. 

  3754. static GLboolean _glewInit_GL_ARB_color_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT)
    3755. 

  3755. {
    3756. 

  3756.   GLboolean r = GL_FALSE;
    3757. 

  3757. 

  3758.   r = ((glClampColorARB = (PFNGLCLAMPCOLORARBPROC)glewGetProcAddress((const GLubyte*)"glClampColorARB")) == NULL) || r;
    3759. 

  3759. 

  3760.   return r;
    3761. 

  3761. }
    3762. 

  3762. 

  3763. #endif /* GL_ARB_color_buffer_float */
    3764. 

  3764. 

  3765. #ifdef GL_ARB_compatibility
    3766. 

  3766. 

  3767. #endif /* GL_ARB_compatibility */
    3768. 

  3768. 

  3769. #ifdef GL_ARB_compressed_texture_pixel_storage
    3770. 

  3770. 

  3771. #endif /* GL_ARB_compressed_texture_pixel_storage */
    3772. 

  3772. 

  3773. #ifdef GL_ARB_conservative_depth
    3774. 

  3774. 

  3775. #endif /* GL_ARB_conservative_depth */
    3776. 

  3776. 

  3777. #ifdef GL_ARB_copy_buffer
    3778. 

  3778. 

  3779. static GLboolean _glewInit_GL_ARB_copy_buffer (GLEW_CONTEXT_ARG_DEF_INIT)
    3780. 

  3780. {
    3781. 

  3781.   GLboolean r = GL_FALSE;
    3782. 

  3782. 

  3783.   r = ((glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glCopyBufferSubData")) == NULL) || r;
    3784. 

  3784. 

  3785.   return r;
    3786. 

  3786. }
    3787. 

  3787. 

  3788. #endif /* GL_ARB_copy_buffer */
    3789. 

  3789. 

  3790. #ifdef GL_ARB_debug_output
    3791. 

  3791. 

  3792. static GLboolean _glewInit_GL_ARB_debug_output (GLEW_CONTEXT_ARG_DEF_INIT)
    3793. 

  3793. {
    3794. 

  3794.   GLboolean r = GL_FALSE;
    3795. 

  3795. 

  3796.   r = ((glDebugMessageCallbackARB = (PFNGLDEBUGMESSAGECALLBACKARBPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageCallbackARB")) == NULL) || r;
    3797. 

  3797.   r = ((glDebugMessageControlARB = (PFNGLDEBUGMESSAGECONTROLARBPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageControlARB")) == NULL) || r;
    3798. 

  3798.   r = ((glDebugMessageInsertARB = (PFNGLDEBUGMESSAGEINSERTARBPROC)glewGetProcAddress((const GLubyte*)"glDebugMessageInsertARB")) == NULL) || r;
    3799. 

  3799.   r = ((glGetDebugMessageLogARB = (PFNGLGETDEBUGMESSAGELOGARBPROC)glewGetProcAddress((const GLubyte*)"glGetDebugMessageLogARB")) == NULL) || r;
    3800. 

  3800. 

  3801.   return r;
    3802. 

  3802. }
    3803. 

  3803. 

  3804. #endif /* GL_ARB_debug_output */
    3805. 

  3805. 

  3806. #ifdef GL_ARB_depth_buffer_float
    3807. 

  3807. 

  3808. #endif /* GL_ARB_depth_buffer_float */
    3809. 

  3809. 

  3810. #ifdef GL_ARB_depth_clamp
    3811. 

  3811. 

  3812. #endif /* GL_ARB_depth_clamp */
    3813. 

  3813. 

  3814. #ifdef GL_ARB_depth_texture
    3815. 

  3815. 

  3816. #endif /* GL_ARB_depth_texture */
    3817. 

  3817. 

  3818. #ifdef GL_ARB_draw_buffers
    3819. 

  3819. 

  3820. static GLboolean _glewInit_GL_ARB_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT)
    3821. 

  3821. {
    3822. 

  3822.   GLboolean r = GL_FALSE;
    3823. 

  3823. 

  3824.   r = ((glDrawBuffersARB = (PFNGLDRAWBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersARB")) == NULL) || r;
    3825. 

  3825. 

  3826.   return r;
    3827. 

  3827. }
    3828. 

  3828. 

  3829. #endif /* GL_ARB_draw_buffers */
    3830. 

  3830. 

  3831. #ifdef GL_ARB_draw_buffers_blend
    3832. 

  3832. 

  3833. static GLboolean _glewInit_GL_ARB_draw_buffers_blend (GLEW_CONTEXT_ARG_DEF_INIT)
    3834. 

  3834. {
    3835. 

  3835.   GLboolean r = GL_FALSE;
    3836. 

  3836. 

  3837.   r = ((glBlendEquationSeparateiARB = (PFNGLBLENDEQUATIONSEPARATEIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateiARB")) == NULL) || r;
    3838. 

  3838.   r = ((glBlendEquationiARB = (PFNGLBLENDEQUATIONIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationiARB")) == NULL) || r;
    3839. 

  3839.   r = ((glBlendFuncSeparateiARB = (PFNGLBLENDFUNCSEPARATEIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateiARB")) == NULL) || r;
    3840. 

  3840.   r = ((glBlendFunciARB = (PFNGLBLENDFUNCIARBPROC)glewGetProcAddress((const GLubyte*)"glBlendFunciARB")) == NULL) || r;
    3841. 

  3841. 

  3842.   return r;
    3843. 

  3843. }
    3844. 

  3844. 

  3845. #endif /* GL_ARB_draw_buffers_blend */
    3846. 

  3846. 

  3847. #ifdef GL_ARB_draw_elements_base_vertex
    3848. 

  3848. 

  3849. static GLboolean _glewInit_GL_ARB_draw_elements_base_vertex (GLEW_CONTEXT_ARG_DEF_INIT)
    3850. 

  3850. {
    3851. 

  3851.   GLboolean r = GL_FALSE;
    3852. 

  3852. 

  3853.   r = ((glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsBaseVertex")) == NULL) || r;
    3854. 

  3854.   r = ((glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseVertex")) == NULL) || r;
    3855. 

  3855.   r = ((glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementsBaseVertex")) == NULL) || r;
    3856. 

  3856.   r = ((glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsBaseVertex")) == NULL) || r;
    3857. 

  3857. 

  3858.   return r;
    3859. 

  3859. }
    3860. 

  3860. 

  3861. #endif /* GL_ARB_draw_elements_base_vertex */
    3862. 

  3862. 

  3863. #ifdef GL_ARB_draw_indirect
    3864. 

  3864. 

  3865. static GLboolean _glewInit_GL_ARB_draw_indirect (GLEW_CONTEXT_ARG_DEF_INIT)
    3866. 

  3866. {
    3867. 

  3867.   GLboolean r = GL_FALSE;
    3868. 

  3868. 

  3869.   r = ((glDrawArraysIndirect = (PFNGLDRAWARRAYSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysIndirect")) == NULL) || r;
    3870. 

  3870.   r = ((glDrawElementsIndirect = (PFNGLDRAWELEMENTSINDIRECTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsIndirect")) == NULL) || r;
    3871. 

  3871. 

  3872.   return r;
    3873. 

  3873. }
    3874. 

  3874. 

  3875. #endif /* GL_ARB_draw_indirect */
    3876. 

  3876. 

  3877. #ifdef GL_ARB_draw_instanced
    3878. 

  3878. 

  3879. #endif /* GL_ARB_draw_instanced */
    3880. 

  3880. 

  3881. #ifdef GL_ARB_explicit_attrib_location
    3882. 

  3882. 

  3883. #endif /* GL_ARB_explicit_attrib_location */
    3884. 

  3884. 

  3885. #ifdef GL_ARB_fragment_coord_conventions
    3886. 

  3886. 

  3887. #endif /* GL_ARB_fragment_coord_conventions */
    3888. 

  3888. 

  3889. #ifdef GL_ARB_fragment_program
    3890. 

  3890. 

  3891. #endif /* GL_ARB_fragment_program */
    3892. 

  3892. 

  3893. #ifdef GL_ARB_fragment_program_shadow
    3894. 

  3894. 

  3895. #endif /* GL_ARB_fragment_program_shadow */
    3896. 

  3896. 

  3897. #ifdef GL_ARB_fragment_shader
    3898. 

  3898. 

  3899. #endif /* GL_ARB_fragment_shader */
    3900. 

  3900. 

  3901. #ifdef GL_ARB_framebuffer_object
    3902. 

  3902. 

  3903. static GLboolean _glewInit_GL_ARB_framebuffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
    3904. 

  3904. {
    3905. 

  3905.   GLboolean r = GL_FALSE;
    3906. 

  3906. 

  3907.   r = ((glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindFramebuffer")) == NULL) || r;
    3908. 

  3908.   r = ((glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindRenderbuffer")) == NULL) || r;
    3909. 

  3909.   r = ((glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebuffer")) == NULL) || r;
    3910. 

  3910.   r = ((glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)glewGetProcAddress((const GLubyte*)"glCheckFramebufferStatus")) == NULL) || r;
    3911. 

  3911.   r = ((glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffers")) == NULL) || r;
    3912. 

  3912.   r = ((glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffers")) == NULL) || r;
    3913. 

  3913.   r = ((glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbuffer")) == NULL) || r;
    3914. 

  3914.   r = ((glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture1D")) == NULL) || r;
    3915. 

  3915.   r = ((glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2D")) == NULL) || r;
    3916. 

  3916.   r = ((glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3D")) == NULL) || r;
    3917. 

  3917.   r = ((glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayer")) == NULL) || r;
    3918. 

  3918.   r = ((glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffers")) == NULL) || r;
    3919. 

  3919.   r = ((glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffers")) == NULL) || r;
    3920. 

  3920.   r = ((glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmap")) == NULL) || r;
    3921. 

  3921.   r = ((glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferAttachmentParameteriv")) == NULL) || r;
    3922. 

  3922.   r = ((glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetRenderbufferParameteriv")) == NULL) || r;
    3923. 

  3923.   r = ((glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsFramebuffer")) == NULL) || r;
    3924. 

  3924.   r = ((glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsRenderbuffer")) == NULL) || r;
    3925. 

  3925.   r = ((glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorage")) == NULL) || r;
    3926. 

  3926.   r = ((glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisample")) == NULL) || r;
    3927. 

  3927. 

  3928.   return r;
    3929. 

  3929. }
    3930. 

  3930. 

  3931. #endif /* GL_ARB_framebuffer_object */
    3932. 

  3932. 

  3933. #ifdef GL_ARB_framebuffer_sRGB
    3934. 

  3934. 

  3935. #endif /* GL_ARB_framebuffer_sRGB */
    3936. 

  3936. 

  3937. #ifdef GL_ARB_geometry_shader4
    3938. 

  3938. 

  3939. static GLboolean _glewInit_GL_ARB_geometry_shader4 (GLEW_CONTEXT_ARG_DEF_INIT)
    3940. 

  3940. {
    3941. 

  3941.   GLboolean r = GL_FALSE;
    3942. 

  3942. 

  3943.   r = ((glFramebufferTextureARB = (PFNGLFRAMEBUFFERTEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureARB")) == NULL) || r;
    3944. 

  3944.   r = ((glFramebufferTextureFaceARB = (PFNGLFRAMEBUFFERTEXTUREFACEARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureFaceARB")) == NULL) || r;
    3945. 

  3945.   r = ((glFramebufferTextureLayerARB = (PFNGLFRAMEBUFFERTEXTURELAYERARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayerARB")) == NULL) || r;
    3946. 

  3946.   r = ((glProgramParameteriARB = (PFNGLPROGRAMPARAMETERIARBPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteriARB")) == NULL) || r;
    3947. 

  3947. 

  3948.   return r;
    3949. 

  3949. }
    3950. 

  3950. 

  3951. #endif /* GL_ARB_geometry_shader4 */
    3952. 

  3952. 

  3953. #ifdef GL_ARB_get_program_binary
    3954. 

  3954. 

  3955. static GLboolean _glewInit_GL_ARB_get_program_binary (GLEW_CONTEXT_ARG_DEF_INIT)
    3956. 

  3956. {
    3957. 

  3957.   GLboolean r = GL_FALSE;
    3958. 

  3958. 

  3959.   r = ((glGetProgramBinary = (PFNGLGETPROGRAMBINARYPROC)glewGetProcAddress((const GLubyte*)"glGetProgramBinary")) == NULL) || r;
    3960. 

  3960.   r = ((glProgramBinary = (PFNGLPROGRAMBINARYPROC)glewGetProcAddress((const GLubyte*)"glProgramBinary")) == NULL) || r;
    3961. 

  3961.   r = ((glProgramParameteri = (PFNGLPROGRAMPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteri")) == NULL) || r;
    3962. 

  3962. 

  3963.   return r;
    3964. 

  3964. }
    3965. 

  3965. 

  3966. #endif /* GL_ARB_get_program_binary */
    3967. 

  3967. 

  3968. #ifdef GL_ARB_gpu_shader5
    3969. 

  3969. 

  3970. #endif /* GL_ARB_gpu_shader5 */
    3971. 

  3971. 

  3972. #ifdef GL_ARB_gpu_shader_fp64
    3973. 

  3973. 

  3974. static GLboolean _glewInit_GL_ARB_gpu_shader_fp64 (GLEW_CONTEXT_ARG_DEF_INIT)
    3975. 

  3975. {
    3976. 

  3976.   GLboolean r = GL_FALSE;
    3977. 

  3977. 

  3978.   r = ((glGetUniformdv = (PFNGLGETUNIFORMDVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformdv")) == NULL) || r;
    3979. 

  3979.   r = ((glProgramUniform1dEXT = (PFNGLPROGRAMUNIFORM1DEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1dEXT")) == NULL) || r;
    3980. 

  3980.   r = ((glProgramUniform1dvEXT = (PFNGLPROGRAMUNIFORM1DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1dvEXT")) == NULL) || r;
    3981. 

  3981.   r = ((glProgramUniform2dEXT = (PFNGLPROGRAMUNIFORM2DEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2dEXT")) == NULL) || r;
    3982. 

  3982.   r = ((glProgramUniform2dvEXT = (PFNGLPROGRAMUNIFORM2DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2dvEXT")) == NULL) || r;
    3983. 

  3983.   r = ((glProgramUniform3dEXT = (PFNGLPROGRAMUNIFORM3DEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3dEXT")) == NULL) || r;
    3984. 

  3984.   r = ((glProgramUniform3dvEXT = (PFNGLPROGRAMUNIFORM3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3dvEXT")) == NULL) || r;
    3985. 

  3985.   r = ((glProgramUniform4dEXT = (PFNGLPROGRAMUNIFORM4DEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4dEXT")) == NULL) || r;
    3986. 

  3986.   r = ((glProgramUniform4dvEXT = (PFNGLPROGRAMUNIFORM4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4dvEXT")) == NULL) || r;
    3987. 

  3987.   r = ((glProgramUniformMatrix2dvEXT = (PFNGLPROGRAMUNIFORMMATRIX2DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2dvEXT")) == NULL) || r;
    3988. 

  3988.   r = ((glProgramUniformMatrix2x3dvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3dvEXT")) == NULL) || r;
    3989. 

  3989.   r = ((glProgramUniformMatrix2x4dvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4dvEXT")) == NULL) || r;
    3990. 

  3990.   r = ((glProgramUniformMatrix3dvEXT = (PFNGLPROGRAMUNIFORMMATRIX3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3dvEXT")) == NULL) || r;
    3991. 

  3991.   r = ((glProgramUniformMatrix3x2dvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X2DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2dvEXT")) == NULL) || r;
    3992. 

  3992.   r = ((glProgramUniformMatrix3x4dvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4dvEXT")) == NULL) || r;
    3993. 

  3993.   r = ((glProgramUniformMatrix4dvEXT = (PFNGLPROGRAMUNIFORMMATRIX4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4dvEXT")) == NULL) || r;
    3994. 

  3994.   r = ((glProgramUniformMatrix4x2dvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X2DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2dvEXT")) == NULL) || r;
    3995. 

  3995.   r = ((glProgramUniformMatrix4x3dvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3dvEXT")) == NULL) || r;
    3996. 

  3996.   r = ((glUniform1d = (PFNGLUNIFORM1DPROC)glewGetProcAddress((const GLubyte*)"glUniform1d")) == NULL) || r;
    3997. 

  3997.   r = ((glUniform1dv = (PFNGLUNIFORM1DVPROC)glewGetProcAddress((const GLubyte*)"glUniform1dv")) == NULL) || r;
    3998. 

  3998.   r = ((glUniform2d = (PFNGLUNIFORM2DPROC)glewGetProcAddress((const GLubyte*)"glUniform2d")) == NULL) || r;
    3999. 

  3999.   r = ((glUniform2dv = (PFNGLUNIFORM2DVPROC)glewGetProcAddress((const GLubyte*)"glUniform2dv")) == NULL) || r;
    4000. 

  4000.   r = ((glUniform3d = (PFNGLUNIFORM3DPROC)glewGetProcAddress((const GLubyte*)"glUniform3d")) == NULL) || r;
    4001. 

  4001.   r = ((glUniform3dv = (PFNGLUNIFORM3DVPROC)glewGetProcAddress((const GLubyte*)"glUniform3dv")) == NULL) || r;
    4002. 

  4002.   r = ((glUniform4d = (PFNGLUNIFORM4DPROC)glewGetProcAddress((const GLubyte*)"glUniform4d")) == NULL) || r;
    4003. 

  4003.   r = ((glUniform4dv = (PFNGLUNIFORM4DVPROC)glewGetProcAddress((const GLubyte*)"glUniform4dv")) == NULL) || r;
    4004. 

  4004.   r = ((glUniformMatrix2dv = (PFNGLUNIFORMMATRIX2DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2dv")) == NULL) || r;
    4005. 

  4005.   r = ((glUniformMatrix2x3dv = (PFNGLUNIFORMMATRIX2X3DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x3dv")) == NULL) || r;
    4006. 

  4006.   r = ((glUniformMatrix2x4dv = (PFNGLUNIFORMMATRIX2X4DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x4dv")) == NULL) || r;
    4007. 

  4007.   r = ((glUniformMatrix3dv = (PFNGLUNIFORMMATRIX3DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3dv")) == NULL) || r;
    4008. 

  4008.   r = ((glUniformMatrix3x2dv = (PFNGLUNIFORMMATRIX3X2DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x2dv")) == NULL) || r;
    4009. 

  4009.   r = ((glUniformMatrix3x4dv = (PFNGLUNIFORMMATRIX3X4DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x4dv")) == NULL) || r;
    4010. 

  4010.   r = ((glUniformMatrix4dv = (PFNGLUNIFORMMATRIX4DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4dv")) == NULL) || r;
    4011. 

  4011.   r = ((glUniformMatrix4x2dv = (PFNGLUNIFORMMATRIX4X2DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x2dv")) == NULL) || r;
    4012. 

  4012.   r = ((glUniformMatrix4x3dv = (PFNGLUNIFORMMATRIX4X3DVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x3dv")) == NULL) || r;
    4013. 

  4013. 

  4014.   return r;
    4015. 

  4015. }
    4016. 

  4016. 

  4017. #endif /* GL_ARB_gpu_shader_fp64 */
    4018. 

  4018. 

  4019. #ifdef GL_ARB_half_float_pixel
    4020. 

  4020. 

  4021. #endif /* GL_ARB_half_float_pixel */
    4022. 

  4022. 

  4023. #ifdef GL_ARB_half_float_vertex
    4024. 

  4024. 

  4025. #endif /* GL_ARB_half_float_vertex */
    4026. 

  4026. 

  4027. #ifdef GL_ARB_imaging
    4028. 

  4028. 

  4029. static GLboolean _glewInit_GL_ARB_imaging (GLEW_CONTEXT_ARG_DEF_INIT)
    4030. 

  4030. {
    4031. 

  4031.   GLboolean r = GL_FALSE;
    4032. 

  4032. 

  4033.   r = ((glBlendEquation = (PFNGLBLENDEQUATIONPROC)glewGetProcAddress((const GLubyte*)"glBlendEquation")) == NULL) || r;
    4034. 

  4034.   r = ((glColorSubTable = (PFNGLCOLORSUBTABLEPROC)glewGetProcAddress((const GLubyte*)"glColorSubTable")) == NULL) || r;
    4035. 

  4035.   r = ((glColorTable = (PFNGLCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glColorTable")) == NULL) || r;
    4036. 

  4036.   r = ((glColorTableParameterfv = (PFNGLCOLORTABLEPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterfv")) == NULL) || r;
    4037. 

  4037.   r = ((glColorTableParameteriv = (PFNGLCOLORTABLEPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameteriv")) == NULL) || r;
    4038. 

  4038.   r = ((glConvolutionFilter1D = (PFNGLCONVOLUTIONFILTER1DPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter1D")) == NULL) || r;
    4039. 

  4039.   r = ((glConvolutionFilter2D = (PFNGLCONVOLUTIONFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter2D")) == NULL) || r;
    4040. 

  4040.   r = ((glConvolutionParameterf = (PFNGLCONVOLUTIONPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterf")) == NULL) || r;
    4041. 

  4041.   r = ((glConvolutionParameterfv = (PFNGLCONVOLUTIONPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfv")) == NULL) || r;
    4042. 

  4042.   r = ((glConvolutionParameteri = (PFNGLCONVOLUTIONPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteri")) == NULL) || r;
    4043. 

  4043.   r = ((glConvolutionParameteriv = (PFNGLCONVOLUTIONPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteriv")) == NULL) || r;
    4044. 

  4044.   r = ((glCopyColorSubTable = (PFNGLCOPYCOLORSUBTABLEPROC)glewGetProcAddress((const GLubyte*)"glCopyColorSubTable")) == NULL) || r;
    4045. 

  4045.   r = ((glCopyColorTable = (PFNGLCOPYCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glCopyColorTable")) == NULL) || r;
    4046. 

  4046.   r = ((glCopyConvolutionFilter1D = (PFNGLCOPYCONVOLUTIONFILTER1DPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter1D")) == NULL) || r;
    4047. 

  4047.   r = ((glCopyConvolutionFilter2D = (PFNGLCOPYCONVOLUTIONFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter2D")) == NULL) || r;
    4048. 

  4048.   r = ((glGetColorTable = (PFNGLGETCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glGetColorTable")) == NULL) || r;
    4049. 

  4049.   r = ((glGetColorTableParameterfv = (PFNGLGETCOLORTABLEPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfv")) == NULL) || r;
    4050. 

  4050.   r = ((glGetColorTableParameteriv = (PFNGLGETCOLORTABLEPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameteriv")) == NULL) || r;
    4051. 

  4051.   r = ((glGetConvolutionFilter = (PFNGLGETCONVOLUTIONFILTERPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionFilter")) == NULL) || r;
    4052. 

  4052.   r = ((glGetConvolutionParameterfv = (PFNGLGETCONVOLUTIONPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterfv")) == NULL) || r;
    4053. 

  4053.   r = ((glGetConvolutionParameteriv = (PFNGLGETCONVOLUTIONPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameteriv")) == NULL) || r;
    4054. 

  4054.   r = ((glGetHistogram = (PFNGLGETHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glGetHistogram")) == NULL) || r;
    4055. 

  4055.   r = ((glGetHistogramParameterfv = (PFNGLGETHISTOGRAMPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterfv")) == NULL) || r;
    4056. 

  4056.   r = ((glGetHistogramParameteriv = (PFNGLGETHISTOGRAMPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameteriv")) == NULL) || r;
    4057. 

  4057.   r = ((glGetMinmax = (PFNGLGETMINMAXPROC)glewGetProcAddress((const GLubyte*)"glGetMinmax")) == NULL) || r;
    4058. 

  4058.   r = ((glGetMinmaxParameterfv = (PFNGLGETMINMAXPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterfv")) == NULL) || r;
    4059. 

  4059.   r = ((glGetMinmaxParameteriv = (PFNGLGETMINMAXPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameteriv")) == NULL) || r;
    4060. 

  4060.   r = ((glGetSeparableFilter = (PFNGLGETSEPARABLEFILTERPROC)glewGetProcAddress((const GLubyte*)"glGetSeparableFilter")) == NULL) || r;
    4061. 

  4061.   r = ((glHistogram = (PFNGLHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glHistogram")) == NULL) || r;
    4062. 

  4062.   r = ((glMinmax = (PFNGLMINMAXPROC)glewGetProcAddress((const GLubyte*)"glMinmax")) == NULL) || r;
    4063. 

  4063.   r = ((glResetHistogram = (PFNGLRESETHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glResetHistogram")) == NULL) || r;
    4064. 

  4064.   r = ((glResetMinmax = (PFNGLRESETMINMAXPROC)glewGetProcAddress((const GLubyte*)"glResetMinmax")) == NULL) || r;
    4065. 

  4065.   r = ((glSeparableFilter2D = (PFNGLSEPARABLEFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glSeparableFilter2D")) == NULL) || r;
    4066. 

  4066. 

  4067.   return r;
    4068. 

  4068. }
    4069. 

  4069. 

  4070. #endif /* GL_ARB_imaging */
    4071. 

  4071. 

  4072. #ifdef GL_ARB_instanced_arrays
    4073. 

  4073. 

  4074. static GLboolean _glewInit_GL_ARB_instanced_arrays (GLEW_CONTEXT_ARG_DEF_INIT)
    4075. 

  4075. {
    4076. 

  4076.   GLboolean r = GL_FALSE;
    4077. 

  4077. 

  4078.   r = ((glDrawArraysInstancedARB = (PFNGLDRAWARRAYSINSTANCEDARBPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedARB")) == NULL) || r;
    4079. 

  4079.   r = ((glDrawElementsInstancedARB = (PFNGLDRAWELEMENTSINSTANCEDARBPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedARB")) == NULL) || r;
    4080. 

  4080.   r = ((glVertexAttribDivisorARB = (PFNGLVERTEXATTRIBDIVISORARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisorARB")) == NULL) || r;
    4081. 

  4081. 

  4082.   return r;
    4083. 

  4083. }
    4084. 

  4084. 

  4085. #endif /* GL_ARB_instanced_arrays */
    4086. 

  4086. 

  4087. #ifdef GL_ARB_internalformat_query
    4088. 

  4088. 

  4089. static GLboolean _glewInit_GL_ARB_internalformat_query (GLEW_CONTEXT_ARG_DEF_INIT)
    4090. 

  4090. {
    4091. 

  4091.   GLboolean r = GL_FALSE;
    4092. 

  4092. 

  4093.   r = ((glGetInternalformativ = (PFNGLGETINTERNALFORMATIVPROC)glewGetProcAddress((const GLubyte*)"glGetInternalformativ")) == NULL) || r;
    4094. 

  4094. 

  4095.   return r;
    4096. 

  4096. }
    4097. 

  4097. 

  4098. #endif /* GL_ARB_internalformat_query */
    4099. 

  4099. 

  4100. #ifdef GL_ARB_map_buffer_alignment
    4101. 

  4101. 

  4102. #endif /* GL_ARB_map_buffer_alignment */
    4103. 

  4103. 

  4104. #ifdef GL_ARB_map_buffer_range
    4105. 

  4105. 

  4106. static GLboolean _glewInit_GL_ARB_map_buffer_range (GLEW_CONTEXT_ARG_DEF_INIT)
    4107. 

  4107. {
    4108. 

  4108.   GLboolean r = GL_FALSE;
    4109. 

  4109. 

  4110.   r = ((glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedBufferRange")) == NULL) || r;
    4111. 

  4111.   r = ((glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glMapBufferRange")) == NULL) || r;
    4112. 

  4112. 

  4113.   return r;
    4114. 

  4114. }
    4115. 

  4115. 

  4116. #endif /* GL_ARB_map_buffer_range */
    4117. 

  4117. 

  4118. #ifdef GL_ARB_matrix_palette
    4119. 

  4119. 

  4120. static GLboolean _glewInit_GL_ARB_matrix_palette (GLEW_CONTEXT_ARG_DEF_INIT)
    4121. 

  4121. {
    4122. 

  4122.   GLboolean r = GL_FALSE;
    4123. 

  4123. 

  4124.   r = ((glCurrentPaletteMatrixARB = (PFNGLCURRENTPALETTEMATRIXARBPROC)glewGetProcAddress((const GLubyte*)"glCurrentPaletteMatrixARB")) == NULL) || r;
    4125. 

  4125.   r = ((glMatrixIndexPointerARB = (PFNGLMATRIXINDEXPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexPointerARB")) == NULL) || r;
    4126. 

  4126.   r = ((glMatrixIndexubvARB = (PFNGLMATRIXINDEXUBVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexubvARB")) == NULL) || r;
    4127. 

  4127.   r = ((glMatrixIndexuivARB = (PFNGLMATRIXINDEXUIVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexuivARB")) == NULL) || r;
    4128. 

  4128.   r = ((glMatrixIndexusvARB = (PFNGLMATRIXINDEXUSVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexusvARB")) == NULL) || r;
    4129. 

  4129. 

  4130.   return r;
    4131. 

  4131. }
    4132. 

  4132. 

  4133. #endif /* GL_ARB_matrix_palette */
    4134. 

  4134. 

  4135. #ifdef GL_ARB_multisample
    4136. 

  4136. 

  4137. static GLboolean _glewInit_GL_ARB_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
    4138. 

  4138. {
    4139. 

  4139.   GLboolean r = GL_FALSE;
    4140. 

  4140. 

  4141.   r = ((glSampleCoverageARB = (PFNGLSAMPLECOVERAGEARBPROC)glewGetProcAddress((const GLubyte*)"glSampleCoverageARB")) == NULL) || r;
    4142. 

  4142. 

  4143.   return r;
    4144. 

  4144. }
    4145. 

  4145. 

  4146. #endif /* GL_ARB_multisample */
    4147. 

  4147. 

  4148. #ifdef GL_ARB_multitexture
    4149. 

  4149. 

  4150. static GLboolean _glewInit_GL_ARB_multitexture (GLEW_CONTEXT_ARG_DEF_INIT)
    4151. 

  4151. {
    4152. 

  4152.   GLboolean r = GL_FALSE;
    4153. 

  4153. 

  4154.   r = ((glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glActiveTextureARB")) == NULL) || r;
    4155. 

  4155.   r = ((glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glClientActiveTextureARB")) == NULL) || r;
    4156. 

  4156.   r = ((glMultiTexCoord1dARB = (PFNGLMULTITEXCOORD1DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dARB")) == NULL) || r;
    4157. 

  4157.   r = ((glMultiTexCoord1dvARB = (PFNGLMULTITEXCOORD1DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dvARB")) == NULL) || r;
    4158. 

  4158.   r = ((glMultiTexCoord1fARB = (PFNGLMULTITEXCOORD1FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fARB")) == NULL) || r;
    4159. 

  4159.   r = ((glMultiTexCoord1fvARB = (PFNGLMULTITEXCOORD1FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fvARB")) == NULL) || r;
    4160. 

  4160.   r = ((glMultiTexCoord1iARB = (PFNGLMULTITEXCOORD1IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1iARB")) == NULL) || r;
    4161. 

  4161.   r = ((glMultiTexCoord1ivARB = (PFNGLMULTITEXCOORD1IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1ivARB")) == NULL) || r;
    4162. 

  4162.   r = ((glMultiTexCoord1sARB = (PFNGLMULTITEXCOORD1SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1sARB")) == NULL) || r;
    4163. 

  4163.   r = ((glMultiTexCoord1svARB = (PFNGLMULTITEXCOORD1SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1svARB")) == NULL) || r;
    4164. 

  4164.   r = ((glMultiTexCoord2dARB = (PFNGLMULTITEXCOORD2DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dARB")) == NULL) || r;
    4165. 

  4165.   r = ((glMultiTexCoord2dvARB = (PFNGLMULTITEXCOORD2DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dvARB")) == NULL) || r;
    4166. 

  4166.   r = ((glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fARB")) == NULL) || r;
    4167. 

  4167.   r = ((glMultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fvARB")) == NULL) || r;
    4168. 

  4168.   r = ((glMultiTexCoord2iARB = (PFNGLMULTITEXCOORD2IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2iARB")) == NULL) || r;
    4169. 

  4169.   r = ((glMultiTexCoord2ivARB = (PFNGLMULTITEXCOORD2IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2ivARB")) == NULL) || r;
    4170. 

  4170.   r = ((glMultiTexCoord2sARB = (PFNGLMULTITEXCOORD2SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2sARB")) == NULL) || r;
    4171. 

  4171.   r = ((glMultiTexCoord2svARB = (PFNGLMULTITEXCOORD2SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2svARB")) == NULL) || r;
    4172. 

  4172.   r = ((glMultiTexCoord3dARB = (PFNGLMULTITEXCOORD3DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dARB")) == NULL) || r;
    4173. 

  4173.   r = ((glMultiTexCoord3dvARB = (PFNGLMULTITEXCOORD3DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dvARB")) == NULL) || r;
    4174. 

  4174.   r = ((glMultiTexCoord3fARB = (PFNGLMULTITEXCOORD3FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fARB")) == NULL) || r;
    4175. 

  4175.   r = ((glMultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fvARB")) == NULL) || r;
    4176. 

  4176.   r = ((glMultiTexCoord3iARB = (PFNGLMULTITEXCOORD3IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3iARB")) == NULL) || r;
    4177. 

  4177.   r = ((glMultiTexCoord3ivARB = (PFNGLMULTITEXCOORD3IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3ivARB")) == NULL) || r;
    4178. 

  4178.   r = ((glMultiTexCoord3sARB = (PFNGLMULTITEXCOORD3SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3sARB")) == NULL) || r;
    4179. 

  4179.   r = ((glMultiTexCoord3svARB = (PFNGLMULTITEXCOORD3SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3svARB")) == NULL) || r;
    4180. 

  4180.   r = ((glMultiTexCoord4dARB = (PFNGLMULTITEXCOORD4DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dARB")) == NULL) || r;
    4181. 

  4181.   r = ((glMultiTexCoord4dvARB = (PFNGLMULTITEXCOORD4DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dvARB")) == NULL) || r;
    4182. 

  4182.   r = ((glMultiTexCoord4fARB = (PFNGLMULTITEXCOORD4FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fARB")) == NULL) || r;
    4183. 

  4183.   r = ((glMultiTexCoord4fvARB = (PFNGLMULTITEXCOORD4FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fvARB")) == NULL) || r;
    4184. 

  4184.   r = ((glMultiTexCoord4iARB = (PFNGLMULTITEXCOORD4IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4iARB")) == NULL) || r;
    4185. 

  4185.   r = ((glMultiTexCoord4ivARB = (PFNGLMULTITEXCOORD4IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4ivARB")) == NULL) || r;
    4186. 

  4186.   r = ((glMultiTexCoord4sARB = (PFNGLMULTITEXCOORD4SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4sARB")) == NULL) || r;
    4187. 

  4187.   r = ((glMultiTexCoord4svARB = (PFNGLMULTITEXCOORD4SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4svARB")) == NULL) || r;
    4188. 

  4188. 

  4189.   return r;
    4190. 

  4190. }
    4191. 

  4191. 

  4192. #endif /* GL_ARB_multitexture */
    4193. 

  4193. 

  4194. #ifdef GL_ARB_occlusion_query
    4195. 

  4195. 

  4196. static GLboolean _glewInit_GL_ARB_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT)
    4197. 

  4197. {
    4198. 

  4198.   GLboolean r = GL_FALSE;
    4199. 

  4199. 

  4200.   r = ((glBeginQueryARB = (PFNGLBEGINQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryARB")) == NULL) || r;
    4201. 

  4201.   r = ((glDeleteQueriesARB = (PFNGLDELETEQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueriesARB")) == NULL) || r;
    4202. 

  4202.   r = ((glEndQueryARB = (PFNGLENDQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glEndQueryARB")) == NULL) || r;
    4203. 

  4203.   r = ((glGenQueriesARB = (PFNGLGENQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glGenQueriesARB")) == NULL) || r;
    4204. 

  4204.   r = ((glGetQueryObjectivARB = (PFNGLGETQUERYOBJECTIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectivARB")) == NULL) || r;
    4205. 

  4205.   r = ((glGetQueryObjectuivARB = (PFNGLGETQUERYOBJECTUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuivARB")) == NULL) || r;
    4206. 

  4206.   r = ((glGetQueryivARB = (PFNGLGETQUERYIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryivARB")) == NULL) || r;
    4207. 

  4207.   r = ((glIsQueryARB = (PFNGLISQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glIsQueryARB")) == NULL) || r;
    4208. 

  4208. 

  4209.   return r;
    4210. 

  4210. }
    4211. 

  4211. 

  4212. #endif /* GL_ARB_occlusion_query */
    4213. 

  4213. 

  4214. #ifdef GL_ARB_occlusion_query2
    4215. 

  4215. 

  4216. #endif /* GL_ARB_occlusion_query2 */
    4217. 

  4217. 

  4218. #ifdef GL_ARB_pixel_buffer_object
    4219. 

  4219. 

  4220. #endif /* GL_ARB_pixel_buffer_object */
    4221. 

  4221. 

  4222. #ifdef GL_ARB_point_parameters
    4223. 

  4223. 

  4224. static GLboolean _glewInit_GL_ARB_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT)
    4225. 

  4225. {
    4226. 

  4226.   GLboolean r = GL_FALSE;
    4227. 

  4227. 

  4228.   r = ((glPointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfARB")) == NULL) || r;
    4229. 

  4229.   r = ((glPointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvARB")) == NULL) || r;
    4230. 

  4230. 

  4231.   return r;
    4232. 

  4232. }
    4233. 

  4233. 

  4234. #endif /* GL_ARB_point_parameters */
    4235. 

  4235. 

  4236. #ifdef GL_ARB_point_sprite
    4237. 

  4237. 

  4238. #endif /* GL_ARB_point_sprite */
    4239. 

  4239. 

  4240. #ifdef GL_ARB_provoking_vertex
    4241. 

  4241. 

  4242. static GLboolean _glewInit_GL_ARB_provoking_vertex (GLEW_CONTEXT_ARG_DEF_INIT)
    4243. 

  4243. {
    4244. 

  4244.   GLboolean r = GL_FALSE;
    4245. 

  4245. 

  4246.   r = ((glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)glewGetProcAddress((const GLubyte*)"glProvokingVertex")) == NULL) || r;
    4247. 

  4247. 

  4248.   return r;
    4249. 

  4249. }
    4250. 

  4250. 

  4251. #endif /* GL_ARB_provoking_vertex */
    4252. 

  4252. 

  4253. #ifdef GL_ARB_robustness
    4254. 

  4254. 

  4255. static GLboolean _glewInit_GL_ARB_robustness (GLEW_CONTEXT_ARG_DEF_INIT)
    4256. 

  4256. {
    4257. 

  4257.   GLboolean r = GL_FALSE;
    4258. 

  4258. 

  4259.   r = ((glGetGraphicsResetStatusARB = (PFNGLGETGRAPHICSRESETSTATUSARBPROC)glewGetProcAddress((const GLubyte*)"glGetGraphicsResetStatusARB")) == NULL) || r;
    4260. 

  4260.   r = ((glGetnColorTableARB = (PFNGLGETNCOLORTABLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnColorTableARB")) == NULL) || r;
    4261. 

  4261.   r = ((glGetnCompressedTexImageARB = (PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnCompressedTexImageARB")) == NULL) || r;
    4262. 

  4262.   r = ((glGetnConvolutionFilterARB = (PFNGLGETNCONVOLUTIONFILTERARBPROC)glewGetProcAddress((const GLubyte*)"glGetnConvolutionFilterARB")) == NULL) || r;
    4263. 

  4263.   r = ((glGetnHistogramARB = (PFNGLGETNHISTOGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glGetnHistogramARB")) == NULL) || r;
    4264. 

  4264.   r = ((glGetnMapdvARB = (PFNGLGETNMAPDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMapdvARB")) == NULL) || r;
    4265. 

  4265.   r = ((glGetnMapfvARB = (PFNGLGETNMAPFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMapfvARB")) == NULL) || r;
    4266. 

  4266.   r = ((glGetnMapivARB = (PFNGLGETNMAPIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMapivARB")) == NULL) || r;
    4267. 

  4267.   r = ((glGetnMinmaxARB = (PFNGLGETNMINMAXARBPROC)glewGetProcAddress((const GLubyte*)"glGetnMinmaxARB")) == NULL) || r;
    4268. 

  4268.   r = ((glGetnPixelMapfvARB = (PFNGLGETNPIXELMAPFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPixelMapfvARB")) == NULL) || r;
    4269. 

  4269.   r = ((glGetnPixelMapuivARB = (PFNGLGETNPIXELMAPUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPixelMapuivARB")) == NULL) || r;
    4270. 

  4270.   r = ((glGetnPixelMapusvARB = (PFNGLGETNPIXELMAPUSVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPixelMapusvARB")) == NULL) || r;
    4271. 

  4271.   r = ((glGetnPolygonStippleARB = (PFNGLGETNPOLYGONSTIPPLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnPolygonStippleARB")) == NULL) || r;
    4272. 

  4272.   r = ((glGetnSeparableFilterARB = (PFNGLGETNSEPARABLEFILTERARBPROC)glewGetProcAddress((const GLubyte*)"glGetnSeparableFilterARB")) == NULL) || r;
    4273. 

  4273.   r = ((glGetnTexImageARB = (PFNGLGETNTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetnTexImageARB")) == NULL) || r;
    4274. 

  4274.   r = ((glGetnUniformdvARB = (PFNGLGETNUNIFORMDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformdvARB")) == NULL) || r;
    4275. 

  4275.   r = ((glGetnUniformfvARB = (PFNGLGETNUNIFORMFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformfvARB")) == NULL) || r;
    4276. 

  4276.   r = ((glGetnUniformivARB = (PFNGLGETNUNIFORMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformivARB")) == NULL) || r;
    4277. 

  4277.   r = ((glGetnUniformuivARB = (PFNGLGETNUNIFORMUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformuivARB")) == NULL) || r;
    4278. 

  4278.   r = ((glReadnPixelsARB = (PFNGLREADNPIXELSARBPROC)glewGetProcAddress((const GLubyte*)"glReadnPixelsARB")) == NULL) || r;
    4279. 

  4279. 

  4280.   return r;
    4281. 

  4281. }
    4282. 

  4282. 

  4283. #endif /* GL_ARB_robustness */
    4284. 

  4284. 

  4285. #ifdef GL_ARB_sample_shading
    4286. 

  4286. 

  4287. static GLboolean _glewInit_GL_ARB_sample_shading (GLEW_CONTEXT_ARG_DEF_INIT)
    4288. 

  4288. {
    4289. 

  4289.   GLboolean r = GL_FALSE;
    4290. 

  4290. 

  4291.   r = ((glMinSampleShadingARB = (PFNGLMINSAMPLESHADINGARBPROC)glewGetProcAddress((const GLubyte*)"glMinSampleShadingARB")) == NULL) || r;
    4292. 

  4292. 

  4293.   return r;
    4294. 

  4294. }
    4295. 

  4295. 

  4296. #endif /* GL_ARB_sample_shading */
    4297. 

  4297. 

  4298. #ifdef GL_ARB_sampler_objects
    4299. 

  4299. 

  4300. static GLboolean _glewInit_GL_ARB_sampler_objects (GLEW_CONTEXT_ARG_DEF_INIT)
    4301. 

  4301. {
    4302. 

  4302.   GLboolean r = GL_FALSE;
    4303. 

  4303. 

  4304.   r = ((glBindSampler = (PFNGLBINDSAMPLERPROC)glewGetProcAddress((const GLubyte*)"glBindSampler")) == NULL) || r;
    4305. 

  4305.   r = ((glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteSamplers")) == NULL) || r;
    4306. 

  4306.   r = ((glGenSamplers = (PFNGLGENSAMPLERSPROC)glewGetProcAddress((const GLubyte*)"glGenSamplers")) == NULL) || r;
    4307. 

  4307.   r = ((glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterIiv")) == NULL) || r;
    4308. 

  4308.   r = ((glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterIuiv")) == NULL) || r;
    4309. 

  4309.   r = ((glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterfv")) == NULL) || r;
    4310. 

  4310.   r = ((glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameteriv")) == NULL) || r;
    4311. 

  4311.   r = ((glIsSampler = (PFNGLISSAMPLERPROC)glewGetProcAddress((const GLubyte*)"glIsSampler")) == NULL) || r;
    4312. 

  4312.   r = ((glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterIiv")) == NULL) || r;
    4313. 

  4313.   r = ((glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterIuiv")) == NULL) || r;
    4314. 

  4314.   r = ((glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterf")) == NULL) || r;
    4315. 

  4315.   r = ((glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterfv")) == NULL) || r;
    4316. 

  4316.   r = ((glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameteri")) == NULL) || r;
    4317. 

  4317.   r = ((glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameteriv")) == NULL) || r;
    4318. 

  4318. 

  4319.   return r;
    4320. 

  4320. }
    4321. 

  4321. 

  4322. #endif /* GL_ARB_sampler_objects */
    4323. 

  4323. 

  4324. #ifdef GL_ARB_seamless_cube_map
    4325. 

  4325. 

  4326. #endif /* GL_ARB_seamless_cube_map */
    4327. 

  4327. 

  4328. #ifdef GL_ARB_separate_shader_objects
    4329. 

  4329. 

  4330. static GLboolean _glewInit_GL_ARB_separate_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT)
    4331. 

  4331. {
    4332. 

  4332.   GLboolean r = GL_FALSE;
    4333. 

  4333. 

  4334.   r = ((glActiveShaderProgram = (PFNGLACTIVESHADERPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glActiveShaderProgram")) == NULL) || r;
    4335. 

  4335.   r = ((glBindProgramPipeline = (PFNGLBINDPROGRAMPIPELINEPROC)glewGetProcAddress((const GLubyte*)"glBindProgramPipeline")) == NULL) || r;
    4336. 

  4336.   r = ((glCreateShaderProgramv = (PFNGLCREATESHADERPROGRAMVPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderProgramv")) == NULL) || r;
    4337. 

  4337.   r = ((glDeleteProgramPipelines = (PFNGLDELETEPROGRAMPIPELINESPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramPipelines")) == NULL) || r;
    4338. 

  4338.   r = ((glGenProgramPipelines = (PFNGLGENPROGRAMPIPELINESPROC)glewGetProcAddress((const GLubyte*)"glGenProgramPipelines")) == NULL) || r;
    4339. 

  4339.   r = ((glGetProgramPipelineInfoLog = (PFNGLGETPROGRAMPIPELINEINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetProgramPipelineInfoLog")) == NULL) || r;
    4340. 

  4340.   r = ((glGetProgramPipelineiv = (PFNGLGETPROGRAMPIPELINEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramPipelineiv")) == NULL) || r;
    4341. 

  4341.   r = ((glIsProgramPipeline = (PFNGLISPROGRAMPIPELINEPROC)glewGetProcAddress((const GLubyte*)"glIsProgramPipeline")) == NULL) || r;
    4342. 

  4342.   r = ((glProgramUniform1d = (PFNGLPROGRAMUNIFORM1DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1d")) == NULL) || r;
    4343. 

  4343.   r = ((glProgramUniform1dv = (PFNGLPROGRAMUNIFORM1DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1dv")) == NULL) || r;
    4344. 

  4344.   r = ((glProgramUniform1f = (PFNGLPROGRAMUNIFORM1FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1f")) == NULL) || r;
    4345. 

  4345.   r = ((glProgramUniform1fv = (PFNGLPROGRAMUNIFORM1FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fv")) == NULL) || r;
    4346. 

  4346.   r = ((glProgramUniform1i = (PFNGLPROGRAMUNIFORM1IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i")) == NULL) || r;
    4347. 

  4347.   r = ((glProgramUniform1iv = (PFNGLPROGRAMUNIFORM1IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1iv")) == NULL) || r;
    4348. 

  4348.   r = ((glProgramUniform1ui = (PFNGLPROGRAMUNIFORM1UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui")) == NULL) || r;
    4349. 

  4349.   r = ((glProgramUniform1uiv = (PFNGLPROGRAMUNIFORM1UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uiv")) == NULL) || r;
    4350. 

  4350.   r = ((glProgramUniform2d = (PFNGLPROGRAMUNIFORM2DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2d")) == NULL) || r;
    4351. 

  4351.   r = ((glProgramUniform2dv = (PFNGLPROGRAMUNIFORM2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2dv")) == NULL) || r;
    4352. 

  4352.   r = ((glProgramUniform2f = (PFNGLPROGRAMUNIFORM2FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2f")) == NULL) || r;
    4353. 

  4353.   r = ((glProgramUniform2fv = (PFNGLPROGRAMUNIFORM2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fv")) == NULL) || r;
    4354. 

  4354.   r = ((glProgramUniform2i = (PFNGLPROGRAMUNIFORM2IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i")) == NULL) || r;
    4355. 

  4355.   r = ((glProgramUniform2iv = (PFNGLPROGRAMUNIFORM2IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2iv")) == NULL) || r;
    4356. 

  4356.   r = ((glProgramUniform2ui = (PFNGLPROGRAMUNIFORM2UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui")) == NULL) || r;
    4357. 

  4357.   r = ((glProgramUniform2uiv = (PFNGLPROGRAMUNIFORM2UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uiv")) == NULL) || r;
    4358. 

  4358.   r = ((glProgramUniform3d = (PFNGLPROGRAMUNIFORM3DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3d")) == NULL) || r;
    4359. 

  4359.   r = ((glProgramUniform3dv = (PFNGLPROGRAMUNIFORM3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3dv")) == NULL) || r;
    4360. 

  4360.   r = ((glProgramUniform3f = (PFNGLPROGRAMUNIFORM3FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3f")) == NULL) || r;
    4361. 

  4361.   r = ((glProgramUniform3fv = (PFNGLPROGRAMUNIFORM3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fv")) == NULL) || r;
    4362. 

  4362.   r = ((glProgramUniform3i = (PFNGLPROGRAMUNIFORM3IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i")) == NULL) || r;
    4363. 

  4363.   r = ((glProgramUniform3iv = (PFNGLPROGRAMUNIFORM3IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3iv")) == NULL) || r;
    4364. 

  4364.   r = ((glProgramUniform3ui = (PFNGLPROGRAMUNIFORM3UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui")) == NULL) || r;
    4365. 

  4365.   r = ((glProgramUniform3uiv = (PFNGLPROGRAMUNIFORM3UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uiv")) == NULL) || r;
    4366. 

  4366.   r = ((glProgramUniform4d = (PFNGLPROGRAMUNIFORM4DPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4d")) == NULL) || r;
    4367. 

  4367.   r = ((glProgramUniform4dv = (PFNGLPROGRAMUNIFORM4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4dv")) == NULL) || r;
    4368. 

  4368.   r = ((glProgramUniform4f = (PFNGLPROGRAMUNIFORM4FPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4f")) == NULL) || r;
    4369. 

  4369.   r = ((glProgramUniform4fv = (PFNGLPROGRAMUNIFORM4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fv")) == NULL) || r;
    4370. 

  4370.   r = ((glProgramUniform4i = (PFNGLPROGRAMUNIFORM4IPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i")) == NULL) || r;
    4371. 

  4371.   r = ((glProgramUniform4iv = (PFNGLPROGRAMUNIFORM4IVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4iv")) == NULL) || r;
    4372. 

  4372.   r = ((glProgramUniform4ui = (PFNGLPROGRAMUNIFORM4UIPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui")) == NULL) || r;
    4373. 

  4373.   r = ((glProgramUniform4uiv = (PFNGLPROGRAMUNIFORM4UIVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uiv")) == NULL) || r;
    4374. 

  4374.   r = ((glProgramUniformMatrix2dv = (PFNGLPROGRAMUNIFORMMATRIX2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2dv")) == NULL) || r;
    4375. 

  4375.   r = ((glProgramUniformMatrix2fv = (PFNGLPROGRAMUNIFORMMATRIX2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2fv")) == NULL) || r;
    4376. 

  4376.   r = ((glProgramUniformMatrix2x3dv = (PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3dv")) == NULL) || r;
    4377. 

  4377.   r = ((glProgramUniformMatrix2x3fv = (PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3fv")) == NULL) || r;
    4378. 

  4378.   r = ((glProgramUniformMatrix2x4dv = (PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4dv")) == NULL) || r;
    4379. 

  4379.   r = ((glProgramUniformMatrix2x4fv = (PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4fv")) == NULL) || r;
    4380. 

  4380.   r = ((glProgramUniformMatrix3dv = (PFNGLPROGRAMUNIFORMMATRIX3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3dv")) == NULL) || r;
    4381. 

  4381.   r = ((glProgramUniformMatrix3fv = (PFNGLPROGRAMUNIFORMMATRIX3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3fv")) == NULL) || r;
    4382. 

  4382.   r = ((glProgramUniformMatrix3x2dv = (PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2dv")) == NULL) || r;
    4383. 

  4383.   r = ((glProgramUniformMatrix3x2fv = (PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2fv")) == NULL) || r;
    4384. 

  4384.   r = ((glProgramUniformMatrix3x4dv = (PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4dv")) == NULL) || r;
    4385. 

  4385.   r = ((glProgramUniformMatrix3x4fv = (PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4fv")) == NULL) || r;
    4386. 

  4386.   r = ((glProgramUniformMatrix4dv = (PFNGLPROGRAMUNIFORMMATRIX4DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4dv")) == NULL) || r;
    4387. 

  4387.   r = ((glProgramUniformMatrix4fv = (PFNGLPROGRAMUNIFORMMATRIX4FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4fv")) == NULL) || r;
    4388. 

  4388.   r = ((glProgramUniformMatrix4x2dv = (PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2dv")) == NULL) || r;
    4389. 

  4389.   r = ((glProgramUniformMatrix4x2fv = (PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2fv")) == NULL) || r;
    4390. 

  4390.   r = ((glProgramUniformMatrix4x3dv = (PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3dv")) == NULL) || r;
    4391. 

  4391.   r = ((glProgramUniformMatrix4x3fv = (PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3fv")) == NULL) || r;
    4392. 

  4392.   r = ((glUseProgramStages = (PFNGLUSEPROGRAMSTAGESPROC)glewGetProcAddress((const GLubyte*)"glUseProgramStages")) == NULL) || r;
    4393. 

  4393.   r = ((glValidateProgramPipeline = (PFNGLVALIDATEPROGRAMPIPELINEPROC)glewGetProcAddress((const GLubyte*)"glValidateProgramPipeline")) == NULL) || r;
    4394. 

  4394. 

  4395.   return r;
    4396. 

  4396. }
    4397. 

  4397. 

  4398. #endif /* GL_ARB_separate_shader_objects */
    4399. 

  4399. 

  4400. #ifdef GL_ARB_shader_atomic_counters
    4401. 

  4401. 

  4402. static GLboolean _glewInit_GL_ARB_shader_atomic_counters (GLEW_CONTEXT_ARG_DEF_INIT)
    4403. 

  4403. {
    4404. 

  4404.   GLboolean r = GL_FALSE;
    4405. 

  4405. 

  4406.   r = ((glGetActiveAtomicCounterBufferiv = (PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAtomicCounterBufferiv")) == NULL) || r;
    4407. 

  4407. 

  4408.   return r;
    4409. 

  4409. }
    4410. 

  4410. 

  4411. #endif /* GL_ARB_shader_atomic_counters */
    4412. 

  4412. 

  4413. #ifdef GL_ARB_shader_bit_encoding
    4414. 

  4414. 

  4415. #endif /* GL_ARB_shader_bit_encoding */
    4416. 

  4416. 

  4417. #ifdef GL_ARB_shader_image_load_store
    4418. 

  4418. 

  4419. static GLboolean _glewInit_GL_ARB_shader_image_load_store (GLEW_CONTEXT_ARG_DEF_INIT)
    4420. 

  4420. {
    4421. 

  4421.   GLboolean r = GL_FALSE;
    4422. 

  4422. 

  4423.   r = ((glBindImageTexture = (PFNGLBINDIMAGETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glBindImageTexture")) == NULL) || r;
    4424. 

  4424.   r = ((glMemoryBarrier = (PFNGLMEMORYBARRIERPROC)glewGetProcAddress((const GLubyte*)"glMemoryBarrier")) == NULL) || r;
    4425. 

  4425. 

  4426.   return r;
    4427. 

  4427. }
    4428. 

  4428. 

  4429. #endif /* GL_ARB_shader_image_load_store */
    4430. 

  4430. 

  4431. #ifdef GL_ARB_shader_objects
    4432. 

  4432. 

  4433. static GLboolean _glewInit_GL_ARB_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT)
    4434. 

  4434. {
    4435. 

  4435.   GLboolean r = GL_FALSE;
    4436. 

  4436. 

  4437.   r = ((glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glAttachObjectARB")) == NULL) || r;
    4438. 

  4438.   r = ((glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)glewGetProcAddress((const GLubyte*)"glCompileShaderARB")) == NULL) || r;
    4439. 

  4439.   r = ((glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateProgramObjectARB")) == NULL) || r;
    4440. 

  4440.   r = ((glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderObjectARB")) == NULL) || r;
    4441. 

  4441.   r = ((glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteObjectARB")) == NULL) || r;
    4442. 

  4442.   r = ((glDetachObjectARB = (PFNGLDETACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDetachObjectARB")) == NULL) || r;
    4443. 

  4443.   r = ((glGetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformARB")) == NULL) || r;
    4444. 

  4444.   r = ((glGetAttachedObjectsARB = (PFNGLGETATTACHEDOBJECTSARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttachedObjectsARB")) == NULL) || r;
    4445. 

  4445.   r = ((glGetHandleARB = (PFNGLGETHANDLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetHandleARB")) == NULL) || r;
    4446. 

  4446.   r = ((glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)glewGetProcAddress((const GLubyte*)"glGetInfoLogARB")) == NULL) || r;
    4447. 

  4447.   r = ((glGetObjectParameterfvARB = (PFNGLGETOBJECTPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterfvARB")) == NULL) || r;
    4448. 

  4448.   r = ((glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterivARB")) == NULL) || r;
    4449. 

  4449.   r = ((glGetShaderSourceARB = (PFNGLGETSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glGetShaderSourceARB")) == NULL) || r;
    4450. 

  4450.   r = ((glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformLocationARB")) == NULL) || r;
    4451. 

  4451.   r = ((glGetUniformfvARB = (PFNGLGETUNIFORMFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformfvARB")) == NULL) || r;
    4452. 

  4452.   r = ((glGetUniformivARB = (PFNGLGETUNIFORMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformivARB")) == NULL) || r;
    4453. 

  4453.   r = ((glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glLinkProgramARB")) == NULL) || r;
    4454. 

  4454.   r = ((glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glShaderSourceARB")) == NULL) || r;
    4455. 

  4455.   r = ((glUniform1fARB = (PFNGLUNIFORM1FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fARB")) == NULL) || r;
    4456. 

  4456.   r = ((glUniform1fvARB = (PFNGLUNIFORM1FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fvARB")) == NULL) || r;
    4457. 

  4457.   r = ((glUniform1iARB = (PFNGLUNIFORM1IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1iARB")) == NULL) || r;
    4458. 

  4458.   r = ((glUniform1ivARB = (PFNGLUNIFORM1IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1ivARB")) == NULL) || r;
    4459. 

  4459.   r = ((glUniform2fARB = (PFNGLUNIFORM2FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fARB")) == NULL) || r;
    4460. 

  4460.   r = ((glUniform2fvARB = (PFNGLUNIFORM2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fvARB")) == NULL) || r;
    4461. 

  4461.   r = ((glUniform2iARB = (PFNGLUNIFORM2IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2iARB")) == NULL) || r;
    4462. 

  4462.   r = ((glUniform2ivARB = (PFNGLUNIFORM2IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2ivARB")) == NULL) || r;
    4463. 

  4463.   r = ((glUniform3fARB = (PFNGLUNIFORM3FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fARB")) == NULL) || r;
    4464. 

  4464.   r = ((glUniform3fvARB = (PFNGLUNIFORM3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fvARB")) == NULL) || r;
    4465. 

  4465.   r = ((glUniform3iARB = (PFNGLUNIFORM3IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3iARB")) == NULL) || r;
    4466. 

  4466.   r = ((glUniform3ivARB = (PFNGLUNIFORM3IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3ivARB")) == NULL) || r;
    4467. 

  4467.   r = ((glUniform4fARB = (PFNGLUNIFORM4FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fARB")) == NULL) || r;
    4468. 

  4468.   r = ((glUniform4fvARB = (PFNGLUNIFORM4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fvARB")) == NULL) || r;
    4469. 

  4469.   r = ((glUniform4iARB = (PFNGLUNIFORM4IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4iARB")) == NULL) || r;
    4470. 

  4470.   r = ((glUniform4ivARB = (PFNGLUNIFORM4IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4ivARB")) == NULL) || r;
    4471. 

  4471.   r = ((glUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2fvARB")) == NULL) || r;
    4472. 

  4472.   r = ((glUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3fvARB")) == NULL) || r;
    4473. 

  4473.   r = ((glUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4fvARB")) == NULL) || r;
    4474. 

  4474.   r = ((glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glUseProgramObjectARB")) == NULL) || r;
    4475. 

  4475.   r = ((glValidateProgramARB = (PFNGLVALIDATEPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glValidateProgramARB")) == NULL) || r;
    4476. 

  4476. 

  4477.   return r;
    4478. 

  4478. }
    4479. 

  4479. 

  4480. #endif /* GL_ARB_shader_objects */
    4481. 

  4481. 

  4482. #ifdef GL_ARB_shader_precision
    4483. 

  4483. 

  4484. #endif /* GL_ARB_shader_precision */
    4485. 

  4485. 

  4486. #ifdef GL_ARB_shader_stencil_export
    4487. 

  4487. 

  4488. #endif /* GL_ARB_shader_stencil_export */
    4489. 

  4489. 

  4490. #ifdef GL_ARB_shader_subroutine
    4491. 

  4491. 

  4492. static GLboolean _glewInit_GL_ARB_shader_subroutine (GLEW_CONTEXT_ARG_DEF_INIT)
    4493. 

  4493. {
    4494. 

  4494.   GLboolean r = GL_FALSE;
    4495. 

  4495. 

  4496.   r = ((glGetActiveSubroutineName = (PFNGLGETACTIVESUBROUTINENAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineName")) == NULL) || r;
    4497. 

  4497.   r = ((glGetActiveSubroutineUniformName = (PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineUniformName")) == NULL) || r;
    4498. 

  4498.   r = ((glGetActiveSubroutineUniformiv = (PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveSubroutineUniformiv")) == NULL) || r;
    4499. 

  4499.   r = ((glGetProgramStageiv = (PFNGLGETPROGRAMSTAGEIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStageiv")) == NULL) || r;
    4500. 

  4500.   r = ((glGetSubroutineIndex = (PFNGLGETSUBROUTINEINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetSubroutineIndex")) == NULL) || r;
    4501. 

  4501.   r = ((glGetSubroutineUniformLocation = (PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetSubroutineUniformLocation")) == NULL) || r;
    4502. 

  4502.   r = ((glGetUniformSubroutineuiv = (PFNGLGETUNIFORMSUBROUTINEUIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformSubroutineuiv")) == NULL) || r;
    4503. 

  4503.   r = ((glUniformSubroutinesuiv = (PFNGLUNIFORMSUBROUTINESUIVPROC)glewGetProcAddress((const GLubyte*)"glUniformSubroutinesuiv")) == NULL) || r;
    4504. 

  4504. 

  4505.   return r;
    4506. 

  4506. }
    4507. 

  4507. 

  4508. #endif /* GL_ARB_shader_subroutine */
    4509. 

  4509. 

  4510. #ifdef GL_ARB_shader_texture_lod
    4511. 

  4511. 

  4512. #endif /* GL_ARB_shader_texture_lod */
    4513. 

  4513. 

  4514. #ifdef GL_ARB_shading_language_100
    4515. 

  4515. 

  4516. #endif /* GL_ARB_shading_language_100 */
    4517. 

  4517. 

  4518. #ifdef GL_ARB_shading_language_420pack
    4519. 

  4519. 

  4520. #endif /* GL_ARB_shading_language_420pack */
    4521. 

  4521. 

  4522. #ifdef GL_ARB_shading_language_include
    4523. 

  4523. 

  4524. static GLboolean _glewInit_GL_ARB_shading_language_include (GLEW_CONTEXT_ARG_DEF_INIT)
    4525. 

  4525. {
    4526. 

  4526.   GLboolean r = GL_FALSE;
    4527. 

  4527. 

  4528.   r = ((glCompileShaderIncludeARB = (PFNGLCOMPILESHADERINCLUDEARBPROC)glewGetProcAddress((const GLubyte*)"glCompileShaderIncludeARB")) == NULL) || r;
    4529. 

  4529.   r = ((glDeleteNamedStringARB = (PFNGLDELETENAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteNamedStringARB")) == NULL) || r;
    4530. 

  4530.   r = ((glGetNamedStringARB = (PFNGLGETNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glGetNamedStringARB")) == NULL) || r;
    4531. 

  4531.   r = ((glGetNamedStringivARB = (PFNGLGETNAMEDSTRINGIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetNamedStringivARB")) == NULL) || r;
    4532. 

  4532.   r = ((glIsNamedStringARB = (PFNGLISNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glIsNamedStringARB")) == NULL) || r;
    4533. 

  4533.   r = ((glNamedStringARB = (PFNGLNAMEDSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glNamedStringARB")) == NULL) || r;
    4534. 

  4534. 

  4535.   return r;
    4536. 

  4536. }
    4537. 

  4537. 

  4538. #endif /* GL_ARB_shading_language_include */
    4539. 

  4539. 

  4540. #ifdef GL_ARB_shading_language_packing
    4541. 

  4541. 

  4542. #endif /* GL_ARB_shading_language_packing */
    4543. 

  4543. 

  4544. #ifdef GL_ARB_shadow
    4545. 

  4545. 

  4546. #endif /* GL_ARB_shadow */
    4547. 

  4547. 

  4548. #ifdef GL_ARB_shadow_ambient
    4549. 

  4549. 

  4550. #endif /* GL_ARB_shadow_ambient */
    4551. 

  4551. 

  4552. #ifdef GL_ARB_sync
    4553. 

  4553. 

  4554. static GLboolean _glewInit_GL_ARB_sync (GLEW_CONTEXT_ARG_DEF_INIT)
    4555. 

  4555. {
    4556. 

  4556.   GLboolean r = GL_FALSE;
    4557. 

  4557. 

  4558.   r = ((glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"glClientWaitSync")) == NULL) || r;
    4559. 

  4559.   r = ((glDeleteSync = (PFNGLDELETESYNCPROC)glewGetProcAddress((const GLubyte*)"glDeleteSync")) == NULL) || r;
    4560. 

  4560.   r = ((glFenceSync = (PFNGLFENCESYNCPROC)glewGetProcAddress((const GLubyte*)"glFenceSync")) == NULL) || r;
    4561. 

  4561.   r = ((glGetInteger64v = (PFNGLGETINTEGER64VPROC)glewGetProcAddress((const GLubyte*)"glGetInteger64v")) == NULL) || r;
    4562. 

  4562.   r = ((glGetSynciv = (PFNGLGETSYNCIVPROC)glewGetProcAddress((const GLubyte*)"glGetSynciv")) == NULL) || r;
    4563. 

  4563.   r = ((glIsSync = (PFNGLISSYNCPROC)glewGetProcAddress((const GLubyte*)"glIsSync")) == NULL) || r;
    4564. 

  4564.   r = ((glWaitSync = (PFNGLWAITSYNCPROC)glewGetProcAddress((const GLubyte*)"glWaitSync")) == NULL) || r;
    4565. 

  4565. 

  4566.   return r;
    4567. 

  4567. }
    4568. 

  4568. 

  4569. #endif /* GL_ARB_sync */
    4570. 

  4570. 

  4571. #ifdef GL_ARB_tessellation_shader
    4572. 

  4572. 

  4573. static GLboolean _glewInit_GL_ARB_tessellation_shader (GLEW_CONTEXT_ARG_DEF_INIT)
    4574. 

  4574. {
    4575. 

  4575.   GLboolean r = GL_FALSE;
    4576. 

  4576. 

  4577.   r = ((glPatchParameterfv = (PFNGLPATCHPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glPatchParameterfv")) == NULL) || r;
    4578. 

  4578.   r = ((glPatchParameteri = (PFNGLPATCHPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glPatchParameteri")) == NULL) || r;
    4579. 

  4579. 

  4580.   return r;
    4581. 

  4581. }
    4582. 

  4582. 

  4583. #endif /* GL_ARB_tessellation_shader */
    4584. 

  4584. 

  4585. #ifdef GL_ARB_texture_border_clamp
    4586. 

  4586. 

  4587. #endif /* GL_ARB_texture_border_clamp */
    4588. 

  4588. 

  4589. #ifdef GL_ARB_texture_buffer_object
    4590. 

  4590. 

  4591. static GLboolean _glewInit_GL_ARB_texture_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
    4592. 

  4592. {
    4593. 

  4593.   GLboolean r = GL_FALSE;
    4594. 

  4594. 

  4595.   r = ((glTexBufferARB = (PFNGLTEXBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glTexBufferARB")) == NULL) || r;
    4596. 

  4596. 

  4597.   return r;
    4598. 

  4598. }
    4599. 

  4599. 

  4600. #endif /* GL_ARB_texture_buffer_object */
    4601. 

  4601. 

  4602. #ifdef GL_ARB_texture_buffer_object_rgb32
    4603. 

  4603. 

  4604. #endif /* GL_ARB_texture_buffer_object_rgb32 */
    4605. 

  4605. 

  4606. #ifdef GL_ARB_texture_compression
    4607. 

  4607. 

  4608. static GLboolean _glewInit_GL_ARB_texture_compression (GLEW_CONTEXT_ARG_DEF_INIT)
    4609. 

  4609. {
    4610. 

  4610.   GLboolean r = GL_FALSE;
    4611. 

  4611. 

  4612.   r = ((glCompressedTexImage1DARB = (PFNGLCOMPRESSEDTEXIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage1DARB")) == NULL) || r;
    4613. 

  4613.   r = ((glCompressedTexImage2DARB = (PFNGLCOMPRESSEDTEXIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage2DARB")) == NULL) || r;
    4614. 

  4614.   r = ((glCompressedTexImage3DARB = (PFNGLCOMPRESSEDTEXIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3DARB")) == NULL) || r;
    4615. 

  4615.   r = ((glCompressedTexSubImage1DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage1DARB")) == NULL) || r;
    4616. 

  4616.   r = ((glCompressedTexSubImage2DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage2DARB")) == NULL) || r;
    4617. 

  4617.   r = ((glCompressedTexSubImage3DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3DARB")) == NULL) || r;
    4618. 

  4618.   r = ((glGetCompressedTexImageARB = (PFNGLGETCOMPRESSEDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTexImageARB")) == NULL) || r;
    4619. 

  4619. 

  4620.   return r;
    4621. 

  4621. }
    4622. 

  4622. 

  4623. #endif /* GL_ARB_texture_compression */
    4624. 

  4624. 

  4625. #ifdef GL_ARB_texture_compression_bptc
    4626. 

  4626. 

  4627. #endif /* GL_ARB_texture_compression_bptc */
    4628. 

  4628. 

  4629. #ifdef GL_ARB_texture_compression_rgtc
    4630. 

  4630. 

  4631. #endif /* GL_ARB_texture_compression_rgtc */
    4632. 

  4632. 

  4633. #ifdef GL_ARB_texture_cube_map
    4634. 

  4634. 

  4635. #endif /* GL_ARB_texture_cube_map */
    4636. 

  4636. 

  4637. #ifdef GL_ARB_texture_cube_map_array
    4638. 

  4638. 

  4639. #endif /* GL_ARB_texture_cube_map_array */
    4640. 

  4640. 

  4641. #ifdef GL_ARB_texture_env_add
    4642. 

  4642. 

  4643. #endif /* GL_ARB_texture_env_add */
    4644. 

  4644. 

  4645. #ifdef GL_ARB_texture_env_combine
    4646. 

  4646. 

  4647. #endif /* GL_ARB_texture_env_combine */
    4648. 

  4648. 

  4649. #ifdef GL_ARB_texture_env_crossbar
    4650. 

  4650. 

  4651. #endif /* GL_ARB_texture_env_crossbar */
    4652. 

  4652. 

  4653. #ifdef GL_ARB_texture_env_dot3
    4654. 

  4654. 

  4655. #endif /* GL_ARB_texture_env_dot3 */
    4656. 

  4656. 

  4657. #ifdef GL_ARB_texture_float
    4658. 

  4658. 

  4659. #endif /* GL_ARB_texture_float */
    4660. 

  4660. 

  4661. #ifdef GL_ARB_texture_gather
    4662. 

  4662. 

  4663. #endif /* GL_ARB_texture_gather */
    4664. 

  4664. 

  4665. #ifdef GL_ARB_texture_mirrored_repeat
    4666. 

  4666. 

  4667. #endif /* GL_ARB_texture_mirrored_repeat */
    4668. 

  4668. 

  4669. #ifdef GL_ARB_texture_multisample
    4670. 

  4670. 

  4671. static GLboolean _glewInit_GL_ARB_texture_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
    4672. 

  4672. {
    4673. 

  4673.   GLboolean r = GL_FALSE;
    4674. 

  4674. 

  4675.   r = ((glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)glewGetProcAddress((const GLubyte*)"glGetMultisamplefv")) == NULL) || r;
    4676. 

  4676.   r = ((glSampleMaski = (PFNGLSAMPLEMASKIPROC)glewGetProcAddress((const GLubyte*)"glSampleMaski")) == NULL) || r;
    4677. 

  4677.   r = ((glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexImage2DMultisample")) == NULL) || r;
    4678. 

  4678.   r = ((glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DMultisample")) == NULL) || r;
    4679. 

  4679. 

  4680.   return r;
    4681. 

  4681. }
    4682. 

  4682. 

  4683. #endif /* GL_ARB_texture_multisample */
    4684. 

  4684. 

  4685. #ifdef GL_ARB_texture_non_power_of_two
    4686. 

  4686. 

  4687. #endif /* GL_ARB_texture_non_power_of_two */
    4688. 

  4688. 

  4689. #ifdef GL_ARB_texture_query_lod
    4690. 

  4690. 

  4691. #endif /* GL_ARB_texture_query_lod */
    4692. 

  4692. 

  4693. #ifdef GL_ARB_texture_rectangle
    4694. 

  4694. 

  4695. #endif /* GL_ARB_texture_rectangle */
    4696. 

  4696. 

  4697. #ifdef GL_ARB_texture_rg
    4698. 

  4698. 

  4699. #endif /* GL_ARB_texture_rg */
    4700. 

  4700. 

  4701. #ifdef GL_ARB_texture_rgb10_a2ui
    4702. 

  4702. 

  4703. #endif /* GL_ARB_texture_rgb10_a2ui */
    4704. 

  4704. 

  4705. #ifdef GL_ARB_texture_storage
    4706. 

  4706. 

  4707. static GLboolean _glewInit_GL_ARB_texture_storage (GLEW_CONTEXT_ARG_DEF_INIT)
    4708. 

  4708. {
    4709. 

  4709.   GLboolean r = GL_FALSE;
    4710. 

  4710. 

  4711.   r = ((glTexStorage1D = (PFNGLTEXSTORAGE1DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage1D")) == NULL) || r;
    4712. 

  4712.   r = ((glTexStorage2D = (PFNGLTEXSTORAGE2DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage2D")) == NULL) || r;
    4713. 

  4713.   r = ((glTexStorage3D = (PFNGLTEXSTORAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage3D")) == NULL) || r;
    4714. 

  4714.   r = ((glTextureStorage1DEXT = (PFNGLTEXTURESTORAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage1DEXT")) == NULL) || r;
    4715. 

  4715.   r = ((glTextureStorage2DEXT = (PFNGLTEXTURESTORAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage2DEXT")) == NULL) || r;
    4716. 

  4716.   r = ((glTextureStorage3DEXT = (PFNGLTEXTURESTORAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage3DEXT")) == NULL) || r;
    4717. 

  4717. 

  4718.   return r;
    4719. 

  4719. }
    4720. 

  4720. 

  4721. #endif /* GL_ARB_texture_storage */
    4722. 

  4722. 

  4723. #ifdef GL_ARB_texture_swizzle
    4724. 

  4724. 

  4725. #endif /* GL_ARB_texture_swizzle */
    4726. 

  4726. 

  4727. #ifdef GL_ARB_timer_query
    4728. 

  4728. 

  4729. static GLboolean _glewInit_GL_ARB_timer_query (GLEW_CONTEXT_ARG_DEF_INIT)
    4730. 

  4730. {
    4731. 

  4731.   GLboolean r = GL_FALSE;
    4732. 

  4732. 

  4733.   r = ((glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjecti64v")) == NULL) || r;
    4734. 

  4734.   r = ((glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectui64v")) == NULL) || r;
    4735. 

  4735.   r = ((glQueryCounter = (PFNGLQUERYCOUNTERPROC)glewGetProcAddress((const GLubyte*)"glQueryCounter")) == NULL) || r;
    4736. 

  4736. 

  4737.   return r;
    4738. 

  4738. }
    4739. 

  4739. 

  4740. #endif /* GL_ARB_timer_query */
    4741. 

  4741. 

  4742. #ifdef GL_ARB_transform_feedback2
    4743. 

  4743. 

  4744. static GLboolean _glewInit_GL_ARB_transform_feedback2 (GLEW_CONTEXT_ARG_DEF_INIT)
    4745. 

  4745. {
    4746. 

  4746.   GLboolean r = GL_FALSE;
    4747. 

  4747. 

  4748.   r = ((glBindTransformFeedback = (PFNGLBINDTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glBindTransformFeedback")) == NULL) || r;
    4749. 

  4749.   r = ((glDeleteTransformFeedbacks = (PFNGLDELETETRANSFORMFEEDBACKSPROC)glewGetProcAddress((const GLubyte*)"glDeleteTransformFeedbacks")) == NULL) || r;
    4750. 

  4750.   r = ((glDrawTransformFeedback = (PFNGLDRAWTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedback")) == NULL) || r;
    4751. 

  4751.   r = ((glGenTransformFeedbacks = (PFNGLGENTRANSFORMFEEDBACKSPROC)glewGetProcAddress((const GLubyte*)"glGenTransformFeedbacks")) == NULL) || r;
    4752. 

  4752.   r = ((glIsTransformFeedback = (PFNGLISTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glIsTransformFeedback")) == NULL) || r;
    4753. 

  4753.   r = ((glPauseTransformFeedback = (PFNGLPAUSETRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glPauseTransformFeedback")) == NULL) || r;
    4754. 

  4754.   r = ((glResumeTransformFeedback = (PFNGLRESUMETRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glResumeTransformFeedback")) == NULL) || r;
    4755. 

  4755. 

  4756.   return r;
    4757. 

  4757. }
    4758. 

  4758. 

  4759. #endif /* GL_ARB_transform_feedback2 */
    4760. 

  4760. 

  4761. #ifdef GL_ARB_transform_feedback3
    4762. 

  4762. 

  4763. static GLboolean _glewInit_GL_ARB_transform_feedback3 (GLEW_CONTEXT_ARG_DEF_INIT)
    4764. 

  4764. {
    4765. 

  4765.   GLboolean r = GL_FALSE;
    4766. 

  4766. 

  4767.   r = ((glBeginQueryIndexed = (PFNGLBEGINQUERYINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryIndexed")) == NULL) || r;
    4768. 

  4768.   r = ((glDrawTransformFeedbackStream = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackStream")) == NULL) || r;
    4769. 

  4769.   r = ((glEndQueryIndexed = (PFNGLENDQUERYINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glEndQueryIndexed")) == NULL) || r;
    4770. 

  4770.   r = ((glGetQueryIndexediv = (PFNGLGETQUERYINDEXEDIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryIndexediv")) == NULL) || r;
    4771. 

  4771. 

  4772.   return r;
    4773. 

  4773. }
    4774. 

  4774. 

  4775. #endif /* GL_ARB_transform_feedback3 */
    4776. 

  4776. 

  4777. #ifdef GL_ARB_transform_feedback_instanced
    4778. 

  4778. 

  4779. static GLboolean _glewInit_GL_ARB_transform_feedback_instanced (GLEW_CONTEXT_ARG_DEF_INIT)
    4780. 

  4780. {
    4781. 

  4781.   GLboolean r = GL_FALSE;
    4782. 

  4782. 

  4783.   r = ((glDrawTransformFeedbackInstanced = (PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackInstanced")) == NULL) || r;
    4784. 

  4784.   r = ((glDrawTransformFeedbackStreamInstanced = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackStreamInstanced")) == NULL) || r;
    4785. 

  4785. 

  4786.   return r;
    4787. 

  4787. }
    4788. 

  4788. 

  4789. #endif /* GL_ARB_transform_feedback_instanced */
    4790. 

  4790. 

  4791. #ifdef GL_ARB_transpose_matrix
    4792. 

  4792. 

  4793. static GLboolean _glewInit_GL_ARB_transpose_matrix (GLEW_CONTEXT_ARG_DEF_INIT)
    4794. 

  4794. {
    4795. 

  4795.   GLboolean r = GL_FALSE;
    4796. 

  4796. 

  4797.   r = ((glLoadTransposeMatrixdARB = (PFNGLLOADTRANSPOSEMATRIXDARBPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixdARB")) == NULL) || r;
    4798. 

  4798.   r = ((glLoadTransposeMatrixfARB = (PFNGLLOADTRANSPOSEMATRIXFARBPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixfARB")) == NULL) || r;
    4799. 

  4799.   r = ((glMultTransposeMatrixdARB = (PFNGLMULTTRANSPOSEMATRIXDARBPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixdARB")) == NULL) || r;
    4800. 

  4800.   r = ((glMultTransposeMatrixfARB = (PFNGLMULTTRANSPOSEMATRIXFARBPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixfARB")) == NULL) || r;
    4801. 

  4801. 

  4802.   return r;
    4803. 

  4803. }
    4804. 

  4804. 

  4805. #endif /* GL_ARB_transpose_matrix */
    4806. 

  4806. 

  4807. #ifdef GL_ARB_uniform_buffer_object
    4808. 

  4808. 

  4809. static GLboolean _glewInit_GL_ARB_uniform_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
    4810. 

  4810. {
    4811. 

  4811.   GLboolean r = GL_FALSE;
    4812. 

  4812. 

  4813.   r = ((glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBase")) == NULL) || r;
    4814. 

  4814.   r = ((glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRange")) == NULL) || r;
    4815. 

  4815.   r = ((glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformBlockName")) == NULL) || r;
    4816. 

  4816.   r = ((glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformBlockiv")) == NULL) || r;
    4817. 

  4817.   r = ((glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformName")) == NULL) || r;
    4818. 

  4818.   r = ((glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformsiv")) == NULL) || r;
    4819. 

  4819.   r = ((glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)glewGetProcAddress((const GLubyte*)"glGetIntegeri_v")) == NULL) || r;
    4820. 

  4820.   r = ((glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)glewGetProcAddress((const GLubyte*)"glGetUniformBlockIndex")) == NULL) || r;
    4821. 

  4821.   r = ((glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)glewGetProcAddress((const GLubyte*)"glGetUniformIndices")) == NULL) || r;
    4822. 

  4822.   r = ((glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)glewGetProcAddress((const GLubyte*)"glUniformBlockBinding")) == NULL) || r;
    4823. 

  4823. 

  4824.   return r;
    4825. 

  4825. }
    4826. 

  4826. 

  4827. #endif /* GL_ARB_uniform_buffer_object */
    4828. 

  4828. 

  4829. #ifdef GL_ARB_vertex_array_bgra
    4830. 

  4830. 

  4831. #endif /* GL_ARB_vertex_array_bgra */
    4832. 

  4832. 

  4833. #ifdef GL_ARB_vertex_array_object
    4834. 

  4834. 

  4835. static GLboolean _glewInit_GL_ARB_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT)
    4836. 

  4836. {
    4837. 

  4837.   GLboolean r = GL_FALSE;
    4838. 

  4838. 

  4839.   r = ((glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)glewGetProcAddress((const GLubyte*)"glBindVertexArray")) == NULL) || r;
    4840. 

  4840.   r = ((glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexArrays")) == NULL) || r;
    4841. 

  4841.   r = ((glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glGenVertexArrays")) == NULL) || r;
    4842. 

  4842.   r = ((glIsVertexArray = (PFNGLISVERTEXARRAYPROC)glewGetProcAddress((const GLubyte*)"glIsVertexArray")) == NULL) || r;
    4843. 

  4843. 

  4844.   return r;
    4845. 

  4845. }
    4846. 

  4846. 

  4847. #endif /* GL_ARB_vertex_array_object */
    4848. 

  4848. 

  4849. #ifdef GL_ARB_vertex_attrib_64bit
    4850. 

  4850. 

  4851. static GLboolean _glewInit_GL_ARB_vertex_attrib_64bit (GLEW_CONTEXT_ARG_DEF_INIT)
    4852. 

  4852. {
    4853. 

  4853.   GLboolean r = GL_FALSE;
    4854. 

  4854. 

  4855.   r = ((glGetVertexAttribLdv = (PFNGLGETVERTEXATTRIBLDVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLdv")) == NULL) || r;
    4856. 

  4856.   r = ((glVertexAttribL1d = (PFNGLVERTEXATTRIBL1DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1d")) == NULL) || r;
    4857. 

  4857.   r = ((glVertexAttribL1dv = (PFNGLVERTEXATTRIBL1DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dv")) == NULL) || r;
    4858. 

  4858.   r = ((glVertexAttribL2d = (PFNGLVERTEXATTRIBL2DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2d")) == NULL) || r;
    4859. 

  4859.   r = ((glVertexAttribL2dv = (PFNGLVERTEXATTRIBL2DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dv")) == NULL) || r;
    4860. 

  4860.   r = ((glVertexAttribL3d = (PFNGLVERTEXATTRIBL3DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3d")) == NULL) || r;
    4861. 

  4861.   r = ((glVertexAttribL3dv = (PFNGLVERTEXATTRIBL3DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dv")) == NULL) || r;
    4862. 

  4862.   r = ((glVertexAttribL4d = (PFNGLVERTEXATTRIBL4DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4d")) == NULL) || r;
    4863. 

  4863.   r = ((glVertexAttribL4dv = (PFNGLVERTEXATTRIBL4DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dv")) == NULL) || r;
    4864. 

  4864.   r = ((glVertexAttribLPointer = (PFNGLVERTEXATTRIBLPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLPointer")) == NULL) || r;
    4865. 

  4865. 

  4866.   return r;
    4867. 

  4867. }
    4868. 

  4868. 

  4869. #endif /* GL_ARB_vertex_attrib_64bit */
    4870. 

  4870. 

  4871. #ifdef GL_ARB_vertex_blend
    4872. 

  4872. 

  4873. static GLboolean _glewInit_GL_ARB_vertex_blend (GLEW_CONTEXT_ARG_DEF_INIT)
    4874. 

  4874. {
    4875. 

  4875.   GLboolean r = GL_FALSE;
    4876. 

  4876. 

  4877.   r = ((glVertexBlendARB = (PFNGLVERTEXBLENDARBPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendARB")) == NULL) || r;
    4878. 

  4878.   r = ((glWeightPointerARB = (PFNGLWEIGHTPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glWeightPointerARB")) == NULL) || r;
    4879. 

  4879.   r = ((glWeightbvARB = (PFNGLWEIGHTBVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightbvARB")) == NULL) || r;
    4880. 

  4880.   r = ((glWeightdvARB = (PFNGLWEIGHTDVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightdvARB")) == NULL) || r;
    4881. 

  4881.   r = ((glWeightfvARB = (PFNGLWEIGHTFVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightfvARB")) == NULL) || r;
    4882. 

  4882.   r = ((glWeightivARB = (PFNGLWEIGHTIVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightivARB")) == NULL) || r;
    4883. 

  4883.   r = ((glWeightsvARB = (PFNGLWEIGHTSVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightsvARB")) == NULL) || r;
    4884. 

  4884.   r = ((glWeightubvARB = (PFNGLWEIGHTUBVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightubvARB")) == NULL) || r;
    4885. 

  4885.   r = ((glWeightuivARB = (PFNGLWEIGHTUIVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightuivARB")) == NULL) || r;
    4886. 

  4886.   r = ((glWeightusvARB = (PFNGLWEIGHTUSVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightusvARB")) == NULL) || r;
    4887. 

  4887. 

  4888.   return r;
    4889. 

  4889. }
    4890. 

  4890. 

  4891. #endif /* GL_ARB_vertex_blend */
    4892. 

  4892. 

  4893. #ifdef GL_ARB_vertex_buffer_object
    4894. 

  4894. 

  4895. static GLboolean _glewInit_GL_ARB_vertex_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
    4896. 

  4896. {
    4897. 

  4897.   GLboolean r = GL_FALSE;
    4898. 

  4898. 

  4899.   r = ((glBindBufferARB = (PFNGLBINDBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glBindBufferARB")) == NULL) || r;
    4900. 

  4900.   r = ((glBufferDataARB = (PFNGLBUFFERDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferDataARB")) == NULL) || r;
    4901. 

  4901.   r = ((glBufferSubDataARB = (PFNGLBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferSubDataARB")) == NULL) || r;
    4902. 

  4902.   r = ((glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteBuffersARB")) == NULL) || r;
    4903. 

  4903.   r = ((glGenBuffersARB = (PFNGLGENBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glGenBuffersARB")) == NULL) || r;
    4904. 

  4904.   r = ((glGetBufferParameterivARB = (PFNGLGETBUFFERPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameterivARB")) == NULL) || r;
    4905. 

  4905.   r = ((glGetBufferPointervARB = (PFNGLGETBUFFERPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointervARB")) == NULL) || r;
    4906. 

  4906.   r = ((glGetBufferSubDataARB = (PFNGLGETBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferSubDataARB")) == NULL) || r;
    4907. 

  4907.   r = ((glIsBufferARB = (PFNGLISBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glIsBufferARB")) == NULL) || r;
    4908. 

  4908.   r = ((glMapBufferARB = (PFNGLMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glMapBufferARB")) == NULL) || r;
    4909. 

  4909.   r = ((glUnmapBufferARB = (PFNGLUNMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glUnmapBufferARB")) == NULL) || r;
    4910. 

  4910. 

  4911.   return r;
    4912. 

  4912. }
    4913. 

  4913. 

  4914. #endif /* GL_ARB_vertex_buffer_object */
    4915. 

  4915. 

  4916. #ifdef GL_ARB_vertex_program
    4917. 

  4917. 

  4918. static GLboolean _glewInit_GL_ARB_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT)
    4919. 

  4919. {
    4920. 

  4920.   GLboolean r = GL_FALSE;
    4921. 

  4921. 

  4922.   r = ((glBindProgramARB = (PFNGLBINDPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glBindProgramARB")) == NULL) || r;
    4923. 

  4923.   r = ((glDeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsARB")) == NULL) || r;
    4924. 

  4924.   r = ((glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribArrayARB")) == NULL) || r;
    4925. 

  4925.   r = ((glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribArrayARB")) == NULL) || r;
    4926. 

  4926.   r = ((glGenProgramsARB = (PFNGLGENPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsARB")) == NULL) || r;
    4927. 

  4927.   r = ((glGetProgramEnvParameterdvARB = (PFNGLGETPROGRAMENVPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterdvARB")) == NULL) || r;
    4928. 

  4928.   r = ((glGetProgramEnvParameterfvARB = (PFNGLGETPROGRAMENVPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterfvARB")) == NULL) || r;
    4929. 

  4929.   r = ((glGetProgramLocalParameterdvARB = (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterdvARB")) == NULL) || r;
    4930. 

  4930.   r = ((glGetProgramLocalParameterfvARB = (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterfvARB")) == NULL) || r;
    4931. 

  4931.   r = ((glGetProgramStringARB = (PFNGLGETPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringARB")) == NULL) || r;
    4932. 

  4932.   r = ((glGetProgramivARB = (PFNGLGETPROGRAMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivARB")) == NULL) || r;
    4933. 

  4933.   r = ((glGetVertexAttribPointervARB = (PFNGLGETVERTEXATTRIBPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervARB")) == NULL) || r;
    4934. 

  4934.   r = ((glGetVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvARB")) == NULL) || r;
    4935. 

  4935.   r = ((glGetVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvARB")) == NULL) || r;
    4936. 

  4936.   r = ((glGetVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivARB")) == NULL) || r;
    4937. 

  4937.   r = ((glIsProgramARB = (PFNGLISPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glIsProgramARB")) == NULL) || r;
    4938. 

  4938.   r = ((glProgramEnvParameter4dARB = (PFNGLPROGRAMENVPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dARB")) == NULL) || r;
    4939. 

  4939.   r = ((glProgramEnvParameter4dvARB = (PFNGLPROGRAMENVPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dvARB")) == NULL) || r;
    4940. 

  4940.   r = ((glProgramEnvParameter4fARB = (PFNGLPROGRAMENVPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fARB")) == NULL) || r;
    4941. 

  4941.   r = ((glProgramEnvParameter4fvARB = (PFNGLPROGRAMENVPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fvARB")) == NULL) || r;
    4942. 

  4942.   r = ((glProgramLocalParameter4dARB = (PFNGLPROGRAMLOCALPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dARB")) == NULL) || r;
    4943. 

  4943.   r = ((glProgramLocalParameter4dvARB = (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dvARB")) == NULL) || r;
    4944. 

  4944.   r = ((glProgramLocalParameter4fARB = (PFNGLPROGRAMLOCALPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fARB")) == NULL) || r;
    4945. 

  4945.   r = ((glProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fvARB")) == NULL) || r;
    4946. 

  4946.   r = ((glProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glProgramStringARB")) == NULL) || r;
    4947. 

  4947.   r = ((glVertexAttrib1dARB = (PFNGLVERTEXATTRIB1DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dARB")) == NULL) || r;
    4948. 

  4948.   r = ((glVertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvARB")) == NULL) || r;
    4949. 

  4949.   r = ((glVertexAttrib1fARB = (PFNGLVERTEXATTRIB1FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fARB")) == NULL) || r;
    4950. 

  4950.   r = ((glVertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvARB")) == NULL) || r;
    4951. 

  4951.   r = ((glVertexAttrib1sARB = (PFNGLVERTEXATTRIB1SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sARB")) == NULL) || r;
    4952. 

  4952.   r = ((glVertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svARB")) == NULL) || r;
    4953. 

  4953.   r = ((glVertexAttrib2dARB = (PFNGLVERTEXATTRIB2DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dARB")) == NULL) || r;
    4954. 

  4954.   r = ((glVertexAttrib2dvARB = (PFNGLVERTEXATTRIB2DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvARB")) == NULL) || r;
    4955. 

  4955.   r = ((glVertexAttrib2fARB = (PFNGLVERTEXATTRIB2FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fARB")) == NULL) || r;
    4956. 

  4956.   r = ((glVertexAttrib2fvARB = (PFNGLVERTEXATTRIB2FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvARB")) == NULL) || r;
    4957. 

  4957.   r = ((glVertexAttrib2sARB = (PFNGLVERTEXATTRIB2SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sARB")) == NULL) || r;
    4958. 

  4958.   r = ((glVertexAttrib2svARB = (PFNGLVERTEXATTRIB2SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svARB")) == NULL) || r;
    4959. 

  4959.   r = ((glVertexAttrib3dARB = (PFNGLVERTEXATTRIB3DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dARB")) == NULL) || r;
    4960. 

  4960.   r = ((glVertexAttrib3dvARB = (PFNGLVERTEXATTRIB3DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvARB")) == NULL) || r;
    4961. 

  4961.   r = ((glVertexAttrib3fARB = (PFNGLVERTEXATTRIB3FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fARB")) == NULL) || r;
    4962. 

  4962.   r = ((glVertexAttrib3fvARB = (PFNGLVERTEXATTRIB3FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvARB")) == NULL) || r;
    4963. 

  4963.   r = ((glVertexAttrib3sARB = (PFNGLVERTEXATTRIB3SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sARB")) == NULL) || r;
    4964. 

  4964.   r = ((glVertexAttrib3svARB = (PFNGLVERTEXATTRIB3SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svARB")) == NULL) || r;
    4965. 

  4965.   r = ((glVertexAttrib4NbvARB = (PFNGLVERTEXATTRIB4NBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NbvARB")) == NULL) || r;
    4966. 

  4966.   r = ((glVertexAttrib4NivARB = (PFNGLVERTEXATTRIB4NIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NivARB")) == NULL) || r;
    4967. 

  4967.   r = ((glVertexAttrib4NsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NsvARB")) == NULL) || r;
    4968. 

  4968.   r = ((glVertexAttrib4NubARB = (PFNGLVERTEXATTRIB4NUBARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubARB")) == NULL) || r;
    4969. 

  4969.   r = ((glVertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubvARB")) == NULL) || r;
    4970. 

  4970.   r = ((glVertexAttrib4NuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NuivARB")) == NULL) || r;
    4971. 

  4971.   r = ((glVertexAttrib4NusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NusvARB")) == NULL) || r;
    4972. 

  4972.   r = ((glVertexAttrib4bvARB = (PFNGLVERTEXATTRIB4BVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4bvARB")) == NULL) || r;
    4973. 

  4973.   r = ((glVertexAttrib4dARB = (PFNGLVERTEXATTRIB4DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dARB")) == NULL) || r;
    4974. 

  4974.   r = ((glVertexAttrib4dvARB = (PFNGLVERTEXATTRIB4DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvARB")) == NULL) || r;
    4975. 

  4975.   r = ((glVertexAttrib4fARB = (PFNGLVERTEXATTRIB4FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fARB")) == NULL) || r;
    4976. 

  4976.   r = ((glVertexAttrib4fvARB = (PFNGLVERTEXATTRIB4FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvARB")) == NULL) || r;
    4977. 

  4977.   r = ((glVertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ivARB")) == NULL) || r;
    4978. 

  4978.   r = ((glVertexAttrib4sARB = (PFNGLVERTEXATTRIB4SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sARB")) == NULL) || r;
    4979. 

  4979.   r = ((glVertexAttrib4svARB = (PFNGLVERTEXATTRIB4SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svARB")) == NULL) || r;
    4980. 

  4980.   r = ((glVertexAttrib4ubvARB = (PFNGLVERTEXATTRIB4UBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvARB")) == NULL) || r;
    4981. 

  4981.   r = ((glVertexAttrib4uivARB = (PFNGLVERTEXATTRIB4UIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4uivARB")) == NULL) || r;
    4982. 

  4982.   r = ((glVertexAttrib4usvARB = (PFNGLVERTEXATTRIB4USVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4usvARB")) == NULL) || r;
    4983. 

  4983.   r = ((glVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerARB")) == NULL) || r;
    4984. 

  4984. 

  4985.   return r;
    4986. 

  4986. }
    4987. 

  4987. 

  4988. #endif /* GL_ARB_vertex_program */
    4989. 

  4989. 

  4990. #ifdef GL_ARB_vertex_shader
    4991. 

  4991. 

  4992. static GLboolean _glewInit_GL_ARB_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT)
    4993. 

  4993. {
    4994. 

  4994.   GLboolean r = GL_FALSE;
    4995. 

  4995. 

  4996.   r = ((glBindAttribLocationARB = (PFNGLBINDATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glBindAttribLocationARB")) == NULL) || r;
    4997. 

  4997.   r = ((glGetActiveAttribARB = (PFNGLGETACTIVEATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAttribARB")) == NULL) || r;
    4998. 

  4998.   r = ((glGetAttribLocationARB = (PFNGLGETATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttribLocationARB")) == NULL) || r;
    4999. 

  4999. 

  5000.   return r;
    5001. 

  5001. }
    5002. 

  5002. 

  5003. #endif /* GL_ARB_vertex_shader */
    5004. 

  5004. 

  5005. #ifdef GL_ARB_vertex_type_2_10_10_10_rev
    5006. 

  5006. 

  5007. static GLboolean _glewInit_GL_ARB_vertex_type_2_10_10_10_rev (GLEW_CONTEXT_ARG_DEF_INIT)
    5008. 

  5008. {
    5009. 

  5009.   GLboolean r = GL_FALSE;
    5010. 

  5010. 

  5011.   r = ((glColorP3ui = (PFNGLCOLORP3UIPROC)glewGetProcAddress((const GLubyte*)"glColorP3ui")) == NULL) || r;
    5012. 

  5012.   r = ((glColorP3uiv = (PFNGLCOLORP3UIVPROC)glewGetProcAddress((const GLubyte*)"glColorP3uiv")) == NULL) || r;
    5013. 

  5013.   r = ((glColorP4ui = (PFNGLCOLORP4UIPROC)glewGetProcAddress((const GLubyte*)"glColorP4ui")) == NULL) || r;
    5014. 

  5014.   r = ((glColorP4uiv = (PFNGLCOLORP4UIVPROC)glewGetProcAddress((const GLubyte*)"glColorP4uiv")) == NULL) || r;
    5015. 

  5015.   r = ((glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP1ui")) == NULL) || r;
    5016. 

  5016.   r = ((glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP1uiv")) == NULL) || r;
    5017. 

  5017.   r = ((glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP2ui")) == NULL) || r;
    5018. 

  5018.   r = ((glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP2uiv")) == NULL) || r;
    5019. 

  5019.   r = ((glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP3ui")) == NULL) || r;
    5020. 

  5020.   r = ((glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP3uiv")) == NULL) || r;
    5021. 

  5021.   r = ((glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP4ui")) == NULL) || r;
    5022. 

  5022.   r = ((glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordP4uiv")) == NULL) || r;
    5023. 

  5023.   r = ((glNormalP3ui = (PFNGLNORMALP3UIPROC)glewGetProcAddress((const GLubyte*)"glNormalP3ui")) == NULL) || r;
    5024. 

  5024.   r = ((glNormalP3uiv = (PFNGLNORMALP3UIVPROC)glewGetProcAddress((const GLubyte*)"glNormalP3uiv")) == NULL) || r;
    5025. 

  5025.   r = ((glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorP3ui")) == NULL) || r;
    5026. 

  5026.   r = ((glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorP3uiv")) == NULL) || r;
    5027. 

  5027.   r = ((glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP1ui")) == NULL) || r;
    5028. 

  5028.   r = ((glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP1uiv")) == NULL) || r;
    5029. 

  5029.   r = ((glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP2ui")) == NULL) || r;
    5030. 

  5030.   r = ((glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP2uiv")) == NULL) || r;
    5031. 

  5031.   r = ((glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP3ui")) == NULL) || r;
    5032. 

  5032.   r = ((glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP3uiv")) == NULL) || r;
    5033. 

  5033.   r = ((glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP4ui")) == NULL) || r;
    5034. 

  5034.   r = ((glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordP4uiv")) == NULL) || r;
    5035. 

  5035.   r = ((glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP1ui")) == NULL) || r;
    5036. 

  5036.   r = ((glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP1uiv")) == NULL) || r;
    5037. 

  5037.   r = ((glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP2ui")) == NULL) || r;
    5038. 

  5038.   r = ((glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP2uiv")) == NULL) || r;
    5039. 

  5039.   r = ((glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP3ui")) == NULL) || r;
    5040. 

  5040.   r = ((glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP3uiv")) == NULL) || r;
    5041. 

  5041.   r = ((glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP4ui")) == NULL) || r;
    5042. 

  5042.   r = ((glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribP4uiv")) == NULL) || r;
    5043. 

  5043.   r = ((glVertexP2ui = (PFNGLVERTEXP2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP2ui")) == NULL) || r;
    5044. 

  5044.   r = ((glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP2uiv")) == NULL) || r;
    5045. 

  5045.   r = ((glVertexP3ui = (PFNGLVERTEXP3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP3ui")) == NULL) || r;
    5046. 

  5046.   r = ((glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP3uiv")) == NULL) || r;
    5047. 

  5047.   r = ((glVertexP4ui = (PFNGLVERTEXP4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexP4ui")) == NULL) || r;
    5048. 

  5048.   r = ((glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexP4uiv")) == NULL) || r;
    5049. 

  5049. 

  5050.   return r;
    5051. 

  5051. }
    5052. 

  5052. 

  5053. #endif /* GL_ARB_vertex_type_2_10_10_10_rev */
    5054. 

  5054. 

  5055. #ifdef GL_ARB_viewport_array
    5056. 

  5056. 

  5057. static GLboolean _glewInit_GL_ARB_viewport_array (GLEW_CONTEXT_ARG_DEF_INIT)
    5058. 

  5058. {
    5059. 

  5059.   GLboolean r = GL_FALSE;
    5060. 

  5060. 

  5061.   r = ((glDepthRangeArrayv = (PFNGLDEPTHRANGEARRAYVPROC)glewGetProcAddress((const GLubyte*)"glDepthRangeArrayv")) == NULL) || r;
    5062. 

  5062.   r = ((glDepthRangeIndexed = (PFNGLDEPTHRANGEINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glDepthRangeIndexed")) == NULL) || r;
    5063. 

  5063.   r = ((glGetDoublei_v = (PFNGLGETDOUBLEI_VPROC)glewGetProcAddress((const GLubyte*)"glGetDoublei_v")) == NULL) || r;
    5064. 

  5064.   r = ((glGetFloati_v = (PFNGLGETFLOATI_VPROC)glewGetProcAddress((const GLubyte*)"glGetFloati_v")) == NULL) || r;
    5065. 

  5065.   r = ((glScissorArrayv = (PFNGLSCISSORARRAYVPROC)glewGetProcAddress((const GLubyte*)"glScissorArrayv")) == NULL) || r;
    5066. 

  5066.   r = ((glScissorIndexed = (PFNGLSCISSORINDEXEDPROC)glewGetProcAddress((const GLubyte*)"glScissorIndexed")) == NULL) || r;
    5067. 

  5067.   r = ((glScissorIndexedv = (PFNGLSCISSORINDEXEDVPROC)glewGetProcAddress((const GLubyte*)"glScissorIndexedv")) == NULL) || r;
    5068. 

  5068.   r = ((glViewportArrayv = (PFNGLVIEWPORTARRAYVPROC)glewGetProcAddress((const GLubyte*)"glViewportArrayv")) == NULL) || r;
    5069. 

  5069.   r = ((glViewportIndexedf = (PFNGLVIEWPORTINDEXEDFPROC)glewGetProcAddress((const GLubyte*)"glViewportIndexedf")) == NULL) || r;
    5070. 

  5070.   r = ((glViewportIndexedfv = (PFNGLVIEWPORTINDEXEDFVPROC)glewGetProcAddress((const GLubyte*)"glViewportIndexedfv")) == NULL) || r;
    5071. 

  5071. 

  5072.   return r;
    5073. 

  5073. }
    5074. 

  5074. 

  5075. #endif /* GL_ARB_viewport_array */
    5076. 

  5076. 

  5077. #ifdef GL_ARB_window_pos
    5078. 

  5078. 

  5079. static GLboolean _glewInit_GL_ARB_window_pos (GLEW_CONTEXT_ARG_DEF_INIT)
    5080. 

  5080. {
    5081. 

  5081.   GLboolean r = GL_FALSE;
    5082. 

  5082. 

  5083.   r = ((glWindowPos2dARB = (PFNGLWINDOWPOS2DARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dARB")) == NULL) || r;
    5084. 

  5084.   r = ((glWindowPos2dvARB = (PFNGLWINDOWPOS2DVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dvARB")) == NULL) || r;
    5085. 

  5085.   r = ((glWindowPos2fARB = (PFNGLWINDOWPOS2FARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fARB")) == NULL) || r;
    5086. 

  5086.   r = ((glWindowPos2fvARB = (PFNGLWINDOWPOS2FVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fvARB")) == NULL) || r;
    5087. 

  5087.   r = ((glWindowPos2iARB = (PFNGLWINDOWPOS2IARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iARB")) == NULL) || r;
    5088. 

  5088.   r = ((glWindowPos2ivARB = (PFNGLWINDOWPOS2IVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2ivARB")) == NULL) || r;
    5089. 

  5089.   r = ((glWindowPos2sARB = (PFNGLWINDOWPOS2SARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sARB")) == NULL) || r;
    5090. 

  5090.   r = ((glWindowPos2svARB = (PFNGLWINDOWPOS2SVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2svARB")) == NULL) || r;
    5091. 

  5091.   r = ((glWindowPos3dARB = (PFNGLWINDOWPOS3DARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dARB")) == NULL) || r;
    5092. 

  5092.   r = ((glWindowPos3dvARB = (PFNGLWINDOWPOS3DVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dvARB")) == NULL) || r;
    5093. 

  5093.   r = ((glWindowPos3fARB = (PFNGLWINDOWPOS3FARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fARB")) == NULL) || r;
    5094. 

  5094.   r = ((glWindowPos3fvARB = (PFNGLWINDOWPOS3FVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fvARB")) == NULL) || r;
    5095. 

  5095.   r = ((glWindowPos3iARB = (PFNGLWINDOWPOS3IARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iARB")) == NULL) || r;
    5096. 

  5096.   r = ((glWindowPos3ivARB = (PFNGLWINDOWPOS3IVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3ivARB")) == NULL) || r;
    5097. 

  5097.   r = ((glWindowPos3sARB = (PFNGLWINDOWPOS3SARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sARB")) == NULL) || r;
    5098. 

  5098.   r = ((glWindowPos3svARB = (PFNGLWINDOWPOS3SVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3svARB")) == NULL) || r;
    5099. 

  5099. 

  5100.   return r;
    5101. 

  5101. }
    5102. 

  5102. 

  5103. #endif /* GL_ARB_window_pos */
    5104. 

  5104. 

  5105. #ifdef GL_ATIX_point_sprites
    5106. 

  5106. 

  5107. #endif /* GL_ATIX_point_sprites */
    5108. 

  5108. 

  5109. #ifdef GL_ATIX_texture_env_combine3
    5110. 

  5110. 

  5111. #endif /* GL_ATIX_texture_env_combine3 */
    5112. 

  5112. 

  5113. #ifdef GL_ATIX_texture_env_route
    5114. 

  5114. 

  5115. #endif /* GL_ATIX_texture_env_route */
    5116. 

  5116. 

  5117. #ifdef GL_ATIX_vertex_shader_output_point_size
    5118. 

  5118. 

  5119. #endif /* GL_ATIX_vertex_shader_output_point_size */
    5120. 

  5120. 

  5121. #ifdef GL_ATI_draw_buffers
    5122. 

  5122. 

  5123. static GLboolean _glewInit_GL_ATI_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT)
    5124. 

  5124. {
    5125. 

  5125.   GLboolean r = GL_FALSE;
    5126. 

  5126. 

  5127.   r = ((glDrawBuffersATI = (PFNGLDRAWBUFFERSATIPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersATI")) == NULL) || r;
    5128. 

  5128. 

  5129.   return r;
    5130. 

  5130. }
    5131. 

  5131. 

  5132. #endif /* GL_ATI_draw_buffers */
    5133. 

  5133. 

  5134. #ifdef GL_ATI_element_array
    5135. 

  5135. 

  5136. static GLboolean _glewInit_GL_ATI_element_array (GLEW_CONTEXT_ARG_DEF_INIT)
    5137. 

  5137. {
    5138. 

  5138.   GLboolean r = GL_FALSE;
    5139. 

  5139. 

  5140.   r = ((glDrawElementArrayATI = (PFNGLDRAWELEMENTARRAYATIPROC)glewGetProcAddress((const GLubyte*)"glDrawElementArrayATI")) == NULL) || r;
    5141. 

  5141.   r = ((glDrawRangeElementArrayATI = (PFNGLDRAWRANGEELEMENTARRAYATIPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementArrayATI")) == NULL) || r;
    5142. 

  5142.   r = ((glElementPointerATI = (PFNGLELEMENTPOINTERATIPROC)glewGetProcAddress((const GLubyte*)"glElementPointerATI")) == NULL) || r;
    5143. 

  5143. 

  5144.   return r;
    5145. 

  5145. }
    5146. 

  5146. 

  5147. #endif /* GL_ATI_element_array */
    5148. 

  5148. 

  5149. #ifdef GL_ATI_envmap_bumpmap
    5150. 

  5150. 

  5151. static GLboolean _glewInit_GL_ATI_envmap_bumpmap (GLEW_CONTEXT_ARG_DEF_INIT)
    5152. 

  5152. {
    5153. 

  5153.   GLboolean r = GL_FALSE;
    5154. 

  5154. 

  5155.   r = ((glGetTexBumpParameterfvATI = (PFNGLGETTEXBUMPPARAMETERFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetTexBumpParameterfvATI")) == NULL) || r;
    5156. 

  5156.   r = ((glGetTexBumpParameterivATI = (PFNGLGETTEXBUMPPARAMETERIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetTexBumpParameterivATI")) == NULL) || r;
    5157. 

  5157.   r = ((glTexBumpParameterfvATI = (PFNGLTEXBUMPPARAMETERFVATIPROC)glewGetProcAddress((const GLubyte*)"glTexBumpParameterfvATI")) == NULL) || r;
    5158. 

  5158.   r = ((glTexBumpParameterivATI = (PFNGLTEXBUMPPARAMETERIVATIPROC)glewGetProcAddress((const GLubyte*)"glTexBumpParameterivATI")) == NULL) || r;
    5159. 

  5159. 

  5160.   return r;
    5161. 

  5161. }
    5162. 

  5162. 

  5163. #endif /* GL_ATI_envmap_bumpmap */
    5164. 

  5164. 

  5165. #ifdef GL_ATI_fragment_shader
    5166. 

  5166. 

  5167. static GLboolean _glewInit_GL_ATI_fragment_shader (GLEW_CONTEXT_ARG_DEF_INIT)
    5168. 

  5168. {
    5169. 

  5169.   GLboolean r = GL_FALSE;
    5170. 

  5170. 

  5171.   r = ((glAlphaFragmentOp1ATI = (PFNGLALPHAFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp1ATI")) == NULL) || r;
    5172. 

  5172.   r = ((glAlphaFragmentOp2ATI = (PFNGLALPHAFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp2ATI")) == NULL) || r;
    5173. 

  5173.   r = ((glAlphaFragmentOp3ATI = (PFNGLALPHAFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp3ATI")) == NULL) || r;
    5174. 

  5174.   r = ((glBeginFragmentShaderATI = (PFNGLBEGINFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBeginFragmentShaderATI")) == NULL) || r;
    5175. 

  5175.   r = ((glBindFragmentShaderATI = (PFNGLBINDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBindFragmentShaderATI")) == NULL) || r;
    5176. 

  5176.   r = ((glColorFragmentOp1ATI = (PFNGLCOLORFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp1ATI")) == NULL) || r;
    5177. 

  5177.   r = ((glColorFragmentOp2ATI = (PFNGLCOLORFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp2ATI")) == NULL) || r;
    5178. 

  5178.   r = ((glColorFragmentOp3ATI = (PFNGLCOLORFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp3ATI")) == NULL) || r;
    5179. 

  5179.   r = ((glDeleteFragmentShaderATI = (PFNGLDELETEFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glDeleteFragmentShaderATI")) == NULL) || r;
    5180. 

  5180.   r = ((glEndFragmentShaderATI = (PFNGLENDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glEndFragmentShaderATI")) == NULL) || r;
    5181. 

  5181.   r = ((glGenFragmentShadersATI = (PFNGLGENFRAGMENTSHADERSATIPROC)glewGetProcAddress((const GLubyte*)"glGenFragmentShadersATI")) == NULL) || r;
    5182. 

  5182.   r = ((glPassTexCoordATI = (PFNGLPASSTEXCOORDATIPROC)glewGetProcAddress((const GLubyte*)"glPassTexCoordATI")) == NULL) || r;
    5183. 

  5183.   r = ((glSampleMapATI = (PFNGLSAMPLEMAPATIPROC)glewGetProcAddress((const GLubyte*)"glSampleMapATI")) == NULL) || r;
    5184. 

  5184.   r = ((glSetFragmentShaderConstantATI = (PFNGLSETFRAGMENTSHADERCONSTANTATIPROC)glewGetProcAddress((const GLubyte*)"glSetFragmentShaderConstantATI")) == NULL) || r;
    5185. 

  5185. 

  5186.   return r;
    5187. 

  5187. }
    5188. 

  5188. 

  5189. #endif /* GL_ATI_fragment_shader */
    5190. 

  5190. 

  5191. #ifdef GL_ATI_map_object_buffer
    5192. 

  5192. 

  5193. static GLboolean _glewInit_GL_ATI_map_object_buffer (GLEW_CONTEXT_ARG_DEF_INIT)
    5194. 

  5194. {
    5195. 

  5195.   GLboolean r = GL_FALSE;
    5196. 

  5196. 

  5197.   r = ((glMapObjectBufferATI = (PFNGLMAPOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glMapObjectBufferATI")) == NULL) || r;
    5198. 

  5198.   r = ((glUnmapObjectBufferATI = (PFNGLUNMAPOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glUnmapObjectBufferATI")) == NULL) || r;
    5199. 

  5199. 

  5200.   return r;
    5201. 

  5201. }
    5202. 

  5202. 

  5203. #endif /* GL_ATI_map_object_buffer */
    5204. 

  5204. 

  5205. #ifdef GL_ATI_meminfo
    5206. 

  5206. 

  5207. #endif /* GL_ATI_meminfo */
    5208. 

  5208. 

  5209. #ifdef GL_ATI_pn_triangles
    5210. 

  5210. 

  5211. static GLboolean _glewInit_GL_ATI_pn_triangles (GLEW_CONTEXT_ARG_DEF_INIT)
    5212. 

  5212. {
    5213. 

  5213.   GLboolean r = GL_FALSE;
    5214. 

  5214. 

  5215.   r = ((glPNTrianglesfATI = (PFNGLPNTRIANGLESFATIPROC)glewGetProcAddress((const GLubyte*)"glPNTrianglesfATI")) == NULL) || r;
    5216. 

  5216.   r = ((glPNTrianglesiATI = (PFNGLPNTRIANGLESIATIPROC)glewGetProcAddress((const GLubyte*)"glPNTrianglesiATI")) == NULL) || r;
    5217. 

  5217. 

  5218.   return r;
    5219. 

  5219. }
    5220. 

  5220. 

  5221. #endif /* GL_ATI_pn_triangles */
    5222. 

  5222. 

  5223. #ifdef GL_ATI_separate_stencil
    5224. 

  5224. 

  5225. static GLboolean _glewInit_GL_ATI_separate_stencil (GLEW_CONTEXT_ARG_DEF_INIT)
    5226. 

  5226. {
    5227. 

  5227.   GLboolean r = GL_FALSE;
    5228. 

  5228. 

  5229.   r = ((glStencilFuncSeparateATI = (PFNGLSTENCILFUNCSEPARATEATIPROC)glewGetProcAddress((const GLubyte*)"glStencilFuncSeparateATI")) == NULL) || r;
    5230. 

  5230.   r = ((glStencilOpSeparateATI = (PFNGLSTENCILOPSEPARATEATIPROC)glewGetProcAddress((const GLubyte*)"glStencilOpSeparateATI")) == NULL) || r;
    5231. 

  5231. 

  5232.   return r;
    5233. 

  5233. }
    5234. 

  5234. 

  5235. #endif /* GL_ATI_separate_stencil */
    5236. 

  5236. 

  5237. #ifdef GL_ATI_shader_texture_lod
    5238. 

  5238. 

  5239. #endif /* GL_ATI_shader_texture_lod */
    5240. 

  5240. 

  5241. #ifdef GL_ATI_text_fragment_shader
    5242. 

  5242. 

  5243. #endif /* GL_ATI_text_fragment_shader */
    5244. 

  5244. 

  5245. #ifdef GL_ATI_texture_compression_3dc
    5246. 

  5246. 

  5247. #endif /* GL_ATI_texture_compression_3dc */
    5248. 

  5248. 

  5249. #ifdef GL_ATI_texture_env_combine3
    5250. 

  5250. 

  5251. #endif /* GL_ATI_texture_env_combine3 */
    5252. 

  5252. 

  5253. #ifdef GL_ATI_texture_float
    5254. 

  5254. 

  5255. #endif /* GL_ATI_texture_float */
    5256. 

  5256. 

  5257. #ifdef GL_ATI_texture_mirror_once
    5258. 

  5258. 

  5259. #endif /* GL_ATI_texture_mirror_once */
    5260. 

  5260. 

  5261. #ifdef GL_ATI_vertex_array_object
    5262. 

  5262. 

  5263. static GLboolean _glewInit_GL_ATI_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT)
    5264. 

  5264. {
    5265. 

  5265.   GLboolean r = GL_FALSE;
    5266. 

  5266. 

  5267.   r = ((glArrayObjectATI = (PFNGLARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glArrayObjectATI")) == NULL) || r;
    5268. 

  5268.   r = ((glFreeObjectBufferATI = (PFNGLFREEOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glFreeObjectBufferATI")) == NULL) || r;
    5269. 

  5269.   r = ((glGetArrayObjectfvATI = (PFNGLGETARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetArrayObjectfvATI")) == NULL) || r;
    5270. 

  5270.   r = ((glGetArrayObjectivATI = (PFNGLGETARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetArrayObjectivATI")) == NULL) || r;
    5271. 

  5271.   r = ((glGetObjectBufferfvATI = (PFNGLGETOBJECTBUFFERFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetObjectBufferfvATI")) == NULL) || r;
    5272. 

  5272.   r = ((glGetObjectBufferivATI = (PFNGLGETOBJECTBUFFERIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetObjectBufferivATI")) == NULL) || r;
    5273. 

  5273.   r = ((glGetVariantArrayObjectfvATI = (PFNGLGETVARIANTARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVariantArrayObjectfvATI")) == NULL) || r;
    5274. 

  5274.   r = ((glGetVariantArrayObjectivATI = (PFNGLGETVARIANTARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVariantArrayObjectivATI")) == NULL) || r;
    5275. 

  5275.   r = ((glIsObjectBufferATI = (PFNGLISOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glIsObjectBufferATI")) == NULL) || r;
    5276. 

  5276.   r = ((glNewObjectBufferATI = (PFNGLNEWOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glNewObjectBufferATI")) == NULL) || r;
    5277. 

  5277.   r = ((glUpdateObjectBufferATI = (PFNGLUPDATEOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glUpdateObjectBufferATI")) == NULL) || r;
    5278. 

  5278.   r = ((glVariantArrayObjectATI = (PFNGLVARIANTARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glVariantArrayObjectATI")) == NULL) || r;
    5279. 

  5279. 

  5280.   return r;
    5281. 

  5281. }
    5282. 

  5282. 

  5283. #endif /* GL_ATI_vertex_array_object */
    5284. 

  5284. 

  5285. #ifdef GL_ATI_vertex_attrib_array_object
    5286. 

  5286. 

  5287. static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object (GLEW_CONTEXT_ARG_DEF_INIT)
    5288. 

  5288. {
    5289. 

  5289.   GLboolean r = GL_FALSE;
    5290. 

  5290. 

  5291.   r = ((glGetVertexAttribArrayObjectfvATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribArrayObjectfvATI")) == NULL) || r;
    5292. 

  5292.   r = ((glGetVertexAttribArrayObjectivATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribArrayObjectivATI")) == NULL) || r;
    5293. 

  5293.   r = ((glVertexAttribArrayObjectATI = (PFNGLVERTEXATTRIBARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribArrayObjectATI")) == NULL) || r;
    5294. 

  5294. 

  5295.   return r;
    5296. 

  5296. }
    5297. 

  5297. 

  5298. #endif /* GL_ATI_vertex_attrib_array_object */
    5299. 

  5299. 

  5300. #ifdef GL_ATI_vertex_streams
    5301. 

  5301. 

  5302. static GLboolean _glewInit_GL_ATI_vertex_streams (GLEW_CONTEXT_ARG_DEF_INIT)
    5303. 

  5303. {
    5304. 

  5304.   GLboolean r = GL_FALSE;
    5305. 

  5305. 

  5306.   r = ((glClientActiveVertexStreamATI = (PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC)glewGetProcAddress((const GLubyte*)"glClientActiveVertexStreamATI")) == NULL) || r;
    5307. 

  5307.   r = ((glNormalStream3bATI = (PFNGLNORMALSTREAM3BATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3bATI")) == NULL) || r;
    5308. 

  5308.   r = ((glNormalStream3bvATI = (PFNGLNORMALSTREAM3BVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3bvATI")) == NULL) || r;
    5309. 

  5309.   r = ((glNormalStream3dATI = (PFNGLNORMALSTREAM3DATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3dATI")) == NULL) || r;
    5310. 

  5310.   r = ((glNormalStream3dvATI = (PFNGLNORMALSTREAM3DVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3dvATI")) == NULL) || r;
    5311. 

  5311.   r = ((glNormalStream3fATI = (PFNGLNORMALSTREAM3FATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3fATI")) == NULL) || r;
    5312. 

  5312.   r = ((glNormalStream3fvATI = (PFNGLNORMALSTREAM3FVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3fvATI")) == NULL) || r;
    5313. 

  5313.   r = ((glNormalStream3iATI = (PFNGLNORMALSTREAM3IATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3iATI")) == NULL) || r;
    5314. 

  5314.   r = ((glNormalStream3ivATI = (PFNGLNORMALSTREAM3IVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3ivATI")) == NULL) || r;
    5315. 

  5315.   r = ((glNormalStream3sATI = (PFNGLNORMALSTREAM3SATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3sATI")) == NULL) || r;
    5316. 

  5316.   r = ((glNormalStream3svATI = (PFNGLNORMALSTREAM3SVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3svATI")) == NULL) || r;
    5317. 

  5317.   r = ((glVertexBlendEnvfATI = (PFNGLVERTEXBLENDENVFATIPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendEnvfATI")) == NULL) || r;
    5318. 

  5318.   r = ((glVertexBlendEnviATI = (PFNGLVERTEXBLENDENVIATIPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendEnviATI")) == NULL) || r;
    5319. 

  5319.   r = ((glVertexStream2dATI = (PFNGLVERTEXSTREAM2DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2dATI")) == NULL) || r;
    5320. 

  5320.   r = ((glVertexStream2dvATI = (PFNGLVERTEXSTREAM2DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2dvATI")) == NULL) || r;
    5321. 

  5321.   r = ((glVertexStream2fATI = (PFNGLVERTEXSTREAM2FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2fATI")) == NULL) || r;
    5322. 

  5322.   r = ((glVertexStream2fvATI = (PFNGLVERTEXSTREAM2FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2fvATI")) == NULL) || r;
    5323. 

  5323.   r = ((glVertexStream2iATI = (PFNGLVERTEXSTREAM2IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2iATI")) == NULL) || r;
    5324. 

  5324.   r = ((glVertexStream2ivATI = (PFNGLVERTEXSTREAM2IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2ivATI")) == NULL) || r;
    5325. 

  5325.   r = ((glVertexStream2sATI = (PFNGLVERTEXSTREAM2SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2sATI")) == NULL) || r;
    5326. 

  5326.   r = ((glVertexStream2svATI = (PFNGLVERTEXSTREAM2SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2svATI")) == NULL) || r;
    5327. 

  5327.   r = ((glVertexStream3dATI = (PFNGLVERTEXSTREAM3DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3dATI")) == NULL) || r;
    5328. 

  5328.   r = ((glVertexStream3dvATI = (PFNGLVERTEXSTREAM3DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3dvATI")) == NULL) || r;
    5329. 

  5329.   r = ((glVertexStream3fATI = (PFNGLVERTEXSTREAM3FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3fATI")) == NULL) || r;
    5330. 

  5330.   r = ((glVertexStream3fvATI = (PFNGLVERTEXSTREAM3FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3fvATI")) == NULL) || r;
    5331. 

  5331.   r = ((glVertexStream3iATI = (PFNGLVERTEXSTREAM3IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3iATI")) == NULL) || r;
    5332. 

  5332.   r = ((glVertexStream3ivATI = (PFNGLVERTEXSTREAM3IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3ivATI")) == NULL) || r;
    5333. 

  5333.   r = ((glVertexStream3sATI = (PFNGLVERTEXSTREAM3SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3sATI")) == NULL) || r;
    5334. 

  5334.   r = ((glVertexStream3svATI = (PFNGLVERTEXSTREAM3SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3svATI")) == NULL) || r;
    5335. 

  5335.   r = ((glVertexStream4dATI = (PFNGLVERTEXSTREAM4DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4dATI")) == NULL) || r;
    5336. 

  5336.   r = ((glVertexStream4dvATI = (PFNGLVERTEXSTREAM4DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4dvATI")) == NULL) || r;
    5337. 

  5337.   r = ((glVertexStream4fATI = (PFNGLVERTEXSTREAM4FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4fATI")) == NULL) || r;
    5338. 

  5338.   r = ((glVertexStream4fvATI = (PFNGLVERTEXSTREAM4FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4fvATI")) == NULL) || r;
    5339. 

  5339.   r = ((glVertexStream4iATI = (PFNGLVERTEXSTREAM4IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4iATI")) == NULL) || r;
    5340. 

  5340.   r = ((glVertexStream4ivATI = (PFNGLVERTEXSTREAM4IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4ivATI")) == NULL) || r;
    5341. 

  5341.   r = ((glVertexStream4sATI = (PFNGLVERTEXSTREAM4SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4sATI")) == NULL) || r;
    5342. 

  5342.   r = ((glVertexStream4svATI = (PFNGLVERTEXSTREAM4SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4svATI")) == NULL) || r;
    5343. 

  5343. 

  5344.   return r;
    5345. 

  5345. }
    5346. 

  5346. 

  5347. #endif /* GL_ATI_vertex_streams */
    5348. 

  5348. 

  5349. #ifdef GL_EXT_422_pixels
    5350. 

  5350. 

  5351. #endif /* GL_EXT_422_pixels */
    5352. 

  5352. 

  5353. #ifdef GL_EXT_Cg_shader
    5354. 

  5354. 

  5355. #endif /* GL_EXT_Cg_shader */
    5356. 

  5356. 

  5357. #ifdef GL_EXT_abgr
    5358. 

  5358. 

  5359. #endif /* GL_EXT_abgr */
    5360. 

  5360. 

  5361. #ifdef GL_EXT_bgra
    5362. 

  5362. 

  5363. #endif /* GL_EXT_bgra */
    5364. 

  5364. 

  5365. #ifdef GL_EXT_bindable_uniform
    5366. 

  5366. 

  5367. static GLboolean _glewInit_GL_EXT_bindable_uniform (GLEW_CONTEXT_ARG_DEF_INIT)
    5368. 

  5368. {
    5369. 

  5369.   GLboolean r = GL_FALSE;
    5370. 

  5370. 

  5371.   r = ((glGetUniformBufferSizeEXT = (PFNGLGETUNIFORMBUFFERSIZEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformBufferSizeEXT")) == NULL) || r;
    5372. 

  5372.   r = ((glGetUniformOffsetEXT = (PFNGLGETUNIFORMOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformOffsetEXT")) == NULL) || r;
    5373. 

  5373.   r = ((glUniformBufferEXT = (PFNGLUNIFORMBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glUniformBufferEXT")) == NULL) || r;
    5374. 

  5374. 

  5375.   return r;
    5376. 

  5376. }
    5377. 

  5377. 

  5378. #endif /* GL_EXT_bindable_uniform */
    5379. 

  5379. 

  5380. #ifdef GL_EXT_blend_color
    5381. 

  5381. 

  5382. static GLboolean _glewInit_GL_EXT_blend_color (GLEW_CONTEXT_ARG_DEF_INIT)
    5383. 

  5383. {
    5384. 

  5384.   GLboolean r = GL_FALSE;
    5385. 

  5385. 

  5386.   r = ((glBlendColorEXT = (PFNGLBLENDCOLOREXTPROC)glewGetProcAddress((const GLubyte*)"glBlendColorEXT")) == NULL) || r;
    5387. 

  5387. 

  5388.   return r;
    5389. 

  5389. }
    5390. 

  5390. 

  5391. #endif /* GL_EXT_blend_color */
    5392. 

  5392. 

  5393. #ifdef GL_EXT_blend_equation_separate
    5394. 

  5394. 

  5395. static GLboolean _glewInit_GL_EXT_blend_equation_separate (GLEW_CONTEXT_ARG_DEF_INIT)
    5396. 

  5396. {
    5397. 

  5397.   GLboolean r = GL_FALSE;
    5398. 

  5398. 

  5399.   r = ((glBlendEquationSeparateEXT = (PFNGLBLENDEQUATIONSEPARATEEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateEXT")) == NULL) || r;
    5400. 

  5400. 

  5401.   return r;
    5402. 

  5402. }
    5403. 

  5403. 

  5404. #endif /* GL_EXT_blend_equation_separate */
    5405. 

  5405. 

  5406. #ifdef GL_EXT_blend_func_separate
    5407. 

  5407. 

  5408. static GLboolean _glewInit_GL_EXT_blend_func_separate (GLEW_CONTEXT_ARG_DEF_INIT)
    5409. 

  5409. {
    5410. 

  5410.   GLboolean r = GL_FALSE;
    5411. 

  5411. 

  5412.   r = ((glBlendFuncSeparateEXT = (PFNGLBLENDFUNCSEPARATEEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateEXT")) == NULL) || r;
    5413. 

  5413. 

  5414.   return r;
    5415. 

  5415. }
    5416. 

  5416. 

  5417. #endif /* GL_EXT_blend_func_separate */
    5418. 

  5418. 

  5419. #ifdef GL_EXT_blend_logic_op
    5420. 

  5420. 

  5421. #endif /* GL_EXT_blend_logic_op */
    5422. 

  5422. 

  5423. #ifdef GL_EXT_blend_minmax
    5424. 

  5424. 

  5425. static GLboolean _glewInit_GL_EXT_blend_minmax (GLEW_CONTEXT_ARG_DEF_INIT)
    5426. 

  5426. {
    5427. 

  5427.   GLboolean r = GL_FALSE;
    5428. 

  5428. 

  5429.   r = ((glBlendEquationEXT = (PFNGLBLENDEQUATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationEXT")) == NULL) || r;
    5430. 

  5430. 

  5431.   return r;
    5432. 

  5432. }
    5433. 

  5433. 

  5434. #endif /* GL_EXT_blend_minmax */
    5435. 

  5435. 

  5436. #ifdef GL_EXT_blend_subtract
    5437. 

  5437. 

  5438. #endif /* GL_EXT_blend_subtract */
    5439. 

  5439. 

  5440. #ifdef GL_EXT_clip_volume_hint
    5441. 

  5441. 

  5442. #endif /* GL_EXT_clip_volume_hint */
    5443. 

  5443. 

  5444. #ifdef GL_EXT_cmyka
    5445. 

  5445. 

  5446. #endif /* GL_EXT_cmyka */
    5447. 

  5447. 

  5448. #ifdef GL_EXT_color_subtable
    5449. 

  5449. 

  5450. static GLboolean _glewInit_GL_EXT_color_subtable (GLEW_CONTEXT_ARG_DEF_INIT)
    5451. 

  5451. {
    5452. 

  5452.   GLboolean r = GL_FALSE;
    5453. 

  5453. 

  5454.   r = ((glColorSubTableEXT = (PFNGLCOLORSUBTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glColorSubTableEXT")) == NULL) || r;
    5455. 

  5455.   r = ((glCopyColorSubTableEXT = (PFNGLCOPYCOLORSUBTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyColorSubTableEXT")) == NULL) || r;
    5456. 

  5456. 

  5457.   return r;
    5458. 

  5458. }
    5459. 

  5459. 

  5460. #endif /* GL_EXT_color_subtable */
    5461. 

  5461. 

  5462. #ifdef GL_EXT_compiled_vertex_array
    5463. 

  5463. 

  5464. static GLboolean _glewInit_GL_EXT_compiled_vertex_array (GLEW_CONTEXT_ARG_DEF_INIT)
    5465. 

  5465. {
    5466. 

  5466.   GLboolean r = GL_FALSE;
    5467. 

  5467. 

  5468.   r = ((glLockArraysEXT = (PFNGLLOCKARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glLockArraysEXT")) == NULL) || r;
    5469. 

  5469.   r = ((glUnlockArraysEXT = (PFNGLUNLOCKARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glUnlockArraysEXT")) == NULL) || r;
    5470. 

  5470. 

  5471.   return r;
    5472. 

  5472. }
    5473. 

  5473. 

  5474. #endif /* GL_EXT_compiled_vertex_array */
    5475. 

  5475. 

  5476. #ifdef GL_EXT_convolution
    5477. 

  5477. 

  5478. static GLboolean _glewInit_GL_EXT_convolution (GLEW_CONTEXT_ARG_DEF_INIT)
    5479. 

  5479. {
    5480. 

  5480.   GLboolean r = GL_FALSE;
    5481. 

  5481. 

  5482.   r = ((glConvolutionFilter1DEXT = (PFNGLCONVOLUTIONFILTER1DEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter1DEXT")) == NULL) || r;
    5483. 

  5483.   r = ((glConvolutionFilter2DEXT = (PFNGLCONVOLUTIONFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter2DEXT")) == NULL) || r;
    5484. 

  5484.   r = ((glConvolutionParameterfEXT = (PFNGLCONVOLUTIONPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfEXT")) == NULL) || r;
    5485. 

  5485.   r = ((glConvolutionParameterfvEXT = (PFNGLCONVOLUTIONPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfvEXT")) == NULL) || r;
    5486. 

  5486.   r = ((glConvolutionParameteriEXT = (PFNGLCONVOLUTIONPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteriEXT")) == NULL) || r;
    5487. 

  5487.   r = ((glConvolutionParameterivEXT = (PFNGLCONVOLUTIONPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterivEXT")) == NULL) || r;
    5488. 

  5488.   r = ((glCopyConvolutionFilter1DEXT = (PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter1DEXT")) == NULL) || r;
    5489. 

  5489.   r = ((glCopyConvolutionFilter2DEXT = (PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter2DEXT")) == NULL) || r;
    5490. 

  5490.   r = ((glGetConvolutionFilterEXT = (PFNGLGETCONVOLUTIONFILTEREXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionFilterEXT")) == NULL) || r;
    5491. 

  5491.   r = ((glGetConvolutionParameterfvEXT = (PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterfvEXT")) == NULL) || r;
    5492. 

  5492.   r = ((glGetConvolutionParameterivEXT = (PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterivEXT")) == NULL) || r;
    5493. 

  5493.   r = ((glGetSeparableFilterEXT = (PFNGLGETSEPARABLEFILTEREXTPROC)glewGetProcAddress((const GLubyte*)"glGetSeparableFilterEXT")) == NULL) || r;
    5494. 

  5494.   r = ((glSeparableFilter2DEXT = (PFNGLSEPARABLEFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glSeparableFilter2DEXT")) == NULL) || r;
    5495. 

  5495. 

  5496.   return r;
    5497. 

  5497. }
    5498. 

  5498. 

  5499. #endif /* GL_EXT_convolution */
    5500. 

  5500. 

  5501. #ifdef GL_EXT_coordinate_frame
    5502. 

  5502. 

  5503. static GLboolean _glewInit_GL_EXT_coordinate_frame (GLEW_CONTEXT_ARG_DEF_INIT)
    5504. 

  5504. {
    5505. 

  5505.   GLboolean r = GL_FALSE;
    5506. 

  5506. 

  5507.   r = ((glBinormalPointerEXT = (PFNGLBINORMALPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glBinormalPointerEXT")) == NULL) || r;
    5508. 

  5508.   r = ((glTangentPointerEXT = (PFNGLTANGENTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glTangentPointerEXT")) == NULL) || r;
    5509. 

  5509. 

  5510.   return r;
    5511. 

  5511. }
    5512. 

  5512. 

  5513. #endif /* GL_EXT_coordinate_frame */
    5514. 

  5514. 

  5515. #ifdef GL_EXT_copy_texture
    5516. 

  5516. 

  5517. static GLboolean _glewInit_GL_EXT_copy_texture (GLEW_CONTEXT_ARG_DEF_INIT)
    5518. 

  5518. {
    5519. 

  5519.   GLboolean r = GL_FALSE;
    5520. 

  5520. 

  5521.   r = ((glCopyTexImage1DEXT = (PFNGLCOPYTEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexImage1DEXT")) == NULL) || r;
    5522. 

  5522.   r = ((glCopyTexImage2DEXT = (PFNGLCOPYTEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexImage2DEXT")) == NULL) || r;
    5523. 

  5523.   r = ((glCopyTexSubImage1DEXT = (PFNGLCOPYTEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage1DEXT")) == NULL) || r;
    5524. 

  5524.   r = ((glCopyTexSubImage2DEXT = (PFNGLCOPYTEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage2DEXT")) == NULL) || r;
    5525. 

  5525.   r = ((glCopyTexSubImage3DEXT = (PFNGLCOPYTEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3DEXT")) == NULL) || r;
    5526. 

  5526. 

  5527.   return r;
    5528. 

  5528. }
    5529. 

  5529. 

  5530. #endif /* GL_EXT_copy_texture */
    5531. 

  5531. 

  5532. #ifdef GL_EXT_cull_vertex
    5533. 

  5533. 

  5534. static GLboolean _glewInit_GL_EXT_cull_vertex (GLEW_CONTEXT_ARG_DEF_INIT)
    5535. 

  5535. {
    5536. 

  5536.   GLboolean r = GL_FALSE;
    5537. 

  5537. 

  5538.   r = ((glCullParameterdvEXT = (PFNGLCULLPARAMETERDVEXTPROC)glewGetProcAddress((const GLubyte*)"glCullParameterdvEXT")) == NULL) || r;
    5539. 

  5539.   r = ((glCullParameterfvEXT = (PFNGLCULLPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glCullParameterfvEXT")) == NULL) || r;
    5540. 

  5540. 

  5541.   return r;
    5542. 

  5542. }
    5543. 

  5543. 

  5544. #endif /* GL_EXT_cull_vertex */
    5545. 

  5545. 

  5546. #ifdef GL_EXT_depth_bounds_test
    5547. 

  5547. 

  5548. static GLboolean _glewInit_GL_EXT_depth_bounds_test (GLEW_CONTEXT_ARG_DEF_INIT)
    5549. 

  5549. {
    5550. 

  5550.   GLboolean r = GL_FALSE;
    5551. 

  5551. 

  5552.   r = ((glDepthBoundsEXT = (PFNGLDEPTHBOUNDSEXTPROC)glewGetProcAddress((const GLubyte*)"glDepthBoundsEXT")) == NULL) || r;
    5553. 

  5553. 

  5554.   return r;
    5555. 

  5555. }
    5556. 

  5556. 

  5557. #endif /* GL_EXT_depth_bounds_test */
    5558. 

  5558. 

  5559. #ifdef GL_EXT_direct_state_access
    5560. 

  5560. 

  5561. static GLboolean _glewInit_GL_EXT_direct_state_access (GLEW_CONTEXT_ARG_DEF_INIT)
    5562. 

  5562. {
    5563. 

  5563.   GLboolean r = GL_FALSE;
    5564. 

  5564. 

  5565.   r = ((glBindMultiTextureEXT = (PFNGLBINDMULTITEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindMultiTextureEXT")) == NULL) || r;
    5566. 

  5566.   r = ((glCheckNamedFramebufferStatusEXT = (PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glCheckNamedFramebufferStatusEXT")) == NULL) || r;
    5567. 

  5567.   r = ((glClientAttribDefaultEXT = (PFNGLCLIENTATTRIBDEFAULTEXTPROC)glewGetProcAddress((const GLubyte*)"glClientAttribDefaultEXT")) == NULL) || r;
    5568. 

  5568.   r = ((glCompressedMultiTexImage1DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage1DEXT")) == NULL) || r;
    5569. 

  5569.   r = ((glCompressedMultiTexImage2DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage2DEXT")) == NULL) || r;
    5570. 

  5570.   r = ((glCompressedMultiTexImage3DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage3DEXT")) == NULL) || r;
    5571. 

  5571.   r = ((glCompressedMultiTexSubImage1DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage1DEXT")) == NULL) || r;
    5572. 

  5572.   r = ((glCompressedMultiTexSubImage2DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage2DEXT")) == NULL) || r;
    5573. 

  5573.   r = ((glCompressedMultiTexSubImage3DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage3DEXT")) == NULL) || r;
    5574. 

  5574.   r = ((glCompressedTextureImage1DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage1DEXT")) == NULL) || r;
    5575. 

  5575.   r = ((glCompressedTextureImage2DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage2DEXT")) == NULL) || r;
    5576. 

  5576.   r = ((glCompressedTextureImage3DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage3DEXT")) == NULL) || r;
    5577. 

  5577.   r = ((glCompressedTextureSubImage1DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage1DEXT")) == NULL) || r;
    5578. 

  5578.   r = ((glCompressedTextureSubImage2DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage2DEXT")) == NULL) || r;
    5579. 

  5579.   r = ((glCompressedTextureSubImage3DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage3DEXT")) == NULL) || r;
    5580. 

  5580.   r = ((glCopyMultiTexImage1DEXT = (PFNGLCOPYMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexImage1DEXT")) == NULL) || r;
    5581. 

  5581.   r = ((glCopyMultiTexImage2DEXT = (PFNGLCOPYMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexImage2DEXT")) == NULL) || r;
    5582. 

  5582.   r = ((glCopyMultiTexSubImage1DEXT = (PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage1DEXT")) == NULL) || r;
    5583. 

  5583.   r = ((glCopyMultiTexSubImage2DEXT = (PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage2DEXT")) == NULL) || r;
    5584. 

  5584.   r = ((glCopyMultiTexSubImage3DEXT = (PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage3DEXT")) == NULL) || r;
    5585. 

  5585.   r = ((glCopyTextureImage1DEXT = (PFNGLCOPYTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureImage1DEXT")) == NULL) || r;
    5586. 

  5586.   r = ((glCopyTextureImage2DEXT = (PFNGLCOPYTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureImage2DEXT")) == NULL) || r;
    5587. 

  5587.   r = ((glCopyTextureSubImage1DEXT = (PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage1DEXT")) == NULL) || r;
    5588. 

  5588.   r = ((glCopyTextureSubImage2DEXT = (PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage2DEXT")) == NULL) || r;
    5589. 

  5589.   r = ((glCopyTextureSubImage3DEXT = (PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage3DEXT")) == NULL) || r;
    5590. 

  5590.   r = ((glDisableClientStateIndexedEXT = (PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableClientStateIndexedEXT")) == NULL) || r;
    5591. 

  5591.   r = ((glDisableClientStateiEXT = (PFNGLDISABLECLIENTSTATEIEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableClientStateiEXT")) == NULL) || r;
    5592. 

  5592.   r = ((glDisableVertexArrayAttribEXT = (PFNGLDISABLEVERTEXARRAYATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexArrayAttribEXT")) == NULL) || r;
    5593. 

  5593.   r = ((glDisableVertexArrayEXT = (PFNGLDISABLEVERTEXARRAYEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexArrayEXT")) == NULL) || r;
    5594. 

  5594.   r = ((glEnableClientStateIndexedEXT = (PFNGLENABLECLIENTSTATEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableClientStateIndexedEXT")) == NULL) || r;
    5595. 

  5595.   r = ((glEnableClientStateiEXT = (PFNGLENABLECLIENTSTATEIEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableClientStateiEXT")) == NULL) || r;
    5596. 

  5596.   r = ((glEnableVertexArrayAttribEXT = (PFNGLENABLEVERTEXARRAYATTRIBEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexArrayAttribEXT")) == NULL) || r;
    5597. 

  5597.   r = ((glEnableVertexArrayEXT = (PFNGLENABLEVERTEXARRAYEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexArrayEXT")) == NULL) || r;
    5598. 

  5598.   r = ((glFlushMappedNamedBufferRangeEXT = (PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedNamedBufferRangeEXT")) == NULL) || r;
    5599. 

  5599.   r = ((glFramebufferDrawBufferEXT = (PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferDrawBufferEXT")) == NULL) || r;
    5600. 

  5600.   r = ((glFramebufferDrawBuffersEXT = (PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferDrawBuffersEXT")) == NULL) || r;
    5601. 

  5601.   r = ((glFramebufferReadBufferEXT = (PFNGLFRAMEBUFFERREADBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferReadBufferEXT")) == NULL) || r;
    5602. 

  5602.   r = ((glGenerateMultiTexMipmapEXT = (PFNGLGENERATEMULTITEXMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateMultiTexMipmapEXT")) == NULL) || r;
    5603. 

  5603.   r = ((glGenerateTextureMipmapEXT = (PFNGLGENERATETEXTUREMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateTextureMipmapEXT")) == NULL) || r;
    5604. 

  5604.   r = ((glGetCompressedMultiTexImageEXT = (PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedMultiTexImageEXT")) == NULL) || r;
    5605. 

  5605.   r = ((glGetCompressedTextureImageEXT = (PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTextureImageEXT")) == NULL) || r;
    5606. 

  5606.   r = ((glGetDoubleIndexedvEXT = (PFNGLGETDOUBLEINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetDoubleIndexedvEXT")) == NULL) || r;
    5607. 

  5607.   r = ((glGetDoublei_vEXT = (PFNGLGETDOUBLEI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetDoublei_vEXT")) == NULL) || r;
    5608. 

  5608.   r = ((glGetFloatIndexedvEXT = (PFNGLGETFLOATINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFloatIndexedvEXT")) == NULL) || r;
    5609. 

  5609.   r = ((glGetFloati_vEXT = (PFNGLGETFLOATI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFloati_vEXT")) == NULL) || r;
    5610. 

  5610.   r = ((glGetFramebufferParameterivEXT = (PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferParameterivEXT")) == NULL) || r;
    5611. 

  5611.   r = ((glGetMultiTexEnvfvEXT = (PFNGLGETMULTITEXENVFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexEnvfvEXT")) == NULL) || r;
    5612. 

  5612.   r = ((glGetMultiTexEnvivEXT = (PFNGLGETMULTITEXENVIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexEnvivEXT")) == NULL) || r;
    5613. 

  5613.   r = ((glGetMultiTexGendvEXT = (PFNGLGETMULTITEXGENDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGendvEXT")) == NULL) || r;
    5614. 

  5614.   r = ((glGetMultiTexGenfvEXT = (PFNGLGETMULTITEXGENFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGenfvEXT")) == NULL) || r;
    5615. 

  5615.   r = ((glGetMultiTexGenivEXT = (PFNGLGETMULTITEXGENIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGenivEXT")) == NULL) || r;
    5616. 

  5616.   r = ((glGetMultiTexImageEXT = (PFNGLGETMULTITEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexImageEXT")) == NULL) || r;
    5617. 

  5617.   r = ((glGetMultiTexLevelParameterfvEXT = (PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexLevelParameterfvEXT")) == NULL) || r;
    5618. 

  5618.   r = ((glGetMultiTexLevelParameterivEXT = (PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexLevelParameterivEXT")) == NULL) || r;
    5619. 

  5619.   r = ((glGetMultiTexParameterIivEXT = (PFNGLGETMULTITEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterIivEXT")) == NULL) || r;
    5620. 

  5620.   r = ((glGetMultiTexParameterIuivEXT = (PFNGLGETMULTITEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterIuivEXT")) == NULL) || r;
    5621. 

  5621.   r = ((glGetMultiTexParameterfvEXT = (PFNGLGETMULTITEXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterfvEXT")) == NULL) || r;
    5622. 

  5622.   r = ((glGetMultiTexParameterivEXT = (PFNGLGETMULTITEXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterivEXT")) == NULL) || r;
    5623. 

  5623.   r = ((glGetNamedBufferParameterivEXT = (PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferParameterivEXT")) == NULL) || r;
    5624. 

  5624.   r = ((glGetNamedBufferPointervEXT = (PFNGLGETNAMEDBUFFERPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferPointervEXT")) == NULL) || r;
    5625. 

  5625.   r = ((glGetNamedBufferSubDataEXT = (PFNGLGETNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferSubDataEXT")) == NULL) || r;
    5626. 

  5626.   r = ((glGetNamedFramebufferAttachmentParameterivEXT = (PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedFramebufferAttachmentParameterivEXT")) == NULL) || r;
    5627. 

  5627.   r = ((glGetNamedProgramLocalParameterIivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterIivEXT")) == NULL) || r;
    5628. 

  5628.   r = ((glGetNamedProgramLocalParameterIuivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterIuivEXT")) == NULL) || r;
    5629. 

  5629.   r = ((glGetNamedProgramLocalParameterdvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterdvEXT")) == NULL) || r;
    5630. 

  5630.   r = ((glGetNamedProgramLocalParameterfvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterfvEXT")) == NULL) || r;
    5631. 

  5631.   r = ((glGetNamedProgramStringEXT = (PFNGLGETNAMEDPROGRAMSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramStringEXT")) == NULL) || r;
    5632. 

  5632.   r = ((glGetNamedProgramivEXT = (PFNGLGETNAMEDPROGRAMIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramivEXT")) == NULL) || r;
    5633. 

  5633.   r = ((glGetNamedRenderbufferParameterivEXT = (PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedRenderbufferParameterivEXT")) == NULL) || r;
    5634. 

  5634.   r = ((glGetPointerIndexedvEXT = (PFNGLGETPOINTERINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointerIndexedvEXT")) == NULL) || r;
    5635. 

  5635.   r = ((glGetPointeri_vEXT = (PFNGLGETPOINTERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointeri_vEXT")) == NULL) || r;
    5636. 

  5636.   r = ((glGetTextureImageEXT = (PFNGLGETTEXTUREIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureImageEXT")) == NULL) || r;
    5637. 

  5637.   r = ((glGetTextureLevelParameterfvEXT = (PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterfvEXT")) == NULL) || r;
    5638. 

  5638.   r = ((glGetTextureLevelParameterivEXT = (PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterivEXT")) == NULL) || r;
    5639. 

  5639.   r = ((glGetTextureParameterIivEXT = (PFNGLGETTEXTUREPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIivEXT")) == NULL) || r;
    5640. 

  5640.   r = ((glGetTextureParameterIuivEXT = (PFNGLGETTEXTUREPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIuivEXT")) == NULL) || r;
    5641. 

  5641.   r = ((glGetTextureParameterfvEXT = (PFNGLGETTEXTUREPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterfvEXT")) == NULL) || r;
    5642. 

  5642.   r = ((glGetTextureParameterivEXT = (PFNGLGETTEXTUREPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterivEXT")) == NULL) || r;
    5643. 

  5643.   r = ((glGetVertexArrayIntegeri_vEXT = (PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayIntegeri_vEXT")) == NULL) || r;
    5644. 

  5644.   r = ((glGetVertexArrayIntegervEXT = (PFNGLGETVERTEXARRAYINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayIntegervEXT")) == NULL) || r;
    5645. 

  5645.   r = ((glGetVertexArrayPointeri_vEXT = (PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayPointeri_vEXT")) == NULL) || r;
    5646. 

  5646.   r = ((glGetVertexArrayPointervEXT = (PFNGLGETVERTEXARRAYPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexArrayPointervEXT")) == NULL) || r;
    5647. 

  5647.   r = ((glMapNamedBufferEXT = (PFNGLMAPNAMEDBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBufferEXT")) == NULL) || r;
    5648. 

  5648.   r = ((glMapNamedBufferRangeEXT = (PFNGLMAPNAMEDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBufferRangeEXT")) == NULL) || r;
    5649. 

  5649.   r = ((glMatrixFrustumEXT = (PFNGLMATRIXFRUSTUMEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixFrustumEXT")) == NULL) || r;
    5650. 

  5650.   r = ((glMatrixLoadIdentityEXT = (PFNGLMATRIXLOADIDENTITYEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadIdentityEXT")) == NULL) || r;
    5651. 

  5651.   r = ((glMatrixLoadTransposedEXT = (PFNGLMATRIXLOADTRANSPOSEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadTransposedEXT")) == NULL) || r;
    5652. 

  5652.   r = ((glMatrixLoadTransposefEXT = (PFNGLMATRIXLOADTRANSPOSEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadTransposefEXT")) == NULL) || r;
    5653. 

  5653.   r = ((glMatrixLoaddEXT = (PFNGLMATRIXLOADDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoaddEXT")) == NULL) || r;
    5654. 

  5654.   r = ((glMatrixLoadfEXT = (PFNGLMATRIXLOADFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadfEXT")) == NULL) || r;
    5655. 

  5655.   r = ((glMatrixMultTransposedEXT = (PFNGLMATRIXMULTTRANSPOSEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultTransposedEXT")) == NULL) || r;
    5656. 

  5656.   r = ((glMatrixMultTransposefEXT = (PFNGLMATRIXMULTTRANSPOSEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultTransposefEXT")) == NULL) || r;
    5657. 

  5657.   r = ((glMatrixMultdEXT = (PFNGLMATRIXMULTDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultdEXT")) == NULL) || r;
    5658. 

  5658.   r = ((glMatrixMultfEXT = (PFNGLMATRIXMULTFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultfEXT")) == NULL) || r;
    5659. 

  5659.   r = ((glMatrixOrthoEXT = (PFNGLMATRIXORTHOEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixOrthoEXT")) == NULL) || r;
    5660. 

  5660.   r = ((glMatrixPopEXT = (PFNGLMATRIXPOPEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixPopEXT")) == NULL) || r;
    5661. 

  5661.   r = ((glMatrixPushEXT = (PFNGLMATRIXPUSHEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixPushEXT")) == NULL) || r;
    5662. 

  5662.   r = ((glMatrixRotatedEXT = (PFNGLMATRIXROTATEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixRotatedEXT")) == NULL) || r;
    5663. 

  5663.   r = ((glMatrixRotatefEXT = (PFNGLMATRIXROTATEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixRotatefEXT")) == NULL) || r;
    5664. 

  5664.   r = ((glMatrixScaledEXT = (PFNGLMATRIXSCALEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixScaledEXT")) == NULL) || r;
    5665. 

  5665.   r = ((glMatrixScalefEXT = (PFNGLMATRIXSCALEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixScalefEXT")) == NULL) || r;
    5666. 

  5666.   r = ((glMatrixTranslatedEXT = (PFNGLMATRIXTRANSLATEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixTranslatedEXT")) == NULL) || r;
    5667. 

  5667.   r = ((glMatrixTranslatefEXT = (PFNGLMATRIXTRANSLATEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixTranslatefEXT")) == NULL) || r;
    5668. 

  5668.   r = ((glMultiTexBufferEXT = (PFNGLMULTITEXBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexBufferEXT")) == NULL) || r;
    5669. 

  5669.   r = ((glMultiTexCoordPointerEXT = (PFNGLMULTITEXCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordPointerEXT")) == NULL) || r;
    5670. 

  5670.   r = ((glMultiTexEnvfEXT = (PFNGLMULTITEXENVFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvfEXT")) == NULL) || r;
    5671. 

  5671.   r = ((glMultiTexEnvfvEXT = (PFNGLMULTITEXENVFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvfvEXT")) == NULL) || r;
    5672. 

  5672.   r = ((glMultiTexEnviEXT = (PFNGLMULTITEXENVIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnviEXT")) == NULL) || r;
    5673. 

  5673.   r = ((glMultiTexEnvivEXT = (PFNGLMULTITEXENVIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvivEXT")) == NULL) || r;
    5674. 

  5674.   r = ((glMultiTexGendEXT = (PFNGLMULTITEXGENDEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGendEXT")) == NULL) || r;
    5675. 

  5675.   r = ((glMultiTexGendvEXT = (PFNGLMULTITEXGENDVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGendvEXT")) == NULL) || r;
    5676. 

  5676.   r = ((glMultiTexGenfEXT = (PFNGLMULTITEXGENFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenfEXT")) == NULL) || r;
    5677. 

  5677.   r = ((glMultiTexGenfvEXT = (PFNGLMULTITEXGENFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenfvEXT")) == NULL) || r;
    5678. 

  5678.   r = ((glMultiTexGeniEXT = (PFNGLMULTITEXGENIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGeniEXT")) == NULL) || r;
    5679. 

  5679.   r = ((glMultiTexGenivEXT = (PFNGLMULTITEXGENIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenivEXT")) == NULL) || r;
    5680. 

  5680.   r = ((glMultiTexImage1DEXT = (PFNGLMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage1DEXT")) == NULL) || r;
    5681. 

  5681.   r = ((glMultiTexImage2DEXT = (PFNGLMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage2DEXT")) == NULL) || r;
    5682. 

  5682.   r = ((glMultiTexImage3DEXT = (PFNGLMULTITEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage3DEXT")) == NULL) || r;
    5683. 

  5683.   r = ((glMultiTexParameterIivEXT = (PFNGLMULTITEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterIivEXT")) == NULL) || r;
    5684. 

  5684.   r = ((glMultiTexParameterIuivEXT = (PFNGLMULTITEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterIuivEXT")) == NULL) || r;
    5685. 

  5685.   r = ((glMultiTexParameterfEXT = (PFNGLMULTITEXPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterfEXT")) == NULL) || r;
    5686. 

  5686.   r = ((glMultiTexParameterfvEXT = (PFNGLMULTITEXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterfvEXT")) == NULL) || r;
    5687. 

  5687.   r = ((glMultiTexParameteriEXT = (PFNGLMULTITEXPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameteriEXT")) == NULL) || r;
    5688. 

  5688.   r = ((glMultiTexParameterivEXT = (PFNGLMULTITEXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterivEXT")) == NULL) || r;
    5689. 

  5689.   r = ((glMultiTexRenderbufferEXT = (PFNGLMULTITEXRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexRenderbufferEXT")) == NULL) || r;
    5690. 

  5690.   r = ((glMultiTexSubImage1DEXT = (PFNGLMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage1DEXT")) == NULL) || r;
    5691. 

  5691.   r = ((glMultiTexSubImage2DEXT = (PFNGLMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage2DEXT")) == NULL) || r;
    5692. 

  5692.   r = ((glMultiTexSubImage3DEXT = (PFNGLMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage3DEXT")) == NULL) || r;
    5693. 

  5693.   r = ((glNamedBufferDataEXT = (PFNGLNAMEDBUFFERDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferDataEXT")) == NULL) || r;
    5694. 

  5694.   r = ((glNamedBufferSubDataEXT = (PFNGLNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferSubDataEXT")) == NULL) || r;
    5695. 

  5695.   r = ((glNamedCopyBufferSubDataEXT = (PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedCopyBufferSubDataEXT")) == NULL) || r;
    5696. 

  5696.   r = ((glNamedFramebufferRenderbufferEXT = (PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferRenderbufferEXT")) == NULL) || r;
    5697. 

  5697.   r = ((glNamedFramebufferTexture1DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture1DEXT")) == NULL) || r;
    5698. 

  5698.   r = ((glNamedFramebufferTexture2DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture2DEXT")) == NULL) || r;
    5699. 

  5699.   r = ((glNamedFramebufferTexture3DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture3DEXT")) == NULL) || r;
    5700. 

  5700.   r = ((glNamedFramebufferTextureEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureEXT")) == NULL) || r;
    5701. 

  5701.   r = ((glNamedFramebufferTextureFaceEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureFaceEXT")) == NULL) || r;
    5702. 

  5702.   r = ((glNamedFramebufferTextureLayerEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureLayerEXT")) == NULL) || r;
    5703. 

  5703.   r = ((glNamedProgramLocalParameter4dEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4dEXT")) == NULL) || r;
    5704. 

  5704.   r = ((glNamedProgramLocalParameter4dvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4dvEXT")) == NULL) || r;
    5705. 

  5705.   r = ((glNamedProgramLocalParameter4fEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4fEXT")) == NULL) || r;
    5706. 

  5706.   r = ((glNamedProgramLocalParameter4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4fvEXT")) == NULL) || r;
    5707. 

  5707.   r = ((glNamedProgramLocalParameterI4iEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4iEXT")) == NULL) || r;
    5708. 

  5708.   r = ((glNamedProgramLocalParameterI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4ivEXT")) == NULL) || r;
    5709. 

  5709.   r = ((glNamedProgramLocalParameterI4uiEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4uiEXT")) == NULL) || r;
    5710. 

  5710.   r = ((glNamedProgramLocalParameterI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4uivEXT")) == NULL) || r;
    5711. 

  5711.   r = ((glNamedProgramLocalParameters4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameters4fvEXT")) == NULL) || r;
    5712. 

  5712.   r = ((glNamedProgramLocalParametersI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParametersI4ivEXT")) == NULL) || r;
    5713. 

  5713.   r = ((glNamedProgramLocalParametersI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParametersI4uivEXT")) == NULL) || r;
    5714. 

  5714.   r = ((glNamedProgramStringEXT = (PFNGLNAMEDPROGRAMSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramStringEXT")) == NULL) || r;
    5715. 

  5715.   r = ((glNamedRenderbufferStorageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageEXT")) == NULL) || r;
    5716. 

  5716.   r = ((glNamedRenderbufferStorageMultisampleCoverageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageMultisampleCoverageEXT")) == NULL) || r;
    5717. 

  5717.   r = ((glNamedRenderbufferStorageMultisampleEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageMultisampleEXT")) == NULL) || r;
    5718. 

  5718.   r = ((glProgramUniform1fEXT = (PFNGLPROGRAMUNIFORM1FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fEXT")) == NULL) || r;
    5719. 

  5719.   r = ((glProgramUniform1fvEXT = (PFNGLPROGRAMUNIFORM1FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fvEXT")) == NULL) || r;
    5720. 

  5720.   r = ((glProgramUniform1iEXT = (PFNGLPROGRAMUNIFORM1IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1iEXT")) == NULL) || r;
    5721. 

  5721.   r = ((glProgramUniform1ivEXT = (PFNGLPROGRAMUNIFORM1IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ivEXT")) == NULL) || r;
    5722. 

  5722.   r = ((glProgramUniform1uiEXT = (PFNGLPROGRAMUNIFORM1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uiEXT")) == NULL) || r;
    5723. 

  5723.   r = ((glProgramUniform1uivEXT = (PFNGLPROGRAMUNIFORM1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uivEXT")) == NULL) || r;
    5724. 

  5724.   r = ((glProgramUniform2fEXT = (PFNGLPROGRAMUNIFORM2FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fEXT")) == NULL) || r;
    5725. 

  5725.   r = ((glProgramUniform2fvEXT = (PFNGLPROGRAMUNIFORM2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fvEXT")) == NULL) || r;
    5726. 

  5726.   r = ((glProgramUniform2iEXT = (PFNGLPROGRAMUNIFORM2IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2iEXT")) == NULL) || r;
    5727. 

  5727.   r = ((glProgramUniform2ivEXT = (PFNGLPROGRAMUNIFORM2IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ivEXT")) == NULL) || r;
    5728. 

  5728.   r = ((glProgramUniform2uiEXT = (PFNGLPROGRAMUNIFORM2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uiEXT")) == NULL) || r;
    5729. 

  5729.   r = ((glProgramUniform2uivEXT = (PFNGLPROGRAMUNIFORM2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uivEXT")) == NULL) || r;
    5730. 

  5730.   r = ((glProgramUniform3fEXT = (PFNGLPROGRAMUNIFORM3FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fEXT")) == NULL) || r;
    5731. 

  5731.   r = ((glProgramUniform3fvEXT = (PFNGLPROGRAMUNIFORM3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fvEXT")) == NULL) || r;
    5732. 

  5732.   r = ((glProgramUniform3iEXT = (PFNGLPROGRAMUNIFORM3IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3iEXT")) == NULL) || r;
    5733. 

  5733.   r = ((glProgramUniform3ivEXT = (PFNGLPROGRAMUNIFORM3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ivEXT")) == NULL) || r;
    5734. 

  5734.   r = ((glProgramUniform3uiEXT = (PFNGLPROGRAMUNIFORM3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uiEXT")) == NULL) || r;
    5735. 

  5735.   r = ((glProgramUniform3uivEXT = (PFNGLPROGRAMUNIFORM3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uivEXT")) == NULL) || r;
    5736. 

  5736.   r = ((glProgramUniform4fEXT = (PFNGLPROGRAMUNIFORM4FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fEXT")) == NULL) || r;
    5737. 

  5737.   r = ((glProgramUniform4fvEXT = (PFNGLPROGRAMUNIFORM4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fvEXT")) == NULL) || r;
    5738. 

  5738.   r = ((glProgramUniform4iEXT = (PFNGLPROGRAMUNIFORM4IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4iEXT")) == NULL) || r;
    5739. 

  5739.   r = ((glProgramUniform4ivEXT = (PFNGLPROGRAMUNIFORM4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ivEXT")) == NULL) || r;
    5740. 

  5740.   r = ((glProgramUniform4uiEXT = (PFNGLPROGRAMUNIFORM4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uiEXT")) == NULL) || r;
    5741. 

  5741.   r = ((glProgramUniform4uivEXT = (PFNGLPROGRAMUNIFORM4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uivEXT")) == NULL) || r;
    5742. 

  5742.   r = ((glProgramUniformMatrix2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2fvEXT")) == NULL) || r;
    5743. 

  5743.   r = ((glProgramUniformMatrix2x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3fvEXT")) == NULL) || r;
    5744. 

  5744.   r = ((glProgramUniformMatrix2x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4fvEXT")) == NULL) || r;
    5745. 

  5745.   r = ((glProgramUniformMatrix3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3fvEXT")) == NULL) || r;
    5746. 

  5746.   r = ((glProgramUniformMatrix3x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2fvEXT")) == NULL) || r;
    5747. 

  5747.   r = ((glProgramUniformMatrix3x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4fvEXT")) == NULL) || r;
    5748. 

  5748.   r = ((glProgramUniformMatrix4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4fvEXT")) == NULL) || r;
    5749. 

  5749.   r = ((glProgramUniformMatrix4x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2fvEXT")) == NULL) || r;
    5750. 

  5750.   r = ((glProgramUniformMatrix4x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3fvEXT")) == NULL) || r;
    5751. 

  5751.   r = ((glPushClientAttribDefaultEXT = (PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC)glewGetProcAddress((const GLubyte*)"glPushClientAttribDefaultEXT")) == NULL) || r;
    5752. 

  5752.   r = ((glTextureBufferEXT = (PFNGLTEXTUREBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTextureBufferEXT")) == NULL) || r;
    5753. 

  5753.   r = ((glTextureImage1DEXT = (PFNGLTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage1DEXT")) == NULL) || r;
    5754. 

  5754.   r = ((glTextureImage2DEXT = (PFNGLTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DEXT")) == NULL) || r;
    5755. 

  5755.   r = ((glTextureImage3DEXT = (PFNGLTEXTUREIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DEXT")) == NULL) || r;
    5756. 

  5756.   r = ((glTextureParameterIivEXT = (PFNGLTEXTUREPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIivEXT")) == NULL) || r;
    5757. 

  5757.   r = ((glTextureParameterIuivEXT = (PFNGLTEXTUREPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIuivEXT")) == NULL) || r;
    5758. 

  5758.   r = ((glTextureParameterfEXT = (PFNGLTEXTUREPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfEXT")) == NULL) || r;
    5759. 

  5759.   r = ((glTextureParameterfvEXT = (PFNGLTEXTUREPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfvEXT")) == NULL) || r;
    5760. 

  5760.   r = ((glTextureParameteriEXT = (PFNGLTEXTUREPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameteriEXT")) == NULL) || r;
    5761. 

  5761.   r = ((glTextureParameterivEXT = (PFNGLTEXTUREPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterivEXT")) == NULL) || r;
    5762. 

  5762.   r = ((glTextureRenderbufferEXT = (PFNGLTEXTURERENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTextureRenderbufferEXT")) == NULL) || r;
    5763. 

  5763.   r = ((glTextureSubImage1DEXT = (PFNGLTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage1DEXT")) == NULL) || r;
    5764. 

  5764.   r = ((glTextureSubImage2DEXT = (PFNGLTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage2DEXT")) == NULL) || r;
    5765. 

  5765.   r = ((glTextureSubImage3DEXT = (PFNGLTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage3DEXT")) == NULL) || r;
    5766. 

  5766.   r = ((glUnmapNamedBufferEXT = (PFNGLUNMAPNAMEDBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glUnmapNamedBufferEXT")) == NULL) || r;
    5767. 

  5767.   r = ((glVertexArrayColorOffsetEXT = (PFNGLVERTEXARRAYCOLOROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayColorOffsetEXT")) == NULL) || r;
    5768. 

  5768.   r = ((glVertexArrayEdgeFlagOffsetEXT = (PFNGLVERTEXARRAYEDGEFLAGOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayEdgeFlagOffsetEXT")) == NULL) || r;
    5769. 

  5769.   r = ((glVertexArrayFogCoordOffsetEXT = (PFNGLVERTEXARRAYFOGCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayFogCoordOffsetEXT")) == NULL) || r;
    5770. 

  5770.   r = ((glVertexArrayIndexOffsetEXT = (PFNGLVERTEXARRAYINDEXOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayIndexOffsetEXT")) == NULL) || r;
    5771. 

  5771.   r = ((glVertexArrayMultiTexCoordOffsetEXT = (PFNGLVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayMultiTexCoordOffsetEXT")) == NULL) || r;
    5772. 

  5772.   r = ((glVertexArrayNormalOffsetEXT = (PFNGLVERTEXARRAYNORMALOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayNormalOffsetEXT")) == NULL) || r;
    5773. 

  5773.   r = ((glVertexArraySecondaryColorOffsetEXT = (PFNGLVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArraySecondaryColorOffsetEXT")) == NULL) || r;
    5774. 

  5774.   r = ((glVertexArrayTexCoordOffsetEXT = (PFNGLVERTEXARRAYTEXCOORDOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayTexCoordOffsetEXT")) == NULL) || r;
    5775. 

  5775.   r = ((glVertexArrayVertexAttribIOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribIOffsetEXT")) == NULL) || r;
    5776. 

  5776.   r = ((glVertexArrayVertexAttribOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribOffsetEXT")) == NULL) || r;
    5777. 

  5777.   r = ((glVertexArrayVertexOffsetEXT = (PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexOffsetEXT")) == NULL) || r;
    5778. 

  5778. 

  5779.   return r;
    5780. 

  5780. }
    5781. 

  5781. 

  5782. #endif /* GL_EXT_direct_state_access */
    5783. 

  5783. 

  5784. #ifdef GL_EXT_draw_buffers2
    5785. 

  5785. 

  5786. static GLboolean _glewInit_GL_EXT_draw_buffers2 (GLEW_CONTEXT_ARG_DEF_INIT)
    5787. 

  5787. {
    5788. 

  5788.   GLboolean r = GL_FALSE;
    5789. 

  5789. 

  5790.   r = ((glColorMaskIndexedEXT = (PFNGLCOLORMASKINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glColorMaskIndexedEXT")) == NULL) || r;
    5791. 

  5791.   r = ((glDisableIndexedEXT = (PFNGLDISABLEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableIndexedEXT")) == NULL) || r;
    5792. 

  5792.   r = ((glEnableIndexedEXT = (PFNGLENABLEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableIndexedEXT")) == NULL) || r;
    5793. 

  5793.   r = ((glGetBooleanIndexedvEXT = (PFNGLGETBOOLEANINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetBooleanIndexedvEXT")) == NULL) || r;
    5794. 

  5794.   r = ((glGetIntegerIndexedvEXT = (PFNGLGETINTEGERINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerIndexedvEXT")) == NULL) || r;
    5795. 

  5795.   r = ((glIsEnabledIndexedEXT = (PFNGLISENABLEDINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glIsEnabledIndexedEXT")) == NULL) || r;
    5796. 

  5796. 

  5797.   return r;
    5798. 

  5798. }
    5799. 

  5799. 

  5800. #endif /* GL_EXT_draw_buffers2 */
    5801. 

  5801. 

  5802. #ifdef GL_EXT_draw_instanced
    5803. 

  5803. 

  5804. static GLboolean _glewInit_GL_EXT_draw_instanced (GLEW_CONTEXT_ARG_DEF_INIT)
    5805. 

  5805. {
    5806. 

  5806.   GLboolean r = GL_FALSE;
    5807. 

  5807. 

  5808.   r = ((glDrawArraysInstancedEXT = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedEXT")) == NULL) || r;
    5809. 

  5809.   r = ((glDrawElementsInstancedEXT = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedEXT")) == NULL) || r;
    5810. 

  5810. 

  5811.   return r;
    5812. 

  5812. }
    5813. 

  5813. 

  5814. #endif /* GL_EXT_draw_instanced */
    5815. 

  5815. 

  5816. #ifdef GL_EXT_draw_range_elements
    5817. 

  5817. 

  5818. static GLboolean _glewInit_GL_EXT_draw_range_elements (GLEW_CONTEXT_ARG_DEF_INIT)
    5819. 

  5819. {
    5820. 

  5820.   GLboolean r = GL_FALSE;
    5821. 

  5821. 

  5822.   r = ((glDrawRangeElementsEXT = (PFNGLDRAWRANGEELEMENTSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementsEXT")) == NULL) || r;
    5823. 

  5823. 

  5824.   return r;
    5825. 

  5825. }
    5826. 

  5826. 

  5827. #endif /* GL_EXT_draw_range_elements */
    5828. 

  5828. 

  5829. #ifdef GL_EXT_fog_coord
    5830. 

  5830. 

  5831. static GLboolean _glewInit_GL_EXT_fog_coord (GLEW_CONTEXT_ARG_DEF_INIT)
    5832. 

  5832. {
    5833. 

  5833.   GLboolean r = GL_FALSE;
    5834. 

  5834. 

  5835.   r = ((glFogCoordPointerEXT = (PFNGLFOGCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointerEXT")) == NULL) || r;
    5836. 

  5836.   r = ((glFogCoorddEXT = (PFNGLFOGCOORDDEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddEXT")) == NULL) || r;
    5837. 

  5837.   r = ((glFogCoorddvEXT = (PFNGLFOGCOORDDVEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddvEXT")) == NULL) || r;
    5838. 

  5838.   r = ((glFogCoordfEXT = (PFNGLFOGCOORDFEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfEXT")) == NULL) || r;
    5839. 

  5839.   r = ((glFogCoordfvEXT = (PFNGLFOGCOORDFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfvEXT")) == NULL) || r;
    5840. 

  5840. 

  5841.   return r;
    5842. 

  5842. }
    5843. 

  5843. 

  5844. #endif /* GL_EXT_fog_coord */
    5845. 

  5845. 

  5846. #ifdef GL_EXT_fragment_lighting
    5847. 

  5847. 

  5848. static GLboolean _glewInit_GL_EXT_fragment_lighting (GLEW_CONTEXT_ARG_DEF_INIT)
    5849. 

  5849. {
    5850. 

  5850.   GLboolean r = GL_FALSE;
    5851. 

  5851. 

  5852.   r = ((glFragmentColorMaterialEXT = (PFNGLFRAGMENTCOLORMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentColorMaterialEXT")) == NULL) || r;
    5853. 

  5853.   r = ((glFragmentLightModelfEXT = (PFNGLFRAGMENTLIGHTMODELFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfEXT")) == NULL) || r;
    5854. 

  5854.   r = ((glFragmentLightModelfvEXT = (PFNGLFRAGMENTLIGHTMODELFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfvEXT")) == NULL) || r;
    5855. 

  5855.   r = ((glFragmentLightModeliEXT = (PFNGLFRAGMENTLIGHTMODELIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModeliEXT")) == NULL) || r;
    5856. 

  5856.   r = ((glFragmentLightModelivEXT = (PFNGLFRAGMENTLIGHTMODELIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelivEXT")) == NULL) || r;
    5857. 

  5857.   r = ((glFragmentLightfEXT = (PFNGLFRAGMENTLIGHTFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfEXT")) == NULL) || r;
    5858. 

  5858.   r = ((glFragmentLightfvEXT = (PFNGLFRAGMENTLIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfvEXT")) == NULL) || r;
    5859. 

  5859.   r = ((glFragmentLightiEXT = (PFNGLFRAGMENTLIGHTIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightiEXT")) == NULL) || r;
    5860. 

  5860.   r = ((glFragmentLightivEXT = (PFNGLFRAGMENTLIGHTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightivEXT")) == NULL) || r;
    5861. 

  5861.   r = ((glFragmentMaterialfEXT = (PFNGLFRAGMENTMATERIALFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfEXT")) == NULL) || r;
    5862. 

  5862.   r = ((glFragmentMaterialfvEXT = (PFNGLFRAGMENTMATERIALFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfvEXT")) == NULL) || r;
    5863. 

  5863.   r = ((glFragmentMaterialiEXT = (PFNGLFRAGMENTMATERIALIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialiEXT")) == NULL) || r;
    5864. 

  5864.   r = ((glFragmentMaterialivEXT = (PFNGLFRAGMENTMATERIALIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialivEXT")) == NULL) || r;
    5865. 

  5865.   r = ((glGetFragmentLightfvEXT = (PFNGLGETFRAGMENTLIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightfvEXT")) == NULL) || r;
    5866. 

  5866.   r = ((glGetFragmentLightivEXT = (PFNGLGETFRAGMENTLIGHTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightivEXT")) == NULL) || r;
    5867. 

  5867.   r = ((glGetFragmentMaterialfvEXT = (PFNGLGETFRAGMENTMATERIALFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialfvEXT")) == NULL) || r;
    5868. 

  5868.   r = ((glGetFragmentMaterialivEXT = (PFNGLGETFRAGMENTMATERIALIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialivEXT")) == NULL) || r;
    5869. 

  5869.   r = ((glLightEnviEXT = (PFNGLLIGHTENVIEXTPROC)glewGetProcAddress((const GLubyte*)"glLightEnviEXT")) == NULL) || r;
    5870. 

  5870. 

  5871.   return r;
    5872. 

  5872. }
    5873. 

  5873. 

  5874. #endif /* GL_EXT_fragment_lighting */
    5875. 

  5875. 

  5876. #ifdef GL_EXT_framebuffer_blit
    5877. 

  5877. 

  5878. static GLboolean _glewInit_GL_EXT_framebuffer_blit (GLEW_CONTEXT_ARG_DEF_INIT)
    5879. 

  5879. {
    5880. 

  5880.   GLboolean r = GL_FALSE;
    5881. 

  5881. 

  5882.   r = ((glBlitFramebufferEXT = (PFNGLBLITFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebufferEXT")) == NULL) || r;
    5883. 

  5883. 

  5884.   return r;
    5885. 

  5885. }
    5886. 

  5886. 

  5887. #endif /* GL_EXT_framebuffer_blit */
    5888. 

  5888. 

  5889. #ifdef GL_EXT_framebuffer_multisample
    5890. 

  5890. 

  5891. static GLboolean _glewInit_GL_EXT_framebuffer_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
    5892. 

  5892. {
    5893. 

  5893.   GLboolean r = GL_FALSE;
    5894. 

  5894. 

  5895.   r = ((glRenderbufferStorageMultisampleEXT = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleEXT")) == NULL) || r;
    5896. 

  5896. 

  5897.   return r;
    5898. 

  5898. }
    5899. 

  5899. 

  5900. #endif /* GL_EXT_framebuffer_multisample */
    5901. 

  5901. 

  5902. #ifdef GL_EXT_framebuffer_multisample_blit_scaled
    5903. 

  5903. 

  5904. #endif /* GL_EXT_framebuffer_multisample_blit_scaled */
    5905. 

  5905. 

  5906. #ifdef GL_EXT_framebuffer_object
    5907. 

  5907. 

  5908. static GLboolean _glewInit_GL_EXT_framebuffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
    5909. 

  5909. {
    5910. 

  5910.   GLboolean r = GL_FALSE;
    5911. 

  5911. 

  5912.   r = ((glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindFramebufferEXT")) == NULL) || r;
    5913. 

  5913.   r = ((glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindRenderbufferEXT")) == NULL) || r;
    5914. 

  5914.   r = ((glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glCheckFramebufferStatusEXT")) == NULL) || r;
    5915. 

  5915.   r = ((glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffersEXT")) == NULL) || r;
    5916. 

  5916.   r = ((glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffersEXT")) == NULL) || r;
    5917. 

  5917.   r = ((glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbufferEXT")) == NULL) || r;
    5918. 

  5918.   r = ((glFramebufferTexture1DEXT = (PFNGLFRAMEBUFFERTEXTURE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture1DEXT")) == NULL) || r;
    5919. 

  5919.   r = ((glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2DEXT")) == NULL) || r;
    5920. 

  5920.   r = ((glFramebufferTexture3DEXT = (PFNGLFRAMEBUFFERTEXTURE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3DEXT")) == NULL) || r;
    5921. 

  5921.   r = ((glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffersEXT")) == NULL) || r;
    5922. 

  5922.   r = ((glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffersEXT")) == NULL) || r;
    5923. 

  5923.   r = ((glGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmapEXT")) == NULL) || r;
    5924. 

  5924.   r = ((glGetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferAttachmentParameterivEXT")) == NULL) || r;
    5925. 

  5925.   r = ((glGetRenderbufferParameterivEXT = (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetRenderbufferParameterivEXT")) == NULL) || r;
    5926. 

  5926.   r = ((glIsFramebufferEXT = (PFNGLISFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsFramebufferEXT")) == NULL) || r;
    5927. 

  5927.   r = ((glIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsRenderbufferEXT")) == NULL) || r;
    5928. 

  5928.   r = ((glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageEXT")) == NULL) || r;
    5929. 

  5929. 

  5930.   return r;
    5931. 

  5931. }
    5932. 

  5932. 

  5933. #endif /* GL_EXT_framebuffer_object */
    5934. 

  5934. 

  5935. #ifdef GL_EXT_framebuffer_sRGB
    5936. 

  5936. 

  5937. #endif /* GL_EXT_framebuffer_sRGB */
    5938. 

  5938. 

  5939. #ifdef GL_EXT_geometry_shader4
    5940. 

  5940. 

  5941. static GLboolean _glewInit_GL_EXT_geometry_shader4 (GLEW_CONTEXT_ARG_DEF_INIT)
    5942. 

  5942. {
    5943. 

  5943.   GLboolean r = GL_FALSE;
    5944. 

  5944. 

  5945.   r = ((glFramebufferTextureEXT = (PFNGLFRAMEBUFFERTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureEXT")) == NULL) || r;
    5946. 

  5946.   r = ((glFramebufferTextureFaceEXT = (PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureFaceEXT")) == NULL) || r;
    5947. 

  5947.   r = ((glProgramParameteriEXT = (PFNGLPROGRAMPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteriEXT")) == NULL) || r;
    5948. 

  5948. 

  5949.   return r;
    5950. 

  5950. }
    5951. 

  5951. 

  5952. #endif /* GL_EXT_geometry_shader4 */
    5953. 

  5953. 

  5954. #ifdef GL_EXT_gpu_program_parameters
    5955. 

  5955. 

  5956. static GLboolean _glewInit_GL_EXT_gpu_program_parameters (GLEW_CONTEXT_ARG_DEF_INIT)
    5957. 

  5957. {
    5958. 

  5958.   GLboolean r = GL_FALSE;
    5959. 

  5959. 

  5960.   r = ((glProgramEnvParameters4fvEXT = (PFNGLPROGRAMENVPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameters4fvEXT")) == NULL) || r;
    5961. 

  5961.   r = ((glProgramLocalParameters4fvEXT = (PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameters4fvEXT")) == NULL) || r;
    5962. 

  5962. 

  5963.   return r;
    5964. 

  5964. }
    5965. 

  5965. 

  5966. #endif /* GL_EXT_gpu_program_parameters */
    5967. 

  5967. 

  5968. #ifdef GL_EXT_gpu_shader4
    5969. 

  5969. 

  5970. static GLboolean _glewInit_GL_EXT_gpu_shader4 (GLEW_CONTEXT_ARG_DEF_INIT)
    5971. 

  5971. {
    5972. 

  5972.   GLboolean r = GL_FALSE;
    5973. 

  5973. 

  5974.   r = ((glBindFragDataLocationEXT = (PFNGLBINDFRAGDATALOCATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocationEXT")) == NULL) || r;
    5975. 

  5975.   r = ((glGetFragDataLocationEXT = (PFNGLGETFRAGDATALOCATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataLocationEXT")) == NULL) || r;
    5976. 

  5976.   r = ((glGetUniformuivEXT = (PFNGLGETUNIFORMUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformuivEXT")) == NULL) || r;
    5977. 

  5977.   r = ((glGetVertexAttribIivEXT = (PFNGLGETVERTEXATTRIBIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIivEXT")) == NULL) || r;
    5978. 

  5978.   r = ((glGetVertexAttribIuivEXT = (PFNGLGETVERTEXATTRIBIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIuivEXT")) == NULL) || r;
    5979. 

  5979.   r = ((glUniform1uiEXT = (PFNGLUNIFORM1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform1uiEXT")) == NULL) || r;
    5980. 

  5980.   r = ((glUniform1uivEXT = (PFNGLUNIFORM1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform1uivEXT")) == NULL) || r;
    5981. 

  5981.   r = ((glUniform2uiEXT = (PFNGLUNIFORM2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform2uiEXT")) == NULL) || r;
    5982. 

  5982.   r = ((glUniform2uivEXT = (PFNGLUNIFORM2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform2uivEXT")) == NULL) || r;
    5983. 

  5983.   r = ((glUniform3uiEXT = (PFNGLUNIFORM3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform3uiEXT")) == NULL) || r;
    5984. 

  5984.   r = ((glUniform3uivEXT = (PFNGLUNIFORM3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform3uivEXT")) == NULL) || r;
    5985. 

  5985.   r = ((glUniform4uiEXT = (PFNGLUNIFORM4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform4uiEXT")) == NULL) || r;
    5986. 

  5986.   r = ((glUniform4uivEXT = (PFNGLUNIFORM4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform4uivEXT")) == NULL) || r;
    5987. 

  5987.   r = ((glVertexAttribI1iEXT = (PFNGLVERTEXATTRIBI1IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1iEXT")) == NULL) || r;
    5988. 

  5988.   r = ((glVertexAttribI1ivEXT = (PFNGLVERTEXATTRIBI1IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1ivEXT")) == NULL) || r;
    5989. 

  5989.   r = ((glVertexAttribI1uiEXT = (PFNGLVERTEXATTRIBI1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uiEXT")) == NULL) || r;
    5990. 

  5990.   r = ((glVertexAttribI1uivEXT = (PFNGLVERTEXATTRIBI1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uivEXT")) == NULL) || r;
    5991. 

  5991.   r = ((glVertexAttribI2iEXT = (PFNGLVERTEXATTRIBI2IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2iEXT")) == NULL) || r;
    5992. 

  5992.   r = ((glVertexAttribI2ivEXT = (PFNGLVERTEXATTRIBI2IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2ivEXT")) == NULL) || r;
    5993. 

  5993.   r = ((glVertexAttribI2uiEXT = (PFNGLVERTEXATTRIBI2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uiEXT")) == NULL) || r;
    5994. 

  5994.   r = ((glVertexAttribI2uivEXT = (PFNGLVERTEXATTRIBI2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uivEXT")) == NULL) || r;
    5995. 

  5995.   r = ((glVertexAttribI3iEXT = (PFNGLVERTEXATTRIBI3IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3iEXT")) == NULL) || r;
    5996. 

  5996.   r = ((glVertexAttribI3ivEXT = (PFNGLVERTEXATTRIBI3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3ivEXT")) == NULL) || r;
    5997. 

  5997.   r = ((glVertexAttribI3uiEXT = (PFNGLVERTEXATTRIBI3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uiEXT")) == NULL) || r;
    5998. 

  5998.   r = ((glVertexAttribI3uivEXT = (PFNGLVERTEXATTRIBI3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uivEXT")) == NULL) || r;
    5999. 

  5999.   r = ((glVertexAttribI4bvEXT = (PFNGLVERTEXATTRIBI4BVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4bvEXT")) == NULL) || r;
    6000. 

  6000.   r = ((glVertexAttribI4iEXT = (PFNGLVERTEXATTRIBI4IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4iEXT")) == NULL) || r;
    6001. 

  6001.   r = ((glVertexAttribI4ivEXT = (PFNGLVERTEXATTRIBI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ivEXT")) == NULL) || r;
    6002. 

  6002.   r = ((glVertexAttribI4svEXT = (PFNGLVERTEXATTRIBI4SVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4svEXT")) == NULL) || r;
    6003. 

  6003.   r = ((glVertexAttribI4ubvEXT = (PFNGLVERTEXATTRIBI4UBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ubvEXT")) == NULL) || r;
    6004. 

  6004.   r = ((glVertexAttribI4uiEXT = (PFNGLVERTEXATTRIBI4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uiEXT")) == NULL) || r;
    6005. 

  6005.   r = ((glVertexAttribI4uivEXT = (PFNGLVERTEXATTRIBI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uivEXT")) == NULL) || r;
    6006. 

  6006.   r = ((glVertexAttribI4usvEXT = (PFNGLVERTEXATTRIBI4USVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4usvEXT")) == NULL) || r;
    6007. 

  6007.   r = ((glVertexAttribIPointerEXT = (PFNGLVERTEXATTRIBIPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIPointerEXT")) == NULL) || r;
    6008. 

  6008. 

  6009.   return r;
    6010. 

  6010. }
    6011. 

  6011. 

  6012. #endif /* GL_EXT_gpu_shader4 */
    6013. 

  6013. 

  6014. #ifdef GL_EXT_histogram
    6015. 

  6015. 

  6016. static GLboolean _glewInit_GL_EXT_histogram (GLEW_CONTEXT_ARG_DEF_INIT)
    6017. 

  6017. {
    6018. 

  6018.   GLboolean r = GL_FALSE;
    6019. 

  6019. 

  6020.   r = ((glGetHistogramEXT = (PFNGLGETHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramEXT")) == NULL) || r;
    6021. 

  6021.   r = ((glGetHistogramParameterfvEXT = (PFNGLGETHISTOGRAMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterfvEXT")) == NULL) || r;
    6022. 

  6022.   r = ((glGetHistogramParameterivEXT = (PFNGLGETHISTOGRAMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterivEXT")) == NULL) || r;
    6023. 

  6023.   r = ((glGetMinmaxEXT = (PFNGLGETMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxEXT")) == NULL) || r;
    6024. 

  6024.   r = ((glGetMinmaxParameterfvEXT = (PFNGLGETMINMAXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterfvEXT")) == NULL) || r;
    6025. 

  6025.   r = ((glGetMinmaxParameterivEXT = (PFNGLGETMINMAXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterivEXT")) == NULL) || r;
    6026. 

  6026.   r = ((glHistogramEXT = (PFNGLHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glHistogramEXT")) == NULL) || r;
    6027. 

  6027.   r = ((glMinmaxEXT = (PFNGLMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glMinmaxEXT")) == NULL) || r;
    6028. 

  6028.   r = ((glResetHistogramEXT = (PFNGLRESETHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glResetHistogramEXT")) == NULL) || r;
    6029. 

  6029.   r = ((glResetMinmaxEXT = (PFNGLRESETMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glResetMinmaxEXT")) == NULL) || r;
    6030. 

  6030. 

  6031.   return r;
    6032. 

  6032. }
    6033. 

  6033. 

  6034. #endif /* GL_EXT_histogram */
    6035. 

  6035. 

  6036. #ifdef GL_EXT_index_array_formats
    6037. 

  6037. 

  6038. #endif /* GL_EXT_index_array_formats */
    6039. 

  6039. 

  6040. #ifdef GL_EXT_index_func
    6041. 

  6041. 

  6042. static GLboolean _glewInit_GL_EXT_index_func (GLEW_CONTEXT_ARG_DEF_INIT)
    6043. 

  6043. {
    6044. 

  6044.   GLboolean r = GL_FALSE;
    6045. 

  6045. 

  6046.   r = ((glIndexFuncEXT = (PFNGLINDEXFUNCEXTPROC)glewGetProcAddress((const GLubyte*)"glIndexFuncEXT")) == NULL) || r;
    6047. 

  6047. 

  6048.   return r;
    6049. 

  6049. }
    6050. 

  6050. 

  6051. #endif /* GL_EXT_index_func */
    6052. 

  6052. 

  6053. #ifdef GL_EXT_index_material
    6054. 

  6054. 

  6055. static GLboolean _glewInit_GL_EXT_index_material (GLEW_CONTEXT_ARG_DEF_INIT)
    6056. 

  6056. {
    6057. 

  6057.   GLboolean r = GL_FALSE;
    6058. 

  6058. 

  6059.   r = ((glIndexMaterialEXT = (PFNGLINDEXMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glIndexMaterialEXT")) == NULL) || r;
    6060. 

  6060. 

  6061.   return r;
    6062. 

  6062. }
    6063. 

  6063. 

  6064. #endif /* GL_EXT_index_material */
    6065. 

  6065. 

  6066. #ifdef GL_EXT_index_texture
    6067. 

  6067. 

  6068. #endif /* GL_EXT_index_texture */
    6069. 

  6069. 

  6070. #ifdef GL_EXT_light_texture
    6071. 

  6071. 

  6072. static GLboolean _glewInit_GL_EXT_light_texture (GLEW_CONTEXT_ARG_DEF_INIT)
    6073. 

  6073. {
    6074. 

  6074.   GLboolean r = GL_FALSE;
    6075. 

  6075. 

  6076.   r = ((glApplyTextureEXT = (PFNGLAPPLYTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glApplyTextureEXT")) == NULL) || r;
    6077. 

  6077.   r = ((glTextureLightEXT = (PFNGLTEXTURELIGHTEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureLightEXT")) == NULL) || r;
    6078. 

  6078.   r = ((glTextureMaterialEXT = (PFNGLTEXTUREMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureMaterialEXT")) == NULL) || r;
    6079. 

  6079. 

  6080.   return r;
    6081. 

  6081. }
    6082. 

  6082. 

  6083. #endif /* GL_EXT_light_texture */
    6084. 

  6084. 

  6085. #ifdef GL_EXT_misc_attribute
    6086. 

  6086. 

  6087. #endif /* GL_EXT_misc_attribute */
    6088. 

  6088. 

  6089. #ifdef GL_EXT_multi_draw_arrays
    6090. 

  6090. 

  6091. static GLboolean _glewInit_GL_EXT_multi_draw_arrays (GLEW_CONTEXT_ARG_DEF_INIT)
    6092. 

  6092. {
    6093. 

  6093.   GLboolean r = GL_FALSE;
    6094. 

  6094. 

  6095.   r = ((glMultiDrawArraysEXT = (PFNGLMULTIDRAWARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysEXT")) == NULL) || r;
    6096. 

  6096.   r = ((glMultiDrawElementsEXT = (PFNGLMULTIDRAWELEMENTSEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsEXT")) == NULL) || r;
    6097. 

  6097. 

  6098.   return r;
    6099. 

  6099. }
    6100. 

  6100. 

  6101. #endif /* GL_EXT_multi_draw_arrays */
    6102. 

  6102. 

  6103. #ifdef GL_EXT_multisample
    6104. 

  6104. 

  6105. static GLboolean _glewInit_GL_EXT_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
    6106. 

  6106. {
    6107. 

  6107.   GLboolean r = GL_FALSE;
    6108. 

  6108. 

  6109.   r = ((glSampleMaskEXT = (PFNGLSAMPLEMASKEXTPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskEXT")) == NULL) || r;
    6110. 

  6110.   r = ((glSamplePatternEXT = (PFNGLSAMPLEPATTERNEXTPROC)glewGetProcAddress((const GLubyte*)"glSamplePatternEXT")) == NULL) || r;
    6111. 

  6111. 

  6112.   return r;
    6113. 

  6113. }
    6114. 

  6114. 

  6115. #endif /* GL_EXT_multisample */
    6116. 

  6116. 

  6117. #ifdef GL_EXT_packed_depth_stencil
    6118. 

  6118. 

  6119. #endif /* GL_EXT_packed_depth_stencil */
    6120. 

  6120. 

  6121. #ifdef GL_EXT_packed_float
    6122. 

  6122. 

  6123. #endif /* GL_EXT_packed_float */
    6124. 

  6124. 

  6125. #ifdef GL_EXT_packed_pixels
    6126. 

  6126. 

  6127. #endif /* GL_EXT_packed_pixels */
    6128. 

  6128. 

  6129. #ifdef GL_EXT_paletted_texture
    6130. 

  6130. 

  6131. static GLboolean _glewInit_GL_EXT_paletted_texture (GLEW_CONTEXT_ARG_DEF_INIT)
    6132. 

  6132. {
    6133. 

  6133.   GLboolean r = GL_FALSE;
    6134. 

  6134. 

  6135.   r = ((glColorTableEXT = (PFNGLCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glColorTableEXT")) == NULL) || r;
    6136. 

  6136.   r = ((glGetColorTableEXT = (PFNGLGETCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableEXT")) == NULL) || r;
    6137. 

  6137.   r = ((glGetColorTableParameterfvEXT = (PFNGLGETCOLORTABLEPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfvEXT")) == NULL) || r;
    6138. 

  6138.   r = ((glGetColorTableParameterivEXT = (PFNGLGETCOLORTABLEPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterivEXT")) == NULL) || r;
    6139. 

  6139. 

  6140.   return r;
    6141. 

  6141. }
    6142. 

  6142. 

  6143. #endif /* GL_EXT_paletted_texture */
    6144. 

  6144. 

  6145. #ifdef GL_EXT_pixel_buffer_object
    6146. 

  6146. 

  6147. #endif /* GL_EXT_pixel_buffer_object */
    6148. 

  6148. 

  6149. #ifdef GL_EXT_pixel_transform
    6150. 

  6150. 

  6151. static GLboolean _glewInit_GL_EXT_pixel_transform (GLEW_CONTEXT_ARG_DEF_INIT)
    6152. 

  6152. {
    6153. 

  6153.   GLboolean r = GL_FALSE;
    6154. 

  6154. 

  6155.   r = ((glGetPixelTransformParameterfvEXT = (PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterfvEXT")) == NULL) || r;
    6156. 

  6156.   r = ((glGetPixelTransformParameterivEXT = (PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterivEXT")) == NULL) || r;
    6157. 

  6157.   r = ((glPixelTransformParameterfEXT = (PFNGLPIXELTRANSFORMPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfEXT")) == NULL) || r;
    6158. 

  6158.   r = ((glPixelTransformParameterfvEXT = (PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfvEXT")) == NULL) || r;
    6159. 

  6159.   r = ((glPixelTransformParameteriEXT = (PFNGLPIXELTRANSFORMPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameteriEXT")) == NULL) || r;
    6160. 

  6160.   r = ((glPixelTransformParameterivEXT = (PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterivEXT")) == NULL) || r;
    6161. 

  6161. 

  6162.   return r;
    6163. 

  6163. }
    6164. 

  6164. 

  6165. #endif /* GL_EXT_pixel_transform */
    6166. 

  6166. 

  6167. #ifdef GL_EXT_pixel_transform_color_table
    6168. 

  6168. 

  6169. #endif /* GL_EXT_pixel_transform_color_table */
    6170. 

  6170. 

  6171. #ifdef GL_EXT_point_parameters
    6172. 

  6172. 

  6173. static GLboolean _glewInit_GL_EXT_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT)
    6174. 

  6174. {
    6175. 

  6175.   GLboolean r = GL_FALSE;
    6176. 

  6176. 

  6177.   r = ((glPointParameterfEXT = (PFNGLPOINTPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfEXT")) == NULL) || r;
    6178. 

  6178.   r = ((glPointParameterfvEXT = (PFNGLPOINTPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvEXT")) == NULL) || r;
    6179. 

  6179. 

  6180.   return r;
    6181. 

  6181. }
    6182. 

  6182. 

  6183. #endif /* GL_EXT_point_parameters */
    6184. 

  6184. 

  6185. #ifdef GL_EXT_polygon_offset
    6186. 

  6186. 

  6187. static GLboolean _glewInit_GL_EXT_polygon_offset (GLEW_CONTEXT_ARG_DEF_INIT)
    6188. 

  6188. {
    6189. 

  6189.   GLboolean r = GL_FALSE;
    6190. 

  6190. 

  6191.   r = ((glPolygonOffsetEXT = (PFNGLPOLYGONOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glPolygonOffsetEXT")) == NULL) || r;
    6192. 

  6192. 

  6193.   return r;
    6194. 

  6194. }
    6195. 

  6195. 

  6196. #endif /* GL_EXT_polygon_offset */
    6197. 

  6197. 

  6198. #ifdef GL_EXT_provoking_vertex
    6199. 

  6199. 

  6200. static GLboolean _glewInit_GL_EXT_provoking_vertex (GLEW_CONTEXT_ARG_DEF_INIT)
    6201. 

  6201. {
    6202. 

  6202.   GLboolean r = GL_FALSE;
    6203. 

  6203. 

  6204.   r = ((glProvokingVertexEXT = (PFNGLPROVOKINGVERTEXEXTPROC)glewGetProcAddress((const GLubyte*)"glProvokingVertexEXT")) == NULL) || r;
    6205. 

  6205. 

  6206.   return r;
    6207. 

  6207. }
    6208. 

  6208. 

  6209. #endif /* GL_EXT_provoking_vertex */
    6210. 

  6210. 

  6211. #ifdef GL_EXT_rescale_normal
    6212. 

  6212. 

  6213. #endif /* GL_EXT_rescale_normal */
    6214. 

  6214. 

  6215. #ifdef GL_EXT_scene_marker
    6216. 

  6216. 

  6217. static GLboolean _glewInit_GL_EXT_scene_marker (GLEW_CONTEXT_ARG_DEF_INIT)
    6218. 

  6218. {
    6219. 

  6219.   GLboolean r = GL_FALSE;
    6220. 

  6220. 

  6221.   r = ((glBeginSceneEXT = (PFNGLBEGINSCENEEXTPROC)glewGetProcAddress((const GLubyte*)"glBeginSceneEXT")) == NULL) || r;
    6222. 

  6222.   r = ((glEndSceneEXT = (PFNGLENDSCENEEXTPROC)glewGetProcAddress((const GLubyte*)"glEndSceneEXT")) == NULL) || r;
    6223. 

  6223. 

  6224.   return r;
    6225. 

  6225. }
    6226. 

  6226. 

  6227. #endif /* GL_EXT_scene_marker */
    6228. 

  6228. 

  6229. #ifdef GL_EXT_secondary_color
    6230. 

  6230. 

  6231. static GLboolean _glewInit_GL_EXT_secondary_color (GLEW_CONTEXT_ARG_DEF_INIT)
    6232. 

  6232. {
    6233. 

  6233.   GLboolean r = GL_FALSE;
    6234. 

  6234. 

  6235.   r = ((glSecondaryColor3bEXT = (PFNGLSECONDARYCOLOR3BEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bEXT")) == NULL) || r;
    6236. 

  6236.   r = ((glSecondaryColor3bvEXT = (PFNGLSECONDARYCOLOR3BVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bvEXT")) == NULL) || r;
    6237. 

  6237.   r = ((glSecondaryColor3dEXT = (PFNGLSECONDARYCOLOR3DEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dEXT")) == NULL) || r;
    6238. 

  6238.   r = ((glSecondaryColor3dvEXT = (PFNGLSECONDARYCOLOR3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dvEXT")) == NULL) || r;
    6239. 

  6239.   r = ((glSecondaryColor3fEXT = (PFNGLSECONDARYCOLOR3FEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fEXT")) == NULL) || r;
    6240. 

  6240.   r = ((glSecondaryColor3fvEXT = (PFNGLSECONDARYCOLOR3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fvEXT")) == NULL) || r;
    6241. 

  6241.   r = ((glSecondaryColor3iEXT = (PFNGLSECONDARYCOLOR3IEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3iEXT")) == NULL) || r;
    6242. 

  6242.   r = ((glSecondaryColor3ivEXT = (PFNGLSECONDARYCOLOR3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ivEXT")) == NULL) || r;
    6243. 

  6243.   r = ((glSecondaryColor3sEXT = (PFNGLSECONDARYCOLOR3SEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3sEXT")) == NULL) || r;
    6244. 

  6244.   r = ((glSecondaryColor3svEXT = (PFNGLSECONDARYCOLOR3SVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3svEXT")) == NULL) || r;
    6245. 

  6245.   r = ((glSecondaryColor3ubEXT = (PFNGLSECONDARYCOLOR3UBEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubEXT")) == NULL) || r;
    6246. 

  6246.   r = ((glSecondaryColor3ubvEXT = (PFNGLSECONDARYCOLOR3UBVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubvEXT")) == NULL) || r;
    6247. 

  6247.   r = ((glSecondaryColor3uiEXT = (PFNGLSECONDARYCOLOR3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uiEXT")) == NULL) || r;
    6248. 

  6248.   r = ((glSecondaryColor3uivEXT = (PFNGLSECONDARYCOLOR3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uivEXT")) == NULL) || r;
    6249. 

  6249.   r = ((glSecondaryColor3usEXT = (PFNGLSECONDARYCOLOR3USEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usEXT")) == NULL) || r;
    6250. 

  6250.   r = ((glSecondaryColor3usvEXT = (PFNGLSECONDARYCOLOR3USVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usvEXT")) == NULL) || r;
    6251. 

  6251.   r = ((glSecondaryColorPointerEXT = (PFNGLSECONDARYCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerEXT")) == NULL) || r;
    6252. 

  6252. 

  6253.   return r;
    6254. 

  6254. }
    6255. 

  6255. 

  6256. #endif /* GL_EXT_secondary_color */
    6257. 

  6257. 

  6258. #ifdef GL_EXT_separate_shader_objects
    6259. 

  6259. 

  6260. static GLboolean _glewInit_GL_EXT_separate_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT)
    6261. 

  6261. {
    6262. 

  6262.   GLboolean r = GL_FALSE;
    6263. 

  6263. 

  6264.   r = ((glActiveProgramEXT = (PFNGLACTIVEPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glActiveProgramEXT")) == NULL) || r;
    6265. 

  6265.   r = ((glCreateShaderProgramEXT = (PFNGLCREATESHADERPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderProgramEXT")) == NULL) || r;
    6266. 

  6266.   r = ((glUseShaderProgramEXT = (PFNGLUSESHADERPROGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glUseShaderProgramEXT")) == NULL) || r;
    6267. 

  6267. 

  6268.   return r;
    6269. 

  6269. }
    6270. 

  6270. 

  6271. #endif /* GL_EXT_separate_shader_objects */
    6272. 

  6272. 

  6273. #ifdef GL_EXT_separate_specular_color
    6274. 

  6274. 

  6275. #endif /* GL_EXT_separate_specular_color */
    6276. 

  6276. 

  6277. #ifdef GL_EXT_shader_image_load_store
    6278. 

  6278. 

  6279. static GLboolean _glewInit_GL_EXT_shader_image_load_store (GLEW_CONTEXT_ARG_DEF_INIT)
    6280. 

  6280. {
    6281. 

  6281.   GLboolean r = GL_FALSE;
    6282. 

  6282. 

  6283.   r = ((glBindImageTextureEXT = (PFNGLBINDIMAGETEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindImageTextureEXT")) == NULL) || r;
    6284. 

  6284.   r = ((glMemoryBarrierEXT = (PFNGLMEMORYBARRIEREXTPROC)glewGetProcAddress((const GLubyte*)"glMemoryBarrierEXT")) == NULL) || r;
    6285. 

  6285. 

  6286.   return r;
    6287. 

  6287. }
    6288. 

  6288. 

  6289. #endif /* GL_EXT_shader_image_load_store */
    6290. 

  6290. 

  6291. #ifdef GL_EXT_shadow_funcs
    6292. 

  6292. 

  6293. #endif /* GL_EXT_shadow_funcs */
    6294. 

  6294. 

  6295. #ifdef GL_EXT_shared_texture_palette
    6296. 

  6296. 

  6297. #endif /* GL_EXT_shared_texture_palette */
    6298. 

  6298. 

  6299. #ifdef GL_EXT_stencil_clear_tag
    6300. 

  6300. 

  6301. #endif /* GL_EXT_stencil_clear_tag */
    6302. 

  6302. 

  6303. #ifdef GL_EXT_stencil_two_side
    6304. 

  6304. 

  6305. static GLboolean _glewInit_GL_EXT_stencil_two_side (GLEW_CONTEXT_ARG_DEF_INIT)
    6306. 

  6306. {
    6307. 

  6307.   GLboolean r = GL_FALSE;
    6308. 

  6308. 

  6309.   r = ((glActiveStencilFaceEXT = (PFNGLACTIVESTENCILFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glActiveStencilFaceEXT")) == NULL) || r;
    6310. 

  6310. 

  6311.   return r;
    6312. 

  6312. }
    6313. 

  6313. 

  6314. #endif /* GL_EXT_stencil_two_side */
    6315. 

  6315. 

  6316. #ifdef GL_EXT_stencil_wrap
    6317. 

  6317. 

  6318. #endif /* GL_EXT_stencil_wrap */
    6319. 

  6319. 

  6320. #ifdef GL_EXT_subtexture
    6321. 

  6321. 

  6322. static GLboolean _glewInit_GL_EXT_subtexture (GLEW_CONTEXT_ARG_DEF_INIT)
    6323. 

  6323. {
    6324. 

  6324.   GLboolean r = GL_FALSE;
    6325. 

  6325. 

  6326.   r = ((glTexSubImage1DEXT = (PFNGLTEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage1DEXT")) == NULL) || r;
    6327. 

  6327.   r = ((glTexSubImage2DEXT = (PFNGLTEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage2DEXT")) == NULL) || r;
    6328. 

  6328.   r = ((glTexSubImage3DEXT = (PFNGLTEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3DEXT")) == NULL) || r;
    6329. 

  6329. 

  6330.   return r;
    6331. 

  6331. }
    6332. 

  6332. 

  6333. #endif /* GL_EXT_subtexture */
    6334. 

  6334. 

  6335. #ifdef GL_EXT_texture
    6336. 

  6336. 

  6337. #endif /* GL_EXT_texture */
    6338. 

  6338. 

  6339. #ifdef GL_EXT_texture3D
    6340. 

  6340. 

  6341. static GLboolean _glewInit_GL_EXT_texture3D (GLEW_CONTEXT_ARG_DEF_INIT)
    6342. 

  6342. {
    6343. 

  6343.   GLboolean r = GL_FALSE;
    6344. 

  6344. 

  6345.   r = ((glTexImage3DEXT = (PFNGLTEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DEXT")) == NULL) || r;
    6346. 

  6346. 

  6347.   return r;
    6348. 

  6348. }
    6349. 

  6349. 

  6350. #endif /* GL_EXT_texture3D */
    6351. 

  6351. 

  6352. #ifdef GL_EXT_texture_array
    6353. 

  6353. 

  6354. static GLboolean _glewInit_GL_EXT_texture_array (GLEW_CONTEXT_ARG_DEF_INIT)
    6355. 

  6355. {
    6356. 

  6356.   GLboolean r = GL_FALSE;
    6357. 

  6357. 

  6358.   r = ((glFramebufferTextureLayerEXT = (PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayerEXT")) == NULL) || r;
    6359. 

  6359. 

  6360.   return r;
    6361. 

  6361. }
    6362. 

  6362. 

  6363. #endif /* GL_EXT_texture_array */
    6364. 

  6364. 

  6365. #ifdef GL_EXT_texture_buffer_object
    6366. 

  6366. 

  6367. static GLboolean _glewInit_GL_EXT_texture_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
    6368. 

  6368. {
    6369. 

  6369.   GLboolean r = GL_FALSE;
    6370. 

  6370. 

  6371.   r = ((glTexBufferEXT = (PFNGLTEXBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTexBufferEXT")) == NULL) || r;
    6372. 

  6372. 

  6373.   return r;
    6374. 

  6374. }
    6375. 

  6375. 

  6376. #endif /* GL_EXT_texture_buffer_object */
    6377. 

  6377. 

  6378. #ifdef GL_EXT_texture_compression_dxt1
    6379. 

  6379. 

  6380. #endif /* GL_EXT_texture_compression_dxt1 */
    6381. 

  6381. 

  6382. #ifdef GL_EXT_texture_compression_latc
    6383. 

  6383. 

  6384. #endif /* GL_EXT_texture_compression_latc */
    6385. 

  6385. 

  6386. #ifdef GL_EXT_texture_compression_rgtc
    6387. 

  6387. 

  6388. #endif /* GL_EXT_texture_compression_rgtc */
    6389. 

  6389. 

  6390. #ifdef GL_EXT_texture_compression_s3tc
    6391. 

  6391. 

  6392. #endif /* GL_EXT_texture_compression_s3tc */
    6393. 

  6393. 

  6394. #ifdef GL_EXT_texture_cube_map
    6395. 

  6395. 

  6396. #endif /* GL_EXT_texture_cube_map */
    6397. 

  6397. 

  6398. #ifdef GL_EXT_texture_edge_clamp
    6399. 

  6399. 

  6400. #endif /* GL_EXT_texture_edge_clamp */
    6401. 

  6401. 

  6402. #ifdef GL_EXT_texture_env
    6403. 

  6403. 

  6404. #endif /* GL_EXT_texture_env */
    6405. 

  6405. 

  6406. #ifdef GL_EXT_texture_env_add
    6407. 

  6407. 

  6408. #endif /* GL_EXT_texture_env_add */
    6409. 

  6409. 

  6410. #ifdef GL_EXT_texture_env_combine
    6411. 

  6411. 

  6412. #endif /* GL_EXT_texture_env_combine */
    6413. 

  6413. 

  6414. #ifdef GL_EXT_texture_env_dot3
    6415. 

  6415. 

  6416. #endif /* GL_EXT_texture_env_dot3 */
    6417. 

  6417. 

  6418. #ifdef GL_EXT_texture_filter_anisotropic
    6419. 

  6419. 

  6420. #endif /* GL_EXT_texture_filter_anisotropic */
    6421. 

  6421. 

  6422. #ifdef GL_EXT_texture_integer
    6423. 

  6423. 

  6424. static GLboolean _glewInit_GL_EXT_texture_integer (GLEW_CONTEXT_ARG_DEF_INIT)
    6425. 

  6425. {
    6426. 

  6426.   GLboolean r = GL_FALSE;
    6427. 

  6427. 

  6428.   r = ((glClearColorIiEXT = (PFNGLCLEARCOLORIIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearColorIiEXT")) == NULL) || r;
    6429. 

  6429.   r = ((glClearColorIuiEXT = (PFNGLCLEARCOLORIUIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearColorIuiEXT")) == NULL) || r;
    6430. 

  6430.   r = ((glGetTexParameterIivEXT = (PFNGLGETTEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIivEXT")) == NULL) || r;
    6431. 

  6431.   r = ((glGetTexParameterIuivEXT = (PFNGLGETTEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIuivEXT")) == NULL) || r;
    6432. 

  6432.   r = ((glTexParameterIivEXT = (PFNGLTEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIivEXT")) == NULL) || r;
    6433. 

  6433.   r = ((glTexParameterIuivEXT = (PFNGLTEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIuivEXT")) == NULL) || r;
    6434. 

  6434. 

  6435.   return r;
    6436. 

  6436. }
    6437. 

  6437. 

  6438. #endif /* GL_EXT_texture_integer */
    6439. 

  6439. 

  6440. #ifdef GL_EXT_texture_lod_bias
    6441. 

  6441. 

  6442. #endif /* GL_EXT_texture_lod_bias */
    6443. 

  6443. 

  6444. #ifdef GL_EXT_texture_mirror_clamp
    6445. 

  6445. 

  6446. #endif /* GL_EXT_texture_mirror_clamp */
    6447. 

  6447. 

  6448. #ifdef GL_EXT_texture_object
    6449. 

  6449. 

  6450. static GLboolean _glewInit_GL_EXT_texture_object (GLEW_CONTEXT_ARG_DEF_INIT)
    6451. 

  6451. {
    6452. 

  6452.   GLboolean r = GL_FALSE;
    6453. 

  6453. 

  6454.   r = ((glAreTexturesResidentEXT = (PFNGLARETEXTURESRESIDENTEXTPROC)glewGetProcAddress((const GLubyte*)"glAreTexturesResidentEXT")) == NULL) || r;
    6455. 

  6455.   r = ((glBindTextureEXT = (PFNGLBINDTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindTextureEXT")) == NULL) || r;
    6456. 

  6456.   r = ((glDeleteTexturesEXT = (PFNGLDELETETEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteTexturesEXT")) == NULL) || r;
    6457. 

  6457.   r = ((glGenTexturesEXT = (PFNGLGENTEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glGenTexturesEXT")) == NULL) || r;
    6458. 

  6458.   r = ((glIsTextureEXT = (PFNGLISTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glIsTextureEXT")) == NULL) || r;
    6459. 

  6459.   r = ((glPrioritizeTexturesEXT = (PFNGLPRIORITIZETEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glPrioritizeTexturesEXT")) == NULL) || r;
    6460. 

  6460. 

  6461.   return r;
    6462. 

  6462. }
    6463. 

  6463. 

  6464. #endif /* GL_EXT_texture_object */
    6465. 

  6465. 

  6466. #ifdef GL_EXT_texture_perturb_normal
    6467. 

  6467. 

  6468. static GLboolean _glewInit_GL_EXT_texture_perturb_normal (GLEW_CONTEXT_ARG_DEF_INIT)
    6469. 

  6469. {
    6470. 

  6470.   GLboolean r = GL_FALSE;
    6471. 

  6471. 

  6472.   r = ((glTextureNormalEXT = (PFNGLTEXTURENORMALEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureNormalEXT")) == NULL) || r;
    6473. 

  6473. 

  6474.   return r;
    6475. 

  6475. }
    6476. 

  6476. 

  6477. #endif /* GL_EXT_texture_perturb_normal */
    6478. 

  6478. 

  6479. #ifdef GL_EXT_texture_rectangle
    6480. 

  6480. 

  6481. #endif /* GL_EXT_texture_rectangle */
    6482. 

  6482. 

  6483. #ifdef GL_EXT_texture_sRGB
    6484. 

  6484. 

  6485. #endif /* GL_EXT_texture_sRGB */
    6486. 

  6486. 

  6487. #ifdef GL_EXT_texture_sRGB_decode
    6488. 

  6488. 

  6489. #endif /* GL_EXT_texture_sRGB_decode */
    6490. 

  6490. 

  6491. #ifdef GL_EXT_texture_shared_exponent
    6492. 

  6492. 

  6493. #endif /* GL_EXT_texture_shared_exponent */
    6494. 

  6494. 

  6495. #ifdef GL_EXT_texture_snorm
    6496. 

  6496. 

  6497. #endif /* GL_EXT_texture_snorm */
    6498. 

  6498. 

  6499. #ifdef GL_EXT_texture_swizzle
    6500. 

  6500. 

  6501. #endif /* GL_EXT_texture_swizzle */
    6502. 

  6502. 

  6503. #ifdef GL_EXT_timer_query
    6504. 

  6504. 

  6505. static GLboolean _glewInit_GL_EXT_timer_query (GLEW_CONTEXT_ARG_DEF_INIT)
    6506. 

  6506. {
    6507. 

  6507.   GLboolean r = GL_FALSE;
    6508. 

  6508. 

  6509.   r = ((glGetQueryObjecti64vEXT = (PFNGLGETQUERYOBJECTI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjecti64vEXT")) == NULL) || r;
    6510. 

  6510.   r = ((glGetQueryObjectui64vEXT = (PFNGLGETQUERYOBJECTUI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectui64vEXT")) == NULL) || r;
    6511. 

  6511. 

  6512.   return r;
    6513. 

  6513. }
    6514. 

  6514. 

  6515. #endif /* GL_EXT_timer_query */
    6516. 

  6516. 

  6517. #ifdef GL_EXT_transform_feedback
    6518. 

  6518. 

  6519. static GLboolean _glewInit_GL_EXT_transform_feedback (GLEW_CONTEXT_ARG_DEF_INIT)
    6520. 

  6520. {
    6521. 

  6521.   GLboolean r = GL_FALSE;
    6522. 

  6522. 

  6523.   r = ((glBeginTransformFeedbackEXT = (PFNGLBEGINTRANSFORMFEEDBACKEXTPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedbackEXT")) == NULL) || r;
    6524. 

  6524.   r = ((glBindBufferBaseEXT = (PFNGLBINDBUFFERBASEEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBaseEXT")) == NULL) || r;
    6525. 

  6525.   r = ((glBindBufferOffsetEXT = (PFNGLBINDBUFFEROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferOffsetEXT")) == NULL) || r;
    6526. 

  6526.   r = ((glBindBufferRangeEXT = (PFNGLBINDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRangeEXT")) == NULL) || r;
    6527. 

  6527.   r = ((glEndTransformFeedbackEXT = (PFNGLENDTRANSFORMFEEDBACKEXTPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedbackEXT")) == NULL) || r;
    6528. 

  6528.   r = ((glGetTransformFeedbackVaryingEXT = (PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVaryingEXT")) == NULL) || r;
    6529. 

  6529.   r = ((glTransformFeedbackVaryingsEXT = (PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryingsEXT")) == NULL) || r;
    6530. 

  6530. 

  6531.   return r;
    6532. 

  6532. }
    6533. 

  6533. 

  6534. #endif /* GL_EXT_transform_feedback */
    6535. 

  6535. 

  6536. #ifdef GL_EXT_vertex_array
    6537. 

  6537. 

  6538. static GLboolean _glewInit_GL_EXT_vertex_array (GLEW_CONTEXT_ARG_DEF_INIT)
    6539. 

  6539. {
    6540. 

  6540.   GLboolean r = GL_FALSE;
    6541. 

  6541. 

  6542.   r = ((glArrayElementEXT = (PFNGLARRAYELEMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glArrayElementEXT")) == NULL) || r;
    6543. 

  6543.   r = ((glColorPointerEXT = (PFNGLCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glColorPointerEXT")) == NULL) || r;
    6544. 

  6544.   r = ((glDrawArraysEXT = (PFNGLDRAWARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysEXT")) == NULL) || r;
    6545. 

  6545.   r = ((glEdgeFlagPointerEXT = (PFNGLEDGEFLAGPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerEXT")) == NULL) || r;
    6546. 

  6546.   r = ((glIndexPointerEXT = (PFNGLINDEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerEXT")) == NULL) || r;
    6547. 

  6547.   r = ((glNormalPointerEXT = (PFNGLNORMALPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerEXT")) == NULL) || r;
    6548. 

  6548.   r = ((glTexCoordPointerEXT = (PFNGLTEXCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerEXT")) == NULL) || r;
    6549. 

  6549.   r = ((glVertexPointerEXT = (PFNGLVERTEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerEXT")) == NULL) || r;
    6550. 

  6550. 

  6551.   return r;
    6552. 

  6552. }
    6553. 

  6553. 

  6554. #endif /* GL_EXT_vertex_array */
    6555. 

  6555. 

  6556. #ifdef GL_EXT_vertex_array_bgra
    6557. 

  6557. 

  6558. #endif /* GL_EXT_vertex_array_bgra */
    6559. 

  6559. 

  6560. #ifdef GL_EXT_vertex_attrib_64bit
    6561. 

  6561. 

  6562. static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit (GLEW_CONTEXT_ARG_DEF_INIT)
    6563. 

  6563. {
    6564. 

  6564.   GLboolean r = GL_FALSE;
    6565. 

  6565. 

  6566.   r = ((glGetVertexAttribLdvEXT = (PFNGLGETVERTEXATTRIBLDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLdvEXT")) == NULL) || r;
    6567. 

  6567.   r = ((glVertexArrayVertexAttribLOffsetEXT = (PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayVertexAttribLOffsetEXT")) == NULL) || r;
    6568. 

  6568.   r = ((glVertexAttribL1dEXT = (PFNGLVERTEXATTRIBL1DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dEXT")) == NULL) || r;
    6569. 

  6569.   r = ((glVertexAttribL1dvEXT = (PFNGLVERTEXATTRIBL1DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1dvEXT")) == NULL) || r;
    6570. 

  6570.   r = ((glVertexAttribL2dEXT = (PFNGLVERTEXATTRIBL2DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dEXT")) == NULL) || r;
    6571. 

  6571.   r = ((glVertexAttribL2dvEXT = (PFNGLVERTEXATTRIBL2DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2dvEXT")) == NULL) || r;
    6572. 

  6572.   r = ((glVertexAttribL3dEXT = (PFNGLVERTEXATTRIBL3DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dEXT")) == NULL) || r;
    6573. 

  6573.   r = ((glVertexAttribL3dvEXT = (PFNGLVERTEXATTRIBL3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3dvEXT")) == NULL) || r;
    6574. 

  6574.   r = ((glVertexAttribL4dEXT = (PFNGLVERTEXATTRIBL4DEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dEXT")) == NULL) || r;
    6575. 

  6575.   r = ((glVertexAttribL4dvEXT = (PFNGLVERTEXATTRIBL4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4dvEXT")) == NULL) || r;
    6576. 

  6576.   r = ((glVertexAttribLPointerEXT = (PFNGLVERTEXATTRIBLPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLPointerEXT")) == NULL) || r;
    6577. 

  6577. 

  6578.   return r;
    6579. 

  6579. }
    6580. 

  6580. 

  6581. #endif /* GL_EXT_vertex_attrib_64bit */
    6582. 

  6582. 

  6583. #ifdef GL_EXT_vertex_shader
    6584. 

  6584. 

  6585. static GLboolean _glewInit_GL_EXT_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT)
    6586. 

  6586. {
    6587. 

  6587.   GLboolean r = GL_FALSE;
    6588. 

  6588. 

  6589.   r = ((glBeginVertexShaderEXT = (PFNGLBEGINVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBeginVertexShaderEXT")) == NULL) || r;
    6590. 

  6590.   r = ((glBindLightParameterEXT = (PFNGLBINDLIGHTPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindLightParameterEXT")) == NULL) || r;
    6591. 

  6591.   r = ((glBindMaterialParameterEXT = (PFNGLBINDMATERIALPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindMaterialParameterEXT")) == NULL) || r;
    6592. 

  6592.   r = ((glBindParameterEXT = (PFNGLBINDPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindParameterEXT")) == NULL) || r;
    6593. 

  6593.   r = ((glBindTexGenParameterEXT = (PFNGLBINDTEXGENPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTexGenParameterEXT")) == NULL) || r;
    6594. 

  6594.   r = ((glBindTextureUnitParameterEXT = (PFNGLBINDTEXTUREUNITPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTextureUnitParameterEXT")) == NULL) || r;
    6595. 

  6595.   r = ((glBindVertexShaderEXT = (PFNGLBINDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindVertexShaderEXT")) == NULL) || r;
    6596. 

  6596.   r = ((glDeleteVertexShaderEXT = (PFNGLDELETEVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexShaderEXT")) == NULL) || r;
    6597. 

  6597.   r = ((glDisableVariantClientStateEXT = (PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVariantClientStateEXT")) == NULL) || r;
    6598. 

  6598.   r = ((glEnableVariantClientStateEXT = (PFNGLENABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVariantClientStateEXT")) == NULL) || r;
    6599. 

  6599.   r = ((glEndVertexShaderEXT = (PFNGLENDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glEndVertexShaderEXT")) == NULL) || r;
    6600. 

  6600.   r = ((glExtractComponentEXT = (PFNGLEXTRACTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glExtractComponentEXT")) == NULL) || r;
    6601. 

  6601.   r = ((glGenSymbolsEXT = (PFNGLGENSYMBOLSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenSymbolsEXT")) == NULL) || r;
    6602. 

  6602.   r = ((glGenVertexShadersEXT = (PFNGLGENVERTEXSHADERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenVertexShadersEXT")) == NULL) || r;
    6603. 

  6603.   r = ((glGetInvariantBooleanvEXT = (PFNGLGETINVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantBooleanvEXT")) == NULL) || r;
    6604. 

  6604.   r = ((glGetInvariantFloatvEXT = (PFNGLGETINVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantFloatvEXT")) == NULL) || r;
    6605. 

  6605.   r = ((glGetInvariantIntegervEXT = (PFNGLGETINVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantIntegervEXT")) == NULL) || r;
    6606. 

  6606.   r = ((glGetLocalConstantBooleanvEXT = (PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantBooleanvEXT")) == NULL) || r;
    6607. 

  6607.   r = ((glGetLocalConstantFloatvEXT = (PFNGLGETLOCALCONSTANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantFloatvEXT")) == NULL) || r;
    6608. 

  6608.   r = ((glGetLocalConstantIntegervEXT = (PFNGLGETLOCALCONSTANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantIntegervEXT")) == NULL) || r;
    6609. 

  6609.   r = ((glGetVariantBooleanvEXT = (PFNGLGETVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantBooleanvEXT")) == NULL) || r;
    6610. 

  6610.   r = ((glGetVariantFloatvEXT = (PFNGLGETVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantFloatvEXT")) == NULL) || r;
    6611. 

  6611.   r = ((glGetVariantIntegervEXT = (PFNGLGETVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantIntegervEXT")) == NULL) || r;
    6612. 

  6612.   r = ((glGetVariantPointervEXT = (PFNGLGETVARIANTPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantPointervEXT")) == NULL) || r;
    6613. 

  6613.   r = ((glInsertComponentEXT = (PFNGLINSERTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glInsertComponentEXT")) == NULL) || r;
    6614. 

  6614.   r = ((glIsVariantEnabledEXT = (PFNGLISVARIANTENABLEDEXTPROC)glewGetProcAddress((const GLubyte*)"glIsVariantEnabledEXT")) == NULL) || r;
    6615. 

  6615.   r = ((glSetInvariantEXT = (PFNGLSETINVARIANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetInvariantEXT")) == NULL) || r;
    6616. 

  6616.   r = ((glSetLocalConstantEXT = (PFNGLSETLOCALCONSTANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetLocalConstantEXT")) == NULL) || r;
    6617. 

  6617.   r = ((glShaderOp1EXT = (PFNGLSHADEROP1EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp1EXT")) == NULL) || r;
    6618. 

  6618.   r = ((glShaderOp2EXT = (PFNGLSHADEROP2EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp2EXT")) == NULL) || r;
    6619. 

  6619.   r = ((glShaderOp3EXT = (PFNGLSHADEROP3EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp3EXT")) == NULL) || r;
    6620. 

  6620.   r = ((glSwizzleEXT = (PFNGLSWIZZLEEXTPROC)glewGetProcAddress((const GLubyte*)"glSwizzleEXT")) == NULL) || r;
    6621. 

  6621.   r = ((glVariantPointerEXT = (PFNGLVARIANTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVariantPointerEXT")) == NULL) || r;
    6622. 

  6622.   r = ((glVariantbvEXT = (PFNGLVARIANTBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantbvEXT")) == NULL) || r;
    6623. 

  6623.   r = ((glVariantdvEXT = (PFNGLVARIANTDVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantdvEXT")) == NULL) || r;
    6624. 

  6624.   r = ((glVariantfvEXT = (PFNGLVARIANTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantfvEXT")) == NULL) || r;
    6625. 

  6625.   r = ((glVariantivEXT = (PFNGLVARIANTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantivEXT")) == NULL) || r;
    6626. 

  6626.   r = ((glVariantsvEXT = (PFNGLVARIANTSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantsvEXT")) == NULL) || r;
    6627. 

  6627.   r = ((glVariantubvEXT = (PFNGLVARIANTUBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantubvEXT")) == NULL) || r;
    6628. 

  6628.   r = ((glVariantuivEXT = (PFNGLVARIANTUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantuivEXT")) == NULL) || r;
    6629. 

  6629.   r = ((glVariantusvEXT = (PFNGLVARIANTUSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantusvEXT")) == NULL) || r;
    6630. 

  6630.   r = ((glWriteMaskEXT = (PFNGLWRITEMASKEXTPROC)glewGetProcAddress((const GLubyte*)"glWriteMaskEXT")) == NULL) || r;
    6631. 

  6631. 

  6632.   return r;
    6633. 

  6633. }
    6634. 

  6634. 

  6635. #endif /* GL_EXT_vertex_shader */
    6636. 

  6636. 

  6637. #ifdef GL_EXT_vertex_weighting
    6638. 

  6638. 

  6639. static GLboolean _glewInit_GL_EXT_vertex_weighting (GLEW_CONTEXT_ARG_DEF_INIT)
    6640. 

  6640. {
    6641. 

  6641.   GLboolean r = GL_FALSE;
    6642. 

  6642. 

  6643.   r = ((glVertexWeightPointerEXT = (PFNGLVERTEXWEIGHTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightPointerEXT")) == NULL) || r;
    6644. 

  6644.   r = ((glVertexWeightfEXT = (PFNGLVERTEXWEIGHTFEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfEXT")) == NULL) || r;
    6645. 

  6645.   r = ((glVertexWeightfvEXT = (PFNGLVERTEXWEIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfvEXT")) == NULL) || r;
    6646. 

  6646. 

  6647.   return r;
    6648. 

  6648. }
    6649. 

  6649. 

  6650. #endif /* GL_EXT_vertex_weighting */
    6651. 

  6651. 

  6652. #ifdef GL_EXT_x11_sync_object
    6653. 

  6653. 

  6654. static GLboolean _glewInit_GL_EXT_x11_sync_object (GLEW_CONTEXT_ARG_DEF_INIT)
    6655. 

  6655. {
    6656. 

  6656.   GLboolean r = GL_FALSE;
    6657. 

  6657. 

  6658.   r = ((glImportSyncEXT = (PFNGLIMPORTSYNCEXTPROC)glewGetProcAddress((const GLubyte*)"glImportSyncEXT")) == NULL) || r;
    6659. 

  6659. 

  6660.   return r;
    6661. 

  6661. }
    6662. 

  6662. 

  6663. #endif /* GL_EXT_x11_sync_object */
    6664. 

  6664. 

  6665. #ifdef GL_GREMEDY_frame_terminator
    6666. 

  6666. 

  6667. static GLboolean _glewInit_GL_GREMEDY_frame_terminator (GLEW_CONTEXT_ARG_DEF_INIT)
    6668. 

  6668. {
    6669. 

  6669.   GLboolean r = GL_FALSE;
    6670. 

  6670. 

  6671.   r = ((glFrameTerminatorGREMEDY = (PFNGLFRAMETERMINATORGREMEDYPROC)glewGetProcAddress((const GLubyte*)"glFrameTerminatorGREMEDY")) == NULL) || r;
    6672. 

  6672. 

  6673.   return r;
    6674. 

  6674. }
    6675. 

  6675. 

  6676. #endif /* GL_GREMEDY_frame_terminator */
    6677. 

  6677. 

  6678. #ifdef GL_GREMEDY_string_marker
    6679. 

  6679. 

  6680. static GLboolean _glewInit_GL_GREMEDY_string_marker (GLEW_CONTEXT_ARG_DEF_INIT)
    6681. 

  6681. {
    6682. 

  6682.   GLboolean r = GL_FALSE;
    6683. 

  6683. 

  6684.   r = ((glStringMarkerGREMEDY = (PFNGLSTRINGMARKERGREMEDYPROC)glewGetProcAddress((const GLubyte*)"glStringMarkerGREMEDY")) == NULL) || r;
    6685. 

  6685. 

  6686.   return r;
    6687. 

  6687. }
    6688. 

  6688. 

  6689. #endif /* GL_GREMEDY_string_marker */
    6690. 

  6690. 

  6691. #ifdef GL_HP_convolution_border_modes
    6692. 

  6692. 

  6693. #endif /* GL_HP_convolution_border_modes */
    6694. 

  6694. 

  6695. #ifdef GL_HP_image_transform
    6696. 

  6696. 

  6697. static GLboolean _glewInit_GL_HP_image_transform (GLEW_CONTEXT_ARG_DEF_INIT)
    6698. 

  6698. {
    6699. 

  6699.   GLboolean r = GL_FALSE;
    6700. 

  6700. 

  6701.   r = ((glGetImageTransformParameterfvHP = (PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterfvHP")) == NULL) || r;
    6702. 

  6702.   r = ((glGetImageTransformParameterivHP = (PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterivHP")) == NULL) || r;
    6703. 

  6703.   r = ((glImageTransformParameterfHP = (PFNGLIMAGETRANSFORMPARAMETERFHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfHP")) == NULL) || r;
    6704. 

  6704.   r = ((glImageTransformParameterfvHP = (PFNGLIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfvHP")) == NULL) || r;
    6705. 

  6705.   r = ((glImageTransformParameteriHP = (PFNGLIMAGETRANSFORMPARAMETERIHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameteriHP")) == NULL) || r;
    6706. 

  6706.   r = ((glImageTransformParameterivHP = (PFNGLIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterivHP")) == NULL) || r;
    6707. 

  6707. 

  6708.   return r;
    6709. 

  6709. }
    6710. 

  6710. 

  6711. #endif /* GL_HP_image_transform */
    6712. 

  6712. 

  6713. #ifdef GL_HP_occlusion_test
    6714. 

  6714. 

  6715. #endif /* GL_HP_occlusion_test */
    6716. 

  6716. 

  6717. #ifdef GL_HP_texture_lighting
    6718. 

  6718. 

  6719. #endif /* GL_HP_texture_lighting */
    6720. 

  6720. 

  6721. #ifdef GL_IBM_cull_vertex
    6722. 

  6722. 

  6723. #endif /* GL_IBM_cull_vertex */
    6724. 

  6724. 

  6725. #ifdef GL_IBM_multimode_draw_arrays
    6726. 

  6726. 

  6727. static GLboolean _glewInit_GL_IBM_multimode_draw_arrays (GLEW_CONTEXT_ARG_DEF_INIT)
    6728. 

  6728. {
    6729. 

  6729.   GLboolean r = GL_FALSE;
    6730. 

  6730. 

  6731.   r = ((glMultiModeDrawArraysIBM = (PFNGLMULTIMODEDRAWARRAYSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawArraysIBM")) == NULL) || r;
    6732. 

  6732.   r = ((glMultiModeDrawElementsIBM = (PFNGLMULTIMODEDRAWELEMENTSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawElementsIBM")) == NULL) || r;
    6733. 

  6733. 

  6734.   return r;
    6735. 

  6735. }
    6736. 

  6736. 

  6737. #endif /* GL_IBM_multimode_draw_arrays */
    6738. 

  6738. 

  6739. #ifdef GL_IBM_rasterpos_clip
    6740. 

  6740. 

  6741. #endif /* GL_IBM_rasterpos_clip */
    6742. 

  6742. 

  6743. #ifdef GL_IBM_static_data
    6744. 

  6744. 

  6745. #endif /* GL_IBM_static_data */
    6746. 

  6746. 

  6747. #ifdef GL_IBM_texture_mirrored_repeat
    6748. 

  6748. 

  6749. #endif /* GL_IBM_texture_mirrored_repeat */
    6750. 

  6750. 

  6751. #ifdef GL_IBM_vertex_array_lists
    6752. 

  6752. 

  6753. static GLboolean _glewInit_GL_IBM_vertex_array_lists (GLEW_CONTEXT_ARG_DEF_INIT)
    6754. 

  6754. {
    6755. 

  6755.   GLboolean r = GL_FALSE;
    6756. 

  6756. 

  6757.   r = ((glColorPointerListIBM = (PFNGLCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glColorPointerListIBM")) == NULL) || r;
    6758. 

  6758.   r = ((glEdgeFlagPointerListIBM = (PFNGLEDGEFLAGPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerListIBM")) == NULL) || r;
    6759. 

  6759.   r = ((glFogCoordPointerListIBM = (PFNGLFOGCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointerListIBM")) == NULL) || r;
    6760. 

  6760.   r = ((glIndexPointerListIBM = (PFNGLINDEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerListIBM")) == NULL) || r;
    6761. 

  6761.   r = ((glNormalPointerListIBM = (PFNGLNORMALPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerListIBM")) == NULL) || r;
    6762. 

  6762.   r = ((glSecondaryColorPointerListIBM = (PFNGLSECONDARYCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerListIBM")) == NULL) || r;
    6763. 

  6763.   r = ((glTexCoordPointerListIBM = (PFNGLTEXCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerListIBM")) == NULL) || r;
    6764. 

  6764.   r = ((glVertexPointerListIBM = (PFNGLVERTEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerListIBM")) == NULL) || r;
    6765. 

  6765. 

  6766.   return r;
    6767. 

  6767. }
    6768. 

  6768. 

  6769. #endif /* GL_IBM_vertex_array_lists */
    6770. 

  6770. 

  6771. #ifdef GL_INGR_color_clamp
    6772. 

  6772. 

  6773. #endif /* GL_INGR_color_clamp */
    6774. 

  6774. 

  6775. #ifdef GL_INGR_interlace_read
    6776. 

  6776. 

  6777. #endif /* GL_INGR_interlace_read */
    6778. 

  6778. 

  6779. #ifdef GL_INTEL_parallel_arrays
    6780. 

  6780. 

  6781. static GLboolean _glewInit_GL_INTEL_parallel_arrays (GLEW_CONTEXT_ARG_DEF_INIT)
    6782. 

  6782. {
    6783. 

  6783.   GLboolean r = GL_FALSE;
    6784. 

  6784. 

  6785.   r = ((glColorPointervINTEL = (PFNGLCOLORPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glColorPointervINTEL")) == NULL) || r;
    6786. 

  6786.   r = ((glNormalPointervINTEL = (PFNGLNORMALPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glNormalPointervINTEL")) == NULL) || r;
    6787. 

  6787.   r = ((glTexCoordPointervINTEL = (PFNGLTEXCOORDPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointervINTEL")) == NULL) || r;
    6788. 

  6788.   r = ((glVertexPointervINTEL = (PFNGLVERTEXPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glVertexPointervINTEL")) == NULL) || r;
    6789. 

  6789. 

  6790.   return r;
    6791. 

  6791. }
    6792. 

  6792. 

  6793. #endif /* GL_INTEL_parallel_arrays */
    6794. 

  6794. 

  6795. #ifdef GL_INTEL_texture_scissor
    6796. 

  6796. 

  6797. static GLboolean _glewInit_GL_INTEL_texture_scissor (GLEW_CONTEXT_ARG_DEF_INIT)
    6798. 

  6798. {
    6799. 

  6799.   GLboolean r = GL_FALSE;
    6800. 

  6800. 

  6801.   r = ((glTexScissorFuncINTEL = (PFNGLTEXSCISSORFUNCINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorFuncINTEL")) == NULL) || r;
    6802. 

  6802.   r = ((glTexScissorINTEL = (PFNGLTEXSCISSORINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorINTEL")) == NULL) || r;
    6803. 

  6803. 

  6804.   return r;
    6805. 

  6805. }
    6806. 

  6806. 

  6807. #endif /* GL_INTEL_texture_scissor */
    6808. 

  6808. 

  6809. #ifdef GL_KTX_buffer_region
    6810. 

  6810. 

  6811. static GLboolean _glewInit_GL_KTX_buffer_region (GLEW_CONTEXT_ARG_DEF_INIT)
    6812. 

  6812. {
    6813. 

  6813.   GLboolean r = GL_FALSE;
    6814. 

  6814. 

  6815.   r = ((glBufferRegionEnabled = (PFNGLBUFFERREGIONENABLEDPROC)glewGetProcAddress((const GLubyte*)"glBufferRegionEnabled")) == NULL) || r;
    6816. 

  6816.   r = ((glDeleteBufferRegion = (PFNGLDELETEBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glDeleteBufferRegion")) == NULL) || r;
    6817. 

  6817.   r = ((glDrawBufferRegion = (PFNGLDRAWBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glDrawBufferRegion")) == NULL) || r;
    6818. 

  6818.   r = ((glNewBufferRegion = (PFNGLNEWBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glNewBufferRegion")) == NULL) || r;
    6819. 

  6819.   r = ((glReadBufferRegion = (PFNGLREADBUFFERREGIONPROC)glewGetProcAddress((const GLubyte*)"glReadBufferRegion")) == NULL) || r;
    6820. 

  6820. 

  6821.   return r;
    6822. 

  6822. }
    6823. 

  6823. 

  6824. #endif /* GL_KTX_buffer_region */
    6825. 

  6825. 

  6826. #ifdef GL_MESAX_texture_stack
    6827. 

  6827. 

  6828. #endif /* GL_MESAX_texture_stack */
    6829. 

  6829. 

  6830. #ifdef GL_MESA_pack_invert
    6831. 

  6831. 

  6832. #endif /* GL_MESA_pack_invert */
    6833. 

  6833. 

  6834. #ifdef GL_MESA_resize_buffers
    6835. 

  6835. 

  6836. static GLboolean _glewInit_GL_MESA_resize_buffers (GLEW_CONTEXT_ARG_DEF_INIT)
    6837. 

  6837. {
    6838. 

  6838.   GLboolean r = GL_FALSE;
    6839. 

  6839. 

  6840.   r = ((glResizeBuffersMESA = (PFNGLRESIZEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glResizeBuffersMESA")) == NULL) || r;
    6841. 

  6841. 

  6842.   return r;
    6843. 

  6843. }
    6844. 

  6844. 

  6845. #endif /* GL_MESA_resize_buffers */
    6846. 

  6846. 

  6847. #ifdef GL_MESA_window_pos
    6848. 

  6848. 

  6849. static GLboolean _glewInit_GL_MESA_window_pos (GLEW_CONTEXT_ARG_DEF_INIT)
    6850. 

  6850. {
    6851. 

  6851.   GLboolean r = GL_FALSE;
    6852. 

  6852. 

  6853.   r = ((glWindowPos2dMESA = (PFNGLWINDOWPOS2DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dMESA")) == NULL) || r;
    6854. 

  6854.   r = ((glWindowPos2dvMESA = (PFNGLWINDOWPOS2DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dvMESA")) == NULL) || r;
    6855. 

  6855.   r = ((glWindowPos2fMESA = (PFNGLWINDOWPOS2FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fMESA")) == NULL) || r;
    6856. 

  6856.   r = ((glWindowPos2fvMESA = (PFNGLWINDOWPOS2FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fvMESA")) == NULL) || r;
    6857. 

  6857.   r = ((glWindowPos2iMESA = (PFNGLWINDOWPOS2IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iMESA")) == NULL) || r;
    6858. 

  6858.   r = ((glWindowPos2ivMESA = (PFNGLWINDOWPOS2IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2ivMESA")) == NULL) || r;
    6859. 

  6859.   r = ((glWindowPos2sMESA = (PFNGLWINDOWPOS2SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sMESA")) == NULL) || r;
    6860. 

  6860.   r = ((glWindowPos2svMESA = (PFNGLWINDOWPOS2SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2svMESA")) == NULL) || r;
    6861. 

  6861.   r = ((glWindowPos3dMESA = (PFNGLWINDOWPOS3DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dMESA")) == NULL) || r;
    6862. 

  6862.   r = ((glWindowPos3dvMESA = (PFNGLWINDOWPOS3DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dvMESA")) == NULL) || r;
    6863. 

  6863.   r = ((glWindowPos3fMESA = (PFNGLWINDOWPOS3FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fMESA")) == NULL) || r;
    6864. 

  6864.   r = ((glWindowPos3fvMESA = (PFNGLWINDOWPOS3FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fvMESA")) == NULL) || r;
    6865. 

  6865.   r = ((glWindowPos3iMESA = (PFNGLWINDOWPOS3IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iMESA")) == NULL) || r;
    6866. 

  6866.   r = ((glWindowPos3ivMESA = (PFNGLWINDOWPOS3IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3ivMESA")) == NULL) || r;
    6867. 

  6867.   r = ((glWindowPos3sMESA = (PFNGLWINDOWPOS3SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sMESA")) == NULL) || r;
    6868. 

  6868.   r = ((glWindowPos3svMESA = (PFNGLWINDOWPOS3SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3svMESA")) == NULL) || r;
    6869. 

  6869.   r = ((glWindowPos4dMESA = (PFNGLWINDOWPOS4DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dMESA")) == NULL) || r;
    6870. 

  6870.   r = ((glWindowPos4dvMESA = (PFNGLWINDOWPOS4DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dvMESA")) == NULL) || r;
    6871. 

  6871.   r = ((glWindowPos4fMESA = (PFNGLWINDOWPOS4FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fMESA")) == NULL) || r;
    6872. 

  6872.   r = ((glWindowPos4fvMESA = (PFNGLWINDOWPOS4FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fvMESA")) == NULL) || r;
    6873. 

  6873.   r = ((glWindowPos4iMESA = (PFNGLWINDOWPOS4IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4iMESA")) == NULL) || r;
    6874. 

  6874.   r = ((glWindowPos4ivMESA = (PFNGLWINDOWPOS4IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4ivMESA")) == NULL) || r;
    6875. 

  6875.   r = ((glWindowPos4sMESA = (PFNGLWINDOWPOS4SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4sMESA")) == NULL) || r;
    6876. 

  6876.   r = ((glWindowPos4svMESA = (PFNGLWINDOWPOS4SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4svMESA")) == NULL) || r;
    6877. 

  6877. 

  6878.   return r;
    6879. 

  6879. }
    6880. 

  6880. 

  6881. #endif /* GL_MESA_window_pos */
    6882. 

  6882. 

  6883. #ifdef GL_MESA_ycbcr_texture
    6884. 

  6884. 

  6885. #endif /* GL_MESA_ycbcr_texture */
    6886. 

  6886. 

  6887. #ifdef GL_NVX_gpu_memory_info
    6888. 

  6888. 

  6889. #endif /* GL_NVX_gpu_memory_info */
    6890. 

  6890. 

  6891. #ifdef GL_NV_blend_square
    6892. 

  6892. 

  6893. #endif /* GL_NV_blend_square */
    6894. 

  6894. 

  6895. #ifdef GL_NV_conditional_render
    6896. 

  6896. 

  6897. static GLboolean _glewInit_GL_NV_conditional_render (GLEW_CONTEXT_ARG_DEF_INIT)
    6898. 

  6898. {
    6899. 

  6899.   GLboolean r = GL_FALSE;
    6900. 

  6900. 

  6901.   r = ((glBeginConditionalRenderNV = (PFNGLBEGINCONDITIONALRENDERNVPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRenderNV")) == NULL) || r;
    6902. 

  6902.   r = ((glEndConditionalRenderNV = (PFNGLENDCONDITIONALRENDERNVPROC)glewGetProcAddress((const GLubyte*)"glEndConditionalRenderNV")) == NULL) || r;
    6903. 

  6903. 

  6904.   return r;
    6905. 

  6905. }
    6906. 

  6906. 

  6907. #endif /* GL_NV_conditional_render */
    6908. 

  6908. 

  6909. #ifdef GL_NV_copy_depth_to_color
    6910. 

  6910. 

  6911. #endif /* GL_NV_copy_depth_to_color */
    6912. 

  6912. 

  6913. #ifdef GL_NV_copy_image
    6914. 

  6914. 

  6915. static GLboolean _glewInit_GL_NV_copy_image (GLEW_CONTEXT_ARG_DEF_INIT)
    6916. 

  6916. {
    6917. 

  6917.   GLboolean r = GL_FALSE;
    6918. 

  6918. 

  6919.   r = ((glCopyImageSubDataNV = (PFNGLCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glCopyImageSubDataNV")) == NULL) || r;
    6920. 

  6920. 

  6921.   return r;
    6922. 

  6922. }
    6923. 

  6923. 

  6924. #endif /* GL_NV_copy_image */
    6925. 

  6925. 

  6926. #ifdef GL_NV_depth_buffer_float
    6927. 

  6927. 

  6928. static GLboolean _glewInit_GL_NV_depth_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT)
    6929. 

  6929. {
    6930. 

  6930.   GLboolean r = GL_FALSE;
    6931. 

  6931. 

  6932.   r = ((glClearDepthdNV = (PFNGLCLEARDEPTHDNVPROC)glewGetProcAddress((const GLubyte*)"glClearDepthdNV")) == NULL) || r;
    6933. 

  6933.   r = ((glDepthBoundsdNV = (PFNGLDEPTHBOUNDSDNVPROC)glewGetProcAddress((const GLubyte*)"glDepthBoundsdNV")) == NULL) || r;
    6934. 

  6934.   r = ((glDepthRangedNV = (PFNGLDEPTHRANGEDNVPROC)glewGetProcAddress((const GLubyte*)"glDepthRangedNV")) == NULL) || r;
    6935. 

  6935. 

  6936.   return r;
    6937. 

  6937. }
    6938. 

  6938. 

  6939. #endif /* GL_NV_depth_buffer_float */
    6940. 

  6940. 

  6941. #ifdef GL_NV_depth_clamp
    6942. 

  6942. 

  6943. #endif /* GL_NV_depth_clamp */
    6944. 

  6944. 

  6945. #ifdef GL_NV_depth_range_unclamped
    6946. 

  6946. 

  6947. #endif /* GL_NV_depth_range_unclamped */
    6948. 

  6948. 

  6949. #ifdef GL_NV_evaluators
    6950. 

  6950. 

  6951. static GLboolean _glewInit_GL_NV_evaluators (GLEW_CONTEXT_ARG_DEF_INIT)
    6952. 

  6952. {
    6953. 

  6953.   GLboolean r = GL_FALSE;
    6954. 

  6954. 

  6955.   r = ((glEvalMapsNV = (PFNGLEVALMAPSNVPROC)glewGetProcAddress((const GLubyte*)"glEvalMapsNV")) == NULL) || r;
    6956. 

  6956.   r = ((glGetMapAttribParameterfvNV = (PFNGLGETMAPATTRIBPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterfvNV")) == NULL) || r;
    6957. 

  6957.   r = ((glGetMapAttribParameterivNV = (PFNGLGETMAPATTRIBPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterivNV")) == NULL) || r;
    6958. 

  6958.   r = ((glGetMapControlPointsNV = (PFNGLGETMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapControlPointsNV")) == NULL) || r;
    6959. 

  6959.   r = ((glGetMapParameterfvNV = (PFNGLGETMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterfvNV")) == NULL) || r;
    6960. 

  6960.   r = ((glGetMapParameterivNV = (PFNGLGETMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterivNV")) == NULL) || r;
    6961. 

  6961.   r = ((glMapControlPointsNV = (PFNGLMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glMapControlPointsNV")) == NULL) || r;
    6962. 

  6962.   r = ((glMapParameterfvNV = (PFNGLMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterfvNV")) == NULL) || r;
    6963. 

  6963.   r = ((glMapParameterivNV = (PFNGLMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterivNV")) == NULL) || r;
    6964. 

  6964. 

  6965.   return r;
    6966. 

  6966. }
    6967. 

  6967. 

  6968. #endif /* GL_NV_evaluators */
    6969. 

  6969. 

  6970. #ifdef GL_NV_explicit_multisample
    6971. 

  6971. 

  6972. static GLboolean _glewInit_GL_NV_explicit_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
    6973. 

  6973. {
    6974. 

  6974.   GLboolean r = GL_FALSE;
    6975. 

  6975. 

  6976.   r = ((glGetMultisamplefvNV = (PFNGLGETMULTISAMPLEFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMultisamplefvNV")) == NULL) || r;
    6977. 

  6977.   r = ((glSampleMaskIndexedNV = (PFNGLSAMPLEMASKINDEXEDNVPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskIndexedNV")) == NULL) || r;
    6978. 

  6978.   r = ((glTexRenderbufferNV = (PFNGLTEXRENDERBUFFERNVPROC)glewGetProcAddress((const GLubyte*)"glTexRenderbufferNV")) == NULL) || r;
    6979. 

  6979. 

  6980.   return r;
    6981. 

  6981. }
    6982. 

  6982. 

  6983. #endif /* GL_NV_explicit_multisample */
    6984. 

  6984. 

  6985. #ifdef GL_NV_fence
    6986. 

  6986. 

  6987. static GLboolean _glewInit_GL_NV_fence (GLEW_CONTEXT_ARG_DEF_INIT)
    6988. 

  6988. {
    6989. 

  6989.   GLboolean r = GL_FALSE;
    6990. 

  6990. 

  6991.   r = ((glDeleteFencesNV = (PFNGLDELETEFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteFencesNV")) == NULL) || r;
    6992. 

  6992.   r = ((glFinishFenceNV = (PFNGLFINISHFENCENVPROC)glewGetProcAddress((const GLubyte*)"glFinishFenceNV")) == NULL) || r;
    6993. 

  6993.   r = ((glGenFencesNV = (PFNGLGENFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glGenFencesNV")) == NULL) || r;
    6994. 

  6994.   r = ((glGetFenceivNV = (PFNGLGETFENCEIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFenceivNV")) == NULL) || r;
    6995. 

  6995.   r = ((glIsFenceNV = (PFNGLISFENCENVPROC)glewGetProcAddress((const GLubyte*)"glIsFenceNV")) == NULL) || r;
    6996. 

  6996.   r = ((glSetFenceNV = (PFNGLSETFENCENVPROC)glewGetProcAddress((const GLubyte*)"glSetFenceNV")) == NULL) || r;
    6997. 

  6997.   r = ((glTestFenceNV = (PFNGLTESTFENCENVPROC)glewGetProcAddress((const GLubyte*)"glTestFenceNV")) == NULL) || r;
    6998. 

  6998. 

  6999.   return r;
    7000. 

  7000. }
    7001. 

  7001. 

  7002. #endif /* GL_NV_fence */
    7003. 

  7003. 

  7004. #ifdef GL_NV_float_buffer
    7005. 

  7005. 

  7006. #endif /* GL_NV_float_buffer */
    7007. 

  7007. 

  7008. #ifdef GL_NV_fog_distance
    7009. 

  7009. 

  7010. #endif /* GL_NV_fog_distance */
    7011. 

  7011. 

  7012. #ifdef GL_NV_fragment_program
    7013. 

  7013. 

  7014. static GLboolean _glewInit_GL_NV_fragment_program (GLEW_CONTEXT_ARG_DEF_INIT)
    7015. 

  7015. {
    7016. 

  7016.   GLboolean r = GL_FALSE;
    7017. 

  7017. 

  7018.   r = ((glGetProgramNamedParameterdvNV = (PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterdvNV")) == NULL) || r;
    7019. 

  7019.   r = ((glGetProgramNamedParameterfvNV = (PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterfvNV")) == NULL) || r;
    7020. 

  7020.   r = ((glProgramNamedParameter4dNV = (PFNGLPROGRAMNAMEDPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dNV")) == NULL) || r;
    7021. 

  7021.   r = ((glProgramNamedParameter4dvNV = (PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dvNV")) == NULL) || r;
    7022. 

  7022.   r = ((glProgramNamedParameter4fNV = (PFNGLPROGRAMNAMEDPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fNV")) == NULL) || r;
    7023. 

  7023.   r = ((glProgramNamedParameter4fvNV = (PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fvNV")) == NULL) || r;
    7024. 

  7024. 

  7025.   return r;
    7026. 

  7026. }
    7027. 

  7027. 

  7028. #endif /* GL_NV_fragment_program */
    7029. 

  7029. 

  7030. #ifdef GL_NV_fragment_program2
    7031. 

  7031. 

  7032. #endif /* GL_NV_fragment_program2 */
    7033. 

  7033. 

  7034. #ifdef GL_NV_fragment_program4
    7035. 

  7035. 

  7036. #endif /* GL_NV_fragment_program4 */
    7037. 

  7037. 

  7038. #ifdef GL_NV_fragment_program_option
    7039. 

  7039. 

  7040. #endif /* GL_NV_fragment_program_option */
    7041. 

  7041. 

  7042. #ifdef GL_NV_framebuffer_multisample_coverage
    7043. 

  7043. 

  7044. static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage (GLEW_CONTEXT_ARG_DEF_INIT)
    7045. 

  7045. {
    7046. 

  7046.   GLboolean r = GL_FALSE;
    7047. 

  7047. 

  7048.   r = ((glRenderbufferStorageMultisampleCoverageNV = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleCoverageNV")) == NULL) || r;
    7049. 

  7049. 

  7050.   return r;
    7051. 

  7051. }
    7052. 

  7052. 

  7053. #endif /* GL_NV_framebuffer_multisample_coverage */
    7054. 

  7054. 

  7055. #ifdef GL_NV_geometry_program4
    7056. 

  7056. 

  7057. static GLboolean _glewInit_GL_NV_geometry_program4 (GLEW_CONTEXT_ARG_DEF_INIT)
    7058. 

  7058. {
    7059. 

  7059.   GLboolean r = GL_FALSE;
    7060. 

  7060. 

  7061.   r = ((glProgramVertexLimitNV = (PFNGLPROGRAMVERTEXLIMITNVPROC)glewGetProcAddress((const GLubyte*)"glProgramVertexLimitNV")) == NULL) || r;
    7062. 

  7062. 

  7063.   return r;
    7064. 

  7064. }
    7065. 

  7065. 

  7066. #endif /* GL_NV_geometry_program4 */
    7067. 

  7067. 

  7068. #ifdef GL_NV_geometry_shader4
    7069. 

  7069. 

  7070. #endif /* GL_NV_geometry_shader4 */
    7071. 

  7071. 

  7072. #ifdef GL_NV_gpu_program4
    7073. 

  7073. 

  7074. static GLboolean _glewInit_GL_NV_gpu_program4 (GLEW_CONTEXT_ARG_DEF_INIT)
    7075. 

  7075. {
    7076. 

  7076.   GLboolean r = GL_FALSE;
    7077. 

  7077. 

  7078.   r = ((glProgramEnvParameterI4iNV = (PFNGLPROGRAMENVPARAMETERI4INVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4iNV")) == NULL) || r;
    7079. 

  7079.   r = ((glProgramEnvParameterI4ivNV = (PFNGLPROGRAMENVPARAMETERI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4ivNV")) == NULL) || r;
    7080. 

  7080.   r = ((glProgramEnvParameterI4uiNV = (PFNGLPROGRAMENVPARAMETERI4UINVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4uiNV")) == NULL) || r;
    7081. 

  7081.   r = ((glProgramEnvParameterI4uivNV = (PFNGLPROGRAMENVPARAMETERI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4uivNV")) == NULL) || r;
    7082. 

  7082.   r = ((glProgramEnvParametersI4ivNV = (PFNGLPROGRAMENVPARAMETERSI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParametersI4ivNV")) == NULL) || r;
    7083. 

  7083.   r = ((glProgramEnvParametersI4uivNV = (PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParametersI4uivNV")) == NULL) || r;
    7084. 

  7084.   r = ((glProgramLocalParameterI4iNV = (PFNGLPROGRAMLOCALPARAMETERI4INVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4iNV")) == NULL) || r;
    7085. 

  7085.   r = ((glProgramLocalParameterI4ivNV = (PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4ivNV")) == NULL) || r;
    7086. 

  7086.   r = ((glProgramLocalParameterI4uiNV = (PFNGLPROGRAMLOCALPARAMETERI4UINVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4uiNV")) == NULL) || r;
    7087. 

  7087.   r = ((glProgramLocalParameterI4uivNV = (PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4uivNV")) == NULL) || r;
    7088. 

  7088.   r = ((glProgramLocalParametersI4ivNV = (PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParametersI4ivNV")) == NULL) || r;
    7089. 

  7089.   r = ((glProgramLocalParametersI4uivNV = (PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParametersI4uivNV")) == NULL) || r;
    7090. 

  7090. 

  7091.   return r;
    7092. 

  7092. }
    7093. 

  7093. 

  7094. #endif /* GL_NV_gpu_program4 */
    7095. 

  7095. 

  7096. #ifdef GL_NV_gpu_program5
    7097. 

  7097. 

  7098. #endif /* GL_NV_gpu_program5 */
    7099. 

  7099. 

  7100. #ifdef GL_NV_gpu_program_fp64
    7101. 

  7101. 

  7102. #endif /* GL_NV_gpu_program_fp64 */
    7103. 

  7103. 

  7104. #ifdef GL_NV_gpu_shader5
    7105. 

  7105. 

  7106. static GLboolean _glewInit_GL_NV_gpu_shader5 (GLEW_CONTEXT_ARG_DEF_INIT)
    7107. 

  7107. {
    7108. 

  7108.   GLboolean r = GL_FALSE;
    7109. 

  7109. 

  7110.   r = ((glGetUniformi64vNV = (PFNGLGETUNIFORMI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformi64vNV")) == NULL) || r;
    7111. 

  7111.   r = ((glGetUniformui64vNV = (PFNGLGETUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformui64vNV")) == NULL) || r;
    7112. 

  7112.   r = ((glProgramUniform1i64NV = (PFNGLPROGRAMUNIFORM1I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i64NV")) == NULL) || r;
    7113. 

  7113.   r = ((glProgramUniform1i64vNV = (PFNGLPROGRAMUNIFORM1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1i64vNV")) == NULL) || r;
    7114. 

  7114.   r = ((glProgramUniform1ui64NV = (PFNGLPROGRAMUNIFORM1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui64NV")) == NULL) || r;
    7115. 

  7115.   r = ((glProgramUniform1ui64vNV = (PFNGLPROGRAMUNIFORM1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ui64vNV")) == NULL) || r;
    7116. 

  7116.   r = ((glProgramUniform2i64NV = (PFNGLPROGRAMUNIFORM2I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i64NV")) == NULL) || r;
    7117. 

  7117.   r = ((glProgramUniform2i64vNV = (PFNGLPROGRAMUNIFORM2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2i64vNV")) == NULL) || r;
    7118. 

  7118.   r = ((glProgramUniform2ui64NV = (PFNGLPROGRAMUNIFORM2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui64NV")) == NULL) || r;
    7119. 

  7119.   r = ((glProgramUniform2ui64vNV = (PFNGLPROGRAMUNIFORM2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ui64vNV")) == NULL) || r;
    7120. 

  7120.   r = ((glProgramUniform3i64NV = (PFNGLPROGRAMUNIFORM3I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i64NV")) == NULL) || r;
    7121. 

  7121.   r = ((glProgramUniform3i64vNV = (PFNGLPROGRAMUNIFORM3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3i64vNV")) == NULL) || r;
    7122. 

  7122.   r = ((glProgramUniform3ui64NV = (PFNGLPROGRAMUNIFORM3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui64NV")) == NULL) || r;
    7123. 

  7123.   r = ((glProgramUniform3ui64vNV = (PFNGLPROGRAMUNIFORM3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ui64vNV")) == NULL) || r;
    7124. 

  7124.   r = ((glProgramUniform4i64NV = (PFNGLPROGRAMUNIFORM4I64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i64NV")) == NULL) || r;
    7125. 

  7125.   r = ((glProgramUniform4i64vNV = (PFNGLPROGRAMUNIFORM4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4i64vNV")) == NULL) || r;
    7126. 

  7126.   r = ((glProgramUniform4ui64NV = (PFNGLPROGRAMUNIFORM4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui64NV")) == NULL) || r;
    7127. 

  7127.   r = ((glProgramUniform4ui64vNV = (PFNGLPROGRAMUNIFORM4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ui64vNV")) == NULL) || r;
    7128. 

  7128.   r = ((glUniform1i64NV = (PFNGLUNIFORM1I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform1i64NV")) == NULL) || r;
    7129. 

  7129.   r = ((glUniform1i64vNV = (PFNGLUNIFORM1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform1i64vNV")) == NULL) || r;
    7130. 

  7130.   r = ((glUniform1ui64NV = (PFNGLUNIFORM1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui64NV")) == NULL) || r;
    7131. 

  7131.   r = ((glUniform1ui64vNV = (PFNGLUNIFORM1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui64vNV")) == NULL) || r;
    7132. 

  7132.   r = ((glUniform2i64NV = (PFNGLUNIFORM2I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform2i64NV")) == NULL) || r;
    7133. 

  7133.   r = ((glUniform2i64vNV = (PFNGLUNIFORM2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform2i64vNV")) == NULL) || r;
    7134. 

  7134.   r = ((glUniform2ui64NV = (PFNGLUNIFORM2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui64NV")) == NULL) || r;
    7135. 

  7135.   r = ((glUniform2ui64vNV = (PFNGLUNIFORM2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui64vNV")) == NULL) || r;
    7136. 

  7136.   r = ((glUniform3i64NV = (PFNGLUNIFORM3I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform3i64NV")) == NULL) || r;
    7137. 

  7137.   r = ((glUniform3i64vNV = (PFNGLUNIFORM3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform3i64vNV")) == NULL) || r;
    7138. 

  7138.   r = ((glUniform3ui64NV = (PFNGLUNIFORM3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui64NV")) == NULL) || r;
    7139. 

  7139.   r = ((glUniform3ui64vNV = (PFNGLUNIFORM3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui64vNV")) == NULL) || r;
    7140. 

  7140.   r = ((glUniform4i64NV = (PFNGLUNIFORM4I64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform4i64NV")) == NULL) || r;
    7141. 

  7141.   r = ((glUniform4i64vNV = (PFNGLUNIFORM4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform4i64vNV")) == NULL) || r;
    7142. 

  7142.   r = ((glUniform4ui64NV = (PFNGLUNIFORM4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui64NV")) == NULL) || r;
    7143. 

  7143.   r = ((glUniform4ui64vNV = (PFNGLUNIFORM4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui64vNV")) == NULL) || r;
    7144. 

  7144. 

  7145.   return r;
    7146. 

  7146. }
    7147. 

  7147. 

  7148. #endif /* GL_NV_gpu_shader5 */
    7149. 

  7149. 

  7150. #ifdef GL_NV_half_float
    7151. 

  7151. 

  7152. static GLboolean _glewInit_GL_NV_half_float (GLEW_CONTEXT_ARG_DEF_INIT)
    7153. 

  7153. {
    7154. 

  7154.   GLboolean r = GL_FALSE;
    7155. 

  7155. 

  7156.   r = ((glColor3hNV = (PFNGLCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hNV")) == NULL) || r;
    7157. 

  7157.   r = ((glColor3hvNV = (PFNGLCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hvNV")) == NULL) || r;
    7158. 

  7158.   r = ((glColor4hNV = (PFNGLCOLOR4HNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hNV")) == NULL) || r;
    7159. 

  7159.   r = ((glColor4hvNV = (PFNGLCOLOR4HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hvNV")) == NULL) || r;
    7160. 

  7160.   r = ((glFogCoordhNV = (PFNGLFOGCOORDHNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhNV")) == NULL) || r;
    7161. 

  7161.   r = ((glFogCoordhvNV = (PFNGLFOGCOORDHVNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhvNV")) == NULL) || r;
    7162. 

  7162.   r = ((glMultiTexCoord1hNV = (PFNGLMULTITEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hNV")) == NULL) || r;
    7163. 

  7163.   r = ((glMultiTexCoord1hvNV = (PFNGLMULTITEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hvNV")) == NULL) || r;
    7164. 

  7164.   r = ((glMultiTexCoord2hNV = (PFNGLMULTITEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hNV")) == NULL) || r;
    7165. 

  7165.   r = ((glMultiTexCoord2hvNV = (PFNGLMULTITEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hvNV")) == NULL) || r;
    7166. 

  7166.   r = ((glMultiTexCoord3hNV = (PFNGLMULTITEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hNV")) == NULL) || r;
    7167. 

  7167.   r = ((glMultiTexCoord3hvNV = (PFNGLMULTITEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hvNV")) == NULL) || r;
    7168. 

  7168.   r = ((glMultiTexCoord4hNV = (PFNGLMULTITEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hNV")) == NULL) || r;
    7169. 

  7169.   r = ((glMultiTexCoord4hvNV = (PFNGLMULTITEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hvNV")) == NULL) || r;
    7170. 

  7170.   r = ((glNormal3hNV = (PFNGLNORMAL3HNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hNV")) == NULL) || r;
    7171. 

  7171.   r = ((glNormal3hvNV = (PFNGLNORMAL3HVNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hvNV")) == NULL) || r;
    7172. 

  7172.   r = ((glSecondaryColor3hNV = (PFNGLSECONDARYCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hNV")) == NULL) || r;
    7173. 

  7173.   r = ((glSecondaryColor3hvNV = (PFNGLSECONDARYCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hvNV")) == NULL) || r;
    7174. 

  7174.   r = ((glTexCoord1hNV = (PFNGLTEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hNV")) == NULL) || r;
    7175. 

  7175.   r = ((glTexCoord1hvNV = (PFNGLTEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hvNV")) == NULL) || r;
    7176. 

  7176.   r = ((glTexCoord2hNV = (PFNGLTEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hNV")) == NULL) || r;
    7177. 

  7177.   r = ((glTexCoord2hvNV = (PFNGLTEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hvNV")) == NULL) || r;
    7178. 

  7178.   r = ((glTexCoord3hNV = (PFNGLTEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hNV")) == NULL) || r;
    7179. 

  7179.   r = ((glTexCoord3hvNV = (PFNGLTEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hvNV")) == NULL) || r;
    7180. 

  7180.   r = ((glTexCoord4hNV = (PFNGLTEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hNV")) == NULL) || r;
    7181. 

  7181.   r = ((glTexCoord4hvNV = (PFNGLTEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hvNV")) == NULL) || r;
    7182. 

  7182.   r = ((glVertex2hNV = (PFNGLVERTEX2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hNV")) == NULL) || r;
    7183. 

  7183.   r = ((glVertex2hvNV = (PFNGLVERTEX2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hvNV")) == NULL) || r;
    7184. 

  7184.   r = ((glVertex3hNV = (PFNGLVERTEX3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hNV")) == NULL) || r;
    7185. 

  7185.   r = ((glVertex3hvNV = (PFNGLVERTEX3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hvNV")) == NULL) || r;
    7186. 

  7186.   r = ((glVertex4hNV = (PFNGLVERTEX4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hNV")) == NULL) || r;
    7187. 

  7187.   r = ((glVertex4hvNV = (PFNGLVERTEX4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hvNV")) == NULL) || r;
    7188. 

  7188.   r = ((glVertexAttrib1hNV = (PFNGLVERTEXATTRIB1HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hNV")) == NULL) || r;
    7189. 

  7189.   r = ((glVertexAttrib1hvNV = (PFNGLVERTEXATTRIB1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hvNV")) == NULL) || r;
    7190. 

  7190.   r = ((glVertexAttrib2hNV = (PFNGLVERTEXATTRIB2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hNV")) == NULL) || r;
    7191. 

  7191.   r = ((glVertexAttrib2hvNV = (PFNGLVERTEXATTRIB2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hvNV")) == NULL) || r;
    7192. 

  7192.   r = ((glVertexAttrib3hNV = (PFNGLVERTEXATTRIB3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hNV")) == NULL) || r;
    7193. 

  7193.   r = ((glVertexAttrib3hvNV = (PFNGLVERTEXATTRIB3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hvNV")) == NULL) || r;
    7194. 

  7194.   r = ((glVertexAttrib4hNV = (PFNGLVERTEXATTRIB4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hNV")) == NULL) || r;
    7195. 

  7195.   r = ((glVertexAttrib4hvNV = (PFNGLVERTEXATTRIB4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hvNV")) == NULL) || r;
    7196. 

  7196.   r = ((glVertexAttribs1hvNV = (PFNGLVERTEXATTRIBS1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1hvNV")) == NULL) || r;
    7197. 

  7197.   r = ((glVertexAttribs2hvNV = (PFNGLVERTEXATTRIBS2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2hvNV")) == NULL) || r;
    7198. 

  7198.   r = ((glVertexAttribs3hvNV = (PFNGLVERTEXATTRIBS3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3hvNV")) == NULL) || r;
    7199. 

  7199.   r = ((glVertexAttribs4hvNV = (PFNGLVERTEXATTRIBS4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4hvNV")) == NULL) || r;
    7200. 

  7200.   r = ((glVertexWeighthNV = (PFNGLVERTEXWEIGHTHNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthNV")) == NULL) || r;
    7201. 

  7201.   r = ((glVertexWeighthvNV = (PFNGLVERTEXWEIGHTHVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthvNV")) == NULL) || r;
    7202. 

  7202. 

  7203.   return r;
    7204. 

  7204. }
    7205. 

  7205. 

  7206. #endif /* GL_NV_half_float */
    7207. 

  7207. 

  7208. #ifdef GL_NV_light_max_exponent
    7209. 

  7209. 

  7210. #endif /* GL_NV_light_max_exponent */
    7211. 

  7211. 

  7212. #ifdef GL_NV_multisample_coverage
    7213. 

  7213. 

  7214. #endif /* GL_NV_multisample_coverage */
    7215. 

  7215. 

  7216. #ifdef GL_NV_multisample_filter_hint
    7217. 

  7217. 

  7218. #endif /* GL_NV_multisample_filter_hint */
    7219. 

  7219. 

  7220. #ifdef GL_NV_occlusion_query
    7221. 

  7221. 

  7222. static GLboolean _glewInit_GL_NV_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT)
    7223. 

  7223. {
    7224. 

  7224.   GLboolean r = GL_FALSE;
    7225. 

  7225. 

  7226.   r = ((glBeginOcclusionQueryNV = (PFNGLBEGINOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glBeginOcclusionQueryNV")) == NULL) || r;
    7227. 

  7227.   r = ((glDeleteOcclusionQueriesNV = (PFNGLDELETEOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteOcclusionQueriesNV")) == NULL) || r;
    7228. 

  7228.   r = ((glEndOcclusionQueryNV = (PFNGLENDOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glEndOcclusionQueryNV")) == NULL) || r;
    7229. 

  7229.   r = ((glGenOcclusionQueriesNV = (PFNGLGENOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glGenOcclusionQueriesNV")) == NULL) || r;
    7230. 

  7230.   r = ((glGetOcclusionQueryivNV = (PFNGLGETOCCLUSIONQUERYIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryivNV")) == NULL) || r;
    7231. 

  7231.   r = ((glGetOcclusionQueryuivNV = (PFNGLGETOCCLUSIONQUERYUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryuivNV")) == NULL) || r;
    7232. 

  7232.   r = ((glIsOcclusionQueryNV = (PFNGLISOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glIsOcclusionQueryNV")) == NULL) || r;
    7233. 

  7233. 

  7234.   return r;
    7235. 

  7235. }
    7236. 

  7236. 

  7237. #endif /* GL_NV_occlusion_query */
    7238. 

  7238. 

  7239. #ifdef GL_NV_packed_depth_stencil
    7240. 

  7240. 

  7241. #endif /* GL_NV_packed_depth_stencil */
    7242. 

  7242. 

  7243. #ifdef GL_NV_parameter_buffer_object
    7244. 

  7244. 

  7245. static GLboolean _glewInit_GL_NV_parameter_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT)
    7246. 

  7246. {
    7247. 

  7247.   GLboolean r = GL_FALSE;
    7248. 

  7248. 

  7249.   r = ((glProgramBufferParametersIivNV = (PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersIivNV")) == NULL) || r;
    7250. 

  7250.   r = ((glProgramBufferParametersIuivNV = (PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersIuivNV")) == NULL) || r;
    7251. 

  7251.   r = ((glProgramBufferParametersfvNV = (PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersfvNV")) == NULL) || r;
    7252. 

  7252. 

  7253.   return r;
    7254. 

  7254. }
    7255. 

  7255. 

  7256. #endif /* GL_NV_parameter_buffer_object */
    7257. 

  7257. 

  7258. #ifdef GL_NV_parameter_buffer_object2
    7259. 

  7259. 

  7260. #endif /* GL_NV_parameter_buffer_object2 */
    7261. 

  7261. 

  7262. #ifdef GL_NV_path_rendering
    7263. 

  7263. 

  7264. static GLboolean _glewInit_GL_NV_path_rendering (GLEW_CONTEXT_ARG_DEF_INIT)
    7265. 

  7265. {
    7266. 

  7266.   GLboolean r = GL_FALSE;
    7267. 

  7267. 

  7268.   r = ((glCopyPathNV = (PFNGLCOPYPATHNVPROC)glewGetProcAddress((const GLubyte*)"glCopyPathNV")) == NULL) || r;
    7269. 

  7269.   r = ((glCoverFillPathInstancedNV = (PFNGLCOVERFILLPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glCoverFillPathInstancedNV")) == NULL) || r;
    7270. 

  7270.   r = ((glCoverFillPathNV = (PFNGLCOVERFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glCoverFillPathNV")) == NULL) || r;
    7271. 

  7271.   r = ((glCoverStrokePathInstancedNV = (PFNGLCOVERSTROKEPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glCoverStrokePathInstancedNV")) == NULL) || r;
    7272. 

  7272.   r = ((glCoverStrokePathNV = (PFNGLCOVERSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glCoverStrokePathNV")) == NULL) || r;
    7273. 

  7273.   r = ((glDeletePathsNV = (PFNGLDELETEPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glDeletePathsNV")) == NULL) || r;
    7274. 

  7274.   r = ((glGenPathsNV = (PFNGLGENPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glGenPathsNV")) == NULL) || r;
    7275. 

  7275.   r = ((glGetPathColorGenfvNV = (PFNGLGETPATHCOLORGENFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathColorGenfvNV")) == NULL) || r;
    7276. 

  7276.   r = ((glGetPathColorGenivNV = (PFNGLGETPATHCOLORGENIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathColorGenivNV")) == NULL) || r;
    7277. 

  7277.   r = ((glGetPathCommandsNV = (PFNGLGETPATHCOMMANDSNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathCommandsNV")) == NULL) || r;
    7278. 

  7278.   r = ((glGetPathCoordsNV = (PFNGLGETPATHCOORDSNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathCoordsNV")) == NULL) || r;
    7279. 

  7279.   r = ((glGetPathDashArrayNV = (PFNGLGETPATHDASHARRAYNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathDashArrayNV")) == NULL) || r;
    7280. 

  7280.   r = ((glGetPathLengthNV = (PFNGLGETPATHLENGTHNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathLengthNV")) == NULL) || r;
    7281. 

  7281.   r = ((glGetPathMetricRangeNV = (PFNGLGETPATHMETRICRANGENVPROC)glewGetProcAddress((const GLubyte*)"glGetPathMetricRangeNV")) == NULL) || r;
    7282. 

  7282.   r = ((glGetPathMetricsNV = (PFNGLGETPATHMETRICSNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathMetricsNV")) == NULL) || r;
    7283. 

  7283.   r = ((glGetPathParameterfvNV = (PFNGLGETPATHPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathParameterfvNV")) == NULL) || r;
    7284. 

  7284.   r = ((glGetPathParameterivNV = (PFNGLGETPATHPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathParameterivNV")) == NULL) || r;
    7285. 

  7285.   r = ((glGetPathSpacingNV = (PFNGLGETPATHSPACINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathSpacingNV")) == NULL) || r;
    7286. 

  7286.   r = ((glGetPathTexGenfvNV = (PFNGLGETPATHTEXGENFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathTexGenfvNV")) == NULL) || r;
    7287. 

  7287.   r = ((glGetPathTexGenivNV = (PFNGLGETPATHTEXGENIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetPathTexGenivNV")) == NULL) || r;
    7288. 

  7288.   r = ((glInterpolatePathsNV = (PFNGLINTERPOLATEPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glInterpolatePathsNV")) == NULL) || r;
    7289. 

  7289.   r = ((glIsPathNV = (PFNGLISPATHNVPROC)glewGetProcAddress((const GLubyte*)"glIsPathNV")) == NULL) || r;
    7290. 

  7290.   r = ((glIsPointInFillPathNV = (PFNGLISPOINTINFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glIsPointInFillPathNV")) == NULL) || r;
    7291. 

  7291.   r = ((glIsPointInStrokePathNV = (PFNGLISPOINTINSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glIsPointInStrokePathNV")) == NULL) || r;
    7292. 

  7292.   r = ((glPathColorGenNV = (PFNGLPATHCOLORGENNVPROC)glewGetProcAddress((const GLubyte*)"glPathColorGenNV")) == NULL) || r;
    7293. 

  7293.   r = ((glPathCommandsNV = (PFNGLPATHCOMMANDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathCommandsNV")) == NULL) || r;
    7294. 

  7294.   r = ((glPathCoordsNV = (PFNGLPATHCOORDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathCoordsNV")) == NULL) || r;
    7295. 

  7295.   r = ((glPathCoverDepthFuncNV = (PFNGLPATHCOVERDEPTHFUNCNVPROC)glewGetProcAddress((const GLubyte*)"glPathCoverDepthFuncNV")) == NULL) || r;
    7296. 

  7296.   r = ((glPathDashArrayNV = (PFNGLPATHDASHARRAYNVPROC)glewGetProcAddress((const GLubyte*)"glPathDashArrayNV")) == NULL) || r;
    7297. 

  7297.   r = ((glPathFogGenNV = (PFNGLPATHFOGGENNVPROC)glewGetProcAddress((const GLubyte*)"glPathFogGenNV")) == NULL) || r;
    7298. 

  7298.   r = ((glPathGlyphRangeNV = (PFNGLPATHGLYPHRANGENVPROC)glewGetProcAddress((const GLubyte*)"glPathGlyphRangeNV")) == NULL) || r;
    7299. 

  7299.   r = ((glPathGlyphsNV = (PFNGLPATHGLYPHSNVPROC)glewGetProcAddress((const GLubyte*)"glPathGlyphsNV")) == NULL) || r;
    7300. 

  7300.   r = ((glPathParameterfNV = (PFNGLPATHPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glPathParameterfNV")) == NULL) || r;
    7301. 

  7301.   r = ((glPathParameterfvNV = (PFNGLPATHPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glPathParameterfvNV")) == NULL) || r;
    7302. 

  7302.   r = ((glPathParameteriNV = (PFNGLPATHPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glPathParameteriNV")) == NULL) || r;
    7303. 

  7303.   r = ((glPathParameterivNV = (PFNGLPATHPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glPathParameterivNV")) == NULL) || r;
    7304. 

  7304.   r = ((glPathStencilDepthOffsetNV = (PFNGLPATHSTENCILDEPTHOFFSETNVPROC)glewGetProcAddress((const GLubyte*)"glPathStencilDepthOffsetNV")) == NULL) || r;
    7305. 

  7305.   r = ((glPathStencilFuncNV = (PFNGLPATHSTENCILFUNCNVPROC)glewGetProcAddress((const GLubyte*)"glPathStencilFuncNV")) == NULL) || r;
    7306. 

  7306.   r = ((glPathStringNV = (PFNGLPATHSTRINGNVPROC)glewGetProcAddress((const GLubyte*)"glPathStringNV")) == NULL) || r;
    7307. 

  7307.   r = ((glPathSubCommandsNV = (PFNGLPATHSUBCOMMANDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathSubCommandsNV")) == NULL) || r;
    7308. 

  7308.   r = ((glPathSubCoordsNV = (PFNGLPATHSUBCOORDSNVPROC)glewGetProcAddress((const GLubyte*)"glPathSubCoordsNV")) == NULL) || r;
    7309. 

  7309.   r = ((glPathTexGenNV = (PFNGLPATHTEXGENNVPROC)glewGetProcAddress((const GLubyte*)"glPathTexGenNV")) == NULL) || r;
    7310. 

  7310.   r = ((glPointAlongPathNV = (PFNGLPOINTALONGPATHNVPROC)glewGetProcAddress((const GLubyte*)"glPointAlongPathNV")) == NULL) || r;
    7311. 

  7311.   r = ((glStencilFillPathInstancedNV = (PFNGLSTENCILFILLPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glStencilFillPathInstancedNV")) == NULL) || r;
    7312. 

  7312.   r = ((glStencilFillPathNV = (PFNGLSTENCILFILLPATHNVPROC)glewGetProcAddress((const GLubyte*)"glStencilFillPathNV")) == NULL) || r;
    7313. 

  7313.   r = ((glStencilStrokePathInstancedNV = (PFNGLSTENCILSTROKEPATHINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glStencilStrokePathInstancedNV")) == NULL) || r;
    7314. 

  7314.   r = ((glStencilStrokePathNV = (PFNGLSTENCILSTROKEPATHNVPROC)glewGetProcAddress((const GLubyte*)"glStencilStrokePathNV")) == NULL) || r;
    7315. 

  7315.   r = ((glTransformPathNV = (PFNGLTRANSFORMPATHNVPROC)glewGetProcAddress((const GLubyte*)"glTransformPathNV")) == NULL) || r;
    7316. 

  7316.   r = ((glWeightPathsNV = (PFNGLWEIGHTPATHSNVPROC)glewGetProcAddress((const GLubyte*)"glWeightPathsNV")) == NULL) || r;
    7317. 

  7317. 

  7318.   return r;
    7319. 

  7319. }
    7320. 

  7320. 

  7321. #endif /* GL_NV_path_rendering */
    7322. 

  7322. 

  7323. #ifdef GL_NV_pixel_data_range
    7324. 

  7324. 

  7325. static GLboolean _glewInit_GL_NV_pixel_data_range (GLEW_CONTEXT_ARG_DEF_INIT)
    7326. 

  7326. {
    7327. 

  7327.   GLboolean r = GL_FALSE;
    7328. 

  7328. 

  7329.   r = ((glFlushPixelDataRangeNV = (PFNGLFLUSHPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushPixelDataRangeNV")) == NULL) || r;
    7330. 

  7330.   r = ((glPixelDataRangeNV = (PFNGLPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glPixelDataRangeNV")) == NULL) || r;
    7331. 

  7331. 

  7332.   return r;
    7333. 

  7333. }
    7334. 

  7334. 

  7335. #endif /* GL_NV_pixel_data_range */
    7336. 

  7336. 

  7337. #ifdef GL_NV_point_sprite
    7338. 

  7338. 

  7339. static GLboolean _glewInit_GL_NV_point_sprite (GLEW_CONTEXT_ARG_DEF_INIT)
    7340. 

  7340. {
    7341. 

  7341.   GLboolean r = GL_FALSE;
    7342. 

  7342. 

  7343.   r = ((glPointParameteriNV = (PFNGLPOINTPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glPointParameteriNV")) == NULL) || r;
    7344. 

  7344.   r = ((glPointParameterivNV = (PFNGLPOINTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterivNV")) == NULL) || r;
    7345. 

  7345. 

  7346.   return r;
    7347. 

  7347. }
    7348. 

  7348. 

  7349. #endif /* GL_NV_point_sprite */
    7350. 

  7350. 

  7351. #ifdef GL_NV_present_video
    7352. 

  7352. 

  7353. static GLboolean _glewInit_GL_NV_present_video (GLEW_CONTEXT_ARG_DEF_INIT)
    7354. 

  7354. {
    7355. 

  7355.   GLboolean r = GL_FALSE;
    7356. 

  7356. 

  7357.   r = ((glGetVideoi64vNV = (PFNGLGETVIDEOI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoi64vNV")) == NULL) || r;
    7358. 

  7358.   r = ((glGetVideoivNV = (PFNGLGETVIDEOIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoivNV")) == NULL) || r;
    7359. 

  7359.   r = ((glGetVideoui64vNV = (PFNGLGETVIDEOUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoui64vNV")) == NULL) || r;
    7360. 

  7360.   r = ((glGetVideouivNV = (PFNGLGETVIDEOUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideouivNV")) == NULL) || r;
    7361. 

  7361.   r = ((glPresentFrameDualFillNV = (PFNGLPRESENTFRAMEDUALFILLNVPROC)glewGetProcAddress((const GLubyte*)"glPresentFrameDualFillNV")) == NULL) || r;
    7362. 

  7362.   r = ((glPresentFrameKeyedNV = (PFNGLPRESENTFRAMEKEYEDNVPROC)glewGetProcAddress((const GLubyte*)"glPresentFrameKeyedNV")) == NULL) || r;
    7363. 

  7363. 

  7364.   return r;
    7365. 

  7365. }
    7366. 

  7366. 

  7367. #endif /* GL_NV_present_video */
    7368. 

  7368. 

  7369. #ifdef GL_NV_primitive_restart
    7370. 

  7370. 

  7371. static GLboolean _glewInit_GL_NV_primitive_restart (GLEW_CONTEXT_ARG_DEF_INIT)
    7372. 

  7372. {
    7373. 

  7373.   GLboolean r = GL_FALSE;
    7374. 

  7374. 

  7375.   r = ((glPrimitiveRestartIndexNV = (PFNGLPRIMITIVERESTARTINDEXNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartIndexNV")) == NULL) || r;
    7376. 

  7376.   r = ((glPrimitiveRestartNV = (PFNGLPRIMITIVERESTARTNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartNV")) == NULL) || r;
    7377. 

  7377. 

  7378.   return r;
    7379. 

  7379. }
    7380. 

  7380. 

  7381. #endif /* GL_NV_primitive_restart */
    7382. 

  7382. 

  7383. #ifdef GL_NV_register_combiners
    7384. 

  7384. 

  7385. static GLboolean _glewInit_GL_NV_register_combiners (GLEW_CONTEXT_ARG_DEF_INIT)
    7386. 

  7386. {
    7387. 

  7387.   GLboolean r = GL_FALSE;
    7388. 

  7388. 

  7389.   r = ((glCombinerInputNV = (PFNGLCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerInputNV")) == NULL) || r;
    7390. 

  7390.   r = ((glCombinerOutputNV = (PFNGLCOMBINEROUTPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerOutputNV")) == NULL) || r;
    7391. 

  7391.   r = ((glCombinerParameterfNV = (PFNGLCOMBINERPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfNV")) == NULL) || r;
    7392. 

  7392.   r = ((glCombinerParameterfvNV = (PFNGLCOMBINERPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfvNV")) == NULL) || r;
    7393. 

  7393.   r = ((glCombinerParameteriNV = (PFNGLCOMBINERPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameteriNV")) == NULL) || r;
    7394. 

  7394.   r = ((glCombinerParameterivNV = (PFNGLCOMBINERPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterivNV")) == NULL) || r;
    7395. 

  7395.   r = ((glFinalCombinerInputNV = (PFNGLFINALCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glFinalCombinerInputNV")) == NULL) || r;
    7396. 

  7396.   r = ((glGetCombinerInputParameterfvNV = (PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterfvNV")) == NULL) || r;
    7397. 

  7397.   r = ((glGetCombinerInputParameterivNV = (PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterivNV")) == NULL) || r;
    7398. 

  7398.   r = ((glGetCombinerOutputParameterfvNV = (PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterfvNV")) == NULL) || r;
    7399. 

  7399.   r = ((glGetCombinerOutputParameterivNV = (PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterivNV")) == NULL) || r;
    7400. 

  7400.   r = ((glGetFinalCombinerInputParameterfvNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterfvNV")) == NULL) || r;
    7401. 

  7401.   r = ((glGetFinalCombinerInputParameterivNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterivNV")) == NULL) || r;
    7402. 

  7402. 

  7403.   return r;
    7404. 

  7404. }
    7405. 

  7405. 

  7406. #endif /* GL_NV_register_combiners */
    7407. 

  7407. 

  7408. #ifdef GL_NV_register_combiners2
    7409. 

  7409. 

  7410. static GLboolean _glewInit_GL_NV_register_combiners2 (GLEW_CONTEXT_ARG_DEF_INIT)
    7411. 

  7411. {
    7412. 

  7412.   GLboolean r = GL_FALSE;
    7413. 

  7413. 

  7414.   r = ((glCombinerStageParameterfvNV = (PFNGLCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerStageParameterfvNV")) == NULL) || r;
    7415. 

  7415.   r = ((glGetCombinerStageParameterfvNV = (PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerStageParameterfvNV")) == NULL) || r;
    7416. 

  7416. 

  7417.   return r;
    7418. 

  7418. }
    7419. 

  7419. 

  7420. #endif /* GL_NV_register_combiners2 */
    7421. 

  7421. 

  7422. #ifdef GL_NV_shader_buffer_load
    7423. 

  7423. 

  7424. static GLboolean _glewInit_GL_NV_shader_buffer_load (GLEW_CONTEXT_ARG_DEF_INIT)
    7425. 

  7425. {
    7426. 

  7426.   GLboolean r = GL_FALSE;
    7427. 

  7427. 

  7428.   r = ((glGetBufferParameterui64vNV = (PFNGLGETBUFFERPARAMETERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameterui64vNV")) == NULL) || r;
    7429. 

  7429.   r = ((glGetIntegerui64vNV = (PFNGLGETINTEGERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerui64vNV")) == NULL) || r;
    7430. 

  7430.   r = ((glGetNamedBufferParameterui64vNV = (PFNGLGETNAMEDBUFFERPARAMETERUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferParameterui64vNV")) == NULL) || r;
    7431. 

  7431.   r = ((glIsBufferResidentNV = (PFNGLISBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsBufferResidentNV")) == NULL) || r;
    7432. 

  7432.   r = ((glIsNamedBufferResidentNV = (PFNGLISNAMEDBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glIsNamedBufferResidentNV")) == NULL) || r;
    7433. 

  7433.   r = ((glMakeBufferNonResidentNV = (PFNGLMAKEBUFFERNONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeBufferNonResidentNV")) == NULL) || r;
    7434. 

  7434.   r = ((glMakeBufferResidentNV = (PFNGLMAKEBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeBufferResidentNV")) == NULL) || r;
    7435. 

  7435.   r = ((glMakeNamedBufferNonResidentNV = (PFNGLMAKENAMEDBUFFERNONRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeNamedBufferNonResidentNV")) == NULL) || r;
    7436. 

  7436.   r = ((glMakeNamedBufferResidentNV = (PFNGLMAKENAMEDBUFFERRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glMakeNamedBufferResidentNV")) == NULL) || r;
    7437. 

  7437.   r = ((glProgramUniformui64NV = (PFNGLPROGRAMUNIFORMUI64NVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformui64NV")) == NULL) || r;
    7438. 

  7438.   r = ((glProgramUniformui64vNV = (PFNGLPROGRAMUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformui64vNV")) == NULL) || r;
    7439. 

  7439.   r = ((glUniformui64NV = (PFNGLUNIFORMUI64NVPROC)glewGetProcAddress((const GLubyte*)"glUniformui64NV")) == NULL) || r;
    7440. 

  7440.   r = ((glUniformui64vNV = (PFNGLUNIFORMUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glUniformui64vNV")) == NULL) || r;
    7441. 

  7441. 

  7442.   return r;
    7443. 

  7443. }
    7444. 

  7444. 

  7445. #endif /* GL_NV_shader_buffer_load */
    7446. 

  7446. 

  7447. #ifdef GL_NV_tessellation_program5
    7448. 

  7448. 

  7449. #endif /* GL_NV_tessellation_program5 */
    7450. 

  7450. 

  7451. #ifdef GL_NV_texgen_emboss
    7452. 

  7452. 

  7453. #endif /* GL_NV_texgen_emboss */
    7454. 

  7454. 

  7455. #ifdef GL_NV_texgen_reflection
    7456. 

  7456. 

  7457. #endif /* GL_NV_texgen_reflection */
    7458. 

  7458. 

  7459. #ifdef GL_NV_texture_barrier
    7460. 

  7460. 

  7461. static GLboolean _glewInit_GL_NV_texture_barrier (GLEW_CONTEXT_ARG_DEF_INIT)
    7462. 

  7462. {
    7463. 

  7463.   GLboolean r = GL_FALSE;
    7464. 

  7464. 

  7465.   r = ((glTextureBarrierNV = (PFNGLTEXTUREBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glTextureBarrierNV")) == NULL) || r;
    7466. 

  7466. 

  7467.   return r;
    7468. 

  7468. }
    7469. 

  7469. 

  7470. #endif /* GL_NV_texture_barrier */
    7471. 

  7471. 

  7472. #ifdef GL_NV_texture_compression_vtc
    7473. 

  7473. 

  7474. #endif /* GL_NV_texture_compression_vtc */
    7475. 

  7475. 

  7476. #ifdef GL_NV_texture_env_combine4
    7477. 

  7477. 

  7478. #endif /* GL_NV_texture_env_combine4 */
    7479. 

  7479. 

  7480. #ifdef GL_NV_texture_expand_normal
    7481. 

  7481. 

  7482. #endif /* GL_NV_texture_expand_normal */
    7483. 

  7483. 

  7484. #ifdef GL_NV_texture_multisample
    7485. 

  7485. 

  7486. static GLboolean _glewInit_GL_NV_texture_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
    7487. 

  7487. {
    7488. 

  7488.   GLboolean r = GL_FALSE;
    7489. 

  7489. 

  7490.   r = ((glTexImage2DMultisampleCoverageNV = (PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTexImage2DMultisampleCoverageNV")) == NULL) || r;
    7491. 

  7491.   r = ((glTexImage3DMultisampleCoverageNV = (PFNGLTEXIMAGE3DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DMultisampleCoverageNV")) == NULL) || r;
    7492. 

  7492.   r = ((glTextureImage2DMultisampleCoverageNV = (PFNGLTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DMultisampleCoverageNV")) == NULL) || r;
    7493. 

  7493.   r = ((glTextureImage2DMultisampleNV = (PFNGLTEXTUREIMAGE2DMULTISAMPLENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DMultisampleNV")) == NULL) || r;
    7494. 

  7494.   r = ((glTextureImage3DMultisampleCoverageNV = (PFNGLTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DMultisampleCoverageNV")) == NULL) || r;
    7495. 

  7495.   r = ((glTextureImage3DMultisampleNV = (PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DMultisampleNV")) == NULL) || r;
    7496. 

  7496. 

  7497.   return r;
    7498. 

  7498. }
    7499. 

  7499. 

  7500. #endif /* GL_NV_texture_multisample */
    7501. 

  7501. 

  7502. #ifdef GL_NV_texture_rectangle
    7503. 

  7503. 

  7504. #endif /* GL_NV_texture_rectangle */
    7505. 

  7505. 

  7506. #ifdef GL_NV_texture_shader
    7507. 

  7507. 

  7508. #endif /* GL_NV_texture_shader */
    7509. 

  7509. 

  7510. #ifdef GL_NV_texture_shader2
    7511. 

  7511. 

  7512. #endif /* GL_NV_texture_shader2 */
    7513. 

  7513. 

  7514. #ifdef GL_NV_texture_shader3
    7515. 

  7515. 

  7516. #endif /* GL_NV_texture_shader3 */
    7517. 

  7517. 

  7518. #ifdef GL_NV_transform_feedback
    7519. 

  7519. 

  7520. static GLboolean _glewInit_GL_NV_transform_feedback (GLEW_CONTEXT_ARG_DEF_INIT)
    7521. 

  7521. {
    7522. 

  7522.   GLboolean r = GL_FALSE;
    7523. 

  7523. 

  7524.   r = ((glActiveVaryingNV = (PFNGLACTIVEVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glActiveVaryingNV")) == NULL) || r;
    7525. 

  7525.   r = ((glBeginTransformFeedbackNV = (PFNGLBEGINTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedbackNV")) == NULL) || r;
    7526. 

  7526.   r = ((glBindBufferBaseNV = (PFNGLBINDBUFFERBASENVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBaseNV")) == NULL) || r;
    7527. 

  7527.   r = ((glBindBufferOffsetNV = (PFNGLBINDBUFFEROFFSETNVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferOffsetNV")) == NULL) || r;
    7528. 

  7528.   r = ((glBindBufferRangeNV = (PFNGLBINDBUFFERRANGENVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRangeNV")) == NULL) || r;
    7529. 

  7529.   r = ((glEndTransformFeedbackNV = (PFNGLENDTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedbackNV")) == NULL) || r;
    7530. 

  7530.   r = ((glGetActiveVaryingNV = (PFNGLGETACTIVEVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveVaryingNV")) == NULL) || r;
    7531. 

  7531.   r = ((glGetTransformFeedbackVaryingNV = (PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVaryingNV")) == NULL) || r;
    7532. 

  7532.   r = ((glGetVaryingLocationNV = (PFNGLGETVARYINGLOCATIONNVPROC)glewGetProcAddress((const GLubyte*)"glGetVaryingLocationNV")) == NULL) || r;
    7533. 

  7533.   r = ((glTransformFeedbackAttribsNV = (PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackAttribsNV")) == NULL) || r;
    7534. 

  7534.   r = ((glTransformFeedbackVaryingsNV = (PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryingsNV")) == NULL) || r;
    7535. 

  7535. 

  7536.   return r;
    7537. 

  7537. }
    7538. 

  7538. 

  7539. #endif /* GL_NV_transform_feedback */
    7540. 

  7540. 

  7541. #ifdef GL_NV_transform_feedback2
    7542. 

  7542. 

  7543. static GLboolean _glewInit_GL_NV_transform_feedback2 (GLEW_CONTEXT_ARG_DEF_INIT)
    7544. 

  7544. {
    7545. 

  7545.   GLboolean r = GL_FALSE;
    7546. 

  7546. 

  7547.   r = ((glBindTransformFeedbackNV = (PFNGLBINDTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glBindTransformFeedbackNV")) == NULL) || r;
    7548. 

  7548.   r = ((glDeleteTransformFeedbacksNV = (PFNGLDELETETRANSFORMFEEDBACKSNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteTransformFeedbacksNV")) == NULL) || r;
    7549. 

  7549.   r = ((glDrawTransformFeedbackNV = (PFNGLDRAWTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackNV")) == NULL) || r;
    7550. 

  7550.   r = ((glGenTransformFeedbacksNV = (PFNGLGENTRANSFORMFEEDBACKSNVPROC)glewGetProcAddress((const GLubyte*)"glGenTransformFeedbacksNV")) == NULL) || r;
    7551. 

  7551.   r = ((glIsTransformFeedbackNV = (PFNGLISTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glIsTransformFeedbackNV")) == NULL) || r;
    7552. 

  7552.   r = ((glPauseTransformFeedbackNV = (PFNGLPAUSETRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glPauseTransformFeedbackNV")) == NULL) || r;
    7553. 

  7553.   r = ((glResumeTransformFeedbackNV = (PFNGLRESUMETRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glResumeTransformFeedbackNV")) == NULL) || r;
    7554. 

  7554. 

  7555.   return r;
    7556. 

  7556. }
    7557. 

  7557. 

  7558. #endif /* GL_NV_transform_feedback2 */
    7559. 

  7559. 

  7560. #ifdef GL_NV_vdpau_interop
    7561. 

  7561. 

  7562. static GLboolean _glewInit_GL_NV_vdpau_interop (GLEW_CONTEXT_ARG_DEF_INIT)
    7563. 

  7563. {
    7564. 

  7564.   GLboolean r = GL_FALSE;
    7565. 

  7565. 

  7566.   r = ((glVDPAUFiniNV = (PFNGLVDPAUFININVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUFiniNV")) == NULL) || r;
    7567. 

  7567.   r = ((glVDPAUGetSurfaceivNV = (PFNGLVDPAUGETSURFACEIVNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUGetSurfaceivNV")) == NULL) || r;
    7568. 

  7568.   r = ((glVDPAUInitNV = (PFNGLVDPAUINITNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUInitNV")) == NULL) || r;
    7569. 

  7569.   r = ((glVDPAUIsSurfaceNV = (PFNGLVDPAUISSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUIsSurfaceNV")) == NULL) || r;
    7570. 

  7570.   r = ((glVDPAUMapSurfacesNV = (PFNGLVDPAUMAPSURFACESNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUMapSurfacesNV")) == NULL) || r;
    7571. 

  7571.   r = ((glVDPAURegisterOutputSurfaceNV = (PFNGLVDPAUREGISTEROUTPUTSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAURegisterOutputSurfaceNV")) == NULL) || r;
    7572. 

  7572.   r = ((glVDPAURegisterVideoSurfaceNV = (PFNGLVDPAUREGISTERVIDEOSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAURegisterVideoSurfaceNV")) == NULL) || r;
    7573. 

  7573.   r = ((glVDPAUSurfaceAccessNV = (PFNGLVDPAUSURFACEACCESSNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUSurfaceAccessNV")) == NULL) || r;
    7574. 

  7574.   r = ((glVDPAUUnmapSurfacesNV = (PFNGLVDPAUUNMAPSURFACESNVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUUnmapSurfacesNV")) == NULL) || r;
    7575. 

  7575.   r = ((glVDPAUUnregisterSurfaceNV = (PFNGLVDPAUUNREGISTERSURFACENVPROC)glewGetProcAddress((const GLubyte*)"glVDPAUUnregisterSurfaceNV")) == NULL) || r;
    7576. 

  7576. 

  7577.   return r;
    7578. 

  7578. }
    7579. 

  7579. 

  7580. #endif /* GL_NV_vdpau_interop */
    7581. 

  7581. 

  7582. #ifdef GL_NV_vertex_array_range
    7583. 

  7583. 

  7584. static GLboolean _glewInit_GL_NV_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT)
    7585. 

  7585. {
    7586. 

  7586.   GLboolean r = GL_FALSE;
    7587. 

  7587. 

  7588.   r = ((glFlushVertexArrayRangeNV = (PFNGLFLUSHVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushVertexArrayRangeNV")) == NULL) || r;
    7589. 

  7589.   r = ((glVertexArrayRangeNV = (PFNGLVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayRangeNV")) == NULL) || r;
    7590. 

  7590. 

  7591.   return r;
    7592. 

  7592. }
    7593. 

  7593. 

  7594. #endif /* GL_NV_vertex_array_range */
    7595. 

  7595. 

  7596. #ifdef GL_NV_vertex_array_range2
    7597. 

  7597. 

  7598. #endif /* GL_NV_vertex_array_range2 */
    7599. 

  7599. 

  7600. #ifdef GL_NV_vertex_attrib_integer_64bit
    7601. 

  7601. 

  7602. static GLboolean _glewInit_GL_NV_vertex_attrib_integer_64bit (GLEW_CONTEXT_ARG_DEF_INIT)
    7603. 

  7603. {
    7604. 

  7604.   GLboolean r = GL_FALSE;
    7605. 

  7605. 

  7606.   r = ((glGetVertexAttribLi64vNV = (PFNGLGETVERTEXATTRIBLI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLi64vNV")) == NULL) || r;
    7607. 

  7607.   r = ((glGetVertexAttribLui64vNV = (PFNGLGETVERTEXATTRIBLUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribLui64vNV")) == NULL) || r;
    7608. 

  7608.   r = ((glVertexAttribL1i64NV = (PFNGLVERTEXATTRIBL1I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1i64NV")) == NULL) || r;
    7609. 

  7609.   r = ((glVertexAttribL1i64vNV = (PFNGLVERTEXATTRIBL1I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1i64vNV")) == NULL) || r;
    7610. 

  7610.   r = ((glVertexAttribL1ui64NV = (PFNGLVERTEXATTRIBL1UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64NV")) == NULL) || r;
    7611. 

  7611.   r = ((glVertexAttribL1ui64vNV = (PFNGLVERTEXATTRIBL1UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL1ui64vNV")) == NULL) || r;
    7612. 

  7612.   r = ((glVertexAttribL2i64NV = (PFNGLVERTEXATTRIBL2I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2i64NV")) == NULL) || r;
    7613. 

  7613.   r = ((glVertexAttribL2i64vNV = (PFNGLVERTEXATTRIBL2I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2i64vNV")) == NULL) || r;
    7614. 

  7614.   r = ((glVertexAttribL2ui64NV = (PFNGLVERTEXATTRIBL2UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2ui64NV")) == NULL) || r;
    7615. 

  7615.   r = ((glVertexAttribL2ui64vNV = (PFNGLVERTEXATTRIBL2UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL2ui64vNV")) == NULL) || r;
    7616. 

  7616.   r = ((glVertexAttribL3i64NV = (PFNGLVERTEXATTRIBL3I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3i64NV")) == NULL) || r;
    7617. 

  7617.   r = ((glVertexAttribL3i64vNV = (PFNGLVERTEXATTRIBL3I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3i64vNV")) == NULL) || r;
    7618. 

  7618.   r = ((glVertexAttribL3ui64NV = (PFNGLVERTEXATTRIBL3UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3ui64NV")) == NULL) || r;
    7619. 

  7619.   r = ((glVertexAttribL3ui64vNV = (PFNGLVERTEXATTRIBL3UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL3ui64vNV")) == NULL) || r;
    7620. 

  7620.   r = ((glVertexAttribL4i64NV = (PFNGLVERTEXATTRIBL4I64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4i64NV")) == NULL) || r;
    7621. 

  7621.   r = ((glVertexAttribL4i64vNV = (PFNGLVERTEXATTRIBL4I64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4i64vNV")) == NULL) || r;
    7622. 

  7622.   r = ((glVertexAttribL4ui64NV = (PFNGLVERTEXATTRIBL4UI64NVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4ui64NV")) == NULL) || r;
    7623. 

  7623.   r = ((glVertexAttribL4ui64vNV = (PFNGLVERTEXATTRIBL4UI64VNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribL4ui64vNV")) == NULL) || r;
    7624. 

  7624.   r = ((glVertexAttribLFormatNV = (PFNGLVERTEXATTRIBLFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribLFormatNV")) == NULL) || r;
    7625. 

  7625. 

  7626.   return r;
    7627. 

  7627. }
    7628. 

  7628. 

  7629. #endif /* GL_NV_vertex_attrib_integer_64bit */
    7630. 

  7630. 

  7631. #ifdef GL_NV_vertex_buffer_unified_memory
    7632. 

  7632. 

  7633. static GLboolean _glewInit_GL_NV_vertex_buffer_unified_memory (GLEW_CONTEXT_ARG_DEF_INIT)
    7634. 

  7634. {
    7635. 

  7635.   GLboolean r = GL_FALSE;
    7636. 

  7636. 

  7637.   r = ((glBufferAddressRangeNV = (PFNGLBUFFERADDRESSRANGENVPROC)glewGetProcAddress((const GLubyte*)"glBufferAddressRangeNV")) == NULL) || r;
    7638. 

  7638.   r = ((glColorFormatNV = (PFNGLCOLORFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glColorFormatNV")) == NULL) || r;
    7639. 

  7639.   r = ((glEdgeFlagFormatNV = (PFNGLEDGEFLAGFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagFormatNV")) == NULL) || r;
    7640. 

  7640.   r = ((glFogCoordFormatNV = (PFNGLFOGCOORDFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordFormatNV")) == NULL) || r;
    7641. 

  7641.   r = ((glGetIntegerui64i_vNV = (PFNGLGETINTEGERUI64I_VNVPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerui64i_vNV")) == NULL) || r;
    7642. 

  7642.   r = ((glIndexFormatNV = (PFNGLINDEXFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glIndexFormatNV")) == NULL) || r;
    7643. 

  7643.   r = ((glNormalFormatNV = (PFNGLNORMALFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glNormalFormatNV")) == NULL) || r;
    7644. 

  7644.   r = ((glSecondaryColorFormatNV = (PFNGLSECONDARYCOLORFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorFormatNV")) == NULL) || r;
    7645. 

  7645.   r = ((glTexCoordFormatNV = (PFNGLTEXCOORDFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoordFormatNV")) == NULL) || r;
    7646. 

  7646.   r = ((glVertexAttribFormatNV = (PFNGLVERTEXATTRIBFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribFormatNV")) == NULL) || r;
    7647. 

  7647.   r = ((glVertexAttribIFormatNV = (PFNGLVERTEXATTRIBIFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIFormatNV")) == NULL) || r;
    7648. 

  7648.   r = ((glVertexFormatNV = (PFNGLVERTEXFORMATNVPROC)glewGetProcAddress((const GLubyte*)"glVertexFormatNV")) == NULL) || r;
    7649. 

  7649. 

  7650.   return r;
    7651. 

  7651. }
    7652. 

  7652. 

  7653. #endif /* GL_NV_vertex_buffer_unified_memory */
    7654. 

  7654. 

  7655. #ifdef GL_NV_vertex_program
    7656. 

  7656. 

  7657. static GLboolean _glewInit_GL_NV_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT)
    7658. 

  7658. {
    7659. 

  7659.   GLboolean r = GL_FALSE;
    7660. 

  7660. 

  7661.   r = ((glAreProgramsResidentNV = (PFNGLAREPROGRAMSRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glAreProgramsResidentNV")) == NULL) || r;
    7662. 

  7662.   r = ((glBindProgramNV = (PFNGLBINDPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glBindProgramNV")) == NULL) || r;
    7663. 

  7663.   r = ((glDeleteProgramsNV = (PFNGLDELETEPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsNV")) == NULL) || r;
    7664. 

  7664.   r = ((glExecuteProgramNV = (PFNGLEXECUTEPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glExecuteProgramNV")) == NULL) || r;
    7665. 

  7665.   r = ((glGenProgramsNV = (PFNGLGENPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsNV")) == NULL) || r;
    7666. 

  7666.   r = ((glGetProgramParameterdvNV = (PFNGLGETPROGRAMPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterdvNV")) == NULL) || r;
    7667. 

  7667.   r = ((glGetProgramParameterfvNV = (PFNGLGETPROGRAMPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterfvNV")) == NULL) || r;
    7668. 

  7668.   r = ((glGetProgramStringNV = (PFNGLGETPROGRAMSTRINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringNV")) == NULL) || r;
    7669. 

  7669.   r = ((glGetProgramivNV = (PFNGLGETPROGRAMIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivNV")) == NULL) || r;
    7670. 

  7670.   r = ((glGetTrackMatrixivNV = (PFNGLGETTRACKMATRIXIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetTrackMatrixivNV")) == NULL) || r;
    7671. 

  7671.   r = ((glGetVertexAttribPointervNV = (PFNGLGETVERTEXATTRIBPOINTERVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervNV")) == NULL) || r;
    7672. 

  7672.   r = ((glGetVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvNV")) == NULL) || r;
    7673. 

  7673.   r = ((glGetVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvNV")) == NULL) || r;
    7674. 

  7674.   r = ((glGetVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivNV")) == NULL) || r;
    7675. 

  7675.   r = ((glIsProgramNV = (PFNGLISPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glIsProgramNV")) == NULL) || r;
    7676. 

  7676.   r = ((glLoadProgramNV = (PFNGLLOADPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glLoadProgramNV")) == NULL) || r;
    7677. 

  7677.   r = ((glProgramParameter4dNV = (PFNGLPROGRAMPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dNV")) == NULL) || r;
    7678. 

  7678.   r = ((glProgramParameter4dvNV = (PFNGLPROGRAMPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dvNV")) == NULL) || r;
    7679. 

  7679.   r = ((glProgramParameter4fNV = (PFNGLPROGRAMPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fNV")) == NULL) || r;
    7680. 

  7680.   r = ((glProgramParameter4fvNV = (PFNGLPROGRAMPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fvNV")) == NULL) || r;
    7681. 

  7681.   r = ((glProgramParameters4dvNV = (PFNGLPROGRAMPARAMETERS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4dvNV")) == NULL) || r;
    7682. 

  7682.   r = ((glProgramParameters4fvNV = (PFNGLPROGRAMPARAMETERS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4fvNV")) == NULL) || r;
    7683. 

  7683.   r = ((glRequestResidentProgramsNV = (PFNGLREQUESTRESIDENTPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glRequestResidentProgramsNV")) == NULL) || r;
    7684. 

  7684.   r = ((glTrackMatrixNV = (PFNGLTRACKMATRIXNVPROC)glewGetProcAddress((const GLubyte*)"glTrackMatrixNV")) == NULL) || r;
    7685. 

  7685.   r = ((glVertexAttrib1dNV = (PFNGLVERTEXATTRIB1DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dNV")) == NULL) || r;
    7686. 

  7686.   r = ((glVertexAttrib1dvNV = (PFNGLVERTEXATTRIB1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvNV")) == NULL) || r;
    7687. 

  7687.   r = ((glVertexAttrib1fNV = (PFNGLVERTEXATTRIB1FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fNV")) == NULL) || r;
    7688. 

  7688.   r = ((glVertexAttrib1fvNV = (PFNGLVERTEXATTRIB1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvNV")) == NULL) || r;
    7689. 

  7689.   r = ((glVertexAttrib1sNV = (PFNGLVERTEXATTRIB1SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sNV")) == NULL) || r;
    7690. 

  7690.   r = ((glVertexAttrib1svNV = (PFNGLVERTEXATTRIB1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svNV")) == NULL) || r;
    7691. 

  7691.   r = ((glVertexAttrib2dNV = (PFNGLVERTEXATTRIB2DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dNV")) == NULL) || r;
    7692. 

  7692.   r = ((glVertexAttrib2dvNV = (PFNGLVERTEXATTRIB2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvNV")) == NULL) || r;
    7693. 

  7693.   r = ((glVertexAttrib2fNV = (PFNGLVERTEXATTRIB2FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fNV")) == NULL) || r;
    7694. 

  7694.   r = ((glVertexAttrib2fvNV = (PFNGLVERTEXATTRIB2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvNV")) == NULL) || r;
    7695. 

  7695.   r = ((glVertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sNV")) == NULL) || r;
    7696. 

  7696.   r = ((glVertexAttrib2svNV = (PFNGLVERTEXATTRIB2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svNV")) == NULL) || r;
    7697. 

  7697.   r = ((glVertexAttrib3dNV = (PFNGLVERTEXATTRIB3DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dNV")) == NULL) || r;
    7698. 

  7698.   r = ((glVertexAttrib3dvNV = (PFNGLVERTEXATTRIB3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvNV")) == NULL) || r;
    7699. 

  7699.   r = ((glVertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fNV")) == NULL) || r;
    7700. 

  7700.   r = ((glVertexAttrib3fvNV = (PFNGLVERTEXATTRIB3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvNV")) == NULL) || r;
    7701. 

  7701.   r = ((glVertexAttrib3sNV = (PFNGLVERTEXATTRIB3SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sNV")) == NULL) || r;
    7702. 

  7702.   r = ((glVertexAttrib3svNV = (PFNGLVERTEXATTRIB3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svNV")) == NULL) || r;
    7703. 

  7703.   r = ((glVertexAttrib4dNV = (PFNGLVERTEXATTRIB4DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dNV")) == NULL) || r;
    7704. 

  7704.   r = ((glVertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvNV")) == NULL) || r;
    7705. 

  7705.   r = ((glVertexAttrib4fNV = (PFNGLVERTEXATTRIB4FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fNV")) == NULL) || r;
    7706. 

  7706.   r = ((glVertexAttrib4fvNV = (PFNGLVERTEXATTRIB4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvNV")) == NULL) || r;
    7707. 

  7707.   r = ((glVertexAttrib4sNV = (PFNGLVERTEXATTRIB4SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sNV")) == NULL) || r;
    7708. 

  7708.   r = ((glVertexAttrib4svNV = (PFNGLVERTEXATTRIB4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svNV")) == NULL) || r;
    7709. 

  7709.   r = ((glVertexAttrib4ubNV = (PFNGLVERTEXATTRIB4UBNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubNV")) == NULL) || r;
    7710. 

  7710.   r = ((glVertexAttrib4ubvNV = (PFNGLVERTEXATTRIB4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvNV")) == NULL) || r;
    7711. 

  7711.   r = ((glVertexAttribPointerNV = (PFNGLVERTEXATTRIBPOINTERNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerNV")) == NULL) || r;
    7712. 

  7712.   r = ((glVertexAttribs1dvNV = (PFNGLVERTEXATTRIBS1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1dvNV")) == NULL) || r;
    7713. 

  7713.   r = ((glVertexAttribs1fvNV = (PFNGLVERTEXATTRIBS1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1fvNV")) == NULL) || r;
    7714. 

  7714.   r = ((glVertexAttribs1svNV = (PFNGLVERTEXATTRIBS1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1svNV")) == NULL) || r;
    7715. 

  7715.   r = ((glVertexAttribs2dvNV = (PFNGLVERTEXATTRIBS2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2dvNV")) == NULL) || r;
    7716. 

  7716.   r = ((glVertexAttribs2fvNV = (PFNGLVERTEXATTRIBS2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2fvNV")) == NULL) || r;
    7717. 

  7717.   r = ((glVertexAttribs2svNV = (PFNGLVERTEXATTRIBS2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2svNV")) == NULL) || r;
    7718. 

  7718.   r = ((glVertexAttribs3dvNV = (PFNGLVERTEXATTRIBS3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3dvNV")) == NULL) || r;
    7719. 

  7719.   r = ((glVertexAttribs3fvNV = (PFNGLVERTEXATTRIBS3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3fvNV")) == NULL) || r;
    7720. 

  7720.   r = ((glVertexAttribs3svNV = (PFNGLVERTEXATTRIBS3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3svNV")) == NULL) || r;
    7721. 

  7721.   r = ((glVertexAttribs4dvNV = (PFNGLVERTEXATTRIBS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4dvNV")) == NULL) || r;
    7722. 

  7722.   r = ((glVertexAttribs4fvNV = (PFNGLVERTEXATTRIBS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4fvNV")) == NULL) || r;
    7723. 

  7723.   r = ((glVertexAttribs4svNV = (PFNGLVERTEXATTRIBS4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4svNV")) == NULL) || r;
    7724. 

  7724.   r = ((glVertexAttribs4ubvNV = (PFNGLVERTEXATTRIBS4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4ubvNV")) == NULL) || r;
    7725. 

  7725. 

  7726.   return r;
    7727. 

  7727. }
    7728. 

  7728. 

  7729. #endif /* GL_NV_vertex_program */
    7730. 

  7730. 

  7731. #ifdef GL_NV_vertex_program1_1
    7732. 

  7732. 

  7733. #endif /* GL_NV_vertex_program1_1 */
    7734. 

  7734. 

  7735. #ifdef GL_NV_vertex_program2
    7736. 

  7736. 

  7737. #endif /* GL_NV_vertex_program2 */
    7738. 

  7738. 

  7739. #ifdef GL_NV_vertex_program2_option
    7740. 

  7740. 

  7741. #endif /* GL_NV_vertex_program2_option */
    7742. 

  7742. 

  7743. #ifdef GL_NV_vertex_program3
    7744. 

  7744. 

  7745. #endif /* GL_NV_vertex_program3 */
    7746. 

  7746. 

  7747. #ifdef GL_NV_vertex_program4
    7748. 

  7748. 

  7749. #endif /* GL_NV_vertex_program4 */
    7750. 

  7750. 

  7751. #ifdef GL_NV_video_capture
    7752. 

  7752. 

  7753. static GLboolean _glewInit_GL_NV_video_capture (GLEW_CONTEXT_ARG_DEF_INIT)
    7754. 

  7754. {
    7755. 

  7755.   GLboolean r = GL_FALSE;
    7756. 

  7756. 

  7757.   r = ((glBeginVideoCaptureNV = (PFNGLBEGINVIDEOCAPTURENVPROC)glewGetProcAddress((const GLubyte*)"glBeginVideoCaptureNV")) == NULL) || r;
    7758. 

  7758.   r = ((glBindVideoCaptureStreamBufferNV = (PFNGLBINDVIDEOCAPTURESTREAMBUFFERNVPROC)glewGetProcAddress((const GLubyte*)"glBindVideoCaptureStreamBufferNV")) == NULL) || r;
    7759. 

  7759.   r = ((glBindVideoCaptureStreamTextureNV = (PFNGLBINDVIDEOCAPTURESTREAMTEXTURENVPROC)glewGetProcAddress((const GLubyte*)"glBindVideoCaptureStreamTextureNV")) == NULL) || r;
    7760. 

  7760.   r = ((glEndVideoCaptureNV = (PFNGLENDVIDEOCAPTURENVPROC)glewGetProcAddress((const GLubyte*)"glEndVideoCaptureNV")) == NULL) || r;
    7761. 

  7761.   r = ((glGetVideoCaptureStreamdvNV = (PFNGLGETVIDEOCAPTURESTREAMDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureStreamdvNV")) == NULL) || r;
    7762. 

  7762.   r = ((glGetVideoCaptureStreamfvNV = (PFNGLGETVIDEOCAPTURESTREAMFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureStreamfvNV")) == NULL) || r;
    7763. 

  7763.   r = ((glGetVideoCaptureStreamivNV = (PFNGLGETVIDEOCAPTURESTREAMIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureStreamivNV")) == NULL) || r;
    7764. 

  7764.   r = ((glGetVideoCaptureivNV = (PFNGLGETVIDEOCAPTUREIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoCaptureivNV")) == NULL) || r;
    7765. 

  7765.   r = ((glVideoCaptureNV = (PFNGLVIDEOCAPTURENVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureNV")) == NULL) || r;
    7766. 

  7766.   r = ((glVideoCaptureStreamParameterdvNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureStreamParameterdvNV")) == NULL) || r;
    7767. 

  7767.   r = ((glVideoCaptureStreamParameterfvNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureStreamParameterfvNV")) == NULL) || r;
    7768. 

  7768.   r = ((glVideoCaptureStreamParameterivNV = (PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoCaptureStreamParameterivNV")) == NULL) || r;
    7769. 

  7769. 

  7770.   return r;
    7771. 

  7771. }
    7772. 

  7772. 

  7773. #endif /* GL_NV_video_capture */
    7774. 

  7774. 

  7775. #ifdef GL_OES_byte_coordinates
    7776. 

  7776. 

  7777. #endif /* GL_OES_byte_coordinates */
    7778. 

  7778. 

  7779. #ifdef GL_OES_compressed_paletted_texture
    7780. 

  7780. 

  7781. #endif /* GL_OES_compressed_paletted_texture */
    7782. 

  7782. 

  7783. #ifdef GL_OES_read_format
    7784. 

  7784. 

  7785. #endif /* GL_OES_read_format */
    7786. 

  7786. 

  7787. #ifdef GL_OES_single_precision
    7788. 

  7788. 

  7789. static GLboolean _glewInit_GL_OES_single_precision (GLEW_CONTEXT_ARG_DEF_INIT)
    7790. 

  7790. {
    7791. 

  7791.   GLboolean r = GL_FALSE;
    7792. 

  7792. 

  7793.   r = ((glClearDepthfOES = (PFNGLCLEARDEPTHFOESPROC)glewGetProcAddress((const GLubyte*)"glClearDepthfOES")) == NULL) || r;
    7794. 

  7794.   r = ((glClipPlanefOES = (PFNGLCLIPPLANEFOESPROC)glewGetProcAddress((const GLubyte*)"glClipPlanefOES")) == NULL) || r;
    7795. 

  7795.   r = ((glDepthRangefOES = (PFNGLDEPTHRANGEFOESPROC)glewGetProcAddress((const GLubyte*)"glDepthRangefOES")) == NULL) || r;
    7796. 

  7796.   r = ((glFrustumfOES = (PFNGLFRUSTUMFOESPROC)glewGetProcAddress((const GLubyte*)"glFrustumfOES")) == NULL) || r;
    7797. 

  7797.   r = ((glGetClipPlanefOES = (PFNGLGETCLIPPLANEFOESPROC)glewGetProcAddress((const GLubyte*)"glGetClipPlanefOES")) == NULL) || r;
    7798. 

  7798.   r = ((glOrthofOES = (PFNGLORTHOFOESPROC)glewGetProcAddress((const GLubyte*)"glOrthofOES")) == NULL) || r;
    7799. 

  7799. 

  7800.   return r;
    7801. 

  7801. }
    7802. 

  7802. 

  7803. #endif /* GL_OES_single_precision */
    7804. 

  7804. 

  7805. #ifdef GL_OML_interlace
    7806. 

  7806. 

  7807. #endif /* GL_OML_interlace */
    7808. 

  7808. 

  7809. #ifdef GL_OML_resample
    7810. 

  7810. 

  7811. #endif /* GL_OML_resample */
    7812. 

  7812. 

  7813. #ifdef GL_OML_subsample
    7814. 

  7814. 

  7815. #endif /* GL_OML_subsample */
    7816. 

  7816. 

  7817. #ifdef GL_PGI_misc_hints
    7818. 

  7818. 

  7819. #endif /* GL_PGI_misc_hints */
    7820. 

  7820. 

  7821. #ifdef GL_PGI_vertex_hints
    7822. 

  7822. 

  7823. #endif /* GL_PGI_vertex_hints */
    7824. 

  7824. 

  7825. #ifdef GL_REND_screen_coordinates
    7826. 

  7826. 

  7827. #endif /* GL_REND_screen_coordinates */
    7828. 

  7828. 

  7829. #ifdef GL_S3_s3tc
    7830. 

  7830. 

  7831. #endif /* GL_S3_s3tc */
    7832. 

  7832. 

  7833. #ifdef GL_SGIS_color_range
    7834. 

  7834. 

  7835. #endif /* GL_SGIS_color_range */
    7836. 

  7836. 

  7837. #ifdef GL_SGIS_detail_texture
    7838. 

  7838. 

  7839. static GLboolean _glewInit_GL_SGIS_detail_texture (GLEW_CONTEXT_ARG_DEF_INIT)
    7840. 

  7840. {
    7841. 

  7841.   GLboolean r = GL_FALSE;
    7842. 

  7842. 

  7843.   r = ((glDetailTexFuncSGIS = (PFNGLDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glDetailTexFuncSGIS")) == NULL) || r;
    7844. 

  7844.   r = ((glGetDetailTexFuncSGIS = (PFNGLGETDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetDetailTexFuncSGIS")) == NULL) || r;
    7845. 

  7845. 

  7846.   return r;
    7847. 

  7847. }
    7848. 

  7848. 

  7849. #endif /* GL_SGIS_detail_texture */
    7850. 

  7850. 

  7851. #ifdef GL_SGIS_fog_function
    7852. 

  7852. 

  7853. static GLboolean _glewInit_GL_SGIS_fog_function (GLEW_CONTEXT_ARG_DEF_INIT)
    7854. 

  7854. {
    7855. 

  7855.   GLboolean r = GL_FALSE;
    7856. 

  7856. 

  7857.   r = ((glFogFuncSGIS = (PFNGLFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glFogFuncSGIS")) == NULL) || r;
    7858. 

  7858.   r = ((glGetFogFuncSGIS = (PFNGLGETFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetFogFuncSGIS")) == NULL) || r;
    7859. 

  7859. 

  7860.   return r;
    7861. 

  7861. }
    7862. 

  7862. 

  7863. #endif /* GL_SGIS_fog_function */
    7864. 

  7864. 

  7865. #ifdef GL_SGIS_generate_mipmap
    7866. 

  7866. 

  7867. #endif /* GL_SGIS_generate_mipmap */
    7868. 

  7868. 

  7869. #ifdef GL_SGIS_multisample
    7870. 

  7870. 

  7871. static GLboolean _glewInit_GL_SGIS_multisample (GLEW_CONTEXT_ARG_DEF_INIT)
    7872. 

  7872. {
    7873. 

  7873.   GLboolean r = GL_FALSE;
    7874. 

  7874. 

  7875.   r = ((glSampleMaskSGIS = (PFNGLSAMPLEMASKSGISPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskSGIS")) == NULL) || r;
    7876. 

  7876.   r = ((glSamplePatternSGIS = (PFNGLSAMPLEPATTERNSGISPROC)glewGetProcAddress((const GLubyte*)"glSamplePatternSGIS")) == NULL) || r;
    7877. 

  7877. 

  7878.   return r;
    7879. 

  7879. }
    7880. 

  7880. 

  7881. #endif /* GL_SGIS_multisample */
    7882. 

  7882. 

  7883. #ifdef GL_SGIS_pixel_texture
    7884. 

  7884. 

  7885. #endif /* GL_SGIS_pixel_texture */
    7886. 

  7886. 

  7887. #ifdef GL_SGIS_point_line_texgen
    7888. 

  7888. 

  7889. #endif /* GL_SGIS_point_line_texgen */
    7890. 

  7890. 

  7891. #ifdef GL_SGIS_sharpen_texture
    7892. 

  7892. 

  7893. static GLboolean _glewInit_GL_SGIS_sharpen_texture (GLEW_CONTEXT_ARG_DEF_INIT)
    7894. 

  7894. {
    7895. 

  7895.   GLboolean r = GL_FALSE;
    7896. 

  7896. 

  7897.   r = ((glGetSharpenTexFuncSGIS = (PFNGLGETSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetSharpenTexFuncSGIS")) == NULL) || r;
    7898. 

  7898.   r = ((glSharpenTexFuncSGIS = (PFNGLSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glSharpenTexFuncSGIS")) == NULL) || r;
    7899. 

  7899. 

  7900.   return r;
    7901. 

  7901. }
    7902. 

  7902. 

  7903. #endif /* GL_SGIS_sharpen_texture */
    7904. 

  7904. 

  7905. #ifdef GL_SGIS_texture4D
    7906. 

  7906. 

  7907. static GLboolean _glewInit_GL_SGIS_texture4D (GLEW_CONTEXT_ARG_DEF_INIT)
    7908. 

  7908. {
    7909. 

  7909.   GLboolean r = GL_FALSE;
    7910. 

  7910. 

  7911.   r = ((glTexImage4DSGIS = (PFNGLTEXIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexImage4DSGIS")) == NULL) || r;
    7912. 

  7912.   r = ((glTexSubImage4DSGIS = (PFNGLTEXSUBIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage4DSGIS")) == NULL) || r;
    7913. 

  7913. 

  7914.   return r;
    7915. 

  7915. }
    7916. 

  7916. 

  7917. #endif /* GL_SGIS_texture4D */
    7918. 

  7918. 

  7919. #ifdef GL_SGIS_texture_border_clamp
    7920. 

  7920. 

  7921. #endif /* GL_SGIS_texture_border_clamp */
    7922. 

  7922. 

  7923. #ifdef GL_SGIS_texture_edge_clamp
    7924. 

  7924. 

  7925. #endif /* GL_SGIS_texture_edge_clamp */
    7926. 

  7926. 

  7927. #ifdef GL_SGIS_texture_filter4
    7928. 

  7928. 

  7929. static GLboolean _glewInit_GL_SGIS_texture_filter4 (GLEW_CONTEXT_ARG_DEF_INIT)
    7930. 

  7930. {
    7931. 

  7931.   GLboolean r = GL_FALSE;
    7932. 

  7932. 

  7933.   r = ((glGetTexFilterFuncSGIS = (PFNGLGETTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetTexFilterFuncSGIS")) == NULL) || r;
    7934. 

  7934.   r = ((glTexFilterFuncSGIS = (PFNGLTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glTexFilterFuncSGIS")) == NULL) || r;
    7935. 

  7935. 

  7936.   return r;
    7937. 

  7937. }
    7938. 

  7938. 

  7939. #endif /* GL_SGIS_texture_filter4 */
    7940. 

  7940. 

  7941. #ifdef GL_SGIS_texture_lod
    7942. 

  7942. 

  7943. #endif /* GL_SGIS_texture_lod */
    7944. 

  7944. 

  7945. #ifdef GL_SGIS_texture_select
    7946. 

  7946. 

  7947. #endif /* GL_SGIS_texture_select */
    7948. 

  7948. 

  7949. #ifdef GL_SGIX_async
    7950. 

  7950. 

  7951. static GLboolean _glewInit_GL_SGIX_async (GLEW_CONTEXT_ARG_DEF_INIT)
    7952. 

  7952. {
    7953. 

  7953.   GLboolean r = GL_FALSE;
    7954. 

  7954. 

  7955.   r = ((glAsyncMarkerSGIX = (PFNGLASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glAsyncMarkerSGIX")) == NULL) || r;
    7956. 

  7956.   r = ((glDeleteAsyncMarkersSGIX = (PFNGLDELETEASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glDeleteAsyncMarkersSGIX")) == NULL) || r;
    7957. 

  7957.   r = ((glFinishAsyncSGIX = (PFNGLFINISHASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glFinishAsyncSGIX")) == NULL) || r;
    7958. 

  7958.   r = ((glGenAsyncMarkersSGIX = (PFNGLGENASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glGenAsyncMarkersSGIX")) == NULL) || r;
    7959. 

  7959.   r = ((glIsAsyncMarkerSGIX = (PFNGLISASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glIsAsyncMarkerSGIX")) == NULL) || r;
    7960. 

  7960.   r = ((glPollAsyncSGIX = (PFNGLPOLLASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glPollAsyncSGIX")) == NULL) || r;
    7961. 

  7961. 

  7962.   return r;
    7963. 

  7963. }
    7964. 

  7964. 

  7965. #endif /* GL_SGIX_async */
    7966. 

  7966. 

  7967. #ifdef GL_SGIX_async_histogram
    7968. 

  7968. 

  7969. #endif /* GL_SGIX_async_histogram */
    7970. 

  7970. 

  7971. #ifdef GL_SGIX_async_pixel
    7972. 

  7972. 

  7973. #endif /* GL_SGIX_async_pixel */
    7974. 

  7974. 

  7975. #ifdef GL_SGIX_blend_alpha_minmax
    7976. 

  7976. 

  7977. #endif /* GL_SGIX_blend_alpha_minmax */
    7978. 

  7978. 

  7979. #ifdef GL_SGIX_clipmap
    7980. 

  7980. 

  7981. #endif /* GL_SGIX_clipmap */
    7982. 

  7982. 

  7983. #ifdef GL_SGIX_convolution_accuracy
    7984. 

  7984. 

  7985. #endif /* GL_SGIX_convolution_accuracy */
    7986. 

  7986. 

  7987. #ifdef GL_SGIX_depth_texture
    7988. 

  7988. 

  7989. #endif /* GL_SGIX_depth_texture */
    7990. 

  7990. 

  7991. #ifdef GL_SGIX_flush_raster
    7992. 

  7992. 

  7993. static GLboolean _glewInit_GL_SGIX_flush_raster (GLEW_CONTEXT_ARG_DEF_INIT)
    7994. 

  7994. {
    7995. 

  7995.   GLboolean r = GL_FALSE;
    7996. 

  7996. 

  7997.   r = ((glFlushRasterSGIX = (PFNGLFLUSHRASTERSGIXPROC)glewGetProcAddress((const GLubyte*)"glFlushRasterSGIX")) == NULL) || r;
    7998. 

  7998. 

  7999.   return r;
    8000. 

  8000. }
    8001. 

  8001. 

  8002. #endif /* GL_SGIX_flush_raster */
    8003. 

  8003. 

  8004. #ifdef GL_SGIX_fog_offset
    8005. 

  8005. 

  8006. #endif /* GL_SGIX_fog_offset */
    8007. 

  8007. 

  8008. #ifdef GL_SGIX_fog_texture
    8009. 

  8009. 

  8010. static GLboolean _glewInit_GL_SGIX_fog_texture (GLEW_CONTEXT_ARG_DEF_INIT)
    8011. 

  8011. {
    8012. 

  8012.   GLboolean r = GL_FALSE;
    8013. 

  8013. 

  8014.   r = ((glTextureFogSGIX = (PFNGLTEXTUREFOGSGIXPROC)glewGetProcAddress((const GLubyte*)"glTextureFogSGIX")) == NULL) || r;
    8015. 

  8015. 

  8016.   return r;
    8017. 

  8017. }
    8018. 

  8018. 

  8019. #endif /* GL_SGIX_fog_texture */
    8020. 

  8020. 

  8021. #ifdef GL_SGIX_fragment_specular_lighting
    8022. 

  8022. 

  8023. static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting (GLEW_CONTEXT_ARG_DEF_INIT)
    8024. 

  8024. {
    8025. 

  8025.   GLboolean r = GL_FALSE;
    8026. 

  8026. 

  8027.   r = ((glFragmentColorMaterialSGIX = (PFNGLFRAGMENTCOLORMATERIALSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentColorMaterialSGIX")) == NULL) || r;
    8028. 

  8028.   r = ((glFragmentLightModelfSGIX = (PFNGLFRAGMENTLIGHTMODELFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfSGIX")) == NULL) || r;
    8029. 

  8029.   r = ((glFragmentLightModelfvSGIX = (PFNGLFRAGMENTLIGHTMODELFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfvSGIX")) == NULL) || r;
    8030. 

  8030.   r = ((glFragmentLightModeliSGIX = (PFNGLFRAGMENTLIGHTMODELISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModeliSGIX")) == NULL) || r;
    8031. 

  8031.   r = ((glFragmentLightModelivSGIX = (PFNGLFRAGMENTLIGHTMODELIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelivSGIX")) == NULL) || r;
    8032. 

  8032.   r = ((glFragmentLightfSGIX = (PFNGLFRAGMENTLIGHTFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfSGIX")) == NULL) || r;
    8033. 

  8033.   r = ((glFragmentLightfvSGIX = (PFNGLFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfvSGIX")) == NULL) || r;
    8034. 

  8034.   r = ((glFragmentLightiSGIX = (PFNGLFRAGMENTLIGHTISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightiSGIX")) == NULL) || r;
    8035. 

  8035.   r = ((glFragmentLightivSGIX = (PFNGLFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightivSGIX")) == NULL) || r;
    8036. 

  8036.   r = ((glFragmentMaterialfSGIX = (PFNGLFRAGMENTMATERIALFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfSGIX")) == NULL) || r;
    8037. 

  8037.   r = ((glFragmentMaterialfvSGIX = (PFNGLFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfvSGIX")) == NULL) || r;
    8038. 

  8038.   r = ((glFragmentMaterialiSGIX = (PFNGLFRAGMENTMATERIALISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialiSGIX")) == NULL) || r;
    8039. 

  8039.   r = ((glFragmentMaterialivSGIX = (PFNGLFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialivSGIX")) == NULL) || r;
    8040. 

  8040.   r = ((glGetFragmentLightfvSGIX = (PFNGLGETFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightfvSGIX")) == NULL) || r;
    8041. 

  8041.   r = ((glGetFragmentLightivSGIX = (PFNGLGETFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightivSGIX")) == NULL) || r;
    8042. 

  8042.   r = ((glGetFragmentMaterialfvSGIX = (PFNGLGETFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialfvSGIX")) == NULL) || r;
    8043. 

  8043.   r = ((glGetFragmentMaterialivSGIX = (PFNGLGETFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialivSGIX")) == NULL) || r;
    8044. 

  8044. 

  8045.   return r;
    8046. 

  8046. }
    8047. 

  8047. 

  8048. #endif /* GL_SGIX_fragment_specular_lighting */
    8049. 

  8049. 

  8050. #ifdef GL_SGIX_framezoom
    8051. 

  8051. 

  8052. static GLboolean _glewInit_GL_SGIX_framezoom (GLEW_CONTEXT_ARG_DEF_INIT)
    8053. 

  8053. {
    8054. 

  8054.   GLboolean r = GL_FALSE;
    8055. 

  8055. 

  8056.   r = ((glFrameZoomSGIX = (PFNGLFRAMEZOOMSGIXPROC)glewGetProcAddress((const GLubyte*)"glFrameZoomSGIX")) == NULL) || r;
    8057. 

  8057. 

  8058.   return r;
    8059. 

  8059. }
    8060. 

  8060. 

  8061. #endif /* GL_SGIX_framezoom */
    8062. 

  8062. 

  8063. #ifdef GL_SGIX_interlace
    8064. 

  8064. 

  8065. #endif /* GL_SGIX_interlace */
    8066. 

  8066. 

  8067. #ifdef GL_SGIX_ir_instrument1
    8068. 

  8068. 

  8069. #endif /* GL_SGIX_ir_instrument1 */
    8070. 

  8070. 

  8071. #ifdef GL_SGIX_list_priority
    8072. 

  8072. 

  8073. #endif /* GL_SGIX_list_priority */
    8074. 

  8074. 

  8075. #ifdef GL_SGIX_pixel_texture
    8076. 

  8076. 

  8077. static GLboolean _glewInit_GL_SGIX_pixel_texture (GLEW_CONTEXT_ARG_DEF_INIT)
    8078. 

  8078. {
    8079. 

  8079.   GLboolean r = GL_FALSE;
    8080. 

  8080. 

  8081.   r = ((glPixelTexGenSGIX = (PFNGLPIXELTEXGENSGIXPROC)glewGetProcAddress((const GLubyte*)"glPixelTexGenSGIX")) == NULL) || r;
    8082. 

  8082. 

  8083.   return r;
    8084. 

  8084. }
    8085. 

  8085. 

  8086. #endif /* GL_SGIX_pixel_texture */
    8087. 

  8087. 

  8088. #ifdef GL_SGIX_pixel_texture_bits
    8089. 

  8089. 

  8090. #endif /* GL_SGIX_pixel_texture_bits */
    8091. 

  8091. 

  8092. #ifdef GL_SGIX_reference_plane
    8093. 

  8093. 

  8094. static GLboolean _glewInit_GL_SGIX_reference_plane (GLEW_CONTEXT_ARG_DEF_INIT)
    8095. 

  8095. {
    8096. 

  8096.   GLboolean r = GL_FALSE;
    8097. 

  8097. 

  8098.   r = ((glReferencePlaneSGIX = (PFNGLREFERENCEPLANESGIXPROC)glewGetProcAddress((const GLubyte*)"glReferencePlaneSGIX")) == NULL) || r;
    8099. 

  8099. 

  8100.   return r;
    8101. 

  8101. }
    8102. 

  8102. 

  8103. #endif /* GL_SGIX_reference_plane */
    8104. 

  8104. 

  8105. #ifdef GL_SGIX_resample
    8106. 

  8106. 

  8107. #endif /* GL_SGIX_resample */
    8108. 

  8108. 

  8109. #ifdef GL_SGIX_shadow
    8110. 

  8110. 

  8111. #endif /* GL_SGIX_shadow */
    8112. 

  8112. 

  8113. #ifdef GL_SGIX_shadow_ambient
    8114. 

  8114. 

  8115. #endif /* GL_SGIX_shadow_ambient */
    8116. 

  8116. 

  8117. #ifdef GL_SGIX_sprite
    8118. 

  8118. 

  8119. static GLboolean _glewInit_GL_SGIX_sprite (GLEW_CONTEXT_ARG_DEF_INIT)
    8120. 

  8120. {
    8121. 

  8121.   GLboolean r = GL_FALSE;
    8122. 

  8122. 

  8123.   r = ((glSpriteParameterfSGIX = (PFNGLSPRITEPARAMETERFSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfSGIX")) == NULL) || r;
    8124. 

  8124.   r = ((glSpriteParameterfvSGIX = (PFNGLSPRITEPARAMETERFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfvSGIX")) == NULL) || r;
    8125. 

  8125.   r = ((glSpriteParameteriSGIX = (PFNGLSPRITEPARAMETERISGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameteriSGIX")) == NULL) || r;
    8126. 

  8126.   r = ((glSpriteParameterivSGIX = (PFNGLSPRITEPARAMETERIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterivSGIX")) == NULL) || r;
    8127. 

  8127. 

  8128.   return r;
    8129. 

  8129. }
    8130. 

  8130. 

  8131. #endif /* GL_SGIX_sprite */
    8132. 

  8132. 

  8133. #ifdef GL_SGIX_tag_sample_buffer
    8134. 

  8134. 

  8135. static GLboolean _glewInit_GL_SGIX_tag_sample_buffer (GLEW_CONTEXT_ARG_DEF_INIT)
    8136. 

  8136. {
    8137. 

  8137.   GLboolean r = GL_FALSE;
    8138. 

  8138. 

  8139.   r = ((glTagSampleBufferSGIX = (PFNGLTAGSAMPLEBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glTagSampleBufferSGIX")) == NULL) || r;
    8140. 

  8140. 

  8141.   return r;
    8142. 

  8142. }
    8143. 

  8143. 

  8144. #endif /* GL_SGIX_tag_sample_buffer */
    8145. 

  8145. 

  8146. #ifdef GL_SGIX_texture_add_env
    8147. 

  8147. 

  8148. #endif /* GL_SGIX_texture_add_env */
    8149. 

  8149. 

  8150. #ifdef GL_SGIX_texture_coordinate_clamp
    8151. 

  8151. 

  8152. #endif /* GL_SGIX_texture_coordinate_clamp */
    8153. 

  8153. 

  8154. #ifdef GL_SGIX_texture_lod_bias
    8155. 

  8155. 

  8156. #endif /* GL_SGIX_texture_lod_bias */
    8157. 

  8157. 

  8158. #ifdef GL_SGIX_texture_multi_buffer
    8159. 

  8159. 

  8160. #endif /* GL_SGIX_texture_multi_buffer */
    8161. 

  8161. 

  8162. #ifdef GL_SGIX_texture_range
    8163. 

  8163. 

  8164. #endif /* GL_SGIX_texture_range */
    8165. 

  8165. 

  8166. #ifdef GL_SGIX_texture_scale_bias
    8167. 

  8167. 

  8168. #endif /* GL_SGIX_texture_scale_bias */
    8169. 

  8169. 

  8170. #ifdef GL_SGIX_vertex_preclip
    8171. 

  8171. 

  8172. #endif /* GL_SGIX_vertex_preclip */
    8173. 

  8173. 

  8174. #ifdef GL_SGIX_vertex_preclip_hint
    8175. 

  8175. 

  8176. #endif /* GL_SGIX_vertex_preclip_hint */
    8177. 

  8177. 

  8178. #ifdef GL_SGIX_ycrcb
    8179. 

  8179. 

  8180. #endif /* GL_SGIX_ycrcb */
    8181. 

  8181. 

  8182. #ifdef GL_SGI_color_matrix
    8183. 

  8183. 

  8184. #endif /* GL_SGI_color_matrix */
    8185. 

  8185. 

  8186. #ifdef GL_SGI_color_table
    8187. 

  8187. 

  8188. static GLboolean _glewInit_GL_SGI_color_table (GLEW_CONTEXT_ARG_DEF_INIT)
    8189. 

  8189. {
    8190. 

  8190.   GLboolean r = GL_FALSE;
    8191. 

  8191. 

  8192.   r = ((glColorTableParameterfvSGI = (PFNGLCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterfvSGI")) == NULL) || r;
    8193. 

  8193.   r = ((glColorTableParameterivSGI = (PFNGLCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterivSGI")) == NULL) || r;
    8194. 

  8194.   r = ((glColorTableSGI = (PFNGLCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableSGI")) == NULL) || r;
    8195. 

  8195.   r = ((glCopyColorTableSGI = (PFNGLCOPYCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glCopyColorTableSGI")) == NULL) || r;
    8196. 

  8196.   r = ((glGetColorTableParameterfvSGI = (PFNGLGETCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfvSGI")) == NULL) || r;
    8197. 

  8197.   r = ((glGetColorTableParameterivSGI = (PFNGLGETCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterivSGI")) == NULL) || r;
    8198. 

  8198.   r = ((glGetColorTableSGI = (PFNGLGETCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableSGI")) == NULL) || r;
    8199. 

  8199. 

  8200.   return r;
    8201. 

  8201. }
    8202. 

  8202. 

  8203. #endif /* GL_SGI_color_table */
    8204. 

  8204. 

  8205. #ifdef GL_SGI_texture_color_table
    8206. 

  8206. 

  8207. #endif /* GL_SGI_texture_color_table */
    8208. 

  8208. 

  8209. #ifdef GL_SUNX_constant_data
    8210. 

  8210. 

  8211. static GLboolean _glewInit_GL_SUNX_constant_data (GLEW_CONTEXT_ARG_DEF_INIT)
    8212. 

  8212. {
    8213. 

  8213.   GLboolean r = GL_FALSE;
    8214. 

  8214. 

  8215.   r = ((glFinishTextureSUNX = (PFNGLFINISHTEXTURESUNXPROC)glewGetProcAddress((const GLubyte*)"glFinishTextureSUNX")) == NULL) || r;
    8216. 

  8216. 

  8217.   return r;
    8218. 

  8218. }
    8219. 

  8219. 

  8220. #endif /* GL_SUNX_constant_data */
    8221. 

  8221. 

  8222. #ifdef GL_SUN_convolution_border_modes
    8223. 

  8223. 

  8224. #endif /* GL_SUN_convolution_border_modes */
    8225. 

  8225. 

  8226. #ifdef GL_SUN_global_alpha
    8227. 

  8227. 

  8228. static GLboolean _glewInit_GL_SUN_global_alpha (GLEW_CONTEXT_ARG_DEF_INIT)
    8229. 

  8229. {
    8230. 

  8230.   GLboolean r = GL_FALSE;
    8231. 

  8231. 

  8232.   r = ((glGlobalAlphaFactorbSUN = (PFNGLGLOBALALPHAFACTORBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorbSUN")) == NULL) || r;
    8233. 

  8233.   r = ((glGlobalAlphaFactordSUN = (PFNGLGLOBALALPHAFACTORDSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactordSUN")) == NULL) || r;
    8234. 

  8234.   r = ((glGlobalAlphaFactorfSUN = (PFNGLGLOBALALPHAFACTORFSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorfSUN")) == NULL) || r;
    8235. 

  8235.   r = ((glGlobalAlphaFactoriSUN = (PFNGLGLOBALALPHAFACTORISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoriSUN")) == NULL) || r;
    8236. 

  8236.   r = ((glGlobalAlphaFactorsSUN = (PFNGLGLOBALALPHAFACTORSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorsSUN")) == NULL) || r;
    8237. 

  8237.   r = ((glGlobalAlphaFactorubSUN = (PFNGLGLOBALALPHAFACTORUBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorubSUN")) == NULL) || r;
    8238. 

  8238.   r = ((glGlobalAlphaFactoruiSUN = (PFNGLGLOBALALPHAFACTORUISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoruiSUN")) == NULL) || r;
    8239. 

  8239.   r = ((glGlobalAlphaFactorusSUN = (PFNGLGLOBALALPHAFACTORUSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorusSUN")) == NULL) || r;
    8240. 

  8240. 

  8241.   return r;
    8242. 

  8242. }
    8243. 

  8243. 

  8244. #endif /* GL_SUN_global_alpha */
    8245. 

  8245. 

  8246. #ifdef GL_SUN_mesh_array
    8247. 

  8247. 

  8248. #endif /* GL_SUN_mesh_array */
    8249. 

  8249. 

  8250. #ifdef GL_SUN_read_video_pixels
    8251. 

  8251. 

  8252. static GLboolean _glewInit_GL_SUN_read_video_pixels (GLEW_CONTEXT_ARG_DEF_INIT)
    8253. 

  8253. {
    8254. 

  8254.   GLboolean r = GL_FALSE;
    8255. 

  8255. 

  8256.   r = ((glReadVideoPixelsSUN = (PFNGLREADVIDEOPIXELSSUNPROC)glewGetProcAddress((const GLubyte*)"glReadVideoPixelsSUN")) == NULL) || r;
    8257. 

  8257. 

  8258.   return r;
    8259. 

  8259. }
    8260. 

  8260. 

  8261. #endif /* GL_SUN_read_video_pixels */
    8262. 

  8262. 

  8263. #ifdef GL_SUN_slice_accum
    8264. 

  8264. 

  8265. #endif /* GL_SUN_slice_accum */
    8266. 

  8266. 

  8267. #ifdef GL_SUN_triangle_list
    8268. 

  8268. 

  8269. static GLboolean _glewInit_GL_SUN_triangle_list (GLEW_CONTEXT_ARG_DEF_INIT)
    8270. 

  8270. {
    8271. 

  8271.   GLboolean r = GL_FALSE;
    8272. 

  8272. 

  8273.   r = ((glReplacementCodePointerSUN = (PFNGLREPLACEMENTCODEPOINTERSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodePointerSUN")) == NULL) || r;
    8274. 

  8274.   r = ((glReplacementCodeubSUN = (PFNGLREPLACEMENTCODEUBSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubSUN")) == NULL) || r;
    8275. 

  8275.   r = ((glReplacementCodeubvSUN = (PFNGLREPLACEMENTCODEUBVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubvSUN")) == NULL) || r;
    8276. 

  8276.   r = ((glReplacementCodeuiSUN = (PFNGLREPLACEMENTCODEUISUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiSUN")) == NULL) || r;
    8277. 

  8277.   r = ((glReplacementCodeuivSUN = (PFNGLREPLACEMENTCODEUIVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuivSUN")) == NULL) || r;
    8278. 

  8278.   r = ((glReplacementCodeusSUN = (PFNGLREPLACEMENTCODEUSSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusSUN")) == NULL) || r;
    8279. 

  8279.   r = ((glReplacementCodeusvSUN = (PFNGLREPLACEMENTCODEUSVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusvSUN")) == NULL) || r;
    8280. 

  8280. 

  8281.   return r;
    8282. 

  8282. }
    8283. 

  8283. 

  8284. #endif /* GL_SUN_triangle_list */
    8285. 

  8285. 

  8286. #ifdef GL_SUN_vertex
    8287. 

  8287. 

  8288. static GLboolean _glewInit_GL_SUN_vertex (GLEW_CONTEXT_ARG_DEF_INIT)
    8289. 

  8289. {
    8290. 

  8290.   GLboolean r = GL_FALSE;
    8291. 

  8291. 

  8292.   r = ((glColor3fVertex3fSUN = (PFNGLCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fSUN")) == NULL) || r;
    8293. 

  8293.   r = ((glColor3fVertex3fvSUN = (PFNGLCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fvSUN")) == NULL) || r;
    8294. 

  8294.   r = ((glColor4fNormal3fVertex3fSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fSUN")) == NULL) || r;
    8295. 

  8295.   r = ((glColor4fNormal3fVertex3fvSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fvSUN")) == NULL) || r;
    8296. 

  8296.   r = ((glColor4ubVertex2fSUN = (PFNGLCOLOR4UBVERTEX2FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fSUN")) == NULL) || r;
    8297. 

  8297.   r = ((glColor4ubVertex2fvSUN = (PFNGLCOLOR4UBVERTEX2FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fvSUN")) == NULL) || r;
    8298. 

  8298.   r = ((glColor4ubVertex3fSUN = (PFNGLCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fSUN")) == NULL) || r;
    8299. 

  8299.   r = ((glColor4ubVertex3fvSUN = (PFNGLCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fvSUN")) == NULL) || r;
    8300. 

  8300.   r = ((glNormal3fVertex3fSUN = (PFNGLNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fSUN")) == NULL) || r;
    8301. 

  8301.   r = ((glNormal3fVertex3fvSUN = (PFNGLNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fvSUN")) == NULL) || r;
    8302. 

  8302.   r = ((glReplacementCodeuiColor3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fSUN")) == NULL) || r;
    8303. 

  8303.   r = ((glReplacementCodeuiColor3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fvSUN")) == NULL) || r;
    8304. 

  8304.   r = ((glReplacementCodeuiColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fSUN")) == NULL) || r;
    8305. 

  8305.   r = ((glReplacementCodeuiColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fvSUN")) == NULL) || r;
    8306. 

  8306.   r = ((glReplacementCodeuiColor4ubVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fSUN")) == NULL) || r;
    8307. 

  8307.   r = ((glReplacementCodeuiColor4ubVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fvSUN")) == NULL) || r;
    8308. 

  8308.   r = ((glReplacementCodeuiNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fSUN")) == NULL) || r;
    8309. 

  8309.   r = ((glReplacementCodeuiNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fvSUN")) == NULL) || r;
    8310. 

  8310.   r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r;
    8311. 

  8311.   r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r;
    8312. 

  8312.   r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN")) == NULL) || r;
    8313. 

  8313.   r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r;
    8314. 

  8314.   r = ((glReplacementCodeuiTexCoord2fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fSUN")) == NULL) || r;
    8315. 

  8315.   r = ((glReplacementCodeuiTexCoord2fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fvSUN")) == NULL) || r;
    8316. 

  8316.   r = ((glReplacementCodeuiVertex3fSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fSUN")) == NULL) || r;
    8317. 

  8317.   r = ((glReplacementCodeuiVertex3fvSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fvSUN")) == NULL) || r;
    8318. 

  8318.   r = ((glTexCoord2fColor3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fSUN")) == NULL) || r;
    8319. 

  8319.   r = ((glTexCoord2fColor3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fvSUN")) == NULL) || r;
    8320. 

  8320.   r = ((glTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r;
    8321. 

  8321.   r = ((glTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r;
    8322. 

  8322.   r = ((glTexCoord2fColor4ubVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fSUN")) == NULL) || r;
    8323. 

  8323.   r = ((glTexCoord2fColor4ubVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fvSUN")) == NULL) || r;
    8324. 

  8324.   r = ((glTexCoord2fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fSUN")) == NULL) || r;
    8325. 

  8325.   r = ((glTexCoord2fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r;
    8326. 

  8326.   r = ((glTexCoord2fVertex3fSUN = (PFNGLTEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fSUN")) == NULL) || r;
    8327. 

  8327.   r = ((glTexCoord2fVertex3fvSUN = (PFNGLTEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fvSUN")) == NULL) || r;
    8328. 

  8328.   r = ((glTexCoord4fColor4fNormal3fVertex4fSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fSUN")) == NULL) || r;
    8329. 

  8329.   r = ((glTexCoord4fColor4fNormal3fVertex4fvSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fvSUN")) == NULL) || r;
    8330. 

  8330.   r = ((glTexCoord4fVertex4fSUN = (PFNGLTEXCOORD4FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fSUN")) == NULL) || r;
    8331. 

  8331.   r = ((glTexCoord4fVertex4fvSUN = (PFNGLTEXCOORD4FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fvSUN")) == NULL) || r;
    8332. 

  8332. 

  8333.   return r;
    8334. 

  8334. }
    8335. 

  8335. 

  8336. #endif /* GL_SUN_vertex */
    8337. 

  8337. 

  8338. #ifdef GL_WIN_phong_shading
    8339. 

  8339. 

  8340. #endif /* GL_WIN_phong_shading */
    8341. 

  8341. 

  8342. #ifdef GL_WIN_specular_fog
    8343. 

  8343. 

  8344. #endif /* GL_WIN_specular_fog */
    8345. 

  8345. 

  8346. #ifdef GL_WIN_swap_hint
    8347. 

  8347. 

  8348. static GLboolean _glewInit_GL_WIN_swap_hint (GLEW_CONTEXT_ARG_DEF_INIT)
    8349. 

  8349. {
    8350. 

  8350.   GLboolean r = GL_FALSE;
    8351. 

  8351. 

  8352.   r = ((glAddSwapHintRectWIN = (PFNGLADDSWAPHINTRECTWINPROC)glewGetProcAddress((const GLubyte*)"glAddSwapHintRectWIN")) == NULL) || r;
    8353. 

  8353. 

  8354.   return r;
    8355. 

  8355. }
    8356. 

  8356. 

  8357. #endif /* GL_WIN_swap_hint */
    8358. 

  8358. 

  8359. /* ------------------------------------------------------------------------- */
    8360. 

  8360. 

  8361. GLboolean glewGetExtension (const char* name)
    8362. 

  8362. {    
    8363. 

  8363.   const GLubyte* start;
    8364. 

  8364.   const GLubyte* end;
    8365. 

  8365.   start = (const GLubyte*)glGetString(GL_EXTENSIONS);
    8366. 

  8366.   if (start == 0)
    8367. 

  8367.     return GL_FALSE;
    8368. 

  8368.   end = start + _glewStrLen(start);
    8369. 

  8369.   return _glewSearchExtension(name, start, end);
    8370. 

  8370. }
    8371. 

  8371. 

  8372. /* ------------------------------------------------------------------------- */
    8373. 

  8373. 

  8374. // SJS
    8375. 

  8375. //#ifndef GLEW_MX
    8376. 

  8376. //static
    8377. 

  8377. //#endif
    8378. 

  8378. // SJS
    8379. 

  8379. GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
    8380. 

  8380. {
    8381. 

  8381.   const GLubyte* s;
    8382. 

  8382.   GLuint dot;
    8383. 

  8383.   GLint major, minor;
    8384. 

  8384.   const GLubyte* extStart;
    8385. 

  8385.   const GLubyte* extEnd;
    8386. 

  8386.   /* query opengl version */
    8387. 

  8387.   s = glGetString(GL_VERSION);
    8388. 

  8388.   dot = _glewStrCLen(s, '.');
    8389. 

  8389.   if (dot == 0)
    8390. 

  8390.     return GLEW_ERROR_NO_GL_VERSION;
    8391. 

  8391.   
    8392. 

  8392.   major = s[dot-1]-'0';
    8393. 

  8393.   minor = s[dot+1]-'0';
    8394. 

  8394. 

  8395.   if (minor < 0 || minor > 9)
    8396. 

  8396.     minor = 0;
    8397. 

  8397.   if (major<0 || major>9)
    8398. 

  8398.     return GLEW_ERROR_NO_GL_VERSION;
    8399. 

  8399.   
    8400. 

  8400. 

  8401.   if (major == 1 && minor == 0)
    8402. 

  8402.   {
    8403. 

  8403.     return GLEW_ERROR_GL_VERSION_10_ONLY;
    8404. 

  8404.   }
    8405. 

  8405.   else
    8406. 

  8406.   {
    8407. 

  8407.     CONST_CAST(GLEW_VERSION_4_2)   = ( major > 4 )                 || ( major == 4 && minor >= 2 ) ? GL_TRUE : GL_FALSE;
    8408. 

  8408.     CONST_CAST(GLEW_VERSION_4_1)   = GLEW_VERSION_4_2   == GL_TRUE || ( major == 4 && minor >= 1 ) ? GL_TRUE : GL_FALSE;
    8409. 

  8409.     CONST_CAST(GLEW_VERSION_4_0)   = GLEW_VERSION_4_1   == GL_TRUE || ( major == 4               ) ? GL_TRUE : GL_FALSE;
    8410. 

  8410.     CONST_CAST(GLEW_VERSION_3_3)   = GLEW_VERSION_4_0   == GL_TRUE || ( major == 3 && minor >= 3 ) ? GL_TRUE : GL_FALSE;
    8411. 

  8411.     CONST_CAST(GLEW_VERSION_3_2)   = GLEW_VERSION_3_3   == GL_TRUE || ( major == 3 && minor >= 2 ) ? GL_TRUE : GL_FALSE;
    8412. 

  8412.     CONST_CAST(GLEW_VERSION_3_1)   = GLEW_VERSION_3_2   == GL_TRUE || ( major == 3 && minor >= 1 ) ? GL_TRUE : GL_FALSE;
    8413. 

  8413.     CONST_CAST(GLEW_VERSION_3_0)   = GLEW_VERSION_3_1   == GL_TRUE || ( major == 3               ) ? GL_TRUE : GL_FALSE;
    8414. 

  8414.     CONST_CAST(GLEW_VERSION_2_1)   = GLEW_VERSION_3_0   == GL_TRUE || ( major == 2 && minor >= 1 ) ? GL_TRUE : GL_FALSE;    
    8415. 

  8415.     CONST_CAST(GLEW_VERSION_2_0)   = GLEW_VERSION_2_1   == GL_TRUE || ( major == 2               ) ? GL_TRUE : GL_FALSE;
    8416. 

  8416.     CONST_CAST(GLEW_VERSION_1_5)   = GLEW_VERSION_2_0   == GL_TRUE || ( major == 1 && minor >= 5 ) ? GL_TRUE : GL_FALSE;
    8417. 

  8417.     CONST_CAST(GLEW_VERSION_1_4)   = GLEW_VERSION_1_5   == GL_TRUE || ( major == 1 && minor >= 4 ) ? GL_TRUE : GL_FALSE;
    8418. 

  8418.     CONST_CAST(GLEW_VERSION_1_3)   = GLEW_VERSION_1_4   == GL_TRUE || ( major == 1 && minor >= 3 ) ? GL_TRUE : GL_FALSE;
    8419. 

  8419.     CONST_CAST(GLEW_VERSION_1_2_1) = GLEW_VERSION_1_3   == GL_TRUE                                 ? GL_TRUE : GL_FALSE; 
    8420. 

  8420.     CONST_CAST(GLEW_VERSION_1_2)   = GLEW_VERSION_1_2_1 == GL_TRUE || ( major == 1 && minor >= 2 ) ? GL_TRUE : GL_FALSE;
    8421. 

  8421.     CONST_CAST(GLEW_VERSION_1_1)   = GLEW_VERSION_1_2   == GL_TRUE || ( major == 1 && minor >= 1 ) ? GL_TRUE : GL_FALSE;
    8422. 

  8422.   }
    8423. 

  8423. 

  8424.   /* query opengl extensions string */
    8425. 

  8425.   extStart = glGetString(GL_EXTENSIONS);
    8426. 

  8426.   if (extStart == 0)
    8427. 

  8427.     extStart = (const GLubyte*)"";
    8428. 

  8428.   extEnd = extStart + _glewStrLen(extStart);
    8429. 

  8429. 

  8430.   /* initialize extensions */
    8431. 

  8431. #ifdef GL_VERSION_1_2
    8432. 

  8432.   if (glewExperimental || GLEW_VERSION_1_2) CONST_CAST(GLEW_VERSION_1_2) = !_glewInit_GL_VERSION_1_2(GLEW_CONTEXT_ARG_VAR_INIT);
    8433. 

  8433. #endif /* GL_VERSION_1_2 */
    8434. 

  8434. #ifdef GL_VERSION_1_2_1
    8435. 

  8435. #endif /* GL_VERSION_1_2_1 */
    8436. 

  8436. #ifdef GL_VERSION_1_3
    8437. 

  8437.   if (glewExperimental || GLEW_VERSION_1_3) CONST_CAST(GLEW_VERSION_1_3) = !_glewInit_GL_VERSION_1_3(GLEW_CONTEXT_ARG_VAR_INIT);
    8438. 

  8438. #endif /* GL_VERSION_1_3 */
    8439. 

  8439. #ifdef GL_VERSION_1_4
    8440. 

  8440.   if (glewExperimental || GLEW_VERSION_1_4) CONST_CAST(GLEW_VERSION_1_4) = !_glewInit_GL_VERSION_1_4(GLEW_CONTEXT_ARG_VAR_INIT);
    8441. 

  8441. #endif /* GL_VERSION_1_4 */
    8442. 

  8442. #ifdef GL_VERSION_1_5
    8443. 

  8443.   if (glewExperimental || GLEW_VERSION_1_5) CONST_CAST(GLEW_VERSION_1_5) = !_glewInit_GL_VERSION_1_5(GLEW_CONTEXT_ARG_VAR_INIT);
    8444. 

  8444. #endif /* GL_VERSION_1_5 */
    8445. 

  8445. #ifdef GL_VERSION_2_0
    8446. 

  8446.   if (glewExperimental || GLEW_VERSION_2_0) CONST_CAST(GLEW_VERSION_2_0) = !_glewInit_GL_VERSION_2_0(GLEW_CONTEXT_ARG_VAR_INIT);
    8447. 

  8447. #endif /* GL_VERSION_2_0 */
    8448. 

  8448. #ifdef GL_VERSION_2_1
    8449. 

  8449.   if (glewExperimental || GLEW_VERSION_2_1) CONST_CAST(GLEW_VERSION_2_1) = !_glewInit_GL_VERSION_2_1(GLEW_CONTEXT_ARG_VAR_INIT);
    8450. 

  8450. #endif /* GL_VERSION_2_1 */
    8451. 

  8451. #ifdef GL_VERSION_3_0
    8452. 

  8452.   if (glewExperimental || GLEW_VERSION_3_0) CONST_CAST(GLEW_VERSION_3_0) = !_glewInit_GL_VERSION_3_0(GLEW_CONTEXT_ARG_VAR_INIT);
    8453. 

  8453. #endif /* GL_VERSION_3_0 */
    8454. 

  8454. #ifdef GL_VERSION_3_1
    8455. 

  8455.   if (glewExperimental || GLEW_VERSION_3_1) CONST_CAST(GLEW_VERSION_3_1) = !_glewInit_GL_VERSION_3_1(GLEW_CONTEXT_ARG_VAR_INIT);
    8456. 

  8456. #endif /* GL_VERSION_3_1 */
    8457. 

  8457. #ifdef GL_VERSION_3_2
    8458. 

  8458.   if (glewExperimental || GLEW_VERSION_3_2) CONST_CAST(GLEW_VERSION_3_2) = !_glewInit_GL_VERSION_3_2(GLEW_CONTEXT_ARG_VAR_INIT);
    8459. 

  8459. #endif /* GL_VERSION_3_2 */
    8460. 

  8460. #ifdef GL_VERSION_3_3
    8461. 

  8461.   if (glewExperimental || GLEW_VERSION_3_3) CONST_CAST(GLEW_VERSION_3_3) = !_glewInit_GL_VERSION_3_3(GLEW_CONTEXT_ARG_VAR_INIT);
    8462. 

  8462. #endif /* GL_VERSION_3_3 */
    8463. 

  8463. #ifdef GL_VERSION_4_0
    8464. 

  8464.   if (glewExperimental || GLEW_VERSION_4_0) CONST_CAST(GLEW_VERSION_4_0) = !_glewInit_GL_VERSION_4_0(GLEW_CONTEXT_ARG_VAR_INIT);
    8465. 

  8465. #endif /* GL_VERSION_4_0 */
    8466. 

  8466. #ifdef GL_VERSION_4_1
    8467. 

  8467. #endif /* GL_VERSION_4_1 */
    8468. 

  8468. #ifdef GL_VERSION_4_2
    8469. 

  8469. #endif /* GL_VERSION_4_2 */
    8470. 

  8470. #ifdef GL_3DFX_multisample
    8471. 

  8471.   CONST_CAST(GLEW_3DFX_multisample) = _glewSearchExtension("GL_3DFX_multisample", extStart, extEnd);
    8472. 

  8472. #endif /* GL_3DFX_multisample */
    8473. 

  8473. #ifdef GL_3DFX_tbuffer
    8474. 

  8474.   CONST_CAST(GLEW_3DFX_tbuffer) = _glewSearchExtension("GL_3DFX_tbuffer", extStart, extEnd);
    8475. 

  8475.   if (glewExperimental || GLEW_3DFX_tbuffer) CONST_CAST(GLEW_3DFX_tbuffer) = !_glewInit_GL_3DFX_tbuffer(GLEW_CONTEXT_ARG_VAR_INIT);
    8476. 

  8476. #endif /* GL_3DFX_tbuffer */
    8477. 

  8477. #ifdef GL_3DFX_texture_compression_FXT1
    8478. 

  8478.   CONST_CAST(GLEW_3DFX_texture_compression_FXT1) = _glewSearchExtension("GL_3DFX_texture_compression_FXT1", extStart, extEnd);
    8479. 

  8479. #endif /* GL_3DFX_texture_compression_FXT1 */
    8480. 

  8480. #ifdef GL_AMD_blend_minmax_factor
    8481. 

  8481.   CONST_CAST(GLEW_AMD_blend_minmax_factor) = _glewSearchExtension("GL_AMD_blend_minmax_factor", extStart, extEnd);
    8482. 

  8482. #endif /* GL_AMD_blend_minmax_factor */
    8483. 

  8483. #ifdef GL_AMD_conservative_depth
    8484. 

  8484.   CONST_CAST(GLEW_AMD_conservative_depth) = _glewSearchExtension("GL_AMD_conservative_depth", extStart, extEnd);
    8485. 

  8485. #endif /* GL_AMD_conservative_depth */
    8486. 

  8486. #ifdef GL_AMD_debug_output
    8487. 

  8487.   CONST_CAST(GLEW_AMD_debug_output) = _glewSearchExtension("GL_AMD_debug_output", extStart, extEnd);
    8488. 

  8488.   if (glewExperimental || GLEW_AMD_debug_output) CONST_CAST(GLEW_AMD_debug_output) = !_glewInit_GL_AMD_debug_output(GLEW_CONTEXT_ARG_VAR_INIT);
    8489. 

  8489. #endif /* GL_AMD_debug_output */
    8490. 

  8490. #ifdef GL_AMD_depth_clamp_separate
    8491. 

  8491.   CONST_CAST(GLEW_AMD_depth_clamp_separate) = _glewSearchExtension("GL_AMD_depth_clamp_separate", extStart, extEnd);
    8492. 

  8492. #endif /* GL_AMD_depth_clamp_separate */
    8493. 

  8493. #ifdef GL_AMD_draw_buffers_blend
    8494. 

  8494.   CONST_CAST(GLEW_AMD_draw_buffers_blend) = _glewSearchExtension("GL_AMD_draw_buffers_blend", extStart, extEnd);
    8495. 

  8495.   if (glewExperimental || GLEW_AMD_draw_buffers_blend) CONST_CAST(GLEW_AMD_draw_buffers_blend) = !_glewInit_GL_AMD_draw_buffers_blend(GLEW_CONTEXT_ARG_VAR_INIT);
    8496. 

  8496. #endif /* GL_AMD_draw_buffers_blend */
    8497. 

  8497. #ifdef GL_AMD_multi_draw_indirect
    8498. 

  8498.   CONST_CAST(GLEW_AMD_multi_draw_indirect) = _glewSearchExtension("GL_AMD_multi_draw_indirect", extStart, extEnd);
    8499. 

  8499.   if (glewExperimental || GLEW_AMD_multi_draw_indirect) CONST_CAST(GLEW_AMD_multi_draw_indirect) = !_glewInit_GL_AMD_multi_draw_indirect(GLEW_CONTEXT_ARG_VAR_INIT);
    8500. 

  8500. #endif /* GL_AMD_multi_draw_indirect */
    8501. 

  8501. #ifdef GL_AMD_name_gen_delete
    8502. 

  8502.   CONST_CAST(GLEW_AMD_name_gen_delete) = _glewSearchExtension("GL_AMD_name_gen_delete", extStart, extEnd);
    8503. 

  8503.   if (glewExperimental || GLEW_AMD_name_gen_delete) CONST_CAST(GLEW_AMD_name_gen_delete) = !_glewInit_GL_AMD_name_gen_delete(GLEW_CONTEXT_ARG_VAR_INIT);
    8504. 

  8504. #endif /* GL_AMD_name_gen_delete */
    8505. 

  8505. #ifdef GL_AMD_performance_monitor
    8506. 

  8506.   CONST_CAST(GLEW_AMD_performance_monitor) = _glewSearchExtension("GL_AMD_performance_monitor", extStart, extEnd);
    8507. 

  8507.   if (glewExperimental || GLEW_AMD_performance_monitor) CONST_CAST(GLEW_AMD_performance_monitor) = !_glewInit_GL_AMD_performance_monitor(GLEW_CONTEXT_ARG_VAR_INIT);
    8508. 

  8508. #endif /* GL_AMD_performance_monitor */
    8509. 

  8509. #ifdef GL_AMD_sample_positions
    8510. 

  8510.   CONST_CAST(GLEW_AMD_sample_positions) = _glewSearchExtension("GL_AMD_sample_positions", extStart, extEnd);
    8511. 

  8511.   if (glewExperimental || GLEW_AMD_sample_positions) CONST_CAST(GLEW_AMD_sample_positions) = !_glewInit_GL_AMD_sample_positions(GLEW_CONTEXT_ARG_VAR_INIT);
    8512. 

  8512. #endif /* GL_AMD_sample_positions */
    8513. 

  8513. #ifdef GL_AMD_seamless_cubemap_per_texture
    8514. 

  8514.   CONST_CAST(GLEW_AMD_seamless_cubemap_per_texture) = _glewSearchExtension("GL_AMD_seamless_cubemap_per_texture", extStart, extEnd);
    8515. 

  8515. #endif /* GL_AMD_seamless_cubemap_per_texture */
    8516. 

  8516. #ifdef GL_AMD_shader_stencil_export
    8517. 

  8517.   CONST_CAST(GLEW_AMD_shader_stencil_export) = _glewSearchExtension("GL_AMD_shader_stencil_export", extStart, extEnd);
    8518. 

  8518. #endif /* GL_AMD_shader_stencil_export */
    8519. 

  8519. #ifdef GL_AMD_texture_texture4
    8520. 

  8520.   CONST_CAST(GLEW_AMD_texture_texture4) = _glewSearchExtension("GL_AMD_texture_texture4", extStart, extEnd);
    8521. 

  8521. #endif /* GL_AMD_texture_texture4 */
    8522. 

  8522. #ifdef GL_AMD_transform_feedback3_lines_triangles
    8523. 

  8523.   CONST_CAST(GLEW_AMD_transform_feedback3_lines_triangles) = _glewSearchExtension("GL_AMD_transform_feedback3_lines_triangles", extStart, extEnd);
    8524. 

  8524. #endif /* GL_AMD_transform_feedback3_lines_triangles */
    8525. 

  8525. #ifdef GL_AMD_vertex_shader_tessellator
    8526. 

  8526.   CONST_CAST(GLEW_AMD_vertex_shader_tessellator) = _glewSearchExtension("GL_AMD_vertex_shader_tessellator", extStart, extEnd);
    8527. 

  8527.   if (glewExperimental || GLEW_AMD_vertex_shader_tessellator) CONST_CAST(GLEW_AMD_vertex_shader_tessellator) = !_glewInit_GL_AMD_vertex_shader_tessellator(GLEW_CONTEXT_ARG_VAR_INIT);
    8528. 

  8528. #endif /* GL_AMD_vertex_shader_tessellator */
    8529. 

  8529. #ifdef GL_APPLE_aux_depth_stencil
    8530. 

  8530.   CONST_CAST(GLEW_APPLE_aux_depth_stencil) = _glewSearchExtension("GL_APPLE_aux_depth_stencil", extStart, extEnd);
    8531. 

  8531. #endif /* GL_APPLE_aux_depth_stencil */
    8532. 

  8532. #ifdef GL_APPLE_client_storage
    8533. 

  8533.   CONST_CAST(GLEW_APPLE_client_storage) = _glewSearchExtension("GL_APPLE_client_storage", extStart, extEnd);
    8534. 

  8534. #endif /* GL_APPLE_client_storage */
    8535. 

  8535. #ifdef GL_APPLE_element_array
    8536. 

  8536.   CONST_CAST(GLEW_APPLE_element_array) = _glewSearchExtension("GL_APPLE_element_array", extStart, extEnd);
    8537. 

  8537.   if (glewExperimental || GLEW_APPLE_element_array) CONST_CAST(GLEW_APPLE_element_array) = !_glewInit_GL_APPLE_element_array(GLEW_CONTEXT_ARG_VAR_INIT);
    8538. 

  8538. #endif /* GL_APPLE_element_array */
    8539. 

  8539. #ifdef GL_APPLE_fence
    8540. 

  8540.   CONST_CAST(GLEW_APPLE_fence) = _glewSearchExtension("GL_APPLE_fence", extStart, extEnd);
    8541. 

  8541.   if (glewExperimental || GLEW_APPLE_fence) CONST_CAST(GLEW_APPLE_fence) = !_glewInit_GL_APPLE_fence(GLEW_CONTEXT_ARG_VAR_INIT);
    8542. 

  8542. #endif /* GL_APPLE_fence */
    8543. 

  8543. #ifdef GL_APPLE_float_pixels
    8544. 

  8544.   CONST_CAST(GLEW_APPLE_float_pixels) = _glewSearchExtension("GL_APPLE_float_pixels", extStart, extEnd);
    8545. 

  8545. #endif /* GL_APPLE_float_pixels */
    8546. 

  8546. #ifdef GL_APPLE_flush_buffer_range
    8547. 

  8547.   CONST_CAST(GLEW_APPLE_flush_buffer_range) = _glewSearchExtension("GL_APPLE_flush_buffer_range", extStart, extEnd);
    8548. 

  8548.   if (glewExperimental || GLEW_APPLE_flush_buffer_range) CONST_CAST(GLEW_APPLE_flush_buffer_range) = !_glewInit_GL_APPLE_flush_buffer_range(GLEW_CONTEXT_ARG_VAR_INIT);
    8549. 

  8549. #endif /* GL_APPLE_flush_buffer_range */
    8550. 

  8550. #ifdef GL_APPLE_object_purgeable
    8551. 

  8551.   CONST_CAST(GLEW_APPLE_object_purgeable) = _glewSearchExtension("GL_APPLE_object_purgeable", extStart, extEnd);
    8552. 

  8552.   if (glewExperimental || GLEW_APPLE_object_purgeable) CONST_CAST(GLEW_APPLE_object_purgeable) = !_glewInit_GL_APPLE_object_purgeable(GLEW_CONTEXT_ARG_VAR_INIT);
    8553. 

  8553. #endif /* GL_APPLE_object_purgeable */
    8554. 

  8554. #ifdef GL_APPLE_pixel_buffer
    8555. 

  8555.   CONST_CAST(GLEW_APPLE_pixel_buffer) = _glewSearchExtension("GL_APPLE_pixel_buffer", extStart, extEnd);
    8556. 

  8556. #endif /* GL_APPLE_pixel_buffer */
    8557. 

  8557. #ifdef GL_APPLE_rgb_422
    8558. 

  8558.   CONST_CAST(GLEW_APPLE_rgb_422) = _glewSearchExtension("GL_APPLE_rgb_422", extStart, extEnd);
    8559. 

  8559. #endif /* GL_APPLE_rgb_422 */
    8560. 

  8560. #ifdef GL_APPLE_row_bytes
    8561. 

  8561.   CONST_CAST(GLEW_APPLE_row_bytes) = _glewSearchExtension("GL_APPLE_row_bytes", extStart, extEnd);
    8562. 

  8562. #endif /* GL_APPLE_row_bytes */
    8563. 

  8563. #ifdef GL_APPLE_specular_vector
    8564. 

  8564.   CONST_CAST(GLEW_APPLE_specular_vector) = _glewSearchExtension("GL_APPLE_specular_vector", extStart, extEnd);
    8565. 

  8565. #endif /* GL_APPLE_specular_vector */
    8566. 

  8566. #ifdef GL_APPLE_texture_range
    8567. 

  8567.   CONST_CAST(GLEW_APPLE_texture_range) = _glewSearchExtension("GL_APPLE_texture_range", extStart, extEnd);
    8568. 

  8568.   if (glewExperimental || GLEW_APPLE_texture_range) CONST_CAST(GLEW_APPLE_texture_range) = !_glewInit_GL_APPLE_texture_range(GLEW_CONTEXT_ARG_VAR_INIT);
    8569. 

  8569. #endif /* GL_APPLE_texture_range */
    8570. 

  8570. #ifdef GL_APPLE_transform_hint
    8571. 

  8571.   CONST_CAST(GLEW_APPLE_transform_hint) = _glewSearchExtension("GL_APPLE_transform_hint", extStart, extEnd);
    8572. 

  8572. #endif /* GL_APPLE_transform_hint */
    8573. 

  8573. #ifdef GL_APPLE_vertex_array_object
    8574. 

  8574.   CONST_CAST(GLEW_APPLE_vertex_array_object) = _glewSearchExtension("GL_APPLE_vertex_array_object", extStart, extEnd);
    8575. 

  8575.   if (glewExperimental || GLEW_APPLE_vertex_array_object) CONST_CAST(GLEW_APPLE_vertex_array_object) = !_glewInit_GL_APPLE_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT);
    8576. 

  8576. #endif /* GL_APPLE_vertex_array_object */
    8577. 

  8577. #ifdef GL_APPLE_vertex_array_range
    8578. 

  8578.   CONST_CAST(GLEW_APPLE_vertex_array_range) = _glewSearchExtension("GL_APPLE_vertex_array_range", extStart, extEnd);
    8579. 

  8579.   if (glewExperimental || GLEW_APPLE_vertex_array_range) CONST_CAST(GLEW_APPLE_vertex_array_range) = !_glewInit_GL_APPLE_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);
    8580. 

  8580. #endif /* GL_APPLE_vertex_array_range */
    8581. 

  8581. #ifdef GL_APPLE_vertex_program_evaluators
    8582. 

  8582.   CONST_CAST(GLEW_APPLE_vertex_program_evaluators) = _glewSearchExtension("GL_APPLE_vertex_program_evaluators", extStart, extEnd);
    8583. 

  8583.   if (glewExperimental || GLEW_APPLE_vertex_program_evaluators) CONST_CAST(GLEW_APPLE_vertex_program_evaluators) = !_glewInit_GL_APPLE_vertex_program_evaluators(GLEW_CONTEXT_ARG_VAR_INIT);
    8584. 

  8584. #endif /* GL_APPLE_vertex_program_evaluators */
    8585. 

  8585. #ifdef GL_APPLE_ycbcr_422
    8586. 

  8586.   CONST_CAST(GLEW_APPLE_ycbcr_422) = _glewSearchExtension("GL_APPLE_ycbcr_422", extStart, extEnd);
    8587. 

  8587. #endif /* GL_APPLE_ycbcr_422 */
    8588. 

  8588. #ifdef GL_ARB_ES2_compatibility
    8589. 

  8589.   CONST_CAST(GLEW_ARB_ES2_compatibility) = _glewSearchExtension("GL_ARB_ES2_compatibility", extStart, extEnd);
    8590. 

  8590.   if (glewExperimental || GLEW_ARB_ES2_compatibility) CONST_CAST(GLEW_ARB_ES2_compatibility) = !_glewInit_GL_ARB_ES2_compatibility(GLEW_CONTEXT_ARG_VAR_INIT);
    8591. 

  8591. #endif /* GL_ARB_ES2_compatibility */
    8592. 

  8592. #ifdef GL_ARB_base_instance
    8593. 

  8593.   CONST_CAST(GLEW_ARB_base_instance) = _glewSearchExtension("GL_ARB_base_instance", extStart, extEnd);
    8594. 

  8594.   if (glewExperimental || GLEW_ARB_base_instance) CONST_CAST(GLEW_ARB_base_instance) = !_glewInit_GL_ARB_base_instance(GLEW_CONTEXT_ARG_VAR_INIT);
    8595. 

  8595. #endif /* GL_ARB_base_instance */
    8596. 

  8596. #ifdef GL_ARB_blend_func_extended
    8597. 

  8597.   CONST_CAST(GLEW_ARB_blend_func_extended) = _glewSearchExtension("GL_ARB_blend_func_extended", extStart, extEnd);
    8598. 

  8598.   if (glewExperimental || GLEW_ARB_blend_func_extended) CONST_CAST(GLEW_ARB_blend_func_extended) = !_glewInit_GL_ARB_blend_func_extended(GLEW_CONTEXT_ARG_VAR_INIT);
    8599. 

  8599. #endif /* GL_ARB_blend_func_extended */
    8600. 

  8600. #ifdef GL_ARB_cl_event
    8601. 

  8601.   CONST_CAST(GLEW_ARB_cl_event) = _glewSearchExtension("GL_ARB_cl_event", extStart, extEnd);
    8602. 

  8602.   if (glewExperimental || GLEW_ARB_cl_event) CONST_CAST(GLEW_ARB_cl_event) = !_glewInit_GL_ARB_cl_event(GLEW_CONTEXT_ARG_VAR_INIT);
    8603. 

  8603. #endif /* GL_ARB_cl_event */
    8604. 

  8604. #ifdef GL_ARB_color_buffer_float
    8605. 

  8605.   CONST_CAST(GLEW_ARB_color_buffer_float) = _glewSearchExtension("GL_ARB_color_buffer_float", extStart, extEnd);
    8606. 

  8606.   if (glewExperimental || GLEW_ARB_color_buffer_float) CONST_CAST(GLEW_ARB_color_buffer_float) = !_glewInit_GL_ARB_color_buffer_float(GLEW_CONTEXT_ARG_VAR_INIT);
    8607. 

  8607. #endif /* GL_ARB_color_buffer_float */
    8608. 

  8608. #ifdef GL_ARB_compatibility
    8609. 

  8609.   CONST_CAST(GLEW_ARB_compatibility) = _glewSearchExtension("GL_ARB_compatibility", extStart, extEnd);
    8610. 

  8610. #endif /* GL_ARB_compatibility */
    8611. 

  8611. #ifdef GL_ARB_compressed_texture_pixel_storage
    8612. 

  8612.   CONST_CAST(GLEW_ARB_compressed_texture_pixel_storage) = _glewSearchExtension("GL_ARB_compressed_texture_pixel_storage", extStart, extEnd);
    8613. 

  8613. #endif /* GL_ARB_compressed_texture_pixel_storage */
    8614. 

  8614. #ifdef GL_ARB_conservative_depth
    8615. 

  8615.   CONST_CAST(GLEW_ARB_conservative_depth) = _glewSearchExtension("GL_ARB_conservative_depth", extStart, extEnd);
    8616. 

  8616. #endif /* GL_ARB_conservative_depth */
    8617. 

  8617. #ifdef GL_ARB_copy_buffer
    8618. 

  8618.   CONST_CAST(GLEW_ARB_copy_buffer) = _glewSearchExtension("GL_ARB_copy_buffer", extStart, extEnd);
    8619. 

  8619.   if (glewExperimental || GLEW_ARB_copy_buffer) CONST_CAST(GLEW_ARB_copy_buffer) = !_glewInit_GL_ARB_copy_buffer(GLEW_CONTEXT_ARG_VAR_INIT);
    8620. 

  8620. #endif /* GL_ARB_copy_buffer */
    8621. 

  8621. #ifdef GL_ARB_debug_output
    8622. 

  8622.   CONST_CAST(GLEW_ARB_debug_output) = _glewSearchExtension("GL_ARB_debug_output", extStart, extEnd);
    8623. 

  8623.   if (glewExperimental || GLEW_ARB_debug_output) CONST_CAST(GLEW_ARB_debug_output) = !_glewInit_GL_ARB_debug_output(GLEW_CONTEXT_ARG_VAR_INIT);
    8624. 

  8624. #endif /* GL_ARB_debug_output */
    8625. 

  8625. #ifdef GL_ARB_depth_buffer_float
    8626. 

  8626.   CONST_CAST(GLEW_ARB_depth_buffer_float) = _glewSearchExtension("GL_ARB_depth_buffer_float", extStart, extEnd);
    8627. 

  8627. #endif /* GL_ARB_depth_buffer_float */
    8628. 

  8628. #ifdef GL_ARB_depth_clamp
    8629. 

  8629.   CONST_CAST(GLEW_ARB_depth_clamp) = _glewSearchExtension("GL_ARB_depth_clamp", extStart, extEnd);
    8630. 

  8630. #endif /* GL_ARB_depth_clamp */
    8631. 

  8631. #ifdef GL_ARB_depth_texture
    8632. 

  8632.   CONST_CAST(GLEW_ARB_depth_texture) = _glewSearchExtension("GL_ARB_depth_texture", extStart, extEnd);
    8633. 

  8633. #endif /* GL_ARB_depth_texture */
    8634. 

  8634. #ifdef GL_ARB_draw_buffers
    8635. 

  8635.   CONST_CAST(GLEW_ARB_draw_buffers) = _glewSearchExtension("GL_ARB_draw_buffers", extStart, extEnd);
    8636. 

  8636.   if (glewExperimental || GLEW_ARB_draw_buffers) CONST_CAST(GLEW_ARB_draw_buffers) = !_glewInit_GL_ARB_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT);
    8637. 

  8637. #endif /* GL_ARB_draw_buffers */
    8638. 

  8638. #ifdef GL_ARB_draw_buffers_blend
    8639. 

  8639.   CONST_CAST(GLEW_ARB_draw_buffers_blend) = _glewSearchExtension("GL_ARB_draw_buffers_blend", extStart, extEnd);
    8640. 

  8640.   if (glewExperimental || GLEW_ARB_draw_buffers_blend) CONST_CAST(GLEW_ARB_draw_buffers_blend) = !_glewInit_GL_ARB_draw_buffers_blend(GLEW_CONTEXT_ARG_VAR_INIT);
    8641. 

  8641. #endif /* GL_ARB_draw_buffers_blend */
    8642. 

  8642. #ifdef GL_ARB_draw_elements_base_vertex
    8643. 

  8643.   CONST_CAST(GLEW_ARB_draw_elements_base_vertex) = _glewSearchExtension("GL_ARB_draw_elements_base_vertex", extStart, extEnd);
    8644. 

  8644.   if (glewExperimental || GLEW_ARB_draw_elements_base_vertex) CONST_CAST(GLEW_ARB_draw_elements_base_vertex) = !_glewInit_GL_ARB_draw_elements_base_vertex(GLEW_CONTEXT_ARG_VAR_INIT);
    8645. 

  8645. #endif /* GL_ARB_draw_elements_base_vertex */
    8646. 

  8646. #ifdef GL_ARB_draw_indirect
    8647. 

  8647.   CONST_CAST(GLEW_ARB_draw_indirect) = _glewSearchExtension("GL_ARB_draw_indirect", extStart, extEnd);
    8648. 

  8648.   if (glewExperimental || GLEW_ARB_draw_indirect) CONST_CAST(GLEW_ARB_draw_indirect) = !_glewInit_GL_ARB_draw_indirect(GLEW_CONTEXT_ARG_VAR_INIT);
    8649. 

  8649. #endif /* GL_ARB_draw_indirect */
    8650. 

  8650. #ifdef GL_ARB_draw_instanced
    8651. 

  8651.   CONST_CAST(GLEW_ARB_draw_instanced) = _glewSearchExtension("GL_ARB_draw_instanced", extStart, extEnd);
    8652. 

  8652. #endif /* GL_ARB_draw_instanced */
    8653. 

  8653. #ifdef GL_ARB_explicit_attrib_location
    8654. 

  8654.   CONST_CAST(GLEW_ARB_explicit_attrib_location) = _glewSearchExtension("GL_ARB_explicit_attrib_location", extStart, extEnd);
    8655. 

  8655. #endif /* GL_ARB_explicit_attrib_location */
    8656. 

  8656. #ifdef GL_ARB_fragment_coord_conventions
    8657. 

  8657.   CONST_CAST(GLEW_ARB_fragment_coord_conventions) = _glewSearchExtension("GL_ARB_fragment_coord_conventions", extStart, extEnd);
    8658. 

  8658. #endif /* GL_ARB_fragment_coord_conventions */
    8659. 

  8659. #ifdef GL_ARB_fragment_program
    8660. 

  8660.   CONST_CAST(GLEW_ARB_fragment_program) = _glewSearchExtension("GL_ARB_fragment_program", extStart, extEnd);
    8661. 

  8661. #endif /* GL_ARB_fragment_program */
    8662. 

  8662. #ifdef GL_ARB_fragment_program_shadow
    8663. 

  8663.   CONST_CAST(GLEW_ARB_fragment_program_shadow) = _glewSearchExtension("GL_ARB_fragment_program_shadow", extStart, extEnd);
    8664. 

  8664. #endif /* GL_ARB_fragment_program_shadow */
    8665. 

  8665. #ifdef GL_ARB_fragment_shader
    8666. 

  8666.   CONST_CAST(GLEW_ARB_fragment_shader) = _glewSearchExtension("GL_ARB_fragment_shader", extStart, extEnd);
    8667. 

  8667. #endif /* GL_ARB_fragment_shader */
    8668. 

  8668. #ifdef GL_ARB_framebuffer_object
    8669. 

  8669.   CONST_CAST(GLEW_ARB_framebuffer_object) = _glewSearchExtension("GL_ARB_framebuffer_object", extStart, extEnd);
    8670. 

  8670.   if (glewExperimental || GLEW_ARB_framebuffer_object) CONST_CAST(GLEW_ARB_framebuffer_object) = !_glewInit_GL_ARB_framebuffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
    8671. 

  8671. #endif /* GL_ARB_framebuffer_object */
    8672. 

  8672. #ifdef GL_ARB_framebuffer_sRGB
    8673. 

  8673.   CONST_CAST(GLEW_ARB_framebuffer_sRGB) = _glewSearchExtension("GL_ARB_framebuffer_sRGB", extStart, extEnd);
    8674. 

  8674. #endif /* GL_ARB_framebuffer_sRGB */
    8675. 

  8675. #ifdef GL_ARB_geometry_shader4
    8676. 

  8676.   CONST_CAST(GLEW_ARB_geometry_shader4) = _glewSearchExtension("GL_ARB_geometry_shader4", extStart, extEnd);
    8677. 

  8677.   if (glewExperimental || GLEW_ARB_geometry_shader4) CONST_CAST(GLEW_ARB_geometry_shader4) = !_glewInit_GL_ARB_geometry_shader4(GLEW_CONTEXT_ARG_VAR_INIT);
    8678. 

  8678. #endif /* GL_ARB_geometry_shader4 */
    8679. 

  8679. #ifdef GL_ARB_get_program_binary
    8680. 

  8680.   CONST_CAST(GLEW_ARB_get_program_binary) = _glewSearchExtension("GL_ARB_get_program_binary", extStart, extEnd);
    8681. 

  8681.   if (glewExperimental || GLEW_ARB_get_program_binary) CONST_CAST(GLEW_ARB_get_program_binary) = !_glewInit_GL_ARB_get_program_binary(GLEW_CONTEXT_ARG_VAR_INIT);
    8682. 

  8682. #endif /* GL_ARB_get_program_binary */
    8683. 

  8683. #ifdef GL_ARB_gpu_shader5
    8684. 

  8684.   CONST_CAST(GLEW_ARB_gpu_shader5) = _glewSearchExtension("GL_ARB_gpu_shader5", extStart, extEnd);
    8685. 

  8685. #endif /* GL_ARB_gpu_shader5 */
    8686. 

  8686. #ifdef GL_ARB_gpu_shader_fp64
    8687. 

  8687.   CONST_CAST(GLEW_ARB_gpu_shader_fp64) = _glewSearchExtension("GL_ARB_gpu_shader_fp64", extStart, extEnd);
    8688. 

  8688.   if (glewExperimental || GLEW_ARB_gpu_shader_fp64) CONST_CAST(GLEW_ARB_gpu_shader_fp64) = !_glewInit_GL_ARB_gpu_shader_fp64(GLEW_CONTEXT_ARG_VAR_INIT);
    8689. 

  8689. #endif /* GL_ARB_gpu_shader_fp64 */
    8690. 

  8690. #ifdef GL_ARB_half_float_pixel
    8691. 

  8691.   CONST_CAST(GLEW_ARB_half_float_pixel) = _glewSearchExtension("GL_ARB_half_float_pixel", extStart, extEnd);
    8692. 

  8692. #endif /* GL_ARB_half_float_pixel */
    8693. 

  8693. #ifdef GL_ARB_half_float_vertex
    8694. 

  8694.   CONST_CAST(GLEW_ARB_half_float_vertex) = _glewSearchExtension("GL_ARB_half_float_vertex", extStart, extEnd);
    8695. 

  8695. #endif /* GL_ARB_half_float_vertex */
    8696. 

  8696. #ifdef GL_ARB_imaging
    8697. 

  8697.   CONST_CAST(GLEW_ARB_imaging) = _glewSearchExtension("GL_ARB_imaging", extStart, extEnd);
    8698. 

  8698.   if (glewExperimental || GLEW_ARB_imaging) CONST_CAST(GLEW_ARB_imaging) = !_glewInit_GL_ARB_imaging(GLEW_CONTEXT_ARG_VAR_INIT);
    8699. 

  8699. #endif /* GL_ARB_imaging */
    8700. 

  8700. #ifdef GL_ARB_instanced_arrays
    8701. 

  8701.   CONST_CAST(GLEW_ARB_instanced_arrays) = _glewSearchExtension("GL_ARB_instanced_arrays", extStart, extEnd);
    8702. 

  8702.   if (glewExperimental || GLEW_ARB_instanced_arrays) CONST_CAST(GLEW_ARB_instanced_arrays) = !_glewInit_GL_ARB_instanced_arrays(GLEW_CONTEXT_ARG_VAR_INIT);
    8703. 

  8703. #endif /* GL_ARB_instanced_arrays */
    8704. 

  8704. #ifdef GL_ARB_internalformat_query
    8705. 

  8705.   CONST_CAST(GLEW_ARB_internalformat_query) = _glewSearchExtension("GL_ARB_internalformat_query", extStart, extEnd);
    8706. 

  8706.   if (glewExperimental || GLEW_ARB_internalformat_query) CONST_CAST(GLEW_ARB_internalformat_query) = !_glewInit_GL_ARB_internalformat_query(GLEW_CONTEXT_ARG_VAR_INIT);
    8707. 

  8707. #endif /* GL_ARB_internalformat_query */
    8708. 

  8708. #ifdef GL_ARB_map_buffer_alignment
    8709. 

  8709.   CONST_CAST(GLEW_ARB_map_buffer_alignment) = _glewSearchExtension("GL_ARB_map_buffer_alignment", extStart, extEnd);
    8710. 

  8710. #endif /* GL_ARB_map_buffer_alignment */
    8711. 

  8711. #ifdef GL_ARB_map_buffer_range
    8712. 

  8712.   CONST_CAST(GLEW_ARB_map_buffer_range) = _glewSearchExtension("GL_ARB_map_buffer_range", extStart, extEnd);
    8713. 

  8713.   if (glewExperimental || GLEW_ARB_map_buffer_range) CONST_CAST(GLEW_ARB_map_buffer_range) = !_glewInit_GL_ARB_map_buffer_range(GLEW_CONTEXT_ARG_VAR_INIT);
    8714. 

  8714. #endif /* GL_ARB_map_buffer_range */
    8715. 

  8715. #ifdef GL_ARB_matrix_palette
    8716. 

  8716.   CONST_CAST(GLEW_ARB_matrix_palette) = _glewSearchExtension("GL_ARB_matrix_palette", extStart, extEnd);
    8717. 

  8717.   if (glewExperimental || GLEW_ARB_matrix_palette) CONST_CAST(GLEW_ARB_matrix_palette) = !_glewInit_GL_ARB_matrix_palette(GLEW_CONTEXT_ARG_VAR_INIT);
    8718. 

  8718. #endif /* GL_ARB_matrix_palette */
    8719. 

  8719. #ifdef GL_ARB_multisample
    8720. 

  8720.   CONST_CAST(GLEW_ARB_multisample) = _glewSearchExtension("GL_ARB_multisample", extStart, extEnd);
    8721. 

  8721.   if (glewExperimental || GLEW_ARB_multisample) CONST_CAST(GLEW_ARB_multisample) = !_glewInit_GL_ARB_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
    8722. 

  8722. #endif /* GL_ARB_multisample */
    8723. 

  8723. #ifdef GL_ARB_multitexture
    8724. 

  8724.   CONST_CAST(GLEW_ARB_multitexture) = _glewSearchExtension("GL_ARB_multitexture", extStart, extEnd);
    8725. 

  8725.   if (glewExperimental || GLEW_ARB_multitexture) CONST_CAST(GLEW_ARB_multitexture) = !_glewInit_GL_ARB_multitexture(GLEW_CONTEXT_ARG_VAR_INIT);
    8726. 

  8726. #endif /* GL_ARB_multitexture */
    8727. 

  8727. #ifdef GL_ARB_occlusion_query
    8728. 

  8728.   CONST_CAST(GLEW_ARB_occlusion_query) = _glewSearchExtension("GL_ARB_occlusion_query", extStart, extEnd);
    8729. 

  8729.   if (glewExperimental || GLEW_ARB_occlusion_query) CONST_CAST(GLEW_ARB_occlusion_query) = !_glewInit_GL_ARB_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT);
    8730. 

  8730. #endif /* GL_ARB_occlusion_query */
    8731. 

  8731. #ifdef GL_ARB_occlusion_query2
    8732. 

  8732.   CONST_CAST(GLEW_ARB_occlusion_query2) = _glewSearchExtension("GL_ARB_occlusion_query2", extStart, extEnd);
    8733. 

  8733. #endif /* GL_ARB_occlusion_query2 */
    8734. 

  8734. #ifdef GL_ARB_pixel_buffer_object
    8735. 

  8735.   CONST_CAST(GLEW_ARB_pixel_buffer_object) = _glewSearchExtension("GL_ARB_pixel_buffer_object", extStart, extEnd);
    8736. 

  8736. #endif /* GL_ARB_pixel_buffer_object */
    8737. 

  8737. #ifdef GL_ARB_point_parameters
    8738. 

  8738.   CONST_CAST(GLEW_ARB_point_parameters) = _glewSearchExtension("GL_ARB_point_parameters", extStart, extEnd);
    8739. 

  8739.   if (glewExperimental || GLEW_ARB_point_parameters) CONST_CAST(GLEW_ARB_point_parameters) = !_glewInit_GL_ARB_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT);
    8740. 

  8740. #endif /* GL_ARB_point_parameters */
    8741. 

  8741. #ifdef GL_ARB_point_sprite
    8742. 

  8742.   CONST_CAST(GLEW_ARB_point_sprite) = _glewSearchExtension("GL_ARB_point_sprite", extStart, extEnd);
    8743. 

  8743. #endif /* GL_ARB_point_sprite */
    8744. 

  8744. #ifdef GL_ARB_provoking_vertex
    8745. 

  8745.   CONST_CAST(GLEW_ARB_provoking_vertex) = _glewSearchExtension("GL_ARB_provoking_vertex", extStart, extEnd);
    8746. 

  8746.   if (glewExperimental || GLEW_ARB_provoking_vertex) CONST_CAST(GLEW_ARB_provoking_vertex) = !_glewInit_GL_ARB_provoking_vertex(GLEW_CONTEXT_ARG_VAR_INIT);
    8747. 

  8747. #endif /* GL_ARB_provoking_vertex */
    8748. 

  8748. #ifdef GL_ARB_robustness
    8749. 

  8749.   CONST_CAST(GLEW_ARB_robustness) = _glewSearchExtension("GL_ARB_robustness", extStart, extEnd);
    8750. 

  8750.   if (glewExperimental || GLEW_ARB_robustness) CONST_CAST(GLEW_ARB_robustness) = !_glewInit_GL_ARB_robustness(GLEW_CONTEXT_ARG_VAR_INIT);
    8751. 

  8751. #endif /* GL_ARB_robustness */
    8752. 

  8752. #ifdef GL_ARB_sample_shading
    8753. 

  8753.   CONST_CAST(GLEW_ARB_sample_shading) = _glewSearchExtension("GL_ARB_sample_shading", extStart, extEnd);
    8754. 

  8754.   if (glewExperimental || GLEW_ARB_sample_shading) CONST_CAST(GLEW_ARB_sample_shading) = !_glewInit_GL_ARB_sample_shading(GLEW_CONTEXT_ARG_VAR_INIT);
    8755. 

  8755. #endif /* GL_ARB_sample_shading */
    8756. 

  8756. #ifdef GL_ARB_sampler_objects
    8757. 

  8757.   CONST_CAST(GLEW_ARB_sampler_objects) = _glewSearchExtension("GL_ARB_sampler_objects", extStart, extEnd);
    8758. 

  8758.   if (glewExperimental || GLEW_ARB_sampler_objects) CONST_CAST(GLEW_ARB_sampler_objects) = !_glewInit_GL_ARB_sampler_objects(GLEW_CONTEXT_ARG_VAR_INIT);
    8759. 

  8759. #endif /* GL_ARB_sampler_objects */
    8760. 

  8760. #ifdef GL_ARB_seamless_cube_map
    8761. 

  8761.   CONST_CAST(GLEW_ARB_seamless_cube_map) = _glewSearchExtension("GL_ARB_seamless_cube_map", extStart, extEnd);
    8762. 

  8762. #endif /* GL_ARB_seamless_cube_map */
    8763. 

  8763. #ifdef GL_ARB_separate_shader_objects
    8764. 

  8764.   CONST_CAST(GLEW_ARB_separate_shader_objects) = _glewSearchExtension("GL_ARB_separate_shader_objects", extStart, extEnd);
    8765. 

  8765.   if (glewExperimental || GLEW_ARB_separate_shader_objects) CONST_CAST(GLEW_ARB_separate_shader_objects) = !_glewInit_GL_ARB_separate_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT);
    8766. 

  8766. #endif /* GL_ARB_separate_shader_objects */
    8767. 

  8767. #ifdef GL_ARB_shader_atomic_counters
    8768. 

  8768.   CONST_CAST(GLEW_ARB_shader_atomic_counters) = _glewSearchExtension("GL_ARB_shader_atomic_counters", extStart, extEnd);
    8769. 

  8769.   if (glewExperimental || GLEW_ARB_shader_atomic_counters) CONST_CAST(GLEW_ARB_shader_atomic_counters) = !_glewInit_GL_ARB_shader_atomic_counters(GLEW_CONTEXT_ARG_VAR_INIT);
    8770. 

  8770. #endif /* GL_ARB_shader_atomic_counters */
    8771. 

  8771. #ifdef GL_ARB_shader_bit_encoding
    8772. 

  8772.   CONST_CAST(GLEW_ARB_shader_bit_encoding) = _glewSearchExtension("GL_ARB_shader_bit_encoding", extStart, extEnd);
    8773. 

  8773. #endif /* GL_ARB_shader_bit_encoding */
    8774. 

  8774. #ifdef GL_ARB_shader_image_load_store
    8775. 

  8775.   CONST_CAST(GLEW_ARB_shader_image_load_store) = _glewSearchExtension("GL_ARB_shader_image_load_store", extStart, extEnd);
    8776. 

  8776.   if (glewExperimental || GLEW_ARB_shader_image_load_store) CONST_CAST(GLEW_ARB_shader_image_load_store) = !_glewInit_GL_ARB_shader_image_load_store(GLEW_CONTEXT_ARG_VAR_INIT);
    8777. 

  8777. #endif /* GL_ARB_shader_image_load_store */
    8778. 

  8778. #ifdef GL_ARB_shader_objects
    8779. 

  8779.   CONST_CAST(GLEW_ARB_shader_objects) = _glewSearchExtension("GL_ARB_shader_objects", extStart, extEnd);
    8780. 

  8780.   if (glewExperimental || GLEW_ARB_shader_objects) CONST_CAST(GLEW_ARB_shader_objects) = !_glewInit_GL_ARB_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT);
    8781. 

  8781. #endif /* GL_ARB_shader_objects */
    8782. 

  8782. #ifdef GL_ARB_shader_precision
    8783. 

  8783.   CONST_CAST(GLEW_ARB_shader_precision) = _glewSearchExtension("GL_ARB_shader_precision", extStart, extEnd);
    8784. 

  8784. #endif /* GL_ARB_shader_precision */
    8785. 

  8785. #ifdef GL_ARB_shader_stencil_export
    8786. 

  8786.   CONST_CAST(GLEW_ARB_shader_stencil_export) = _glewSearchExtension("GL_ARB_shader_stencil_export", extStart, extEnd);
    8787. 

  8787. #endif /* GL_ARB_shader_stencil_export */
    8788. 

  8788. #ifdef GL_ARB_shader_subroutine
    8789. 

  8789.   CONST_CAST(GLEW_ARB_shader_subroutine) = _glewSearchExtension("GL_ARB_shader_subroutine", extStart, extEnd);
    8790. 

  8790.   if (glewExperimental || GLEW_ARB_shader_subroutine) CONST_CAST(GLEW_ARB_shader_subroutine) = !_glewInit_GL_ARB_shader_subroutine(GLEW_CONTEXT_ARG_VAR_INIT);
    8791. 

  8791. #endif /* GL_ARB_shader_subroutine */
    8792. 

  8792. #ifdef GL_ARB_shader_texture_lod
    8793. 

  8793.   CONST_CAST(GLEW_ARB_shader_texture_lod) = _glewSearchExtension("GL_ARB_shader_texture_lod", extStart, extEnd);
    8794. 

  8794. #endif /* GL_ARB_shader_texture_lod */
    8795. 

  8795. #ifdef GL_ARB_shading_language_100
    8796. 

  8796.   CONST_CAST(GLEW_ARB_shading_language_100) = _glewSearchExtension("GL_ARB_shading_language_100", extStart, extEnd);
    8797. 

  8797. #endif /* GL_ARB_shading_language_100 */
    8798. 

  8798. #ifdef GL_ARB_shading_language_420pack
    8799. 

  8799.   CONST_CAST(GLEW_ARB_shading_language_420pack) = _glewSearchExtension("GL_ARB_shading_language_420pack", extStart, extEnd);
    8800. 

  8800. #endif /* GL_ARB_shading_language_420pack */
    8801. 

  8801. #ifdef GL_ARB_shading_language_include
    8802. 

  8802.   CONST_CAST(GLEW_ARB_shading_language_include) = _glewSearchExtension("GL_ARB_shading_language_include", extStart, extEnd);
    8803. 

  8803.   if (glewExperimental || GLEW_ARB_shading_language_include) CONST_CAST(GLEW_ARB_shading_language_include) = !_glewInit_GL_ARB_shading_language_include(GLEW_CONTEXT_ARG_VAR_INIT);
    8804. 

  8804. #endif /* GL_ARB_shading_language_include */
    8805. 

  8805. #ifdef GL_ARB_shading_language_packing
    8806. 

  8806.   CONST_CAST(GLEW_ARB_shading_language_packing) = _glewSearchExtension("GL_ARB_shading_language_packing", extStart, extEnd);
    8807. 

  8807. #endif /* GL_ARB_shading_language_packing */
    8808. 

  8808. #ifdef GL_ARB_shadow
    8809. 

  8809.   CONST_CAST(GLEW_ARB_shadow) = _glewSearchExtension("GL_ARB_shadow", extStart, extEnd);
    8810. 

  8810. #endif /* GL_ARB_shadow */
    8811. 

  8811. #ifdef GL_ARB_shadow_ambient
    8812. 

  8812.   CONST_CAST(GLEW_ARB_shadow_ambient) = _glewSearchExtension("GL_ARB_shadow_ambient", extStart, extEnd);
    8813. 

  8813. #endif /* GL_ARB_shadow_ambient */
    8814. 

  8814. #ifdef GL_ARB_sync
    8815. 

  8815.   CONST_CAST(GLEW_ARB_sync) = _glewSearchExtension("GL_ARB_sync", extStart, extEnd);
    8816. 

  8816.   if (glewExperimental || GLEW_ARB_sync) CONST_CAST(GLEW_ARB_sync) = !_glewInit_GL_ARB_sync(GLEW_CONTEXT_ARG_VAR_INIT);
    8817. 

  8817. #endif /* GL_ARB_sync */
    8818. 

  8818. #ifdef GL_ARB_tessellation_shader
    8819. 

  8819.   CONST_CAST(GLEW_ARB_tessellation_shader) = _glewSearchExtension("GL_ARB_tessellation_shader", extStart, extEnd);
    8820. 

  8820.   if (glewExperimental || GLEW_ARB_tessellation_shader) CONST_CAST(GLEW_ARB_tessellation_shader) = !_glewInit_GL_ARB_tessellation_shader(GLEW_CONTEXT_ARG_VAR_INIT);
    8821. 

  8821. #endif /* GL_ARB_tessellation_shader */
    8822. 

  8822. #ifdef GL_ARB_texture_border_clamp
    8823. 

  8823.   CONST_CAST(GLEW_ARB_texture_border_clamp) = _glewSearchExtension("GL_ARB_texture_border_clamp", extStart, extEnd);
    8824. 

  8824. #endif /* GL_ARB_texture_border_clamp */
    8825. 

  8825. #ifdef GL_ARB_texture_buffer_object
    8826. 

  8826.   CONST_CAST(GLEW_ARB_texture_buffer_object) = _glewSearchExtension("GL_ARB_texture_buffer_object", extStart, extEnd);
    8827. 

  8827.   if (glewExperimental || GLEW_ARB_texture_buffer_object) CONST_CAST(GLEW_ARB_texture_buffer_object) = !_glewInit_GL_ARB_texture_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
    8828. 

  8828. #endif /* GL_ARB_texture_buffer_object */
    8829. 

  8829. #ifdef GL_ARB_texture_buffer_object_rgb32
    8830. 

  8830.   CONST_CAST(GLEW_ARB_texture_buffer_object_rgb32) = _glewSearchExtension("GL_ARB_texture_buffer_object_rgb32", extStart, extEnd);
    8831. 

  8831. #endif /* GL_ARB_texture_buffer_object_rgb32 */
    8832. 

  8832. #ifdef GL_ARB_texture_compression
    8833. 

  8833.   CONST_CAST(GLEW_ARB_texture_compression) = _glewSearchExtension("GL_ARB_texture_compression", extStart, extEnd);
    8834. 

  8834.   if (glewExperimental || GLEW_ARB_texture_compression) CONST_CAST(GLEW_ARB_texture_compression) = !_glewInit_GL_ARB_texture_compression(GLEW_CONTEXT_ARG_VAR_INIT);
    8835. 

  8835. #endif /* GL_ARB_texture_compression */
    8836. 

  8836. #ifdef GL_ARB_texture_compression_bptc
    8837. 

  8837.   CONST_CAST(GLEW_ARB_texture_compression_bptc) = _glewSearchExtension("GL_ARB_texture_compression_bptc", extStart, extEnd);
    8838. 

  8838. #endif /* GL_ARB_texture_compression_bptc */
    8839. 

  8839. #ifdef GL_ARB_texture_compression_rgtc
    8840. 

  8840.   CONST_CAST(GLEW_ARB_texture_compression_rgtc) = _glewSearchExtension("GL_ARB_texture_compression_rgtc", extStart, extEnd);
    8841. 

  8841. #endif /* GL_ARB_texture_compression_rgtc */
    8842. 

  8842. #ifdef GL_ARB_texture_cube_map
    8843. 

  8843.   CONST_CAST(GLEW_ARB_texture_cube_map) = _glewSearchExtension("GL_ARB_texture_cube_map", extStart, extEnd);
    8844. 

  8844. #endif /* GL_ARB_texture_cube_map */
    8845. 

  8845. #ifdef GL_ARB_texture_cube_map_array
    8846. 

  8846.   CONST_CAST(GLEW_ARB_texture_cube_map_array) = _glewSearchExtension("GL_ARB_texture_cube_map_array", extStart, extEnd);
    8847. 

  8847. #endif /* GL_ARB_texture_cube_map_array */
    8848. 

  8848. #ifdef GL_ARB_texture_env_add
    8849. 

  8849.   CONST_CAST(GLEW_ARB_texture_env_add) = _glewSearchExtension("GL_ARB_texture_env_add", extStart, extEnd);
    8850. 

  8850. #endif /* GL_ARB_texture_env_add */
    8851. 

  8851. #ifdef GL_ARB_texture_env_combine
    8852. 

  8852.   CONST_CAST(GLEW_ARB_texture_env_combine) = _glewSearchExtension("GL_ARB_texture_env_combine", extStart, extEnd);
    8853. 

  8853. #endif /* GL_ARB_texture_env_combine */
    8854. 

  8854. #ifdef GL_ARB_texture_env_crossbar
    8855. 

  8855.   CONST_CAST(GLEW_ARB_texture_env_crossbar) = _glewSearchExtension("GL_ARB_texture_env_crossbar", extStart, extEnd);
    8856. 

  8856. #endif /* GL_ARB_texture_env_crossbar */
    8857. 

  8857. #ifdef GL_ARB_texture_env_dot3
    8858. 

  8858.   CONST_CAST(GLEW_ARB_texture_env_dot3) = _glewSearchExtension("GL_ARB_texture_env_dot3", extStart, extEnd);
    8859. 

  8859. #endif /* GL_ARB_texture_env_dot3 */
    8860. 

  8860. #ifdef GL_ARB_texture_float
    8861. 

  8861.   CONST_CAST(GLEW_ARB_texture_float) = _glewSearchExtension("GL_ARB_texture_float", extStart, extEnd);
    8862. 

  8862. #endif /* GL_ARB_texture_float */
    8863. 

  8863. #ifdef GL_ARB_texture_gather
    8864. 

  8864.   CONST_CAST(GLEW_ARB_texture_gather) = _glewSearchExtension("GL_ARB_texture_gather", extStart, extEnd);
    8865. 

  8865. #endif /* GL_ARB_texture_gather */
    8866. 

  8866. #ifdef GL_ARB_texture_mirrored_repeat
    8867. 

  8867.   CONST_CAST(GLEW_ARB_texture_mirrored_repeat) = _glewSearchExtension("GL_ARB_texture_mirrored_repeat", extStart, extEnd);
    8868. 

  8868. #endif /* GL_ARB_texture_mirrored_repeat */
    8869. 

  8869. #ifdef GL_ARB_texture_multisample
    8870. 

  8870.   CONST_CAST(GLEW_ARB_texture_multisample) = _glewSearchExtension("GL_ARB_texture_multisample", extStart, extEnd);
    8871. 

  8871.   if (glewExperimental || GLEW_ARB_texture_multisample) CONST_CAST(GLEW_ARB_texture_multisample) = !_glewInit_GL_ARB_texture_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
    8872. 

  8872. #endif /* GL_ARB_texture_multisample */
    8873. 

  8873. #ifdef GL_ARB_texture_non_power_of_two
    8874. 

  8874.   CONST_CAST(GLEW_ARB_texture_non_power_of_two) = _glewSearchExtension("GL_ARB_texture_non_power_of_two", extStart, extEnd);
    8875. 

  8875. #endif /* GL_ARB_texture_non_power_of_two */
    8876. 

  8876. #ifdef GL_ARB_texture_query_lod
    8877. 

  8877.   CONST_CAST(GLEW_ARB_texture_query_lod) = _glewSearchExtension("GL_ARB_texture_query_lod", extStart, extEnd);
    8878. 

  8878. #endif /* GL_ARB_texture_query_lod */
    8879. 

  8879. #ifdef GL_ARB_texture_rectangle
    8880. 

  8880.   CONST_CAST(GLEW_ARB_texture_rectangle) = _glewSearchExtension("GL_ARB_texture_rectangle", extStart, extEnd);
    8881. 

  8881. #endif /* GL_ARB_texture_rectangle */
    8882. 

  8882. #ifdef GL_ARB_texture_rg
    8883. 

  8883.   CONST_CAST(GLEW_ARB_texture_rg) = _glewSearchExtension("GL_ARB_texture_rg", extStart, extEnd);
    8884. 

  8884. #endif /* GL_ARB_texture_rg */
    8885. 

  8885. #ifdef GL_ARB_texture_rgb10_a2ui
    8886. 

  8886.   CONST_CAST(GLEW_ARB_texture_rgb10_a2ui) = _glewSearchExtension("GL_ARB_texture_rgb10_a2ui", extStart, extEnd);
    8887. 

  8887. #endif /* GL_ARB_texture_rgb10_a2ui */
    8888. 

  8888. #ifdef GL_ARB_texture_storage
    8889. 

  8889.   CONST_CAST(GLEW_ARB_texture_storage) = _glewSearchExtension("GL_ARB_texture_storage", extStart, extEnd);
    8890. 

  8890.   if (glewExperimental || GLEW_ARB_texture_storage) CONST_CAST(GLEW_ARB_texture_storage) = !_glewInit_GL_ARB_texture_storage(GLEW_CONTEXT_ARG_VAR_INIT);
    8891. 

  8891. #endif /* GL_ARB_texture_storage */
    8892. 

  8892. #ifdef GL_ARB_texture_swizzle
    8893. 

  8893.   CONST_CAST(GLEW_ARB_texture_swizzle) = _glewSearchExtension("GL_ARB_texture_swizzle", extStart, extEnd);
    8894. 

  8894. #endif /* GL_ARB_texture_swizzle */
    8895. 

  8895. #ifdef GL_ARB_timer_query
    8896. 

  8896.   CONST_CAST(GLEW_ARB_timer_query) = _glewSearchExtension("GL_ARB_timer_query", extStart, extEnd);
    8897. 

  8897.   if (glewExperimental || GLEW_ARB_timer_query) CONST_CAST(GLEW_ARB_timer_query) = !_glewInit_GL_ARB_timer_query(GLEW_CONTEXT_ARG_VAR_INIT);
    8898. 

  8898. #endif /* GL_ARB_timer_query */
    8899. 

  8899. #ifdef GL_ARB_transform_feedback2
    8900. 

  8900.   CONST_CAST(GLEW_ARB_transform_feedback2) = _glewSearchExtension("GL_ARB_transform_feedback2", extStart, extEnd);
    8901. 

  8901.   if (glewExperimental || GLEW_ARB_transform_feedback2) CONST_CAST(GLEW_ARB_transform_feedback2) = !_glewInit_GL_ARB_transform_feedback2(GLEW_CONTEXT_ARG_VAR_INIT);
    8902. 

  8902. #endif /* GL_ARB_transform_feedback2 */
    8903. 

  8903. #ifdef GL_ARB_transform_feedback3
    8904. 

  8904.   CONST_CAST(GLEW_ARB_transform_feedback3) = _glewSearchExtension("GL_ARB_transform_feedback3", extStart, extEnd);
    8905. 

  8905.   if (glewExperimental || GLEW_ARB_transform_feedback3) CONST_CAST(GLEW_ARB_transform_feedback3) = !_glewInit_GL_ARB_transform_feedback3(GLEW_CONTEXT_ARG_VAR_INIT);
    8906. 

  8906. #endif /* GL_ARB_transform_feedback3 */
    8907. 

  8907. #ifdef GL_ARB_transform_feedback_instanced
    8908. 

  8908.   CONST_CAST(GLEW_ARB_transform_feedback_instanced) = _glewSearchExtension("GL_ARB_transform_feedback_instanced", extStart, extEnd);
    8909. 

  8909.   if (glewExperimental || GLEW_ARB_transform_feedback_instanced) CONST_CAST(GLEW_ARB_transform_feedback_instanced) = !_glewInit_GL_ARB_transform_feedback_instanced(GLEW_CONTEXT_ARG_VAR_INIT);
    8910. 

  8910. #endif /* GL_ARB_transform_feedback_instanced */
    8911. 

  8911. #ifdef GL_ARB_transpose_matrix
    8912. 

  8912.   CONST_CAST(GLEW_ARB_transpose_matrix) = _glewSearchExtension("GL_ARB_transpose_matrix", extStart, extEnd);
    8913. 

  8913.   if (glewExperimental || GLEW_ARB_transpose_matrix) CONST_CAST(GLEW_ARB_transpose_matrix) = !_glewInit_GL_ARB_transpose_matrix(GLEW_CONTEXT_ARG_VAR_INIT);
    8914. 

  8914. #endif /* GL_ARB_transpose_matrix */
    8915. 

  8915. #ifdef GL_ARB_uniform_buffer_object
    8916. 

  8916.   CONST_CAST(GLEW_ARB_uniform_buffer_object) = _glewSearchExtension("GL_ARB_uniform_buffer_object", extStart, extEnd);
    8917. 

  8917.   if (glewExperimental || GLEW_ARB_uniform_buffer_object) CONST_CAST(GLEW_ARB_uniform_buffer_object) = !_glewInit_GL_ARB_uniform_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
    8918. 

  8918. #endif /* GL_ARB_uniform_buffer_object */
    8919. 

  8919. #ifdef GL_ARB_vertex_array_bgra
    8920. 

  8920.   CONST_CAST(GLEW_ARB_vertex_array_bgra) = _glewSearchExtension("GL_ARB_vertex_array_bgra", extStart, extEnd);
    8921. 

  8921. #endif /* GL_ARB_vertex_array_bgra */
    8922. 

  8922. #ifdef GL_ARB_vertex_array_object
    8923. 

  8923.   CONST_CAST(GLEW_ARB_vertex_array_object) = _glewSearchExtension("GL_ARB_vertex_array_object", extStart, extEnd);
    8924. 

  8924.   if (glewExperimental || GLEW_ARB_vertex_array_object) CONST_CAST(GLEW_ARB_vertex_array_object) = !_glewInit_GL_ARB_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT);
    8925. 

  8925. #endif /* GL_ARB_vertex_array_object */
    8926. 

  8926. #ifdef GL_ARB_vertex_attrib_64bit
    8927. 

  8927.   CONST_CAST(GLEW_ARB_vertex_attrib_64bit) = _glewSearchExtension("GL_ARB_vertex_attrib_64bit", extStart, extEnd);
    8928. 

  8928.   if (glewExperimental || GLEW_ARB_vertex_attrib_64bit) CONST_CAST(GLEW_ARB_vertex_attrib_64bit) = !_glewInit_GL_ARB_vertex_attrib_64bit(GLEW_CONTEXT_ARG_VAR_INIT);
    8929. 

  8929. #endif /* GL_ARB_vertex_attrib_64bit */
    8930. 

  8930. #ifdef GL_ARB_vertex_blend
    8931. 

  8931.   CONST_CAST(GLEW_ARB_vertex_blend) = _glewSearchExtension("GL_ARB_vertex_blend", extStart, extEnd);
    8932. 

  8932.   if (glewExperimental || GLEW_ARB_vertex_blend) CONST_CAST(GLEW_ARB_vertex_blend) = !_glewInit_GL_ARB_vertex_blend(GLEW_CONTEXT_ARG_VAR_INIT);
    8933. 

  8933. #endif /* GL_ARB_vertex_blend */
    8934. 

  8934. #ifdef GL_ARB_vertex_buffer_object
    8935. 

  8935.   CONST_CAST(GLEW_ARB_vertex_buffer_object) = _glewSearchExtension("GL_ARB_vertex_buffer_object", extStart, extEnd);
    8936. 

  8936.   if (glewExperimental || GLEW_ARB_vertex_buffer_object) CONST_CAST(GLEW_ARB_vertex_buffer_object) = !_glewInit_GL_ARB_vertex_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
    8937. 

  8937. #endif /* GL_ARB_vertex_buffer_object */
    8938. 

  8938. #ifdef GL_ARB_vertex_program
    8939. 

  8939.   CONST_CAST(GLEW_ARB_vertex_program) = _glewSearchExtension("GL_ARB_vertex_program", extStart, extEnd);
    8940. 

  8940.   if (glewExperimental || GLEW_ARB_vertex_program) CONST_CAST(GLEW_ARB_vertex_program) = !_glewInit_GL_ARB_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT);
    8941. 

  8941. #endif /* GL_ARB_vertex_program */
    8942. 

  8942. #ifdef GL_ARB_vertex_shader
    8943. 

  8943.   CONST_CAST(GLEW_ARB_vertex_shader) = _glewSearchExtension("GL_ARB_vertex_shader", extStart, extEnd);
    8944. 

  8944.   if (glewExperimental || GLEW_ARB_vertex_shader) CONST_CAST(GLEW_ARB_vertex_shader) = !_glewInit_GL_ARB_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT);
    8945. 

  8945. #endif /* GL_ARB_vertex_shader */
    8946. 

  8946. #ifdef GL_ARB_vertex_type_2_10_10_10_rev
    8947. 

  8947.   CONST_CAST(GLEW_ARB_vertex_type_2_10_10_10_rev) = _glewSearchExtension("GL_ARB_vertex_type_2_10_10_10_rev", extStart, extEnd);
    8948. 

  8948.   if (glewExperimental || GLEW_ARB_vertex_type_2_10_10_10_rev) CONST_CAST(GLEW_ARB_vertex_type_2_10_10_10_rev) = !_glewInit_GL_ARB_vertex_type_2_10_10_10_rev(GLEW_CONTEXT_ARG_VAR_INIT);
    8949. 

  8949. #endif /* GL_ARB_vertex_type_2_10_10_10_rev */
    8950. 

  8950. #ifdef GL_ARB_viewport_array
    8951. 

  8951.   CONST_CAST(GLEW_ARB_viewport_array) = _glewSearchExtension("GL_ARB_viewport_array", extStart, extEnd);
    8952. 

  8952.   if (glewExperimental || GLEW_ARB_viewport_array) CONST_CAST(GLEW_ARB_viewport_array) = !_glewInit_GL_ARB_viewport_array(GLEW_CONTEXT_ARG_VAR_INIT);
    8953. 

  8953. #endif /* GL_ARB_viewport_array */
    8954. 

  8954. #ifdef GL_ARB_window_pos
    8955. 

  8955.   CONST_CAST(GLEW_ARB_window_pos) = _glewSearchExtension("GL_ARB_window_pos", extStart, extEnd);
    8956. 

  8956.   if (glewExperimental || GLEW_ARB_window_pos) CONST_CAST(GLEW_ARB_window_pos) = !_glewInit_GL_ARB_window_pos(GLEW_CONTEXT_ARG_VAR_INIT);
    8957. 

  8957. #endif /* GL_ARB_window_pos */
    8958. 

  8958. #ifdef GL_ATIX_point_sprites
    8959. 

  8959.   CONST_CAST(GLEW_ATIX_point_sprites) = _glewSearchExtension("GL_ATIX_point_sprites", extStart, extEnd);
    8960. 

  8960. #endif /* GL_ATIX_point_sprites */
    8961. 

  8961. #ifdef GL_ATIX_texture_env_combine3
    8962. 

  8962.   CONST_CAST(GLEW_ATIX_texture_env_combine3) = _glewSearchExtension("GL_ATIX_texture_env_combine3", extStart, extEnd);
    8963. 

  8963. #endif /* GL_ATIX_texture_env_combine3 */
    8964. 

  8964. #ifdef GL_ATIX_texture_env_route
    8965. 

  8965.   CONST_CAST(GLEW_ATIX_texture_env_route) = _glewSearchExtension("GL_ATIX_texture_env_route", extStart, extEnd);
    8966. 

  8966. #endif /* GL_ATIX_texture_env_route */
    8967. 

  8967. #ifdef GL_ATIX_vertex_shader_output_point_size
    8968. 

  8968.   CONST_CAST(GLEW_ATIX_vertex_shader_output_point_size) = _glewSearchExtension("GL_ATIX_vertex_shader_output_point_size", extStart, extEnd);
    8969. 

  8969. #endif /* GL_ATIX_vertex_shader_output_point_size */
    8970. 

  8970. #ifdef GL_ATI_draw_buffers
    8971. 

  8971.   CONST_CAST(GLEW_ATI_draw_buffers) = _glewSearchExtension("GL_ATI_draw_buffers", extStart, extEnd);
    8972. 

  8972.   if (glewExperimental || GLEW_ATI_draw_buffers) CONST_CAST(GLEW_ATI_draw_buffers) = !_glewInit_GL_ATI_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT);
    8973. 

  8973. #endif /* GL_ATI_draw_buffers */
    8974. 

  8974. #ifdef GL_ATI_element_array
    8975. 

  8975.   CONST_CAST(GLEW_ATI_element_array) = _glewSearchExtension("GL_ATI_element_array", extStart, extEnd);
    8976. 

  8976.   if (glewExperimental || GLEW_ATI_element_array) CONST_CAST(GLEW_ATI_element_array) = !_glewInit_GL_ATI_element_array(GLEW_CONTEXT_ARG_VAR_INIT);
    8977. 

  8977. #endif /* GL_ATI_element_array */
    8978. 

  8978. #ifdef GL_ATI_envmap_bumpmap
    8979. 

  8979.   CONST_CAST(GLEW_ATI_envmap_bumpmap) = _glewSearchExtension("GL_ATI_envmap_bumpmap", extStart, extEnd);
    8980. 

  8980.   if (glewExperimental || GLEW_ATI_envmap_bumpmap) CONST_CAST(GLEW_ATI_envmap_bumpmap) = !_glewInit_GL_ATI_envmap_bumpmap(GLEW_CONTEXT_ARG_VAR_INIT);
    8981. 

  8981. #endif /* GL_ATI_envmap_bumpmap */
    8982. 

  8982. #ifdef GL_ATI_fragment_shader
    8983. 

  8983.   CONST_CAST(GLEW_ATI_fragment_shader) = _glewSearchExtension("GL_ATI_fragment_shader", extStart, extEnd);
    8984. 

  8984.   if (glewExperimental || GLEW_ATI_fragment_shader) CONST_CAST(GLEW_ATI_fragment_shader) = !_glewInit_GL_ATI_fragment_shader(GLEW_CONTEXT_ARG_VAR_INIT);
    8985. 

  8985. #endif /* GL_ATI_fragment_shader */
    8986. 

  8986. #ifdef GL_ATI_map_object_buffer
    8987. 

  8987.   CONST_CAST(GLEW_ATI_map_object_buffer) = _glewSearchExtension("GL_ATI_map_object_buffer", extStart, extEnd);
    8988. 

  8988.   if (glewExperimental || GLEW_ATI_map_object_buffer) CONST_CAST(GLEW_ATI_map_object_buffer) = !_glewInit_GL_ATI_map_object_buffer(GLEW_CONTEXT_ARG_VAR_INIT);
    8989. 

  8989. #endif /* GL_ATI_map_object_buffer */
    8990. 

  8990. #ifdef GL_ATI_meminfo
    8991. 

  8991.   CONST_CAST(GLEW_ATI_meminfo) = _glewSearchExtension("GL_ATI_meminfo", extStart, extEnd);
    8992. 

  8992. #endif /* GL_ATI_meminfo */
    8993. 

  8993. #ifdef GL_ATI_pn_triangles
    8994. 

  8994.   CONST_CAST(GLEW_ATI_pn_triangles) = _glewSearchExtension("GL_ATI_pn_triangles", extStart, extEnd);
    8995. 

  8995.   if (glewExperimental || GLEW_ATI_pn_triangles) CONST_CAST(GLEW_ATI_pn_triangles) = !_glewInit_GL_ATI_pn_triangles(GLEW_CONTEXT_ARG_VAR_INIT);
    8996. 

  8996. #endif /* GL_ATI_pn_triangles */
    8997. 

  8997. #ifdef GL_ATI_separate_stencil
    8998. 

  8998.   CONST_CAST(GLEW_ATI_separate_stencil) = _glewSearchExtension("GL_ATI_separate_stencil", extStart, extEnd);
    8999. 

  8999.   if (glewExperimental || GLEW_ATI_separate_stencil) CONST_CAST(GLEW_ATI_separate_stencil) = !_glewInit_GL_ATI_separate_stencil(GLEW_CONTEXT_ARG_VAR_INIT);
    9000. 

  9000. #endif /* GL_ATI_separate_stencil */
    9001. 

  9001. #ifdef GL_ATI_shader_texture_lod
    9002. 

  9002.   CONST_CAST(GLEW_ATI_shader_texture_lod) = _glewSearchExtension("GL_ATI_shader_texture_lod", extStart, extEnd);
    9003. 

  9003. #endif /* GL_ATI_shader_texture_lod */
    9004. 

  9004. #ifdef GL_ATI_text_fragment_shader
    9005. 

  9005.   CONST_CAST(GLEW_ATI_text_fragment_shader) = _glewSearchExtension("GL_ATI_text_fragment_shader", extStart, extEnd);
    9006. 

  9006. #endif /* GL_ATI_text_fragment_shader */
    9007. 

  9007. #ifdef GL_ATI_texture_compression_3dc
    9008. 

  9008.   CONST_CAST(GLEW_ATI_texture_compression_3dc) = _glewSearchExtension("GL_ATI_texture_compression_3dc", extStart, extEnd);
    9009. 

  9009. #endif /* GL_ATI_texture_compression_3dc */
    9010. 

  9010. #ifdef GL_ATI_texture_env_combine3
    9011. 

  9011.   CONST_CAST(GLEW_ATI_texture_env_combine3) = _glewSearchExtension("GL_ATI_texture_env_combine3", extStart, extEnd);
    9012. 

  9012. #endif /* GL_ATI_texture_env_combine3 */
    9013. 

  9013. #ifdef GL_ATI_texture_float
    9014. 

  9014.   CONST_CAST(GLEW_ATI_texture_float) = _glewSearchExtension("GL_ATI_texture_float", extStart, extEnd);
    9015. 

  9015. #endif /* GL_ATI_texture_float */
    9016. 

  9016. #ifdef GL_ATI_texture_mirror_once
    9017. 

  9017.   CONST_CAST(GLEW_ATI_texture_mirror_once) = _glewSearchExtension("GL_ATI_texture_mirror_once", extStart, extEnd);
    9018. 

  9018. #endif /* GL_ATI_texture_mirror_once */
    9019. 

  9019. #ifdef GL_ATI_vertex_array_object
    9020. 

  9020.   CONST_CAST(GLEW_ATI_vertex_array_object) = _glewSearchExtension("GL_ATI_vertex_array_object", extStart, extEnd);
    9021. 

  9021.   if (glewExperimental || GLEW_ATI_vertex_array_object) CONST_CAST(GLEW_ATI_vertex_array_object) = !_glewInit_GL_ATI_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT);
    9022. 

  9022. #endif /* GL_ATI_vertex_array_object */
    9023. 

  9023. #ifdef GL_ATI_vertex_attrib_array_object
    9024. 

  9024.   CONST_CAST(GLEW_ATI_vertex_attrib_array_object) = _glewSearchExtension("GL_ATI_vertex_attrib_array_object", extStart, extEnd);
    9025. 

  9025.   if (glewExperimental || GLEW_ATI_vertex_attrib_array_object) CONST_CAST(GLEW_ATI_vertex_attrib_array_object) = !_glewInit_GL_ATI_vertex_attrib_array_object(GLEW_CONTEXT_ARG_VAR_INIT);
    9026. 

  9026. #endif /* GL_ATI_vertex_attrib_array_object */
    9027. 

  9027. #ifdef GL_ATI_vertex_streams
    9028. 

  9028.   CONST_CAST(GLEW_ATI_vertex_streams) = _glewSearchExtension("GL_ATI_vertex_streams", extStart, extEnd);
    9029. 

  9029.   if (glewExperimental || GLEW_ATI_vertex_streams) CONST_CAST(GLEW_ATI_vertex_streams) = !_glewInit_GL_ATI_vertex_streams(GLEW_CONTEXT_ARG_VAR_INIT);
    9030. 

  9030. #endif /* GL_ATI_vertex_streams */
    9031. 

  9031. #ifdef GL_EXT_422_pixels
    9032. 

  9032.   CONST_CAST(GLEW_EXT_422_pixels) = _glewSearchExtension("GL_EXT_422_pixels", extStart, extEnd);
    9033. 

  9033. #endif /* GL_EXT_422_pixels */
    9034. 

  9034. #ifdef GL_EXT_Cg_shader
    9035. 

  9035.   CONST_CAST(GLEW_EXT_Cg_shader) = _glewSearchExtension("GL_EXT_Cg_shader", extStart, extEnd);
    9036. 

  9036. #endif /* GL_EXT_Cg_shader */
    9037. 

  9037. #ifdef GL_EXT_abgr
    9038. 

  9038.   CONST_CAST(GLEW_EXT_abgr) = _glewSearchExtension("GL_EXT_abgr", extStart, extEnd);
    9039. 

  9039. #endif /* GL_EXT_abgr */
    9040. 

  9040. #ifdef GL_EXT_bgra
    9041. 

  9041.   CONST_CAST(GLEW_EXT_bgra) = _glewSearchExtension("GL_EXT_bgra", extStart, extEnd);
    9042. 

  9042. #endif /* GL_EXT_bgra */
    9043. 

  9043. #ifdef GL_EXT_bindable_uniform
    9044. 

  9044.   CONST_CAST(GLEW_EXT_bindable_uniform) = _glewSearchExtension("GL_EXT_bindable_uniform", extStart, extEnd);
    9045. 

  9045.   if (glewExperimental || GLEW_EXT_bindable_uniform) CONST_CAST(GLEW_EXT_bindable_uniform) = !_glewInit_GL_EXT_bindable_uniform(GLEW_CONTEXT_ARG_VAR_INIT);
    9046. 

  9046. #endif /* GL_EXT_bindable_uniform */
    9047. 

  9047. #ifdef GL_EXT_blend_color
    9048. 

  9048.   CONST_CAST(GLEW_EXT_blend_color) = _glewSearchExtension("GL_EXT_blend_color", extStart, extEnd);
    9049. 

  9049.   if (glewExperimental || GLEW_EXT_blend_color) CONST_CAST(GLEW_EXT_blend_color) = !_glewInit_GL_EXT_blend_color(GLEW_CONTEXT_ARG_VAR_INIT);
    9050. 

  9050. #endif /* GL_EXT_blend_color */
    9051. 

  9051. #ifdef GL_EXT_blend_equation_separate
    9052. 

  9052.   CONST_CAST(GLEW_EXT_blend_equation_separate) = _glewSearchExtension("GL_EXT_blend_equation_separate", extStart, extEnd);
    9053. 

  9053.   if (glewExperimental || GLEW_EXT_blend_equation_separate) CONST_CAST(GLEW_EXT_blend_equation_separate) = !_glewInit_GL_EXT_blend_equation_separate(GLEW_CONTEXT_ARG_VAR_INIT);
    9054. 

  9054. #endif /* GL_EXT_blend_equation_separate */
    9055. 

  9055. #ifdef GL_EXT_blend_func_separate
    9056. 

  9056.   CONST_CAST(GLEW_EXT_blend_func_separate) = _glewSearchExtension("GL_EXT_blend_func_separate", extStart, extEnd);
    9057. 

  9057.   if (glewExperimental || GLEW_EXT_blend_func_separate) CONST_CAST(GLEW_EXT_blend_func_separate) = !_glewInit_GL_EXT_blend_func_separate(GLEW_CONTEXT_ARG_VAR_INIT);
    9058. 

  9058. #endif /* GL_EXT_blend_func_separate */
    9059. 

  9059. #ifdef GL_EXT_blend_logic_op
    9060. 

  9060.   CONST_CAST(GLEW_EXT_blend_logic_op) = _glewSearchExtension("GL_EXT_blend_logic_op", extStart, extEnd);
    9061. 

  9061. #endif /* GL_EXT_blend_logic_op */
    9062. 

  9062. #ifdef GL_EXT_blend_minmax
    9063. 

  9063.   CONST_CAST(GLEW_EXT_blend_minmax) = _glewSearchExtension("GL_EXT_blend_minmax", extStart, extEnd);
    9064. 

  9064.   if (glewExperimental || GLEW_EXT_blend_minmax) CONST_CAST(GLEW_EXT_blend_minmax) = !_glewInit_GL_EXT_blend_minmax(GLEW_CONTEXT_ARG_VAR_INIT);
    9065. 

  9065. #endif /* GL_EXT_blend_minmax */
    9066. 

  9066. #ifdef GL_EXT_blend_subtract
    9067. 

  9067.   CONST_CAST(GLEW_EXT_blend_subtract) = _glewSearchExtension("GL_EXT_blend_subtract", extStart, extEnd);
    9068. 

  9068. #endif /* GL_EXT_blend_subtract */
    9069. 

  9069. #ifdef GL_EXT_clip_volume_hint
    9070. 

  9070.   CONST_CAST(GLEW_EXT_clip_volume_hint) = _glewSearchExtension("GL_EXT_clip_volume_hint", extStart, extEnd);
    9071. 

  9071. #endif /* GL_EXT_clip_volume_hint */
    9072. 

  9072. #ifdef GL_EXT_cmyka
    9073. 

  9073.   CONST_CAST(GLEW_EXT_cmyka) = _glewSearchExtension("GL_EXT_cmyka", extStart, extEnd);
    9074. 

  9074. #endif /* GL_EXT_cmyka */
    9075. 

  9075. #ifdef GL_EXT_color_subtable
    9076. 

  9076.   CONST_CAST(GLEW_EXT_color_subtable) = _glewSearchExtension("GL_EXT_color_subtable", extStart, extEnd);
    9077. 

  9077.   if (glewExperimental || GLEW_EXT_color_subtable) CONST_CAST(GLEW_EXT_color_subtable) = !_glewInit_GL_EXT_color_subtable(GLEW_CONTEXT_ARG_VAR_INIT);
    9078. 

  9078. #endif /* GL_EXT_color_subtable */
    9079. 

  9079. #ifdef GL_EXT_compiled_vertex_array
    9080. 

  9080.   CONST_CAST(GLEW_EXT_compiled_vertex_array) = _glewSearchExtension("GL_EXT_compiled_vertex_array", extStart, extEnd);
    9081. 

  9081.   if (glewExperimental || GLEW_EXT_compiled_vertex_array) CONST_CAST(GLEW_EXT_compiled_vertex_array) = !_glewInit_GL_EXT_compiled_vertex_array(GLEW_CONTEXT_ARG_VAR_INIT);
    9082. 

  9082. #endif /* GL_EXT_compiled_vertex_array */
    9083. 

  9083. #ifdef GL_EXT_convolution
    9084. 

  9084.   CONST_CAST(GLEW_EXT_convolution) = _glewSearchExtension("GL_EXT_convolution", extStart, extEnd);
    9085. 

  9085.   if (glewExperimental || GLEW_EXT_convolution) CONST_CAST(GLEW_EXT_convolution) = !_glewInit_GL_EXT_convolution(GLEW_CONTEXT_ARG_VAR_INIT);
    9086. 

  9086. #endif /* GL_EXT_convolution */
    9087. 

  9087. #ifdef GL_EXT_coordinate_frame
    9088. 

  9088.   CONST_CAST(GLEW_EXT_coordinate_frame) = _glewSearchExtension("GL_EXT_coordinate_frame", extStart, extEnd);
    9089. 

  9089.   if (glewExperimental || GLEW_EXT_coordinate_frame) CONST_CAST(GLEW_EXT_coordinate_frame) = !_glewInit_GL_EXT_coordinate_frame(GLEW_CONTEXT_ARG_VAR_INIT);
    9090. 

  9090. #endif /* GL_EXT_coordinate_frame */
    9091. 

  9091. #ifdef GL_EXT_copy_texture
    9092. 

  9092.   CONST_CAST(GLEW_EXT_copy_texture) = _glewSearchExtension("GL_EXT_copy_texture", extStart, extEnd);
    9093. 

  9093.   if (glewExperimental || GLEW_EXT_copy_texture) CONST_CAST(GLEW_EXT_copy_texture) = !_glewInit_GL_EXT_copy_texture(GLEW_CONTEXT_ARG_VAR_INIT);
    9094. 

  9094. #endif /* GL_EXT_copy_texture */
    9095. 

  9095. #ifdef GL_EXT_cull_vertex
    9096. 

  9096.   CONST_CAST(GLEW_EXT_cull_vertex) = _glewSearchExtension("GL_EXT_cull_vertex", extStart, extEnd);
    9097. 

  9097.   if (glewExperimental || GLEW_EXT_cull_vertex) CONST_CAST(GLEW_EXT_cull_vertex) = !_glewInit_GL_EXT_cull_vertex(GLEW_CONTEXT_ARG_VAR_INIT);
    9098. 

  9098. #endif /* GL_EXT_cull_vertex */
    9099. 

  9099. #ifdef GL_EXT_depth_bounds_test
    9100. 

  9100.   CONST_CAST(GLEW_EXT_depth_bounds_test) = _glewSearchExtension("GL_EXT_depth_bounds_test", extStart, extEnd);
    9101. 

  9101.   if (glewExperimental || GLEW_EXT_depth_bounds_test) CONST_CAST(GLEW_EXT_depth_bounds_test) = !_glewInit_GL_EXT_depth_bounds_test(GLEW_CONTEXT_ARG_VAR_INIT);
    9102. 

  9102. #endif /* GL_EXT_depth_bounds_test */
    9103. 

  9103. #ifdef GL_EXT_direct_state_access
    9104. 

  9104.   CONST_CAST(GLEW_EXT_direct_state_access) = _glewSearchExtension("GL_EXT_direct_state_access", extStart, extEnd);
    9105. 

  9105.   if (glewExperimental || GLEW_EXT_direct_state_access) CONST_CAST(GLEW_EXT_direct_state_access) = !_glewInit_GL_EXT_direct_state_access(GLEW_CONTEXT_ARG_VAR_INIT);
    9106. 

  9106. #endif /* GL_EXT_direct_state_access */
    9107. 

  9107. #ifdef GL_EXT_draw_buffers2
    9108. 

  9108.   CONST_CAST(GLEW_EXT_draw_buffers2) = _glewSearchExtension("GL_EXT_draw_buffers2", extStart, extEnd);
    9109. 

  9109.   if (glewExperimental || GLEW_EXT_draw_buffers2) CONST_CAST(GLEW_EXT_draw_buffers2) = !_glewInit_GL_EXT_draw_buffers2(GLEW_CONTEXT_ARG_VAR_INIT);
    9110. 

  9110. #endif /* GL_EXT_draw_buffers2 */
    9111. 

  9111. #ifdef GL_EXT_draw_instanced
    9112. 

  9112.   CONST_CAST(GLEW_EXT_draw_instanced) = _glewSearchExtension("GL_EXT_draw_instanced", extStart, extEnd);
    9113. 

  9113.   if (glewExperimental || GLEW_EXT_draw_instanced) CONST_CAST(GLEW_EXT_draw_instanced) = !_glewInit_GL_EXT_draw_instanced(GLEW_CONTEXT_ARG_VAR_INIT);
    9114. 

  9114. #endif /* GL_EXT_draw_instanced */
    9115. 

  9115. #ifdef GL_EXT_draw_range_elements
    9116. 

  9116.   CONST_CAST(GLEW_EXT_draw_range_elements) = _glewSearchExtension("GL_EXT_draw_range_elements", extStart, extEnd);
    9117. 

  9117.   if (glewExperimental || GLEW_EXT_draw_range_elements) CONST_CAST(GLEW_EXT_draw_range_elements) = !_glewInit_GL_EXT_draw_range_elements(GLEW_CONTEXT_ARG_VAR_INIT);
    9118. 

  9118. #endif /* GL_EXT_draw_range_elements */
    9119. 

  9119. #ifdef GL_EXT_fog_coord
    9120. 

  9120.   CONST_CAST(GLEW_EXT_fog_coord) = _glewSearchExtension("GL_EXT_fog_coord", extStart, extEnd);
    9121. 

  9121.   if (glewExperimental || GLEW_EXT_fog_coord) CONST_CAST(GLEW_EXT_fog_coord) = !_glewInit_GL_EXT_fog_coord(GLEW_CONTEXT_ARG_VAR_INIT);
    9122. 

  9122. #endif /* GL_EXT_fog_coord */
    9123. 

  9123. #ifdef GL_EXT_fragment_lighting
    9124. 

  9124.   CONST_CAST(GLEW_EXT_fragment_lighting) = _glewSearchExtension("GL_EXT_fragment_lighting", extStart, extEnd);
    9125. 

  9125.   if (glewExperimental || GLEW_EXT_fragment_lighting) CONST_CAST(GLEW_EXT_fragment_lighting) = !_glewInit_GL_EXT_fragment_lighting(GLEW_CONTEXT_ARG_VAR_INIT);
    9126. 

  9126. #endif /* GL_EXT_fragment_lighting */
    9127. 

  9127. #ifdef GL_EXT_framebuffer_blit
    9128. 

  9128.   CONST_CAST(GLEW_EXT_framebuffer_blit) = _glewSearchExtension("GL_EXT_framebuffer_blit", extStart, extEnd);
    9129. 

  9129.   if (glewExperimental || GLEW_EXT_framebuffer_blit) CONST_CAST(GLEW_EXT_framebuffer_blit) = !_glewInit_GL_EXT_framebuffer_blit(GLEW_CONTEXT_ARG_VAR_INIT);
    9130. 

  9130. #endif /* GL_EXT_framebuffer_blit */
    9131. 

  9131. #ifdef GL_EXT_framebuffer_multisample
    9132. 

  9132.   CONST_CAST(GLEW_EXT_framebuffer_multisample) = _glewSearchExtension("GL_EXT_framebuffer_multisample", extStart, extEnd);
    9133. 

  9133.   if (glewExperimental || GLEW_EXT_framebuffer_multisample) CONST_CAST(GLEW_EXT_framebuffer_multisample) = !_glewInit_GL_EXT_framebuffer_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
    9134. 

  9134. #endif /* GL_EXT_framebuffer_multisample */
    9135. 

  9135. #ifdef GL_EXT_framebuffer_multisample_blit_scaled
    9136. 

  9136.   CONST_CAST(GLEW_EXT_framebuffer_multisample_blit_scaled) = _glewSearchExtension("GL_EXT_framebuffer_multisample_blit_scaled", extStart, extEnd);
    9137. 

  9137. #endif /* GL_EXT_framebuffer_multisample_blit_scaled */
    9138. 

  9138. #ifdef GL_EXT_framebuffer_object
    9139. 

  9139.   CONST_CAST(GLEW_EXT_framebuffer_object) = _glewSearchExtension("GL_EXT_framebuffer_object", extStart, extEnd);
    9140. 

  9140.   if (glewExperimental || GLEW_EXT_framebuffer_object) CONST_CAST(GLEW_EXT_framebuffer_object) = !_glewInit_GL_EXT_framebuffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
    9141. 

  9141. #endif /* GL_EXT_framebuffer_object */
    9142. 

  9142. #ifdef GL_EXT_framebuffer_sRGB
    9143. 

  9143.   CONST_CAST(GLEW_EXT_framebuffer_sRGB) = _glewSearchExtension("GL_EXT_framebuffer_sRGB", extStart, extEnd);
    9144. 

  9144. #endif /* GL_EXT_framebuffer_sRGB */
    9145. 

  9145. #ifdef GL_EXT_geometry_shader4
    9146. 

  9146.   CONST_CAST(GLEW_EXT_geometry_shader4) = _glewSearchExtension("GL_EXT_geometry_shader4", extStart, extEnd);
    9147. 

  9147.   if (glewExperimental || GLEW_EXT_geometry_shader4) CONST_CAST(GLEW_EXT_geometry_shader4) = !_glewInit_GL_EXT_geometry_shader4(GLEW_CONTEXT_ARG_VAR_INIT);
    9148. 

  9148. #endif /* GL_EXT_geometry_shader4 */
    9149. 

  9149. #ifdef GL_EXT_gpu_program_parameters
    9150. 

  9150.   CONST_CAST(GLEW_EXT_gpu_program_parameters) = _glewSearchExtension("GL_EXT_gpu_program_parameters", extStart, extEnd);
    9151. 

  9151.   if (glewExperimental || GLEW_EXT_gpu_program_parameters) CONST_CAST(GLEW_EXT_gpu_program_parameters) = !_glewInit_GL_EXT_gpu_program_parameters(GLEW_CONTEXT_ARG_VAR_INIT);
    9152. 

  9152. #endif /* GL_EXT_gpu_program_parameters */
    9153. 

  9153. #ifdef GL_EXT_gpu_shader4
    9154. 

  9154.   CONST_CAST(GLEW_EXT_gpu_shader4) = _glewSearchExtension("GL_EXT_gpu_shader4", extStart, extEnd);
    9155. 

  9155.   if (glewExperimental || GLEW_EXT_gpu_shader4) CONST_CAST(GLEW_EXT_gpu_shader4) = !_glewInit_GL_EXT_gpu_shader4(GLEW_CONTEXT_ARG_VAR_INIT);
    9156. 

  9156. #endif /* GL_EXT_gpu_shader4 */
    9157. 

  9157. #ifdef GL_EXT_histogram
    9158. 

  9158.   CONST_CAST(GLEW_EXT_histogram) = _glewSearchExtension("GL_EXT_histogram", extStart, extEnd);
    9159. 

  9159.   if (glewExperimental || GLEW_EXT_histogram) CONST_CAST(GLEW_EXT_histogram) = !_glewInit_GL_EXT_histogram(GLEW_CONTEXT_ARG_VAR_INIT);
    9160. 

  9160. #endif /* GL_EXT_histogram */
    9161. 

  9161. #ifdef GL_EXT_index_array_formats
    9162. 

  9162.   CONST_CAST(GLEW_EXT_index_array_formats) = _glewSearchExtension("GL_EXT_index_array_formats", extStart, extEnd);
    9163. 

  9163. #endif /* GL_EXT_index_array_formats */
    9164. 

  9164. #ifdef GL_EXT_index_func
    9165. 

  9165.   CONST_CAST(GLEW_EXT_index_func) = _glewSearchExtension("GL_EXT_index_func", extStart, extEnd);
    9166. 

  9166.   if (glewExperimental || GLEW_EXT_index_func) CONST_CAST(GLEW_EXT_index_func) = !_glewInit_GL_EXT_index_func(GLEW_CONTEXT_ARG_VAR_INIT);
    9167. 

  9167. #endif /* GL_EXT_index_func */
    9168. 

  9168. #ifdef GL_EXT_index_material
    9169. 

  9169.   CONST_CAST(GLEW_EXT_index_material) = _glewSearchExtension("GL_EXT_index_material", extStart, extEnd);
    9170. 

  9170.   if (glewExperimental || GLEW_EXT_index_material) CONST_CAST(GLEW_EXT_index_material) = !_glewInit_GL_EXT_index_material(GLEW_CONTEXT_ARG_VAR_INIT);
    9171. 

  9171. #endif /* GL_EXT_index_material */
    9172. 

  9172. #ifdef GL_EXT_index_texture
    9173. 

  9173.   CONST_CAST(GLEW_EXT_index_texture) = _glewSearchExtension("GL_EXT_index_texture", extStart, extEnd);
    9174. 

  9174. #endif /* GL_EXT_index_texture */
    9175. 

  9175. #ifdef GL_EXT_light_texture
    9176. 

  9176.   CONST_CAST(GLEW_EXT_light_texture) = _glewSearchExtension("GL_EXT_light_texture", extStart, extEnd);
    9177. 

  9177.   if (glewExperimental || GLEW_EXT_light_texture) CONST_CAST(GLEW_EXT_light_texture) = !_glewInit_GL_EXT_light_texture(GLEW_CONTEXT_ARG_VAR_INIT);
    9178. 

  9178. #endif /* GL_EXT_light_texture */
    9179. 

  9179. #ifdef GL_EXT_misc_attribute
    9180. 

  9180.   CONST_CAST(GLEW_EXT_misc_attribute) = _glewSearchExtension("GL_EXT_misc_attribute", extStart, extEnd);
    9181. 

  9181. #endif /* GL_EXT_misc_attribute */
    9182. 

  9182. #ifdef GL_EXT_multi_draw_arrays
    9183. 

  9183.   CONST_CAST(GLEW_EXT_multi_draw_arrays) = _glewSearchExtension("GL_EXT_multi_draw_arrays", extStart, extEnd);
    9184. 

  9184.   if (glewExperimental || GLEW_EXT_multi_draw_arrays) CONST_CAST(GLEW_EXT_multi_draw_arrays) = !_glewInit_GL_EXT_multi_draw_arrays(GLEW_CONTEXT_ARG_VAR_INIT);
    9185. 

  9185. #endif /* GL_EXT_multi_draw_arrays */
    9186. 

  9186. #ifdef GL_EXT_multisample
    9187. 

  9187.   CONST_CAST(GLEW_EXT_multisample) = _glewSearchExtension("GL_EXT_multisample", extStart, extEnd);
    9188. 

  9188.   if (glewExperimental || GLEW_EXT_multisample) CONST_CAST(GLEW_EXT_multisample) = !_glewInit_GL_EXT_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
    9189. 

  9189. #endif /* GL_EXT_multisample */
    9190. 

  9190. #ifdef GL_EXT_packed_depth_stencil
    9191. 

  9191.   CONST_CAST(GLEW_EXT_packed_depth_stencil) = _glewSearchExtension("GL_EXT_packed_depth_stencil", extStart, extEnd);
    9192. 

  9192. #endif /* GL_EXT_packed_depth_stencil */
    9193. 

  9193. #ifdef GL_EXT_packed_float
    9194. 

  9194.   CONST_CAST(GLEW_EXT_packed_float) = _glewSearchExtension("GL_EXT_packed_float", extStart, extEnd);
    9195. 

  9195. #endif /* GL_EXT_packed_float */
    9196. 

  9196. #ifdef GL_EXT_packed_pixels
    9197. 

  9197.   CONST_CAST(GLEW_EXT_packed_pixels) = _glewSearchExtension("GL_EXT_packed_pixels", extStart, extEnd);
    9198. 

  9198. #endif /* GL_EXT_packed_pixels */
    9199. 

  9199. #ifdef GL_EXT_paletted_texture
    9200. 

  9200.   CONST_CAST(GLEW_EXT_paletted_texture) = _glewSearchExtension("GL_EXT_paletted_texture", extStart, extEnd);
    9201. 

  9201.   if (glewExperimental || GLEW_EXT_paletted_texture) CONST_CAST(GLEW_EXT_paletted_texture) = !_glewInit_GL_EXT_paletted_texture(GLEW_CONTEXT_ARG_VAR_INIT);
    9202. 

  9202. #endif /* GL_EXT_paletted_texture */
    9203. 

  9203. #ifdef GL_EXT_pixel_buffer_object
    9204. 

  9204.   CONST_CAST(GLEW_EXT_pixel_buffer_object) = _glewSearchExtension("GL_EXT_pixel_buffer_object", extStart, extEnd);
    9205. 

  9205. #endif /* GL_EXT_pixel_buffer_object */
    9206. 

  9206. #ifdef GL_EXT_pixel_transform
    9207. 

  9207.   CONST_CAST(GLEW_EXT_pixel_transform) = _glewSearchExtension("GL_EXT_pixel_transform", extStart, extEnd);
    9208. 

  9208.   if (glewExperimental || GLEW_EXT_pixel_transform) CONST_CAST(GLEW_EXT_pixel_transform) = !_glewInit_GL_EXT_pixel_transform(GLEW_CONTEXT_ARG_VAR_INIT);
    9209. 

  9209. #endif /* GL_EXT_pixel_transform */
    9210. 

  9210. #ifdef GL_EXT_pixel_transform_color_table
    9211. 

  9211.   CONST_CAST(GLEW_EXT_pixel_transform_color_table) = _glewSearchExtension("GL_EXT_pixel_transform_color_table", extStart, extEnd);
    9212. 

  9212. #endif /* GL_EXT_pixel_transform_color_table */
    9213. 

  9213. #ifdef GL_EXT_point_parameters
    9214. 

  9214.   CONST_CAST(GLEW_EXT_point_parameters) = _glewSearchExtension("GL_EXT_point_parameters", extStart, extEnd);
    9215. 

  9215.   if (glewExperimental || GLEW_EXT_point_parameters) CONST_CAST(GLEW_EXT_point_parameters) = !_glewInit_GL_EXT_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT);
    9216. 

  9216. #endif /* GL_EXT_point_parameters */
    9217. 

  9217. #ifdef GL_EXT_polygon_offset
    9218. 

  9218.   CONST_CAST(GLEW_EXT_polygon_offset) = _glewSearchExtension("GL_EXT_polygon_offset", extStart, extEnd);
    9219. 

  9219.   if (glewExperimental || GLEW_EXT_polygon_offset) CONST_CAST(GLEW_EXT_polygon_offset) = !_glewInit_GL_EXT_polygon_offset(GLEW_CONTEXT_ARG_VAR_INIT);
    9220. 

  9220. #endif /* GL_EXT_polygon_offset */
    9221. 

  9221. #ifdef GL_EXT_provoking_vertex
    9222. 

  9222.   CONST_CAST(GLEW_EXT_provoking_vertex) = _glewSearchExtension("GL_EXT_provoking_vertex", extStart, extEnd);
    9223. 

  9223.   if (glewExperimental || GLEW_EXT_provoking_vertex) CONST_CAST(GLEW_EXT_provoking_vertex) = !_glewInit_GL_EXT_provoking_vertex(GLEW_CONTEXT_ARG_VAR_INIT);
    9224. 

  9224. #endif /* GL_EXT_provoking_vertex */
    9225. 

  9225. #ifdef GL_EXT_rescale_normal
    9226. 

  9226.   CONST_CAST(GLEW_EXT_rescale_normal) = _glewSearchExtension("GL_EXT_rescale_normal", extStart, extEnd);
    9227. 

  9227. #endif /* GL_EXT_rescale_normal */
    9228. 

  9228. #ifdef GL_EXT_scene_marker
    9229. 

  9229.   CONST_CAST(GLEW_EXT_scene_marker) = _glewSearchExtension("GL_EXT_scene_marker", extStart, extEnd);
    9230. 

  9230.   if (glewExperimental || GLEW_EXT_scene_marker) CONST_CAST(GLEW_EXT_scene_marker) = !_glewInit_GL_EXT_scene_marker(GLEW_CONTEXT_ARG_VAR_INIT);
    9231. 

  9231. #endif /* GL_EXT_scene_marker */
    9232. 

  9232. #ifdef GL_EXT_secondary_color
    9233. 

  9233.   CONST_CAST(GLEW_EXT_secondary_color) = _glewSearchExtension("GL_EXT_secondary_color", extStart, extEnd);
    9234. 

  9234.   if (glewExperimental || GLEW_EXT_secondary_color) CONST_CAST(GLEW_EXT_secondary_color) = !_glewInit_GL_EXT_secondary_color(GLEW_CONTEXT_ARG_VAR_INIT);
    9235. 

  9235. #endif /* GL_EXT_secondary_color */
    9236. 

  9236. #ifdef GL_EXT_separate_shader_objects
    9237. 

  9237.   CONST_CAST(GLEW_EXT_separate_shader_objects) = _glewSearchExtension("GL_EXT_separate_shader_objects", extStart, extEnd);
    9238. 

  9238.   if (glewExperimental || GLEW_EXT_separate_shader_objects) CONST_CAST(GLEW_EXT_separate_shader_objects) = !_glewInit_GL_EXT_separate_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT);
    9239. 

  9239. #endif /* GL_EXT_separate_shader_objects */
    9240. 

  9240. #ifdef GL_EXT_separate_specular_color
    9241. 

  9241.   CONST_CAST(GLEW_EXT_separate_specular_color) = _glewSearchExtension("GL_EXT_separate_specular_color", extStart, extEnd);
    9242. 

  9242. #endif /* GL_EXT_separate_specular_color */
    9243. 

  9243. #ifdef GL_EXT_shader_image_load_store
    9244. 

  9244.   CONST_CAST(GLEW_EXT_shader_image_load_store) = _glewSearchExtension("GL_EXT_shader_image_load_store", extStart, extEnd);
    9245. 

  9245.   if (glewExperimental || GLEW_EXT_shader_image_load_store) CONST_CAST(GLEW_EXT_shader_image_load_store) = !_glewInit_GL_EXT_shader_image_load_store(GLEW_CONTEXT_ARG_VAR_INIT);
    9246. 

  9246. #endif /* GL_EXT_shader_image_load_store */
    9247. 

  9247. #ifdef GL_EXT_shadow_funcs
    9248. 

  9248.   CONST_CAST(GLEW_EXT_shadow_funcs) = _glewSearchExtension("GL_EXT_shadow_funcs", extStart, extEnd);
    9249. 

  9249. #endif /* GL_EXT_shadow_funcs */
    9250. 

  9250. #ifdef GL_EXT_shared_texture_palette
    9251. 

  9251.   CONST_CAST(GLEW_EXT_shared_texture_palette) = _glewSearchExtension("GL_EXT_shared_texture_palette", extStart, extEnd);
    9252. 

  9252. #endif /* GL_EXT_shared_texture_palette */
    9253. 

  9253. #ifdef GL_EXT_stencil_clear_tag
    9254. 

  9254.   CONST_CAST(GLEW_EXT_stencil_clear_tag) = _glewSearchExtension("GL_EXT_stencil_clear_tag", extStart, extEnd);
    9255. 

  9255. #endif /* GL_EXT_stencil_clear_tag */
    9256. 

  9256. #ifdef GL_EXT_stencil_two_side
    9257. 

  9257.   CONST_CAST(GLEW_EXT_stencil_two_side) = _glewSearchExtension("GL_EXT_stencil_two_side", extStart, extEnd);
    9258. 

  9258.   if (glewExperimental || GLEW_EXT_stencil_two_side) CONST_CAST(GLEW_EXT_stencil_two_side) = !_glewInit_GL_EXT_stencil_two_side(GLEW_CONTEXT_ARG_VAR_INIT);
    9259. 

  9259. #endif /* GL_EXT_stencil_two_side */
    9260. 

  9260. #ifdef GL_EXT_stencil_wrap
    9261. 

  9261.   CONST_CAST(GLEW_EXT_stencil_wrap) = _glewSearchExtension("GL_EXT_stencil_wrap", extStart, extEnd);
    9262. 

  9262. #endif /* GL_EXT_stencil_wrap */
    9263. 

  9263. #ifdef GL_EXT_subtexture
    9264. 

  9264.   CONST_CAST(GLEW_EXT_subtexture) = _glewSearchExtension("GL_EXT_subtexture", extStart, extEnd);
    9265. 

  9265.   if (glewExperimental || GLEW_EXT_subtexture) CONST_CAST(GLEW_EXT_subtexture) = !_glewInit_GL_EXT_subtexture(GLEW_CONTEXT_ARG_VAR_INIT);
    9266. 

  9266. #endif /* GL_EXT_subtexture */
    9267. 

  9267. #ifdef GL_EXT_texture
    9268. 

  9268.   CONST_CAST(GLEW_EXT_texture) = _glewSearchExtension("GL_EXT_texture", extStart, extEnd);
    9269. 

  9269. #endif /* GL_EXT_texture */
    9270. 

  9270. #ifdef GL_EXT_texture3D
    9271. 

  9271.   CONST_CAST(GLEW_EXT_texture3D) = _glewSearchExtension("GL_EXT_texture3D", extStart, extEnd);
    9272. 

  9272.   if (glewExperimental || GLEW_EXT_texture3D) CONST_CAST(GLEW_EXT_texture3D) = !_glewInit_GL_EXT_texture3D(GLEW_CONTEXT_ARG_VAR_INIT);
    9273. 

  9273. #endif /* GL_EXT_texture3D */
    9274. 

  9274. #ifdef GL_EXT_texture_array
    9275. 

  9275.   CONST_CAST(GLEW_EXT_texture_array) = _glewSearchExtension("GL_EXT_texture_array", extStart, extEnd);
    9276. 

  9276.   if (glewExperimental || GLEW_EXT_texture_array) CONST_CAST(GLEW_EXT_texture_array) = !_glewInit_GL_EXT_texture_array(GLEW_CONTEXT_ARG_VAR_INIT);
    9277. 

  9277. #endif /* GL_EXT_texture_array */
    9278. 

  9278. #ifdef GL_EXT_texture_buffer_object
    9279. 

  9279.   CONST_CAST(GLEW_EXT_texture_buffer_object) = _glewSearchExtension("GL_EXT_texture_buffer_object", extStart, extEnd);
    9280. 

  9280.   if (glewExperimental || GLEW_EXT_texture_buffer_object) CONST_CAST(GLEW_EXT_texture_buffer_object) = !_glewInit_GL_EXT_texture_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
    9281. 

  9281. #endif /* GL_EXT_texture_buffer_object */
    9282. 

  9282. #ifdef GL_EXT_texture_compression_dxt1
    9283. 

  9283.   CONST_CAST(GLEW_EXT_texture_compression_dxt1) = _glewSearchExtension("GL_EXT_texture_compression_dxt1", extStart, extEnd);
    9284. 

  9284. #endif /* GL_EXT_texture_compression_dxt1 */
    9285. 

  9285. #ifdef GL_EXT_texture_compression_latc
    9286. 

  9286.   CONST_CAST(GLEW_EXT_texture_compression_latc) = _glewSearchExtension("GL_EXT_texture_compression_latc", extStart, extEnd);
    9287. 

  9287. #endif /* GL_EXT_texture_compression_latc */
    9288. 

  9288. #ifdef GL_EXT_texture_compression_rgtc
    9289. 

  9289.   CONST_CAST(GLEW_EXT_texture_compression_rgtc) = _glewSearchExtension("GL_EXT_texture_compression_rgtc", extStart, extEnd);
    9290. 

  9290. #endif /* GL_EXT_texture_compression_rgtc */
    9291. 

  9291. #ifdef GL_EXT_texture_compression_s3tc
    9292. 

  9292.   CONST_CAST(GLEW_EXT_texture_compression_s3tc) = _glewSearchExtension("GL_EXT_texture_compression_s3tc", extStart, extEnd);
    9293. 

  9293. #endif /* GL_EXT_texture_compression_s3tc */
    9294. 

  9294. #ifdef GL_EXT_texture_cube_map
    9295. 

  9295.   CONST_CAST(GLEW_EXT_texture_cube_map) = _glewSearchExtension("GL_EXT_texture_cube_map", extStart, extEnd);
    9296. 

  9296. #endif /* GL_EXT_texture_cube_map */
    9297. 

  9297. #ifdef GL_EXT_texture_edge_clamp
    9298. 

  9298.   CONST_CAST(GLEW_EXT_texture_edge_clamp) = _glewSearchExtension("GL_EXT_texture_edge_clamp", extStart, extEnd);
    9299. 

  9299. #endif /* GL_EXT_texture_edge_clamp */
    9300. 

  9300. #ifdef GL_EXT_texture_env
    9301. 

  9301.   CONST_CAST(GLEW_EXT_texture_env) = _glewSearchExtension("GL_EXT_texture_env", extStart, extEnd);
    9302. 

  9302. #endif /* GL_EXT_texture_env */
    9303. 

  9303. #ifdef GL_EXT_texture_env_add
    9304. 

  9304.   CONST_CAST(GLEW_EXT_texture_env_add) = _glewSearchExtension("GL_EXT_texture_env_add", extStart, extEnd);
    9305. 

  9305. #endif /* GL_EXT_texture_env_add */
    9306. 

  9306. #ifdef GL_EXT_texture_env_combine
    9307. 

  9307.   CONST_CAST(GLEW_EXT_texture_env_combine) = _glewSearchExtension("GL_EXT_texture_env_combine", extStart, extEnd);
    9308. 

  9308. #endif /* GL_EXT_texture_env_combine */
    9309. 

  9309. #ifdef GL_EXT_texture_env_dot3
    9310. 

  9310.   CONST_CAST(GLEW_EXT_texture_env_dot3) = _glewSearchExtension("GL_EXT_texture_env_dot3", extStart, extEnd);
    9311. 

  9311. #endif /* GL_EXT_texture_env_dot3 */
    9312. 

  9312. #ifdef GL_EXT_texture_filter_anisotropic
    9313. 

  9313.   CONST_CAST(GLEW_EXT_texture_filter_anisotropic) = _glewSearchExtension("GL_EXT_texture_filter_anisotropic", extStart, extEnd);
    9314. 

  9314. #endif /* GL_EXT_texture_filter_anisotropic */
    9315. 

  9315. #ifdef GL_EXT_texture_integer
    9316. 

  9316.   CONST_CAST(GLEW_EXT_texture_integer) = _glewSearchExtension("GL_EXT_texture_integer", extStart, extEnd);
    9317. 

  9317.   if (glewExperimental || GLEW_EXT_texture_integer) CONST_CAST(GLEW_EXT_texture_integer) = !_glewInit_GL_EXT_texture_integer(GLEW_CONTEXT_ARG_VAR_INIT);
    9318. 

  9318. #endif /* GL_EXT_texture_integer */
    9319. 

  9319. #ifdef GL_EXT_texture_lod_bias
    9320. 

  9320.   CONST_CAST(GLEW_EXT_texture_lod_bias) = _glewSearchExtension("GL_EXT_texture_lod_bias", extStart, extEnd);
    9321. 

  9321. #endif /* GL_EXT_texture_lod_bias */
    9322. 

  9322. #ifdef GL_EXT_texture_mirror_clamp
    9323. 

  9323.   CONST_CAST(GLEW_EXT_texture_mirror_clamp) = _glewSearchExtension("GL_EXT_texture_mirror_clamp", extStart, extEnd);
    9324. 

  9324. #endif /* GL_EXT_texture_mirror_clamp */
    9325. 

  9325. #ifdef GL_EXT_texture_object
    9326. 

  9326.   CONST_CAST(GLEW_EXT_texture_object) = _glewSearchExtension("GL_EXT_texture_object", extStart, extEnd);
    9327. 

  9327.   if (glewExperimental || GLEW_EXT_texture_object) CONST_CAST(GLEW_EXT_texture_object) = !_glewInit_GL_EXT_texture_object(GLEW_CONTEXT_ARG_VAR_INIT);
    9328. 

  9328. #endif /* GL_EXT_texture_object */
    9329. 

  9329. #ifdef GL_EXT_texture_perturb_normal
    9330. 

  9330.   CONST_CAST(GLEW_EXT_texture_perturb_normal) = _glewSearchExtension("GL_EXT_texture_perturb_normal", extStart, extEnd);
    9331. 

  9331.   if (glewExperimental || GLEW_EXT_texture_perturb_normal) CONST_CAST(GLEW_EXT_texture_perturb_normal) = !_glewInit_GL_EXT_texture_perturb_normal(GLEW_CONTEXT_ARG_VAR_INIT);
    9332. 

  9332. #endif /* GL_EXT_texture_perturb_normal */
    9333. 

  9333. #ifdef GL_EXT_texture_rectangle
    9334. 

  9334.   CONST_CAST(GLEW_EXT_texture_rectangle) = _glewSearchExtension("GL_EXT_texture_rectangle", extStart, extEnd);
    9335. 

  9335. #endif /* GL_EXT_texture_rectangle */
    9336. 

  9336. #ifdef GL_EXT_texture_sRGB
    9337. 

  9337.   CONST_CAST(GLEW_EXT_texture_sRGB) = _glewSearchExtension("GL_EXT_texture_sRGB", extStart, extEnd);
    9338. 

  9338. #endif /* GL_EXT_texture_sRGB */
    9339. 

  9339. #ifdef GL_EXT_texture_sRGB_decode
    9340. 

  9340.   CONST_CAST(GLEW_EXT_texture_sRGB_decode) = _glewSearchExtension("GL_EXT_texture_sRGB_decode", extStart, extEnd);
    9341. 

  9341. #endif /* GL_EXT_texture_sRGB_decode */
    9342. 

  9342. #ifdef GL_EXT_texture_shared_exponent
    9343. 

  9343.   CONST_CAST(GLEW_EXT_texture_shared_exponent) = _glewSearchExtension("GL_EXT_texture_shared_exponent", extStart, extEnd);
    9344. 

  9344. #endif /* GL_EXT_texture_shared_exponent */
    9345. 

  9345. #ifdef GL_EXT_texture_snorm
    9346. 

  9346.   CONST_CAST(GLEW_EXT_texture_snorm) = _glewSearchExtension("GL_EXT_texture_snorm", extStart, extEnd);
    9347. 

  9347. #endif /* GL_EXT_texture_snorm */
    9348. 

  9348. #ifdef GL_EXT_texture_swizzle
    9349. 

  9349.   CONST_CAST(GLEW_EXT_texture_swizzle) = _glewSearchExtension("GL_EXT_texture_swizzle", extStart, extEnd);
    9350. 

  9350. #endif /* GL_EXT_texture_swizzle */
    9351. 

  9351. #ifdef GL_EXT_timer_query
    9352. 

  9352.   CONST_CAST(GLEW_EXT_timer_query) = _glewSearchExtension("GL_EXT_timer_query", extStart, extEnd);
    9353. 

  9353.   if (glewExperimental || GLEW_EXT_timer_query) CONST_CAST(GLEW_EXT_timer_query) = !_glewInit_GL_EXT_timer_query(GLEW_CONTEXT_ARG_VAR_INIT);
    9354. 

  9354. #endif /* GL_EXT_timer_query */
    9355. 

  9355. #ifdef GL_EXT_transform_feedback
    9356. 

  9356.   CONST_CAST(GLEW_EXT_transform_feedback) = _glewSearchExtension("GL_EXT_transform_feedback", extStart, extEnd);
    9357. 

  9357.   if (glewExperimental || GLEW_EXT_transform_feedback) CONST_CAST(GLEW_EXT_transform_feedback) = !_glewInit_GL_EXT_transform_feedback(GLEW_CONTEXT_ARG_VAR_INIT);
    9358. 

  9358. #endif /* GL_EXT_transform_feedback */
    9359. 

  9359. #ifdef GL_EXT_vertex_array
    9360. 

  9360.   CONST_CAST(GLEW_EXT_vertex_array) = _glewSearchExtension("GL_EXT_vertex_array", extStart, extEnd);
    9361. 

  9361.   if (glewExperimental || GLEW_EXT_vertex_array) CONST_CAST(GLEW_EXT_vertex_array) = !_glewInit_GL_EXT_vertex_array(GLEW_CONTEXT_ARG_VAR_INIT);
    9362. 

  9362. #endif /* GL_EXT_vertex_array */
    9363. 

  9363. #ifdef GL_EXT_vertex_array_bgra
    9364. 

  9364.   CONST_CAST(GLEW_EXT_vertex_array_bgra) = _glewSearchExtension("GL_EXT_vertex_array_bgra", extStart, extEnd);
    9365. 

  9365. #endif /* GL_EXT_vertex_array_bgra */
    9366. 

  9366. #ifdef GL_EXT_vertex_attrib_64bit
    9367. 

  9367.   CONST_CAST(GLEW_EXT_vertex_attrib_64bit) = _glewSearchExtension("GL_EXT_vertex_attrib_64bit", extStart, extEnd);
    9368. 

  9368.   if (glewExperimental || GLEW_EXT_vertex_attrib_64bit) CONST_CAST(GLEW_EXT_vertex_attrib_64bit) = !_glewInit_GL_EXT_vertex_attrib_64bit(GLEW_CONTEXT_ARG_VAR_INIT);
    9369. 

  9369. #endif /* GL_EXT_vertex_attrib_64bit */
    9370. 

  9370. #ifdef GL_EXT_vertex_shader
    9371. 

  9371.   CONST_CAST(GLEW_EXT_vertex_shader) = _glewSearchExtension("GL_EXT_vertex_shader", extStart, extEnd);
    9372. 

  9372.   if (glewExperimental || GLEW_EXT_vertex_shader) CONST_CAST(GLEW_EXT_vertex_shader) = !_glewInit_GL_EXT_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT);
    9373. 

  9373. #endif /* GL_EXT_vertex_shader */
    9374. 

  9374. #ifdef GL_EXT_vertex_weighting
    9375. 

  9375.   CONST_CAST(GLEW_EXT_vertex_weighting) = _glewSearchExtension("GL_EXT_vertex_weighting", extStart, extEnd);
    9376. 

  9376.   if (glewExperimental || GLEW_EXT_vertex_weighting) CONST_CAST(GLEW_EXT_vertex_weighting) = !_glewInit_GL_EXT_vertex_weighting(GLEW_CONTEXT_ARG_VAR_INIT);
    9377. 

  9377. #endif /* GL_EXT_vertex_weighting */
    9378. 

  9378. #ifdef GL_EXT_x11_sync_object
    9379. 

  9379.   CONST_CAST(GLEW_EXT_x11_sync_object) = _glewSearchExtension("GL_EXT_x11_sync_object", extStart, extEnd);
    9380. 

  9380.   if (glewExperimental || GLEW_EXT_x11_sync_object) CONST_CAST(GLEW_EXT_x11_sync_object) = !_glewInit_GL_EXT_x11_sync_object(GLEW_CONTEXT_ARG_VAR_INIT);
    9381. 

  9381. #endif /* GL_EXT_x11_sync_object */
    9382. 

  9382. #ifdef GL_GREMEDY_frame_terminator
    9383. 

  9383.   CONST_CAST(GLEW_GREMEDY_frame_terminator) = _glewSearchExtension("GL_GREMEDY_frame_terminator", extStart, extEnd);
    9384. 

  9384.   if (glewExperimental || GLEW_GREMEDY_frame_terminator) CONST_CAST(GLEW_GREMEDY_frame_terminator) = !_glewInit_GL_GREMEDY_frame_terminator(GLEW_CONTEXT_ARG_VAR_INIT);
    9385. 

  9385. #endif /* GL_GREMEDY_frame_terminator */
    9386. 

  9386. #ifdef GL_GREMEDY_string_marker
    9387. 

  9387.   CONST_CAST(GLEW_GREMEDY_string_marker) = _glewSearchExtension("GL_GREMEDY_string_marker", extStart, extEnd);
    9388. 

  9388.   if (glewExperimental || GLEW_GREMEDY_string_marker) CONST_CAST(GLEW_GREMEDY_string_marker) = !_glewInit_GL_GREMEDY_string_marker(GLEW_CONTEXT_ARG_VAR_INIT);
    9389. 

  9389. #endif /* GL_GREMEDY_string_marker */
    9390. 

  9390. #ifdef GL_HP_convolution_border_modes
    9391. 

  9391.   CONST_CAST(GLEW_HP_convolution_border_modes) = _glewSearchExtension("GL_HP_convolution_border_modes", extStart, extEnd);
    9392. 

  9392. #endif /* GL_HP_convolution_border_modes */
    9393. 

  9393. #ifdef GL_HP_image_transform
    9394. 

  9394.   CONST_CAST(GLEW_HP_image_transform) = _glewSearchExtension("GL_HP_image_transform", extStart, extEnd);
    9395. 

  9395.   if (glewExperimental || GLEW_HP_image_transform) CONST_CAST(GLEW_HP_image_transform) = !_glewInit_GL_HP_image_transform(GLEW_CONTEXT_ARG_VAR_INIT);
    9396. 

  9396. #endif /* GL_HP_image_transform */
    9397. 

  9397. #ifdef GL_HP_occlusion_test
    9398. 

  9398.   CONST_CAST(GLEW_HP_occlusion_test) = _glewSearchExtension("GL_HP_occlusion_test", extStart, extEnd);
    9399. 

  9399. #endif /* GL_HP_occlusion_test */
    9400. 

  9400. #ifdef GL_HP_texture_lighting
    9401. 

  9401.   CONST_CAST(GLEW_HP_texture_lighting) = _glewSearchExtension("GL_HP_texture_lighting", extStart, extEnd);
    9402. 

  9402. #endif /* GL_HP_texture_lighting */
    9403. 

  9403. #ifdef GL_IBM_cull_vertex
    9404. 

  9404.   CONST_CAST(GLEW_IBM_cull_vertex) = _glewSearchExtension("GL_IBM_cull_vertex", extStart, extEnd);
    9405. 

  9405. #endif /* GL_IBM_cull_vertex */
    9406. 

  9406. #ifdef GL_IBM_multimode_draw_arrays
    9407. 

  9407.   CONST_CAST(GLEW_IBM_multimode_draw_arrays) = _glewSearchExtension("GL_IBM_multimode_draw_arrays", extStart, extEnd);
    9408. 

  9408.   if (glewExperimental || GLEW_IBM_multimode_draw_arrays) CONST_CAST(GLEW_IBM_multimode_draw_arrays) = !_glewInit_GL_IBM_multimode_draw_arrays(GLEW_CONTEXT_ARG_VAR_INIT);
    9409. 

  9409. #endif /* GL_IBM_multimode_draw_arrays */
    9410. 

  9410. #ifdef GL_IBM_rasterpos_clip
    9411. 

  9411.   CONST_CAST(GLEW_IBM_rasterpos_clip) = _glewSearchExtension("GL_IBM_rasterpos_clip", extStart, extEnd);
    9412. 

  9412. #endif /* GL_IBM_rasterpos_clip */
    9413. 

  9413. #ifdef GL_IBM_static_data
    9414. 

  9414.   CONST_CAST(GLEW_IBM_static_data) = _glewSearchExtension("GL_IBM_static_data", extStart, extEnd);
    9415. 

  9415. #endif /* GL_IBM_static_data */
    9416. 

  9416. #ifdef GL_IBM_texture_mirrored_repeat
    9417. 

  9417.   CONST_CAST(GLEW_IBM_texture_mirrored_repeat) = _glewSearchExtension("GL_IBM_texture_mirrored_repeat", extStart, extEnd);
    9418. 

  9418. #endif /* GL_IBM_texture_mirrored_repeat */
    9419. 

  9419. #ifdef GL_IBM_vertex_array_lists
    9420. 

  9420.   CONST_CAST(GLEW_IBM_vertex_array_lists) = _glewSearchExtension("GL_IBM_vertex_array_lists", extStart, extEnd);
    9421. 

  9421.   if (glewExperimental || GLEW_IBM_vertex_array_lists) CONST_CAST(GLEW_IBM_vertex_array_lists) = !_glewInit_GL_IBM_vertex_array_lists(GLEW_CONTEXT_ARG_VAR_INIT);
    9422. 

  9422. #endif /* GL_IBM_vertex_array_lists */
    9423. 

  9423. #ifdef GL_INGR_color_clamp
    9424. 

  9424.   CONST_CAST(GLEW_INGR_color_clamp) = _glewSearchExtension("GL_INGR_color_clamp", extStart, extEnd);
    9425. 

  9425. #endif /* GL_INGR_color_clamp */
    9426. 

  9426. #ifdef GL_INGR_interlace_read
    9427. 

  9427.   CONST_CAST(GLEW_INGR_interlace_read) = _glewSearchExtension("GL_INGR_interlace_read", extStart, extEnd);
    9428. 

  9428. #endif /* GL_INGR_interlace_read */
    9429. 

  9429. #ifdef GL_INTEL_parallel_arrays
    9430. 

  9430.   CONST_CAST(GLEW_INTEL_parallel_arrays) = _glewSearchExtension("GL_INTEL_parallel_arrays", extStart, extEnd);
    9431. 

  9431.   if (glewExperimental || GLEW_INTEL_parallel_arrays) CONST_CAST(GLEW_INTEL_parallel_arrays) = !_glewInit_GL_INTEL_parallel_arrays(GLEW_CONTEXT_ARG_VAR_INIT);
    9432. 

  9432. #endif /* GL_INTEL_parallel_arrays */
    9433. 

  9433. #ifdef GL_INTEL_texture_scissor
    9434. 

  9434.   CONST_CAST(GLEW_INTEL_texture_scissor) = _glewSearchExtension("GL_INTEL_texture_scissor", extStart, extEnd);
    9435. 

  9435.   if (glewExperimental || GLEW_INTEL_texture_scissor) CONST_CAST(GLEW_INTEL_texture_scissor) = !_glewInit_GL_INTEL_texture_scissor(GLEW_CONTEXT_ARG_VAR_INIT);
    9436. 

  9436. #endif /* GL_INTEL_texture_scissor */
    9437. 

  9437. #ifdef GL_KTX_buffer_region
    9438. 

  9438.   CONST_CAST(GLEW_KTX_buffer_region) = _glewSearchExtension("GL_KTX_buffer_region", extStart, extEnd);
    9439. 

  9439.   if (glewExperimental || GLEW_KTX_buffer_region) CONST_CAST(GLEW_KTX_buffer_region) = !_glewInit_GL_KTX_buffer_region(GLEW_CONTEXT_ARG_VAR_INIT);
    9440. 

  9440. #endif /* GL_KTX_buffer_region */
    9441. 

  9441. #ifdef GL_MESAX_texture_stack
    9442. 

  9442.   CONST_CAST(GLEW_MESAX_texture_stack) = _glewSearchExtension("GL_MESAX_texture_stack", extStart, extEnd);
    9443. 

  9443. #endif /* GL_MESAX_texture_stack */
    9444. 

  9444. #ifdef GL_MESA_pack_invert
    9445. 

  9445.   CONST_CAST(GLEW_MESA_pack_invert) = _glewSearchExtension("GL_MESA_pack_invert", extStart, extEnd);
    9446. 

  9446. #endif /* GL_MESA_pack_invert */
    9447. 

  9447. #ifdef GL_MESA_resize_buffers
    9448. 

  9448.   CONST_CAST(GLEW_MESA_resize_buffers) = _glewSearchExtension("GL_MESA_resize_buffers", extStart, extEnd);
    9449. 

  9449.   if (glewExperimental || GLEW_MESA_resize_buffers) CONST_CAST(GLEW_MESA_resize_buffers) = !_glewInit_GL_MESA_resize_buffers(GLEW_CONTEXT_ARG_VAR_INIT);
    9450. 

  9450. #endif /* GL_MESA_resize_buffers */
    9451. 

  9451. #ifdef GL_MESA_window_pos
    9452. 

  9452.   CONST_CAST(GLEW_MESA_window_pos) = _glewSearchExtension("GL_MESA_window_pos", extStart, extEnd);
    9453. 

  9453.   if (glewExperimental || GLEW_MESA_window_pos) CONST_CAST(GLEW_MESA_window_pos) = !_glewInit_GL_MESA_window_pos(GLEW_CONTEXT_ARG_VAR_INIT);
    9454. 

  9454. #endif /* GL_MESA_window_pos */
    9455. 

  9455. #ifdef GL_MESA_ycbcr_texture
    9456. 

  9456.   CONST_CAST(GLEW_MESA_ycbcr_texture) = _glewSearchExtension("GL_MESA_ycbcr_texture", extStart, extEnd);
    9457. 

  9457. #endif /* GL_MESA_ycbcr_texture */
    9458. 

  9458. #ifdef GL_NVX_gpu_memory_info
    9459. 

  9459.   CONST_CAST(GLEW_NVX_gpu_memory_info) = _glewSearchExtension("GL_NVX_gpu_memory_info", extStart, extEnd);
    9460. 

  9460. #endif /* GL_NVX_gpu_memory_info */
    9461. 

  9461. #ifdef GL_NV_blend_square
    9462. 

  9462.   CONST_CAST(GLEW_NV_blend_square) = _glewSearchExtension("GL_NV_blend_square", extStart, extEnd);
    9463. 

  9463. #endif /* GL_NV_blend_square */
    9464. 

  9464. #ifdef GL_NV_conditional_render
    9465. 

  9465.   CONST_CAST(GLEW_NV_conditional_render) = _glewSearchExtension("GL_NV_conditional_render", extStart, extEnd);
    9466. 

  9466.   if (glewExperimental || GLEW_NV_conditional_render) CONST_CAST(GLEW_NV_conditional_render) = !_glewInit_GL_NV_conditional_render(GLEW_CONTEXT_ARG_VAR_INIT);
    9467. 

  9467. #endif /* GL_NV_conditional_render */
    9468. 

  9468. #ifdef GL_NV_copy_depth_to_color
    9469. 

  9469.   CONST_CAST(GLEW_NV_copy_depth_to_color) = _glewSearchExtension("GL_NV_copy_depth_to_color", extStart, extEnd);
    9470. 

  9470. #endif /* GL_NV_copy_depth_to_color */
    9471. 

  9471. #ifdef GL_NV_copy_image
    9472. 

  9472.   CONST_CAST(GLEW_NV_copy_image) = _glewSearchExtension("GL_NV_copy_image", extStart, extEnd);
    9473. 

  9473.   if (glewExperimental || GLEW_NV_copy_image) CONST_CAST(GLEW_NV_copy_image) = !_glewInit_GL_NV_copy_image(GLEW_CONTEXT_ARG_VAR_INIT);
    9474. 

  9474. #endif /* GL_NV_copy_image */
    9475. 

  9475. #ifdef GL_NV_depth_buffer_float
    9476. 

  9476.   CONST_CAST(GLEW_NV_depth_buffer_float) = _glewSearchExtension("GL_NV_depth_buffer_float", extStart, extEnd);
    9477. 

  9477.   if (glewExperimental || GLEW_NV_depth_buffer_float) CONST_CAST(GLEW_NV_depth_buffer_float) = !_glewInit_GL_NV_depth_buffer_float(GLEW_CONTEXT_ARG_VAR_INIT);
    9478. 

  9478. #endif /* GL_NV_depth_buffer_float */
    9479. 

  9479. #ifdef GL_NV_depth_clamp
    9480. 

  9480.   CONST_CAST(GLEW_NV_depth_clamp) = _glewSearchExtension("GL_NV_depth_clamp", extStart, extEnd);
    9481. 

  9481. #endif /* GL_NV_depth_clamp */
    9482. 

  9482. #ifdef GL_NV_depth_range_unclamped
    9483. 

  9483.   CONST_CAST(GLEW_NV_depth_range_unclamped) = _glewSearchExtension("GL_NV_depth_range_unclamped", extStart, extEnd);
    9484. 

  9484. #endif /* GL_NV_depth_range_unclamped */
    9485. 

  9485. #ifdef GL_NV_evaluators
    9486. 

  9486.   CONST_CAST(GLEW_NV_evaluators) = _glewSearchExtension("GL_NV_evaluators", extStart, extEnd);
    9487. 

  9487.   if (glewExperimental || GLEW_NV_evaluators) CONST_CAST(GLEW_NV_evaluators) = !_glewInit_GL_NV_evaluators(GLEW_CONTEXT_ARG_VAR_INIT);
    9488. 

  9488. #endif /* GL_NV_evaluators */
    9489. 

  9489. #ifdef GL_NV_explicit_multisample
    9490. 

  9490.   CONST_CAST(GLEW_NV_explicit_multisample) = _glewSearchExtension("GL_NV_explicit_multisample", extStart, extEnd);
    9491. 

  9491.   if (glewExperimental || GLEW_NV_explicit_multisample) CONST_CAST(GLEW_NV_explicit_multisample) = !_glewInit_GL_NV_explicit_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
    9492. 

  9492. #endif /* GL_NV_explicit_multisample */
    9493. 

  9493. #ifdef GL_NV_fence
    9494. 

  9494.   CONST_CAST(GLEW_NV_fence) = _glewSearchExtension("GL_NV_fence", extStart, extEnd);
    9495. 

  9495.   if (glewExperimental || GLEW_NV_fence) CONST_CAST(GLEW_NV_fence) = !_glewInit_GL_NV_fence(GLEW_CONTEXT_ARG_VAR_INIT);
    9496. 

  9496. #endif /* GL_NV_fence */
    9497. 

  9497. #ifdef GL_NV_float_buffer
    9498. 

  9498.   CONST_CAST(GLEW_NV_float_buffer) = _glewSearchExtension("GL_NV_float_buffer", extStart, extEnd);
    9499. 

  9499. #endif /* GL_NV_float_buffer */
    9500. 

  9500. #ifdef GL_NV_fog_distance
    9501. 

  9501.   CONST_CAST(GLEW_NV_fog_distance) = _glewSearchExtension("GL_NV_fog_distance", extStart, extEnd);
    9502. 

  9502. #endif /* GL_NV_fog_distance */
    9503. 

  9503. #ifdef GL_NV_fragment_program
    9504. 

  9504.   CONST_CAST(GLEW_NV_fragment_program) = _glewSearchExtension("GL_NV_fragment_program", extStart, extEnd);
    9505. 

  9505.   if (glewExperimental || GLEW_NV_fragment_program) CONST_CAST(GLEW_NV_fragment_program) = !_glewInit_GL_NV_fragment_program(GLEW_CONTEXT_ARG_VAR_INIT);
    9506. 

  9506. #endif /* GL_NV_fragment_program */
    9507. 

  9507. #ifdef GL_NV_fragment_program2
    9508. 

  9508.   CONST_CAST(GLEW_NV_fragment_program2) = _glewSearchExtension("GL_NV_fragment_program2", extStart, extEnd);
    9509. 

  9509. #endif /* GL_NV_fragment_program2 */
    9510. 

  9510. #ifdef GL_NV_fragment_program4
    9511. 

  9511.   CONST_CAST(GLEW_NV_fragment_program4) = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd);
    9512. 

  9512. #endif /* GL_NV_fragment_program4 */
    9513. 

  9513. #ifdef GL_NV_fragment_program_option
    9514. 

  9514.   CONST_CAST(GLEW_NV_fragment_program_option) = _glewSearchExtension("GL_NV_fragment_program_option", extStart, extEnd);
    9515. 

  9515. #endif /* GL_NV_fragment_program_option */
    9516. 

  9516. #ifdef GL_NV_framebuffer_multisample_coverage
    9517. 

  9517.   CONST_CAST(GLEW_NV_framebuffer_multisample_coverage) = _glewSearchExtension("GL_NV_framebuffer_multisample_coverage", extStart, extEnd);
    9518. 

  9518.   if (glewExperimental || GLEW_NV_framebuffer_multisample_coverage) CONST_CAST(GLEW_NV_framebuffer_multisample_coverage) = !_glewInit_GL_NV_framebuffer_multisample_coverage(GLEW_CONTEXT_ARG_VAR_INIT);
    9519. 

  9519. #endif /* GL_NV_framebuffer_multisample_coverage */
    9520. 

  9520. #ifdef GL_NV_geometry_program4
    9521. 

  9521.   CONST_CAST(GLEW_NV_geometry_program4) = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd);
    9522. 

  9522.   if (glewExperimental || GLEW_NV_geometry_program4) CONST_CAST(GLEW_NV_geometry_program4) = !_glewInit_GL_NV_geometry_program4(GLEW_CONTEXT_ARG_VAR_INIT);
    9523. 

  9523. #endif /* GL_NV_geometry_program4 */
    9524. 

  9524. #ifdef GL_NV_geometry_shader4
    9525. 

  9525.   CONST_CAST(GLEW_NV_geometry_shader4) = _glewSearchExtension("GL_NV_geometry_shader4", extStart, extEnd);
    9526. 

  9526. #endif /* GL_NV_geometry_shader4 */
    9527. 

  9527. #ifdef GL_NV_gpu_program4
    9528. 

  9528.   CONST_CAST(GLEW_NV_gpu_program4) = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd);
    9529. 

  9529.   if (glewExperimental || GLEW_NV_gpu_program4) CONST_CAST(GLEW_NV_gpu_program4) = !_glewInit_GL_NV_gpu_program4(GLEW_CONTEXT_ARG_VAR_INIT);
    9530. 

  9530. #endif /* GL_NV_gpu_program4 */
    9531. 

  9531. #ifdef GL_NV_gpu_program5
    9532. 

  9532.   CONST_CAST(GLEW_NV_gpu_program5) = _glewSearchExtension("GL_NV_gpu_program5", extStart, extEnd);
    9533. 

  9533. #endif /* GL_NV_gpu_program5 */
    9534. 

  9534. #ifdef GL_NV_gpu_program_fp64
    9535. 

  9535.   CONST_CAST(GLEW_NV_gpu_program_fp64) = _glewSearchExtension("GL_NV_gpu_program_fp64", extStart, extEnd);
    9536. 

  9536. #endif /* GL_NV_gpu_program_fp64 */
    9537. 

  9537. #ifdef GL_NV_gpu_shader5
    9538. 

  9538.   CONST_CAST(GLEW_NV_gpu_shader5) = _glewSearchExtension("GL_NV_gpu_shader5", extStart, extEnd);
    9539. 

  9539.   if (glewExperimental || GLEW_NV_gpu_shader5) CONST_CAST(GLEW_NV_gpu_shader5) = !_glewInit_GL_NV_gpu_shader5(GLEW_CONTEXT_ARG_VAR_INIT);
    9540. 

  9540. #endif /* GL_NV_gpu_shader5 */
    9541. 

  9541. #ifdef GL_NV_half_float
    9542. 

  9542.   CONST_CAST(GLEW_NV_half_float) = _glewSearchExtension("GL_NV_half_float", extStart, extEnd);
    9543. 

  9543.   if (glewExperimental || GLEW_NV_half_float) CONST_CAST(GLEW_NV_half_float) = !_glewInit_GL_NV_half_float(GLEW_CONTEXT_ARG_VAR_INIT);
    9544. 

  9544. #endif /* GL_NV_half_float */
    9545. 

  9545. #ifdef GL_NV_light_max_exponent
    9546. 

  9546.   CONST_CAST(GLEW_NV_light_max_exponent) = _glewSearchExtension("GL_NV_light_max_exponent", extStart, extEnd);
    9547. 

  9547. #endif /* GL_NV_light_max_exponent */
    9548. 

  9548. #ifdef GL_NV_multisample_coverage
    9549. 

  9549.   CONST_CAST(GLEW_NV_multisample_coverage) = _glewSearchExtension("GL_NV_multisample_coverage", extStart, extEnd);
    9550. 

  9550. #endif /* GL_NV_multisample_coverage */
    9551. 

  9551. #ifdef GL_NV_multisample_filter_hint
    9552. 

  9552.   CONST_CAST(GLEW_NV_multisample_filter_hint) = _glewSearchExtension("GL_NV_multisample_filter_hint", extStart, extEnd);
    9553. 

  9553. #endif /* GL_NV_multisample_filter_hint */
    9554. 

  9554. #ifdef GL_NV_occlusion_query
    9555. 

  9555.   CONST_CAST(GLEW_NV_occlusion_query) = _glewSearchExtension("GL_NV_occlusion_query", extStart, extEnd);
    9556. 

  9556.   if (glewExperimental || GLEW_NV_occlusion_query) CONST_CAST(GLEW_NV_occlusion_query) = !_glewInit_GL_NV_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT);
    9557. 

  9557. #endif /* GL_NV_occlusion_query */
    9558. 

  9558. #ifdef GL_NV_packed_depth_stencil
    9559. 

  9559.   CONST_CAST(GLEW_NV_packed_depth_stencil) = _glewSearchExtension("GL_NV_packed_depth_stencil", extStart, extEnd);
    9560. 

  9560. #endif /* GL_NV_packed_depth_stencil */
    9561. 

  9561. #ifdef GL_NV_parameter_buffer_object
    9562. 

  9562.   CONST_CAST(GLEW_NV_parameter_buffer_object) = _glewSearchExtension("GL_NV_parameter_buffer_object", extStart, extEnd);
    9563. 

  9563.   if (glewExperimental || GLEW_NV_parameter_buffer_object) CONST_CAST(GLEW_NV_parameter_buffer_object) = !_glewInit_GL_NV_parameter_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT);
    9564. 

  9564. #endif /* GL_NV_parameter_buffer_object */
    9565. 

  9565. #ifdef GL_NV_parameter_buffer_object2
    9566. 

  9566.   CONST_CAST(GLEW_NV_parameter_buffer_object2) = _glewSearchExtension("GL_NV_parameter_buffer_object2", extStart, extEnd);
    9567. 

  9567. #endif /* GL_NV_parameter_buffer_object2 */
    9568. 

  9568. #ifdef GL_NV_path_rendering
    9569. 

  9569.   CONST_CAST(GLEW_NV_path_rendering) = _glewSearchExtension("GL_NV_path_rendering", extStart, extEnd);
    9570. 

  9570.   if (glewExperimental || GLEW_NV_path_rendering) CONST_CAST(GLEW_NV_path_rendering) = !_glewInit_GL_NV_path_rendering(GLEW_CONTEXT_ARG_VAR_INIT);
    9571. 

  9571. #endif /* GL_NV_path_rendering */
    9572. 

  9572. #ifdef GL_NV_pixel_data_range
    9573. 

  9573.   CONST_CAST(GLEW_NV_pixel_data_range) = _glewSearchExtension("GL_NV_pixel_data_range", extStart, extEnd);
    9574. 

  9574.   if (glewExperimental || GLEW_NV_pixel_data_range) CONST_CAST(GLEW_NV_pixel_data_range) = !_glewInit_GL_NV_pixel_data_range(GLEW_CONTEXT_ARG_VAR_INIT);
    9575. 

  9575. #endif /* GL_NV_pixel_data_range */
    9576. 

  9576. #ifdef GL_NV_point_sprite
    9577. 

  9577.   CONST_CAST(GLEW_NV_point_sprite) = _glewSearchExtension("GL_NV_point_sprite", extStart, extEnd);
    9578. 

  9578.   if (glewExperimental || GLEW_NV_point_sprite) CONST_CAST(GLEW_NV_point_sprite) = !_glewInit_GL_NV_point_sprite(GLEW_CONTEXT_ARG_VAR_INIT);
    9579. 

  9579. #endif /* GL_NV_point_sprite */
    9580. 

  9580. #ifdef GL_NV_present_video
    9581. 

  9581.   CONST_CAST(GLEW_NV_present_video) = _glewSearchExtension("GL_NV_present_video", extStart, extEnd);
    9582. 

  9582.   if (glewExperimental || GLEW_NV_present_video) CONST_CAST(GLEW_NV_present_video) = !_glewInit_GL_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT);
    9583. 

  9583. #endif /* GL_NV_present_video */
    9584. 

  9584. #ifdef GL_NV_primitive_restart
    9585. 

  9585.   CONST_CAST(GLEW_NV_primitive_restart) = _glewSearchExtension("GL_NV_primitive_restart", extStart, extEnd);
    9586. 

  9586.   if (glewExperimental || GLEW_NV_primitive_restart) CONST_CAST(GLEW_NV_primitive_restart) = !_glewInit_GL_NV_primitive_restart(GLEW_CONTEXT_ARG_VAR_INIT);
    9587. 

  9587. #endif /* GL_NV_primitive_restart */
    9588. 

  9588. #ifdef GL_NV_register_combiners
    9589. 

  9589.   CONST_CAST(GLEW_NV_register_combiners) = _glewSearchExtension("GL_NV_register_combiners", extStart, extEnd);
    9590. 

  9590.   if (glewExperimental || GLEW_NV_register_combiners) CONST_CAST(GLEW_NV_register_combiners) = !_glewInit_GL_NV_register_combiners(GLEW_CONTEXT_ARG_VAR_INIT);
    9591. 

  9591. #endif /* GL_NV_register_combiners */
    9592. 

  9592. #ifdef GL_NV_register_combiners2
    9593. 

  9593.   CONST_CAST(GLEW_NV_register_combiners2) = _glewSearchExtension("GL_NV_register_combiners2", extStart, extEnd);
    9594. 

  9594.   if (glewExperimental || GLEW_NV_register_combiners2) CONST_CAST(GLEW_NV_register_combiners2) = !_glewInit_GL_NV_register_combiners2(GLEW_CONTEXT_ARG_VAR_INIT);
    9595. 

  9595. #endif /* GL_NV_register_combiners2 */
    9596. 

  9596. #ifdef GL_NV_shader_buffer_load
    9597. 

  9597.   CONST_CAST(GLEW_NV_shader_buffer_load) = _glewSearchExtension("GL_NV_shader_buffer_load", extStart, extEnd);
    9598. 

  9598.   if (glewExperimental || GLEW_NV_shader_buffer_load) CONST_CAST(GLEW_NV_shader_buffer_load) = !_glewInit_GL_NV_shader_buffer_load(GLEW_CONTEXT_ARG_VAR_INIT);
    9599. 

  9599. #endif /* GL_NV_shader_buffer_load */
    9600. 

  9600. #ifdef GL_NV_tessellation_program5
    9601. 

  9601.   CONST_CAST(GLEW_NV_tessellation_program5) = _glewSearchExtension("GL_NV_gpu_program5", extStart, extEnd);
    9602. 

  9602. #endif /* GL_NV_tessellation_program5 */
    9603. 

  9603. #ifdef GL_NV_texgen_emboss
    9604. 

  9604.   CONST_CAST(GLEW_NV_texgen_emboss) = _glewSearchExtension("GL_NV_texgen_emboss", extStart, extEnd);
    9605. 

  9605. #endif /* GL_NV_texgen_emboss */
    9606. 

  9606. #ifdef GL_NV_texgen_reflection
    9607. 

  9607.   CONST_CAST(GLEW_NV_texgen_reflection) = _glewSearchExtension("GL_NV_texgen_reflection", extStart, extEnd);
    9608. 

  9608. #endif /* GL_NV_texgen_reflection */
    9609. 

  9609. #ifdef GL_NV_texture_barrier
    9610. 

  9610.   CONST_CAST(GLEW_NV_texture_barrier) = _glewSearchExtension("GL_NV_texture_barrier", extStart, extEnd);
    9611. 

  9611.   if (glewExperimental || GLEW_NV_texture_barrier) CONST_CAST(GLEW_NV_texture_barrier) = !_glewInit_GL_NV_texture_barrier(GLEW_CONTEXT_ARG_VAR_INIT);
    9612. 

  9612. #endif /* GL_NV_texture_barrier */
    9613. 

  9613. #ifdef GL_NV_texture_compression_vtc
    9614. 

  9614.   CONST_CAST(GLEW_NV_texture_compression_vtc) = _glewSearchExtension("GL_NV_texture_compression_vtc", extStart, extEnd);
    9615. 

  9615. #endif /* GL_NV_texture_compression_vtc */
    9616. 

  9616. #ifdef GL_NV_texture_env_combine4
    9617. 

  9617.   CONST_CAST(GLEW_NV_texture_env_combine4) = _glewSearchExtension("GL_NV_texture_env_combine4", extStart, extEnd);
    9618. 

  9618. #endif /* GL_NV_texture_env_combine4 */
    9619. 

  9619. #ifdef GL_NV_texture_expand_normal
    9620. 

  9620.   CONST_CAST(GLEW_NV_texture_expand_normal) = _glewSearchExtension("GL_NV_texture_expand_normal", extStart, extEnd);
    9621. 

  9621. #endif /* GL_NV_texture_expand_normal */
    9622. 

  9622. #ifdef GL_NV_texture_multisample
    9623. 

  9623.   CONST_CAST(GLEW_NV_texture_multisample) = _glewSearchExtension("GL_NV_texture_multisample", extStart, extEnd);
    9624. 

  9624.   if (glewExperimental || GLEW_NV_texture_multisample) CONST_CAST(GLEW_NV_texture_multisample) = !_glewInit_GL_NV_texture_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
    9625. 

  9625. #endif /* GL_NV_texture_multisample */
    9626. 

  9626. #ifdef GL_NV_texture_rectangle
    9627. 

  9627.   CONST_CAST(GLEW_NV_texture_rectangle) = _glewSearchExtension("GL_NV_texture_rectangle", extStart, extEnd);
    9628. 

  9628. #endif /* GL_NV_texture_rectangle */
    9629. 

  9629. #ifdef GL_NV_texture_shader
    9630. 

  9630.   CONST_CAST(GLEW_NV_texture_shader) = _glewSearchExtension("GL_NV_texture_shader", extStart, extEnd);
    9631. 

  9631. #endif /* GL_NV_texture_shader */
    9632. 

  9632. #ifdef GL_NV_texture_shader2
    9633. 

  9633.   CONST_CAST(GLEW_NV_texture_shader2) = _glewSearchExtension("GL_NV_texture_shader2", extStart, extEnd);
    9634. 

  9634. #endif /* GL_NV_texture_shader2 */
    9635. 

  9635. #ifdef GL_NV_texture_shader3
    9636. 

  9636.   CONST_CAST(GLEW_NV_texture_shader3) = _glewSearchExtension("GL_NV_texture_shader3", extStart, extEnd);
    9637. 

  9637. #endif /* GL_NV_texture_shader3 */
    9638. 

  9638. #ifdef GL_NV_transform_feedback
    9639. 

  9639.   CONST_CAST(GLEW_NV_transform_feedback) = _glewSearchExtension("GL_NV_transform_feedback", extStart, extEnd);
    9640. 

  9640.   if (glewExperimental || GLEW_NV_transform_feedback) CONST_CAST(GLEW_NV_transform_feedback) = !_glewInit_GL_NV_transform_feedback(GLEW_CONTEXT_ARG_VAR_INIT);
    9641. 

  9641. #endif /* GL_NV_transform_feedback */
    9642. 

  9642. #ifdef GL_NV_transform_feedback2
    9643. 

  9643.   CONST_CAST(GLEW_NV_transform_feedback2) = _glewSearchExtension("GL_NV_transform_feedback2", extStart, extEnd);
    9644. 

  9644.   if (glewExperimental || GLEW_NV_transform_feedback2) CONST_CAST(GLEW_NV_transform_feedback2) = !_glewInit_GL_NV_transform_feedback2(GLEW_CONTEXT_ARG_VAR_INIT);
    9645. 

  9645. #endif /* GL_NV_transform_feedback2 */
    9646. 

  9646. #ifdef GL_NV_vdpau_interop
    9647. 

  9647.   CONST_CAST(GLEW_NV_vdpau_interop) = _glewSearchExtension("GL_NV_vdpau_interop", extStart, extEnd);
    9648. 

  9648.   if (glewExperimental || GLEW_NV_vdpau_interop) CONST_CAST(GLEW_NV_vdpau_interop) = !_glewInit_GL_NV_vdpau_interop(GLEW_CONTEXT_ARG_VAR_INIT);
    9649. 

  9649. #endif /* GL_NV_vdpau_interop */
    9650. 

  9650. #ifdef GL_NV_vertex_array_range
    9651. 

  9651.   CONST_CAST(GLEW_NV_vertex_array_range) = _glewSearchExtension("GL_NV_vertex_array_range", extStart, extEnd);
    9652. 

  9652.   if (glewExperimental || GLEW_NV_vertex_array_range) CONST_CAST(GLEW_NV_vertex_array_range) = !_glewInit_GL_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);
    9653. 

  9653. #endif /* GL_NV_vertex_array_range */
    9654. 

  9654. #ifdef GL_NV_vertex_array_range2
    9655. 

  9655.   CONST_CAST(GLEW_NV_vertex_array_range2) = _glewSearchExtension("GL_NV_vertex_array_range2", extStart, extEnd);
    9656. 

  9656. #endif /* GL_NV_vertex_array_range2 */
    9657. 

  9657. #ifdef GL_NV_vertex_attrib_integer_64bit
    9658. 

  9658.   CONST_CAST(GLEW_NV_vertex_attrib_integer_64bit) = _glewSearchExtension("GL_NV_vertex_attrib_integer_64bit", extStart, extEnd);
    9659. 

  9659.   if (glewExperimental || GLEW_NV_vertex_attrib_integer_64bit) CONST_CAST(GLEW_NV_vertex_attrib_integer_64bit) = !_glewInit_GL_NV_vertex_attrib_integer_64bit(GLEW_CONTEXT_ARG_VAR_INIT);
    9660. 

  9660. #endif /* GL_NV_vertex_attrib_integer_64bit */
    9661. 

  9661. #ifdef GL_NV_vertex_buffer_unified_memory
    9662. 

  9662.   CONST_CAST(GLEW_NV_vertex_buffer_unified_memory) = _glewSearchExtension("GL_NV_vertex_buffer_unified_memory", extStart, extEnd);
    9663. 

  9663.   if (glewExperimental || GLEW_NV_vertex_buffer_unified_memory) CONST_CAST(GLEW_NV_vertex_buffer_unified_memory) = !_glewInit_GL_NV_vertex_buffer_unified_memory(GLEW_CONTEXT_ARG_VAR_INIT);
    9664. 

  9664. #endif /* GL_NV_vertex_buffer_unified_memory */
    9665. 

  9665. #ifdef GL_NV_vertex_program
    9666. 

  9666.   CONST_CAST(GLEW_NV_vertex_program) = _glewSearchExtension("GL_NV_vertex_program", extStart, extEnd);
    9667. 

  9667.   if (glewExperimental || GLEW_NV_vertex_program) CONST_CAST(GLEW_NV_vertex_program) = !_glewInit_GL_NV_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT);
    9668. 

  9668. #endif /* GL_NV_vertex_program */
    9669. 

  9669. #ifdef GL_NV_vertex_program1_1
    9670. 

  9670.   CONST_CAST(GLEW_NV_vertex_program1_1) = _glewSearchExtension("GL_NV_vertex_program1_1", extStart, extEnd);
    9671. 

  9671. #endif /* GL_NV_vertex_program1_1 */
    9672. 

  9672. #ifdef GL_NV_vertex_program2
    9673. 

  9673.   CONST_CAST(GLEW_NV_vertex_program2) = _glewSearchExtension("GL_NV_vertex_program2", extStart, extEnd);
    9674. 

  9674. #endif /* GL_NV_vertex_program2 */
    9675. 

  9675. #ifdef GL_NV_vertex_program2_option
    9676. 

  9676.   CONST_CAST(GLEW_NV_vertex_program2_option) = _glewSearchExtension("GL_NV_vertex_program2_option", extStart, extEnd);
    9677. 

  9677. #endif /* GL_NV_vertex_program2_option */
    9678. 

  9678. #ifdef GL_NV_vertex_program3
    9679. 

  9679.   CONST_CAST(GLEW_NV_vertex_program3) = _glewSearchExtension("GL_NV_vertex_program3", extStart, extEnd);
    9680. 

  9680. #endif /* GL_NV_vertex_program3 */
    9681. 

  9681. #ifdef GL_NV_vertex_program4
    9682. 

  9682.   CONST_CAST(GLEW_NV_vertex_program4) = _glewSearchExtension("GL_NV_gpu_program4", extStart, extEnd);
    9683. 

  9683. #endif /* GL_NV_vertex_program4 */
    9684. 

  9684. #ifdef GL_NV_video_capture
    9685. 

  9685.   CONST_CAST(GLEW_NV_video_capture) = _glewSearchExtension("GL_NV_video_capture", extStart, extEnd);
    9686. 

  9686.   if (glewExperimental || GLEW_NV_video_capture) CONST_CAST(GLEW_NV_video_capture) = !_glewInit_GL_NV_video_capture(GLEW_CONTEXT_ARG_VAR_INIT);
    9687. 

  9687. #endif /* GL_NV_video_capture */
    9688. 

  9688. #ifdef GL_OES_byte_coordinates
    9689. 

  9689.   CONST_CAST(GLEW_OES_byte_coordinates) = _glewSearchExtension("GL_OES_byte_coordinates", extStart, extEnd);
    9690. 

  9690. #endif /* GL_OES_byte_coordinates */
    9691. 

  9691. #ifdef GL_OES_compressed_paletted_texture
    9692. 

  9692.   CONST_CAST(GLEW_OES_compressed_paletted_texture) = _glewSearchExtension("GL_OES_compressed_paletted_texture", extStart, extEnd);
    9693. 

  9693. #endif /* GL_OES_compressed_paletted_texture */
    9694. 

  9694. #ifdef GL_OES_read_format
    9695. 

  9695.   CONST_CAST(GLEW_OES_read_format) = _glewSearchExtension("GL_OES_read_format", extStart, extEnd);
    9696. 

  9696. #endif /* GL_OES_read_format */
    9697. 

  9697. #ifdef GL_OES_single_precision
    9698. 

  9698.   CONST_CAST(GLEW_OES_single_precision) = _glewSearchExtension("GL_OES_single_precision", extStart, extEnd);
    9699. 

  9699.   if (glewExperimental || GLEW_OES_single_precision) CONST_CAST(GLEW_OES_single_precision) = !_glewInit_GL_OES_single_precision(GLEW_CONTEXT_ARG_VAR_INIT);
    9700. 

  9700. #endif /* GL_OES_single_precision */
    9701. 

  9701. #ifdef GL_OML_interlace
    9702. 

  9702.   CONST_CAST(GLEW_OML_interlace) = _glewSearchExtension("GL_OML_interlace", extStart, extEnd);
    9703. 

  9703. #endif /* GL_OML_interlace */
    9704. 

  9704. #ifdef GL_OML_resample
    9705. 

  9705.   CONST_CAST(GLEW_OML_resample) = _glewSearchExtension("GL_OML_resample", extStart, extEnd);
    9706. 

  9706. #endif /* GL_OML_resample */
    9707. 

  9707. #ifdef GL_OML_subsample
    9708. 

  9708.   CONST_CAST(GLEW_OML_subsample) = _glewSearchExtension("GL_OML_subsample", extStart, extEnd);
    9709. 

  9709. #endif /* GL_OML_subsample */
    9710. 

  9710. #ifdef GL_PGI_misc_hints
    9711. 

  9711.   CONST_CAST(GLEW_PGI_misc_hints) = _glewSearchExtension("GL_PGI_misc_hints", extStart, extEnd);
    9712. 

  9712. #endif /* GL_PGI_misc_hints */
    9713. 

  9713. #ifdef GL_PGI_vertex_hints
    9714. 

  9714.   CONST_CAST(GLEW_PGI_vertex_hints) = _glewSearchExtension("GL_PGI_vertex_hints", extStart, extEnd);
    9715. 

  9715. #endif /* GL_PGI_vertex_hints */
    9716. 

  9716. #ifdef GL_REND_screen_coordinates
    9717. 

  9717.   CONST_CAST(GLEW_REND_screen_coordinates) = _glewSearchExtension("GL_REND_screen_coordinates", extStart, extEnd);
    9718. 

  9718. #endif /* GL_REND_screen_coordinates */
    9719. 

  9719. #ifdef GL_S3_s3tc
    9720. 

  9720.   CONST_CAST(GLEW_S3_s3tc) = _glewSearchExtension("GL_S3_s3tc", extStart, extEnd);
    9721. 

  9721. #endif /* GL_S3_s3tc */
    9722. 

  9722. #ifdef GL_SGIS_color_range
    9723. 

  9723.   CONST_CAST(GLEW_SGIS_color_range) = _glewSearchExtension("GL_SGIS_color_range", extStart, extEnd);
    9724. 

  9724. #endif /* GL_SGIS_color_range */
    9725. 

  9725. #ifdef GL_SGIS_detail_texture
    9726. 

  9726.   CONST_CAST(GLEW_SGIS_detail_texture) = _glewSearchExtension("GL_SGIS_detail_texture", extStart, extEnd);
    9727. 

  9727.   if (glewExperimental || GLEW_SGIS_detail_texture) CONST_CAST(GLEW_SGIS_detail_texture) = !_glewInit_GL_SGIS_detail_texture(GLEW_CONTEXT_ARG_VAR_INIT);
    9728. 

  9728. #endif /* GL_SGIS_detail_texture */
    9729. 

  9729. #ifdef GL_SGIS_fog_function
    9730. 

  9730.   CONST_CAST(GLEW_SGIS_fog_function) = _glewSearchExtension("GL_SGIS_fog_function", extStart, extEnd);
    9731. 

  9731.   if (glewExperimental || GLEW_SGIS_fog_function) CONST_CAST(GLEW_SGIS_fog_function) = !_glewInit_GL_SGIS_fog_function(GLEW_CONTEXT_ARG_VAR_INIT);
    9732. 

  9732. #endif /* GL_SGIS_fog_function */
    9733. 

  9733. #ifdef GL_SGIS_generate_mipmap
    9734. 

  9734.   CONST_CAST(GLEW_SGIS_generate_mipmap) = _glewSearchExtension("GL_SGIS_generate_mipmap", extStart, extEnd);
    9735. 

  9735. #endif /* GL_SGIS_generate_mipmap */
    9736. 

  9736. #ifdef GL_SGIS_multisample
    9737. 

  9737.   CONST_CAST(GLEW_SGIS_multisample) = _glewSearchExtension("GL_SGIS_multisample", extStart, extEnd);
    9738. 

  9738.   if (glewExperimental || GLEW_SGIS_multisample) CONST_CAST(GLEW_SGIS_multisample) = !_glewInit_GL_SGIS_multisample(GLEW_CONTEXT_ARG_VAR_INIT);
    9739. 

  9739. #endif /* GL_SGIS_multisample */
    9740. 

  9740. #ifdef GL_SGIS_pixel_texture
    9741. 

  9741.   CONST_CAST(GLEW_SGIS_pixel_texture) = _glewSearchExtension("GL_SGIS_pixel_texture", extStart, extEnd);
    9742. 

  9742. #endif /* GL_SGIS_pixel_texture */
    9743. 

  9743. #ifdef GL_SGIS_point_line_texgen
    9744. 

  9744.   CONST_CAST(GLEW_SGIS_point_line_texgen) = _glewSearchExtension("GL_SGIS_point_line_texgen", extStart, extEnd);
    9745. 

  9745. #endif /* GL_SGIS_point_line_texgen */
    9746. 

  9746. #ifdef GL_SGIS_sharpen_texture
    9747. 

  9747.   CONST_CAST(GLEW_SGIS_sharpen_texture) = _glewSearchExtension("GL_SGIS_sharpen_texture", extStart, extEnd);
    9748. 

  9748.   if (glewExperimental || GLEW_SGIS_sharpen_texture) CONST_CAST(GLEW_SGIS_sharpen_texture) = !_glewInit_GL_SGIS_sharpen_texture(GLEW_CONTEXT_ARG_VAR_INIT);
    9749. 

  9749. #endif /* GL_SGIS_sharpen_texture */
    9750. 

  9750. #ifdef GL_SGIS_texture4D
    9751. 

  9751.   CONST_CAST(GLEW_SGIS_texture4D) = _glewSearchExtension("GL_SGIS_texture4D", extStart, extEnd);
    9752. 

  9752.   if (glewExperimental || GLEW_SGIS_texture4D) CONST_CAST(GLEW_SGIS_texture4D) = !_glewInit_GL_SGIS_texture4D(GLEW_CONTEXT_ARG_VAR_INIT);
    9753. 

  9753. #endif /* GL_SGIS_texture4D */
    9754. 

  9754. #ifdef GL_SGIS_texture_border_clamp
    9755. 

  9755.   CONST_CAST(GLEW_SGIS_texture_border_clamp) = _glewSearchExtension("GL_SGIS_texture_border_clamp", extStart, extEnd);
    9756. 

  9756. #endif /* GL_SGIS_texture_border_clamp */
    9757. 

  9757. #ifdef GL_SGIS_texture_edge_clamp
    9758. 

  9758.   CONST_CAST(GLEW_SGIS_texture_edge_clamp) = _glewSearchExtension("GL_SGIS_texture_edge_clamp", extStart, extEnd);
    9759. 

  9759. #endif /* GL_SGIS_texture_edge_clamp */
    9760. 

  9760. #ifdef GL_SGIS_texture_filter4
    9761. 

  9761.   CONST_CAST(GLEW_SGIS_texture_filter4) = _glewSearchExtension("GL_SGIS_texture_filter4", extStart, extEnd);
    9762. 

  9762.   if (glewExperimental || GLEW_SGIS_texture_filter4) CONST_CAST(GLEW_SGIS_texture_filter4) = !_glewInit_GL_SGIS_texture_filter4(GLEW_CONTEXT_ARG_VAR_INIT);
    9763. 

  9763. #endif /* GL_SGIS_texture_filter4 */
    9764. 

  9764. #ifdef GL_SGIS_texture_lod
    9765. 

  9765.   CONST_CAST(GLEW_SGIS_texture_lod) = _glewSearchExtension("GL_SGIS_texture_lod", extStart, extEnd);
    9766. 

  9766. #endif /* GL_SGIS_texture_lod */
    9767. 

  9767. #ifdef GL_SGIS_texture_select
    9768. 

  9768.   CONST_CAST(GLEW_SGIS_texture_select) = _glewSearchExtension("GL_SGIS_texture_select", extStart, extEnd);
    9769. 

  9769. #endif /* GL_SGIS_texture_select */
    9770. 

  9770. #ifdef GL_SGIX_async
    9771. 

  9771.   CONST_CAST(GLEW_SGIX_async) = _glewSearchExtension("GL_SGIX_async", extStart, extEnd);
    9772. 

  9772.   if (glewExperimental || GLEW_SGIX_async) CONST_CAST(GLEW_SGIX_async) = !_glewInit_GL_SGIX_async(GLEW_CONTEXT_ARG_VAR_INIT);
    9773. 

  9773. #endif /* GL_SGIX_async */
    9774. 

  9774. #ifdef GL_SGIX_async_histogram
    9775. 

  9775.   CONST_CAST(GLEW_SGIX_async_histogram) = _glewSearchExtension("GL_SGIX_async_histogram", extStart, extEnd);
    9776. 

  9776. #endif /* GL_SGIX_async_histogram */
    9777. 

  9777. #ifdef GL_SGIX_async_pixel
    9778. 

  9778.   CONST_CAST(GLEW_SGIX_async_pixel) = _glewSearchExtension("GL_SGIX_async_pixel", extStart, extEnd);
    9779. 

  9779. #endif /* GL_SGIX_async_pixel */
    9780. 

  9780. #ifdef GL_SGIX_blend_alpha_minmax
    9781. 

  9781.   CONST_CAST(GLEW_SGIX_blend_alpha_minmax) = _glewSearchExtension("GL_SGIX_blend_alpha_minmax", extStart, extEnd);
    9782. 

  9782. #endif /* GL_SGIX_blend_alpha_minmax */
    9783. 

  9783. #ifdef GL_SGIX_clipmap
    9784. 

  9784.   CONST_CAST(GLEW_SGIX_clipmap) = _glewSearchExtension("GL_SGIX_clipmap", extStart, extEnd);
    9785. 

  9785. #endif /* GL_SGIX_clipmap */
    9786. 

  9786. #ifdef GL_SGIX_convolution_accuracy
    9787. 

  9787.   CONST_CAST(GLEW_SGIX_convolution_accuracy) = _glewSearchExtension("GL_SGIX_convolution_accuracy", extStart, extEnd);
    9788. 

  9788. #endif /* GL_SGIX_convolution_accuracy */
    9789. 

  9789. #ifdef GL_SGIX_depth_texture
    9790. 

  9790.   CONST_CAST(GLEW_SGIX_depth_texture) = _glewSearchExtension("GL_SGIX_depth_texture", extStart, extEnd);
    9791. 

  9791. #endif /* GL_SGIX_depth_texture */
    9792. 

  9792. #ifdef GL_SGIX_flush_raster
    9793. 

  9793.   CONST_CAST(GLEW_SGIX_flush_raster) = _glewSearchExtension("GL_SGIX_flush_raster", extStart, extEnd);
    9794. 

  9794.   if (glewExperimental || GLEW_SGIX_flush_raster) CONST_CAST(GLEW_SGIX_flush_raster) = !_glewInit_GL_SGIX_flush_raster(GLEW_CONTEXT_ARG_VAR_INIT);
    9795. 

  9795. #endif /* GL_SGIX_flush_raster */
    9796. 

  9796. #ifdef GL_SGIX_fog_offset
    9797. 

  9797.   CONST_CAST(GLEW_SGIX_fog_offset) = _glewSearchExtension("GL_SGIX_fog_offset", extStart, extEnd);
    9798. 

  9798. #endif /* GL_SGIX_fog_offset */
    9799. 

  9799. #ifdef GL_SGIX_fog_texture
    9800. 

  9800.   CONST_CAST(GLEW_SGIX_fog_texture) = _glewSearchExtension("GL_SGIX_fog_texture", extStart, extEnd);
    9801. 

  9801.   if (glewExperimental || GLEW_SGIX_fog_texture) CONST_CAST(GLEW_SGIX_fog_texture) = !_glewInit_GL_SGIX_fog_texture(GLEW_CONTEXT_ARG_VAR_INIT);
    9802. 

  9802. #endif /* GL_SGIX_fog_texture */
    9803. 

  9803. #ifdef GL_SGIX_fragment_specular_lighting
    9804. 

  9804.   CONST_CAST(GLEW_SGIX_fragment_specular_lighting) = _glewSearchExtension("GL_SGIX_fragment_specular_lighting", extStart, extEnd);
    9805. 

  9805.   if (glewExperimental || GLEW_SGIX_fragment_specular_lighting) CONST_CAST(GLEW_SGIX_fragment_specular_lighting) = !_glewInit_GL_SGIX_fragment_specular_lighting(GLEW_CONTEXT_ARG_VAR_INIT);
    9806. 

  9806. #endif /* GL_SGIX_fragment_specular_lighting */
    9807. 

  9807. #ifdef GL_SGIX_framezoom
    9808. 

  9808.   CONST_CAST(GLEW_SGIX_framezoom) = _glewSearchExtension("GL_SGIX_framezoom", extStart, extEnd);
    9809. 

  9809.   if (glewExperimental || GLEW_SGIX_framezoom) CONST_CAST(GLEW_SGIX_framezoom) = !_glewInit_GL_SGIX_framezoom(GLEW_CONTEXT_ARG_VAR_INIT);
    9810. 

  9810. #endif /* GL_SGIX_framezoom */
    9811. 

  9811. #ifdef GL_SGIX_interlace
    9812. 

  9812.   CONST_CAST(GLEW_SGIX_interlace) = _glewSearchExtension("GL_SGIX_interlace", extStart, extEnd);
    9813. 

  9813. #endif /* GL_SGIX_interlace */
    9814. 

  9814. #ifdef GL_SGIX_ir_instrument1
    9815. 

  9815.   CONST_CAST(GLEW_SGIX_ir_instrument1) = _glewSearchExtension("GL_SGIX_ir_instrument1", extStart, extEnd);
    9816. 

  9816. #endif /* GL_SGIX_ir_instrument1 */
    9817. 

  9817. #ifdef GL_SGIX_list_priority
    9818. 

  9818.   CONST_CAST(GLEW_SGIX_list_priority) = _glewSearchExtension("GL_SGIX_list_priority", extStart, extEnd);
    9819. 

  9819. #endif /* GL_SGIX_list_priority */
    9820. 

  9820. #ifdef GL_SGIX_pixel_texture
    9821. 

  9821.   CONST_CAST(GLEW_SGIX_pixel_texture) = _glewSearchExtension("GL_SGIX_pixel_texture", extStart, extEnd);
    9822. 

  9822.   if (glewExperimental || GLEW_SGIX_pixel_texture) CONST_CAST(GLEW_SGIX_pixel_texture) = !_glewInit_GL_SGIX_pixel_texture(GLEW_CONTEXT_ARG_VAR_INIT);
    9823. 

  9823. #endif /* GL_SGIX_pixel_texture */
    9824. 

  9824. #ifdef GL_SGIX_pixel_texture_bits
    9825. 

  9825.   CONST_CAST(GLEW_SGIX_pixel_texture_bits) = _glewSearchExtension("GL_SGIX_pixel_texture_bits", extStart, extEnd);
    9826. 

  9826. #endif /* GL_SGIX_pixel_texture_bits */
    9827. 

  9827. #ifdef GL_SGIX_reference_plane
    9828. 

  9828.   CONST_CAST(GLEW_SGIX_reference_plane) = _glewSearchExtension("GL_SGIX_reference_plane", extStart, extEnd);
    9829. 

  9829.   if (glewExperimental || GLEW_SGIX_reference_plane) CONST_CAST(GLEW_SGIX_reference_plane) = !_glewInit_GL_SGIX_reference_plane(GLEW_CONTEXT_ARG_VAR_INIT);
    9830. 

  9830. #endif /* GL_SGIX_reference_plane */
    9831. 

  9831. #ifdef GL_SGIX_resample
    9832. 

  9832.   CONST_CAST(GLEW_SGIX_resample) = _glewSearchExtension("GL_SGIX_resample", extStart, extEnd);
    9833. 

  9833. #endif /* GL_SGIX_resample */
    9834. 

  9834. #ifdef GL_SGIX_shadow
    9835. 

  9835.   CONST_CAST(GLEW_SGIX_shadow) = _glewSearchExtension("GL_SGIX_shadow", extStart, extEnd);
    9836. 

  9836. #endif /* GL_SGIX_shadow */
    9837. 

  9837. #ifdef GL_SGIX_shadow_ambient
    9838. 

  9838.   CONST_CAST(GLEW_SGIX_shadow_ambient) = _glewSearchExtension("GL_SGIX_shadow_ambient", extStart, extEnd);
    9839. 

  9839. #endif /* GL_SGIX_shadow_ambient */
    9840. 

  9840. #ifdef GL_SGIX_sprite
    9841. 

  9841.   CONST_CAST(GLEW_SGIX_sprite) = _glewSearchExtension("GL_SGIX_sprite", extStart, extEnd);
    9842. 

  9842.   if (glewExperimental || GLEW_SGIX_sprite) CONST_CAST(GLEW_SGIX_sprite) = !_glewInit_GL_SGIX_sprite(GLEW_CONTEXT_ARG_VAR_INIT);
    9843. 

  9843. #endif /* GL_SGIX_sprite */
    9844. 

  9844. #ifdef GL_SGIX_tag_sample_buffer
    9845. 

  9845.   CONST_CAST(GLEW_SGIX_tag_sample_buffer) = _glewSearchExtension("GL_SGIX_tag_sample_buffer", extStart, extEnd);
    9846. 

  9846.   if (glewExperimental || GLEW_SGIX_tag_sample_buffer) CONST_CAST(GLEW_SGIX_tag_sample_buffer) = !_glewInit_GL_SGIX_tag_sample_buffer(GLEW_CONTEXT_ARG_VAR_INIT);
    9847. 

  9847. #endif /* GL_SGIX_tag_sample_buffer */
    9848. 

  9848. #ifdef GL_SGIX_texture_add_env
    9849. 

  9849.   CONST_CAST(GLEW_SGIX_texture_add_env) = _glewSearchExtension("GL_SGIX_texture_add_env", extStart, extEnd);
    9850. 

  9850. #endif /* GL_SGIX_texture_add_env */
    9851. 

  9851. #ifdef GL_SGIX_texture_coordinate_clamp
    9852. 

  9852.   CONST_CAST(GLEW_SGIX_texture_coordinate_clamp) = _glewSearchExtension("GL_SGIX_texture_coordinate_clamp", extStart, extEnd);
    9853. 

  9853. #endif /* GL_SGIX_texture_coordinate_clamp */
    9854. 

  9854. #ifdef GL_SGIX_texture_lod_bias
    9855. 

  9855.   CONST_CAST(GLEW_SGIX_texture_lod_bias) = _glewSearchExtension("GL_SGIX_texture_lod_bias", extStart, extEnd);
    9856. 

  9856. #endif /* GL_SGIX_texture_lod_bias */
    9857. 

  9857. #ifdef GL_SGIX_texture_multi_buffer
    9858. 

  9858.   CONST_CAST(GLEW_SGIX_texture_multi_buffer) = _glewSearchExtension("GL_SGIX_texture_multi_buffer", extStart, extEnd);
    9859. 

  9859. #endif /* GL_SGIX_texture_multi_buffer */
    9860. 

  9860. #ifdef GL_SGIX_texture_range
    9861. 

  9861.   CONST_CAST(GLEW_SGIX_texture_range) = _glewSearchExtension("GL_SGIX_texture_range", extStart, extEnd);
    9862. 

  9862. #endif /* GL_SGIX_texture_range */
    9863. 

  9863. #ifdef GL_SGIX_texture_scale_bias
    9864. 

  9864.   CONST_CAST(GLEW_SGIX_texture_scale_bias) = _glewSearchExtension("GL_SGIX_texture_scale_bias", extStart, extEnd);
    9865. 

  9865. #endif /* GL_SGIX_texture_scale_bias */
    9866. 

  9866. #ifdef GL_SGIX_vertex_preclip
    9867. 

  9867.   CONST_CAST(GLEW_SGIX_vertex_preclip) = _glewSearchExtension("GL_SGIX_vertex_preclip", extStart, extEnd);
    9868. 

  9868. #endif /* GL_SGIX_vertex_preclip */
    9869. 

  9869. #ifdef GL_SGIX_vertex_preclip_hint
    9870. 

  9870.   CONST_CAST(GLEW_SGIX_vertex_preclip_hint) = _glewSearchExtension("GL_SGIX_vertex_preclip_hint", extStart, extEnd);
    9871. 

  9871. #endif /* GL_SGIX_vertex_preclip_hint */
    9872. 

  9872. #ifdef GL_SGIX_ycrcb
    9873. 

  9873.   CONST_CAST(GLEW_SGIX_ycrcb) = _glewSearchExtension("GL_SGIX_ycrcb", extStart, extEnd);
    9874. 

  9874. #endif /* GL_SGIX_ycrcb */
    9875. 

  9875. #ifdef GL_SGI_color_matrix
    9876. 

  9876.   CONST_CAST(GLEW_SGI_color_matrix) = _glewSearchExtension("GL_SGI_color_matrix", extStart, extEnd);
    9877. 

  9877. #endif /* GL_SGI_color_matrix */
    9878. 

  9878. #ifdef GL_SGI_color_table
    9879. 

  9879.   CONST_CAST(GLEW_SGI_color_table) = _glewSearchExtension("GL_SGI_color_table", extStart, extEnd);
    9880. 

  9880.   if (glewExperimental || GLEW_SGI_color_table) CONST_CAST(GLEW_SGI_color_table) = !_glewInit_GL_SGI_color_table(GLEW_CONTEXT_ARG_VAR_INIT);
    9881. 

  9881. #endif /* GL_SGI_color_table */
    9882. 

  9882. #ifdef GL_SGI_texture_color_table
    9883. 

  9883.   CONST_CAST(GLEW_SGI_texture_color_table) = _glewSearchExtension("GL_SGI_texture_color_table", extStart, extEnd);
    9884. 

  9884. #endif /* GL_SGI_texture_color_table */
    9885. 

  9885. #ifdef GL_SUNX_constant_data
    9886. 

  9886.   CONST_CAST(GLEW_SUNX_constant_data) = _glewSearchExtension("GL_SUNX_constant_data", extStart, extEnd);
    9887. 

  9887.   if (glewExperimental || GLEW_SUNX_constant_data) CONST_CAST(GLEW_SUNX_constant_data) = !_glewInit_GL_SUNX_constant_data(GLEW_CONTEXT_ARG_VAR_INIT);
    9888. 

  9888. #endif /* GL_SUNX_constant_data */
    9889. 

  9889. #ifdef GL_SUN_convolution_border_modes
    9890. 

  9890.   CONST_CAST(GLEW_SUN_convolution_border_modes) = _glewSearchExtension("GL_SUN_convolution_border_modes", extStart, extEnd);
    9891. 

  9891. #endif /* GL_SUN_convolution_border_modes */
    9892. 

  9892. #ifdef GL_SUN_global_alpha
    9893. 

  9893.   CONST_CAST(GLEW_SUN_global_alpha) = _glewSearchExtension("GL_SUN_global_alpha", extStart, extEnd);
    9894. 

  9894.   if (glewExperimental || GLEW_SUN_global_alpha) CONST_CAST(GLEW_SUN_global_alpha) = !_glewInit_GL_SUN_global_alpha(GLEW_CONTEXT_ARG_VAR_INIT);
    9895. 

  9895. #endif /* GL_SUN_global_alpha */
    9896. 

  9896. #ifdef GL_SUN_mesh_array
    9897. 

  9897.   CONST_CAST(GLEW_SUN_mesh_array) = _glewSearchExtension("GL_SUN_mesh_array", extStart, extEnd);
    9898. 

  9898. #endif /* GL_SUN_mesh_array */
    9899. 

  9899. #ifdef GL_SUN_read_video_pixels
    9900. 

  9900.   CONST_CAST(GLEW_SUN_read_video_pixels) = _glewSearchExtension("GL_SUN_read_video_pixels", extStart, extEnd);
    9901. 

  9901.   if (glewExperimental || GLEW_SUN_read_video_pixels) CONST_CAST(GLEW_SUN_read_video_pixels) = !_glewInit_GL_SUN_read_video_pixels(GLEW_CONTEXT_ARG_VAR_INIT);
    9902. 

  9902. #endif /* GL_SUN_read_video_pixels */
    9903. 

  9903. #ifdef GL_SUN_slice_accum
    9904. 

  9904.   CONST_CAST(GLEW_SUN_slice_accum) = _glewSearchExtension("GL_SUN_slice_accum", extStart, extEnd);
    9905. 

  9905. #endif /* GL_SUN_slice_accum */
    9906. 

  9906. #ifdef GL_SUN_triangle_list
    9907. 

  9907.   CONST_CAST(GLEW_SUN_triangle_list) = _glewSearchExtension("GL_SUN_triangle_list", extStart, extEnd);
    9908. 

  9908.   if (glewExperimental || GLEW_SUN_triangle_list) CONST_CAST(GLEW_SUN_triangle_list) = !_glewInit_GL_SUN_triangle_list(GLEW_CONTEXT_ARG_VAR_INIT);
    9909. 

  9909. #endif /* GL_SUN_triangle_list */
    9910. 

  9910. #ifdef GL_SUN_vertex
    9911. 

  9911.   CONST_CAST(GLEW_SUN_vertex) = _glewSearchExtension("GL_SUN_vertex", extStart, extEnd);
    9912. 

  9912.   if (glewExperimental || GLEW_SUN_vertex) CONST_CAST(GLEW_SUN_vertex) = !_glewInit_GL_SUN_vertex(GLEW_CONTEXT_ARG_VAR_INIT);
    9913. 

  9913. #endif /* GL_SUN_vertex */
    9914. 

  9914. #ifdef GL_WIN_phong_shading
    9915. 

  9915.   CONST_CAST(GLEW_WIN_phong_shading) = _glewSearchExtension("GL_WIN_phong_shading", extStart, extEnd);
    9916. 

  9916. #endif /* GL_WIN_phong_shading */
    9917. 

  9917. #ifdef GL_WIN_specular_fog
    9918. 

  9918.   CONST_CAST(GLEW_WIN_specular_fog) = _glewSearchExtension("GL_WIN_specular_fog", extStart, extEnd);
    9919. 

  9919. #endif /* GL_WIN_specular_fog */
    9920. 

  9920. #ifdef GL_WIN_swap_hint
    9921. 

  9921.   CONST_CAST(GLEW_WIN_swap_hint) = _glewSearchExtension("GL_WIN_swap_hint", extStart, extEnd);
    9922. 

  9922.   if (glewExperimental || GLEW_WIN_swap_hint) CONST_CAST(GLEW_WIN_swap_hint) = !_glewInit_GL_WIN_swap_hint(GLEW_CONTEXT_ARG_VAR_INIT);
    9923. 

  9923. #endif /* GL_WIN_swap_hint */
    9924. 

  9924. 

  9925.   return GLEW_OK;
    9926. 

  9926. }
    9927. 

  9927. 

  9928. 

  9929. #if defined(_WIN32)
    9930. 

  9930. 

  9931. #if !defined(GLEW_MX)
    9932. 

  9932. 

  9933. PFNWGLSETSTEREOEMITTERSTATE3DLPROC __wglewSetStereoEmitterState3DL = NULL;
    9934. 

  9934. 

  9935. PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC __wglewBlitContextFramebufferAMD = NULL;
    9936. 

  9936. PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC __wglewCreateAssociatedContextAMD = NULL;
    9937. 

  9937. PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC __wglewCreateAssociatedContextAttribsAMD = NULL;
    9938. 

  9938. PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC __wglewDeleteAssociatedContextAMD = NULL;
    9939. 

  9939. PFNWGLGETCONTEXTGPUIDAMDPROC __wglewGetContextGPUIDAMD = NULL;
    9940. 

  9940. PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC __wglewGetCurrentAssociatedContextAMD = NULL;
    9941. 

  9941. PFNWGLGETGPUIDSAMDPROC __wglewGetGPUIDsAMD = NULL;
    9942. 

  9942. PFNWGLGETGPUINFOAMDPROC __wglewGetGPUInfoAMD = NULL;
    9943. 

  9943. PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC __wglewMakeAssociatedContextCurrentAMD = NULL;
    9944. 

  9944. 

  9945. PFNWGLCREATEBUFFERREGIONARBPROC __wglewCreateBufferRegionARB = NULL;
    9946. 

  9946. PFNWGLDELETEBUFFERREGIONARBPROC __wglewDeleteBufferRegionARB = NULL;
    9947. 

  9947. PFNWGLRESTOREBUFFERREGIONARBPROC __wglewRestoreBufferRegionARB = NULL;
    9948. 

  9948. PFNWGLSAVEBUFFERREGIONARBPROC __wglewSaveBufferRegionARB = NULL;
    9949. 

  9949. 

  9950. PFNWGLCREATECONTEXTATTRIBSARBPROC __wglewCreateContextAttribsARB = NULL;
    9951. 

  9951. 

  9952. PFNWGLGETEXTENSIONSSTRINGARBPROC __wglewGetExtensionsStringARB = NULL;
    9953. 

  9953. 

  9954. PFNWGLGETCURRENTREADDCARBPROC __wglewGetCurrentReadDCARB = NULL;
    9955. 

  9955. PFNWGLMAKECONTEXTCURRENTARBPROC __wglewMakeContextCurrentARB = NULL;
    9956. 

  9956. 

  9957. PFNWGLCREATEPBUFFERARBPROC __wglewCreatePbufferARB = NULL;
    9958. 

  9958. PFNWGLDESTROYPBUFFERARBPROC __wglewDestroyPbufferARB = NULL;
    9959. 

  9959. PFNWGLGETPBUFFERDCARBPROC __wglewGetPbufferDCARB = NULL;
    9960. 

  9960. PFNWGLQUERYPBUFFERARBPROC __wglewQueryPbufferARB = NULL;
    9961. 

  9961. PFNWGLRELEASEPBUFFERDCARBPROC __wglewReleasePbufferDCARB = NULL;
    9962. 

  9962. 

  9963. PFNWGLCHOOSEPIXELFORMATARBPROC __wglewChoosePixelFormatARB = NULL;
    9964. 

  9964. PFNWGLGETPIXELFORMATATTRIBFVARBPROC __wglewGetPixelFormatAttribfvARB = NULL;
    9965. 

  9965. PFNWGLGETPIXELFORMATATTRIBIVARBPROC __wglewGetPixelFormatAttribivARB = NULL;
    9966. 

  9966. 

  9967. PFNWGLBINDTEXIMAGEARBPROC __wglewBindTexImageARB = NULL;
    9968. 

  9968. PFNWGLRELEASETEXIMAGEARBPROC __wglewReleaseTexImageARB = NULL;
    9969. 

  9969. PFNWGLSETPBUFFERATTRIBARBPROC __wglewSetPbufferAttribARB = NULL;
    9970. 

  9970. 

  9971. PFNWGLBINDDISPLAYCOLORTABLEEXTPROC __wglewBindDisplayColorTableEXT = NULL;
    9972. 

  9972. PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC __wglewCreateDisplayColorTableEXT = NULL;
    9973. 

  9973. PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC __wglewDestroyDisplayColorTableEXT = NULL;
    9974. 

  9974. PFNWGLLOADDISPLAYCOLORTABLEEXTPROC __wglewLoadDisplayColorTableEXT = NULL;
    9975. 

  9975. 

  9976. PFNWGLGETEXTENSIONSSTRINGEXTPROC __wglewGetExtensionsStringEXT = NULL;
    9977. 

  9977. 

  9978. PFNWGLGETCURRENTREADDCEXTPROC __wglewGetCurrentReadDCEXT = NULL;
    9979. 

  9979. PFNWGLMAKECONTEXTCURRENTEXTPROC __wglewMakeContextCurrentEXT = NULL;
    9980. 

  9980. 

  9981. PFNWGLCREATEPBUFFEREXTPROC __wglewCreatePbufferEXT = NULL;
    9982. 

  9982. PFNWGLDESTROYPBUFFEREXTPROC __wglewDestroyPbufferEXT = NULL;
    9983. 

  9983. PFNWGLGETPBUFFERDCEXTPROC __wglewGetPbufferDCEXT = NULL;
    9984. 

  9984. PFNWGLQUERYPBUFFEREXTPROC __wglewQueryPbufferEXT = NULL;
    9985. 

  9985. PFNWGLRELEASEPBUFFERDCEXTPROC __wglewReleasePbufferDCEXT = NULL;
    9986. 

  9986. 

  9987. PFNWGLCHOOSEPIXELFORMATEXTPROC __wglewChoosePixelFormatEXT = NULL;
    9988. 

  9988. PFNWGLGETPIXELFORMATATTRIBFVEXTPROC __wglewGetPixelFormatAttribfvEXT = NULL;
    9989. 

  9989. PFNWGLGETPIXELFORMATATTRIBIVEXTPROC __wglewGetPixelFormatAttribivEXT = NULL;
    9990. 

  9990. 

  9991. PFNWGLGETSWAPINTERVALEXTPROC __wglewGetSwapIntervalEXT = NULL;
    9992. 

  9992. PFNWGLSWAPINTERVALEXTPROC __wglewSwapIntervalEXT = NULL;
    9993. 

  9993. 

  9994. PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC __wglewGetDigitalVideoParametersI3D = NULL;
    9995. 

  9995. PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC __wglewSetDigitalVideoParametersI3D = NULL;
    9996. 

  9996. 

  9997. PFNWGLGETGAMMATABLEI3DPROC __wglewGetGammaTableI3D = NULL;
    9998. 

  9998. PFNWGLGETGAMMATABLEPARAMETERSI3DPROC __wglewGetGammaTableParametersI3D = NULL;
    9999. 

  9999. PFNWGLSETGAMMATABLEI3DPROC __wglewSetGammaTableI3D = NULL;
    10000. 

  10000. PFNWGLSETGAMMATABLEPARAMETERSI3DPROC __wglewSetGammaTableParametersI3D = NULL;
    10001. 

  10001. 

  10002. PFNWGLDISABLEGENLOCKI3DPROC __wglewDisableGenlockI3D = NULL;
    10003. 

  10003. PFNWGLENABLEGENLOCKI3DPROC __wglewEnableGenlockI3D = NULL;
    10004. 

  10004. PFNWGLGENLOCKSAMPLERATEI3DPROC __wglewGenlockSampleRateI3D = NULL;
    10005. 

  10005. PFNWGLGENLOCKSOURCEDELAYI3DPROC __wglewGenlockSourceDelayI3D = NULL;
    10006. 

  10006. PFNWGLGENLOCKSOURCEEDGEI3DPROC __wglewGenlockSourceEdgeI3D = NULL;
    10007. 

  10007. PFNWGLGENLOCKSOURCEI3DPROC __wglewGenlockSourceI3D = NULL;
    10008. 

  10008. PFNWGLGETGENLOCKSAMPLERATEI3DPROC __wglewGetGenlockSampleRateI3D = NULL;
    10009. 

  10009. PFNWGLGETGENLOCKSOURCEDELAYI3DPROC __wglewGetGenlockSourceDelayI3D = NULL;
    10010. 

  10010. PFNWGLGETGENLOCKSOURCEEDGEI3DPROC __wglewGetGenlockSourceEdgeI3D = NULL;
    10011. 

  10011. PFNWGLGETGENLOCKSOURCEI3DPROC __wglewGetGenlockSourceI3D = NULL;
    10012. 

  10012. PFNWGLISENABLEDGENLOCKI3DPROC __wglewIsEnabledGenlockI3D = NULL;
    10013. 

  10013. PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC __wglewQueryGenlockMaxSourceDelayI3D = NULL;
    10014. 

  10014. 

  10015. PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC __wglewAssociateImageBufferEventsI3D = NULL;
    10016. 

  10016. PFNWGLCREATEIMAGEBUFFERI3DPROC __wglewCreateImageBufferI3D = NULL;
    10017. 

  10017. PFNWGLDESTROYIMAGEBUFFERI3DPROC __wglewDestroyImageBufferI3D = NULL;
    10018. 

  10018. PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC __wglewReleaseImageBufferEventsI3D = NULL;
    10019. 

  10019. 

  10020. PFNWGLDISABLEFRAMELOCKI3DPROC __wglewDisableFrameLockI3D = NULL;
    10021. 

  10021. PFNWGLENABLEFRAMELOCKI3DPROC __wglewEnableFrameLockI3D = NULL;
    10022. 

  10022. PFNWGLISENABLEDFRAMELOCKI3DPROC __wglewIsEnabledFrameLockI3D = NULL;
    10023. 

  10023. PFNWGLQUERYFRAMELOCKMASTERI3DPROC __wglewQueryFrameLockMasterI3D = NULL;
    10024. 

  10024. 

  10025. PFNWGLBEGINFRAMETRACKINGI3DPROC __wglewBeginFrameTrackingI3D = NULL;
    10026. 

  10026. PFNWGLENDFRAMETRACKINGI3DPROC __wglewEndFrameTrackingI3D = NULL;
    10027. 

  10027. PFNWGLGETFRAMEUSAGEI3DPROC __wglewGetFrameUsageI3D = NULL;
    10028. 

  10028. PFNWGLQUERYFRAMETRACKINGI3DPROC __wglewQueryFrameTrackingI3D = NULL;
    10029. 

  10029. 

  10030. PFNWGLDXCLOSEDEVICENVPROC __wglewDXCloseDeviceNV = NULL;
    10031. 

  10031. PFNWGLDXLOCKOBJECTSNVPROC __wglewDXLockObjectsNV = NULL;
    10032. 

  10032. PFNWGLDXOBJECTACCESSNVPROC __wglewDXObjectAccessNV = NULL;
    10033. 

  10033. PFNWGLDXOPENDEVICENVPROC __wglewDXOpenDeviceNV = NULL;
    10034. 

  10034. PFNWGLDXREGISTEROBJECTNVPROC __wglewDXRegisterObjectNV = NULL;
    10035. 

  10035. PFNWGLDXSETRESOURCESHAREHANDLENVPROC __wglewDXSetResourceShareHandleNV = NULL;
    10036. 

  10036. PFNWGLDXUNLOCKOBJECTSNVPROC __wglewDXUnlockObjectsNV = NULL;
    10037. 

  10037. PFNWGLDXUNREGISTEROBJECTNVPROC __wglewDXUnregisterObjectNV = NULL;
    10038. 

  10038. 

  10039. PFNWGLCOPYIMAGESUBDATANVPROC __wglewCopyImageSubDataNV = NULL;
    10040. 

  10040. 

  10041. PFNWGLCREATEAFFINITYDCNVPROC __wglewCreateAffinityDCNV = NULL;
    10042. 

  10042. PFNWGLDELETEDCNVPROC __wglewDeleteDCNV = NULL;
    10043. 

  10043. PFNWGLENUMGPUDEVICESNVPROC __wglewEnumGpuDevicesNV = NULL;
    10044. 

  10044. PFNWGLENUMGPUSFROMAFFINITYDCNVPROC __wglewEnumGpusFromAffinityDCNV = NULL;
    10045. 

  10045. PFNWGLENUMGPUSNVPROC __wglewEnumGpusNV = NULL;
    10046. 

  10046. 

  10047. PFNWGLBINDVIDEODEVICENVPROC __wglewBindVideoDeviceNV = NULL;
    10048. 

  10048. PFNWGLENUMERATEVIDEODEVICESNVPROC __wglewEnumerateVideoDevicesNV = NULL;
    10049. 

  10049. PFNWGLQUERYCURRENTCONTEXTNVPROC __wglewQueryCurrentContextNV = NULL;
    10050. 

  10050. 

  10051. PFNWGLBINDSWAPBARRIERNVPROC __wglewBindSwapBarrierNV = NULL;
    10052. 

  10052. PFNWGLJOINSWAPGROUPNVPROC __wglewJoinSwapGroupNV = NULL;
    10053. 

  10053. PFNWGLQUERYFRAMECOUNTNVPROC __wglewQueryFrameCountNV = NULL;
    10054. 

  10054. PFNWGLQUERYMAXSWAPGROUPSNVPROC __wglewQueryMaxSwapGroupsNV = NULL;
    10055. 

  10055. PFNWGLQUERYSWAPGROUPNVPROC __wglewQuerySwapGroupNV = NULL;
    10056. 

  10056. PFNWGLRESETFRAMECOUNTNVPROC __wglewResetFrameCountNV = NULL;
    10057. 

  10057. 

  10058. PFNWGLALLOCATEMEMORYNVPROC __wglewAllocateMemoryNV = NULL;
    10059. 

  10059. PFNWGLFREEMEMORYNVPROC __wglewFreeMemoryNV = NULL;
    10060. 

  10060. 

  10061. PFNWGLBINDVIDEOCAPTUREDEVICENVPROC __wglewBindVideoCaptureDeviceNV = NULL;
    10062. 

  10062. PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC __wglewEnumerateVideoCaptureDevicesNV = NULL;
    10063. 

  10063. PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC __wglewLockVideoCaptureDeviceNV = NULL;
    10064. 

  10064. PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC __wglewQueryVideoCaptureDeviceNV = NULL;
    10065. 

  10065. PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC __wglewReleaseVideoCaptureDeviceNV = NULL;
    10066. 

  10066. 

  10067. PFNWGLBINDVIDEOIMAGENVPROC __wglewBindVideoImageNV = NULL;
    10068. 

  10068. PFNWGLGETVIDEODEVICENVPROC __wglewGetVideoDeviceNV = NULL;
    10069. 

  10069. PFNWGLGETVIDEOINFONVPROC __wglewGetVideoInfoNV = NULL;
    10070. 

  10070. PFNWGLRELEASEVIDEODEVICENVPROC __wglewReleaseVideoDeviceNV = NULL;
    10071. 

  10071. PFNWGLRELEASEVIDEOIMAGENVPROC __wglewReleaseVideoImageNV = NULL;
    10072. 

  10072. PFNWGLSENDPBUFFERTOVIDEONVPROC __wglewSendPbufferToVideoNV = NULL;
    10073. 

  10073. 

  10074. PFNWGLGETMSCRATEOMLPROC __wglewGetMscRateOML = NULL;
    10075. 

  10075. PFNWGLGETSYNCVALUESOMLPROC __wglewGetSyncValuesOML = NULL;
    10076. 

  10076. PFNWGLSWAPBUFFERSMSCOMLPROC __wglewSwapBuffersMscOML = NULL;
    10077. 

  10077. PFNWGLSWAPLAYERBUFFERSMSCOMLPROC __wglewSwapLayerBuffersMscOML = NULL;
    10078. 

  10078. PFNWGLWAITFORMSCOMLPROC __wglewWaitForMscOML = NULL;
    10079. 

  10079. PFNWGLWAITFORSBCOMLPROC __wglewWaitForSbcOML = NULL;
    10080. 

  10080. GLboolean __WGLEW_3DFX_multisample = GL_FALSE;
    10081. 

  10081. GLboolean __WGLEW_3DL_stereo_control = GL_FALSE;
    10082. 

  10082. GLboolean __WGLEW_AMD_gpu_association = GL_FALSE;
    10083. 

  10083. GLboolean __WGLEW_ARB_buffer_region = GL_FALSE;
    10084. 

  10084. GLboolean __WGLEW_ARB_create_context = GL_FALSE;
    10085. 

  10085. GLboolean __WGLEW_ARB_create_context_profile = GL_FALSE;
    10086. 

  10086. GLboolean __WGLEW_ARB_create_context_robustness = GL_FALSE;
    10087. 

  10087. GLboolean __WGLEW_ARB_extensions_string = GL_FALSE;
    10088. 

  10088. GLboolean __WGLEW_ARB_framebuffer_sRGB = GL_FALSE;
    10089. 

  10089. GLboolean __WGLEW_ARB_make_current_read = GL_FALSE;
    10090. 

  10090. GLboolean __WGLEW_ARB_multisample = GL_FALSE;
    10091. 

  10091. GLboolean __WGLEW_ARB_pbuffer = GL_FALSE;
    10092. 

  10092. GLboolean __WGLEW_ARB_pixel_format = GL_FALSE;
    10093. 

  10093. GLboolean __WGLEW_ARB_pixel_format_float = GL_FALSE;
    10094. 

  10094. GLboolean __WGLEW_ARB_render_texture = GL_FALSE;
    10095. 

  10095. GLboolean __WGLEW_ATI_pixel_format_float = GL_FALSE;
    10096. 

  10096. GLboolean __WGLEW_ATI_render_texture_rectangle = GL_FALSE;
    10097. 

  10097. GLboolean __WGLEW_EXT_create_context_es2_profile = GL_FALSE;
    10098. 

  10098. GLboolean __WGLEW_EXT_depth_float = GL_FALSE;
    10099. 

  10099. GLboolean __WGLEW_EXT_display_color_table = GL_FALSE;
    10100. 

  10100. GLboolean __WGLEW_EXT_extensions_string = GL_FALSE;
    10101. 

  10101. GLboolean __WGLEW_EXT_framebuffer_sRGB = GL_FALSE;
    10102. 

  10102. GLboolean __WGLEW_EXT_make_current_read = GL_FALSE;
    10103. 

  10103. GLboolean __WGLEW_EXT_multisample = GL_FALSE;
    10104. 

  10104. GLboolean __WGLEW_EXT_pbuffer = GL_FALSE;
    10105. 

  10105. GLboolean __WGLEW_EXT_pixel_format = GL_FALSE;
    10106. 

  10106. GLboolean __WGLEW_EXT_pixel_format_packed_float = GL_FALSE;
    10107. 

  10107. GLboolean __WGLEW_EXT_swap_control = GL_FALSE;
    10108. 

  10108. GLboolean __WGLEW_I3D_digital_video_control = GL_FALSE;
    10109. 

  10109. GLboolean __WGLEW_I3D_gamma = GL_FALSE;
    10110. 

  10110. GLboolean __WGLEW_I3D_genlock = GL_FALSE;
    10111. 

  10111. GLboolean __WGLEW_I3D_image_buffer = GL_FALSE;
    10112. 

  10112. GLboolean __WGLEW_I3D_swap_frame_lock = GL_FALSE;
    10113. 

  10113. GLboolean __WGLEW_I3D_swap_frame_usage = GL_FALSE;
    10114. 

  10114. GLboolean __WGLEW_NV_DX_interop = GL_FALSE;
    10115. 

  10115. GLboolean __WGLEW_NV_copy_image = GL_FALSE;
    10116. 

  10116. GLboolean __WGLEW_NV_float_buffer = GL_FALSE;
    10117. 

  10117. GLboolean __WGLEW_NV_gpu_affinity = GL_FALSE;
    10118. 

  10118. GLboolean __WGLEW_NV_multisample_coverage = GL_FALSE;
    10119. 

  10119. GLboolean __WGLEW_NV_present_video = GL_FALSE;
    10120. 

  10120. GLboolean __WGLEW_NV_render_depth_texture = GL_FALSE;
    10121. 

  10121. GLboolean __WGLEW_NV_render_texture_rectangle = GL_FALSE;
    10122. 

  10122. GLboolean __WGLEW_NV_swap_group = GL_FALSE;
    10123. 

  10123. GLboolean __WGLEW_NV_vertex_array_range = GL_FALSE;
    10124. 

  10124. GLboolean __WGLEW_NV_video_capture = GL_FALSE;
    10125. 

  10125. GLboolean __WGLEW_NV_video_output = GL_FALSE;
    10126. 

  10126. GLboolean __WGLEW_OML_sync_control = GL_FALSE;
    10127. 

  10127. 

  10128. #endif /* !GLEW_MX */
    10129. 

  10129. 

  10130. #ifdef WGL_3DFX_multisample
    10131. 

  10131. 

  10132. #endif /* WGL_3DFX_multisample */
    10133. 

  10133. 

  10134. #ifdef WGL_3DL_stereo_control
    10135. 

  10135. 

  10136. static GLboolean _glewInit_WGL_3DL_stereo_control (WGLEW_CONTEXT_ARG_DEF_INIT)
    10137. 

  10137. {
    10138. 

  10138.   GLboolean r = GL_FALSE;
    10139. 

  10139. 

  10140.   r = ((wglSetStereoEmitterState3DL = (PFNWGLSETSTEREOEMITTERSTATE3DLPROC)glewGetProcAddress((const GLubyte*)"wglSetStereoEmitterState3DL")) == NULL) || r;
    10141. 

  10141. 

  10142.   return r;
    10143. 

  10143. }
    10144. 

  10144. 

  10145. #endif /* WGL_3DL_stereo_control */
    10146. 

  10146. 

  10147. #ifdef WGL_AMD_gpu_association
    10148. 

  10148. 

  10149. static GLboolean _glewInit_WGL_AMD_gpu_association (WGLEW_CONTEXT_ARG_DEF_INIT)
    10150. 

  10150. {
    10151. 

  10151.   GLboolean r = GL_FALSE;
    10152. 

  10152. 

  10153.   r = ((wglBlitContextFramebufferAMD = (PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC)glewGetProcAddress((const GLubyte*)"wglBlitContextFramebufferAMD")) == NULL) || r;
    10154. 

  10154.   r = ((wglCreateAssociatedContextAMD = (PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglCreateAssociatedContextAMD")) == NULL) || r;
    10155. 

  10155.   r = ((wglCreateAssociatedContextAttribsAMD = (PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC)glewGetProcAddress((const GLubyte*)"wglCreateAssociatedContextAttribsAMD")) == NULL) || r;
    10156. 

  10156.   r = ((wglDeleteAssociatedContextAMD = (PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglDeleteAssociatedContextAMD")) == NULL) || r;
    10157. 

  10157.   r = ((wglGetContextGPUIDAMD = (PFNWGLGETCONTEXTGPUIDAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetContextGPUIDAMD")) == NULL) || r;
    10158. 

  10158.   r = ((wglGetCurrentAssociatedContextAMD = (PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentAssociatedContextAMD")) == NULL) || r;
    10159. 

  10159.   r = ((wglGetGPUIDsAMD = (PFNWGLGETGPUIDSAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetGPUIDsAMD")) == NULL) || r;
    10160. 

  10160.   r = ((wglGetGPUInfoAMD = (PFNWGLGETGPUINFOAMDPROC)glewGetProcAddress((const GLubyte*)"wglGetGPUInfoAMD")) == NULL) || r;
    10161. 

  10161.   r = ((wglMakeAssociatedContextCurrentAMD = (PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC)glewGetProcAddress((const GLubyte*)"wglMakeAssociatedContextCurrentAMD")) == NULL) || r;
    10162. 

  10162. 

  10163.   return r;
    10164. 

  10164. }
    10165. 

  10165. 

  10166. #endif /* WGL_AMD_gpu_association */
    10167. 

  10167. 

  10168. #ifdef WGL_ARB_buffer_region
    10169. 

  10169. 

  10170. static GLboolean _glewInit_WGL_ARB_buffer_region (WGLEW_CONTEXT_ARG_DEF_INIT)
    10171. 

  10171. {
    10172. 

  10172.   GLboolean r = GL_FALSE;
    10173. 

  10173. 

  10174.   r = ((wglCreateBufferRegionARB = (PFNWGLCREATEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglCreateBufferRegionARB")) == NULL) || r;
    10175. 

  10175.   r = ((wglDeleteBufferRegionARB = (PFNWGLDELETEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglDeleteBufferRegionARB")) == NULL) || r;
    10176. 

  10176.   r = ((wglRestoreBufferRegionARB = (PFNWGLRESTOREBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglRestoreBufferRegionARB")) == NULL) || r;
    10177. 

  10177.   r = ((wglSaveBufferRegionARB = (PFNWGLSAVEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglSaveBufferRegionARB")) == NULL) || r;
    10178. 

  10178. 

  10179.   return r;
    10180. 

  10180. }
    10181. 

  10181. 

  10182. #endif /* WGL_ARB_buffer_region */
    10183. 

  10183. 

  10184. #ifdef WGL_ARB_create_context
    10185. 

  10185. 

  10186. static GLboolean _glewInit_WGL_ARB_create_context (WGLEW_CONTEXT_ARG_DEF_INIT)
    10187. 

  10187. {
    10188. 

  10188.   GLboolean r = GL_FALSE;
    10189. 

  10189. 

  10190.   r = ((wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)glewGetProcAddress((const GLubyte*)"wglCreateContextAttribsARB")) == NULL) || r;
    10191. 

  10191. 

  10192.   return r;
    10193. 

  10193. }
    10194. 

  10194. 

  10195. #endif /* WGL_ARB_create_context */
    10196. 

  10196. 

  10197. #ifdef WGL_ARB_create_context_profile
    10198. 

  10198. 

  10199. #endif /* WGL_ARB_create_context_profile */
    10200. 

  10200. 

  10201. #ifdef WGL_ARB_create_context_robustness
    10202. 

  10202. 

  10203. #endif /* WGL_ARB_create_context_robustness */
    10204. 

  10204. 

  10205. #ifdef WGL_ARB_extensions_string
    10206. 

  10206. 

  10207. static GLboolean _glewInit_WGL_ARB_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT)
    10208. 

  10208. {
    10209. 

  10209.   GLboolean r = GL_FALSE;
    10210. 

  10210. 

  10211.   r = ((wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB")) == NULL) || r;
    10212. 

  10212. 

  10213.   return r;
    10214. 

  10214. }
    10215. 

  10215. 

  10216. #endif /* WGL_ARB_extensions_string */
    10217. 

  10217. 

  10218. #ifdef WGL_ARB_framebuffer_sRGB
    10219. 

  10219. 

  10220. #endif /* WGL_ARB_framebuffer_sRGB */
    10221. 

  10221. 

  10222. #ifdef WGL_ARB_make_current_read
    10223. 

  10223. 

  10224. static GLboolean _glewInit_WGL_ARB_make_current_read (WGLEW_CONTEXT_ARG_DEF_INIT)
    10225. 

  10225. {
    10226. 

  10226.   GLboolean r = GL_FALSE;
    10227. 

  10227. 

  10228.   r = ((wglGetCurrentReadDCARB = (PFNWGLGETCURRENTREADDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCARB")) == NULL) || r;
    10229. 

  10229.   r = ((wglMakeContextCurrentARB = (PFNWGLMAKECONTEXTCURRENTARBPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentARB")) == NULL) || r;
    10230. 

  10230. 

  10231.   return r;
    10232. 

  10232. }
    10233. 

  10233. 

  10234. #endif /* WGL_ARB_make_current_read */
    10235. 

  10235. 

  10236. #ifdef WGL_ARB_multisample
    10237. 

  10237. 

  10238. #endif /* WGL_ARB_multisample */
    10239. 

  10239. 

  10240. #ifdef WGL_ARB_pbuffer
    10241. 

  10241. 

  10242. static GLboolean _glewInit_WGL_ARB_pbuffer (WGLEW_CONTEXT_ARG_DEF_INIT)
    10243. 

  10243. {
    10244. 

  10244.   GLboolean r = GL_FALSE;
    10245. 

  10245. 

  10246.   r = ((wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferARB")) == NULL) || r;
    10247. 

  10247.   r = ((wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferARB")) == NULL) || r;
    10248. 

  10248.   r = ((wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCARB")) == NULL) || r;
    10249. 

  10249.   r = ((wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferARB")) == NULL) || r;
    10250. 

  10250.   r = ((wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCARB")) == NULL) || r;
    10251. 

  10251. 

  10252.   return r;
    10253. 

  10253. }
    10254. 

  10254. 

  10255. #endif /* WGL_ARB_pbuffer */
    10256. 

  10256. 

  10257. #ifdef WGL_ARB_pixel_format
    10258. 

  10258. 

  10259. static GLboolean _glewInit_WGL_ARB_pixel_format (WGLEW_CONTEXT_ARG_DEF_INIT)
    10260. 

  10260. {
    10261. 

  10261.   GLboolean r = GL_FALSE;
    10262. 

  10262. 

  10263.   r = ((wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatARB")) == NULL) || r;
    10264. 

  10264.   r = ((wglGetPixelFormatAttribfvARB = (PFNWGLGETPIXELFORMATATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvARB")) == NULL) || r;
    10265. 

  10265.   r = ((wglGetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivARB")) == NULL) || r;
    10266. 

  10266. 

  10267.   return r;
    10268. 

  10268. }
    10269. 

  10269. 

  10270. #endif /* WGL_ARB_pixel_format */
    10271. 

  10271. 

  10272. #ifdef WGL_ARB_pixel_format_float
    10273. 

  10273. 

  10274. #endif /* WGL_ARB_pixel_format_float */
    10275. 

  10275. 

  10276. #ifdef WGL_ARB_render_texture
    10277. 

  10277. 

  10278. static GLboolean _glewInit_WGL_ARB_render_texture (WGLEW_CONTEXT_ARG_DEF_INIT)
    10279. 

  10279. {
    10280. 

  10280.   GLboolean r = GL_FALSE;
    10281. 

  10281. 

  10282.   r = ((wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglBindTexImageARB")) == NULL) || r;
    10283. 

  10283.   r = ((wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglReleaseTexImageARB")) == NULL) || r;
    10284. 

  10284.   r = ((wglSetPbufferAttribARB = (PFNWGLSETPBUFFERATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"wglSetPbufferAttribARB")) == NULL) || r;
    10285. 

  10285. 

  10286.   return r;
    10287. 

  10287. }
    10288. 

  10288. 

  10289. #endif /* WGL_ARB_render_texture */
    10290. 

  10290. 

  10291. #ifdef WGL_ATI_pixel_format_float
    10292. 

  10292. 

  10293. #endif /* WGL_ATI_pixel_format_float */
    10294. 

  10294. 

  10295. #ifdef WGL_ATI_render_texture_rectangle
    10296. 

  10296. 

  10297. #endif /* WGL_ATI_render_texture_rectangle */
    10298. 

  10298. 

  10299. #ifdef WGL_EXT_create_context_es2_profile
    10300. 

  10300. 

  10301. #endif /* WGL_EXT_create_context_es2_profile */
    10302. 

  10302. 

  10303. #ifdef WGL_EXT_depth_float
    10304. 

  10304. 

  10305. #endif /* WGL_EXT_depth_float */
    10306. 

  10306. 

  10307. #ifdef WGL_EXT_display_color_table
    10308. 

  10308. 

  10309. static GLboolean _glewInit_WGL_EXT_display_color_table (WGLEW_CONTEXT_ARG_DEF_INIT)
    10310. 

  10310. {
    10311. 

  10311.   GLboolean r = GL_FALSE;
    10312. 

  10312. 

  10313.   r = ((wglBindDisplayColorTableEXT = (PFNWGLBINDDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglBindDisplayColorTableEXT")) == NULL) || r;
    10314. 

  10314.   r = ((wglCreateDisplayColorTableEXT = (PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglCreateDisplayColorTableEXT")) == NULL) || r;
    10315. 

  10315.   r = ((wglDestroyDisplayColorTableEXT = (PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyDisplayColorTableEXT")) == NULL) || r;
    10316. 

  10316.   r = ((wglLoadDisplayColorTableEXT = (PFNWGLLOADDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglLoadDisplayColorTableEXT")) == NULL) || r;
    10317. 

  10317. 

  10318.   return r;
    10319. 

  10319. }
    10320. 

  10320. 

  10321. #endif /* WGL_EXT_display_color_table */
    10322. 

  10322. 

  10323. #ifdef WGL_EXT_extensions_string
    10324. 

  10324. 

  10325. static GLboolean _glewInit_WGL_EXT_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT)
    10326. 

  10326. {
    10327. 

  10327.   GLboolean r = GL_FALSE;
    10328. 

  10328. 

  10329.   r = ((wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT")) == NULL) || r;
    10330. 

  10330. 

  10331.   return r;
    10332. 

  10332. }
    10333. 

  10333. 

  10334. #endif /* WGL_EXT_extensions_string */
    10335. 

  10335. 

  10336. #ifdef WGL_EXT_framebuffer_sRGB
    10337. 

  10337. 

  10338. #endif /* WGL_EXT_framebuffer_sRGB */
    10339. 

  10339. 

  10340. #ifdef WGL_EXT_make_current_read
    10341. 

  10341. 

  10342. static GLboolean _glewInit_WGL_EXT_make_current_read (WGLEW_CONTEXT_ARG_DEF_INIT)
    10343. 

  10343. {
    10344. 

  10344.   GLboolean r = GL_FALSE;
    10345. 

  10345. 

  10346.   r = ((wglGetCurrentReadDCEXT = (PFNWGLGETCURRENTREADDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCEXT")) == NULL) || r;
    10347. 

  10347.   r = ((wglMakeContextCurrentEXT = (PFNWGLMAKECONTEXTCURRENTEXTPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentEXT")) == NULL) || r;
    10348. 

  10348. 

  10349.   return r;
    10350. 

  10350. }
    10351. 

  10351. 

  10352. #endif /* WGL_EXT_make_current_read */
    10353. 

  10353. 

  10354. #ifdef WGL_EXT_multisample
    10355. 

  10355. 

  10356. #endif /* WGL_EXT_multisample */
    10357. 

  10357. 

  10358. #ifdef WGL_EXT_pbuffer
    10359. 

  10359. 

  10360. static GLboolean _glewInit_WGL_EXT_pbuffer (WGLEW_CONTEXT_ARG_DEF_INIT)
    10361. 

  10361. {
    10362. 

  10362.   GLboolean r = GL_FALSE;
    10363. 

  10363. 

  10364.   r = ((wglCreatePbufferEXT = (PFNWGLCREATEPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferEXT")) == NULL) || r;
    10365. 

  10365.   r = ((wglDestroyPbufferEXT = (PFNWGLDESTROYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferEXT")) == NULL) || r;
    10366. 

  10366.   r = ((wglGetPbufferDCEXT = (PFNWGLGETPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCEXT")) == NULL) || r;
    10367. 

  10367.   r = ((wglQueryPbufferEXT = (PFNWGLQUERYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferEXT")) == NULL) || r;
    10368. 

  10368.   r = ((wglReleasePbufferDCEXT = (PFNWGLRELEASEPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCEXT")) == NULL) || r;
    10369. 

  10369. 

  10370.   return r;
    10371. 

  10371. }
    10372. 

  10372. 

  10373. #endif /* WGL_EXT_pbuffer */
    10374. 

  10374. 

  10375. #ifdef WGL_EXT_pixel_format
    10376. 

  10376. 

  10377. static GLboolean _glewInit_WGL_EXT_pixel_format (WGLEW_CONTEXT_ARG_DEF_INIT)
    10378. 

  10378. {
    10379. 

  10379.   GLboolean r = GL_FALSE;
    10380. 

  10380. 

  10381.   r = ((wglChoosePixelFormatEXT = (PFNWGLCHOOSEPIXELFORMATEXTPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatEXT")) == NULL) || r;
    10382. 

  10382.   r = ((wglGetPixelFormatAttribfvEXT = (PFNWGLGETPIXELFORMATATTRIBFVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvEXT")) == NULL) || r;
    10383. 

  10383.   r = ((wglGetPixelFormatAttribivEXT = (PFNWGLGETPIXELFORMATATTRIBIVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivEXT")) == NULL) || r;
    10384. 

  10384. 

  10385.   return r;
    10386. 

  10386. }
    10387. 

  10387. 

  10388. #endif /* WGL_EXT_pixel_format */
    10389. 

  10389. 

  10390. #ifdef WGL_EXT_pixel_format_packed_float
    10391. 

  10391. 

  10392. #endif /* WGL_EXT_pixel_format_packed_float */
    10393. 

  10393. 

  10394. #ifdef WGL_EXT_swap_control
    10395. 

  10395. 

  10396. static GLboolean _glewInit_WGL_EXT_swap_control (WGLEW_CONTEXT_ARG_DEF_INIT)
    10397. 

  10397. {
    10398. 

  10398.   GLboolean r = GL_FALSE;
    10399. 

  10399. 

  10400.   r = ((wglGetSwapIntervalEXT = (PFNWGLGETSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetSwapIntervalEXT")) == NULL) || r;
    10401. 

  10401.   r = ((wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglSwapIntervalEXT")) == NULL) || r;
    10402. 

  10402. 

  10403.   return r;
    10404. 

  10404. }
    10405. 

  10405. 

  10406. #endif /* WGL_EXT_swap_control */
    10407. 

  10407. 

  10408. #ifdef WGL_I3D_digital_video_control
    10409. 

  10409. 

  10410. static GLboolean _glewInit_WGL_I3D_digital_video_control (WGLEW_CONTEXT_ARG_DEF_INIT)
    10411. 

  10411. {
    10412. 

  10412.   GLboolean r = GL_FALSE;
    10413. 

  10413. 

  10414.   r = ((wglGetDigitalVideoParametersI3D = (PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetDigitalVideoParametersI3D")) == NULL) || r;
    10415. 

  10415.   r = ((wglSetDigitalVideoParametersI3D = (PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetDigitalVideoParametersI3D")) == NULL) || r;
    10416. 

  10416. 

  10417.   return r;
    10418. 

  10418. }
    10419. 

  10419. 

  10420. #endif /* WGL_I3D_digital_video_control */
    10421. 

  10421. 

  10422. #ifdef WGL_I3D_gamma
    10423. 

  10423. 

  10424. static GLboolean _glewInit_WGL_I3D_gamma (WGLEW_CONTEXT_ARG_DEF_INIT)
    10425. 

  10425. {
    10426. 

  10426.   GLboolean r = GL_FALSE;
    10427. 

  10427. 

  10428.   r = ((wglGetGammaTableI3D = (PFNWGLGETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableI3D")) == NULL) || r;
    10429. 

  10429.   r = ((wglGetGammaTableParametersI3D = (PFNWGLGETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableParametersI3D")) == NULL) || r;
    10430. 

  10430.   r = ((wglSetGammaTableI3D = (PFNWGLSETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableI3D")) == NULL) || r;
    10431. 

  10431.   r = ((wglSetGammaTableParametersI3D = (PFNWGLSETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableParametersI3D")) == NULL) || r;
    10432. 

  10432. 

  10433.   return r;
    10434. 

  10434. }
    10435. 

  10435. 

  10436. #endif /* WGL_I3D_gamma */
    10437. 

  10437. 

  10438. #ifdef WGL_I3D_genlock
    10439. 

  10439. 

  10440. static GLboolean _glewInit_WGL_I3D_genlock (WGLEW_CONTEXT_ARG_DEF_INIT)
    10441. 

  10441. {
    10442. 

  10442.   GLboolean r = GL_FALSE;
    10443. 

  10443. 

  10444.   r = ((wglDisableGenlockI3D = (PFNWGLDISABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableGenlockI3D")) == NULL) || r;
    10445. 

  10445.   r = ((wglEnableGenlockI3D = (PFNWGLENABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableGenlockI3D")) == NULL) || r;
    10446. 

  10446.   r = ((wglGenlockSampleRateI3D = (PFNWGLGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSampleRateI3D")) == NULL) || r;
    10447. 

  10447.   r = ((wglGenlockSourceDelayI3D = (PFNWGLGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceDelayI3D")) == NULL) || r;
    10448. 

  10448.   r = ((wglGenlockSourceEdgeI3D = (PFNWGLGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceEdgeI3D")) == NULL) || r;
    10449. 

  10449.   r = ((wglGenlockSourceI3D = (PFNWGLGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceI3D")) == NULL) || r;
    10450. 

  10450.   r = ((wglGetGenlockSampleRateI3D = (PFNWGLGETGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSampleRateI3D")) == NULL) || r;
    10451. 

  10451.   r = ((wglGetGenlockSourceDelayI3D = (PFNWGLGETGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceDelayI3D")) == NULL) || r;
    10452. 

  10452.   r = ((wglGetGenlockSourceEdgeI3D = (PFNWGLGETGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceEdgeI3D")) == NULL) || r;
    10453. 

  10453.   r = ((wglGetGenlockSourceI3D = (PFNWGLGETGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceI3D")) == NULL) || r;
    10454. 

  10454.   r = ((wglIsEnabledGenlockI3D = (PFNWGLISENABLEDGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledGenlockI3D")) == NULL) || r;
    10455. 

  10455.   r = ((wglQueryGenlockMaxSourceDelayI3D = (PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryGenlockMaxSourceDelayI3D")) == NULL) || r;
    10456. 

  10456. 

  10457.   return r;
    10458. 

  10458. }
    10459. 

  10459. 

  10460. #endif /* WGL_I3D_genlock */
    10461. 

  10461. 

  10462. #ifdef WGL_I3D_image_buffer
    10463. 

  10463. 

  10464. static GLboolean _glewInit_WGL_I3D_image_buffer (WGLEW_CONTEXT_ARG_DEF_INIT)
    10465. 

  10465. {
    10466. 

  10466.   GLboolean r = GL_FALSE;
    10467. 

  10467. 

  10468.   r = ((wglAssociateImageBufferEventsI3D = (PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglAssociateImageBufferEventsI3D")) == NULL) || r;
    10469. 

  10469.   r = ((wglCreateImageBufferI3D = (PFNWGLCREATEIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglCreateImageBufferI3D")) == NULL) || r;
    10470. 

  10470.   r = ((wglDestroyImageBufferI3D = (PFNWGLDESTROYIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglDestroyImageBufferI3D")) == NULL) || r;
    10471. 

  10471.   r = ((wglReleaseImageBufferEventsI3D = (PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglReleaseImageBufferEventsI3D")) == NULL) || r;
    10472. 

  10472. 

  10473.   return r;
    10474. 

  10474. }
    10475. 

  10475. 

  10476. #endif /* WGL_I3D_image_buffer */
    10477. 

  10477. 

  10478. #ifdef WGL_I3D_swap_frame_lock
    10479. 

  10479. 

  10480. static GLboolean _glewInit_WGL_I3D_swap_frame_lock (WGLEW_CONTEXT_ARG_DEF_INIT)
    10481. 

  10481. {
    10482. 

  10482.   GLboolean r = GL_FALSE;
    10483. 

  10483. 

  10484.   r = ((wglDisableFrameLockI3D = (PFNWGLDISABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableFrameLockI3D")) == NULL) || r;
    10485. 

  10485.   r = ((wglEnableFrameLockI3D = (PFNWGLENABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableFrameLockI3D")) == NULL) || r;
    10486. 

  10486.   r = ((wglIsEnabledFrameLockI3D = (PFNWGLISENABLEDFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledFrameLockI3D")) == NULL) || r;
    10487. 

  10487.   r = ((wglQueryFrameLockMasterI3D = (PFNWGLQUERYFRAMELOCKMASTERI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameLockMasterI3D")) == NULL) || r;
    10488. 

  10488. 

  10489.   return r;
    10490. 

  10490. }
    10491. 

  10491. 

  10492. #endif /* WGL_I3D_swap_frame_lock */
    10493. 

  10493. 

  10494. #ifdef WGL_I3D_swap_frame_usage
    10495. 

  10495. 

  10496. static GLboolean _glewInit_WGL_I3D_swap_frame_usage (WGLEW_CONTEXT_ARG_DEF_INIT)
    10497. 

  10497. {
    10498. 

  10498.   GLboolean r = GL_FALSE;
    10499. 

  10499. 

  10500.   r = ((wglBeginFrameTrackingI3D = (PFNWGLBEGINFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglBeginFrameTrackingI3D")) == NULL) || r;
    10501. 

  10501.   r = ((wglEndFrameTrackingI3D = (PFNWGLENDFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglEndFrameTrackingI3D")) == NULL) || r;
    10502. 

  10502.   r = ((wglGetFrameUsageI3D = (PFNWGLGETFRAMEUSAGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetFrameUsageI3D")) == NULL) || r;
    10503. 

  10503.   r = ((wglQueryFrameTrackingI3D = (PFNWGLQUERYFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameTrackingI3D")) == NULL) || r;
    10504. 

  10504. 

  10505.   return r;
    10506. 

  10506. }
    10507. 

  10507. 

  10508. #endif /* WGL_I3D_swap_frame_usage */
    10509. 

  10509. 

  10510. #ifdef WGL_NV_DX_interop
    10511. 

  10511. 

  10512. static GLboolean _glewInit_WGL_NV_DX_interop (WGLEW_CONTEXT_ARG_DEF_INIT)
    10513. 

  10513. {
    10514. 

  10514.   GLboolean r = GL_FALSE;
    10515. 

  10515. 

  10516.   r = ((wglDXCloseDeviceNV = (PFNWGLDXCLOSEDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglDXCloseDeviceNV")) == NULL) || r;
    10517. 

  10517.   r = ((wglDXLockObjectsNV = (PFNWGLDXLOCKOBJECTSNVPROC)glewGetProcAddress((const GLubyte*)"wglDXLockObjectsNV")) == NULL) || r;
    10518. 

  10518.   r = ((wglDXObjectAccessNV = (PFNWGLDXOBJECTACCESSNVPROC)glewGetProcAddress((const GLubyte*)"wglDXObjectAccessNV")) == NULL) || r;
    10519. 

  10519.   r = ((wglDXOpenDeviceNV = (PFNWGLDXOPENDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglDXOpenDeviceNV")) == NULL) || r;
    10520. 

  10520.   r = ((wglDXRegisterObjectNV = (PFNWGLDXREGISTEROBJECTNVPROC)glewGetProcAddress((const GLubyte*)"wglDXRegisterObjectNV")) == NULL) || r;
    10521. 

  10521.   r = ((wglDXSetResourceShareHandleNV = (PFNWGLDXSETRESOURCESHAREHANDLENVPROC)glewGetProcAddress((const GLubyte*)"wglDXSetResourceShareHandleNV")) == NULL) || r;
    10522. 

  10522.   r = ((wglDXUnlockObjectsNV = (PFNWGLDXUNLOCKOBJECTSNVPROC)glewGetProcAddress((const GLubyte*)"wglDXUnlockObjectsNV")) == NULL) || r;
    10523. 

  10523.   r = ((wglDXUnregisterObjectNV = (PFNWGLDXUNREGISTEROBJECTNVPROC)glewGetProcAddress((const GLubyte*)"wglDXUnregisterObjectNV")) == NULL) || r;
    10524. 

  10524. 

  10525.   return r;
    10526. 

  10526. }
    10527. 

  10527. 

  10528. #endif /* WGL_NV_DX_interop */
    10529. 

  10529. 

  10530. #ifdef WGL_NV_copy_image
    10531. 

  10531. 

  10532. static GLboolean _glewInit_WGL_NV_copy_image (WGLEW_CONTEXT_ARG_DEF_INIT)
    10533. 

  10533. {
    10534. 

  10534.   GLboolean r = GL_FALSE;
    10535. 

  10535. 

  10536.   r = ((wglCopyImageSubDataNV = (PFNWGLCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"wglCopyImageSubDataNV")) == NULL) || r;
    10537. 

  10537. 

  10538.   return r;
    10539. 

  10539. }
    10540. 

  10540. 

  10541. #endif /* WGL_NV_copy_image */
    10542. 

  10542. 

  10543. #ifdef WGL_NV_float_buffer
    10544. 

  10544. 

  10545. #endif /* WGL_NV_float_buffer */
    10546. 

  10546. 

  10547. #ifdef WGL_NV_gpu_affinity
    10548. 

  10548. 

  10549. static GLboolean _glewInit_WGL_NV_gpu_affinity (WGLEW_CONTEXT_ARG_DEF_INIT)
    10550. 

  10550. {
    10551. 

  10551.   GLboolean r = GL_FALSE;
    10552. 

  10552. 

  10553.   r = ((wglCreateAffinityDCNV = (PFNWGLCREATEAFFINITYDCNVPROC)glewGetProcAddress((const GLubyte*)"wglCreateAffinityDCNV")) == NULL) || r;
    10554. 

  10554.   r = ((wglDeleteDCNV = (PFNWGLDELETEDCNVPROC)glewGetProcAddress((const GLubyte*)"wglDeleteDCNV")) == NULL) || r;
    10555. 

  10555.   r = ((wglEnumGpuDevicesNV = (PFNWGLENUMGPUDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpuDevicesNV")) == NULL) || r;
    10556. 

  10556.   r = ((wglEnumGpusFromAffinityDCNV = (PFNWGLENUMGPUSFROMAFFINITYDCNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpusFromAffinityDCNV")) == NULL) || r;
    10557. 

  10557.   r = ((wglEnumGpusNV = (PFNWGLENUMGPUSNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpusNV")) == NULL) || r;
    10558. 

  10558. 

  10559.   return r;
    10560. 

  10560. }
    10561. 

  10561. 

  10562. #endif /* WGL_NV_gpu_affinity */
    10563. 

  10563. 

  10564. #ifdef WGL_NV_multisample_coverage
    10565. 

  10565. 

  10566. #endif /* WGL_NV_multisample_coverage */
    10567. 

  10567. 

  10568. #ifdef WGL_NV_present_video
    10569. 

  10569. 

  10570. static GLboolean _glewInit_WGL_NV_present_video (WGLEW_CONTEXT_ARG_DEF_INIT)
    10571. 

  10571. {
    10572. 

  10572.   GLboolean r = GL_FALSE;
    10573. 

  10573. 

  10574.   r = ((wglBindVideoDeviceNV = (PFNWGLBINDVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoDeviceNV")) == NULL) || r;
    10575. 

  10575.   r = ((wglEnumerateVideoDevicesNV = (PFNWGLENUMERATEVIDEODEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumerateVideoDevicesNV")) == NULL) || r;
    10576. 

  10576.   r = ((wglQueryCurrentContextNV = (PFNWGLQUERYCURRENTCONTEXTNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryCurrentContextNV")) == NULL) || r;
    10577. 

  10577. 

  10578.   return r;
    10579. 

  10579. }
    10580. 

  10580. 

  10581. #endif /* WGL_NV_present_video */
    10582. 

  10582. 

  10583. #ifdef WGL_NV_render_depth_texture
    10584. 

  10584. 

  10585. #endif /* WGL_NV_render_depth_texture */
    10586. 

  10586. 

  10587. #ifdef WGL_NV_render_texture_rectangle
    10588. 

  10588. 

  10589. #endif /* WGL_NV_render_texture_rectangle */
    10590. 

  10590. 

  10591. #ifdef WGL_NV_swap_group
    10592. 

  10592. 

  10593. static GLboolean _glewInit_WGL_NV_swap_group (WGLEW_CONTEXT_ARG_DEF_INIT)
    10594. 

  10594. {
    10595. 

  10595.   GLboolean r = GL_FALSE;
    10596. 

  10596. 

  10597.   r = ((wglBindSwapBarrierNV = (PFNWGLBINDSWAPBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"wglBindSwapBarrierNV")) == NULL) || r;
    10598. 

  10598.   r = ((wglJoinSwapGroupNV = (PFNWGLJOINSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"wglJoinSwapGroupNV")) == NULL) || r;
    10599. 

  10599.   r = ((wglQueryFrameCountNV = (PFNWGLQUERYFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameCountNV")) == NULL) || r;
    10600. 

  10600.   r = ((wglQueryMaxSwapGroupsNV = (PFNWGLQUERYMAXSWAPGROUPSNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryMaxSwapGroupsNV")) == NULL) || r;
    10601. 

  10601.   r = ((wglQuerySwapGroupNV = (PFNWGLQUERYSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"wglQuerySwapGroupNV")) == NULL) || r;
    10602. 

  10602.   r = ((wglResetFrameCountNV = (PFNWGLRESETFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"wglResetFrameCountNV")) == NULL) || r;
    10603. 

  10603. 

  10604.   return r;
    10605. 

  10605. }
    10606. 

  10606. 

  10607. #endif /* WGL_NV_swap_group */
    10608. 

  10608. 

  10609. #ifdef WGL_NV_vertex_array_range
    10610. 

  10610. 

  10611. static GLboolean _glewInit_WGL_NV_vertex_array_range (WGLEW_CONTEXT_ARG_DEF_INIT)
    10612. 

  10612. {
    10613. 

  10613.   GLboolean r = GL_FALSE;
    10614. 

  10614. 

  10615.   r = ((wglAllocateMemoryNV = (PFNWGLALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglAllocateMemoryNV")) == NULL) || r;
    10616. 

  10616.   r = ((wglFreeMemoryNV = (PFNWGLFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglFreeMemoryNV")) == NULL) || r;
    10617. 

  10617. 

  10618.   return r;
    10619. 

  10619. }
    10620. 

  10620. 

  10621. #endif /* WGL_NV_vertex_array_range */
    10622. 

  10622. 

  10623. #ifdef WGL_NV_video_capture
    10624. 

  10624. 

  10625. static GLboolean _glewInit_WGL_NV_video_capture (WGLEW_CONTEXT_ARG_DEF_INIT)
    10626. 

  10626. {
    10627. 

  10627.   GLboolean r = GL_FALSE;
    10628. 

  10628. 

  10629.   r = ((wglBindVideoCaptureDeviceNV = (PFNWGLBINDVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoCaptureDeviceNV")) == NULL) || r;
    10630. 

  10630.   r = ((wglEnumerateVideoCaptureDevicesNV = (PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumerateVideoCaptureDevicesNV")) == NULL) || r;
    10631. 

  10631.   r = ((wglLockVideoCaptureDeviceNV = (PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglLockVideoCaptureDeviceNV")) == NULL) || r;
    10632. 

  10632.   r = ((wglQueryVideoCaptureDeviceNV = (PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglQueryVideoCaptureDeviceNV")) == NULL) || r;
    10633. 

  10633.   r = ((wglReleaseVideoCaptureDeviceNV = (PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoCaptureDeviceNV")) == NULL) || r;
    10634. 

  10634. 

  10635.   return r;
    10636. 

  10636. }
    10637. 

  10637. 

  10638. #endif /* WGL_NV_video_capture */
    10639. 

  10639. 

  10640. #ifdef WGL_NV_video_output
    10641. 

  10641. 

  10642. static GLboolean _glewInit_WGL_NV_video_output (WGLEW_CONTEXT_ARG_DEF_INIT)
    10643. 

  10643. {
    10644. 

  10644.   GLboolean r = GL_FALSE;
    10645. 

  10645. 

  10646.   r = ((wglBindVideoImageNV = (PFNWGLBINDVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoImageNV")) == NULL) || r;
    10647. 

  10647.   r = ((wglGetVideoDeviceNV = (PFNWGLGETVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglGetVideoDeviceNV")) == NULL) || r;
    10648. 

  10648.   r = ((wglGetVideoInfoNV = (PFNWGLGETVIDEOINFONVPROC)glewGetProcAddress((const GLubyte*)"wglGetVideoInfoNV")) == NULL) || r;
    10649. 

  10649.   r = ((wglReleaseVideoDeviceNV = (PFNWGLRELEASEVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoDeviceNV")) == NULL) || r;
    10650. 

  10650.   r = ((wglReleaseVideoImageNV = (PFNWGLRELEASEVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoImageNV")) == NULL) || r;
    10651. 

  10651.   r = ((wglSendPbufferToVideoNV = (PFNWGLSENDPBUFFERTOVIDEONVPROC)glewGetProcAddress((const GLubyte*)"wglSendPbufferToVideoNV")) == NULL) || r;
    10652. 

  10652. 

  10653.   return r;
    10654. 

  10654. }
    10655. 

  10655. 

  10656. #endif /* WGL_NV_video_output */
    10657. 

  10657. 

  10658. #ifdef WGL_OML_sync_control
    10659. 

  10659. 

  10660. static GLboolean _glewInit_WGL_OML_sync_control (WGLEW_CONTEXT_ARG_DEF_INIT)
    10661. 

  10661. {
    10662. 

  10662.   GLboolean r = GL_FALSE;
    10663. 

  10663. 

  10664.   r = ((wglGetMscRateOML = (PFNWGLGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetMscRateOML")) == NULL) || r;
    10665. 

  10665.   r = ((wglGetSyncValuesOML = (PFNWGLGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetSyncValuesOML")) == NULL) || r;
    10666. 

  10666.   r = ((wglSwapBuffersMscOML = (PFNWGLSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapBuffersMscOML")) == NULL) || r;
    10667. 

  10667.   r = ((wglSwapLayerBuffersMscOML = (PFNWGLSWAPLAYERBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapLayerBuffersMscOML")) == NULL) || r;
    10668. 

  10668.   r = ((wglWaitForMscOML = (PFNWGLWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForMscOML")) == NULL) || r;
    10669. 

  10669.   r = ((wglWaitForSbcOML = (PFNWGLWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForSbcOML")) == NULL) || r;
    10670. 

  10670. 

  10671.   return r;
    10672. 

  10672. }
    10673. 

  10673. 

  10674. #endif /* WGL_OML_sync_control */
    10675. 

  10675. 

  10676. /* ------------------------------------------------------------------------- */
    10677. 

  10677. 

  10678. static PFNWGLGETEXTENSIONSSTRINGARBPROC _wglewGetExtensionsStringARB = NULL;
    10679. 

  10679. static PFNWGLGETEXTENSIONSSTRINGEXTPROC _wglewGetExtensionsStringEXT = NULL;
    10680. 

  10680. 

  10681. GLboolean wglewGetExtension (const char* name)
    10682. 

  10682. {    
    10683. 

  10683.   const GLubyte* start;
    10684. 

  10684.   const GLubyte* end;
    10685. 

  10685.   if (_wglewGetExtensionsStringARB == NULL)
    10686. 

  10686.     if (_wglewGetExtensionsStringEXT == NULL)
    10687. 

  10687.       return GL_FALSE;
    10688. 

  10688.     else
    10689. 

  10689.       start = (const GLubyte*)_wglewGetExtensionsStringEXT();
    10690. 

  10690.   else
    10691. 

  10691.     start = (const GLubyte*)_wglewGetExtensionsStringARB(wglGetCurrentDC());
    10692. 

  10692.   if (start == 0)
    10693. 

  10693.     return GL_FALSE;
    10694. 

  10694.   end = start + _glewStrLen(start);
    10695. 

  10695.   return _glewSearchExtension(name, start, end);
    10696. 

  10696. }
    10697. 

  10697. 

  10698. GLenum wglewContextInit (WGLEW_CONTEXT_ARG_DEF_LIST)
    10699. 

  10699. {
    10700. 

  10700.   GLboolean crippled;
    10701. 

  10701.   const GLubyte* extStart;
    10702. 

  10702.   const GLubyte* extEnd;
    10703. 

  10703.   /* find wgl extension string query functions */
    10704. 

  10704.   _wglewGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB");
    10705. 

  10705.   _wglewGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT");
    10706. 

  10706.   /* query wgl extension string */
    10707. 

  10707.   if (_wglewGetExtensionsStringARB == NULL)
    10708. 

  10708.     if (_wglewGetExtensionsStringEXT == NULL)
    10709. 

  10709.       extStart = (const GLubyte*)"";
    10710. 

  10710.     else
    10711. 

  10711.       extStart = (const GLubyte*)_wglewGetExtensionsStringEXT();
    10712. 

  10712.   else
    10713. 

  10713.     extStart = (const GLubyte*)_wglewGetExtensionsStringARB(wglGetCurrentDC());
    10714. 

  10714.   extEnd = extStart + _glewStrLen(extStart);
    10715. 

  10715.   /* initialize extensions */
    10716. 

  10716.   crippled = _wglewGetExtensionsStringARB == NULL && _wglewGetExtensionsStringEXT == NULL;
    10717. 

  10717. #ifdef WGL_3DFX_multisample
    10718. 

  10718.   CONST_CAST(WGLEW_3DFX_multisample) = _glewSearchExtension("WGL_3DFX_multisample", extStart, extEnd);
    10719. 

  10719. #endif /* WGL_3DFX_multisample */
    10720. 

  10720. #ifdef WGL_3DL_stereo_control
    10721. 

  10721.   CONST_CAST(WGLEW_3DL_stereo_control) = _glewSearchExtension("WGL_3DL_stereo_control", extStart, extEnd);
    10722. 

  10722.   if (glewExperimental || WGLEW_3DL_stereo_control|| crippled) CONST_CAST(WGLEW_3DL_stereo_control)= !_glewInit_WGL_3DL_stereo_control(GLEW_CONTEXT_ARG_VAR_INIT);
    10723. 

  10723. #endif /* WGL_3DL_stereo_control */
    10724. 

  10724. #ifdef WGL_AMD_gpu_association
    10725. 

  10725.   CONST_CAST(WGLEW_AMD_gpu_association) = _glewSearchExtension("WGL_AMD_gpu_association", extStart, extEnd);
    10726. 

  10726.   if (glewExperimental || WGLEW_AMD_gpu_association|| crippled) CONST_CAST(WGLEW_AMD_gpu_association)= !_glewInit_WGL_AMD_gpu_association(GLEW_CONTEXT_ARG_VAR_INIT);
    10727. 

  10727. #endif /* WGL_AMD_gpu_association */
    10728. 

  10728. #ifdef WGL_ARB_buffer_region
    10729. 

  10729.   CONST_CAST(WGLEW_ARB_buffer_region) = _glewSearchExtension("WGL_ARB_buffer_region", extStart, extEnd);
    10730. 

  10730.   if (glewExperimental || WGLEW_ARB_buffer_region|| crippled) CONST_CAST(WGLEW_ARB_buffer_region)= !_glewInit_WGL_ARB_buffer_region(GLEW_CONTEXT_ARG_VAR_INIT);
    10731. 

  10731. #endif /* WGL_ARB_buffer_region */
    10732. 

  10732. #ifdef WGL_ARB_create_context
    10733. 

  10733.   CONST_CAST(WGLEW_ARB_create_context) = _glewSearchExtension("WGL_ARB_create_context", extStart, extEnd);
    10734. 

  10734.   if (glewExperimental || WGLEW_ARB_create_context|| crippled) CONST_CAST(WGLEW_ARB_create_context)= !_glewInit_WGL_ARB_create_context(GLEW_CONTEXT_ARG_VAR_INIT);
    10735. 

  10735. #endif /* WGL_ARB_create_context */
    10736. 

  10736. #ifdef WGL_ARB_create_context_profile
    10737. 

  10737.   CONST_CAST(WGLEW_ARB_create_context_profile) = _glewSearchExtension("WGL_ARB_create_context_profile", extStart, extEnd);
    10738. 

  10738. #endif /* WGL_ARB_create_context_profile */
    10739. 

  10739. #ifdef WGL_ARB_create_context_robustness
    10740. 

  10740.   CONST_CAST(WGLEW_ARB_create_context_robustness) = _glewSearchExtension("WGL_ARB_create_context_robustness", extStart, extEnd);
    10741. 

  10741. #endif /* WGL_ARB_create_context_robustness */
    10742. 

  10742. #ifdef WGL_ARB_extensions_string
    10743. 

  10743.   CONST_CAST(WGLEW_ARB_extensions_string) = _glewSearchExtension("WGL_ARB_extensions_string", extStart, extEnd);
    10744. 

  10744.   if (glewExperimental || WGLEW_ARB_extensions_string|| crippled) CONST_CAST(WGLEW_ARB_extensions_string)= !_glewInit_WGL_ARB_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT);
    10745. 

  10745. #endif /* WGL_ARB_extensions_string */
    10746. 

  10746. #ifdef WGL_ARB_framebuffer_sRGB
    10747. 

  10747.   CONST_CAST(WGLEW_ARB_framebuffer_sRGB) = _glewSearchExtension("WGL_ARB_framebuffer_sRGB", extStart, extEnd);
    10748. 

  10748. #endif /* WGL_ARB_framebuffer_sRGB */
    10749. 

  10749. #ifdef WGL_ARB_make_current_read
    10750. 

  10750.   CONST_CAST(WGLEW_ARB_make_current_read) = _glewSearchExtension("WGL_ARB_make_current_read", extStart, extEnd);
    10751. 

  10751.   if (glewExperimental || WGLEW_ARB_make_current_read|| crippled) CONST_CAST(WGLEW_ARB_make_current_read)= !_glewInit_WGL_ARB_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT);
    10752. 

  10752. #endif /* WGL_ARB_make_current_read */
    10753. 

  10753. #ifdef WGL_ARB_multisample
    10754. 

  10754.   CONST_CAST(WGLEW_ARB_multisample) = _glewSearchExtension("WGL_ARB_multisample", extStart, extEnd);
    10755. 

  10755. #endif /* WGL_ARB_multisample */
    10756. 

  10756. #ifdef WGL_ARB_pbuffer
    10757. 

  10757.   CONST_CAST(WGLEW_ARB_pbuffer) = _glewSearchExtension("WGL_ARB_pbuffer", extStart, extEnd);
    10758. 

  10758.   if (glewExperimental || WGLEW_ARB_pbuffer|| crippled) CONST_CAST(WGLEW_ARB_pbuffer)= !_glewInit_WGL_ARB_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT);
    10759. 

  10759. #endif /* WGL_ARB_pbuffer */
    10760. 

  10760. #ifdef WGL_ARB_pixel_format
    10761. 

  10761.   CONST_CAST(WGLEW_ARB_pixel_format) = _glewSearchExtension("WGL_ARB_pixel_format", extStart, extEnd);
    10762. 

  10762.   if (glewExperimental || WGLEW_ARB_pixel_format|| crippled) CONST_CAST(WGLEW_ARB_pixel_format)= !_glewInit_WGL_ARB_pixel_format(GLEW_CONTEXT_ARG_VAR_INIT);
    10763. 

  10763. #endif /* WGL_ARB_pixel_format */
    10764. 

  10764. #ifdef WGL_ARB_pixel_format_float
    10765. 

  10765.   CONST_CAST(WGLEW_ARB_pixel_format_float) = _glewSearchExtension("WGL_ARB_pixel_format_float", extStart, extEnd);
    10766. 

  10766. #endif /* WGL_ARB_pixel_format_float */
    10767. 

  10767. #ifdef WGL_ARB_render_texture
    10768. 

  10768.   CONST_CAST(WGLEW_ARB_render_texture) = _glewSearchExtension("WGL_ARB_render_texture", extStart, extEnd);
    10769. 

  10769.   if (glewExperimental || WGLEW_ARB_render_texture|| crippled) CONST_CAST(WGLEW_ARB_render_texture)= !_glewInit_WGL_ARB_render_texture(GLEW_CONTEXT_ARG_VAR_INIT);
    10770. 

  10770. #endif /* WGL_ARB_render_texture */
    10771. 

  10771. #ifdef WGL_ATI_pixel_format_float
    10772. 

  10772.   CONST_CAST(WGLEW_ATI_pixel_format_float) = _glewSearchExtension("WGL_ATI_pixel_format_float", extStart, extEnd);
    10773. 

  10773. #endif /* WGL_ATI_pixel_format_float */
    10774. 

  10774. #ifdef WGL_ATI_render_texture_rectangle
    10775. 

  10775.   CONST_CAST(WGLEW_ATI_render_texture_rectangle) = _glewSearchExtension("WGL_ATI_render_texture_rectangle", extStart, extEnd);
    10776. 

  10776. #endif /* WGL_ATI_render_texture_rectangle */
    10777. 

  10777. #ifdef WGL_EXT_create_context_es2_profile
    10778. 

  10778.   CONST_CAST(WGLEW_EXT_create_context_es2_profile) = _glewSearchExtension("WGL_EXT_create_context_es2_profile", extStart, extEnd);
    10779. 

  10779. #endif /* WGL_EXT_create_context_es2_profile */
    10780. 

  10780. #ifdef WGL_EXT_depth_float
    10781. 

  10781.   CONST_CAST(WGLEW_EXT_depth_float) = _glewSearchExtension("WGL_EXT_depth_float", extStart, extEnd);
    10782. 

  10782. #endif /* WGL_EXT_depth_float */
    10783. 

  10783. #ifdef WGL_EXT_display_color_table
    10784. 

  10784.   CONST_CAST(WGLEW_EXT_display_color_table) = _glewSearchExtension("WGL_EXT_display_color_table", extStart, extEnd);
    10785. 

  10785.   if (glewExperimental || WGLEW_EXT_display_color_table|| crippled) CONST_CAST(WGLEW_EXT_display_color_table)= !_glewInit_WGL_EXT_display_color_table(GLEW_CONTEXT_ARG_VAR_INIT);
    10786. 

  10786. #endif /* WGL_EXT_display_color_table */
    10787. 

  10787. #ifdef WGL_EXT_extensions_string
    10788. 

  10788.   CONST_CAST(WGLEW_EXT_extensions_string) = _glewSearchExtension("WGL_EXT_extensions_string", extStart, extEnd);
    10789. 

  10789.   if (glewExperimental || WGLEW_EXT_extensions_string|| crippled) CONST_CAST(WGLEW_EXT_extensions_string)= !_glewInit_WGL_EXT_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT);
    10790. 

  10790. #endif /* WGL_EXT_extensions_string */
    10791. 

  10791. #ifdef WGL_EXT_framebuffer_sRGB
    10792. 

  10792.   CONST_CAST(WGLEW_EXT_framebuffer_sRGB) = _glewSearchExtension("WGL_EXT_framebuffer_sRGB", extStart, extEnd);
    10793. 

  10793. #endif /* WGL_EXT_framebuffer_sRGB */
    10794. 

  10794. #ifdef WGL_EXT_make_current_read
    10795. 

  10795.   CONST_CAST(WGLEW_EXT_make_current_read) = _glewSearchExtension("WGL_EXT_make_current_read", extStart, extEnd);
    10796. 

  10796.   if (glewExperimental || WGLEW_EXT_make_current_read|| crippled) CONST_CAST(WGLEW_EXT_make_current_read)= !_glewInit_WGL_EXT_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT);
    10797. 

  10797. #endif /* WGL_EXT_make_current_read */
    10798. 

  10798. #ifdef WGL_EXT_multisample
    10799. 

  10799.   CONST_CAST(WGLEW_EXT_multisample) = _glewSearchExtension("WGL_EXT_multisample", extStart, extEnd);
    10800. 

  10800. #endif /* WGL_EXT_multisample */
    10801. 

  10801. #ifdef WGL_EXT_pbuffer
    10802. 

  10802.   CONST_CAST(WGLEW_EXT_pbuffer) = _glewSearchExtension("WGL_EXT_pbuffer", extStart, extEnd);
    10803. 

  10803.   if (glewExperimental || WGLEW_EXT_pbuffer|| crippled) CONST_CAST(WGLEW_EXT_pbuffer)= !_glewInit_WGL_EXT_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT);
    10804. 

  10804. #endif /* WGL_EXT_pbuffer */
    10805. 

  10805. #ifdef WGL_EXT_pixel_format
    10806. 

  10806.   CONST_CAST(WGLEW_EXT_pixel_format) = _glewSearchExtension("WGL_EXT_pixel_format", extStart, extEnd);
    10807. 

  10807.   if (glewExperimental || WGLEW_EXT_pixel_format|| crippled) CONST_CAST(WGLEW_EXT_pixel_format)= !_glewInit_WGL_EXT_pixel_format(GLEW_CONTEXT_ARG_VAR_INIT);
    10808. 

  10808. #endif /* WGL_EXT_pixel_format */
    10809. 

  10809. #ifdef WGL_EXT_pixel_format_packed_float
    10810. 

  10810.   CONST_CAST(WGLEW_EXT_pixel_format_packed_float) = _glewSearchExtension("WGL_EXT_pixel_format_packed_float", extStart, extEnd);
    10811. 

  10811. #endif /* WGL_EXT_pixel_format_packed_float */
    10812. 

  10812. #ifdef WGL_EXT_swap_control
    10813. 

  10813.   CONST_CAST(WGLEW_EXT_swap_control) = _glewSearchExtension("WGL_EXT_swap_control", extStart, extEnd);
    10814. 

  10814.   if (glewExperimental || WGLEW_EXT_swap_control|| crippled) CONST_CAST(WGLEW_EXT_swap_control)= !_glewInit_WGL_EXT_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);
    10815. 

  10815. #endif /* WGL_EXT_swap_control */
    10816. 

  10816. #ifdef WGL_I3D_digital_video_control
    10817. 

  10817.   CONST_CAST(WGLEW_I3D_digital_video_control) = _glewSearchExtension("WGL_I3D_digital_video_control", extStart, extEnd);
    10818. 

  10818.   if (glewExperimental || WGLEW_I3D_digital_video_control|| crippled) CONST_CAST(WGLEW_I3D_digital_video_control)= !_glewInit_WGL_I3D_digital_video_control(GLEW_CONTEXT_ARG_VAR_INIT);
    10819. 

  10819. #endif /* WGL_I3D_digital_video_control */
    10820. 

  10820. #ifdef WGL_I3D_gamma
    10821. 

  10821.   CONST_CAST(WGLEW_I3D_gamma) = _glewSearchExtension("WGL_I3D_gamma", extStart, extEnd);
    10822. 

  10822.   if (glewExperimental || WGLEW_I3D_gamma|| crippled) CONST_CAST(WGLEW_I3D_gamma)= !_glewInit_WGL_I3D_gamma(GLEW_CONTEXT_ARG_VAR_INIT);
    10823. 

  10823. #endif /* WGL_I3D_gamma */
    10824. 

  10824. #ifdef WGL_I3D_genlock
    10825. 

  10825.   CONST_CAST(WGLEW_I3D_genlock) = _glewSearchExtension("WGL_I3D_genlock", extStart, extEnd);
    10826. 

  10826.   if (glewExperimental || WGLEW_I3D_genlock|| crippled) CONST_CAST(WGLEW_I3D_genlock)= !_glewInit_WGL_I3D_genlock(GLEW_CONTEXT_ARG_VAR_INIT);
    10827. 

  10827. #endif /* WGL_I3D_genlock */
    10828. 

  10828. #ifdef WGL_I3D_image_buffer
    10829. 

  10829.   CONST_CAST(WGLEW_I3D_image_buffer) = _glewSearchExtension("WGL_I3D_image_buffer", extStart, extEnd);
    10830. 

  10830.   if (glewExperimental || WGLEW_I3D_image_buffer|| crippled) CONST_CAST(WGLEW_I3D_image_buffer)= !_glewInit_WGL_I3D_image_buffer(GLEW_CONTEXT_ARG_VAR_INIT);
    10831. 

  10831. #endif /* WGL_I3D_image_buffer */
    10832. 

  10832. #ifdef WGL_I3D_swap_frame_lock
    10833. 

  10833.   CONST_CAST(WGLEW_I3D_swap_frame_lock) = _glewSearchExtension("WGL_I3D_swap_frame_lock", extStart, extEnd);
    10834. 

  10834.   if (glewExperimental || WGLEW_I3D_swap_frame_lock|| crippled) CONST_CAST(WGLEW_I3D_swap_frame_lock)= !_glewInit_WGL_I3D_swap_frame_lock(GLEW_CONTEXT_ARG_VAR_INIT);
    10835. 

  10835. #endif /* WGL_I3D_swap_frame_lock */
    10836. 

  10836. #ifdef WGL_I3D_swap_frame_usage
    10837. 

  10837.   CONST_CAST(WGLEW_I3D_swap_frame_usage) = _glewSearchExtension("WGL_I3D_swap_frame_usage", extStart, extEnd);
    10838. 

  10838.   if (glewExperimental || WGLEW_I3D_swap_frame_usage|| crippled) CONST_CAST(WGLEW_I3D_swap_frame_usage)= !_glewInit_WGL_I3D_swap_frame_usage(GLEW_CONTEXT_ARG_VAR_INIT);
    10839. 

  10839. #endif /* WGL_I3D_swap_frame_usage */
    10840. 

  10840. #ifdef WGL_NV_DX_interop
    10841. 

  10841.   CONST_CAST(WGLEW_NV_DX_interop) = _glewSearchExtension("WGL_NV_DX_interop", extStart, extEnd);
    10842. 

  10842.   if (glewExperimental || WGLEW_NV_DX_interop|| crippled) CONST_CAST(WGLEW_NV_DX_interop)= !_glewInit_WGL_NV_DX_interop(GLEW_CONTEXT_ARG_VAR_INIT);
    10843. 

  10843. #endif /* WGL_NV_DX_interop */
    10844. 

  10844. #ifdef WGL_NV_copy_image
    10845. 

  10845.   CONST_CAST(WGLEW_NV_copy_image) = _glewSearchExtension("WGL_NV_copy_image", extStart, extEnd);
    10846. 

  10846.   if (glewExperimental || WGLEW_NV_copy_image|| crippled) CONST_CAST(WGLEW_NV_copy_image)= !_glewInit_WGL_NV_copy_image(GLEW_CONTEXT_ARG_VAR_INIT);
    10847. 

  10847. #endif /* WGL_NV_copy_image */
    10848. 

  10848. #ifdef WGL_NV_float_buffer
    10849. 

  10849.   CONST_CAST(WGLEW_NV_float_buffer) = _glewSearchExtension("WGL_NV_float_buffer", extStart, extEnd);
    10850. 

  10850. #endif /* WGL_NV_float_buffer */
    10851. 

  10851. #ifdef WGL_NV_gpu_affinity
    10852. 

  10852.   CONST_CAST(WGLEW_NV_gpu_affinity) = _glewSearchExtension("WGL_NV_gpu_affinity", extStart, extEnd);
    10853. 

  10853.   if (glewExperimental || WGLEW_NV_gpu_affinity|| crippled) CONST_CAST(WGLEW_NV_gpu_affinity)= !_glewInit_WGL_NV_gpu_affinity(GLEW_CONTEXT_ARG_VAR_INIT);
    10854. 

  10854. #endif /* WGL_NV_gpu_affinity */
    10855. 

  10855. #ifdef WGL_NV_multisample_coverage
    10856. 

  10856.   CONST_CAST(WGLEW_NV_multisample_coverage) = _glewSearchExtension("WGL_NV_multisample_coverage", extStart, extEnd);
    10857. 

  10857. #endif /* WGL_NV_multisample_coverage */
    10858. 

  10858. #ifdef WGL_NV_present_video
    10859. 

  10859.   CONST_CAST(WGLEW_NV_present_video) = _glewSearchExtension("WGL_NV_present_video", extStart, extEnd);
    10860. 

  10860.   if (glewExperimental || WGLEW_NV_present_video|| crippled) CONST_CAST(WGLEW_NV_present_video)= !_glewInit_WGL_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT);
    10861. 

  10861. #endif /* WGL_NV_present_video */
    10862. 

  10862. #ifdef WGL_NV_render_depth_texture
    10863. 

  10863.   CONST_CAST(WGLEW_NV_render_depth_texture) = _glewSearchExtension("WGL_NV_render_depth_texture", extStart, extEnd);
    10864. 

  10864. #endif /* WGL_NV_render_depth_texture */
    10865. 

  10865. #ifdef WGL_NV_render_texture_rectangle
    10866. 

  10866.   CONST_CAST(WGLEW_NV_render_texture_rectangle) = _glewSearchExtension("WGL_NV_render_texture_rectangle", extStart, extEnd);
    10867. 

  10867. #endif /* WGL_NV_render_texture_rectangle */
    10868. 

  10868. #ifdef WGL_NV_swap_group
    10869. 

  10869.   CONST_CAST(WGLEW_NV_swap_group) = _glewSearchExtension("WGL_NV_swap_group", extStart, extEnd);
    10870. 

  10870.   if (glewExperimental || WGLEW_NV_swap_group|| crippled) CONST_CAST(WGLEW_NV_swap_group)= !_glewInit_WGL_NV_swap_group(GLEW_CONTEXT_ARG_VAR_INIT);
    10871. 

  10871. #endif /* WGL_NV_swap_group */
    10872. 

  10872. #ifdef WGL_NV_vertex_array_range
    10873. 

  10873.   CONST_CAST(WGLEW_NV_vertex_array_range) = _glewSearchExtension("WGL_NV_vertex_array_range", extStart, extEnd);
    10874. 

  10874.   if (glewExperimental || WGLEW_NV_vertex_array_range|| crippled) CONST_CAST(WGLEW_NV_vertex_array_range)= !_glewInit_WGL_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);
    10875. 

  10875. #endif /* WGL_NV_vertex_array_range */
    10876. 

  10876. #ifdef WGL_NV_video_capture
    10877. 

  10877.   CONST_CAST(WGLEW_NV_video_capture) = _glewSearchExtension("WGL_NV_video_capture", extStart, extEnd);
    10878. 

  10878.   if (glewExperimental || WGLEW_NV_video_capture|| crippled) CONST_CAST(WGLEW_NV_video_capture)= !_glewInit_WGL_NV_video_capture(GLEW_CONTEXT_ARG_VAR_INIT);
    10879. 

  10879. #endif /* WGL_NV_video_capture */
    10880. 

  10880. #ifdef WGL_NV_video_output
    10881. 

  10881.   CONST_CAST(WGLEW_NV_video_output) = _glewSearchExtension("WGL_NV_video_output", extStart, extEnd);
    10882. 

  10882.   if (glewExperimental || WGLEW_NV_video_output|| crippled) CONST_CAST(WGLEW_NV_video_output)= !_glewInit_WGL_NV_video_output(GLEW_CONTEXT_ARG_VAR_INIT);
    10883. 

  10883. #endif /* WGL_NV_video_output */
    10884. 

  10884. #ifdef WGL_OML_sync_control
    10885. 

  10885.   CONST_CAST(WGLEW_OML_sync_control) = _glewSearchExtension("WGL_OML_sync_control", extStart, extEnd);
    10886. 

  10886.   if (glewExperimental || WGLEW_OML_sync_control|| crippled) CONST_CAST(WGLEW_OML_sync_control)= !_glewInit_WGL_OML_sync_control(GLEW_CONTEXT_ARG_VAR_INIT);
    10887. 

  10887. #endif /* WGL_OML_sync_control */
    10888. 

  10888. 

  10889.   return GLEW_OK;
    10890. 

  10890. }
    10891. 

  10891. 

  10892. #elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)
    10893. 

  10893. 

  10894. PFNGLXGETCURRENTDISPLAYPROC __glewXGetCurrentDisplay = NULL;
    10895. 

  10895. 

  10896. PFNGLXCHOOSEFBCONFIGPROC __glewXChooseFBConfig = NULL;
    10897. 

  10897. PFNGLXCREATENEWCONTEXTPROC __glewXCreateNewContext = NULL;
    10898. 

  10898. PFNGLXCREATEPBUFFERPROC __glewXCreatePbuffer = NULL;
    10899. 

  10899. PFNGLXCREATEPIXMAPPROC __glewXCreatePixmap = NULL;
    10900. 

  10900. PFNGLXCREATEWINDOWPROC __glewXCreateWindow = NULL;
    10901. 

  10901. PFNGLXDESTROYPBUFFERPROC __glewXDestroyPbuffer = NULL;
    10902. 

  10902. PFNGLXDESTROYPIXMAPPROC __glewXDestroyPixmap = NULL;
    10903. 

  10903. PFNGLXDESTROYWINDOWPROC __glewXDestroyWindow = NULL;
    10904. 

  10904. PFNGLXGETCURRENTREADDRAWABLEPROC __glewXGetCurrentReadDrawable = NULL;
    10905. 

  10905. PFNGLXGETFBCONFIGATTRIBPROC __glewXGetFBConfigAttrib = NULL;
    10906. 

  10906. PFNGLXGETFBCONFIGSPROC __glewXGetFBConfigs = NULL;
    10907. 

  10907. PFNGLXGETSELECTEDEVENTPROC __glewXGetSelectedEvent = NULL;
    10908. 

  10908. PFNGLXGETVISUALFROMFBCONFIGPROC __glewXGetVisualFromFBConfig = NULL;
    10909. 

  10909. PFNGLXMAKECONTEXTCURRENTPROC __glewXMakeContextCurrent = NULL;
    10910. 

  10910. PFNGLXQUERYCONTEXTPROC __glewXQueryContext = NULL;
    10911. 

  10911. PFNGLXQUERYDRAWABLEPROC __glewXQueryDrawable = NULL;
    10912. 

  10912. PFNGLXSELECTEVENTPROC __glewXSelectEvent = NULL;
    10913. 

  10913. 

  10914. PFNGLXCREATECONTEXTATTRIBSARBPROC __glewXCreateContextAttribsARB = NULL;
    10915. 

  10915. 

  10916. PFNGLXBINDTEXIMAGEATIPROC __glewXBindTexImageATI = NULL;
    10917. 

  10917. PFNGLXDRAWABLEATTRIBATIPROC __glewXDrawableAttribATI = NULL;
    10918. 

  10918. PFNGLXRELEASETEXIMAGEATIPROC __glewXReleaseTexImageATI = NULL;
    10919. 

  10919. 

  10920. PFNGLXFREECONTEXTEXTPROC __glewXFreeContextEXT = NULL;
    10921. 

  10921. PFNGLXGETCONTEXTIDEXTPROC __glewXGetContextIDEXT = NULL;
    10922. 

  10922. PFNGLXIMPORTCONTEXTEXTPROC __glewXImportContextEXT = NULL;
    10923. 

  10923. PFNGLXQUERYCONTEXTINFOEXTPROC __glewXQueryContextInfoEXT = NULL;
    10924. 

  10924. 

  10925. PFNGLXSWAPINTERVALEXTPROC __glewXSwapIntervalEXT = NULL;
    10926. 

  10926. 

  10927. PFNGLXBINDTEXIMAGEEXTPROC __glewXBindTexImageEXT = NULL;
    10928. 

  10928. PFNGLXRELEASETEXIMAGEEXTPROC __glewXReleaseTexImageEXT = NULL;
    10929. 

  10929. 

  10930. PFNGLXGETAGPOFFSETMESAPROC __glewXGetAGPOffsetMESA = NULL;
    10931. 

  10931. 

  10932. PFNGLXCOPYSUBBUFFERMESAPROC __glewXCopySubBufferMESA = NULL;
    10933. 

  10933. 

  10934. PFNGLXCREATEGLXPIXMAPMESAPROC __glewXCreateGLXPixmapMESA = NULL;
    10935. 

  10935. 

  10936. PFNGLXRELEASEBUFFERSMESAPROC __glewXReleaseBuffersMESA = NULL;
    10937. 

  10937. 

  10938. PFNGLXSET3DFXMODEMESAPROC __glewXSet3DfxModeMESA = NULL;
    10939. 

  10939. 

  10940. PFNGLXGETSWAPINTERVALMESAPROC __glewXGetSwapIntervalMESA = NULL;
    10941. 

  10941. PFNGLXSWAPINTERVALMESAPROC __glewXSwapIntervalMESA = NULL;
    10942. 

  10942. 

  10943. PFNGLXCOPYIMAGESUBDATANVPROC __glewXCopyImageSubDataNV = NULL;
    10944. 

  10944. 

  10945. PFNGLXBINDVIDEODEVICENVPROC __glewXBindVideoDeviceNV = NULL;
    10946. 

  10946. PFNGLXENUMERATEVIDEODEVICESNVPROC __glewXEnumerateVideoDevicesNV = NULL;
    10947. 

  10947. 

  10948. PFNGLXBINDSWAPBARRIERNVPROC __glewXBindSwapBarrierNV = NULL;
    10949. 

  10949. PFNGLXJOINSWAPGROUPNVPROC __glewXJoinSwapGroupNV = NULL;
    10950. 

  10950. PFNGLXQUERYFRAMECOUNTNVPROC __glewXQueryFrameCountNV = NULL;
    10951. 

  10951. PFNGLXQUERYMAXSWAPGROUPSNVPROC __glewXQueryMaxSwapGroupsNV = NULL;
    10952. 

  10952. PFNGLXQUERYSWAPGROUPNVPROC __glewXQuerySwapGroupNV = NULL;
    10953. 

  10953. PFNGLXRESETFRAMECOUNTNVPROC __glewXResetFrameCountNV = NULL;
    10954. 

  10954. 

  10955. PFNGLXALLOCATEMEMORYNVPROC __glewXAllocateMemoryNV = NULL;
    10956. 

  10956. PFNGLXFREEMEMORYNVPROC __glewXFreeMemoryNV = NULL;
    10957. 

  10957. 

  10958. PFNGLXBINDVIDEOCAPTUREDEVICENVPROC __glewXBindVideoCaptureDeviceNV = NULL;
    10959. 

  10959. PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC __glewXEnumerateVideoCaptureDevicesNV = NULL;
    10960. 

  10960. PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC __glewXLockVideoCaptureDeviceNV = NULL;
    10961. 

  10961. PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC __glewXQueryVideoCaptureDeviceNV = NULL;
    10962. 

  10962. PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC __glewXReleaseVideoCaptureDeviceNV = NULL;
    10963. 

  10963. 

  10964. PFNGLXBINDVIDEOIMAGENVPROC __glewXBindVideoImageNV = NULL;
    10965. 

  10965. PFNGLXGETVIDEODEVICENVPROC __glewXGetVideoDeviceNV = NULL;
    10966. 

  10966. PFNGLXGETVIDEOINFONVPROC __glewXGetVideoInfoNV = NULL;
    10967. 

  10967. PFNGLXRELEASEVIDEODEVICENVPROC __glewXReleaseVideoDeviceNV = NULL;
    10968. 

  10968. PFNGLXRELEASEVIDEOIMAGENVPROC __glewXReleaseVideoImageNV = NULL;
    10969. 

  10969. PFNGLXSENDPBUFFERTOVIDEONVPROC __glewXSendPbufferToVideoNV = NULL;
    10970. 

  10970. 

  10971. PFNGLXGETMSCRATEOMLPROC __glewXGetMscRateOML = NULL;
    10972. 

  10972. PFNGLXGETSYNCVALUESOMLPROC __glewXGetSyncValuesOML = NULL;
    10973. 

  10973. PFNGLXSWAPBUFFERSMSCOMLPROC __glewXSwapBuffersMscOML = NULL;
    10974. 

  10974. PFNGLXWAITFORMSCOMLPROC __glewXWaitForMscOML = NULL;
    10975. 

  10975. PFNGLXWAITFORSBCOMLPROC __glewXWaitForSbcOML = NULL;
    10976. 

  10976. 

  10977. PFNGLXCHOOSEFBCONFIGSGIXPROC __glewXChooseFBConfigSGIX = NULL;
    10978. 

  10978. PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC __glewXCreateContextWithConfigSGIX = NULL;
    10979. 

  10979. PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC __glewXCreateGLXPixmapWithConfigSGIX = NULL;
    10980. 

  10980. PFNGLXGETFBCONFIGATTRIBSGIXPROC __glewXGetFBConfigAttribSGIX = NULL;
    10981. 

  10981. PFNGLXGETFBCONFIGFROMVISUALSGIXPROC __glewXGetFBConfigFromVisualSGIX = NULL;
    10982. 

  10982. PFNGLXGETVISUALFROMFBCONFIGSGIXPROC __glewXGetVisualFromFBConfigSGIX = NULL;
    10983. 

  10983. 

  10984. PFNGLXBINDHYPERPIPESGIXPROC __glewXBindHyperpipeSGIX = NULL;
    10985. 

  10985. PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC __glewXDestroyHyperpipeConfigSGIX = NULL;
    10986. 

  10986. PFNGLXHYPERPIPEATTRIBSGIXPROC __glewXHyperpipeAttribSGIX = NULL;
    10987. 

  10987. PFNGLXHYPERPIPECONFIGSGIXPROC __glewXHyperpipeConfigSGIX = NULL;
    10988. 

  10988. PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC __glewXQueryHyperpipeAttribSGIX = NULL;
    10989. 

  10989. PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC __glewXQueryHyperpipeBestAttribSGIX = NULL;
    10990. 

  10990. PFNGLXQUERYHYPERPIPECONFIGSGIXPROC __glewXQueryHyperpipeConfigSGIX = NULL;
    10991. 

  10991. PFNGLXQUERYHYPERPIPENETWORKSGIXPROC __glewXQueryHyperpipeNetworkSGIX = NULL;
    10992. 

  10992. 

  10993. PFNGLXCREATEGLXPBUFFERSGIXPROC __glewXCreateGLXPbufferSGIX = NULL;
    10994. 

  10994. PFNGLXDESTROYGLXPBUFFERSGIXPROC __glewXDestroyGLXPbufferSGIX = NULL;
    10995. 

  10995. PFNGLXGETSELECTEDEVENTSGIXPROC __glewXGetSelectedEventSGIX = NULL;
    10996. 

  10996. PFNGLXQUERYGLXPBUFFERSGIXPROC __glewXQueryGLXPbufferSGIX = NULL;
    10997. 

  10997. PFNGLXSELECTEVENTSGIXPROC __glewXSelectEventSGIX = NULL;
    10998. 

  10998. 

  10999. PFNGLXBINDSWAPBARRIERSGIXPROC __glewXBindSwapBarrierSGIX = NULL;
    11000. 

  11000. PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC __glewXQueryMaxSwapBarriersSGIX = NULL;
    11001. 

  11001. 

  11002. PFNGLXJOINSWAPGROUPSGIXPROC __glewXJoinSwapGroupSGIX = NULL;
    11003. 

  11003. 

  11004. PFNGLXBINDCHANNELTOWINDOWSGIXPROC __glewXBindChannelToWindowSGIX = NULL;
    11005. 

  11005. PFNGLXCHANNELRECTSGIXPROC __glewXChannelRectSGIX = NULL;
    11006. 

  11006. PFNGLXCHANNELRECTSYNCSGIXPROC __glewXChannelRectSyncSGIX = NULL;
    11007. 

  11007. PFNGLXQUERYCHANNELDELTASSGIXPROC __glewXQueryChannelDeltasSGIX = NULL;
    11008. 

  11008. PFNGLXQUERYCHANNELRECTSGIXPROC __glewXQueryChannelRectSGIX = NULL;
    11009. 

  11009. 

  11010. PFNGLXCUSHIONSGIPROC __glewXCushionSGI = NULL;
    11011. 

  11011. 

  11012. PFNGLXGETCURRENTREADDRAWABLESGIPROC __glewXGetCurrentReadDrawableSGI = NULL;
    11013. 

  11013. PFNGLXMAKECURRENTREADSGIPROC __glewXMakeCurrentReadSGI = NULL;
    11014. 

  11014. 

  11015. PFNGLXSWAPINTERVALSGIPROC __glewXSwapIntervalSGI = NULL;
    11016. 

  11016. 

  11017. PFNGLXGETVIDEOSYNCSGIPROC __glewXGetVideoSyncSGI = NULL;
    11018. 

  11018. PFNGLXWAITVIDEOSYNCSGIPROC __glewXWaitVideoSyncSGI = NULL;
    11019. 

  11019. 

  11020. PFNGLXGETTRANSPARENTINDEXSUNPROC __glewXGetTransparentIndexSUN = NULL;
    11021. 

  11021. 

  11022. PFNGLXGETVIDEORESIZESUNPROC __glewXGetVideoResizeSUN = NULL;
    11023. 

  11023. PFNGLXVIDEORESIZESUNPROC __glewXVideoResizeSUN = NULL;
    11024. 

  11024. 

  11025. #if !defined(GLEW_MX)
    11026. 

  11026. 

  11027. GLboolean __GLXEW_VERSION_1_0 = GL_FALSE;
    11028. 

  11028. GLboolean __GLXEW_VERSION_1_1 = GL_FALSE;
    11029. 

  11029. GLboolean __GLXEW_VERSION_1_2 = GL_FALSE;
    11030. 

  11030. GLboolean __GLXEW_VERSION_1_3 = GL_FALSE;
    11031. 

  11031. GLboolean __GLXEW_VERSION_1_4 = GL_FALSE;
    11032. 

  11032. GLboolean __GLXEW_3DFX_multisample = GL_FALSE;
    11033. 

  11033. GLboolean __GLXEW_AMD_gpu_association = GL_FALSE;
    11034. 

  11034. GLboolean __GLXEW_ARB_create_context = GL_FALSE;
    11035. 

  11035. GLboolean __GLXEW_ARB_create_context_profile = GL_FALSE;
    11036. 

  11036. GLboolean __GLXEW_ARB_create_context_robustness = GL_FALSE;
    11037. 

  11037. GLboolean __GLXEW_ARB_fbconfig_float = GL_FALSE;
    11038. 

  11038. GLboolean __GLXEW_ARB_framebuffer_sRGB = GL_FALSE;
    11039. 

  11039. GLboolean __GLXEW_ARB_get_proc_address = GL_FALSE;
    11040. 

  11040. GLboolean __GLXEW_ARB_multisample = GL_FALSE;
    11041. 

  11041. GLboolean __GLXEW_ARB_vertex_buffer_object = GL_FALSE;
    11042. 

  11042. GLboolean __GLXEW_ATI_pixel_format_float = GL_FALSE;
    11043. 

  11043. GLboolean __GLXEW_ATI_render_texture = GL_FALSE;
    11044. 

  11044. GLboolean __GLXEW_EXT_create_context_es2_profile = GL_FALSE;
    11045. 

  11045. GLboolean __GLXEW_EXT_fbconfig_packed_float = GL_FALSE;
    11046. 

  11046. GLboolean __GLXEW_EXT_framebuffer_sRGB = GL_FALSE;
    11047. 

  11047. GLboolean __GLXEW_EXT_import_context = GL_FALSE;
    11048. 

  11048. GLboolean __GLXEW_EXT_scene_marker = GL_FALSE;
    11049. 

  11049. GLboolean __GLXEW_EXT_swap_control = GL_FALSE;
    11050. 

  11050. GLboolean __GLXEW_EXT_texture_from_pixmap = GL_FALSE;
    11051. 

  11051. GLboolean __GLXEW_EXT_visual_info = GL_FALSE;
    11052. 

  11052. GLboolean __GLXEW_EXT_visual_rating = GL_FALSE;
    11053. 

  11053. GLboolean __GLXEW_INTEL_swap_event = GL_FALSE;
    11054. 

  11054. GLboolean __GLXEW_MESA_agp_offset = GL_FALSE;
    11055. 

  11055. GLboolean __GLXEW_MESA_copy_sub_buffer = GL_FALSE;
    11056. 

  11056. GLboolean __GLXEW_MESA_pixmap_colormap = GL_FALSE;
    11057. 

  11057. GLboolean __GLXEW_MESA_release_buffers = GL_FALSE;
    11058. 

  11058. GLboolean __GLXEW_MESA_set_3dfx_mode = GL_FALSE;
    11059. 

  11059. GLboolean __GLXEW_MESA_swap_control = GL_FALSE;
    11060. 

  11060. GLboolean __GLXEW_NV_copy_image = GL_FALSE;
    11061. 

  11061. GLboolean __GLXEW_NV_float_buffer = GL_FALSE;
    11062. 

  11062. GLboolean __GLXEW_NV_multisample_coverage = GL_FALSE;
    11063. 

  11063. GLboolean __GLXEW_NV_present_video = GL_FALSE;
    11064. 

  11064. GLboolean __GLXEW_NV_swap_group = GL_FALSE;
    11065. 

  11065. GLboolean __GLXEW_NV_vertex_array_range = GL_FALSE;
    11066. 

  11066. GLboolean __GLXEW_NV_video_capture = GL_FALSE;
    11067. 

  11067. GLboolean __GLXEW_NV_video_output = GL_FALSE;
    11068. 

  11068. GLboolean __GLXEW_OML_swap_method = GL_FALSE;
    11069. 

  11069. GLboolean __GLXEW_OML_sync_control = GL_FALSE;
    11070. 

  11070. GLboolean __GLXEW_SGIS_blended_overlay = GL_FALSE;
    11071. 

  11071. GLboolean __GLXEW_SGIS_color_range = GL_FALSE;
    11072. 

  11072. GLboolean __GLXEW_SGIS_multisample = GL_FALSE;
    11073. 

  11073. GLboolean __GLXEW_SGIS_shared_multisample = GL_FALSE;
    11074. 

  11074. GLboolean __GLXEW_SGIX_fbconfig = GL_FALSE;
    11075. 

  11075. GLboolean __GLXEW_SGIX_hyperpipe = GL_FALSE;
    11076. 

  11076. GLboolean __GLXEW_SGIX_pbuffer = GL_FALSE;
    11077. 

  11077. GLboolean __GLXEW_SGIX_swap_barrier = GL_FALSE;
    11078. 

  11078. GLboolean __GLXEW_SGIX_swap_group = GL_FALSE;
    11079. 

  11079. GLboolean __GLXEW_SGIX_video_resize = GL_FALSE;
    11080. 

  11080. GLboolean __GLXEW_SGIX_visual_select_group = GL_FALSE;
    11081. 

  11081. GLboolean __GLXEW_SGI_cushion = GL_FALSE;
    11082. 

  11082. GLboolean __GLXEW_SGI_make_current_read = GL_FALSE;
    11083. 

  11083. GLboolean __GLXEW_SGI_swap_control = GL_FALSE;
    11084. 

  11084. GLboolean __GLXEW_SGI_video_sync = GL_FALSE;
    11085. 

  11085. GLboolean __GLXEW_SUN_get_transparent_index = GL_FALSE;
    11086. 

  11086. GLboolean __GLXEW_SUN_video_resize = GL_FALSE;
    11087. 

  11087. 

  11088. #endif /* !GLEW_MX */
    11089. 

  11089. 

  11090. #ifdef GLX_VERSION_1_2
    11091. 

  11091. 

  11092. static GLboolean _glewInit_GLX_VERSION_1_2 (GLXEW_CONTEXT_ARG_DEF_INIT)
    11093. 

  11093. {
    11094. 

  11094.   GLboolean r = GL_FALSE;
    11095. 

  11095. 

  11096. // SJS
    11097. 

  11097. 	// FB: Patched to allow Ogre to overload glXGetCurrentDisplay
    11098. 

  11098. 	if (glXGetCurrentDisplay == NULL) 
    11099. 

  11099. 	{
    11100. 

  11100. 		r = ((glXGetCurrentDisplay = (PFNGLXGETCURRENTDISPLAYPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentDisplay")) == NULL) || r;
    11101. 

  11101. 	}
    11102. 

  11102. 	//r = ((glXGetCurrentDisplay = (PFNGLXGETCURRENTDISPLAYPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentDisplay")) == NULL) || r;
    11103. 

  11103. // SJS
    11104. 

  11104. 

  11105.   return r;
    11106. 

  11106. }
    11107. 

  11107. 

  11108. #endif /* GLX_VERSION_1_2 */
    11109. 

  11109. 

  11110. #ifdef GLX_VERSION_1_3
    11111. 

  11111. 

  11112. static GLboolean _glewInit_GLX_VERSION_1_3 (GLXEW_CONTEXT_ARG_DEF_INIT)
    11113. 

  11113. {
    11114. 

  11114.   GLboolean r = GL_FALSE;
    11115. 

  11115. 

  11116.   r = ((glXChooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfig")) == NULL) || r;
    11117. 

  11117.   r = ((glXCreateNewContext = (PFNGLXCREATENEWCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXCreateNewContext")) == NULL) || r;
    11118. 

  11118.   r = ((glXCreatePbuffer = (PFNGLXCREATEPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXCreatePbuffer")) == NULL) || r;
    11119. 

  11119.   r = ((glXCreatePixmap = (PFNGLXCREATEPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXCreatePixmap")) == NULL) || r;
    11120. 

  11120.   r = ((glXCreateWindow = (PFNGLXCREATEWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXCreateWindow")) == NULL) || r;
    11121. 

  11121.   r = ((glXDestroyPbuffer = (PFNGLXDESTROYPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPbuffer")) == NULL) || r;
    11122. 

  11122.   r = ((glXDestroyPixmap = (PFNGLXDESTROYPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPixmap")) == NULL) || r;
    11123. 

  11123.   r = ((glXDestroyWindow = (PFNGLXDESTROYWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXDestroyWindow")) == NULL) || r;
    11124. 

  11124.   r = ((glXGetCurrentReadDrawable = (PFNGLXGETCURRENTREADDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawable")) == NULL) || r;
    11125. 

  11125.   r = ((glXGetFBConfigAttrib = (PFNGLXGETFBCONFIGATTRIBPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttrib")) == NULL) || r;
    11126. 

  11126.   r = ((glXGetFBConfigs = (PFNGLXGETFBCONFIGSPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigs")) == NULL) || r;
    11127. 

  11127.   r = ((glXGetSelectedEvent = (PFNGLXGETSELECTEDEVENTPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEvent")) == NULL) || r;
    11128. 

  11128.   r = ((glXGetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfig")) == NULL) || r;
    11129. 

  11129.   r = ((glXMakeContextCurrent = (PFNGLXMAKECONTEXTCURRENTPROC)glewGetProcAddress((const GLubyte*)"glXMakeContextCurrent")) == NULL) || r;
    11130. 

  11130.   r = ((glXQueryContext = (PFNGLXQUERYCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContext")) == NULL) || r;
    11131. 

  11131.   r = ((glXQueryDrawable = (PFNGLXQUERYDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXQueryDrawable")) == NULL) || r;
    11132. 

  11132.   r = ((glXSelectEvent = (PFNGLXSELECTEVENTPROC)glewGetProcAddress((const GLubyte*)"glXSelectEvent")) == NULL) || r;
    11133. 

  11133. 

  11134.   return r;
    11135. 

  11135. }
    11136. 

  11136. 

  11137. #endif /* GLX_VERSION_1_3 */
    11138. 

  11138. 

  11139. #ifdef GLX_VERSION_1_4
    11140. 

  11140. 

  11141. #endif /* GLX_VERSION_1_4 */
    11142. 

  11142. 

  11143. #ifdef GLX_3DFX_multisample
    11144. 

  11144. 

  11145. #endif /* GLX_3DFX_multisample */
    11146. 

  11146. 

  11147. #ifdef GLX_AMD_gpu_association
    11148. 

  11148. 

  11149. #endif /* GLX_AMD_gpu_association */
    11150. 

  11150. 

  11151. #ifdef GLX_ARB_create_context
    11152. 

  11152. 

  11153. static GLboolean _glewInit_GLX_ARB_create_context (GLXEW_CONTEXT_ARG_DEF_INIT)
    11154. 

  11154. {
    11155. 

  11155.   GLboolean r = GL_FALSE;
    11156. 

  11156. 

  11157.   r = ((glXCreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)glewGetProcAddress((const GLubyte*)"glXCreateContextAttribsARB")) == NULL) || r;
    11158. 

  11158. 

  11159.   return r;
    11160. 

  11160. }
    11161. 

  11161. 

  11162. #endif /* GLX_ARB_create_context */
    11163. 

  11163. 

  11164. #ifdef GLX_ARB_create_context_profile
    11165. 

  11165. 

  11166. #endif /* GLX_ARB_create_context_profile */
    11167. 

  11167. 

  11168. #ifdef GLX_ARB_create_context_robustness
    11169. 

  11169. 

  11170. #endif /* GLX_ARB_create_context_robustness */
    11171. 

  11171. 

  11172. #ifdef GLX_ARB_fbconfig_float
    11173. 

  11173. 

  11174. #endif /* GLX_ARB_fbconfig_float */
    11175. 

  11175. 

  11176. #ifdef GLX_ARB_framebuffer_sRGB
    11177. 

  11177. 

  11178. #endif /* GLX_ARB_framebuffer_sRGB */
    11179. 

  11179. 

  11180. #ifdef GLX_ARB_get_proc_address
    11181. 

  11181. 

  11182. #endif /* GLX_ARB_get_proc_address */
    11183. 

  11183. 

  11184. #ifdef GLX_ARB_multisample
    11185. 

  11185. 

  11186. #endif /* GLX_ARB_multisample */
    11187. 

  11187. 

  11188. #ifdef GLX_ARB_vertex_buffer_object
    11189. 

  11189. 

  11190. #endif /* GLX_ARB_vertex_buffer_object */
    11191. 

  11191. 

  11192. #ifdef GLX_ATI_pixel_format_float
    11193. 

  11193. 

  11194. #endif /* GLX_ATI_pixel_format_float */
    11195. 

  11195. 

  11196. #ifdef GLX_ATI_render_texture
    11197. 

  11197. 

  11198. static GLboolean _glewInit_GLX_ATI_render_texture (GLXEW_CONTEXT_ARG_DEF_INIT)
    11199. 

  11199. {
    11200. 

  11200.   GLboolean r = GL_FALSE;
    11201. 

  11201. 

  11202.   r = ((glXBindTexImageATI = (PFNGLXBINDTEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXBindTexImageATI")) == NULL) || r;
    11203. 

  11203.   r = ((glXDrawableAttribATI = (PFNGLXDRAWABLEATTRIBATIPROC)glewGetProcAddress((const GLubyte*)"glXDrawableAttribATI")) == NULL) || r;
    11204. 

  11204.   r = ((glXReleaseTexImageATI = (PFNGLXRELEASETEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXReleaseTexImageATI")) == NULL) || r;
    11205. 

  11205. 

  11206.   return r;
    11207. 

  11207. }
    11208. 

  11208. 

  11209. #endif /* GLX_ATI_render_texture */
    11210. 

  11210. 

  11211. #ifdef GLX_EXT_create_context_es2_profile
    11212. 

  11212. 

  11213. #endif /* GLX_EXT_create_context_es2_profile */
    11214. 

  11214. 

  11215. #ifdef GLX_EXT_fbconfig_packed_float
    11216. 

  11216. 

  11217. #endif /* GLX_EXT_fbconfig_packed_float */
    11218. 

  11218. 

  11219. #ifdef GLX_EXT_framebuffer_sRGB
    11220. 

  11220. 

  11221. #endif /* GLX_EXT_framebuffer_sRGB */
    11222. 

  11222. 

  11223. #ifdef GLX_EXT_import_context
    11224. 

  11224. 

  11225. static GLboolean _glewInit_GLX_EXT_import_context (GLXEW_CONTEXT_ARG_DEF_INIT)
    11226. 

  11226. {
    11227. 

  11227.   GLboolean r = GL_FALSE;
    11228. 

  11228. 

  11229.   r = ((glXFreeContextEXT = (PFNGLXFREECONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXFreeContextEXT")) == NULL) || r;
    11230. 

  11230.   r = ((glXGetContextIDEXT = (PFNGLXGETCONTEXTIDEXTPROC)glewGetProcAddress((const GLubyte*)"glXGetContextIDEXT")) == NULL) || r;
    11231. 

  11231.   r = ((glXImportContextEXT = (PFNGLXIMPORTCONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXImportContextEXT")) == NULL) || r;
    11232. 

  11232.   r = ((glXQueryContextInfoEXT = (PFNGLXQUERYCONTEXTINFOEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContextInfoEXT")) == NULL) || r;
    11233. 

  11233. 

  11234.   return r;
    11235. 

  11235. }
    11236. 

  11236. 

  11237. #endif /* GLX_EXT_import_context */
    11238. 

  11238. 

  11239. #ifdef GLX_EXT_scene_marker
    11240. 

  11240. 

  11241. #endif /* GLX_EXT_scene_marker */
    11242. 

  11242. 

  11243. #ifdef GLX_EXT_swap_control
    11244. 

  11244. 

  11245. static GLboolean _glewInit_GLX_EXT_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT)
    11246. 

  11246. {
    11247. 

  11247.   GLboolean r = GL_FALSE;
    11248. 

  11248. 

  11249.   r = ((glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalEXT")) == NULL) || r;
    11250. 

  11250. 

  11251.   return r;
    11252. 

  11252. }
    11253. 

  11253. 

  11254. #endif /* GLX_EXT_swap_control */
    11255. 

  11255. 

  11256. #ifdef GLX_EXT_texture_from_pixmap
    11257. 

  11257. 

  11258. static GLboolean _glewInit_GLX_EXT_texture_from_pixmap (GLXEW_CONTEXT_ARG_DEF_INIT)
    11259. 

  11259. {
    11260. 

  11260.   GLboolean r = GL_FALSE;
    11261. 

  11261. 

  11262.   r = ((glXBindTexImageEXT = (PFNGLXBINDTEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glXBindTexImageEXT")) == NULL) || r;
    11263. 

  11263.   r = ((glXReleaseTexImageEXT = (PFNGLXRELEASETEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glXReleaseTexImageEXT")) == NULL) || r;
    11264. 

  11264. 

  11265.   return r;
    11266. 

  11266. }
    11267. 

  11267. 

  11268. #endif /* GLX_EXT_texture_from_pixmap */
    11269. 

  11269. 

  11270. #ifdef GLX_EXT_visual_info
    11271. 

  11271. 

  11272. #endif /* GLX_EXT_visual_info */
    11273. 

  11273. 

  11274. #ifdef GLX_EXT_visual_rating
    11275. 

  11275. 

  11276. #endif /* GLX_EXT_visual_rating */
    11277. 

  11277. 

  11278. #ifdef GLX_INTEL_swap_event
    11279. 

  11279. 

  11280. #endif /* GLX_INTEL_swap_event */
    11281. 

  11281. 

  11282. #ifdef GLX_MESA_agp_offset
    11283. 

  11283. 

  11284. static GLboolean _glewInit_GLX_MESA_agp_offset (GLXEW_CONTEXT_ARG_DEF_INIT)
    11285. 

  11285. {
    11286. 

  11286.   GLboolean r = GL_FALSE;
    11287. 

  11287. 

  11288.   r = ((glXGetAGPOffsetMESA = (PFNGLXGETAGPOFFSETMESAPROC)glewGetProcAddress((const GLubyte*)"glXGetAGPOffsetMESA")) == NULL) || r;
    11289. 

  11289. 

  11290.   return r;
    11291. 

  11291. }
    11292. 

  11292. 

  11293. #endif /* GLX_MESA_agp_offset */
    11294. 

  11294. 

  11295. #ifdef GLX_MESA_copy_sub_buffer
    11296. 

  11296. 

  11297. static GLboolean _glewInit_GLX_MESA_copy_sub_buffer (GLXEW_CONTEXT_ARG_DEF_INIT)
    11298. 

  11298. {
    11299. 

  11299.   GLboolean r = GL_FALSE;
    11300. 

  11300. 

  11301.   r = ((glXCopySubBufferMESA = (PFNGLXCOPYSUBBUFFERMESAPROC)glewGetProcAddress((const GLubyte*)"glXCopySubBufferMESA")) == NULL) || r;
    11302. 

  11302. 

  11303.   return r;
    11304. 

  11304. }
    11305. 

  11305. 

  11306. #endif /* GLX_MESA_copy_sub_buffer */
    11307. 

  11307. 

  11308. #ifdef GLX_MESA_pixmap_colormap
    11309. 

  11309. 

  11310. static GLboolean _glewInit_GLX_MESA_pixmap_colormap (GLXEW_CONTEXT_ARG_DEF_INIT)
    11311. 

  11311. {
    11312. 

  11312.   GLboolean r = GL_FALSE;
    11313. 

  11313. 

  11314.   r = ((glXCreateGLXPixmapMESA = (PFNGLXCREATEGLXPIXMAPMESAPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapMESA")) == NULL) || r;
    11315. 

  11315. 

  11316.   return r;
    11317. 

  11317. }
    11318. 

  11318. 

  11319. #endif /* GLX_MESA_pixmap_colormap */
    11320. 

  11320. 

  11321. #ifdef GLX_MESA_release_buffers
    11322. 

  11322. 

  11323. static GLboolean _glewInit_GLX_MESA_release_buffers (GLXEW_CONTEXT_ARG_DEF_INIT)
    11324. 

  11324. {
    11325. 

  11325.   GLboolean r = GL_FALSE;
    11326. 

  11326. 

  11327.   r = ((glXReleaseBuffersMESA = (PFNGLXRELEASEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glXReleaseBuffersMESA")) == NULL) || r;
    11328. 

  11328. 

  11329.   return r;
    11330. 

  11330. }
    11331. 

  11331. 

  11332. #endif /* GLX_MESA_release_buffers */
    11333. 

  11333. 

  11334. #ifdef GLX_MESA_set_3dfx_mode
    11335. 

  11335. 

  11336. static GLboolean _glewInit_GLX_MESA_set_3dfx_mode (GLXEW_CONTEXT_ARG_DEF_INIT)
    11337. 

  11337. {
    11338. 

  11338.   GLboolean r = GL_FALSE;
    11339. 

  11339. 

  11340.   r = ((glXSet3DfxModeMESA = (PFNGLXSET3DFXMODEMESAPROC)glewGetProcAddress((const GLubyte*)"glXSet3DfxModeMESA")) == NULL) || r;
    11341. 

  11341. 

  11342.   return r;
    11343. 

  11343. }
    11344. 

  11344. 

  11345. #endif /* GLX_MESA_set_3dfx_mode */
    11346. 

  11346. 

  11347. #ifdef GLX_MESA_swap_control
    11348. 

  11348. 

  11349. static GLboolean _glewInit_GLX_MESA_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT)
    11350. 

  11350. {
    11351. 

  11351.   GLboolean r = GL_FALSE;
    11352. 

  11352. 

  11353.   r = ((glXGetSwapIntervalMESA = (PFNGLXGETSWAPINTERVALMESAPROC)glewGetProcAddress((const GLubyte*)"glXGetSwapIntervalMESA")) == NULL) || r;
    11354. 

  11354.   r = ((glXSwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalMESA")) == NULL) || r;
    11355. 

  11355. 

  11356.   return r;
    11357. 

  11357. }
    11358. 

  11358. 

  11359. #endif /* GLX_MESA_swap_control */
    11360. 

  11360. 

  11361. #ifdef GLX_NV_copy_image
    11362. 

  11362. 

  11363. static GLboolean _glewInit_GLX_NV_copy_image (GLXEW_CONTEXT_ARG_DEF_INIT)
    11364. 

  11364. {
    11365. 

  11365.   GLboolean r = GL_FALSE;
    11366. 

  11366. 

  11367.   r = ((glXCopyImageSubDataNV = (PFNGLXCOPYIMAGESUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glXCopyImageSubDataNV")) == NULL) || r;
    11368. 

  11368. 

  11369.   return r;
    11370. 

  11370. }
    11371. 

  11371. 

  11372. #endif /* GLX_NV_copy_image */
    11373. 

  11373. 

  11374. #ifdef GLX_NV_float_buffer
    11375. 

  11375. 

  11376. #endif /* GLX_NV_float_buffer */
    11377. 

  11377. 

  11378. #ifdef GLX_NV_multisample_coverage
    11379. 

  11379. 

  11380. #endif /* GLX_NV_multisample_coverage */
    11381. 

  11381. 

  11382. #ifdef GLX_NV_present_video
    11383. 

  11383. 

  11384. static GLboolean _glewInit_GLX_NV_present_video (GLXEW_CONTEXT_ARG_DEF_INIT)
    11385. 

  11385. {
    11386. 

  11386.   GLboolean r = GL_FALSE;
    11387. 

  11387. 

  11388.   r = ((glXBindVideoDeviceNV = (PFNGLXBINDVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoDeviceNV")) == NULL) || r;
    11389. 

  11389.   r = ((glXEnumerateVideoDevicesNV = (PFNGLXENUMERATEVIDEODEVICESNVPROC)glewGetProcAddress((const GLubyte*)"glXEnumerateVideoDevicesNV")) == NULL) || r;
    11390. 

  11390. 

  11391.   return r;
    11392. 

  11392. }
    11393. 

  11393. 

  11394. #endif /* GLX_NV_present_video */
    11395. 

  11395. 

  11396. #ifdef GLX_NV_swap_group
    11397. 

  11397. 

  11398. static GLboolean _glewInit_GLX_NV_swap_group (GLXEW_CONTEXT_ARG_DEF_INIT)
    11399. 

  11399. {
    11400. 

  11400.   GLboolean r = GL_FALSE;
    11401. 

  11401. 

  11402.   r = ((glXBindSwapBarrierNV = (PFNGLXBINDSWAPBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glXBindSwapBarrierNV")) == NULL) || r;
    11403. 

  11403.   r = ((glXJoinSwapGroupNV = (PFNGLXJOINSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"glXJoinSwapGroupNV")) == NULL) || r;
    11404. 

  11404.   r = ((glXQueryFrameCountNV = (PFNGLXQUERYFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glXQueryFrameCountNV")) == NULL) || r;
    11405. 

  11405.   r = ((glXQueryMaxSwapGroupsNV = (PFNGLXQUERYMAXSWAPGROUPSNVPROC)glewGetProcAddress((const GLubyte*)"glXQueryMaxSwapGroupsNV")) == NULL) || r;
    11406. 

  11406.   r = ((glXQuerySwapGroupNV = (PFNGLXQUERYSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"glXQuerySwapGroupNV")) == NULL) || r;
    11407. 

  11407.   r = ((glXResetFrameCountNV = (PFNGLXRESETFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glXResetFrameCountNV")) == NULL) || r;
    11408. 

  11408. 

  11409.   return r;
    11410. 

  11410. }
    11411. 

  11411. 

  11412. #endif /* GLX_NV_swap_group */
    11413. 

  11413. 

  11414. #ifdef GLX_NV_vertex_array_range
    11415. 

  11415. 

  11416. static GLboolean _glewInit_GLX_NV_vertex_array_range (GLXEW_CONTEXT_ARG_DEF_INIT)
    11417. 

  11417. {
    11418. 

  11418.   GLboolean r = GL_FALSE;
    11419. 

  11419. 

  11420.   r = ((glXAllocateMemoryNV = (PFNGLXALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXAllocateMemoryNV")) == NULL) || r;
    11421. 

  11421.   r = ((glXFreeMemoryNV = (PFNGLXFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXFreeMemoryNV")) == NULL) || r;
    11422. 

  11422. 

  11423.   return r;
    11424. 

  11424. }
    11425. 

  11425. 

  11426. #endif /* GLX_NV_vertex_array_range */
    11427. 

  11427. 

  11428. #ifdef GLX_NV_video_capture
    11429. 

  11429. 

  11430. static GLboolean _glewInit_GLX_NV_video_capture (GLXEW_CONTEXT_ARG_DEF_INIT)
    11431. 

  11431. {
    11432. 

  11432.   GLboolean r = GL_FALSE;
    11433. 

  11433. 

  11434.   r = ((glXBindVideoCaptureDeviceNV = (PFNGLXBINDVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoCaptureDeviceNV")) == NULL) || r;
    11435. 

  11435.   r = ((glXEnumerateVideoCaptureDevicesNV = (PFNGLXENUMERATEVIDEOCAPTUREDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"glXEnumerateVideoCaptureDevicesNV")) == NULL) || r;
    11436. 

  11436.   r = ((glXLockVideoCaptureDeviceNV = (PFNGLXLOCKVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXLockVideoCaptureDeviceNV")) == NULL) || r;
    11437. 

  11437.   r = ((glXQueryVideoCaptureDeviceNV = (PFNGLXQUERYVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXQueryVideoCaptureDeviceNV")) == NULL) || r;
    11438. 

  11438.   r = ((glXReleaseVideoCaptureDeviceNV = (PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoCaptureDeviceNV")) == NULL) || r;
    11439. 

  11439. 

  11440.   return r;
    11441. 

  11441. }
    11442. 

  11442. 

  11443. #endif /* GLX_NV_video_capture */
    11444. 

  11444. 

  11445. #ifdef GLX_NV_video_output
    11446. 

  11446. 

  11447. static GLboolean _glewInit_GLX_NV_video_output (GLXEW_CONTEXT_ARG_DEF_INIT)
    11448. 

  11448. {
    11449. 

  11449.   GLboolean r = GL_FALSE;
    11450. 

  11450. 

  11451.   r = ((glXBindVideoImageNV = (PFNGLXBINDVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoImageNV")) == NULL) || r;
    11452. 

  11452.   r = ((glXGetVideoDeviceNV = (PFNGLXGETVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoDeviceNV")) == NULL) || r;
    11453. 

  11453.   r = ((glXGetVideoInfoNV = (PFNGLXGETVIDEOINFONVPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoInfoNV")) == NULL) || r;
    11454. 

  11454.   r = ((glXReleaseVideoDeviceNV = (PFNGLXRELEASEVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoDeviceNV")) == NULL) || r;
    11455. 

  11455.   r = ((glXReleaseVideoImageNV = (PFNGLXRELEASEVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoImageNV")) == NULL) || r;
    11456. 

  11456.   r = ((glXSendPbufferToVideoNV = (PFNGLXSENDPBUFFERTOVIDEONVPROC)glewGetProcAddress((const GLubyte*)"glXSendPbufferToVideoNV")) == NULL) || r;
    11457. 

  11457. 

  11458.   return r;
    11459. 

  11459. }
    11460. 

  11460. 

  11461. #endif /* GLX_NV_video_output */
    11462. 

  11462. 

  11463. #ifdef GLX_OML_swap_method
    11464. 

  11464. 

  11465. #endif /* GLX_OML_swap_method */
    11466. 

  11466. 

  11467. #ifdef GLX_OML_sync_control
    11468. 

  11468. 

  11469. static GLboolean _glewInit_GLX_OML_sync_control (GLXEW_CONTEXT_ARG_DEF_INIT)
    11470. 

  11470. {
    11471. 

  11471.   GLboolean r = GL_FALSE;
    11472. 

  11472. 

  11473.   r = ((glXGetMscRateOML = (PFNGLXGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetMscRateOML")) == NULL) || r;
    11474. 

  11474.   r = ((glXGetSyncValuesOML = (PFNGLXGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetSyncValuesOML")) == NULL) || r;
    11475. 

  11475.   r = ((glXSwapBuffersMscOML = (PFNGLXSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXSwapBuffersMscOML")) == NULL) || r;
    11476. 

  11476.   r = ((glXWaitForMscOML = (PFNGLXWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForMscOML")) == NULL) || r;
    11477. 

  11477.   r = ((glXWaitForSbcOML = (PFNGLXWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForSbcOML")) == NULL) || r;
    11478. 

  11478. 

  11479.   return r;
    11480. 

  11480. }
    11481. 

  11481. 

  11482. #endif /* GLX_OML_sync_control */
    11483. 

  11483. 

  11484. #ifdef GLX_SGIS_blended_overlay
    11485. 

  11485. 

  11486. #endif /* GLX_SGIS_blended_overlay */
    11487. 

  11487. 

  11488. #ifdef GLX_SGIS_color_range
    11489. 

  11489. 

  11490. #endif /* GLX_SGIS_color_range */
    11491. 

  11491. 

  11492. #ifdef GLX_SGIS_multisample
    11493. 

  11493. 

  11494. #endif /* GLX_SGIS_multisample */
    11495. 

  11495. 

  11496. #ifdef GLX_SGIS_shared_multisample
    11497. 

  11497. 

  11498. #endif /* GLX_SGIS_shared_multisample */
    11499. 

  11499. 

  11500. #ifdef GLX_SGIX_fbconfig
    11501. 

  11501. 

  11502. static GLboolean _glewInit_GLX_SGIX_fbconfig (GLXEW_CONTEXT_ARG_DEF_INIT)
    11503. 

  11503. {
    11504. 

  11504.   GLboolean r = GL_FALSE;
    11505. 

  11505. 

  11506.   r = ((glXChooseFBConfigSGIX = (PFNGLXCHOOSEFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfigSGIX")) == NULL) || r;
    11507. 

  11507.   r = ((glXCreateContextWithConfigSGIX = (PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateContextWithConfigSGIX")) == NULL) || r;
    11508. 

  11508.   r = ((glXCreateGLXPixmapWithConfigSGIX = (PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapWithConfigSGIX")) == NULL) || r;
    11509. 

  11509.   r = ((glXGetFBConfigAttribSGIX = (PFNGLXGETFBCONFIGATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttribSGIX")) == NULL) || r;
    11510. 

  11510.   r = ((glXGetFBConfigFromVisualSGIX = (PFNGLXGETFBCONFIGFROMVISUALSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigFromVisualSGIX")) == NULL) || r;
    11511. 

  11511.   r = ((glXGetVisualFromFBConfigSGIX = (PFNGLXGETVISUALFROMFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfigSGIX")) == NULL) || r;
    11512. 

  11512. 

  11513.   return r;
    11514. 

  11514. }
    11515. 

  11515. 

  11516. #endif /* GLX_SGIX_fbconfig */
    11517. 

  11517. 

  11518. #ifdef GLX_SGIX_hyperpipe
    11519. 

  11519. 

  11520. static GLboolean _glewInit_GLX_SGIX_hyperpipe (GLXEW_CONTEXT_ARG_DEF_INIT)
    11521. 

  11521. {
    11522. 

  11522.   GLboolean r = GL_FALSE;
    11523. 

  11523. 

  11524.   r = ((glXBindHyperpipeSGIX = (PFNGLXBINDHYPERPIPESGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindHyperpipeSGIX")) == NULL) || r;
    11525. 

  11525.   r = ((glXDestroyHyperpipeConfigSGIX = (PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXDestroyHyperpipeConfigSGIX")) == NULL) || r;
    11526. 

  11526.   r = ((glXHyperpipeAttribSGIX = (PFNGLXHYPERPIPEATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXHyperpipeAttribSGIX")) == NULL) || r;
    11527. 

  11527.   r = ((glXHyperpipeConfigSGIX = (PFNGLXHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXHyperpipeConfigSGIX")) == NULL) || r;
    11528. 

  11528.   r = ((glXQueryHyperpipeAttribSGIX = (PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeAttribSGIX")) == NULL) || r;
    11529. 

  11529.   r = ((glXQueryHyperpipeBestAttribSGIX = (PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeBestAttribSGIX")) == NULL) || r;
    11530. 

  11530.   r = ((glXQueryHyperpipeConfigSGIX = (PFNGLXQUERYHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeConfigSGIX")) == NULL) || r;
    11531. 

  11531.   r = ((glXQueryHyperpipeNetworkSGIX = (PFNGLXQUERYHYPERPIPENETWORKSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeNetworkSGIX")) == NULL) || r;
    11532. 

  11532. 

  11533.   return r;
    11534. 

  11534. }
    11535. 

  11535. 

  11536. #endif /* GLX_SGIX_hyperpipe */
    11537. 

  11537. 

  11538. #ifdef GLX_SGIX_pbuffer
    11539. 

  11539. 

  11540. static GLboolean _glewInit_GLX_SGIX_pbuffer (GLXEW_CONTEXT_ARG_DEF_INIT)
    11541. 

  11541. {
    11542. 

  11542.   GLboolean r = GL_FALSE;
    11543. 

  11543. 

  11544.   r = ((glXCreateGLXPbufferSGIX = (PFNGLXCREATEGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPbufferSGIX")) == NULL) || r;
    11545. 

  11545.   r = ((glXDestroyGLXPbufferSGIX = (PFNGLXDESTROYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXDestroyGLXPbufferSGIX")) == NULL) || r;
    11546. 

  11546.   r = ((glXGetSelectedEventSGIX = (PFNGLXGETSELECTEDEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEventSGIX")) == NULL) || r;
    11547. 

  11547.   r = ((glXQueryGLXPbufferSGIX = (PFNGLXQUERYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryGLXPbufferSGIX")) == NULL) || r;
    11548. 

  11548.   r = ((glXSelectEventSGIX = (PFNGLXSELECTEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXSelectEventSGIX")) == NULL) || r;
    11549. 

  11549. 

  11550.   return r;
    11551. 

  11551. }
    11552. 

  11552. 

  11553. #endif /* GLX_SGIX_pbuffer */
    11554. 

  11554. 

  11555. #ifdef GLX_SGIX_swap_barrier
    11556. 

  11556. 

  11557. static GLboolean _glewInit_GLX_SGIX_swap_barrier (GLXEW_CONTEXT_ARG_DEF_INIT)
    11558. 

  11558. {
    11559. 

  11559.   GLboolean r = GL_FALSE;
    11560. 

  11560. 

  11561.   r = ((glXBindSwapBarrierSGIX = (PFNGLXBINDSWAPBARRIERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindSwapBarrierSGIX")) == NULL) || r;
    11562. 

  11562.   r = ((glXQueryMaxSwapBarriersSGIX = (PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryMaxSwapBarriersSGIX")) == NULL) || r;
    11563. 

  11563. 

  11564.   return r;
    11565. 

  11565. }
    11566. 

  11566. 

  11567. #endif /* GLX_SGIX_swap_barrier */
    11568. 

  11568. 

  11569. #ifdef GLX_SGIX_swap_group
    11570. 

  11570. 

  11571. static GLboolean _glewInit_GLX_SGIX_swap_group (GLXEW_CONTEXT_ARG_DEF_INIT)
    11572. 

  11572. {
    11573. 

  11573.   GLboolean r = GL_FALSE;
    11574. 

  11574. 

  11575.   r = ((glXJoinSwapGroupSGIX = (PFNGLXJOINSWAPGROUPSGIXPROC)glewGetProcAddress((const GLubyte*)"glXJoinSwapGroupSGIX")) == NULL) || r;
    11576. 

  11576. 

  11577.   return r;
    11578. 

  11578. }
    11579. 

  11579. 

  11580. #endif /* GLX_SGIX_swap_group */
    11581. 

  11581. 

  11582. #ifdef GLX_SGIX_video_resize
    11583. 

  11583. 

  11584. static GLboolean _glewInit_GLX_SGIX_video_resize (GLXEW_CONTEXT_ARG_DEF_INIT)
    11585. 

  11585. {
    11586. 

  11586.   GLboolean r = GL_FALSE;
    11587. 

  11587. 

  11588.   r = ((glXBindChannelToWindowSGIX = (PFNGLXBINDCHANNELTOWINDOWSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindChannelToWindowSGIX")) == NULL) || r;
    11589. 

  11589.   r = ((glXChannelRectSGIX = (PFNGLXCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSGIX")) == NULL) || r;
    11590. 

  11590.   r = ((glXChannelRectSyncSGIX = (PFNGLXCHANNELRECTSYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSyncSGIX")) == NULL) || r;
    11591. 

  11591.   r = ((glXQueryChannelDeltasSGIX = (PFNGLXQUERYCHANNELDELTASSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelDeltasSGIX")) == NULL) || r;
    11592. 

  11592.   r = ((glXQueryChannelRectSGIX = (PFNGLXQUERYCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelRectSGIX")) == NULL) || r;
    11593. 

  11593. 

  11594.   return r;
    11595. 

  11595. }
    11596. 

  11596. 

  11597. #endif /* GLX_SGIX_video_resize */
    11598. 

  11598. 

  11599. #ifdef GLX_SGIX_visual_select_group
    11600. 

  11600. 

  11601. #endif /* GLX_SGIX_visual_select_group */
    11602. 

  11602. 

  11603. #ifdef GLX_SGI_cushion
    11604. 

  11604. 

  11605. static GLboolean _glewInit_GLX_SGI_cushion (GLXEW_CONTEXT_ARG_DEF_INIT)
    11606. 

  11606. {
    11607. 

  11607.   GLboolean r = GL_FALSE;
    11608. 

  11608. 

  11609.   r = ((glXCushionSGI = (PFNGLXCUSHIONSGIPROC)glewGetProcAddress((const GLubyte*)"glXCushionSGI")) == NULL) || r;
    11610. 

  11610. 

  11611.   return r;
    11612. 

  11612. }
    11613. 

  11613. 

  11614. #endif /* GLX_SGI_cushion */
    11615. 

  11615. 

  11616. #ifdef GLX_SGI_make_current_read
    11617. 

  11617. 

  11618. static GLboolean _glewInit_GLX_SGI_make_current_read (GLXEW_CONTEXT_ARG_DEF_INIT)
    11619. 

  11619. {
    11620. 

  11620.   GLboolean r = GL_FALSE;
    11621. 

  11621. 

  11622.   r = ((glXGetCurrentReadDrawableSGI = (PFNGLXGETCURRENTREADDRAWABLESGIPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawableSGI")) == NULL) || r;
    11623. 

  11623.   r = ((glXMakeCurrentReadSGI = (PFNGLXMAKECURRENTREADSGIPROC)glewGetProcAddress((const GLubyte*)"glXMakeCurrentReadSGI")) == NULL) || r;
    11624. 

  11624. 

  11625.   return r;
    11626. 

  11626. }
    11627. 

  11627. 

  11628. #endif /* GLX_SGI_make_current_read */
    11629. 

  11629. 

  11630. #ifdef GLX_SGI_swap_control
    11631. 

  11631. 

  11632. static GLboolean _glewInit_GLX_SGI_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT)
    11633. 

  11633. {
    11634. 

  11634.   GLboolean r = GL_FALSE;
    11635. 

  11635. 

  11636.   r = ((glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalSGI")) == NULL) || r;
    11637. 

  11637. 

  11638.   return r;
    11639. 

  11639. }
    11640. 

  11640. 

  11641. #endif /* GLX_SGI_swap_control */
    11642. 

  11642. 

  11643. #ifdef GLX_SGI_video_sync
    11644. 

  11644. 

  11645. static GLboolean _glewInit_GLX_SGI_video_sync (GLXEW_CONTEXT_ARG_DEF_INIT)
    11646. 

  11646. {
    11647. 

  11647.   GLboolean r = GL_FALSE;
    11648. 

  11648. 

  11649.   r = ((glXGetVideoSyncSGI = (PFNGLXGETVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoSyncSGI")) == NULL) || r;
    11650. 

  11650.   r = ((glXWaitVideoSyncSGI = (PFNGLXWAITVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXWaitVideoSyncSGI")) == NULL) || r;
    11651. 

  11651. 

  11652.   return r;
    11653. 

  11653. }
    11654. 

  11654. 

  11655. #endif /* GLX_SGI_video_sync */
    11656. 

  11656. 

  11657. #ifdef GLX_SUN_get_transparent_index
    11658. 

  11658. 

  11659. static GLboolean _glewInit_GLX_SUN_get_transparent_index (GLXEW_CONTEXT_ARG_DEF_INIT)
    11660. 

  11660. {
    11661. 

  11661.   GLboolean r = GL_FALSE;
    11662. 

  11662. 

  11663.   r = ((glXGetTransparentIndexSUN = (PFNGLXGETTRANSPARENTINDEXSUNPROC)glewGetProcAddress((const GLubyte*)"glXGetTransparentIndexSUN")) == NULL) || r;
    11664. 

  11664. 

  11665.   return r;
    11666. 

  11666. }
    11667. 

  11667. 

  11668. #endif /* GLX_SUN_get_transparent_index */
    11669. 

  11669. 

  11670. #ifdef GLX_SUN_video_resize
    11671. 

  11671. 

  11672. static GLboolean _glewInit_GLX_SUN_video_resize (GLXEW_CONTEXT_ARG_DEF_INIT)
    11673. 

  11673. {
    11674. 

  11674.   GLboolean r = GL_FALSE;
    11675. 

  11675. 

  11676.   r = ((glXGetVideoResizeSUN = (PFNGLXGETVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoResizeSUN")) == NULL) || r;
    11677. 

  11677.   r = ((glXVideoResizeSUN = (PFNGLXVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXVideoResizeSUN")) == NULL) || r;
    11678. 

  11678. 

  11679.   return r;
    11680. 

  11680. }
    11681. 

  11681. 

  11682. #endif /* GLX_SUN_video_resize */
    11683. 

  11683. 

  11684. /* ------------------------------------------------------------------------ */
    11685. 

  11685. 

  11686. GLboolean glxewGetExtension (const char* name)
    11687. 

  11687. {    
    11688. 

  11688.   const GLubyte* start;
    11689. 

  11689.   const GLubyte* end;
    11690. 

  11690. 

  11691.   if (glXGetCurrentDisplay == NULL) return GL_FALSE;
    11692. 

  11692.   start = (const GLubyte*)glXGetClientString(glXGetCurrentDisplay(), GLX_EXTENSIONS);
    11693. 

  11693.   if (0 == start) return GL_FALSE;
    11694. 

  11694.   end = start + _glewStrLen(start);
    11695. 

  11695.   return _glewSearchExtension(name, start, end);
    11696. 

  11696. }
    11697. 

  11697. 

  11698. GLenum glxewContextInit (GLXEW_CONTEXT_ARG_DEF_LIST)
    11699. 

  11699. {
    11700. 

  11700.   int major, minor;
    11701. 

  11701.   const GLubyte* extStart;
    11702. 

  11702.   const GLubyte* extEnd;
    11703. 

  11703.   /* initialize core GLX 1.2 */
    11704. 

  11704.   if (_glewInit_GLX_VERSION_1_2(GLEW_CONTEXT_ARG_VAR_INIT)) return GLEW_ERROR_GLX_VERSION_11_ONLY;
    11705. 

  11705.   /* initialize flags */
    11706. 

  11706.   CONST_CAST(GLXEW_VERSION_1_0) = GL_TRUE;
    11707. 

  11707.   CONST_CAST(GLXEW_VERSION_1_1) = GL_TRUE;
    11708. 

  11708.   CONST_CAST(GLXEW_VERSION_1_2) = GL_TRUE;
    11709. 

  11709.   CONST_CAST(GLXEW_VERSION_1_3) = GL_TRUE;
    11710. 

  11710.   CONST_CAST(GLXEW_VERSION_1_4) = GL_TRUE;
    11711. 

  11711.   /* query GLX version */
    11712. 

  11712.   glXQueryVersion(glXGetCurrentDisplay(), &major, &minor);
    11713. 

  11713.   if (major == 1 && minor <= 3)
    11714. 

  11714.   {
    11715. 

  11715.     switch (minor)
    11716. 

  11716.     {
    11717. 

  11717.       case 3:
    11718. 

  11718.       CONST_CAST(GLXEW_VERSION_1_4) = GL_FALSE;
    11719. 

  11719.       break;
    11720. 

  11720.       case 2:
    11721. 

  11721.       CONST_CAST(GLXEW_VERSION_1_4) = GL_FALSE;
    11722. 

  11722.       CONST_CAST(GLXEW_VERSION_1_3) = GL_FALSE;
    11723. 

  11723.       break;
    11724. 

  11724.       default:
    11725. 

  11725.       return GLEW_ERROR_GLX_VERSION_11_ONLY;
    11726. 

  11726.       break;
    11727. 

  11727.     }
    11728. 

  11728.   }
    11729. 

  11729.   /* query GLX extension string */
    11730. 

  11730.   extStart = 0;
    11731. 

  11731.   if (glXGetCurrentDisplay != NULL)
    11732. 

  11732.     extStart = (const GLubyte*)glXGetClientString(glXGetCurrentDisplay(), GLX_EXTENSIONS);
    11733. 

  11733.   if (extStart == 0)
    11734. 

  11734.     extStart = (const GLubyte *)"";
    11735. 

  11735.   extEnd = extStart + _glewStrLen(extStart);
    11736. 

  11736.   /* initialize extensions */
    11737. 

  11737. #ifdef GLX_VERSION_1_3
    11738. 

  11738.   if (glewExperimental || GLXEW_VERSION_1_3) CONST_CAST(GLXEW_VERSION_1_3) = !_glewInit_GLX_VERSION_1_3(GLEW_CONTEXT_ARG_VAR_INIT);
    11739. 

  11739. #endif /* GLX_VERSION_1_3 */
    11740. 

  11740. #ifdef GLX_3DFX_multisample
    11741. 

  11741.   CONST_CAST(GLXEW_3DFX_multisample) = _glewSearchExtension("GLX_3DFX_multisample", extStart, extEnd);
    11742. 

  11742. #endif /* GLX_3DFX_multisample */
    11743. 

  11743. #ifdef GLX_AMD_gpu_association
    11744. 

  11744.   CONST_CAST(GLXEW_AMD_gpu_association) = _glewSearchExtension("GLX_AMD_gpu_association", extStart, extEnd);
    11745. 

  11745. #endif /* GLX_AMD_gpu_association */
    11746. 

  11746. #ifdef GLX_ARB_create_context
    11747. 

  11747.   CONST_CAST(GLXEW_ARB_create_context) = _glewSearchExtension("GLX_ARB_create_context", extStart, extEnd);
    11748. 

  11748.   if (glewExperimental || GLXEW_ARB_create_context) CONST_CAST(GLXEW_ARB_create_context) = !_glewInit_GLX_ARB_create_context(GLEW_CONTEXT_ARG_VAR_INIT);
    11749. 

  11749. #endif /* GLX_ARB_create_context */
    11750. 

  11750. #ifdef GLX_ARB_create_context_profile
    11751. 

  11751.   CONST_CAST(GLXEW_ARB_create_context_profile) = _glewSearchExtension("GLX_ARB_create_context_profile", extStart, extEnd);
    11752. 

  11752. #endif /* GLX_ARB_create_context_profile */
    11753. 

  11753. #ifdef GLX_ARB_create_context_robustness
    11754. 

  11754.   CONST_CAST(GLXEW_ARB_create_context_robustness) = _glewSearchExtension("GLX_ARB_create_context_robustness", extStart, extEnd);
    11755. 

  11755. #endif /* GLX_ARB_create_context_robustness */
    11756. 

  11756. #ifdef GLX_ARB_fbconfig_float
    11757. 

  11757.   CONST_CAST(GLXEW_ARB_fbconfig_float) = _glewSearchExtension("GLX_ARB_fbconfig_float", extStart, extEnd);
    11758. 

  11758. #endif /* GLX_ARB_fbconfig_float */
    11759. 

  11759. #ifdef GLX_ARB_framebuffer_sRGB
    11760. 

  11760.   CONST_CAST(GLXEW_ARB_framebuffer_sRGB) = _glewSearchExtension("GLX_ARB_framebuffer_sRGB", extStart, extEnd);
    11761. 

  11761. #endif /* GLX_ARB_framebuffer_sRGB */
    11762. 

  11762. #ifdef GLX_ARB_get_proc_address
    11763. 

  11763.   CONST_CAST(GLXEW_ARB_get_proc_address) = _glewSearchExtension("GLX_ARB_get_proc_address", extStart, extEnd);
    11764. 

  11764. #endif /* GLX_ARB_get_proc_address */
    11765. 

  11765. #ifdef GLX_ARB_multisample
    11766. 

  11766.   CONST_CAST(GLXEW_ARB_multisample) = _glewSearchExtension("GLX_ARB_multisample", extStart, extEnd);
    11767. 

  11767. #endif /* GLX_ARB_multisample */
    11768. 

  11768. #ifdef GLX_ARB_vertex_buffer_object
    11769. 

  11769.   CONST_CAST(GLXEW_ARB_vertex_buffer_object) = _glewSearchExtension("GLX_ARB_vertex_buffer_object", extStart, extEnd);
    11770. 

  11770. #endif /* GLX_ARB_vertex_buffer_object */
    11771. 

  11771. #ifdef GLX_ATI_pixel_format_float
    11772. 

  11772.   CONST_CAST(GLXEW_ATI_pixel_format_float) = _glewSearchExtension("GLX_ATI_pixel_format_float", extStart, extEnd);
    11773. 

  11773. #endif /* GLX_ATI_pixel_format_float */
    11774. 

  11774. #ifdef GLX_ATI_render_texture
    11775. 

  11775.   CONST_CAST(GLXEW_ATI_render_texture) = _glewSearchExtension("GLX_ATI_render_texture", extStart, extEnd);
    11776. 

  11776.   if (glewExperimental || GLXEW_ATI_render_texture) CONST_CAST(GLXEW_ATI_render_texture) = !_glewInit_GLX_ATI_render_texture(GLEW_CONTEXT_ARG_VAR_INIT);
    11777. 

  11777. #endif /* GLX_ATI_render_texture */
    11778. 

  11778. #ifdef GLX_EXT_create_context_es2_profile
    11779. 

  11779.   CONST_CAST(GLXEW_EXT_create_context_es2_profile) = _glewSearchExtension("GLX_EXT_create_context_es2_profile", extStart, extEnd);
    11780. 

  11780. #endif /* GLX_EXT_create_context_es2_profile */
    11781. 

  11781. #ifdef GLX_EXT_fbconfig_packed_float
    11782. 

  11782.   CONST_CAST(GLXEW_EXT_fbconfig_packed_float) = _glewSearchExtension("GLX_EXT_fbconfig_packed_float", extStart, extEnd);
    11783. 

  11783. #endif /* GLX_EXT_fbconfig_packed_float */
    11784. 

  11784. #ifdef GLX_EXT_framebuffer_sRGB
    11785. 

  11785.   CONST_CAST(GLXEW_EXT_framebuffer_sRGB) = _glewSearchExtension("GLX_EXT_framebuffer_sRGB", extStart, extEnd);
    11786. 

  11786. #endif /* GLX_EXT_framebuffer_sRGB */
    11787. 

  11787. #ifdef GLX_EXT_import_context
    11788. 

  11788.   CONST_CAST(GLXEW_EXT_import_context) = _glewSearchExtension("GLX_EXT_import_context", extStart, extEnd);
    11789. 

  11789.   if (glewExperimental || GLXEW_EXT_import_context) CONST_CAST(GLXEW_EXT_import_context) = !_glewInit_GLX_EXT_import_context(GLEW_CONTEXT_ARG_VAR_INIT);
    11790. 

  11790. #endif /* GLX_EXT_import_context */
    11791. 

  11791. #ifdef GLX_EXT_scene_marker
    11792. 

  11792.   CONST_CAST(GLXEW_EXT_scene_marker) = _glewSearchExtension("GLX_EXT_scene_marker", extStart, extEnd);
    11793. 

  11793. #endif /* GLX_EXT_scene_marker */
    11794. 

  11794. #ifdef GLX_EXT_swap_control
    11795. 

  11795.   CONST_CAST(GLXEW_EXT_swap_control) = _glewSearchExtension("GLX_EXT_swap_control", extStart, extEnd);
    11796. 

  11796.   if (glewExperimental || GLXEW_EXT_swap_control) CONST_CAST(GLXEW_EXT_swap_control) = !_glewInit_GLX_EXT_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);
    11797. 

  11797. #endif /* GLX_EXT_swap_control */
    11798. 

  11798. #ifdef GLX_EXT_texture_from_pixmap
    11799. 

  11799.   CONST_CAST(GLXEW_EXT_texture_from_pixmap) = _glewSearchExtension("GLX_EXT_texture_from_pixmap", extStart, extEnd);
    11800. 

  11800.   if (glewExperimental || GLXEW_EXT_texture_from_pixmap) CONST_CAST(GLXEW_EXT_texture_from_pixmap) = !_glewInit_GLX_EXT_texture_from_pixmap(GLEW_CONTEXT_ARG_VAR_INIT);
    11801. 

  11801. #endif /* GLX_EXT_texture_from_pixmap */
    11802. 

  11802. #ifdef GLX_EXT_visual_info
    11803. 

  11803.   CONST_CAST(GLXEW_EXT_visual_info) = _glewSearchExtension("GLX_EXT_visual_info", extStart, extEnd);
    11804. 

  11804. #endif /* GLX_EXT_visual_info */
    11805. 

  11805. #ifdef GLX_EXT_visual_rating
    11806. 

  11806.   CONST_CAST(GLXEW_EXT_visual_rating) = _glewSearchExtension("GLX_EXT_visual_rating", extStart, extEnd);
    11807. 

  11807. #endif /* GLX_EXT_visual_rating */
    11808. 

  11808. #ifdef GLX_INTEL_swap_event
    11809. 

  11809.   CONST_CAST(GLXEW_INTEL_swap_event) = _glewSearchExtension("GLX_INTEL_swap_event", extStart, extEnd);
    11810. 

  11810. #endif /* GLX_INTEL_swap_event */
    11811. 

  11811. #ifdef GLX_MESA_agp_offset
    11812. 

  11812.   CONST_CAST(GLXEW_MESA_agp_offset) = _glewSearchExtension("GLX_MESA_agp_offset", extStart, extEnd);
    11813. 

  11813.   if (glewExperimental || GLXEW_MESA_agp_offset) CONST_CAST(GLXEW_MESA_agp_offset) = !_glewInit_GLX_MESA_agp_offset(GLEW_CONTEXT_ARG_VAR_INIT);
    11814. 

  11814. #endif /* GLX_MESA_agp_offset */
    11815. 

  11815. #ifdef GLX_MESA_copy_sub_buffer
    11816. 

  11816.   CONST_CAST(GLXEW_MESA_copy_sub_buffer) = _glewSearchExtension("GLX_MESA_copy_sub_buffer", extStart, extEnd);
    11817. 

  11817.   if (glewExperimental || GLXEW_MESA_copy_sub_buffer) CONST_CAST(GLXEW_MESA_copy_sub_buffer) = !_glewInit_GLX_MESA_copy_sub_buffer(GLEW_CONTEXT_ARG_VAR_INIT);
    11818. 

  11818. #endif /* GLX_MESA_copy_sub_buffer */
    11819. 

  11819. #ifdef GLX_MESA_pixmap_colormap
    11820. 

  11820.   CONST_CAST(GLXEW_MESA_pixmap_colormap) = _glewSearchExtension("GLX_MESA_pixmap_colormap", extStart, extEnd);
    11821. 

  11821.   if (glewExperimental || GLXEW_MESA_pixmap_colormap) CONST_CAST(GLXEW_MESA_pixmap_colormap) = !_glewInit_GLX_MESA_pixmap_colormap(GLEW_CONTEXT_ARG_VAR_INIT);
    11822. 

  11822. #endif /* GLX_MESA_pixmap_colormap */
    11823. 

  11823. #ifdef GLX_MESA_release_buffers
    11824. 

  11824.   CONST_CAST(GLXEW_MESA_release_buffers) = _glewSearchExtension("GLX_MESA_release_buffers", extStart, extEnd);
    11825. 

  11825.   if (glewExperimental || GLXEW_MESA_release_buffers) CONST_CAST(GLXEW_MESA_release_buffers) = !_glewInit_GLX_MESA_release_buffers(GLEW_CONTEXT_ARG_VAR_INIT);
    11826. 

  11826. #endif /* GLX_MESA_release_buffers */
    11827. 

  11827. #ifdef GLX_MESA_set_3dfx_mode
    11828. 

  11828.   CONST_CAST(GLXEW_MESA_set_3dfx_mode) = _glewSearchExtension("GLX_MESA_set_3dfx_mode", extStart, extEnd);
    11829. 

  11829.   if (glewExperimental || GLXEW_MESA_set_3dfx_mode) CONST_CAST(GLXEW_MESA_set_3dfx_mode) = !_glewInit_GLX_MESA_set_3dfx_mode(GLEW_CONTEXT_ARG_VAR_INIT);
    11830. 

  11830. #endif /* GLX_MESA_set_3dfx_mode */
    11831. 

  11831. #ifdef GLX_MESA_swap_control
    11832. 

  11832.   CONST_CAST(GLXEW_MESA_swap_control) = _glewSearchExtension("GLX_MESA_swap_control", extStart, extEnd);
    11833. 

  11833.   if (glewExperimental || GLXEW_MESA_swap_control) CONST_CAST(GLXEW_MESA_swap_control) = !_glewInit_GLX_MESA_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);
    11834. 

  11834. #endif /* GLX_MESA_swap_control */
    11835. 

  11835. #ifdef GLX_NV_copy_image
    11836. 

  11836.   CONST_CAST(GLXEW_NV_copy_image) = _glewSearchExtension("GLX_NV_copy_image", extStart, extEnd);
    11837. 

  11837.   if (glewExperimental || GLXEW_NV_copy_image) CONST_CAST(GLXEW_NV_copy_image) = !_glewInit_GLX_NV_copy_image(GLEW_CONTEXT_ARG_VAR_INIT);
    11838. 

  11838. #endif /* GLX_NV_copy_image */
    11839. 

  11839. #ifdef GLX_NV_float_buffer
    11840. 

  11840.   CONST_CAST(GLXEW_NV_float_buffer) = _glewSearchExtension("GLX_NV_float_buffer", extStart, extEnd);
    11841. 

  11841. #endif /* GLX_NV_float_buffer */
    11842. 

  11842. #ifdef GLX_NV_multisample_coverage
    11843. 

  11843.   CONST_CAST(GLXEW_NV_multisample_coverage) = _glewSearchExtension("GLX_NV_multisample_coverage", extStart, extEnd);
    11844. 

  11844. #endif /* GLX_NV_multisample_coverage */
    11845. 

  11845. #ifdef GLX_NV_present_video
    11846. 

  11846.   CONST_CAST(GLXEW_NV_present_video) = _glewSearchExtension("GLX_NV_present_video", extStart, extEnd);
    11847. 

  11847.   if (glewExperimental || GLXEW_NV_present_video) CONST_CAST(GLXEW_NV_present_video) = !_glewInit_GLX_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT);
    11848. 

  11848. #endif /* GLX_NV_present_video */
    11849. 

  11849. #ifdef GLX_NV_swap_group
    11850. 

  11850.   CONST_CAST(GLXEW_NV_swap_group) = _glewSearchExtension("GLX_NV_swap_group", extStart, extEnd);
    11851. 

  11851.   if (glewExperimental || GLXEW_NV_swap_group) CONST_CAST(GLXEW_NV_swap_group) = !_glewInit_GLX_NV_swap_group(GLEW_CONTEXT_ARG_VAR_INIT);
    11852. 

  11852. #endif /* GLX_NV_swap_group */
    11853. 

  11853. #ifdef GLX_NV_vertex_array_range
    11854. 

  11854.   CONST_CAST(GLXEW_NV_vertex_array_range) = _glewSearchExtension("GLX_NV_vertex_array_range", extStart, extEnd);
    11855. 

  11855.   if (glewExperimental || GLXEW_NV_vertex_array_range) CONST_CAST(GLXEW_NV_vertex_array_range) = !_glewInit_GLX_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT);
    11856. 

  11856. #endif /* GLX_NV_vertex_array_range */
    11857. 

  11857. #ifdef GLX_NV_video_capture
    11858. 

  11858.   CONST_CAST(GLXEW_NV_video_capture) = _glewSearchExtension("GLX_NV_video_capture", extStart, extEnd);
    11859. 

  11859.   if (glewExperimental || GLXEW_NV_video_capture) CONST_CAST(GLXEW_NV_video_capture) = !_glewInit_GLX_NV_video_capture(GLEW_CONTEXT_ARG_VAR_INIT);
    11860. 

  11860. #endif /* GLX_NV_video_capture */
    11861. 

  11861. #ifdef GLX_NV_video_output
    11862. 

  11862.   CONST_CAST(GLXEW_NV_video_output) = _glewSearchExtension("GLX_NV_video_output", extStart, extEnd);
    11863. 

  11863.   if (glewExperimental || GLXEW_NV_video_output) CONST_CAST(GLXEW_NV_video_output) = !_glewInit_GLX_NV_video_output(GLEW_CONTEXT_ARG_VAR_INIT);
    11864. 

  11864. #endif /* GLX_NV_video_output */
    11865. 

  11865. #ifdef GLX_OML_swap_method
    11866. 

  11866.   CONST_CAST(GLXEW_OML_swap_method) = _glewSearchExtension("GLX_OML_swap_method", extStart, extEnd);
    11867. 

  11867. #endif /* GLX_OML_swap_method */
    11868. 

  11868. #ifdef GLX_OML_sync_control
    11869. 

  11869.   CONST_CAST(GLXEW_OML_sync_control) = _glewSearchExtension("GLX_OML_sync_control", extStart, extEnd);
    11870. 

  11870.   if (glewExperimental || GLXEW_OML_sync_control) CONST_CAST(GLXEW_OML_sync_control) = !_glewInit_GLX_OML_sync_control(GLEW_CONTEXT_ARG_VAR_INIT);
    11871. 

  11871. #endif /* GLX_OML_sync_control */
    11872. 

  11872. #ifdef GLX_SGIS_blended_overlay
    11873. 

  11873.   CONST_CAST(GLXEW_SGIS_blended_overlay) = _glewSearchExtension("GLX_SGIS_blended_overlay", extStart, extEnd);
    11874. 

  11874. #endif /* GLX_SGIS_blended_overlay */
    11875. 

  11875. #ifdef GLX_SGIS_color_range
    11876. 

  11876.   CONST_CAST(GLXEW_SGIS_color_range) = _glewSearchExtension("GLX_SGIS_color_range", extStart, extEnd);
    11877. 

  11877. #endif /* GLX_SGIS_color_range */
    11878. 

  11878. #ifdef GLX_SGIS_multisample
    11879. 

  11879.   CONST_CAST(GLXEW_SGIS_multisample) = _glewSearchExtension("GLX_SGIS_multisample", extStart, extEnd);
    11880. 

  11880. #endif /* GLX_SGIS_multisample */
    11881. 

  11881. #ifdef GLX_SGIS_shared_multisample
    11882. 

  11882.   CONST_CAST(GLXEW_SGIS_shared_multisample) = _glewSearchExtension("GLX_SGIS_shared_multisample", extStart, extEnd);
    11883. 

  11883. #endif /* GLX_SGIS_shared_multisample */
    11884. 

  11884. #ifdef GLX_SGIX_fbconfig
    11885. 

  11885.   CONST_CAST(GLXEW_SGIX_fbconfig) = _glewSearchExtension("GLX_SGIX_fbconfig", extStart, extEnd);
    11886. 

  11886.   if (glewExperimental || GLXEW_SGIX_fbconfig) CONST_CAST(GLXEW_SGIX_fbconfig) = !_glewInit_GLX_SGIX_fbconfig(GLEW_CONTEXT_ARG_VAR_INIT);
    11887. 

  11887. #endif /* GLX_SGIX_fbconfig */
    11888. 

  11888. #ifdef GLX_SGIX_hyperpipe
    11889. 

  11889.   CONST_CAST(GLXEW_SGIX_hyperpipe) = _glewSearchExtension("GLX_SGIX_hyperpipe", extStart, extEnd);
    11890. 

  11890.   if (glewExperimental || GLXEW_SGIX_hyperpipe) CONST_CAST(GLXEW_SGIX_hyperpipe) = !_glewInit_GLX_SGIX_hyperpipe(GLEW_CONTEXT_ARG_VAR_INIT);
    11891. 

  11891. #endif /* GLX_SGIX_hyperpipe */
    11892. 

  11892. #ifdef GLX_SGIX_pbuffer
    11893. 

  11893.   CONST_CAST(GLXEW_SGIX_pbuffer) = _glewSearchExtension("GLX_SGIX_pbuffer", extStart, extEnd);
    11894. 

  11894.   if (glewExperimental || GLXEW_SGIX_pbuffer) CONST_CAST(GLXEW_SGIX_pbuffer) = !_glewInit_GLX_SGIX_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT);
    11895. 

  11895. #endif /* GLX_SGIX_pbuffer */
    11896. 

  11896. #ifdef GLX_SGIX_swap_barrier
    11897. 

  11897.   CONST_CAST(GLXEW_SGIX_swap_barrier) = _glewSearchExtension("GLX_SGIX_swap_barrier", extStart, extEnd);
    11898. 

  11898.   if (glewExperimental || GLXEW_SGIX_swap_barrier) CONST_CAST(GLXEW_SGIX_swap_barrier) = !_glewInit_GLX_SGIX_swap_barrier(GLEW_CONTEXT_ARG_VAR_INIT);
    11899. 

  11899. #endif /* GLX_SGIX_swap_barrier */
    11900. 

  11900. #ifdef GLX_SGIX_swap_group
    11901. 

  11901.   CONST_CAST(GLXEW_SGIX_swap_group) = _glewSearchExtension("GLX_SGIX_swap_group", extStart, extEnd);
    11902. 

  11902.   if (glewExperimental || GLXEW_SGIX_swap_group) CONST_CAST(GLXEW_SGIX_swap_group) = !_glewInit_GLX_SGIX_swap_group(GLEW_CONTEXT_ARG_VAR_INIT);
    11903. 

  11903. #endif /* GLX_SGIX_swap_group */
    11904. 

  11904. #ifdef GLX_SGIX_video_resize
    11905. 

  11905.   CONST_CAST(GLXEW_SGIX_video_resize) = _glewSearchExtension("GLX_SGIX_video_resize", extStart, extEnd);
    11906. 

  11906.   if (glewExperimental || GLXEW_SGIX_video_resize) CONST_CAST(GLXEW_SGIX_video_resize) = !_glewInit_GLX_SGIX_video_resize(GLEW_CONTEXT_ARG_VAR_INIT);
    11907. 

  11907. #endif /* GLX_SGIX_video_resize */
    11908. 

  11908. #ifdef GLX_SGIX_visual_select_group
    11909. 

  11909.   CONST_CAST(GLXEW_SGIX_visual_select_group) = _glewSearchExtension("GLX_SGIX_visual_select_group", extStart, extEnd);
    11910. 

  11910. #endif /* GLX_SGIX_visual_select_group */
    11911. 

  11911. #ifdef GLX_SGI_cushion
    11912. 

  11912.   CONST_CAST(GLXEW_SGI_cushion) = _glewSearchExtension("GLX_SGI_cushion", extStart, extEnd);
    11913. 

  11913.   if (glewExperimental || GLXEW_SGI_cushion) CONST_CAST(GLXEW_SGI_cushion) = !_glewInit_GLX_SGI_cushion(GLEW_CONTEXT_ARG_VAR_INIT);
    11914. 

  11914. #endif /* GLX_SGI_cushion */
    11915. 

  11915. #ifdef GLX_SGI_make_current_read
    11916. 

  11916.   CONST_CAST(GLXEW_SGI_make_current_read) = _glewSearchExtension("GLX_SGI_make_current_read", extStart, extEnd);
    11917. 

  11917.   if (glewExperimental || GLXEW_SGI_make_current_read) CONST_CAST(GLXEW_SGI_make_current_read) = !_glewInit_GLX_SGI_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT);
    11918. 

  11918. #endif /* GLX_SGI_make_current_read */
    11919. 

  11919. #ifdef GLX_SGI_swap_control
    11920. 

  11920.   CONST_CAST(GLXEW_SGI_swap_control) = _glewSearchExtension("GLX_SGI_swap_control", extStart, extEnd);
    11921. 

  11921.   if (glewExperimental || GLXEW_SGI_swap_control) CONST_CAST(GLXEW_SGI_swap_control) = !_glewInit_GLX_SGI_swap_control(GLEW_CONTEXT_ARG_VAR_INIT);
    11922. 

  11922. #endif /* GLX_SGI_swap_control */
    11923. 

  11923. #ifdef GLX_SGI_video_sync
    11924. 

  11924.   CONST_CAST(GLXEW_SGI_video_sync) = _glewSearchExtension("GLX_SGI_video_sync", extStart, extEnd);
    11925. 

  11925.   if (glewExperimental || GLXEW_SGI_video_sync) CONST_CAST(GLXEW_SGI_video_sync) = !_glewInit_GLX_SGI_video_sync(GLEW_CONTEXT_ARG_VAR_INIT);
    11926. 

  11926. #endif /* GLX_SGI_video_sync */
    11927. 

  11927. #ifdef GLX_SUN_get_transparent_index
    11928. 

  11928.   CONST_CAST(GLXEW_SUN_get_transparent_index) = _glewSearchExtension("GLX_SUN_get_transparent_index", extStart, extEnd);
    11929. 

  11929.   if (glewExperimental || GLXEW_SUN_get_transparent_index) CONST_CAST(GLXEW_SUN_get_transparent_index) = !_glewInit_GLX_SUN_get_transparent_index(GLEW_CONTEXT_ARG_VAR_INIT);
    11930. 

  11930. #endif /* GLX_SUN_get_transparent_index */
    11931. 

  11931. #ifdef GLX_SUN_video_resize
    11932. 

  11932.   CONST_CAST(GLXEW_SUN_video_resize) = _glewSearchExtension("GLX_SUN_video_resize", extStart, extEnd);
    11933. 

  11933.   if (glewExperimental || GLXEW_SUN_video_resize) CONST_CAST(GLXEW_SUN_video_resize) = !_glewInit_GLX_SUN_video_resize(GLEW_CONTEXT_ARG_VAR_INIT);
    11934. 

  11934. #endif /* GLX_SUN_video_resize */
    11935. 

  11935. 

  11936.   return GLEW_OK;
    11937. 

  11937. }
    11938. 

  11938. 

  11939. #endif /* !__APPLE__ || GLEW_APPLE_GLX */
    11940. 

  11940. 

  11941. /* ------------------------------------------------------------------------ */
    11942. 

  11942. 

  11943. const GLubyte* glewGetErrorString (GLenum error)
    11944. 

  11944. {
    11945. 

  11945.   static const GLubyte* _glewErrorString[] =
    11946. 

  11946.   {
    11947. 

  11947.     (const GLubyte*)"No error",
    11948. 

  11948.     (const GLubyte*)"Missing GL version",
    11949. 

  11949.     (const GLubyte*)"GL 1.1 and up are not supported",
    11950. 

  11950.     (const GLubyte*)"GLX 1.2 and up are not supported",
    11951. 

  11951.     (const GLubyte*)"Unknown error"
    11952. 

  11952.   };
    11953. 

  11953.   const int max_error = sizeof(_glewErrorString)/sizeof(*_glewErrorString) - 1;
    11954. 

  11954.   return _glewErrorString[(int)error > max_error ? max_error : (int)error];
    11955. 

  11955. }
    11956. 

  11956. 

  11957. const GLubyte* glewGetString (GLenum name)
    11958. 

  11958. {
    11959. 

  11959.   static const GLubyte* _glewString[] =
    11960. 

  11960.   {
    11961. 

  11961.     (const GLubyte*)NULL,
    11962. 

  11962.     (const GLubyte*)"1.7.0",
    11963. 

  11963.     (const GLubyte*)"1",
    11964. 

  11964.     (const GLubyte*)"7",
    11965. 

  11965.     (const GLubyte*)"0"
    11966. 

  11966.   };
    11967. 

  11967.   const int max_string = sizeof(_glewString)/sizeof(*_glewString) - 1;
    11968. 

  11968.   return _glewString[(int)name > max_string ? 0 : (int)name];
    11969. 

  11969. }
    11970. 

  11970. 

  11971. /* ------------------------------------------------------------------------ */
    11972. 

  11972. 

  11973. GLboolean glewExperimental = GL_FALSE;
    11974. 

  11974. 

  11975. #if !defined(GLEW_MX)
    11976. 

  11976. 

  11977. #if defined(_WIN32)
    11978. 

  11978. extern GLenum wglewContextInit (void);
    11979. 

  11979. #elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) /* _UNIX */
    11980. 

  11980. extern GLenum glxewContextInit (void);
    11981. 

  11981. #endif /* _WIN32 */
    11982. 

  11982. 

  11983. // SJS
    11984. 

  11984. //GLenum glewInit ()
    11985. 

  11985. //{
    11986. 

  11986. //  GLenum r;
    11987. 

  11987. //  if ( (r = glewContextInit()) ) return r;
    11988. 

  11988. //#if defined(_WIN32)
    11989. 

  11989. //  return wglewContextInit();
    11990. 

  11990. //#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) /* _UNIX */
    11991. 

  11991. //  return glxewContextInit();
    11992. 

  11992. //#else
    11993. 

  11993. //  return r;
    11994. 

  11994. //#endif /* _WIN32 */
    11995. 

  11995. //}
    11996. 

  11996. // End SJS
    11997. 

  11997. 

  11998. #endif /* !GLEW_MX */
    11999. 

  11999. #ifdef GLEW_MX
    12000. 

  12000. GLboolean glewContextIsSupported (const GLEWContext* ctx, const char* name)
    12001. 

  12001. #else
    12002. 

  12002. GLboolean glewIsSupported (const char* name)
    12003. 

  12003. #endif
    12004. 

  12004. {
    12005. 

  12005.   GLubyte* pos = (GLubyte*)name;
    12006. 

  12006.   GLuint len = _glewStrLen(pos);
    12007. 

  12007.   GLboolean ret = GL_TRUE;
    12008. 

  12008.   while (ret && len > 0)
    12009. 

  12009.   {
    12010. 

  12010.     if (_glewStrSame1(&pos, &len, (const GLubyte*)"GL_", 3))
    12011. 

  12011.     {
    12012. 

  12012.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8))
    12013. 

  12013.       {
    12014. 

  12014. #ifdef GL_VERSION_1_2
    12015. 

  12015.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3))
    12016. 

  12016.         {
    12017. 

  12017.           ret = GLEW_VERSION_1_2;
    12018. 

  12018.           continue;
    12019. 

  12019.         }
    12020. 

  12020. #endif
    12021. 

  12021. #ifdef GL_VERSION_1_2_1
    12022. 

  12022.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2_1", 5))
    12023. 

  12023.         {
    12024. 

  12024.           ret = GLEW_VERSION_1_2_1;
    12025. 

  12025.           continue;
    12026. 

  12026.         }
    12027. 

  12027. #endif
    12028. 

  12028. #ifdef GL_VERSION_1_3
    12029. 

  12029.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3))
    12030. 

  12030.         {
    12031. 

  12031.           ret = GLEW_VERSION_1_3;
    12032. 

  12032.           continue;
    12033. 

  12033.         }
    12034. 

  12034. #endif
    12035. 

  12035. #ifdef GL_VERSION_1_4
    12036. 

  12036.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3))
    12037. 

  12037.         {
    12038. 

  12038.           ret = GLEW_VERSION_1_4;
    12039. 

  12039.           continue;
    12040. 

  12040.         }
    12041. 

  12041. #endif
    12042. 

  12042. #ifdef GL_VERSION_1_5
    12043. 

  12043.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_5", 3))
    12044. 

  12044.         {
    12045. 

  12045.           ret = GLEW_VERSION_1_5;
    12046. 

  12046.           continue;
    12047. 

  12047.         }
    12048. 

  12048. #endif
    12049. 

  12049. #ifdef GL_VERSION_2_0
    12050. 

  12050.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_0", 3))
    12051. 

  12051.         {
    12052. 

  12052.           ret = GLEW_VERSION_2_0;
    12053. 

  12053.           continue;
    12054. 

  12054.         }
    12055. 

  12055. #endif
    12056. 

  12056. #ifdef GL_VERSION_2_1
    12057. 

  12057.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_1", 3))
    12058. 

  12058.         {
    12059. 

  12059.           ret = GLEW_VERSION_2_1;
    12060. 

  12060.           continue;
    12061. 

  12061.         }
    12062. 

  12062. #endif
    12063. 

  12063. #ifdef GL_VERSION_3_0
    12064. 

  12064.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_0", 3))
    12065. 

  12065.         {
    12066. 

  12066.           ret = GLEW_VERSION_3_0;
    12067. 

  12067.           continue;
    12068. 

  12068.         }
    12069. 

  12069. #endif
    12070. 

  12070. #ifdef GL_VERSION_3_1
    12071. 

  12071.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_1", 3))
    12072. 

  12072.         {
    12073. 

  12073.           ret = GLEW_VERSION_3_1;
    12074. 

  12074.           continue;
    12075. 

  12075.         }
    12076. 

  12076. #endif
    12077. 

  12077. #ifdef GL_VERSION_3_2
    12078. 

  12078.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_2", 3))
    12079. 

  12079.         {
    12080. 

  12080.           ret = GLEW_VERSION_3_2;
    12081. 

  12081.           continue;
    12082. 

  12082.         }
    12083. 

  12083. #endif
    12084. 

  12084. #ifdef GL_VERSION_3_3
    12085. 

  12085.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_3", 3))
    12086. 

  12086.         {
    12087. 

  12087.           ret = GLEW_VERSION_3_3;
    12088. 

  12088.           continue;
    12089. 

  12089.         }
    12090. 

  12090. #endif
    12091. 

  12091. #ifdef GL_VERSION_4_0
    12092. 

  12092.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_0", 3))
    12093. 

  12093.         {
    12094. 

  12094.           ret = GLEW_VERSION_4_0;
    12095. 

  12095.           continue;
    12096. 

  12096.         }
    12097. 

  12097. #endif
    12098. 

  12098. #ifdef GL_VERSION_4_1
    12099. 

  12099.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_1", 3))
    12100. 

  12100.         {
    12101. 

  12101.           ret = GLEW_VERSION_4_1;
    12102. 

  12102.           continue;
    12103. 

  12103.         }
    12104. 

  12104. #endif
    12105. 

  12105. #ifdef GL_VERSION_4_2
    12106. 

  12106.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_2", 3))
    12107. 

  12107.         {
    12108. 

  12108.           ret = GLEW_VERSION_4_2;
    12109. 

  12109.           continue;
    12110. 

  12110.         }
    12111. 

  12111. #endif
    12112. 

  12112.       }
    12113. 

  12113.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))
    12114. 

  12114.       {
    12115. 

  12115. #ifdef GL_3DFX_multisample
    12116. 

  12116.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
    12117. 

  12117.         {
    12118. 

  12118.           ret = GLEW_3DFX_multisample;
    12119. 

  12119.           continue;
    12120. 

  12120.         }
    12121. 

  12121. #endif
    12122. 

  12122. #ifdef GL_3DFX_tbuffer
    12123. 

  12123.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"tbuffer", 7))
    12124. 

  12124.         {
    12125. 

  12125.           ret = GLEW_3DFX_tbuffer;
    12126. 

  12126.           continue;
    12127. 

  12127.         }
    12128. 

  12128. #endif
    12129. 

  12129. #ifdef GL_3DFX_texture_compression_FXT1
    12130. 

  12130.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_FXT1", 24))
    12131. 

  12131.         {
    12132. 

  12132.           ret = GLEW_3DFX_texture_compression_FXT1;
    12133. 

  12133.           continue;
    12134. 

  12134.         }
    12135. 

  12135. #endif
    12136. 

  12136.       }
    12137. 

  12137.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4))
    12138. 

  12138.       {
    12139. 

  12139. #ifdef GL_AMD_blend_minmax_factor
    12140. 

  12140.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_minmax_factor", 19))
    12141. 

  12141.         {
    12142. 

  12142.           ret = GLEW_AMD_blend_minmax_factor;
    12143. 

  12143.           continue;
    12144. 

  12144.         }
    12145. 

  12145. #endif
    12146. 

  12146. #ifdef GL_AMD_conservative_depth
    12147. 

  12147.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_depth", 18))
    12148. 

  12148.         {
    12149. 

  12149.           ret = GLEW_AMD_conservative_depth;
    12150. 

  12150.           continue;
    12151. 

  12151.         }
    12152. 

  12152. #endif
    12153. 

  12153. #ifdef GL_AMD_debug_output
    12154. 

  12154.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug_output", 12))
    12155. 

  12155.         {
    12156. 

  12156.           ret = GLEW_AMD_debug_output;
    12157. 

  12157.           continue;
    12158. 

  12158.         }
    12159. 

  12159. #endif
    12160. 

  12160. #ifdef GL_AMD_depth_clamp_separate
    12161. 

  12161.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp_separate", 20))
    12162. 

  12162.         {
    12163. 

  12163.           ret = GLEW_AMD_depth_clamp_separate;
    12164. 

  12164.           continue;
    12165. 

  12165.         }
    12166. 

  12166. #endif
    12167. 

  12167. #ifdef GL_AMD_draw_buffers_blend
    12168. 

  12168.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers_blend", 18))
    12169. 

  12169.         {
    12170. 

  12170.           ret = GLEW_AMD_draw_buffers_blend;
    12171. 

  12171.           continue;
    12172. 

  12172.         }
    12173. 

  12173. #endif
    12174. 

  12174. #ifdef GL_AMD_multi_draw_indirect
    12175. 

  12175.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_indirect", 19))
    12176. 

  12176.         {
    12177. 

  12177.           ret = GLEW_AMD_multi_draw_indirect;
    12178. 

  12178.           continue;
    12179. 

  12179.         }
    12180. 

  12180. #endif
    12181. 

  12181. #ifdef GL_AMD_name_gen_delete
    12182. 

  12182.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"name_gen_delete", 15))
    12183. 

  12183.         {
    12184. 

  12184.           ret = GLEW_AMD_name_gen_delete;
    12185. 

  12185.           continue;
    12186. 

  12186.         }
    12187. 

  12187. #endif
    12188. 

  12188. #ifdef GL_AMD_performance_monitor
    12189. 

  12189.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"performance_monitor", 19))
    12190. 

  12190.         {
    12191. 

  12191.           ret = GLEW_AMD_performance_monitor;
    12192. 

  12192.           continue;
    12193. 

  12193.         }
    12194. 

  12194. #endif
    12195. 

  12195. #ifdef GL_AMD_sample_positions
    12196. 

  12196.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_positions", 16))
    12197. 

  12197.         {
    12198. 

  12198.           ret = GLEW_AMD_sample_positions;
    12199. 

  12199.           continue;
    12200. 

  12200.         }
    12201. 

  12201. #endif
    12202. 

  12202. #ifdef GL_AMD_seamless_cubemap_per_texture
    12203. 

  12203.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"seamless_cubemap_per_texture", 28))
    12204. 

  12204.         {
    12205. 

  12205.           ret = GLEW_AMD_seamless_cubemap_per_texture;
    12206. 

  12206.           continue;
    12207. 

  12207.         }
    12208. 

  12208. #endif
    12209. 

  12209. #ifdef GL_AMD_shader_stencil_export
    12210. 

  12210.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_stencil_export", 21))
    12211. 

  12211.         {
    12212. 

  12212.           ret = GLEW_AMD_shader_stencil_export;
    12213. 

  12213.           continue;
    12214. 

  12214.         }
    12215. 

  12215. #endif
    12216. 

  12216. #ifdef GL_AMD_texture_texture4
    12217. 

  12217.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_texture4", 16))
    12218. 

  12218.         {
    12219. 

  12219.           ret = GLEW_AMD_texture_texture4;
    12220. 

  12220.           continue;
    12221. 

  12221.         }
    12222. 

  12222. #endif
    12223. 

  12223. #ifdef GL_AMD_transform_feedback3_lines_triangles
    12224. 

  12224.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback3_lines_triangles", 35))
    12225. 

  12225.         {
    12226. 

  12226.           ret = GLEW_AMD_transform_feedback3_lines_triangles;
    12227. 

  12227.           continue;
    12228. 

  12228.         }
    12229. 

  12229. #endif
    12230. 

  12230. #ifdef GL_AMD_vertex_shader_tessellator
    12231. 

  12231.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_tessellator", 25))
    12232. 

  12232.         {
    12233. 

  12233.           ret = GLEW_AMD_vertex_shader_tessellator;
    12234. 

  12234.           continue;
    12235. 

  12235.         }
    12236. 

  12236. #endif
    12237. 

  12237.       }
    12238. 

  12238.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"APPLE_", 6))
    12239. 

  12239.       {
    12240. 

  12240. #ifdef GL_APPLE_aux_depth_stencil
    12241. 

  12241.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"aux_depth_stencil", 17))
    12242. 

  12242.         {
    12243. 

  12243.           ret = GLEW_APPLE_aux_depth_stencil;
    12244. 

  12244.           continue;
    12245. 

  12245.         }
    12246. 

  12246. #endif
    12247. 

  12247. #ifdef GL_APPLE_client_storage
    12248. 

  12248.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"client_storage", 14))
    12249. 

  12249.         {
    12250. 

  12250.           ret = GLEW_APPLE_client_storage;
    12251. 

  12251.           continue;
    12252. 

  12252.         }
    12253. 

  12253. #endif
    12254. 

  12254. #ifdef GL_APPLE_element_array
    12255. 

  12255.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13))
    12256. 

  12256.         {
    12257. 

  12257.           ret = GLEW_APPLE_element_array;
    12258. 

  12258.           continue;
    12259. 

  12259.         }
    12260. 

  12260. #endif
    12261. 

  12261. #ifdef GL_APPLE_fence
    12262. 

  12262.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5))
    12263. 

  12263.         {
    12264. 

  12264.           ret = GLEW_APPLE_fence;
    12265. 

  12265.           continue;
    12266. 

  12266.         }
    12267. 

  12267. #endif
    12268. 

  12268. #ifdef GL_APPLE_float_pixels
    12269. 

  12269.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_pixels", 12))
    12270. 

  12270.         {
    12271. 

  12271.           ret = GLEW_APPLE_float_pixels;
    12272. 

  12272.           continue;
    12273. 

  12273.         }
    12274. 

  12274. #endif
    12275. 

  12275. #ifdef GL_APPLE_flush_buffer_range
    12276. 

  12276.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_buffer_range", 18))
    12277. 

  12277.         {
    12278. 

  12278.           ret = GLEW_APPLE_flush_buffer_range;
    12279. 

  12279.           continue;
    12280. 

  12280.         }
    12281. 

  12281. #endif
    12282. 

  12282. #ifdef GL_APPLE_object_purgeable
    12283. 

  12283.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"object_purgeable", 16))
    12284. 

  12284.         {
    12285. 

  12285.           ret = GLEW_APPLE_object_purgeable;
    12286. 

  12286.           continue;
    12287. 

  12287.         }
    12288. 

  12288. #endif
    12289. 

  12289. #ifdef GL_APPLE_pixel_buffer
    12290. 

  12290.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer", 12))
    12291. 

  12291.         {
    12292. 

  12292.           ret = GLEW_APPLE_pixel_buffer;
    12293. 

  12293.           continue;
    12294. 

  12294.         }
    12295. 

  12295. #endif
    12296. 

  12296. #ifdef GL_APPLE_rgb_422
    12297. 

  12297.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"rgb_422", 7))
    12298. 

  12298.         {
    12299. 

  12299.           ret = GLEW_APPLE_rgb_422;
    12300. 

  12300.           continue;
    12301. 

  12301.         }
    12302. 

  12302. #endif
    12303. 

  12303. #ifdef GL_APPLE_row_bytes
    12304. 

  12304.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"row_bytes", 9))
    12305. 

  12305.         {
    12306. 

  12306.           ret = GLEW_APPLE_row_bytes;
    12307. 

  12307.           continue;
    12308. 

  12308.         }
    12309. 

  12309. #endif
    12310. 

  12310. #ifdef GL_APPLE_specular_vector
    12311. 

  12311.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_vector", 15))
    12312. 

  12312.         {
    12313. 

  12313.           ret = GLEW_APPLE_specular_vector;
    12314. 

  12314.           continue;
    12315. 

  12315.         }
    12316. 

  12316. #endif
    12317. 

  12317. #ifdef GL_APPLE_texture_range
    12318. 

  12318.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13))
    12319. 

  12319.         {
    12320. 

  12320.           ret = GLEW_APPLE_texture_range;
    12321. 

  12321.           continue;
    12322. 

  12322.         }
    12323. 

  12323. #endif
    12324. 

  12324. #ifdef GL_APPLE_transform_hint
    12325. 

  12325.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_hint", 14))
    12326. 

  12326.         {
    12327. 

  12327.           ret = GLEW_APPLE_transform_hint;
    12328. 

  12328.           continue;
    12329. 

  12329.         }
    12330. 

  12330. #endif
    12331. 

  12331. #ifdef GL_APPLE_vertex_array_object
    12332. 

  12332.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))
    12333. 

  12333.         {
    12334. 

  12334.           ret = GLEW_APPLE_vertex_array_object;
    12335. 

  12335.           continue;
    12336. 

  12336.         }
    12337. 

  12337. #endif
    12338. 

  12338. #ifdef GL_APPLE_vertex_array_range
    12339. 

  12339.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))
    12340. 

  12340.         {
    12341. 

  12341.           ret = GLEW_APPLE_vertex_array_range;
    12342. 

  12342.           continue;
    12343. 

  12343.         }
    12344. 

  12344. #endif
    12345. 

  12345. #ifdef GL_APPLE_vertex_program_evaluators
    12346. 

  12346.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program_evaluators", 25))
    12347. 

  12347.         {
    12348. 

  12348.           ret = GLEW_APPLE_vertex_program_evaluators;
    12349. 

  12349.           continue;
    12350. 

  12350.         }
    12351. 

  12351. #endif
    12352. 

  12352. #ifdef GL_APPLE_ycbcr_422
    12353. 

  12353.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_422", 9))
    12354. 

  12354.         {
    12355. 

  12355.           ret = GLEW_APPLE_ycbcr_422;
    12356. 

  12356.           continue;
    12357. 

  12357.         }
    12358. 

  12358. #endif
    12359. 

  12359.       }
    12360. 

  12360.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))
    12361. 

  12361.       {
    12362. 

  12362. #ifdef GL_ARB_ES2_compatibility
    12363. 

  12363.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"ES2_compatibility", 17))
    12364. 

  12364.         {
    12365. 

  12365.           ret = GLEW_ARB_ES2_compatibility;
    12366. 

  12366.           continue;
    12367. 

  12367.         }
    12368. 

  12368. #endif
    12369. 

  12369. #ifdef GL_ARB_base_instance
    12370. 

  12370.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"base_instance", 13))
    12371. 

  12371.         {
    12372. 

  12372.           ret = GLEW_ARB_base_instance;
    12373. 

  12373.           continue;
    12374. 

  12374.         }
    12375. 

  12375. #endif
    12376. 

  12376. #ifdef GL_ARB_blend_func_extended
    12377. 

  12377.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_extended", 19))
    12378. 

  12378.         {
    12379. 

  12379.           ret = GLEW_ARB_blend_func_extended;
    12380. 

  12380.           continue;
    12381. 

  12381.         }
    12382. 

  12382. #endif
    12383. 

  12383. #ifdef GL_ARB_cl_event
    12384. 

  12384.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"cl_event", 8))
    12385. 

  12385.         {
    12386. 

  12386.           ret = GLEW_ARB_cl_event;
    12387. 

  12387.           continue;
    12388. 

  12388.         }
    12389. 

  12389. #endif
    12390. 

  12390. #ifdef GL_ARB_color_buffer_float
    12391. 

  12391.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_buffer_float", 18))
    12392. 

  12392.         {
    12393. 

  12393.           ret = GLEW_ARB_color_buffer_float;
    12394. 

  12394.           continue;
    12395. 

  12395.         }
    12396. 

  12396. #endif
    12397. 

  12397. #ifdef GL_ARB_compatibility
    12398. 

  12398.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"compatibility", 13))
    12399. 

  12399.         {
    12400. 

  12400.           ret = GLEW_ARB_compatibility;
    12401. 

  12401.           continue;
    12402. 

  12402.         }
    12403. 

  12403. #endif
    12404. 

  12404. #ifdef GL_ARB_compressed_texture_pixel_storage
    12405. 

  12405.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_texture_pixel_storage", 32))
    12406. 

  12406.         {
    12407. 

  12407.           ret = GLEW_ARB_compressed_texture_pixel_storage;
    12408. 

  12408.           continue;
    12409. 

  12409.         }
    12410. 

  12410. #endif
    12411. 

  12411. #ifdef GL_ARB_conservative_depth
    12412. 

  12412.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_depth", 18))
    12413. 

  12413.         {
    12414. 

  12414.           ret = GLEW_ARB_conservative_depth;
    12415. 

  12415.           continue;
    12416. 

  12416.         }
    12417. 

  12417. #endif
    12418. 

  12418. #ifdef GL_ARB_copy_buffer
    12419. 

  12419.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_buffer", 11))
    12420. 

  12420.         {
    12421. 

  12421.           ret = GLEW_ARB_copy_buffer;
    12422. 

  12422.           continue;
    12423. 

  12423.         }
    12424. 

  12424. #endif
    12425. 

  12425. #ifdef GL_ARB_debug_output
    12426. 

  12426.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"debug_output", 12))
    12427. 

  12427.         {
    12428. 

  12428.           ret = GLEW_ARB_debug_output;
    12429. 

  12429.           continue;
    12430. 

  12430.         }
    12431. 

  12431. #endif
    12432. 

  12432. #ifdef GL_ARB_depth_buffer_float
    12433. 

  12433.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_buffer_float", 18))
    12434. 

  12434.         {
    12435. 

  12435.           ret = GLEW_ARB_depth_buffer_float;
    12436. 

  12436.           continue;
    12437. 

  12437.         }
    12438. 

  12438. #endif
    12439. 

  12439. #ifdef GL_ARB_depth_clamp
    12440. 

  12440.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp", 11))
    12441. 

  12441.         {
    12442. 

  12442.           ret = GLEW_ARB_depth_clamp;
    12443. 

  12443.           continue;
    12444. 

  12444.         }
    12445. 

  12445. #endif
    12446. 

  12446. #ifdef GL_ARB_depth_texture
    12447. 

  12447.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13))
    12448. 

  12448.         {
    12449. 

  12449.           ret = GLEW_ARB_depth_texture;
    12450. 

  12450.           continue;
    12451. 

  12451.         }
    12452. 

  12452. #endif
    12453. 

  12453. #ifdef GL_ARB_draw_buffers
    12454. 

  12454.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12))
    12455. 

  12455.         {
    12456. 

  12456.           ret = GLEW_ARB_draw_buffers;
    12457. 

  12457.           continue;
    12458. 

  12458.         }
    12459. 

  12459. #endif
    12460. 

  12460. #ifdef GL_ARB_draw_buffers_blend
    12461. 

  12461.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers_blend", 18))
    12462. 

  12462.         {
    12463. 

  12463.           ret = GLEW_ARB_draw_buffers_blend;
    12464. 

  12464.           continue;
    12465. 

  12465.         }
    12466. 

  12466. #endif
    12467. 

  12467. #ifdef GL_ARB_draw_elements_base_vertex
    12468. 

  12468.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_elements_base_vertex", 25))
    12469. 

  12469.         {
    12470. 

  12470.           ret = GLEW_ARB_draw_elements_base_vertex;
    12471. 

  12471.           continue;
    12472. 

  12472.         }
    12473. 

  12473. #endif
    12474. 

  12474. #ifdef GL_ARB_draw_indirect
    12475. 

  12475.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_indirect", 13))
    12476. 

  12476.         {
    12477. 

  12477.           ret = GLEW_ARB_draw_indirect;
    12478. 

  12478.           continue;
    12479. 

  12479.         }
    12480. 

  12480. #endif
    12481. 

  12481. #ifdef GL_ARB_draw_instanced
    12482. 

  12482.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14))
    12483. 

  12483.         {
    12484. 

  12484.           ret = GLEW_ARB_draw_instanced;
    12485. 

  12485.           continue;
    12486. 

  12486.         }
    12487. 

  12487. #endif
    12488. 

  12488. #ifdef GL_ARB_explicit_attrib_location
    12489. 

  12489.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_attrib_location", 24))
    12490. 

  12490.         {
    12491. 

  12491.           ret = GLEW_ARB_explicit_attrib_location;
    12492. 

  12492.           continue;
    12493. 

  12493.         }
    12494. 

  12494. #endif
    12495. 

  12495. #ifdef GL_ARB_fragment_coord_conventions
    12496. 

  12496.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_coord_conventions", 26))
    12497. 

  12497.         {
    12498. 

  12498.           ret = GLEW_ARB_fragment_coord_conventions;
    12499. 

  12499.           continue;
    12500. 

  12500.         }
    12501. 

  12501. #endif
    12502. 

  12502. #ifdef GL_ARB_fragment_program
    12503. 

  12503.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16))
    12504. 

  12504.         {
    12505. 

  12505.           ret = GLEW_ARB_fragment_program;
    12506. 

  12506.           continue;
    12507. 

  12507.         }
    12508. 

  12508. #endif
    12509. 

  12509. #ifdef GL_ARB_fragment_program_shadow
    12510. 

  12510.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_shadow", 23))
    12511. 

  12511.         {
    12512. 

  12512.           ret = GLEW_ARB_fragment_program_shadow;
    12513. 

  12513.           continue;
    12514. 

  12514.         }
    12515. 

  12515. #endif
    12516. 

  12516. #ifdef GL_ARB_fragment_shader
    12517. 

  12517.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15))
    12518. 

  12518.         {
    12519. 

  12519.           ret = GLEW_ARB_fragment_shader;
    12520. 

  12520.           continue;
    12521. 

  12521.         }
    12522. 

  12522. #endif
    12523. 

  12523. #ifdef GL_ARB_framebuffer_object
    12524. 

  12524.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18))
    12525. 

  12525.         {
    12526. 

  12526.           ret = GLEW_ARB_framebuffer_object;
    12527. 

  12527.           continue;
    12528. 

  12528.         }
    12529. 

  12529. #endif
    12530. 

  12530. #ifdef GL_ARB_framebuffer_sRGB
    12531. 

  12531.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))
    12532. 

  12532.         {
    12533. 

  12533.           ret = GLEW_ARB_framebuffer_sRGB;
    12534. 

  12534.           continue;
    12535. 

  12535.         }
    12536. 

  12536. #endif
    12537. 

  12537. #ifdef GL_ARB_geometry_shader4
    12538. 

  12538.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16))
    12539. 

  12539.         {
    12540. 

  12540.           ret = GLEW_ARB_geometry_shader4;
    12541. 

  12541.           continue;
    12542. 

  12542.         }
    12543. 

  12543. #endif
    12544. 

  12544. #ifdef GL_ARB_get_program_binary
    12545. 

  12545.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_program_binary", 18))
    12546. 

  12546.         {
    12547. 

  12547.           ret = GLEW_ARB_get_program_binary;
    12548. 

  12548.           continue;
    12549. 

  12549.         }
    12550. 

  12550. #endif
    12551. 

  12551. #ifdef GL_ARB_gpu_shader5
    12552. 

  12552.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader5", 11))
    12553. 

  12553.         {
    12554. 

  12554.           ret = GLEW_ARB_gpu_shader5;
    12555. 

  12555.           continue;
    12556. 

  12556.         }
    12557. 

  12557. #endif
    12558. 

  12558. #ifdef GL_ARB_gpu_shader_fp64
    12559. 

  12559.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader_fp64", 15))
    12560. 

  12560.         {
    12561. 

  12561.           ret = GLEW_ARB_gpu_shader_fp64;
    12562. 

  12562.           continue;
    12563. 

  12563.         }
    12564. 

  12564. #endif
    12565. 

  12565. #ifdef GL_ARB_half_float_pixel
    12566. 

  12566.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float_pixel", 16))
    12567. 

  12567.         {
    12568. 

  12568.           ret = GLEW_ARB_half_float_pixel;
    12569. 

  12569.           continue;
    12570. 

  12570.         }
    12571. 

  12571. #endif
    12572. 

  12572. #ifdef GL_ARB_half_float_vertex
    12573. 

  12573.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float_vertex", 17))
    12574. 

  12574.         {
    12575. 

  12575.           ret = GLEW_ARB_half_float_vertex;
    12576. 

  12576.           continue;
    12577. 

  12577.         }
    12578. 

  12578. #endif
    12579. 

  12579. #ifdef GL_ARB_imaging
    12580. 

  12580.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"imaging", 7))
    12581. 

  12581.         {
    12582. 

  12582.           ret = GLEW_ARB_imaging;
    12583. 

  12583.           continue;
    12584. 

  12584.         }
    12585. 

  12585. #endif
    12586. 

  12586. #ifdef GL_ARB_instanced_arrays
    12587. 

  12587.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"instanced_arrays", 16))
    12588. 

  12588.         {
    12589. 

  12589.           ret = GLEW_ARB_instanced_arrays;
    12590. 

  12590.           continue;
    12591. 

  12591.         }
    12592. 

  12592. #endif
    12593. 

  12593. #ifdef GL_ARB_internalformat_query
    12594. 

  12594.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"internalformat_query", 20))
    12595. 

  12595.         {
    12596. 

  12596.           ret = GLEW_ARB_internalformat_query;
    12597. 

  12597.           continue;
    12598. 

  12598.         }
    12599. 

  12599. #endif
    12600. 

  12600. #ifdef GL_ARB_map_buffer_alignment
    12601. 

  12601.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_buffer_alignment", 20))
    12602. 

  12602.         {
    12603. 

  12603.           ret = GLEW_ARB_map_buffer_alignment;
    12604. 

  12604.           continue;
    12605. 

  12605.         }
    12606. 

  12606. #endif
    12607. 

  12607. #ifdef GL_ARB_map_buffer_range
    12608. 

  12608.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_buffer_range", 16))
    12609. 

  12609.         {
    12610. 

  12610.           ret = GLEW_ARB_map_buffer_range;
    12611. 

  12611.           continue;
    12612. 

  12612.         }
    12613. 

  12613. #endif
    12614. 

  12614. #ifdef GL_ARB_matrix_palette
    12615. 

  12615.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"matrix_palette", 14))
    12616. 

  12616.         {
    12617. 

  12617.           ret = GLEW_ARB_matrix_palette;
    12618. 

  12618.           continue;
    12619. 

  12619.         }
    12620. 

  12620. #endif
    12621. 

  12621. #ifdef GL_ARB_multisample
    12622. 

  12622.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
    12623. 

  12623.         {
    12624. 

  12624.           ret = GLEW_ARB_multisample;
    12625. 

  12625.           continue;
    12626. 

  12626.         }
    12627. 

  12627. #endif
    12628. 

  12628. #ifdef GL_ARB_multitexture
    12629. 

  12629.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"multitexture", 12))
    12630. 

  12630.         {
    12631. 

  12631.           ret = GLEW_ARB_multitexture;
    12632. 

  12632.           continue;
    12633. 

  12633.         }
    12634. 

  12634. #endif
    12635. 

  12635. #ifdef GL_ARB_occlusion_query
    12636. 

  12636.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15))
    12637. 

  12637.         {
    12638. 

  12638.           ret = GLEW_ARB_occlusion_query;
    12639. 

  12639.           continue;
    12640. 

  12640.         }
    12641. 

  12641. #endif
    12642. 

  12642. #ifdef GL_ARB_occlusion_query2
    12643. 

  12643.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query2", 16))
    12644. 

  12644.         {
    12645. 

  12645.           ret = GLEW_ARB_occlusion_query2;
    12646. 

  12646.           continue;
    12647. 

  12647.         }
    12648. 

  12648. #endif
    12649. 

  12649. #ifdef GL_ARB_pixel_buffer_object
    12650. 

  12650.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19))
    12651. 

  12651.         {
    12652. 

  12652.           ret = GLEW_ARB_pixel_buffer_object;
    12653. 

  12653.           continue;
    12654. 

  12654.         }
    12655. 

  12655. #endif
    12656. 

  12656. #ifdef GL_ARB_point_parameters
    12657. 

  12657.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16))
    12658. 

  12658.         {
    12659. 

  12659.           ret = GLEW_ARB_point_parameters;
    12660. 

  12660.           continue;
    12661. 

  12661.         }
    12662. 

  12662. #endif
    12663. 

  12663. #ifdef GL_ARB_point_sprite
    12664. 

  12664.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12))
    12665. 

  12665.         {
    12666. 

  12666.           ret = GLEW_ARB_point_sprite;
    12667. 

  12667.           continue;
    12668. 

  12668.         }
    12669. 

  12669. #endif
    12670. 

  12670. #ifdef GL_ARB_provoking_vertex
    12671. 

  12671.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"provoking_vertex", 16))
    12672. 

  12672.         {
    12673. 

  12673.           ret = GLEW_ARB_provoking_vertex;
    12674. 

  12674.           continue;
    12675. 

  12675.         }
    12676. 

  12676. #endif
    12677. 

  12677. #ifdef GL_ARB_robustness
    12678. 

  12678.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness", 10))
    12679. 

  12679.         {
    12680. 

  12680.           ret = GLEW_ARB_robustness;
    12681. 

  12681.           continue;
    12682. 

  12682.         }
    12683. 

  12683. #endif
    12684. 

  12684. #ifdef GL_ARB_sample_shading
    12685. 

  12685.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_shading", 14))
    12686. 

  12686.         {
    12687. 

  12687.           ret = GLEW_ARB_sample_shading;
    12688. 

  12688.           continue;
    12689. 

  12689.         }
    12690. 

  12690. #endif
    12691. 

  12691. #ifdef GL_ARB_sampler_objects
    12692. 

  12692.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"sampler_objects", 15))
    12693. 

  12693.         {
    12694. 

  12694.           ret = GLEW_ARB_sampler_objects;
    12695. 

  12695.           continue;
    12696. 

  12696.         }
    12697. 

  12697. #endif
    12698. 

  12698. #ifdef GL_ARB_seamless_cube_map
    12699. 

  12699.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"seamless_cube_map", 17))
    12700. 

  12700.         {
    12701. 

  12701.           ret = GLEW_ARB_seamless_cube_map;
    12702. 

  12702.           continue;
    12703. 

  12703.         }
    12704. 

  12704. #endif
    12705. 

  12705. #ifdef GL_ARB_separate_shader_objects
    12706. 

  12706.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_shader_objects", 23))
    12707. 

  12707.         {
    12708. 

  12708.           ret = GLEW_ARB_separate_shader_objects;
    12709. 

  12709.           continue;
    12710. 

  12710.         }
    12711. 

  12711. #endif
    12712. 

  12712. #ifdef GL_ARB_shader_atomic_counters
    12713. 

  12713.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_counters", 22))
    12714. 

  12714.         {
    12715. 

  12715.           ret = GLEW_ARB_shader_atomic_counters;
    12716. 

  12716.           continue;
    12717. 

  12717.         }
    12718. 

  12718. #endif
    12719. 

  12719. #ifdef GL_ARB_shader_bit_encoding
    12720. 

  12720.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_bit_encoding", 19))
    12721. 

  12721.         {
    12722. 

  12722.           ret = GLEW_ARB_shader_bit_encoding;
    12723. 

  12723.           continue;
    12724. 

  12724.         }
    12725. 

  12725. #endif
    12726. 

  12726. #ifdef GL_ARB_shader_image_load_store
    12727. 

  12727.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_load_store", 23))
    12728. 

  12728.         {
    12729. 

  12729.           ret = GLEW_ARB_shader_image_load_store;
    12730. 

  12730.           continue;
    12731. 

  12731.         }
    12732. 

  12732. #endif
    12733. 

  12733. #ifdef GL_ARB_shader_objects
    12734. 

  12734.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_objects", 14))
    12735. 

  12735.         {
    12736. 

  12736.           ret = GLEW_ARB_shader_objects;
    12737. 

  12737.           continue;
    12738. 

  12738.         }
    12739. 

  12739. #endif
    12740. 

  12740. #ifdef GL_ARB_shader_precision
    12741. 

  12741.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_precision", 16))
    12742. 

  12742.         {
    12743. 

  12743.           ret = GLEW_ARB_shader_precision;
    12744. 

  12744.           continue;
    12745. 

  12745.         }
    12746. 

  12746. #endif
    12747. 

  12747. #ifdef GL_ARB_shader_stencil_export
    12748. 

  12748.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_stencil_export", 21))
    12749. 

  12749.         {
    12750. 

  12750.           ret = GLEW_ARB_shader_stencil_export;
    12751. 

  12751.           continue;
    12752. 

  12752.         }
    12753. 

  12753. #endif
    12754. 

  12754. #ifdef GL_ARB_shader_subroutine
    12755. 

  12755.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_subroutine", 17))
    12756. 

  12756.         {
    12757. 

  12757.           ret = GLEW_ARB_shader_subroutine;
    12758. 

  12758.           continue;
    12759. 

  12759.         }
    12760. 

  12760. #endif
    12761. 

  12761. #ifdef GL_ARB_shader_texture_lod
    12762. 

  12762.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18))
    12763. 

  12763.         {
    12764. 

  12764.           ret = GLEW_ARB_shader_texture_lod;
    12765. 

  12765.           continue;
    12766. 

  12766.         }
    12767. 

  12767. #endif
    12768. 

  12768. #ifdef GL_ARB_shading_language_100
    12769. 

  12769.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_100", 20))
    12770. 

  12770.         {
    12771. 

  12771.           ret = GLEW_ARB_shading_language_100;
    12772. 

  12772.           continue;
    12773. 

  12773.         }
    12774. 

  12774. #endif
    12775. 

  12775. #ifdef GL_ARB_shading_language_420pack
    12776. 

  12776.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_420pack", 24))
    12777. 

  12777.         {
    12778. 

  12778.           ret = GLEW_ARB_shading_language_420pack;
    12779. 

  12779.           continue;
    12780. 

  12780.         }
    12781. 

  12781. #endif
    12782. 

  12782. #ifdef GL_ARB_shading_language_include
    12783. 

  12783.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_include", 24))
    12784. 

  12784.         {
    12785. 

  12785.           ret = GLEW_ARB_shading_language_include;
    12786. 

  12786.           continue;
    12787. 

  12787.         }
    12788. 

  12788. #endif
    12789. 

  12789. #ifdef GL_ARB_shading_language_packing
    12790. 

  12790.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_packing", 24))
    12791. 

  12791.         {
    12792. 

  12792.           ret = GLEW_ARB_shading_language_packing;
    12793. 

  12793.           continue;
    12794. 

  12794.         }
    12795. 

  12795. #endif
    12796. 

  12796. #ifdef GL_ARB_shadow
    12797. 

  12797.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6))
    12798. 

  12798.         {
    12799. 

  12799.           ret = GLEW_ARB_shadow;
    12800. 

  12800.           continue;
    12801. 

  12801.         }
    12802. 

  12802. #endif
    12803. 

  12803. #ifdef GL_ARB_shadow_ambient
    12804. 

  12804.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14))
    12805. 

  12805.         {
    12806. 

  12806.           ret = GLEW_ARB_shadow_ambient;
    12807. 

  12807.           continue;
    12808. 

  12808.         }
    12809. 

  12809. #endif
    12810. 

  12810. #ifdef GL_ARB_sync
    12811. 

  12811.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync", 4))
    12812. 

  12812.         {
    12813. 

  12813.           ret = GLEW_ARB_sync;
    12814. 

  12814.           continue;
    12815. 

  12815.         }
    12816. 

  12816. #endif
    12817. 

  12817. #ifdef GL_ARB_tessellation_shader
    12818. 

  12818.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"tessellation_shader", 19))
    12819. 

  12819.         {
    12820. 

  12820.           ret = GLEW_ARB_tessellation_shader;
    12821. 

  12821.           continue;
    12822. 

  12822.         }
    12823. 

  12823. #endif
    12824. 

  12824. #ifdef GL_ARB_texture_border_clamp
    12825. 

  12825.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20))
    12826. 

  12826.         {
    12827. 

  12827.           ret = GLEW_ARB_texture_border_clamp;
    12828. 

  12828.           continue;
    12829. 

  12829.         }
    12830. 

  12830. #endif
    12831. 

  12831. #ifdef GL_ARB_texture_buffer_object
    12832. 

  12832.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object", 21))
    12833. 

  12833.         {
    12834. 

  12834.           ret = GLEW_ARB_texture_buffer_object;
    12835. 

  12835.           continue;
    12836. 

  12836.         }
    12837. 

  12837. #endif
    12838. 

  12838. #ifdef GL_ARB_texture_buffer_object_rgb32
    12839. 

  12839.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object_rgb32", 27))
    12840. 

  12840.         {
    12841. 

  12841.           ret = GLEW_ARB_texture_buffer_object_rgb32;
    12842. 

  12842.           continue;
    12843. 

  12843.         }
    12844. 

  12844. #endif
    12845. 

  12845. #ifdef GL_ARB_texture_compression
    12846. 

  12846.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression", 19))
    12847. 

  12847.         {
    12848. 

  12848.           ret = GLEW_ARB_texture_compression;
    12849. 

  12849.           continue;
    12850. 

  12850.         }
    12851. 

  12851. #endif
    12852. 

  12852. #ifdef GL_ARB_texture_compression_bptc
    12853. 

  12853.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_bptc", 24))
    12854. 

  12854.         {
    12855. 

  12855.           ret = GLEW_ARB_texture_compression_bptc;
    12856. 

  12856.           continue;
    12857. 

  12857.         }
    12858. 

  12858. #endif
    12859. 

  12859. #ifdef GL_ARB_texture_compression_rgtc
    12860. 

  12860.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_rgtc", 24))
    12861. 

  12861.         {
    12862. 

  12862.           ret = GLEW_ARB_texture_compression_rgtc;
    12863. 

  12863.           continue;
    12864. 

  12864.         }
    12865. 

  12865. #endif
    12866. 

  12866. #ifdef GL_ARB_texture_cube_map
    12867. 

  12867.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16))
    12868. 

  12868.         {
    12869. 

  12869.           ret = GLEW_ARB_texture_cube_map;
    12870. 

  12870.           continue;
    12871. 

  12871.         }
    12872. 

  12872. #endif
    12873. 

  12873. #ifdef GL_ARB_texture_cube_map_array
    12874. 

  12874.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map_array", 22))
    12875. 

  12875.         {
    12876. 

  12876.           ret = GLEW_ARB_texture_cube_map_array;
    12877. 

  12877.           continue;
    12878. 

  12878.         }
    12879. 

  12879. #endif
    12880. 

  12880. #ifdef GL_ARB_texture_env_add
    12881. 

  12881.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15))
    12882. 

  12882.         {
    12883. 

  12883.           ret = GLEW_ARB_texture_env_add;
    12884. 

  12884.           continue;
    12885. 

  12885.         }
    12886. 

  12886. #endif
    12887. 

  12887. #ifdef GL_ARB_texture_env_combine
    12888. 

  12888.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19))
    12889. 

  12889.         {
    12890. 

  12890.           ret = GLEW_ARB_texture_env_combine;
    12891. 

  12891.           continue;
    12892. 

  12892.         }
    12893. 

  12893. #endif
    12894. 

  12894. #ifdef GL_ARB_texture_env_crossbar
    12895. 

  12895.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_crossbar", 20))
    12896. 

  12896.         {
    12897. 

  12897.           ret = GLEW_ARB_texture_env_crossbar;
    12898. 

  12898.           continue;
    12899. 

  12899.         }
    12900. 

  12900. #endif
    12901. 

  12901. #ifdef GL_ARB_texture_env_dot3
    12902. 

  12902.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16))
    12903. 

  12903.         {
    12904. 

  12904.           ret = GLEW_ARB_texture_env_dot3;
    12905. 

  12905.           continue;
    12906. 

  12906.         }
    12907. 

  12907. #endif
    12908. 

  12908. #ifdef GL_ARB_texture_float
    12909. 

  12909.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13))
    12910. 

  12910.         {
    12911. 

  12911.           ret = GLEW_ARB_texture_float;
    12912. 

  12912.           continue;
    12913. 

  12913.         }
    12914. 

  12914. #endif
    12915. 

  12915. #ifdef GL_ARB_texture_gather
    12916. 

  12916.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_gather", 14))
    12917. 

  12917.         {
    12918. 

  12918.           ret = GLEW_ARB_texture_gather;
    12919. 

  12919.           continue;
    12920. 

  12920.         }
    12921. 

  12921. #endif
    12922. 

  12922. #ifdef GL_ARB_texture_mirrored_repeat
    12923. 

  12923.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23))
    12924. 

  12924.         {
    12925. 

  12925.           ret = GLEW_ARB_texture_mirrored_repeat;
    12926. 

  12926.           continue;
    12927. 

  12927.         }
    12928. 

  12928. #endif
    12929. 

  12929. #ifdef GL_ARB_texture_multisample
    12930. 

  12930.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multisample", 19))
    12931. 

  12931.         {
    12932. 

  12932.           ret = GLEW_ARB_texture_multisample;
    12933. 

  12933.           continue;
    12934. 

  12934.         }
    12935. 

  12935. #endif
    12936. 

  12936. #ifdef GL_ARB_texture_non_power_of_two
    12937. 

  12937.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_non_power_of_two", 24))
    12938. 

  12938.         {
    12939. 

  12939.           ret = GLEW_ARB_texture_non_power_of_two;
    12940. 

  12940.           continue;
    12941. 

  12941.         }
    12942. 

  12942. #endif
    12943. 

  12943. #ifdef GL_ARB_texture_query_lod
    12944. 

  12944.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_query_lod", 17))
    12945. 

  12945.         {
    12946. 

  12946.           ret = GLEW_ARB_texture_query_lod;
    12947. 

  12947.           continue;
    12948. 

  12948.         }
    12949. 

  12949. #endif
    12950. 

  12950. #ifdef GL_ARB_texture_rectangle
    12951. 

  12951.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))
    12952. 

  12952.         {
    12953. 

  12953.           ret = GLEW_ARB_texture_rectangle;
    12954. 

  12954.           continue;
    12955. 

  12955.         }
    12956. 

  12956. #endif
    12957. 

  12957. #ifdef GL_ARB_texture_rg
    12958. 

  12958.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rg", 10))
    12959. 

  12959.         {
    12960. 

  12960.           ret = GLEW_ARB_texture_rg;
    12961. 

  12961.           continue;
    12962. 

  12962.         }
    12963. 

  12963. #endif
    12964. 

  12964. #ifdef GL_ARB_texture_rgb10_a2ui
    12965. 

  12965.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rgb10_a2ui", 18))
    12966. 

  12966.         {
    12967. 

  12967.           ret = GLEW_ARB_texture_rgb10_a2ui;
    12968. 

  12968.           continue;
    12969. 

  12969.         }
    12970. 

  12970. #endif
    12971. 

  12971. #ifdef GL_ARB_texture_storage
    12972. 

  12972.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_storage", 15))
    12973. 

  12973.         {
    12974. 

  12974.           ret = GLEW_ARB_texture_storage;
    12975. 

  12975.           continue;
    12976. 

  12976.         }
    12977. 

  12977. #endif
    12978. 

  12978. #ifdef GL_ARB_texture_swizzle
    12979. 

  12979.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_swizzle", 15))
    12980. 

  12980.         {
    12981. 

  12981.           ret = GLEW_ARB_texture_swizzle;
    12982. 

  12982.           continue;
    12983. 

  12983.         }
    12984. 

  12984. #endif
    12985. 

  12985. #ifdef GL_ARB_timer_query
    12986. 

  12986.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11))
    12987. 

  12987.         {
    12988. 

  12988.           ret = GLEW_ARB_timer_query;
    12989. 

  12989.           continue;
    12990. 

  12990.         }
    12991. 

  12991. #endif
    12992. 

  12992. #ifdef GL_ARB_transform_feedback2
    12993. 

  12993.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback2", 19))
    12994. 

  12994.         {
    12995. 

  12995.           ret = GLEW_ARB_transform_feedback2;
    12996. 

  12996.           continue;
    12997. 

  12997.         }
    12998. 

  12998. #endif
    12999. 

  12999. #ifdef GL_ARB_transform_feedback3
    13000. 

  13000.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback3", 19))
    13001. 

  13001.         {
    13002. 

  13002.           ret = GLEW_ARB_transform_feedback3;
    13003. 

  13003.           continue;
    13004. 

  13004.         }
    13005. 

  13005. #endif
    13006. 

  13006. #ifdef GL_ARB_transform_feedback_instanced
    13007. 

  13007.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback_instanced", 28))
    13008. 

  13008.         {
    13009. 

  13009.           ret = GLEW_ARB_transform_feedback_instanced;
    13010. 

  13010.           continue;
    13011. 

  13011.         }
    13012. 

  13012. #endif
    13013. 

  13013. #ifdef GL_ARB_transpose_matrix
    13014. 

  13014.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"transpose_matrix", 16))
    13015. 

  13015.         {
    13016. 

  13016.           ret = GLEW_ARB_transpose_matrix;
    13017. 

  13017.           continue;
    13018. 

  13018.         }
    13019. 

  13019. #endif
    13020. 

  13020. #ifdef GL_ARB_uniform_buffer_object
    13021. 

  13021.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"uniform_buffer_object", 21))
    13022. 

  13022.         {
    13023. 

  13023.           ret = GLEW_ARB_uniform_buffer_object;
    13024. 

  13024.           continue;
    13025. 

  13025.         }
    13026. 

  13026. #endif
    13027. 

  13027. #ifdef GL_ARB_vertex_array_bgra
    13028. 

  13028.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_bgra", 17))
    13029. 

  13029.         {
    13030. 

  13030.           ret = GLEW_ARB_vertex_array_bgra;
    13031. 

  13031.           continue;
    13032. 

  13032.         }
    13033. 

  13033. #endif
    13034. 

  13034. #ifdef GL_ARB_vertex_array_object
    13035. 

  13035.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))
    13036. 

  13036.         {
    13037. 

  13037.           ret = GLEW_ARB_vertex_array_object;
    13038. 

  13038.           continue;
    13039. 

  13039.         }
    13040. 

  13040. #endif
    13041. 

  13041. #ifdef GL_ARB_vertex_attrib_64bit
    13042. 

  13042.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_64bit", 19))
    13043. 

  13043.         {
    13044. 

  13044.           ret = GLEW_ARB_vertex_attrib_64bit;
    13045. 

  13045.           continue;
    13046. 

  13046.         }
    13047. 

  13047. #endif
    13048. 

  13048. #ifdef GL_ARB_vertex_blend
    13049. 

  13049.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_blend", 12))
    13050. 

  13050.         {
    13051. 

  13051.           ret = GLEW_ARB_vertex_blend;
    13052. 

  13052.           continue;
    13053. 

  13053.         }
    13054. 

  13054. #endif
    13055. 

  13055. #ifdef GL_ARB_vertex_buffer_object
    13056. 

  13056.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_object", 20))
    13057. 

  13057.         {
    13058. 

  13058.           ret = GLEW_ARB_vertex_buffer_object;
    13059. 

  13059.           continue;
    13060. 

  13060.         }
    13061. 

  13061. #endif
    13062. 

  13062. #ifdef GL_ARB_vertex_program
    13063. 

  13063.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14))
    13064. 

  13064.         {
    13065. 

  13065.           ret = GLEW_ARB_vertex_program;
    13066. 

  13066.           continue;
    13067. 

  13067.         }
    13068. 

  13068. #endif
    13069. 

  13069. #ifdef GL_ARB_vertex_shader
    13070. 

  13070.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13))
    13071. 

  13071.         {
    13072. 

  13072.           ret = GLEW_ARB_vertex_shader;
    13073. 

  13073.           continue;
    13074. 

  13074.         }
    13075. 

  13075. #endif
    13076. 

  13076. #ifdef GL_ARB_vertex_type_2_10_10_10_rev
    13077. 

  13077.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_type_2_10_10_10_rev", 26))
    13078. 

  13078.         {
    13079. 

  13079.           ret = GLEW_ARB_vertex_type_2_10_10_10_rev;
    13080. 

  13080.           continue;
    13081. 

  13081.         }
    13082. 

  13082. #endif
    13083. 

  13083. #ifdef GL_ARB_viewport_array
    13084. 

  13084.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"viewport_array", 14))
    13085. 

  13085.         {
    13086. 

  13086.           ret = GLEW_ARB_viewport_array;
    13087. 

  13087.           continue;
    13088. 

  13088.         }
    13089. 

  13089. #endif
    13090. 

  13090. #ifdef GL_ARB_window_pos
    13091. 

  13091.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10))
    13092. 

  13092.         {
    13093. 

  13093.           ret = GLEW_ARB_window_pos;
    13094. 

  13094.           continue;
    13095. 

  13095.         }
    13096. 

  13096. #endif
    13097. 

  13097.       }
    13098. 

  13098.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATIX_", 5))
    13099. 

  13099.       {
    13100. 

  13100. #ifdef GL_ATIX_point_sprites
    13101. 

  13101.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprites", 13))
    13102. 

  13102.         {
    13103. 

  13103.           ret = GLEW_ATIX_point_sprites;
    13104. 

  13104.           continue;
    13105. 

  13105.         }
    13106. 

  13106. #endif
    13107. 

  13107. #ifdef GL_ATIX_texture_env_combine3
    13108. 

  13108.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20))
    13109. 

  13109.         {
    13110. 

  13110.           ret = GLEW_ATIX_texture_env_combine3;
    13111. 

  13111.           continue;
    13112. 

  13112.         }
    13113. 

  13113. #endif
    13114. 

  13114. #ifdef GL_ATIX_texture_env_route
    13115. 

  13115.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_route", 17))
    13116. 

  13116.         {
    13117. 

  13117.           ret = GLEW_ATIX_texture_env_route;
    13118. 

  13118.           continue;
    13119. 

  13119.         }
    13120. 

  13120. #endif
    13121. 

  13121. #ifdef GL_ATIX_vertex_shader_output_point_size
    13122. 

  13122.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_output_point_size", 31))
    13123. 

  13123.         {
    13124. 

  13124.           ret = GLEW_ATIX_vertex_shader_output_point_size;
    13125. 

  13125.           continue;
    13126. 

  13126.         }
    13127. 

  13127. #endif
    13128. 

  13128.       }
    13129. 

  13129.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))
    13130. 

  13130.       {
    13131. 

  13131. #ifdef GL_ATI_draw_buffers
    13132. 

  13132.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12))
    13133. 

  13133.         {
    13134. 

  13134.           ret = GLEW_ATI_draw_buffers;
    13135. 

  13135.           continue;
    13136. 

  13136.         }
    13137. 

  13137. #endif
    13138. 

  13138. #ifdef GL_ATI_element_array
    13139. 

  13139.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13))
    13140. 

  13140.         {
    13141. 

  13141.           ret = GLEW_ATI_element_array;
    13142. 

  13142.           continue;
    13143. 

  13143.         }
    13144. 

  13144. #endif
    13145. 

  13145. #ifdef GL_ATI_envmap_bumpmap
    13146. 

  13146.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"envmap_bumpmap", 14))
    13147. 

  13147.         {
    13148. 

  13148.           ret = GLEW_ATI_envmap_bumpmap;
    13149. 

  13149.           continue;
    13150. 

  13150.         }
    13151. 

  13151. #endif
    13152. 

  13152. #ifdef GL_ATI_fragment_shader
    13153. 

  13153.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15))
    13154. 

  13154.         {
    13155. 

  13155.           ret = GLEW_ATI_fragment_shader;
    13156. 

  13156.           continue;
    13157. 

  13157.         }
    13158. 

  13158. #endif
    13159. 

  13159. #ifdef GL_ATI_map_object_buffer
    13160. 

  13160.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_object_buffer", 17))
    13161. 

  13161.         {
    13162. 

  13162.           ret = GLEW_ATI_map_object_buffer;
    13163. 

  13163.           continue;
    13164. 

  13164.         }
    13165. 

  13165. #endif
    13166. 

  13166. #ifdef GL_ATI_meminfo
    13167. 

  13167.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"meminfo", 7))
    13168. 

  13168.         {
    13169. 

  13169.           ret = GLEW_ATI_meminfo;
    13170. 

  13170.           continue;
    13171. 

  13171.         }
    13172. 

  13172. #endif
    13173. 

  13173. #ifdef GL_ATI_pn_triangles
    13174. 

  13174.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pn_triangles", 12))
    13175. 

  13175.         {
    13176. 

  13176.           ret = GLEW_ATI_pn_triangles;
    13177. 

  13177.           continue;
    13178. 

  13178.         }
    13179. 

  13179. #endif
    13180. 

  13180. #ifdef GL_ATI_separate_stencil
    13181. 

  13181.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_stencil", 16))
    13182. 

  13182.         {
    13183. 

  13183.           ret = GLEW_ATI_separate_stencil;
    13184. 

  13184.           continue;
    13185. 

  13185.         }
    13186. 

  13186. #endif
    13187. 

  13187. #ifdef GL_ATI_shader_texture_lod
    13188. 

  13188.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18))
    13189. 

  13189.         {
    13190. 

  13190.           ret = GLEW_ATI_shader_texture_lod;
    13191. 

  13191.           continue;
    13192. 

  13192.         }
    13193. 

  13193. #endif
    13194. 

  13194. #ifdef GL_ATI_text_fragment_shader
    13195. 

  13195.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"text_fragment_shader", 20))
    13196. 

  13196.         {
    13197. 

  13197.           ret = GLEW_ATI_text_fragment_shader;
    13198. 

  13198.           continue;
    13199. 

  13199.         }
    13200. 

  13200. #endif
    13201. 

  13201. #ifdef GL_ATI_texture_compression_3dc
    13202. 

  13202.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_3dc", 23))
    13203. 

  13203.         {
    13204. 

  13204.           ret = GLEW_ATI_texture_compression_3dc;
    13205. 

  13205.           continue;
    13206. 

  13206.         }
    13207. 

  13207. #endif
    13208. 

  13208. #ifdef GL_ATI_texture_env_combine3
    13209. 

  13209.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20))
    13210. 

  13210.         {
    13211. 

  13211.           ret = GLEW_ATI_texture_env_combine3;
    13212. 

  13212.           continue;
    13213. 

  13213.         }
    13214. 

  13214. #endif
    13215. 

  13215. #ifdef GL_ATI_texture_float
    13216. 

  13216.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13))
    13217. 

  13217.         {
    13218. 

  13218.           ret = GLEW_ATI_texture_float;
    13219. 

  13219.           continue;
    13220. 

  13220.         }
    13221. 

  13221. #endif
    13222. 

  13222. #ifdef GL_ATI_texture_mirror_once
    13223. 

  13223.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_once", 19))
    13224. 

  13224.         {
    13225. 

  13225.           ret = GLEW_ATI_texture_mirror_once;
    13226. 

  13226.           continue;
    13227. 

  13227.         }
    13228. 

  13228. #endif
    13229. 

  13229. #ifdef GL_ATI_vertex_array_object
    13230. 

  13230.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19))
    13231. 

  13231.         {
    13232. 

  13232.           ret = GLEW_ATI_vertex_array_object;
    13233. 

  13233.           continue;
    13234. 

  13234.         }
    13235. 

  13235. #endif
    13236. 

  13236. #ifdef GL_ATI_vertex_attrib_array_object
    13237. 

  13237.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_array_object", 26))
    13238. 

  13238.         {
    13239. 

  13239.           ret = GLEW_ATI_vertex_attrib_array_object;
    13240. 

  13240.           continue;
    13241. 

  13241.         }
    13242. 

  13242. #endif
    13243. 

  13243. #ifdef GL_ATI_vertex_streams
    13244. 

  13244.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_streams", 14))
    13245. 

  13245.         {
    13246. 

  13246.           ret = GLEW_ATI_vertex_streams;
    13247. 

  13247.           continue;
    13248. 

  13248.         }
    13249. 

  13249. #endif
    13250. 

  13250.       }
    13251. 

  13251.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))
    13252. 

  13252.       {
    13253. 

  13253. #ifdef GL_EXT_422_pixels
    13254. 

  13254.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"422_pixels", 10))
    13255. 

  13255.         {
    13256. 

  13256.           ret = GLEW_EXT_422_pixels;
    13257. 

  13257.           continue;
    13258. 

  13258.         }
    13259. 

  13259. #endif
    13260. 

  13260. #ifdef GL_EXT_Cg_shader
    13261. 

  13261.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"Cg_shader", 9))
    13262. 

  13262.         {
    13263. 

  13263.           ret = GLEW_EXT_Cg_shader;
    13264. 

  13264.           continue;
    13265. 

  13265.         }
    13266. 

  13266. #endif
    13267. 

  13267. #ifdef GL_EXT_abgr
    13268. 

  13268.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"abgr", 4))
    13269. 

  13269.         {
    13270. 

  13270.           ret = GLEW_EXT_abgr;
    13271. 

  13271.           continue;
    13272. 

  13272.         }
    13273. 

  13273. #endif
    13274. 

  13274. #ifdef GL_EXT_bgra
    13275. 

  13275.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"bgra", 4))
    13276. 

  13276.         {
    13277. 

  13277.           ret = GLEW_EXT_bgra;
    13278. 

  13278.           continue;
    13279. 

  13279.         }
    13280. 

  13280. #endif
    13281. 

  13281. #ifdef GL_EXT_bindable_uniform
    13282. 

  13282.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindable_uniform", 16))
    13283. 

  13283.         {
    13284. 

  13284.           ret = GLEW_EXT_bindable_uniform;
    13285. 

  13285.           continue;
    13286. 

  13286.         }
    13287. 

  13287. #endif
    13288. 

  13288. #ifdef GL_EXT_blend_color
    13289. 

  13289.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_color", 11))
    13290. 

  13290.         {
    13291. 

  13291.           ret = GLEW_EXT_blend_color;
    13292. 

  13292.           continue;
    13293. 

  13293.         }
    13294. 

  13294. #endif
    13295. 

  13295. #ifdef GL_EXT_blend_equation_separate
    13296. 

  13296.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_separate", 23))
    13297. 

  13297.         {
    13298. 

  13298.           ret = GLEW_EXT_blend_equation_separate;
    13299. 

  13299.           continue;
    13300. 

  13300.         }
    13301. 

  13301. #endif
    13302. 

  13302. #ifdef GL_EXT_blend_func_separate
    13303. 

  13303.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_separate", 19))
    13304. 

  13304.         {
    13305. 

  13305.           ret = GLEW_EXT_blend_func_separate;
    13306. 

  13306.           continue;
    13307. 

  13307.         }
    13308. 

  13308. #endif
    13309. 

  13309. #ifdef GL_EXT_blend_logic_op
    13310. 

  13310.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_logic_op", 14))
    13311. 

  13311.         {
    13312. 

  13312.           ret = GLEW_EXT_blend_logic_op;
    13313. 

  13313.           continue;
    13314. 

  13314.         }
    13315. 

  13315. #endif
    13316. 

  13316. #ifdef GL_EXT_blend_minmax
    13317. 

  13317.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_minmax", 12))
    13318. 

  13318.         {
    13319. 

  13319.           ret = GLEW_EXT_blend_minmax;
    13320. 

  13320.           continue;
    13321. 

  13321.         }
    13322. 

  13322. #endif
    13323. 

  13323. #ifdef GL_EXT_blend_subtract
    13324. 

  13324.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_subtract", 14))
    13325. 

  13325.         {
    13326. 

  13326.           ret = GLEW_EXT_blend_subtract;
    13327. 

  13327.           continue;
    13328. 

  13328.         }
    13329. 

  13329. #endif
    13330. 

  13330. #ifdef GL_EXT_clip_volume_hint
    13331. 

  13331.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_volume_hint", 16))
    13332. 

  13332.         {
    13333. 

  13333.           ret = GLEW_EXT_clip_volume_hint;
    13334. 

  13334.           continue;
    13335. 

  13335.         }
    13336. 

  13336. #endif
    13337. 

  13337. #ifdef GL_EXT_cmyka
    13338. 

  13338.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"cmyka", 5))
    13339. 

  13339.         {
    13340. 

  13340.           ret = GLEW_EXT_cmyka;
    13341. 

  13341.           continue;
    13342. 

  13342.         }
    13343. 

  13343. #endif
    13344. 

  13344. #ifdef GL_EXT_color_subtable
    13345. 

  13345.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_subtable", 14))
    13346. 

  13346.         {
    13347. 

  13347.           ret = GLEW_EXT_color_subtable;
    13348. 

  13348.           continue;
    13349. 

  13349.         }
    13350. 

  13350. #endif
    13351. 

  13351. #ifdef GL_EXT_compiled_vertex_array
    13352. 

  13352.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"compiled_vertex_array", 21))
    13353. 

  13353.         {
    13354. 

  13354.           ret = GLEW_EXT_compiled_vertex_array;
    13355. 

  13355.           continue;
    13356. 

  13356.         }
    13357. 

  13357. #endif
    13358. 

  13358. #ifdef GL_EXT_convolution
    13359. 

  13359.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution", 11))
    13360. 

  13360.         {
    13361. 

  13361.           ret = GLEW_EXT_convolution;
    13362. 

  13362.           continue;
    13363. 

  13363.         }
    13364. 

  13364. #endif
    13365. 

  13365. #ifdef GL_EXT_coordinate_frame
    13366. 

  13366.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"coordinate_frame", 16))
    13367. 

  13367.         {
    13368. 

  13368.           ret = GLEW_EXT_coordinate_frame;
    13369. 

  13369.           continue;
    13370. 

  13370.         }
    13371. 

  13371. #endif
    13372. 

  13372. #ifdef GL_EXT_copy_texture
    13373. 

  13373.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_texture", 12))
    13374. 

  13374.         {
    13375. 

  13375.           ret = GLEW_EXT_copy_texture;
    13376. 

  13376.           continue;
    13377. 

  13377.         }
    13378. 

  13378. #endif
    13379. 

  13379. #ifdef GL_EXT_cull_vertex
    13380. 

  13380.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11))
    13381. 

  13381.         {
    13382. 

  13382.           ret = GLEW_EXT_cull_vertex;
    13383. 

  13383.           continue;
    13384. 

  13384.         }
    13385. 

  13385. #endif
    13386. 

  13386. #ifdef GL_EXT_depth_bounds_test
    13387. 

  13387.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_bounds_test", 17))
    13388. 

  13388.         {
    13389. 

  13389.           ret = GLEW_EXT_depth_bounds_test;
    13390. 

  13390.           continue;
    13391. 

  13391.         }
    13392. 

  13392. #endif
    13393. 

  13393. #ifdef GL_EXT_direct_state_access
    13394. 

  13394.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"direct_state_access", 19))
    13395. 

  13395.         {
    13396. 

  13396.           ret = GLEW_EXT_direct_state_access;
    13397. 

  13397.           continue;
    13398. 

  13398.         }
    13399. 

  13399. #endif
    13400. 

  13400. #ifdef GL_EXT_draw_buffers2
    13401. 

  13401.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers2", 13))
    13402. 

  13402.         {
    13403. 

  13403.           ret = GLEW_EXT_draw_buffers2;
    13404. 

  13404.           continue;
    13405. 

  13405.         }
    13406. 

  13406. #endif
    13407. 

  13407. #ifdef GL_EXT_draw_instanced
    13408. 

  13408.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14))
    13409. 

  13409.         {
    13410. 

  13410.           ret = GLEW_EXT_draw_instanced;
    13411. 

  13411.           continue;
    13412. 

  13412.         }
    13413. 

  13413. #endif
    13414. 

  13414. #ifdef GL_EXT_draw_range_elements
    13415. 

  13415.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_range_elements", 19))
    13416. 

  13416.         {
    13417. 

  13417.           ret = GLEW_EXT_draw_range_elements;
    13418. 

  13418.           continue;
    13419. 

  13419.         }
    13420. 

  13420. #endif
    13421. 

  13421. #ifdef GL_EXT_fog_coord
    13422. 

  13422.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_coord", 9))
    13423. 

  13423.         {
    13424. 

  13424.           ret = GLEW_EXT_fog_coord;
    13425. 

  13425.           continue;
    13426. 

  13426.         }
    13427. 

  13427. #endif
    13428. 

  13428. #ifdef GL_EXT_fragment_lighting
    13429. 

  13429.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_lighting", 17))
    13430. 

  13430.         {
    13431. 

  13431.           ret = GLEW_EXT_fragment_lighting;
    13432. 

  13432.           continue;
    13433. 

  13433.         }
    13434. 

  13434. #endif
    13435. 

  13435. #ifdef GL_EXT_framebuffer_blit
    13436. 

  13436.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_blit", 16))
    13437. 

  13437.         {
    13438. 

  13438.           ret = GLEW_EXT_framebuffer_blit;
    13439. 

  13439.           continue;
    13440. 

  13440.         }
    13441. 

  13441. #endif
    13442. 

  13442. #ifdef GL_EXT_framebuffer_multisample
    13443. 

  13443.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample", 23))
    13444. 

  13444.         {
    13445. 

  13445.           ret = GLEW_EXT_framebuffer_multisample;
    13446. 

  13446.           continue;
    13447. 

  13447.         }
    13448. 

  13448. #endif
    13449. 

  13449. #ifdef GL_EXT_framebuffer_multisample_blit_scaled
    13450. 

  13450.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample_blit_scaled", 35))
    13451. 

  13451.         {
    13452. 

  13452.           ret = GLEW_EXT_framebuffer_multisample_blit_scaled;
    13453. 

  13453.           continue;
    13454. 

  13454.         }
    13455. 

  13455. #endif
    13456. 

  13456. #ifdef GL_EXT_framebuffer_object
    13457. 

  13457.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18))
    13458. 

  13458.         {
    13459. 

  13459.           ret = GLEW_EXT_framebuffer_object;
    13460. 

  13460.           continue;
    13461. 

  13461.         }
    13462. 

  13462. #endif
    13463. 

  13463. #ifdef GL_EXT_framebuffer_sRGB
    13464. 

  13464.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))
    13465. 

  13465.         {
    13466. 

  13466.           ret = GLEW_EXT_framebuffer_sRGB;
    13467. 

  13467.           continue;
    13468. 

  13468.         }
    13469. 

  13469. #endif
    13470. 

  13470. #ifdef GL_EXT_geometry_shader4
    13471. 

  13471.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16))
    13472. 

  13472.         {
    13473. 

  13473.           ret = GLEW_EXT_geometry_shader4;
    13474. 

  13474.           continue;
    13475. 

  13475.         }
    13476. 

  13476. #endif
    13477. 

  13477. #ifdef GL_EXT_gpu_program_parameters
    13478. 

  13478.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program_parameters", 22))
    13479. 

  13479.         {
    13480. 

  13480.           ret = GLEW_EXT_gpu_program_parameters;
    13481. 

  13481.           continue;
    13482. 

  13482.         }
    13483. 

  13483. #endif
    13484. 

  13484. #ifdef GL_EXT_gpu_shader4
    13485. 

  13485.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader4", 11))
    13486. 

  13486.         {
    13487. 

  13487.           ret = GLEW_EXT_gpu_shader4;
    13488. 

  13488.           continue;
    13489. 

  13489.         }
    13490. 

  13490. #endif
    13491. 

  13491. #ifdef GL_EXT_histogram
    13492. 

  13492.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"histogram", 9))
    13493. 

  13493.         {
    13494. 

  13494.           ret = GLEW_EXT_histogram;
    13495. 

  13495.           continue;
    13496. 

  13496.         }
    13497. 

  13497. #endif
    13498. 

  13498. #ifdef GL_EXT_index_array_formats
    13499. 

  13499.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_array_formats", 19))
    13500. 

  13500.         {
    13501. 

  13501.           ret = GLEW_EXT_index_array_formats;
    13502. 

  13502.           continue;
    13503. 

  13503.         }
    13504. 

  13504. #endif
    13505. 

  13505. #ifdef GL_EXT_index_func
    13506. 

  13506.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_func", 10))
    13507. 

  13507.         {
    13508. 

  13508.           ret = GLEW_EXT_index_func;
    13509. 

  13509.           continue;
    13510. 

  13510.         }
    13511. 

  13511. #endif
    13512. 

  13512. #ifdef GL_EXT_index_material
    13513. 

  13513.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_material", 14))
    13514. 

  13514.         {
    13515. 

  13515.           ret = GLEW_EXT_index_material;
    13516. 

  13516.           continue;
    13517. 

  13517.         }
    13518. 

  13518. #endif
    13519. 

  13519. #ifdef GL_EXT_index_texture
    13520. 

  13520.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_texture", 13))
    13521. 

  13521.         {
    13522. 

  13522.           ret = GLEW_EXT_index_texture;
    13523. 

  13523.           continue;
    13524. 

  13524.         }
    13525. 

  13525. #endif
    13526. 

  13526. #ifdef GL_EXT_light_texture
    13527. 

  13527.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_texture", 13))
    13528. 

  13528.         {
    13529. 

  13529.           ret = GLEW_EXT_light_texture;
    13530. 

  13530.           continue;
    13531. 

  13531.         }
    13532. 

  13532. #endif
    13533. 

  13533. #ifdef GL_EXT_misc_attribute
    13534. 

  13534.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_attribute", 14))
    13535. 

  13535.         {
    13536. 

  13536.           ret = GLEW_EXT_misc_attribute;
    13537. 

  13537.           continue;
    13538. 

  13538.         }
    13539. 

  13539. #endif
    13540. 

  13540. #ifdef GL_EXT_multi_draw_arrays
    13541. 

  13541.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_arrays", 17))
    13542. 

  13542.         {
    13543. 

  13543.           ret = GLEW_EXT_multi_draw_arrays;
    13544. 

  13544.           continue;
    13545. 

  13545.         }
    13546. 

  13546. #endif
    13547. 

  13547. #ifdef GL_EXT_multisample
    13548. 

  13548.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
    13549. 

  13549.         {
    13550. 

  13550.           ret = GLEW_EXT_multisample;
    13551. 

  13551.           continue;
    13552. 

  13552.         }
    13553. 

  13553. #endif
    13554. 

  13554. #ifdef GL_EXT_packed_depth_stencil
    13555. 

  13555.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20))
    13556. 

  13556.         {
    13557. 

  13557.           ret = GLEW_EXT_packed_depth_stencil;
    13558. 

  13558.           continue;
    13559. 

  13559.         }
    13560. 

  13560. #endif
    13561. 

  13561. #ifdef GL_EXT_packed_float
    13562. 

  13562.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_float", 12))
    13563. 

  13563.         {
    13564. 

  13564.           ret = GLEW_EXT_packed_float;
    13565. 

  13565.           continue;
    13566. 

  13566.         }
    13567. 

  13567. #endif
    13568. 

  13568. #ifdef GL_EXT_packed_pixels
    13569. 

  13569.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_pixels", 13))
    13570. 

  13570.         {
    13571. 

  13571.           ret = GLEW_EXT_packed_pixels;
    13572. 

  13572.           continue;
    13573. 

  13573.         }
    13574. 

  13574. #endif
    13575. 

  13575. #ifdef GL_EXT_paletted_texture
    13576. 

  13576.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"paletted_texture", 16))
    13577. 

  13577.         {
    13578. 

  13578.           ret = GLEW_EXT_paletted_texture;
    13579. 

  13579.           continue;
    13580. 

  13580.         }
    13581. 

  13581. #endif
    13582. 

  13582. #ifdef GL_EXT_pixel_buffer_object
    13583. 

  13583.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19))
    13584. 

  13584.         {
    13585. 

  13585.           ret = GLEW_EXT_pixel_buffer_object;
    13586. 

  13586.           continue;
    13587. 

  13587.         }
    13588. 

  13588. #endif
    13589. 

  13589. #ifdef GL_EXT_pixel_transform
    13590. 

  13590.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform", 15))
    13591. 

  13591.         {
    13592. 

  13592.           ret = GLEW_EXT_pixel_transform;
    13593. 

  13593.           continue;
    13594. 

  13594.         }
    13595. 

  13595. #endif
    13596. 

  13596. #ifdef GL_EXT_pixel_transform_color_table
    13597. 

  13597.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform_color_table", 27))
    13598. 

  13598.         {
    13599. 

  13599.           ret = GLEW_EXT_pixel_transform_color_table;
    13600. 

  13600.           continue;
    13601. 

  13601.         }
    13602. 

  13602. #endif
    13603. 

  13603. #ifdef GL_EXT_point_parameters
    13604. 

  13604.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16))
    13605. 

  13605.         {
    13606. 

  13606.           ret = GLEW_EXT_point_parameters;
    13607. 

  13607.           continue;
    13608. 

  13608.         }
    13609. 

  13609. #endif
    13610. 

  13610. #ifdef GL_EXT_polygon_offset
    13611. 

  13611.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"polygon_offset", 14))
    13612. 

  13612.         {
    13613. 

  13613.           ret = GLEW_EXT_polygon_offset;
    13614. 

  13614.           continue;
    13615. 

  13615.         }
    13616. 

  13616. #endif
    13617. 

  13617. #ifdef GL_EXT_provoking_vertex
    13618. 

  13618.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"provoking_vertex", 16))
    13619. 

  13619.         {
    13620. 

  13620.           ret = GLEW_EXT_provoking_vertex;
    13621. 

  13621.           continue;
    13622. 

  13622.         }
    13623. 

  13623. #endif
    13624. 

  13624. #ifdef GL_EXT_rescale_normal
    13625. 

  13625.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"rescale_normal", 14))
    13626. 

  13626.         {
    13627. 

  13627.           ret = GLEW_EXT_rescale_normal;
    13628. 

  13628.           continue;
    13629. 

  13629.         }
    13630. 

  13630. #endif
    13631. 

  13631. #ifdef GL_EXT_scene_marker
    13632. 

  13632.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12))
    13633. 

  13633.         {
    13634. 

  13634.           ret = GLEW_EXT_scene_marker;
    13635. 

  13635.           continue;
    13636. 

  13636.         }
    13637. 

  13637. #endif
    13638. 

  13638. #ifdef GL_EXT_secondary_color
    13639. 

  13639.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"secondary_color", 15))
    13640. 

  13640.         {
    13641. 

  13641.           ret = GLEW_EXT_secondary_color;
    13642. 

  13642.           continue;
    13643. 

  13643.         }
    13644. 

  13644. #endif
    13645. 

  13645. #ifdef GL_EXT_separate_shader_objects
    13646. 

  13646.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_shader_objects", 23))
    13647. 

  13647.         {
    13648. 

  13648.           ret = GLEW_EXT_separate_shader_objects;
    13649. 

  13649.           continue;
    13650. 

  13650.         }
    13651. 

  13651. #endif
    13652. 

  13652. #ifdef GL_EXT_separate_specular_color
    13653. 

  13653.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_specular_color", 23))
    13654. 

  13654.         {
    13655. 

  13655.           ret = GLEW_EXT_separate_specular_color;
    13656. 

  13656.           continue;
    13657. 

  13657.         }
    13658. 

  13658. #endif
    13659. 

  13659. #ifdef GL_EXT_shader_image_load_store
    13660. 

  13660.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_load_store", 23))
    13661. 

  13661.         {
    13662. 

  13662.           ret = GLEW_EXT_shader_image_load_store;
    13663. 

  13663.           continue;
    13664. 

  13664.         }
    13665. 

  13665. #endif
    13666. 

  13666. #ifdef GL_EXT_shadow_funcs
    13667. 

  13667.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_funcs", 12))
    13668. 

  13668.         {
    13669. 

  13669.           ret = GLEW_EXT_shadow_funcs;
    13670. 

  13670.           continue;
    13671. 

  13671.         }
    13672. 

  13672. #endif
    13673. 

  13673. #ifdef GL_EXT_shared_texture_palette
    13674. 

  13674.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_texture_palette", 22))
    13675. 

  13675.         {
    13676. 

  13676.           ret = GLEW_EXT_shared_texture_palette;
    13677. 

  13677.           continue;
    13678. 

  13678.         }
    13679. 

  13679. #endif
    13680. 

  13680. #ifdef GL_EXT_stencil_clear_tag
    13681. 

  13681.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_clear_tag", 17))
    13682. 

  13682.         {
    13683. 

  13683.           ret = GLEW_EXT_stencil_clear_tag;
    13684. 

  13684.           continue;
    13685. 

  13685.         }
    13686. 

  13686. #endif
    13687. 

  13687. #ifdef GL_EXT_stencil_two_side
    13688. 

  13688.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_two_side", 16))
    13689. 

  13689.         {
    13690. 

  13690.           ret = GLEW_EXT_stencil_two_side;
    13691. 

  13691.           continue;
    13692. 

  13692.         }
    13693. 

  13693. #endif
    13694. 

  13694. #ifdef GL_EXT_stencil_wrap
    13695. 

  13695.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_wrap", 12))
    13696. 

  13696.         {
    13697. 

  13697.           ret = GLEW_EXT_stencil_wrap;
    13698. 

  13698.           continue;
    13699. 

  13699.         }
    13700. 

  13700. #endif
    13701. 

  13701. #ifdef GL_EXT_subtexture
    13702. 

  13702.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"subtexture", 10))
    13703. 

  13703.         {
    13704. 

  13704.           ret = GLEW_EXT_subtexture;
    13705. 

  13705.           continue;
    13706. 

  13706.         }
    13707. 

  13707. #endif
    13708. 

  13708. #ifdef GL_EXT_texture
    13709. 

  13709.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture", 7))
    13710. 

  13710.         {
    13711. 

  13711.           ret = GLEW_EXT_texture;
    13712. 

  13712.           continue;
    13713. 

  13713.         }
    13714. 

  13714. #endif
    13715. 

  13715. #ifdef GL_EXT_texture3D
    13716. 

  13716.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture3D", 9))
    13717. 

  13717.         {
    13718. 

  13718.           ret = GLEW_EXT_texture3D;
    13719. 

  13719.           continue;
    13720. 

  13720.         }
    13721. 

  13721. #endif
    13722. 

  13722. #ifdef GL_EXT_texture_array
    13723. 

  13723.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_array", 13))
    13724. 

  13724.         {
    13725. 

  13725.           ret = GLEW_EXT_texture_array;
    13726. 

  13726.           continue;
    13727. 

  13727.         }
    13728. 

  13728. #endif
    13729. 

  13729. #ifdef GL_EXT_texture_buffer_object
    13730. 

  13730.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object", 21))
    13731. 

  13731.         {
    13732. 

  13732.           ret = GLEW_EXT_texture_buffer_object;
    13733. 

  13733.           continue;
    13734. 

  13734.         }
    13735. 

  13735. #endif
    13736. 

  13736. #ifdef GL_EXT_texture_compression_dxt1
    13737. 

  13737.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt1", 24))
    13738. 

  13738.         {
    13739. 

  13739.           ret = GLEW_EXT_texture_compression_dxt1;
    13740. 

  13740.           continue;
    13741. 

  13741.         }
    13742. 

  13742. #endif
    13743. 

  13743. #ifdef GL_EXT_texture_compression_latc
    13744. 

  13744.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_latc", 24))
    13745. 

  13745.         {
    13746. 

  13746.           ret = GLEW_EXT_texture_compression_latc;
    13747. 

  13747.           continue;
    13748. 

  13748.         }
    13749. 

  13749. #endif
    13750. 

  13750. #ifdef GL_EXT_texture_compression_rgtc
    13751. 

  13751.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_rgtc", 24))
    13752. 

  13752.         {
    13753. 

  13753.           ret = GLEW_EXT_texture_compression_rgtc;
    13754. 

  13754.           continue;
    13755. 

  13755.         }
    13756. 

  13756. #endif
    13757. 

  13757. #ifdef GL_EXT_texture_compression_s3tc
    13758. 

  13758.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_s3tc", 24))
    13759. 

  13759.         {
    13760. 

  13760.           ret = GLEW_EXT_texture_compression_s3tc;
    13761. 

  13761.           continue;
    13762. 

  13762.         }
    13763. 

  13763. #endif
    13764. 

  13764. #ifdef GL_EXT_texture_cube_map
    13765. 

  13765.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16))
    13766. 

  13766.         {
    13767. 

  13767.           ret = GLEW_EXT_texture_cube_map;
    13768. 

  13768.           continue;
    13769. 

  13769.         }
    13770. 

  13770. #endif
    13771. 

  13771. #ifdef GL_EXT_texture_edge_clamp
    13772. 

  13772.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18))
    13773. 

  13773.         {
    13774. 

  13774.           ret = GLEW_EXT_texture_edge_clamp;
    13775. 

  13775.           continue;
    13776. 

  13776.         }
    13777. 

  13777. #endif
    13778. 

  13778. #ifdef GL_EXT_texture_env
    13779. 

  13779.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env", 11))
    13780. 

  13780.         {
    13781. 

  13781.           ret = GLEW_EXT_texture_env;
    13782. 

  13782.           continue;
    13783. 

  13783.         }
    13784. 

  13784. #endif
    13785. 

  13785. #ifdef GL_EXT_texture_env_add
    13786. 

  13786.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15))
    13787. 

  13787.         {
    13788. 

  13788.           ret = GLEW_EXT_texture_env_add;
    13789. 

  13789.           continue;
    13790. 

  13790.         }
    13791. 

  13791. #endif
    13792. 

  13792. #ifdef GL_EXT_texture_env_combine
    13793. 

  13793.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19))
    13794. 

  13794.         {
    13795. 

  13795.           ret = GLEW_EXT_texture_env_combine;
    13796. 

  13796.           continue;
    13797. 

  13797.         }
    13798. 

  13798. #endif
    13799. 

  13799. #ifdef GL_EXT_texture_env_dot3
    13800. 

  13800.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16))
    13801. 

  13801.         {
    13802. 

  13802.           ret = GLEW_EXT_texture_env_dot3;
    13803. 

  13803.           continue;
    13804. 

  13804.         }
    13805. 

  13805. #endif
    13806. 

  13806. #ifdef GL_EXT_texture_filter_anisotropic
    13807. 

  13807.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter_anisotropic", 26))
    13808. 

  13808.         {
    13809. 

  13809.           ret = GLEW_EXT_texture_filter_anisotropic;
    13810. 

  13810.           continue;
    13811. 

  13811.         }
    13812. 

  13812. #endif
    13813. 

  13813. #ifdef GL_EXT_texture_integer
    13814. 

  13814.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_integer", 15))
    13815. 

  13815.         {
    13816. 

  13816.           ret = GLEW_EXT_texture_integer;
    13817. 

  13817.           continue;
    13818. 

  13818.         }
    13819. 

  13819. #endif
    13820. 

  13820. #ifdef GL_EXT_texture_lod_bias
    13821. 

  13821.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16))
    13822. 

  13822.         {
    13823. 

  13823.           ret = GLEW_EXT_texture_lod_bias;
    13824. 

  13824.           continue;
    13825. 

  13825.         }
    13826. 

  13826. #endif
    13827. 

  13827. #ifdef GL_EXT_texture_mirror_clamp
    13828. 

  13828.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_clamp", 20))
    13829. 

  13829.         {
    13830. 

  13830.           ret = GLEW_EXT_texture_mirror_clamp;
    13831. 

  13831.           continue;
    13832. 

  13832.         }
    13833. 

  13833. #endif
    13834. 

  13834. #ifdef GL_EXT_texture_object
    13835. 

  13835.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_object", 14))
    13836. 

  13836.         {
    13837. 

  13837.           ret = GLEW_EXT_texture_object;
    13838. 

  13838.           continue;
    13839. 

  13839.         }
    13840. 

  13840. #endif
    13841. 

  13841. #ifdef GL_EXT_texture_perturb_normal
    13842. 

  13842.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_perturb_normal", 22))
    13843. 

  13843.         {
    13844. 

  13844.           ret = GLEW_EXT_texture_perturb_normal;
    13845. 

  13845.           continue;
    13846. 

  13846.         }
    13847. 

  13847. #endif
    13848. 

  13848. #ifdef GL_EXT_texture_rectangle
    13849. 

  13849.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))
    13850. 

  13850.         {
    13851. 

  13851.           ret = GLEW_EXT_texture_rectangle;
    13852. 

  13852.           continue;
    13853. 

  13853.         }
    13854. 

  13854. #endif
    13855. 

  13855. #ifdef GL_EXT_texture_sRGB
    13856. 

  13856.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB", 12))
    13857. 

  13857.         {
    13858. 

  13858.           ret = GLEW_EXT_texture_sRGB;
    13859. 

  13859.           continue;
    13860. 

  13860.         }
    13861. 

  13861. #endif
    13862. 

  13862. #ifdef GL_EXT_texture_sRGB_decode
    13863. 

  13863.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB_decode", 19))
    13864. 

  13864.         {
    13865. 

  13865.           ret = GLEW_EXT_texture_sRGB_decode;
    13866. 

  13866.           continue;
    13867. 

  13867.         }
    13868. 

  13868. #endif
    13869. 

  13869. #ifdef GL_EXT_texture_shared_exponent
    13870. 

  13870.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shared_exponent", 23))
    13871. 

  13871.         {
    13872. 

  13872.           ret = GLEW_EXT_texture_shared_exponent;
    13873. 

  13873.           continue;
    13874. 

  13874.         }
    13875. 

  13875. #endif
    13876. 

  13876. #ifdef GL_EXT_texture_snorm
    13877. 

  13877.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_snorm", 13))
    13878. 

  13878.         {
    13879. 

  13879.           ret = GLEW_EXT_texture_snorm;
    13880. 

  13880.           continue;
    13881. 

  13881.         }
    13882. 

  13882. #endif
    13883. 

  13883. #ifdef GL_EXT_texture_swizzle
    13884. 

  13884.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_swizzle", 15))
    13885. 

  13885.         {
    13886. 

  13886.           ret = GLEW_EXT_texture_swizzle;
    13887. 

  13887.           continue;
    13888. 

  13888.         }
    13889. 

  13889. #endif
    13890. 

  13890. #ifdef GL_EXT_timer_query
    13891. 

  13891.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11))
    13892. 

  13892.         {
    13893. 

  13893.           ret = GLEW_EXT_timer_query;
    13894. 

  13894.           continue;
    13895. 

  13895.         }
    13896. 

  13896. #endif
    13897. 

  13897. #ifdef GL_EXT_transform_feedback
    13898. 

  13898.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback", 18))
    13899. 

  13899.         {
    13900. 

  13900.           ret = GLEW_EXT_transform_feedback;
    13901. 

  13901.           continue;
    13902. 

  13902.         }
    13903. 

  13903. #endif
    13904. 

  13904. #ifdef GL_EXT_vertex_array
    13905. 

  13905.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array", 12))
    13906. 

  13906.         {
    13907. 

  13907.           ret = GLEW_EXT_vertex_array;
    13908. 

  13908.           continue;
    13909. 

  13909.         }
    13910. 

  13910. #endif
    13911. 

  13911. #ifdef GL_EXT_vertex_array_bgra
    13912. 

  13912.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_bgra", 17))
    13913. 

  13913.         {
    13914. 

  13914.           ret = GLEW_EXT_vertex_array_bgra;
    13915. 

  13915.           continue;
    13916. 

  13916.         }
    13917. 

  13917. #endif
    13918. 

  13918. #ifdef GL_EXT_vertex_attrib_64bit
    13919. 

  13919.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_64bit", 19))
    13920. 

  13920.         {
    13921. 

  13921.           ret = GLEW_EXT_vertex_attrib_64bit;
    13922. 

  13922.           continue;
    13923. 

  13923.         }
    13924. 

  13924. #endif
    13925. 

  13925. #ifdef GL_EXT_vertex_shader
    13926. 

  13926.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13))
    13927. 

  13927.         {
    13928. 

  13928.           ret = GLEW_EXT_vertex_shader;
    13929. 

  13929.           continue;
    13930. 

  13930.         }
    13931. 

  13931. #endif
    13932. 

  13932. #ifdef GL_EXT_vertex_weighting
    13933. 

  13933.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_weighting", 16))
    13934. 

  13934.         {
    13935. 

  13935.           ret = GLEW_EXT_vertex_weighting;
    13936. 

  13936.           continue;
    13937. 

  13937.         }
    13938. 

  13938. #endif
    13939. 

  13939. #ifdef GL_EXT_x11_sync_object
    13940. 

  13940.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"x11_sync_object", 15))
    13941. 

  13941.         {
    13942. 

  13942.           ret = GLEW_EXT_x11_sync_object;
    13943. 

  13943.           continue;
    13944. 

  13944.         }
    13945. 

  13945. #endif
    13946. 

  13946.       }
    13947. 

  13947.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"GREMEDY_", 8))
    13948. 

  13948.       {
    13949. 

  13949. #ifdef GL_GREMEDY_frame_terminator
    13950. 

  13950.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"frame_terminator", 16))
    13951. 

  13951.         {
    13952. 

  13952.           ret = GLEW_GREMEDY_frame_terminator;
    13953. 

  13953.           continue;
    13954. 

  13954.         }
    13955. 

  13955. #endif
    13956. 

  13956. #ifdef GL_GREMEDY_string_marker
    13957. 

  13957.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"string_marker", 13))
    13958. 

  13958.         {
    13959. 

  13959.           ret = GLEW_GREMEDY_string_marker;
    13960. 

  13960.           continue;
    13961. 

  13961.         }
    13962. 

  13962. #endif
    13963. 

  13963.       }
    13964. 

  13964.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"HP_", 3))
    13965. 

  13965.       {
    13966. 

  13966. #ifdef GL_HP_convolution_border_modes
    13967. 

  13967.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24))
    13968. 

  13968.         {
    13969. 

  13969.           ret = GLEW_HP_convolution_border_modes;
    13970. 

  13970.           continue;
    13971. 

  13971.         }
    13972. 

  13972. #endif
    13973. 

  13973. #ifdef GL_HP_image_transform
    13974. 

  13974.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_transform", 15))
    13975. 

  13975.         {
    13976. 

  13976.           ret = GLEW_HP_image_transform;
    13977. 

  13977.           continue;
    13978. 

  13978.         }
    13979. 

  13979. #endif
    13980. 

  13980. #ifdef GL_HP_occlusion_test
    13981. 

  13981.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_test", 14))
    13982. 

  13982.         {
    13983. 

  13983.           ret = GLEW_HP_occlusion_test;
    13984. 

  13984.           continue;
    13985. 

  13985.         }
    13986. 

  13986. #endif
    13987. 

  13987. #ifdef GL_HP_texture_lighting
    13988. 

  13988.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lighting", 16))
    13989. 

  13989.         {
    13990. 

  13990.           ret = GLEW_HP_texture_lighting;
    13991. 

  13991.           continue;
    13992. 

  13992.         }
    13993. 

  13993. #endif
    13994. 

  13994.       }
    13995. 

  13995.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"IBM_", 4))
    13996. 

  13996.       {
    13997. 

  13997. #ifdef GL_IBM_cull_vertex
    13998. 

  13998.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11))
    13999. 

  13999.         {
    14000. 

  14000.           ret = GLEW_IBM_cull_vertex;
    14001. 

  14001.           continue;
    14002. 

  14002.         }
    14003. 

  14003. #endif
    14004. 

  14004. #ifdef GL_IBM_multimode_draw_arrays
    14005. 

  14005.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"multimode_draw_arrays", 21))
    14006. 

  14006.         {
    14007. 

  14007.           ret = GLEW_IBM_multimode_draw_arrays;
    14008. 

  14008.           continue;
    14009. 

  14009.         }
    14010. 

  14010. #endif
    14011. 

  14011. #ifdef GL_IBM_rasterpos_clip
    14012. 

  14012.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"rasterpos_clip", 14))
    14013. 

  14013.         {
    14014. 

  14014.           ret = GLEW_IBM_rasterpos_clip;
    14015. 

  14015.           continue;
    14016. 

  14016.         }
    14017. 

  14017. #endif
    14018. 

  14018. #ifdef GL_IBM_static_data
    14019. 

  14019.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"static_data", 11))
    14020. 

  14020.         {
    14021. 

  14021.           ret = GLEW_IBM_static_data;
    14022. 

  14022.           continue;
    14023. 

  14023.         }
    14024. 

  14024. #endif
    14025. 

  14025. #ifdef GL_IBM_texture_mirrored_repeat
    14026. 

  14026.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23))
    14027. 

  14027.         {
    14028. 

  14028.           ret = GLEW_IBM_texture_mirrored_repeat;
    14029. 

  14029.           continue;
    14030. 

  14030.         }
    14031. 

  14031. #endif
    14032. 

  14032. #ifdef GL_IBM_vertex_array_lists
    14033. 

  14033.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_lists", 18))
    14034. 

  14034.         {
    14035. 

  14035.           ret = GLEW_IBM_vertex_array_lists;
    14036. 

  14036.           continue;
    14037. 

  14037.         }
    14038. 

  14038. #endif
    14039. 

  14039.       }
    14040. 

  14040.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"INGR_", 5))
    14041. 

  14041.       {
    14042. 

  14042. #ifdef GL_INGR_color_clamp
    14043. 

  14043.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_clamp", 11))
    14044. 

  14044.         {
    14045. 

  14045.           ret = GLEW_INGR_color_clamp;
    14046. 

  14046.           continue;
    14047. 

  14047.         }
    14048. 

  14048. #endif
    14049. 

  14049. #ifdef GL_INGR_interlace_read
    14050. 

  14050.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace_read", 14))
    14051. 

  14051.         {
    14052. 

  14052.           ret = GLEW_INGR_interlace_read;
    14053. 

  14053.           continue;
    14054. 

  14054.         }
    14055. 

  14055. #endif
    14056. 

  14056.       }
    14057. 

  14057.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"INTEL_", 6))
    14058. 

  14058.       {
    14059. 

  14059. #ifdef GL_INTEL_parallel_arrays
    14060. 

  14060.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"parallel_arrays", 15))
    14061. 

  14061.         {
    14062. 

  14062.           ret = GLEW_INTEL_parallel_arrays;
    14063. 

  14063.           continue;
    14064. 

  14064.         }
    14065. 

  14065. #endif
    14066. 

  14066. #ifdef GL_INTEL_texture_scissor
    14067. 

  14067.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scissor", 15))
    14068. 

  14068.         {
    14069. 

  14069.           ret = GLEW_INTEL_texture_scissor;
    14070. 

  14070.           continue;
    14071. 

  14071.         }
    14072. 

  14072. #endif
    14073. 

  14073.       }
    14074. 

  14074.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"KTX_", 4))
    14075. 

  14075.       {
    14076. 

  14076. #ifdef GL_KTX_buffer_region
    14077. 

  14077.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13))
    14078. 

  14078.         {
    14079. 

  14079.           ret = GLEW_KTX_buffer_region;
    14080. 

  14080.           continue;
    14081. 

  14081.         }
    14082. 

  14082. #endif
    14083. 

  14083.       }
    14084. 

  14084.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESAX_", 6))
    14085. 

  14085.       {
    14086. 

  14086. #ifdef GL_MESAX_texture_stack
    14087. 

  14087.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_stack", 13))
    14088. 

  14088.         {
    14089. 

  14089.           ret = GLEW_MESAX_texture_stack;
    14090. 

  14090.           continue;
    14091. 

  14091.         }
    14092. 

  14092. #endif
    14093. 

  14093.       }
    14094. 

  14094.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5))
    14095. 

  14095.       {
    14096. 

  14096. #ifdef GL_MESA_pack_invert
    14097. 

  14097.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pack_invert", 11))
    14098. 

  14098.         {
    14099. 

  14099.           ret = GLEW_MESA_pack_invert;
    14100. 

  14100.           continue;
    14101. 

  14101.         }
    14102. 

  14102. #endif
    14103. 

  14103. #ifdef GL_MESA_resize_buffers
    14104. 

  14104.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"resize_buffers", 14))
    14105. 

  14105.         {
    14106. 

  14106.           ret = GLEW_MESA_resize_buffers;
    14107. 

  14107.           continue;
    14108. 

  14108.         }
    14109. 

  14109. #endif
    14110. 

  14110. #ifdef GL_MESA_window_pos
    14111. 

  14111.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10))
    14112. 

  14112.         {
    14113. 

  14113.           ret = GLEW_MESA_window_pos;
    14114. 

  14114.           continue;
    14115. 

  14115.         }
    14116. 

  14116. #endif
    14117. 

  14117. #ifdef GL_MESA_ycbcr_texture
    14118. 

  14118.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_texture", 13))
    14119. 

  14119.         {
    14120. 

  14120.           ret = GLEW_MESA_ycbcr_texture;
    14121. 

  14121.           continue;
    14122. 

  14122.         }
    14123. 

  14123. #endif
    14124. 

  14124.       }
    14125. 

  14125.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"NVX_", 4))
    14126. 

  14126.       {
    14127. 

  14127. #ifdef GL_NVX_gpu_memory_info
    14128. 

  14128.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_memory_info", 15))
    14129. 

  14129.         {
    14130. 

  14130.           ret = GLEW_NVX_gpu_memory_info;
    14131. 

  14131.           continue;
    14132. 

  14132.         }
    14133. 

  14133. #endif
    14134. 

  14134.       }
    14135. 

  14135.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))
    14136. 

  14136.       {
    14137. 

  14137. #ifdef GL_NV_blend_square
    14138. 

  14138.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_square", 12))
    14139. 

  14139.         {
    14140. 

  14140.           ret = GLEW_NV_blend_square;
    14141. 

  14141.           continue;
    14142. 

  14142.         }
    14143. 

  14143. #endif
    14144. 

  14144. #ifdef GL_NV_conditional_render
    14145. 

  14145.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"conditional_render", 18))
    14146. 

  14146.         {
    14147. 

  14147.           ret = GLEW_NV_conditional_render;
    14148. 

  14148.           continue;
    14149. 

  14149.         }
    14150. 

  14150. #endif
    14151. 

  14151. #ifdef GL_NV_copy_depth_to_color
    14152. 

  14152.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_depth_to_color", 19))
    14153. 

  14153.         {
    14154. 

  14154.           ret = GLEW_NV_copy_depth_to_color;
    14155. 

  14155.           continue;
    14156. 

  14156.         }
    14157. 

  14157. #endif
    14158. 

  14158. #ifdef GL_NV_copy_image
    14159. 

  14159.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10))
    14160. 

  14160.         {
    14161. 

  14161.           ret = GLEW_NV_copy_image;
    14162. 

  14162.           continue;
    14163. 

  14163.         }
    14164. 

  14164. #endif
    14165. 

  14165. #ifdef GL_NV_depth_buffer_float
    14166. 

  14166.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_buffer_float", 18))
    14167. 

  14167.         {
    14168. 

  14168.           ret = GLEW_NV_depth_buffer_float;
    14169. 

  14169.           continue;
    14170. 

  14170.         }
    14171. 

  14171. #endif
    14172. 

  14172. #ifdef GL_NV_depth_clamp
    14173. 

  14173.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp", 11))
    14174. 

  14174.         {
    14175. 

  14175.           ret = GLEW_NV_depth_clamp;
    14176. 

  14176.           continue;
    14177. 

  14177.         }
    14178. 

  14178. #endif
    14179. 

  14179. #ifdef GL_NV_depth_range_unclamped
    14180. 

  14180.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_range_unclamped", 21))
    14181. 

  14181.         {
    14182. 

  14182.           ret = GLEW_NV_depth_range_unclamped;
    14183. 

  14183.           continue;
    14184. 

  14184.         }
    14185. 

  14185. #endif
    14186. 

  14186. #ifdef GL_NV_evaluators
    14187. 

  14187.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"evaluators", 10))
    14188. 

  14188.         {
    14189. 

  14189.           ret = GLEW_NV_evaluators;
    14190. 

  14190.           continue;
    14191. 

  14191.         }
    14192. 

  14192. #endif
    14193. 

  14193. #ifdef GL_NV_explicit_multisample
    14194. 

  14194.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_multisample", 20))
    14195. 

  14195.         {
    14196. 

  14196.           ret = GLEW_NV_explicit_multisample;
    14197. 

  14197.           continue;
    14198. 

  14198.         }
    14199. 

  14199. #endif
    14200. 

  14200. #ifdef GL_NV_fence
    14201. 

  14201.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5))
    14202. 

  14202.         {
    14203. 

  14203.           ret = GLEW_NV_fence;
    14204. 

  14204.           continue;
    14205. 

  14205.         }
    14206. 

  14206. #endif
    14207. 

  14207. #ifdef GL_NV_float_buffer
    14208. 

  14208.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))
    14209. 

  14209.         {
    14210. 

  14210.           ret = GLEW_NV_float_buffer;
    14211. 

  14211.           continue;
    14212. 

  14212.         }
    14213. 

  14213. #endif
    14214. 

  14214. #ifdef GL_NV_fog_distance
    14215. 

  14215.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_distance", 12))
    14216. 

  14216.         {
    14217. 

  14217.           ret = GLEW_NV_fog_distance;
    14218. 

  14218.           continue;
    14219. 

  14219.         }
    14220. 

  14220. #endif
    14221. 

  14221. #ifdef GL_NV_fragment_program
    14222. 

  14222.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16))
    14223. 

  14223.         {
    14224. 

  14224.           ret = GLEW_NV_fragment_program;
    14225. 

  14225.           continue;
    14226. 

  14226.         }
    14227. 

  14227. #endif
    14228. 

  14228. #ifdef GL_NV_fragment_program2
    14229. 

  14229.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program2", 17))
    14230. 

  14230.         {
    14231. 

  14231.           ret = GLEW_NV_fragment_program2;
    14232. 

  14232.           continue;
    14233. 

  14233.         }
    14234. 

  14234. #endif
    14235. 

  14235. #ifdef GL_NV_fragment_program4
    14236. 

  14236.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program4", 17))
    14237. 

  14237.         {
    14238. 

  14238.           ret = GLEW_NV_fragment_program4;
    14239. 

  14239.           continue;
    14240. 

  14240.         }
    14241. 

  14241. #endif
    14242. 

  14242. #ifdef GL_NV_fragment_program_option
    14243. 

  14243.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_option", 23))
    14244. 

  14244.         {
    14245. 

  14245.           ret = GLEW_NV_fragment_program_option;
    14246. 

  14246.           continue;
    14247. 

  14247.         }
    14248. 

  14248. #endif
    14249. 

  14249. #ifdef GL_NV_framebuffer_multisample_coverage
    14250. 

  14250.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample_coverage", 32))
    14251. 

  14251.         {
    14252. 

  14252.           ret = GLEW_NV_framebuffer_multisample_coverage;
    14253. 

  14253.           continue;
    14254. 

  14254.         }
    14255. 

  14255. #endif
    14256. 

  14256. #ifdef GL_NV_geometry_program4
    14257. 

  14257.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_program4", 17))
    14258. 

  14258.         {
    14259. 

  14259.           ret = GLEW_NV_geometry_program4;
    14260. 

  14260.           continue;
    14261. 

  14261.         }
    14262. 

  14262. #endif
    14263. 

  14263. #ifdef GL_NV_geometry_shader4
    14264. 

  14264.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16))
    14265. 

  14265.         {
    14266. 

  14266.           ret = GLEW_NV_geometry_shader4;
    14267. 

  14267.           continue;
    14268. 

  14268.         }
    14269. 

  14269. #endif
    14270. 

  14270. #ifdef GL_NV_gpu_program4
    14271. 

  14271.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program4", 12))
    14272. 

  14272.         {
    14273. 

  14273.           ret = GLEW_NV_gpu_program4;
    14274. 

  14274.           continue;
    14275. 

  14275.         }
    14276. 

  14276. #endif
    14277. 

  14277. #ifdef GL_NV_gpu_program5
    14278. 

  14278.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program5", 12))
    14279. 

  14279.         {
    14280. 

  14280.           ret = GLEW_NV_gpu_program5;
    14281. 

  14281.           continue;
    14282. 

  14282.         }
    14283. 

  14283. #endif
    14284. 

  14284. #ifdef GL_NV_gpu_program_fp64
    14285. 

  14285.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program_fp64", 16))
    14286. 

  14286.         {
    14287. 

  14287.           ret = GLEW_NV_gpu_program_fp64;
    14288. 

  14288.           continue;
    14289. 

  14289.         }
    14290. 

  14290. #endif
    14291. 

  14291. #ifdef GL_NV_gpu_shader5
    14292. 

  14292.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader5", 11))
    14293. 

  14293.         {
    14294. 

  14294.           ret = GLEW_NV_gpu_shader5;
    14295. 

  14295.           continue;
    14296. 

  14296.         }
    14297. 

  14297. #endif
    14298. 

  14298. #ifdef GL_NV_half_float
    14299. 

  14299.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float", 10))
    14300. 

  14300.         {
    14301. 

  14301.           ret = GLEW_NV_half_float;
    14302. 

  14302.           continue;
    14303. 

  14303.         }
    14304. 

  14304. #endif
    14305. 

  14305. #ifdef GL_NV_light_max_exponent
    14306. 

  14306.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_max_exponent", 18))
    14307. 

  14307.         {
    14308. 

  14308.           ret = GLEW_NV_light_max_exponent;
    14309. 

  14309.           continue;
    14310. 

  14310.         }
    14311. 

  14311. #endif
    14312. 

  14312. #ifdef GL_NV_multisample_coverage
    14313. 

  14313.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_coverage", 20))
    14314. 

  14314.         {
    14315. 

  14315.           ret = GLEW_NV_multisample_coverage;
    14316. 

  14316.           continue;
    14317. 

  14317.         }
    14318. 

  14318. #endif
    14319. 

  14319. #ifdef GL_NV_multisample_filter_hint
    14320. 

  14320.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_filter_hint", 23))
    14321. 

  14321.         {
    14322. 

  14322.           ret = GLEW_NV_multisample_filter_hint;
    14323. 

  14323.           continue;
    14324. 

  14324.         }
    14325. 

  14325. #endif
    14326. 

  14326. #ifdef GL_NV_occlusion_query
    14327. 

  14327.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15))
    14328. 

  14328.         {
    14329. 

  14329.           ret = GLEW_NV_occlusion_query;
    14330. 

  14330.           continue;
    14331. 

  14331.         }
    14332. 

  14332. #endif
    14333. 

  14333. #ifdef GL_NV_packed_depth_stencil
    14334. 

  14334.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20))
    14335. 

  14335.         {
    14336. 

  14336.           ret = GLEW_NV_packed_depth_stencil;
    14337. 

  14337.           continue;
    14338. 

  14338.         }
    14339. 

  14339. #endif
    14340. 

  14340. #ifdef GL_NV_parameter_buffer_object
    14341. 

  14341.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"parameter_buffer_object", 23))
    14342. 

  14342.         {
    14343. 

  14343.           ret = GLEW_NV_parameter_buffer_object;
    14344. 

  14344.           continue;
    14345. 

  14345.         }
    14346. 

  14346. #endif
    14347. 

  14347. #ifdef GL_NV_parameter_buffer_object2
    14348. 

  14348.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"parameter_buffer_object2", 24))
    14349. 

  14349.         {
    14350. 

  14350.           ret = GLEW_NV_parameter_buffer_object2;
    14351. 

  14351.           continue;
    14352. 

  14352.         }
    14353. 

  14353. #endif
    14354. 

  14354. #ifdef GL_NV_path_rendering
    14355. 

  14355.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"path_rendering", 14))
    14356. 

  14356.         {
    14357. 

  14357.           ret = GLEW_NV_path_rendering;
    14358. 

  14358.           continue;
    14359. 

  14359.         }
    14360. 

  14360. #endif
    14361. 

  14361. #ifdef GL_NV_pixel_data_range
    14362. 

  14362.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_data_range", 16))
    14363. 

  14363.         {
    14364. 

  14364.           ret = GLEW_NV_pixel_data_range;
    14365. 

  14365.           continue;
    14366. 

  14366.         }
    14367. 

  14367. #endif
    14368. 

  14368. #ifdef GL_NV_point_sprite
    14369. 

  14369.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12))
    14370. 

  14370.         {
    14371. 

  14371.           ret = GLEW_NV_point_sprite;
    14372. 

  14372.           continue;
    14373. 

  14373.         }
    14374. 

  14374. #endif
    14375. 

  14375. #ifdef GL_NV_present_video
    14376. 

  14376.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13))
    14377. 

  14377.         {
    14378. 

  14378.           ret = GLEW_NV_present_video;
    14379. 

  14379.           continue;
    14380. 

  14380.         }
    14381. 

  14381. #endif
    14382. 

  14382. #ifdef GL_NV_primitive_restart
    14383. 

  14383.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"primitive_restart", 17))
    14384. 

  14384.         {
    14385. 

  14385.           ret = GLEW_NV_primitive_restart;
    14386. 

  14386.           continue;
    14387. 

  14387.         }
    14388. 

  14388. #endif
    14389. 

  14389. #ifdef GL_NV_register_combiners
    14390. 

  14390.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners", 18))
    14391. 

  14391.         {
    14392. 

  14392.           ret = GLEW_NV_register_combiners;
    14393. 

  14393.           continue;
    14394. 

  14394.         }
    14395. 

  14395. #endif
    14396. 

  14396. #ifdef GL_NV_register_combiners2
    14397. 

  14397.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners2", 19))
    14398. 

  14398.         {
    14399. 

  14399.           ret = GLEW_NV_register_combiners2;
    14400. 

  14400.           continue;
    14401. 

  14401.         }
    14402. 

  14402. #endif
    14403. 

  14403. #ifdef GL_NV_shader_buffer_load
    14404. 

  14404.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_buffer_load", 18))
    14405. 

  14405.         {
    14406. 

  14406.           ret = GLEW_NV_shader_buffer_load;
    14407. 

  14407.           continue;
    14408. 

  14408.         }
    14409. 

  14409. #endif
    14410. 

  14410. #ifdef GL_NV_tessellation_program5
    14411. 

  14411.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"tessellation_program5", 21))
    14412. 

  14412.         {
    14413. 

  14413.           ret = GLEW_NV_tessellation_program5;
    14414. 

  14414.           continue;
    14415. 

  14415.         }
    14416. 

  14416. #endif
    14417. 

  14417. #ifdef GL_NV_texgen_emboss
    14418. 

  14418.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_emboss", 13))
    14419. 

  14419.         {
    14420. 

  14420.           ret = GLEW_NV_texgen_emboss;
    14421. 

  14421.           continue;
    14422. 

  14422.         }
    14423. 

  14423. #endif
    14424. 

  14424. #ifdef GL_NV_texgen_reflection
    14425. 

  14425.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_reflection", 17))
    14426. 

  14426.         {
    14427. 

  14427.           ret = GLEW_NV_texgen_reflection;
    14428. 

  14428.           continue;
    14429. 

  14429.         }
    14430. 

  14430. #endif
    14431. 

  14431. #ifdef GL_NV_texture_barrier
    14432. 

  14432.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_barrier", 15))
    14433. 

  14433.         {
    14434. 

  14434.           ret = GLEW_NV_texture_barrier;
    14435. 

  14435.           continue;
    14436. 

  14436.         }
    14437. 

  14437. #endif
    14438. 

  14438. #ifdef GL_NV_texture_compression_vtc
    14439. 

  14439.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_vtc", 23))
    14440. 

  14440.         {
    14441. 

  14441.           ret = GLEW_NV_texture_compression_vtc;
    14442. 

  14442.           continue;
    14443. 

  14443.         }
    14444. 

  14444. #endif
    14445. 

  14445. #ifdef GL_NV_texture_env_combine4
    14446. 

  14446.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine4", 20))
    14447. 

  14447.         {
    14448. 

  14448.           ret = GLEW_NV_texture_env_combine4;
    14449. 

  14449.           continue;
    14450. 

  14450.         }
    14451. 

  14451. #endif
    14452. 

  14452. #ifdef GL_NV_texture_expand_normal
    14453. 

  14453.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_expand_normal", 21))
    14454. 

  14454.         {
    14455. 

  14455.           ret = GLEW_NV_texture_expand_normal;
    14456. 

  14456.           continue;
    14457. 

  14457.         }
    14458. 

  14458. #endif
    14459. 

  14459. #ifdef GL_NV_texture_multisample
    14460. 

  14460.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multisample", 19))
    14461. 

  14461.         {
    14462. 

  14462.           ret = GLEW_NV_texture_multisample;
    14463. 

  14463.           continue;
    14464. 

  14464.         }
    14465. 

  14465. #endif
    14466. 

  14466. #ifdef GL_NV_texture_rectangle
    14467. 

  14467.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17))
    14468. 

  14468.         {
    14469. 

  14469.           ret = GLEW_NV_texture_rectangle;
    14470. 

  14470.           continue;
    14471. 

  14471.         }
    14472. 

  14472. #endif
    14473. 

  14473. #ifdef GL_NV_texture_shader
    14474. 

  14474.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader", 14))
    14475. 

  14475.         {
    14476. 

  14476.           ret = GLEW_NV_texture_shader;
    14477. 

  14477.           continue;
    14478. 

  14478.         }
    14479. 

  14479. #endif
    14480. 

  14480. #ifdef GL_NV_texture_shader2
    14481. 

  14481.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader2", 15))
    14482. 

  14482.         {
    14483. 

  14483.           ret = GLEW_NV_texture_shader2;
    14484. 

  14484.           continue;
    14485. 

  14485.         }
    14486. 

  14486. #endif
    14487. 

  14487. #ifdef GL_NV_texture_shader3
    14488. 

  14488.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader3", 15))
    14489. 

  14489.         {
    14490. 

  14490.           ret = GLEW_NV_texture_shader3;
    14491. 

  14491.           continue;
    14492. 

  14492.         }
    14493. 

  14493. #endif
    14494. 

  14494. #ifdef GL_NV_transform_feedback
    14495. 

  14495.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback", 18))
    14496. 

  14496.         {
    14497. 

  14497.           ret = GLEW_NV_transform_feedback;
    14498. 

  14498.           continue;
    14499. 

  14499.         }
    14500. 

  14500. #endif
    14501. 

  14501. #ifdef GL_NV_transform_feedback2
    14502. 

  14502.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback2", 19))
    14503. 

  14503.         {
    14504. 

  14504.           ret = GLEW_NV_transform_feedback2;
    14505. 

  14505.           continue;
    14506. 

  14506.         }
    14507. 

  14507. #endif
    14508. 

  14508. #ifdef GL_NV_vdpau_interop
    14509. 

  14509.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vdpau_interop", 13))
    14510. 

  14510.         {
    14511. 

  14511.           ret = GLEW_NV_vdpau_interop;
    14512. 

  14512.           continue;
    14513. 

  14513.         }
    14514. 

  14514. #endif
    14515. 

  14515. #ifdef GL_NV_vertex_array_range
    14516. 

  14516.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))
    14517. 

  14517.         {
    14518. 

  14518.           ret = GLEW_NV_vertex_array_range;
    14519. 

  14519.           continue;
    14520. 

  14520.         }
    14521. 

  14521. #endif
    14522. 

  14522. #ifdef GL_NV_vertex_array_range2
    14523. 

  14523.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range2", 19))
    14524. 

  14524.         {
    14525. 

  14525.           ret = GLEW_NV_vertex_array_range2;
    14526. 

  14526.           continue;
    14527. 

  14527.         }
    14528. 

  14528. #endif
    14529. 

  14529. #ifdef GL_NV_vertex_attrib_integer_64bit
    14530. 

  14530.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_integer_64bit", 27))
    14531. 

  14531.         {
    14532. 

  14532.           ret = GLEW_NV_vertex_attrib_integer_64bit;
    14533. 

  14533.           continue;
    14534. 

  14534.         }
    14535. 

  14535. #endif
    14536. 

  14536. #ifdef GL_NV_vertex_buffer_unified_memory
    14537. 

  14537.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_unified_memory", 28))
    14538. 

  14538.         {
    14539. 

  14539.           ret = GLEW_NV_vertex_buffer_unified_memory;
    14540. 

  14540.           continue;
    14541. 

  14541.         }
    14542. 

  14542. #endif
    14543. 

  14543. #ifdef GL_NV_vertex_program
    14544. 

  14544.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14))
    14545. 

  14545.         {
    14546. 

  14546.           ret = GLEW_NV_vertex_program;
    14547. 

  14547.           continue;
    14548. 

  14548.         }
    14549. 

  14549. #endif
    14550. 

  14550. #ifdef GL_NV_vertex_program1_1
    14551. 

  14551.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program1_1", 17))
    14552. 

  14552.         {
    14553. 

  14553.           ret = GLEW_NV_vertex_program1_1;
    14554. 

  14554.           continue;
    14555. 

  14555.         }
    14556. 

  14556. #endif
    14557. 

  14557. #ifdef GL_NV_vertex_program2
    14558. 

  14558.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2", 15))
    14559. 

  14559.         {
    14560. 

  14560.           ret = GLEW_NV_vertex_program2;
    14561. 

  14561.           continue;
    14562. 

  14562.         }
    14563. 

  14563. #endif
    14564. 

  14564. #ifdef GL_NV_vertex_program2_option
    14565. 

  14565.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2_option", 22))
    14566. 

  14566.         {
    14567. 

  14567.           ret = GLEW_NV_vertex_program2_option;
    14568. 

  14568.           continue;
    14569. 

  14569.         }
    14570. 

  14570. #endif
    14571. 

  14571. #ifdef GL_NV_vertex_program3
    14572. 

  14572.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program3", 15))
    14573. 

  14573.         {
    14574. 

  14574.           ret = GLEW_NV_vertex_program3;
    14575. 

  14575.           continue;
    14576. 

  14576.         }
    14577. 

  14577. #endif
    14578. 

  14578. #ifdef GL_NV_vertex_program4
    14579. 

  14579.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program4", 15))
    14580. 

  14580.         {
    14581. 

  14581.           ret = GLEW_NV_vertex_program4;
    14582. 

  14582.           continue;
    14583. 

  14583.         }
    14584. 

  14584. #endif
    14585. 

  14585. #ifdef GL_NV_video_capture
    14586. 

  14586.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_capture", 13))
    14587. 

  14587.         {
    14588. 

  14588.           ret = GLEW_NV_video_capture;
    14589. 

  14589.           continue;
    14590. 

  14590.         }
    14591. 

  14591. #endif
    14592. 

  14592.       }
    14593. 

  14593.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"OES_", 4))
    14594. 

  14594.       {
    14595. 

  14595. #ifdef GL_OES_byte_coordinates
    14596. 

  14596.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"byte_coordinates", 16))
    14597. 

  14597.         {
    14598. 

  14598.           ret = GLEW_OES_byte_coordinates;
    14599. 

  14599.           continue;
    14600. 

  14600.         }
    14601. 

  14601. #endif
    14602. 

  14602. #ifdef GL_OES_compressed_paletted_texture
    14603. 

  14603.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_paletted_texture", 27))
    14604. 

  14604.         {
    14605. 

  14605.           ret = GLEW_OES_compressed_paletted_texture;
    14606. 

  14606.           continue;
    14607. 

  14607.         }
    14608. 

  14608. #endif
    14609. 

  14609. #ifdef GL_OES_read_format
    14610. 

  14610.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_format", 11))
    14611. 

  14611.         {
    14612. 

  14612.           ret = GLEW_OES_read_format;
    14613. 

  14613.           continue;
    14614. 

  14614.         }
    14615. 

  14615. #endif
    14616. 

  14616. #ifdef GL_OES_single_precision
    14617. 

  14617.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"single_precision", 16))
    14618. 

  14618.         {
    14619. 

  14619.           ret = GLEW_OES_single_precision;
    14620. 

  14620.           continue;
    14621. 

  14621.         }
    14622. 

  14622. #endif
    14623. 

  14623.       }
    14624. 

  14624.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))
    14625. 

  14625.       {
    14626. 

  14626. #ifdef GL_OML_interlace
    14627. 

  14627.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9))
    14628. 

  14628.         {
    14629. 

  14629.           ret = GLEW_OML_interlace;
    14630. 

  14630.           continue;
    14631. 

  14631.         }
    14632. 

  14632. #endif
    14633. 

  14633. #ifdef GL_OML_resample
    14634. 

  14634.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8))
    14635. 

  14635.         {
    14636. 

  14636.           ret = GLEW_OML_resample;
    14637. 

  14637.           continue;
    14638. 

  14638.         }
    14639. 

  14639. #endif
    14640. 

  14640. #ifdef GL_OML_subsample
    14641. 

  14641.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"subsample", 9))
    14642. 

  14642.         {
    14643. 

  14643.           ret = GLEW_OML_subsample;
    14644. 

  14644.           continue;
    14645. 

  14645.         }
    14646. 

  14646. #endif
    14647. 

  14647.       }
    14648. 

  14648.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"PGI_", 4))
    14649. 

  14649.       {
    14650. 

  14650. #ifdef GL_PGI_misc_hints
    14651. 

  14651.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_hints", 10))
    14652. 

  14652.         {
    14653. 

  14653.           ret = GLEW_PGI_misc_hints;
    14654. 

  14654.           continue;
    14655. 

  14655.         }
    14656. 

  14656. #endif
    14657. 

  14657. #ifdef GL_PGI_vertex_hints
    14658. 

  14658.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_hints", 12))
    14659. 

  14659.         {
    14660. 

  14660.           ret = GLEW_PGI_vertex_hints;
    14661. 

  14661.           continue;
    14662. 

  14662.         }
    14663. 

  14663. #endif
    14664. 

  14664.       }
    14665. 

  14665.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"REND_", 5))
    14666. 

  14666.       {
    14667. 

  14667. #ifdef GL_REND_screen_coordinates
    14668. 

  14668.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"screen_coordinates", 18))
    14669. 

  14669.         {
    14670. 

  14670.           ret = GLEW_REND_screen_coordinates;
    14671. 

  14671.           continue;
    14672. 

  14672.         }
    14673. 

  14673. #endif
    14674. 

  14674.       }
    14675. 

  14675.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"S3_", 3))
    14676. 

  14676.       {
    14677. 

  14677. #ifdef GL_S3_s3tc
    14678. 

  14678.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"s3tc", 4))
    14679. 

  14679.         {
    14680. 

  14680.           ret = GLEW_S3_s3tc;
    14681. 

  14681.           continue;
    14682. 

  14682.         }
    14683. 

  14683. #endif
    14684. 

  14684.       }
    14685. 

  14685.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5))
    14686. 

  14686.       {
    14687. 

  14687. #ifdef GL_SGIS_color_range
    14688. 

  14688.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11))
    14689. 

  14689.         {
    14690. 

  14690.           ret = GLEW_SGIS_color_range;
    14691. 

  14691.           continue;
    14692. 

  14692.         }
    14693. 

  14693. #endif
    14694. 

  14694. #ifdef GL_SGIS_detail_texture
    14695. 

  14695.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"detail_texture", 14))
    14696. 

  14696.         {
    14697. 

  14697.           ret = GLEW_SGIS_detail_texture;
    14698. 

  14698.           continue;
    14699. 

  14699.         }
    14700. 

  14700. #endif
    14701. 

  14701. #ifdef GL_SGIS_fog_function
    14702. 

  14702.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_function", 12))
    14703. 

  14703.         {
    14704. 

  14704.           ret = GLEW_SGIS_fog_function;
    14705. 

  14705.           continue;
    14706. 

  14706.         }
    14707. 

  14707. #endif
    14708. 

  14708. #ifdef GL_SGIS_generate_mipmap
    14709. 

  14709.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"generate_mipmap", 15))
    14710. 

  14710.         {
    14711. 

  14711.           ret = GLEW_SGIS_generate_mipmap;
    14712. 

  14712.           continue;
    14713. 

  14713.         }
    14714. 

  14714. #endif
    14715. 

  14715. #ifdef GL_SGIS_multisample
    14716. 

  14716.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
    14717. 

  14717.         {
    14718. 

  14718.           ret = GLEW_SGIS_multisample;
    14719. 

  14719.           continue;
    14720. 

  14720.         }
    14721. 

  14721. #endif
    14722. 

  14722. #ifdef GL_SGIS_pixel_texture
    14723. 

  14723.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13))
    14724. 

  14724.         {
    14725. 

  14725.           ret = GLEW_SGIS_pixel_texture;
    14726. 

  14726.           continue;
    14727. 

  14727.         }
    14728. 

  14728. #endif
    14729. 

  14729. #ifdef GL_SGIS_point_line_texgen
    14730. 

  14730.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_line_texgen", 17))
    14731. 

  14731.         {
    14732. 

  14732.           ret = GLEW_SGIS_point_line_texgen;
    14733. 

  14733.           continue;
    14734. 

  14734.         }
    14735. 

  14735. #endif
    14736. 

  14736. #ifdef GL_SGIS_sharpen_texture
    14737. 

  14737.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"sharpen_texture", 15))
    14738. 

  14738.         {
    14739. 

  14739.           ret = GLEW_SGIS_sharpen_texture;
    14740. 

  14740.           continue;
    14741. 

  14741.         }
    14742. 

  14742. #endif
    14743. 

  14743. #ifdef GL_SGIS_texture4D
    14744. 

  14744.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture4D", 9))
    14745. 

  14745.         {
    14746. 

  14746.           ret = GLEW_SGIS_texture4D;
    14747. 

  14747.           continue;
    14748. 

  14748.         }
    14749. 

  14749. #endif
    14750. 

  14750. #ifdef GL_SGIS_texture_border_clamp
    14751. 

  14751.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20))
    14752. 

  14752.         {
    14753. 

  14753.           ret = GLEW_SGIS_texture_border_clamp;
    14754. 

  14754.           continue;
    14755. 

  14755.         }
    14756. 

  14756. #endif
    14757. 

  14757. #ifdef GL_SGIS_texture_edge_clamp
    14758. 

  14758.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18))
    14759. 

  14759.         {
    14760. 

  14760.           ret = GLEW_SGIS_texture_edge_clamp;
    14761. 

  14761.           continue;
    14762. 

  14762.         }
    14763. 

  14763. #endif
    14764. 

  14764. #ifdef GL_SGIS_texture_filter4
    14765. 

  14765.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter4", 15))
    14766. 

  14766.         {
    14767. 

  14767.           ret = GLEW_SGIS_texture_filter4;
    14768. 

  14768.           continue;
    14769. 

  14769.         }
    14770. 

  14770. #endif
    14771. 

  14771. #ifdef GL_SGIS_texture_lod
    14772. 

  14772.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod", 11))
    14773. 

  14773.         {
    14774. 

  14774.           ret = GLEW_SGIS_texture_lod;
    14775. 

  14775.           continue;
    14776. 

  14776.         }
    14777. 

  14777. #endif
    14778. 

  14778. #ifdef GL_SGIS_texture_select
    14779. 

  14779.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_select", 14))
    14780. 

  14780.         {
    14781. 

  14781.           ret = GLEW_SGIS_texture_select;
    14782. 

  14782.           continue;
    14783. 

  14783.         }
    14784. 

  14784. #endif
    14785. 

  14785.       }
    14786. 

  14786.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5))
    14787. 

  14787.       {
    14788. 

  14788. #ifdef GL_SGIX_async
    14789. 

  14789.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"async", 5))
    14790. 

  14790.         {
    14791. 

  14791.           ret = GLEW_SGIX_async;
    14792. 

  14792.           continue;
    14793. 

  14793.         }
    14794. 

  14794. #endif
    14795. 

  14795. #ifdef GL_SGIX_async_histogram
    14796. 

  14796.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_histogram", 15))
    14797. 

  14797.         {
    14798. 

  14798.           ret = GLEW_SGIX_async_histogram;
    14799. 

  14799.           continue;
    14800. 

  14800.         }
    14801. 

  14801. #endif
    14802. 

  14802. #ifdef GL_SGIX_async_pixel
    14803. 

  14803.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_pixel", 11))
    14804. 

  14804.         {
    14805. 

  14805.           ret = GLEW_SGIX_async_pixel;
    14806. 

  14806.           continue;
    14807. 

  14807.         }
    14808. 

  14808. #endif
    14809. 

  14809. #ifdef GL_SGIX_blend_alpha_minmax
    14810. 

  14810.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_alpha_minmax", 18))
    14811. 

  14811.         {
    14812. 

  14812.           ret = GLEW_SGIX_blend_alpha_minmax;
    14813. 

  14813.           continue;
    14814. 

  14814.         }
    14815. 

  14815. #endif
    14816. 

  14816. #ifdef GL_SGIX_clipmap
    14817. 

  14817.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"clipmap", 7))
    14818. 

  14818.         {
    14819. 

  14819.           ret = GLEW_SGIX_clipmap;
    14820. 

  14820.           continue;
    14821. 

  14821.         }
    14822. 

  14822. #endif
    14823. 

  14823. #ifdef GL_SGIX_convolution_accuracy
    14824. 

  14824.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_accuracy", 20))
    14825. 

  14825.         {
    14826. 

  14826.           ret = GLEW_SGIX_convolution_accuracy;
    14827. 

  14827.           continue;
    14828. 

  14828.         }
    14829. 

  14829. #endif
    14830. 

  14830. #ifdef GL_SGIX_depth_texture
    14831. 

  14831.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13))
    14832. 

  14832.         {
    14833. 

  14833.           ret = GLEW_SGIX_depth_texture;
    14834. 

  14834.           continue;
    14835. 

  14835.         }
    14836. 

  14836. #endif
    14837. 

  14837. #ifdef GL_SGIX_flush_raster
    14838. 

  14838.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_raster", 12))
    14839. 

  14839.         {
    14840. 

  14840.           ret = GLEW_SGIX_flush_raster;
    14841. 

  14841.           continue;
    14842. 

  14842.         }
    14843. 

  14843. #endif
    14844. 

  14844. #ifdef GL_SGIX_fog_offset
    14845. 

  14845.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_offset", 10))
    14846. 

  14846.         {
    14847. 

  14847.           ret = GLEW_SGIX_fog_offset;
    14848. 

  14848.           continue;
    14849. 

  14849.         }
    14850. 

  14850. #endif
    14851. 

  14851. #ifdef GL_SGIX_fog_texture
    14852. 

  14852.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_texture", 11))
    14853. 

  14853.         {
    14854. 

  14854.           ret = GLEW_SGIX_fog_texture;
    14855. 

  14855.           continue;
    14856. 

  14856.         }
    14857. 

  14857. #endif
    14858. 

  14858. #ifdef GL_SGIX_fragment_specular_lighting
    14859. 

  14859.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_specular_lighting", 26))
    14860. 

  14860.         {
    14861. 

  14861.           ret = GLEW_SGIX_fragment_specular_lighting;
    14862. 

  14862.           continue;
    14863. 

  14863.         }
    14864. 

  14864. #endif
    14865. 

  14865. #ifdef GL_SGIX_framezoom
    14866. 

  14866.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"framezoom", 9))
    14867. 

  14867.         {
    14868. 

  14868.           ret = GLEW_SGIX_framezoom;
    14869. 

  14869.           continue;
    14870. 

  14870.         }
    14871. 

  14871. #endif
    14872. 

  14872. #ifdef GL_SGIX_interlace
    14873. 

  14873.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9))
    14874. 

  14874.         {
    14875. 

  14875.           ret = GLEW_SGIX_interlace;
    14876. 

  14876.           continue;
    14877. 

  14877.         }
    14878. 

  14878. #endif
    14879. 

  14879. #ifdef GL_SGIX_ir_instrument1
    14880. 

  14880.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"ir_instrument1", 14))
    14881. 

  14881.         {
    14882. 

  14882.           ret = GLEW_SGIX_ir_instrument1;
    14883. 

  14883.           continue;
    14884. 

  14884.         }
    14885. 

  14885. #endif
    14886. 

  14886. #ifdef GL_SGIX_list_priority
    14887. 

  14887.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"list_priority", 13))
    14888. 

  14888.         {
    14889. 

  14889.           ret = GLEW_SGIX_list_priority;
    14890. 

  14890.           continue;
    14891. 

  14891.         }
    14892. 

  14892. #endif
    14893. 

  14893. #ifdef GL_SGIX_pixel_texture
    14894. 

  14894.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13))
    14895. 

  14895.         {
    14896. 

  14896.           ret = GLEW_SGIX_pixel_texture;
    14897. 

  14897.           continue;
    14898. 

  14898.         }
    14899. 

  14899. #endif
    14900. 

  14900. #ifdef GL_SGIX_pixel_texture_bits
    14901. 

  14901.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture_bits", 18))
    14902. 

  14902.         {
    14903. 

  14903.           ret = GLEW_SGIX_pixel_texture_bits;
    14904. 

  14904.           continue;
    14905. 

  14905.         }
    14906. 

  14906. #endif
    14907. 

  14907. #ifdef GL_SGIX_reference_plane
    14908. 

  14908.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"reference_plane", 15))
    14909. 

  14909.         {
    14910. 

  14910.           ret = GLEW_SGIX_reference_plane;
    14911. 

  14911.           continue;
    14912. 

  14912.         }
    14913. 

  14913. #endif
    14914. 

  14914. #ifdef GL_SGIX_resample
    14915. 

  14915.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8))
    14916. 

  14916.         {
    14917. 

  14917.           ret = GLEW_SGIX_resample;
    14918. 

  14918.           continue;
    14919. 

  14919.         }
    14920. 

  14920. #endif
    14921. 

  14921. #ifdef GL_SGIX_shadow
    14922. 

  14922.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6))
    14923. 

  14923.         {
    14924. 

  14924.           ret = GLEW_SGIX_shadow;
    14925. 

  14925.           continue;
    14926. 

  14926.         }
    14927. 

  14927. #endif
    14928. 

  14928. #ifdef GL_SGIX_shadow_ambient
    14929. 

  14929.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14))
    14930. 

  14930.         {
    14931. 

  14931.           ret = GLEW_SGIX_shadow_ambient;
    14932. 

  14932.           continue;
    14933. 

  14933.         }
    14934. 

  14934. #endif
    14935. 

  14935. #ifdef GL_SGIX_sprite
    14936. 

  14936.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"sprite", 6))
    14937. 

  14937.         {
    14938. 

  14938.           ret = GLEW_SGIX_sprite;
    14939. 

  14939.           continue;
    14940. 

  14940.         }
    14941. 

  14941. #endif
    14942. 

  14942. #ifdef GL_SGIX_tag_sample_buffer
    14943. 

  14943.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"tag_sample_buffer", 17))
    14944. 

  14944.         {
    14945. 

  14945.           ret = GLEW_SGIX_tag_sample_buffer;
    14946. 

  14946.           continue;
    14947. 

  14947.         }
    14948. 

  14948. #endif
    14949. 

  14949. #ifdef GL_SGIX_texture_add_env
    14950. 

  14950.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_add_env", 15))
    14951. 

  14951.         {
    14952. 

  14952.           ret = GLEW_SGIX_texture_add_env;
    14953. 

  14953.           continue;
    14954. 

  14954.         }
    14955. 

  14955. #endif
    14956. 

  14956. #ifdef GL_SGIX_texture_coordinate_clamp
    14957. 

  14957.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_coordinate_clamp", 24))
    14958. 

  14958.         {
    14959. 

  14959.           ret = GLEW_SGIX_texture_coordinate_clamp;
    14960. 

  14960.           continue;
    14961. 

  14961.         }
    14962. 

  14962. #endif
    14963. 

  14963. #ifdef GL_SGIX_texture_lod_bias
    14964. 

  14964.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16))
    14965. 

  14965.         {
    14966. 

  14966.           ret = GLEW_SGIX_texture_lod_bias;
    14967. 

  14967.           continue;
    14968. 

  14968.         }
    14969. 

  14969. #endif
    14970. 

  14970. #ifdef GL_SGIX_texture_multi_buffer
    14971. 

  14971.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multi_buffer", 20))
    14972. 

  14972.         {
    14973. 

  14973.           ret = GLEW_SGIX_texture_multi_buffer;
    14974. 

  14974.           continue;
    14975. 

  14975.         }
    14976. 

  14976. #endif
    14977. 

  14977. #ifdef GL_SGIX_texture_range
    14978. 

  14978.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13))
    14979. 

  14979.         {
    14980. 

  14980.           ret = GLEW_SGIX_texture_range;
    14981. 

  14981.           continue;
    14982. 

  14982.         }
    14983. 

  14983. #endif
    14984. 

  14984. #ifdef GL_SGIX_texture_scale_bias
    14985. 

  14985.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scale_bias", 18))
    14986. 

  14986.         {
    14987. 

  14987.           ret = GLEW_SGIX_texture_scale_bias;
    14988. 

  14988.           continue;
    14989. 

  14989.         }
    14990. 

  14990. #endif
    14991. 

  14991. #ifdef GL_SGIX_vertex_preclip
    14992. 

  14992.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip", 14))
    14993. 

  14993.         {
    14994. 

  14994.           ret = GLEW_SGIX_vertex_preclip;
    14995. 

  14995.           continue;
    14996. 

  14996.         }
    14997. 

  14997. #endif
    14998. 

  14998. #ifdef GL_SGIX_vertex_preclip_hint
    14999. 

  14999.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip_hint", 19))
    15000. 

  15000.         {
    15001. 

  15001.           ret = GLEW_SGIX_vertex_preclip_hint;
    15002. 

  15002.           continue;
    15003. 

  15003.         }
    15004. 

  15004. #endif
    15005. 

  15005. #ifdef GL_SGIX_ycrcb
    15006. 

  15006.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycrcb", 5))
    15007. 

  15007.         {
    15008. 

  15008.           ret = GLEW_SGIX_ycrcb;
    15009. 

  15009.           continue;
    15010. 

  15010.         }
    15011. 

  15011. #endif
    15012. 

  15012.       }
    15013. 

  15013.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4))
    15014. 

  15014.       {
    15015. 

  15015. #ifdef GL_SGI_color_matrix
    15016. 

  15016.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_matrix", 12))
    15017. 

  15017.         {
    15018. 

  15018.           ret = GLEW_SGI_color_matrix;
    15019. 

  15019.           continue;
    15020. 

  15020.         }
    15021. 

  15021. #endif
    15022. 

  15022. #ifdef GL_SGI_color_table
    15023. 

  15023.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_table", 11))
    15024. 

  15024.         {
    15025. 

  15025.           ret = GLEW_SGI_color_table;
    15026. 

  15026.           continue;
    15027. 

  15027.         }
    15028. 

  15028. #endif
    15029. 

  15029. #ifdef GL_SGI_texture_color_table
    15030. 

  15030.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_color_table", 19))
    15031. 

  15031.         {
    15032. 

  15032.           ret = GLEW_SGI_texture_color_table;
    15033. 

  15033.           continue;
    15034. 

  15034.         }
    15035. 

  15035. #endif
    15036. 

  15036.       }
    15037. 

  15037.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUNX_", 5))
    15038. 

  15038.       {
    15039. 

  15039. #ifdef GL_SUNX_constant_data
    15040. 

  15040.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"constant_data", 13))
    15041. 

  15041.         {
    15042. 

  15042.           ret = GLEW_SUNX_constant_data;
    15043. 

  15043.           continue;
    15044. 

  15044.         }
    15045. 

  15045. #endif
    15046. 

  15046.       }
    15047. 

  15047.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4))
    15048. 

  15048.       {
    15049. 

  15049. #ifdef GL_SUN_convolution_border_modes
    15050. 

  15050.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24))
    15051. 

  15051.         {
    15052. 

  15052.           ret = GLEW_SUN_convolution_border_modes;
    15053. 

  15053.           continue;
    15054. 

  15054.         }
    15055. 

  15055. #endif
    15056. 

  15056. #ifdef GL_SUN_global_alpha
    15057. 

  15057.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"global_alpha", 12))
    15058. 

  15058.         {
    15059. 

  15059.           ret = GLEW_SUN_global_alpha;
    15060. 

  15060.           continue;
    15061. 

  15061.         }
    15062. 

  15062. #endif
    15063. 

  15063. #ifdef GL_SUN_mesh_array
    15064. 

  15064.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"mesh_array", 10))
    15065. 

  15065.         {
    15066. 

  15066.           ret = GLEW_SUN_mesh_array;
    15067. 

  15067.           continue;
    15068. 

  15068.         }
    15069. 

  15069. #endif
    15070. 

  15070. #ifdef GL_SUN_read_video_pixels
    15071. 

  15071.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_video_pixels", 17))
    15072. 

  15072.         {
    15073. 

  15073.           ret = GLEW_SUN_read_video_pixels;
    15074. 

  15074.           continue;
    15075. 

  15075.         }
    15076. 

  15076. #endif
    15077. 

  15077. #ifdef GL_SUN_slice_accum
    15078. 

  15078.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"slice_accum", 11))
    15079. 

  15079.         {
    15080. 

  15080.           ret = GLEW_SUN_slice_accum;
    15081. 

  15081.           continue;
    15082. 

  15082.         }
    15083. 

  15083. #endif
    15084. 

  15084. #ifdef GL_SUN_triangle_list
    15085. 

  15085.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"triangle_list", 13))
    15086. 

  15086.         {
    15087. 

  15087.           ret = GLEW_SUN_triangle_list;
    15088. 

  15088.           continue;
    15089. 

  15089.         }
    15090. 

  15090. #endif
    15091. 

  15091. #ifdef GL_SUN_vertex
    15092. 

  15092.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex", 6))
    15093. 

  15093.         {
    15094. 

  15094.           ret = GLEW_SUN_vertex;
    15095. 

  15095.           continue;
    15096. 

  15096.         }
    15097. 

  15097. #endif
    15098. 

  15098.       }
    15099. 

  15099.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"WIN_", 4))
    15100. 

  15100.       {
    15101. 

  15101. #ifdef GL_WIN_phong_shading
    15102. 

  15102.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"phong_shading", 13))
    15103. 

  15103.         {
    15104. 

  15104.           ret = GLEW_WIN_phong_shading;
    15105. 

  15105.           continue;
    15106. 

  15106.         }
    15107. 

  15107. #endif
    15108. 

  15108. #ifdef GL_WIN_specular_fog
    15109. 

  15109.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_fog", 12))
    15110. 

  15110.         {
    15111. 

  15111.           ret = GLEW_WIN_specular_fog;
    15112. 

  15112.           continue;
    15113. 

  15113.         }
    15114. 

  15114. #endif
    15115. 

  15115. #ifdef GL_WIN_swap_hint
    15116. 

  15116.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_hint", 9))
    15117. 

  15117.         {
    15118. 

  15118.           ret = GLEW_WIN_swap_hint;
    15119. 

  15119.           continue;
    15120. 

  15120.         }
    15121. 

  15121. #endif
    15122. 

  15122.       }
    15123. 

  15123.     }
    15124. 

  15124.     ret = (len == 0);
    15125. 

  15125.   }
    15126. 

  15126.   return ret;
    15127. 

  15127. }
    15128. 

  15128. 

  15129. #if defined(_WIN32)
    15130. 

  15130. 

  15131. #if defined(GLEW_MX)
    15132. 

  15132. GLboolean wglewContextIsSupported (const WGLEWContext* ctx, const char* name)
    15133. 

  15133. #else
    15134. 

  15134. GLboolean wglewIsSupported (const char* name)
    15135. 

  15135. #endif
    15136. 

  15136. {
    15137. 

  15137.   GLubyte* pos = (GLubyte*)name;
    15138. 

  15138.   GLuint len = _glewStrLen(pos);
    15139. 

  15139.   GLboolean ret = GL_TRUE;
    15140. 

  15140.   while (ret && len > 0)
    15141. 

  15141.   {
    15142. 

  15142.     if (_glewStrSame1(&pos, &len, (const GLubyte*)"WGL_", 4))
    15143. 

  15143.     {
    15144. 

  15144.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))
    15145. 

  15145.       {
    15146. 

  15146. #ifdef WGL_3DFX_multisample
    15147. 

  15147.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
    15148. 

  15148.         {
    15149. 

  15149.           ret = WGLEW_3DFX_multisample;
    15150. 

  15150.           continue;
    15151. 

  15151.         }
    15152. 

  15152. #endif
    15153. 

  15153.       }
    15154. 

  15154.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DL_", 4))
    15155. 

  15155.       {
    15156. 

  15156. #ifdef WGL_3DL_stereo_control
    15157. 

  15157.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"stereo_control", 14))
    15158. 

  15158.         {
    15159. 

  15159.           ret = WGLEW_3DL_stereo_control;
    15160. 

  15160.           continue;
    15161. 

  15161.         }
    15162. 

  15162. #endif
    15163. 

  15163.       }
    15164. 

  15164.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4))
    15165. 

  15165.       {
    15166. 

  15166. #ifdef WGL_AMD_gpu_association
    15167. 

  15167.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_association", 15))
    15168. 

  15168.         {
    15169. 

  15169.           ret = WGLEW_AMD_gpu_association;
    15170. 

  15170.           continue;
    15171. 

  15171.         }
    15172. 

  15172. #endif
    15173. 

  15173.       }
    15174. 

  15174.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))
    15175. 

  15175.       {
    15176. 

  15176. #ifdef WGL_ARB_buffer_region
    15177. 

  15177.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13))
    15178. 

  15178.         {
    15179. 

  15179.           ret = WGLEW_ARB_buffer_region;
    15180. 

  15180.           continue;
    15181. 

  15181.         }
    15182. 

  15182. #endif
    15183. 

  15183. #ifdef WGL_ARB_create_context
    15184. 

  15184.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context", 14))
    15185. 

  15185.         {
    15186. 

  15186.           ret = WGLEW_ARB_create_context;
    15187. 

  15187.           continue;
    15188. 

  15188.         }
    15189. 

  15189. #endif
    15190. 

  15190. #ifdef WGL_ARB_create_context_profile
    15191. 

  15191.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_profile", 22))
    15192. 

  15192.         {
    15193. 

  15193.           ret = WGLEW_ARB_create_context_profile;
    15194. 

  15194.           continue;
    15195. 

  15195.         }
    15196. 

  15196. #endif
    15197. 

  15197. #ifdef WGL_ARB_create_context_robustness
    15198. 

  15198.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_robustness", 25))
    15199. 

  15199.         {
    15200. 

  15200.           ret = WGLEW_ARB_create_context_robustness;
    15201. 

  15201.           continue;
    15202. 

  15202.         }
    15203. 

  15203. #endif
    15204. 

  15204. #ifdef WGL_ARB_extensions_string
    15205. 

  15205.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17))
    15206. 

  15206.         {
    15207. 

  15207.           ret = WGLEW_ARB_extensions_string;
    15208. 

  15208.           continue;
    15209. 

  15209.         }
    15210. 

  15210. #endif
    15211. 

  15211. #ifdef WGL_ARB_framebuffer_sRGB
    15212. 

  15212.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))
    15213. 

  15213.         {
    15214. 

  15214.           ret = WGLEW_ARB_framebuffer_sRGB;
    15215. 

  15215.           continue;
    15216. 

  15216.         }
    15217. 

  15217. #endif
    15218. 

  15218. #ifdef WGL_ARB_make_current_read
    15219. 

  15219.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))
    15220. 

  15220.         {
    15221. 

  15221.           ret = WGLEW_ARB_make_current_read;
    15222. 

  15222.           continue;
    15223. 

  15223.         }
    15224. 

  15224. #endif
    15225. 

  15225. #ifdef WGL_ARB_multisample
    15226. 

  15226.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
    15227. 

  15227.         {
    15228. 

  15228.           ret = WGLEW_ARB_multisample;
    15229. 

  15229.           continue;
    15230. 

  15230.         }
    15231. 

  15231. #endif
    15232. 

  15232. #ifdef WGL_ARB_pbuffer
    15233. 

  15233.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))
    15234. 

  15234.         {
    15235. 

  15235.           ret = WGLEW_ARB_pbuffer;
    15236. 

  15236.           continue;
    15237. 

  15237.         }
    15238. 

  15238. #endif
    15239. 

  15239. #ifdef WGL_ARB_pixel_format
    15240. 

  15240.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12))
    15241. 

  15241.         {
    15242. 

  15242.           ret = WGLEW_ARB_pixel_format;
    15243. 

  15243.           continue;
    15244. 

  15244.         }
    15245. 

  15245. #endif
    15246. 

  15246. #ifdef WGL_ARB_pixel_format_float
    15247. 

  15247.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))
    15248. 

  15248.         {
    15249. 

  15249.           ret = WGLEW_ARB_pixel_format_float;
    15250. 

  15250.           continue;
    15251. 

  15251.         }
    15252. 

  15252. #endif
    15253. 

  15253. #ifdef WGL_ARB_render_texture
    15254. 

  15254.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14))
    15255. 

  15255.         {
    15256. 

  15256.           ret = WGLEW_ARB_render_texture;
    15257. 

  15257.           continue;
    15258. 

  15258.         }
    15259. 

  15259. #endif
    15260. 

  15260.       }
    15261. 

  15261.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))
    15262. 

  15262.       {
    15263. 

  15263. #ifdef WGL_ATI_pixel_format_float
    15264. 

  15264.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))
    15265. 

  15265.         {
    15266. 

  15266.           ret = WGLEW_ATI_pixel_format_float;
    15267. 

  15267.           continue;
    15268. 

  15268.         }
    15269. 

  15269. #endif
    15270. 

  15270. #ifdef WGL_ATI_render_texture_rectangle
    15271. 

  15271.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24))
    15272. 

  15272.         {
    15273. 

  15273.           ret = WGLEW_ATI_render_texture_rectangle;
    15274. 

  15274.           continue;
    15275. 

  15275.         }
    15276. 

  15276. #endif
    15277. 

  15277.       }
    15278. 

  15278.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))
    15279. 

  15279.       {
    15280. 

  15280. #ifdef WGL_EXT_create_context_es2_profile
    15281. 

  15281.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es2_profile", 26))
    15282. 

  15282.         {
    15283. 

  15283.           ret = WGLEW_EXT_create_context_es2_profile;
    15284. 

  15284.           continue;
    15285. 

  15285.         }
    15286. 

  15286. #endif
    15287. 

  15287. #ifdef WGL_EXT_depth_float
    15288. 

  15288.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_float", 11))
    15289. 

  15289.         {
    15290. 

  15290.           ret = WGLEW_EXT_depth_float;
    15291. 

  15291.           continue;
    15292. 

  15292.         }
    15293. 

  15293. #endif
    15294. 

  15294. #ifdef WGL_EXT_display_color_table
    15295. 

  15295.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"display_color_table", 19))
    15296. 

  15296.         {
    15297. 

  15297.           ret = WGLEW_EXT_display_color_table;
    15298. 

  15298.           continue;
    15299. 

  15299.         }
    15300. 

  15300. #endif
    15301. 

  15301. #ifdef WGL_EXT_extensions_string
    15302. 

  15302.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17))
    15303. 

  15303.         {
    15304. 

  15304.           ret = WGLEW_EXT_extensions_string;
    15305. 

  15305.           continue;
    15306. 

  15306.         }
    15307. 

  15307. #endif
    15308. 

  15308. #ifdef WGL_EXT_framebuffer_sRGB
    15309. 

  15309.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))
    15310. 

  15310.         {
    15311. 

  15311.           ret = WGLEW_EXT_framebuffer_sRGB;
    15312. 

  15312.           continue;
    15313. 

  15313.         }
    15314. 

  15314. #endif
    15315. 

  15315. #ifdef WGL_EXT_make_current_read
    15316. 

  15316.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))
    15317. 

  15317.         {
    15318. 

  15318.           ret = WGLEW_EXT_make_current_read;
    15319. 

  15319.           continue;
    15320. 

  15320.         }
    15321. 

  15321. #endif
    15322. 

  15322. #ifdef WGL_EXT_multisample
    15323. 

  15323.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
    15324. 

  15324.         {
    15325. 

  15325.           ret = WGLEW_EXT_multisample;
    15326. 

  15326.           continue;
    15327. 

  15327.         }
    15328. 

  15328. #endif
    15329. 

  15329. #ifdef WGL_EXT_pbuffer
    15330. 

  15330.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))
    15331. 

  15331.         {
    15332. 

  15332.           ret = WGLEW_EXT_pbuffer;
    15333. 

  15333.           continue;
    15334. 

  15334.         }
    15335. 

  15335. #endif
    15336. 

  15336. #ifdef WGL_EXT_pixel_format
    15337. 

  15337.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12))
    15338. 

  15338.         {
    15339. 

  15339.           ret = WGLEW_EXT_pixel_format;
    15340. 

  15340.           continue;
    15341. 

  15341.         }
    15342. 

  15342. #endif
    15343. 

  15343. #ifdef WGL_EXT_pixel_format_packed_float
    15344. 

  15344.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_packed_float", 25))
    15345. 

  15345.         {
    15346. 

  15346.           ret = WGLEW_EXT_pixel_format_packed_float;
    15347. 

  15347.           continue;
    15348. 

  15348.         }
    15349. 

  15349. #endif
    15350. 

  15350. #ifdef WGL_EXT_swap_control
    15351. 

  15351.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))
    15352. 

  15352.         {
    15353. 

  15353.           ret = WGLEW_EXT_swap_control;
    15354. 

  15354.           continue;
    15355. 

  15355.         }
    15356. 

  15356. #endif
    15357. 

  15357.       }
    15358. 

  15358.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"I3D_", 4))
    15359. 

  15359.       {
    15360. 

  15360. #ifdef WGL_I3D_digital_video_control
    15361. 

  15361.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"digital_video_control", 21))
    15362. 

  15362.         {
    15363. 

  15363.           ret = WGLEW_I3D_digital_video_control;
    15364. 

  15364.           continue;
    15365. 

  15365.         }
    15366. 

  15366. #endif
    15367. 

  15367. #ifdef WGL_I3D_gamma
    15368. 

  15368.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"gamma", 5))
    15369. 

  15369.         {
    15370. 

  15370.           ret = WGLEW_I3D_gamma;
    15371. 

  15371.           continue;
    15372. 

  15372.         }
    15373. 

  15373. #endif
    15374. 

  15374. #ifdef WGL_I3D_genlock
    15375. 

  15375.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"genlock", 7))
    15376. 

  15376.         {
    15377. 

  15377.           ret = WGLEW_I3D_genlock;
    15378. 

  15378.           continue;
    15379. 

  15379.         }
    15380. 

  15380. #endif
    15381. 

  15381. #ifdef WGL_I3D_image_buffer
    15382. 

  15382.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_buffer", 12))
    15383. 

  15383.         {
    15384. 

  15384.           ret = WGLEW_I3D_image_buffer;
    15385. 

  15385.           continue;
    15386. 

  15386.         }
    15387. 

  15387. #endif
    15388. 

  15388. #ifdef WGL_I3D_swap_frame_lock
    15389. 

  15389.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_lock", 15))
    15390. 

  15390.         {
    15391. 

  15391.           ret = WGLEW_I3D_swap_frame_lock;
    15392. 

  15392.           continue;
    15393. 

  15393.         }
    15394. 

  15394. #endif
    15395. 

  15395. #ifdef WGL_I3D_swap_frame_usage
    15396. 

  15396.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_usage", 16))
    15397. 

  15397.         {
    15398. 

  15398.           ret = WGLEW_I3D_swap_frame_usage;
    15399. 

  15399.           continue;
    15400. 

  15400.         }
    15401. 

  15401. #endif
    15402. 

  15402.       }
    15403. 

  15403.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))
    15404. 

  15404.       {
    15405. 

  15405. #ifdef WGL_NV_DX_interop
    15406. 

  15406.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"DX_interop", 10))
    15407. 

  15407.         {
    15408. 

  15408.           ret = WGLEW_NV_DX_interop;
    15409. 

  15409.           continue;
    15410. 

  15410.         }
    15411. 

  15411. #endif
    15412. 

  15412. #ifdef WGL_NV_copy_image
    15413. 

  15413.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10))
    15414. 

  15414.         {
    15415. 

  15415.           ret = WGLEW_NV_copy_image;
    15416. 

  15416.           continue;
    15417. 

  15417.         }
    15418. 

  15418. #endif
    15419. 

  15419. #ifdef WGL_NV_float_buffer
    15420. 

  15420.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))
    15421. 

  15421.         {
    15422. 

  15422.           ret = WGLEW_NV_float_buffer;
    15423. 

  15423.           continue;
    15424. 

  15424.         }
    15425. 

  15425. #endif
    15426. 

  15426. #ifdef WGL_NV_gpu_affinity
    15427. 

  15427.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_affinity", 12))
    15428. 

  15428.         {
    15429. 

  15429.           ret = WGLEW_NV_gpu_affinity;
    15430. 

  15430.           continue;
    15431. 

  15431.         }
    15432. 

  15432. #endif
    15433. 

  15433. #ifdef WGL_NV_multisample_coverage
    15434. 

  15434.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_coverage", 20))
    15435. 

  15435.         {
    15436. 

  15436.           ret = WGLEW_NV_multisample_coverage;
    15437. 

  15437.           continue;
    15438. 

  15438.         }
    15439. 

  15439. #endif
    15440. 

  15440. #ifdef WGL_NV_present_video
    15441. 

  15441.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13))
    15442. 

  15442.         {
    15443. 

  15443.           ret = WGLEW_NV_present_video;
    15444. 

  15444.           continue;
    15445. 

  15445.         }
    15446. 

  15446. #endif
    15447. 

  15447. #ifdef WGL_NV_render_depth_texture
    15448. 

  15448.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_depth_texture", 20))
    15449. 

  15449.         {
    15450. 

  15450.           ret = WGLEW_NV_render_depth_texture;
    15451. 

  15451.           continue;
    15452. 

  15452.         }
    15453. 

  15453. #endif
    15454. 

  15454. #ifdef WGL_NV_render_texture_rectangle
    15455. 

  15455.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24))
    15456. 

  15456.         {
    15457. 

  15457.           ret = WGLEW_NV_render_texture_rectangle;
    15458. 

  15458.           continue;
    15459. 

  15459.         }
    15460. 

  15460. #endif
    15461. 

  15461. #ifdef WGL_NV_swap_group
    15462. 

  15462.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10))
    15463. 

  15463.         {
    15464. 

  15464.           ret = WGLEW_NV_swap_group;
    15465. 

  15465.           continue;
    15466. 

  15466.         }
    15467. 

  15467. #endif
    15468. 

  15468. #ifdef WGL_NV_vertex_array_range
    15469. 

  15469.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))
    15470. 

  15470.         {
    15471. 

  15471.           ret = WGLEW_NV_vertex_array_range;
    15472. 

  15472.           continue;
    15473. 

  15473.         }
    15474. 

  15474. #endif
    15475. 

  15475. #ifdef WGL_NV_video_capture
    15476. 

  15476.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_capture", 13))
    15477. 

  15477.         {
    15478. 

  15478.           ret = WGLEW_NV_video_capture;
    15479. 

  15479.           continue;
    15480. 

  15480.         }
    15481. 

  15481. #endif
    15482. 

  15482. #ifdef WGL_NV_video_output
    15483. 

  15483.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_output", 12))
    15484. 

  15484.         {
    15485. 

  15485.           ret = WGLEW_NV_video_output;
    15486. 

  15486.           continue;
    15487. 

  15487.         }
    15488. 

  15488. #endif
    15489. 

  15489.       }
    15490. 

  15490.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))
    15491. 

  15491.       {
    15492. 

  15492. #ifdef WGL_OML_sync_control
    15493. 

  15493.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12))
    15494. 

  15494.         {
    15495. 

  15495.           ret = WGLEW_OML_sync_control;
    15496. 

  15496.           continue;
    15497. 

  15497.         }
    15498. 

  15498. #endif
    15499. 

  15499.       }
    15500. 

  15500.     }
    15501. 

  15501.     ret = (len == 0);
    15502. 

  15502.   }
    15503. 

  15503.   return ret;
    15504. 

  15504. }
    15505. 

  15505. 

  15506. #elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)
    15507. 

  15507. 

  15508. #if defined(GLEW_MX)
    15509. 

  15509. GLboolean glxewContextIsSupported (const GLXEWContext* ctx, const char* name)
    15510. 

  15510. #else
    15511. 

  15511. GLboolean glxewIsSupported (const char* name)
    15512. 

  15512. #endif
    15513. 

  15513. {
    15514. 

  15514.   GLubyte* pos = (GLubyte*)name;
    15515. 

  15515.   GLuint len = _glewStrLen(pos);
    15516. 

  15516.   GLboolean ret = GL_TRUE;
    15517. 

  15517.   while (ret && len > 0)
    15518. 

  15518.   {
    15519. 

  15519.     if(_glewStrSame1(&pos, &len, (const GLubyte*)"GLX_", 4))
    15520. 

  15520.     {
    15521. 

  15521.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8))
    15522. 

  15522.       {
    15523. 

  15523. #ifdef GLX_VERSION_1_2
    15524. 

  15524.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3))
    15525. 

  15525.         {
    15526. 

  15526.           ret = GLXEW_VERSION_1_2;
    15527. 

  15527.           continue;
    15528. 

  15528.         }
    15529. 

  15529. #endif
    15530. 

  15530. #ifdef GLX_VERSION_1_3
    15531. 

  15531.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3))
    15532. 

  15532.         {
    15533. 

  15533.           ret = GLXEW_VERSION_1_3;
    15534. 

  15534.           continue;
    15535. 

  15535.         }
    15536. 

  15536. #endif
    15537. 

  15537. #ifdef GLX_VERSION_1_4
    15538. 

  15538.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3))
    15539. 

  15539.         {
    15540. 

  15540.           ret = GLXEW_VERSION_1_4;
    15541. 

  15541.           continue;
    15542. 

  15542.         }
    15543. 

  15543. #endif
    15544. 

  15544.       }
    15545. 

  15545.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5))
    15546. 

  15546.       {
    15547. 

  15547. #ifdef GLX_3DFX_multisample
    15548. 

  15548.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
    15549. 

  15549.         {
    15550. 

  15550.           ret = GLXEW_3DFX_multisample;
    15551. 

  15551.           continue;
    15552. 

  15552.         }
    15553. 

  15553. #endif
    15554. 

  15554.       }
    15555. 

  15555.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"AMD_", 4))
    15556. 

  15556.       {
    15557. 

  15557. #ifdef GLX_AMD_gpu_association
    15558. 

  15558.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_association", 15))
    15559. 

  15559.         {
    15560. 

  15560.           ret = GLXEW_AMD_gpu_association;
    15561. 

  15561.           continue;
    15562. 

  15562.         }
    15563. 

  15563. #endif
    15564. 

  15564.       }
    15565. 

  15565.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4))
    15566. 

  15566.       {
    15567. 

  15567. #ifdef GLX_ARB_create_context
    15568. 

  15568.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context", 14))
    15569. 

  15569.         {
    15570. 

  15570.           ret = GLXEW_ARB_create_context;
    15571. 

  15571.           continue;
    15572. 

  15572.         }
    15573. 

  15573. #endif
    15574. 

  15574. #ifdef GLX_ARB_create_context_profile
    15575. 

  15575.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_profile", 22))
    15576. 

  15576.         {
    15577. 

  15577.           ret = GLXEW_ARB_create_context_profile;
    15578. 

  15578.           continue;
    15579. 

  15579.         }
    15580. 

  15580. #endif
    15581. 

  15581. #ifdef GLX_ARB_create_context_robustness
    15582. 

  15582.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_robustness", 25))
    15583. 

  15583.         {
    15584. 

  15584.           ret = GLXEW_ARB_create_context_robustness;
    15585. 

  15585.           continue;
    15586. 

  15586.         }
    15587. 

  15587. #endif
    15588. 

  15588. #ifdef GLX_ARB_fbconfig_float
    15589. 

  15589.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_float", 14))
    15590. 

  15590.         {
    15591. 

  15591.           ret = GLXEW_ARB_fbconfig_float;
    15592. 

  15592.           continue;
    15593. 

  15593.         }
    15594. 

  15594. #endif
    15595. 

  15595. #ifdef GLX_ARB_framebuffer_sRGB
    15596. 

  15596.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))
    15597. 

  15597.         {
    15598. 

  15598.           ret = GLXEW_ARB_framebuffer_sRGB;
    15599. 

  15599.           continue;
    15600. 

  15600.         }
    15601. 

  15601. #endif
    15602. 

  15602. #ifdef GLX_ARB_get_proc_address
    15603. 

  15603.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_proc_address", 16))
    15604. 

  15604.         {
    15605. 

  15605.           ret = GLXEW_ARB_get_proc_address;
    15606. 

  15606.           continue;
    15607. 

  15607.         }
    15608. 

  15608. #endif
    15609. 

  15609. #ifdef GLX_ARB_multisample
    15610. 

  15610.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
    15611. 

  15611.         {
    15612. 

  15612.           ret = GLXEW_ARB_multisample;
    15613. 

  15613.           continue;
    15614. 

  15614.         }
    15615. 

  15615. #endif
    15616. 

  15616. #ifdef GLX_ARB_vertex_buffer_object
    15617. 

  15617.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_object", 20))
    15618. 

  15618.         {
    15619. 

  15619.           ret = GLXEW_ARB_vertex_buffer_object;
    15620. 

  15620.           continue;
    15621. 

  15621.         }
    15622. 

  15622. #endif
    15623. 

  15623.       }
    15624. 

  15624.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4))
    15625. 

  15625.       {
    15626. 

  15626. #ifdef GLX_ATI_pixel_format_float
    15627. 

  15627.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18))
    15628. 

  15628.         {
    15629. 

  15629.           ret = GLXEW_ATI_pixel_format_float;
    15630. 

  15630.           continue;
    15631. 

  15631.         }
    15632. 

  15632. #endif
    15633. 

  15633. #ifdef GLX_ATI_render_texture
    15634. 

  15634.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14))
    15635. 

  15635.         {
    15636. 

  15636.           ret = GLXEW_ATI_render_texture;
    15637. 

  15637.           continue;
    15638. 

  15638.         }
    15639. 

  15639. #endif
    15640. 

  15640.       }
    15641. 

  15641.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4))
    15642. 

  15642.       {
    15643. 

  15643. #ifdef GLX_EXT_create_context_es2_profile
    15644. 

  15644.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es2_profile", 26))
    15645. 

  15645.         {
    15646. 

  15646.           ret = GLXEW_EXT_create_context_es2_profile;
    15647. 

  15647.           continue;
    15648. 

  15648.         }
    15649. 

  15649. #endif
    15650. 

  15650. #ifdef GLX_EXT_fbconfig_packed_float
    15651. 

  15651.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_packed_float", 21))
    15652. 

  15652.         {
    15653. 

  15653.           ret = GLXEW_EXT_fbconfig_packed_float;
    15654. 

  15654.           continue;
    15655. 

  15655.         }
    15656. 

  15656. #endif
    15657. 

  15657. #ifdef GLX_EXT_framebuffer_sRGB
    15658. 

  15658.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16))
    15659. 

  15659.         {
    15660. 

  15660.           ret = GLXEW_EXT_framebuffer_sRGB;
    15661. 

  15661.           continue;
    15662. 

  15662.         }
    15663. 

  15663. #endif
    15664. 

  15664. #ifdef GLX_EXT_import_context
    15665. 

  15665.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"import_context", 14))
    15666. 

  15666.         {
    15667. 

  15667.           ret = GLXEW_EXT_import_context;
    15668. 

  15668.           continue;
    15669. 

  15669.         }
    15670. 

  15670. #endif
    15671. 

  15671. #ifdef GLX_EXT_scene_marker
    15672. 

  15672.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12))
    15673. 

  15673.         {
    15674. 

  15674.           ret = GLXEW_EXT_scene_marker;
    15675. 

  15675.           continue;
    15676. 

  15676.         }
    15677. 

  15677. #endif
    15678. 

  15678. #ifdef GLX_EXT_swap_control
    15679. 

  15679.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))
    15680. 

  15680.         {
    15681. 

  15681.           ret = GLXEW_EXT_swap_control;
    15682. 

  15682.           continue;
    15683. 

  15683.         }
    15684. 

  15684. #endif
    15685. 

  15685. #ifdef GLX_EXT_texture_from_pixmap
    15686. 

  15686.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_from_pixmap", 19))
    15687. 

  15687.         {
    15688. 

  15688.           ret = GLXEW_EXT_texture_from_pixmap;
    15689. 

  15689.           continue;
    15690. 

  15690.         }
    15691. 

  15691. #endif
    15692. 

  15692. #ifdef GLX_EXT_visual_info
    15693. 

  15693.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_info", 11))
    15694. 

  15694.         {
    15695. 

  15695.           ret = GLXEW_EXT_visual_info;
    15696. 

  15696.           continue;
    15697. 

  15697.         }
    15698. 

  15698. #endif
    15699. 

  15699. #ifdef GLX_EXT_visual_rating
    15700. 

  15700.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_rating", 13))
    15701. 

  15701.         {
    15702. 

  15702.           ret = GLXEW_EXT_visual_rating;
    15703. 

  15703.           continue;
    15704. 

  15704.         }
    15705. 

  15705. #endif
    15706. 

  15706.       }
    15707. 

  15707.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"INTEL_", 6))
    15708. 

  15708.       {
    15709. 

  15709. #ifdef GLX_INTEL_swap_event
    15710. 

  15710.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_event", 10))
    15711. 

  15711.         {
    15712. 

  15712.           ret = GLXEW_INTEL_swap_event;
    15713. 

  15713.           continue;
    15714. 

  15714.         }
    15715. 

  15715. #endif
    15716. 

  15716.       }
    15717. 

  15717.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5))
    15718. 

  15718.       {
    15719. 

  15719. #ifdef GLX_MESA_agp_offset
    15720. 

  15720.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"agp_offset", 10))
    15721. 

  15721.         {
    15722. 

  15722.           ret = GLXEW_MESA_agp_offset;
    15723. 

  15723.           continue;
    15724. 

  15724.         }
    15725. 

  15725. #endif
    15726. 

  15726. #ifdef GLX_MESA_copy_sub_buffer
    15727. 

  15727.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_sub_buffer", 15))
    15728. 

  15728.         {
    15729. 

  15729.           ret = GLXEW_MESA_copy_sub_buffer;
    15730. 

  15730.           continue;
    15731. 

  15731.         }
    15732. 

  15732. #endif
    15733. 

  15733. #ifdef GLX_MESA_pixmap_colormap
    15734. 

  15734.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixmap_colormap", 15))
    15735. 

  15735.         {
    15736. 

  15736.           ret = GLXEW_MESA_pixmap_colormap;
    15737. 

  15737.           continue;
    15738. 

  15738.         }
    15739. 

  15739. #endif
    15740. 

  15740. #ifdef GLX_MESA_release_buffers
    15741. 

  15741.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"release_buffers", 15))
    15742. 

  15742.         {
    15743. 

  15743.           ret = GLXEW_MESA_release_buffers;
    15744. 

  15744.           continue;
    15745. 

  15745.         }
    15746. 

  15746. #endif
    15747. 

  15747. #ifdef GLX_MESA_set_3dfx_mode
    15748. 

  15748.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"set_3dfx_mode", 13))
    15749. 

  15749.         {
    15750. 

  15750.           ret = GLXEW_MESA_set_3dfx_mode;
    15751. 

  15751.           continue;
    15752. 

  15752.         }
    15753. 

  15753. #endif
    15754. 

  15754. #ifdef GLX_MESA_swap_control
    15755. 

  15755.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))
    15756. 

  15756.         {
    15757. 

  15757.           ret = GLXEW_MESA_swap_control;
    15758. 

  15758.           continue;
    15759. 

  15759.         }
    15760. 

  15760. #endif
    15761. 

  15761.       }
    15762. 

  15762.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3))
    15763. 

  15763.       {
    15764. 

  15764. #ifdef GLX_NV_copy_image
    15765. 

  15765.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10))
    15766. 

  15766.         {
    15767. 

  15767.           ret = GLXEW_NV_copy_image;
    15768. 

  15768.           continue;
    15769. 

  15769.         }
    15770. 

  15770. #endif
    15771. 

  15771. #ifdef GLX_NV_float_buffer
    15772. 

  15772.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12))
    15773. 

  15773.         {
    15774. 

  15774.           ret = GLXEW_NV_float_buffer;
    15775. 

  15775.           continue;
    15776. 

  15776.         }
    15777. 

  15777. #endif
    15778. 

  15778. #ifdef GLX_NV_multisample_coverage
    15779. 

  15779.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_coverage", 20))
    15780. 

  15780.         {
    15781. 

  15781.           ret = GLXEW_NV_multisample_coverage;
    15782. 

  15782.           continue;
    15783. 

  15783.         }
    15784. 

  15784. #endif
    15785. 

  15785. #ifdef GLX_NV_present_video
    15786. 

  15786.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13))
    15787. 

  15787.         {
    15788. 

  15788.           ret = GLXEW_NV_present_video;
    15789. 

  15789.           continue;
    15790. 

  15790.         }
    15791. 

  15791. #endif
    15792. 

  15792. #ifdef GLX_NV_swap_group
    15793. 

  15793.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10))
    15794. 

  15794.         {
    15795. 

  15795.           ret = GLXEW_NV_swap_group;
    15796. 

  15796.           continue;
    15797. 

  15797.         }
    15798. 

  15798. #endif
    15799. 

  15799. #ifdef GLX_NV_vertex_array_range
    15800. 

  15800.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18))
    15801. 

  15801.         {
    15802. 

  15802.           ret = GLXEW_NV_vertex_array_range;
    15803. 

  15803.           continue;
    15804. 

  15804.         }
    15805. 

  15805. #endif
    15806. 

  15806. #ifdef GLX_NV_video_capture
    15807. 

  15807.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_capture", 13))
    15808. 

  15808.         {
    15809. 

  15809.           ret = GLXEW_NV_video_capture;
    15810. 

  15810.           continue;
    15811. 

  15811.         }
    15812. 

  15812. #endif
    15813. 

  15813. #ifdef GLX_NV_video_output
    15814. 

  15814.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_output", 12))
    15815. 

  15815.         {
    15816. 

  15816.           ret = GLXEW_NV_video_output;
    15817. 

  15817.           continue;
    15818. 

  15818.         }
    15819. 

  15819. #endif
    15820. 

  15820.       }
    15821. 

  15821.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4))
    15822. 

  15822.       {
    15823. 

  15823. #ifdef GLX_OML_swap_method
    15824. 

  15824.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_method", 11))
    15825. 

  15825.         {
    15826. 

  15826.           ret = GLXEW_OML_swap_method;
    15827. 

  15827.           continue;
    15828. 

  15828.         }
    15829. 

  15829. #endif
    15830. 

  15830. #ifdef GLX_OML_sync_control
    15831. 

  15831.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12))
    15832. 

  15832.         {
    15833. 

  15833.           ret = GLXEW_OML_sync_control;
    15834. 

  15834.           continue;
    15835. 

  15835.         }
    15836. 

  15836. #endif
    15837. 

  15837.       }
    15838. 

  15838.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5))
    15839. 

  15839.       {
    15840. 

  15840. #ifdef GLX_SGIS_blended_overlay
    15841. 

  15841.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"blended_overlay", 15))
    15842. 

  15842.         {
    15843. 

  15843.           ret = GLXEW_SGIS_blended_overlay;
    15844. 

  15844.           continue;
    15845. 

  15845.         }
    15846. 

  15846. #endif
    15847. 

  15847. #ifdef GLX_SGIS_color_range
    15848. 

  15848.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11))
    15849. 

  15849.         {
    15850. 

  15850.           ret = GLXEW_SGIS_color_range;
    15851. 

  15851.           continue;
    15852. 

  15852.         }
    15853. 

  15853. #endif
    15854. 

  15854. #ifdef GLX_SGIS_multisample
    15855. 

  15855.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11))
    15856. 

  15856.         {
    15857. 

  15857.           ret = GLXEW_SGIS_multisample;
    15858. 

  15858.           continue;
    15859. 

  15859.         }
    15860. 

  15860. #endif
    15861. 

  15861. #ifdef GLX_SGIS_shared_multisample
    15862. 

  15862.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_multisample", 18))
    15863. 

  15863.         {
    15864. 

  15864.           ret = GLXEW_SGIS_shared_multisample;
    15865. 

  15865.           continue;
    15866. 

  15866.         }
    15867. 

  15867. #endif
    15868. 

  15868.       }
    15869. 

  15869.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5))
    15870. 

  15870.       {
    15871. 

  15871. #ifdef GLX_SGIX_fbconfig
    15872. 

  15872.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig", 8))
    15873. 

  15873.         {
    15874. 

  15874.           ret = GLXEW_SGIX_fbconfig;
    15875. 

  15875.           continue;
    15876. 

  15876.         }
    15877. 

  15877. #endif
    15878. 

  15878. #ifdef GLX_SGIX_hyperpipe
    15879. 

  15879.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"hyperpipe", 9))
    15880. 

  15880.         {
    15881. 

  15881.           ret = GLXEW_SGIX_hyperpipe;
    15882. 

  15882.           continue;
    15883. 

  15883.         }
    15884. 

  15884. #endif
    15885. 

  15885. #ifdef GLX_SGIX_pbuffer
    15886. 

  15886.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7))
    15887. 

  15887.         {
    15888. 

  15888.           ret = GLXEW_SGIX_pbuffer;
    15889. 

  15889.           continue;
    15890. 

  15890.         }
    15891. 

  15891. #endif
    15892. 

  15892. #ifdef GLX_SGIX_swap_barrier
    15893. 

  15893.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_barrier", 12))
    15894. 

  15894.         {
    15895. 

  15895.           ret = GLXEW_SGIX_swap_barrier;
    15896. 

  15896.           continue;
    15897. 

  15897.         }
    15898. 

  15898. #endif
    15899. 

  15899. #ifdef GLX_SGIX_swap_group
    15900. 

  15900.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10))
    15901. 

  15901.         {
    15902. 

  15902.           ret = GLXEW_SGIX_swap_group;
    15903. 

  15903.           continue;
    15904. 

  15904.         }
    15905. 

  15905. #endif
    15906. 

  15906. #ifdef GLX_SGIX_video_resize
    15907. 

  15907.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12))
    15908. 

  15908.         {
    15909. 

  15909.           ret = GLXEW_SGIX_video_resize;
    15910. 

  15910.           continue;
    15911. 

  15911.         }
    15912. 

  15912. #endif
    15913. 

  15913. #ifdef GLX_SGIX_visual_select_group
    15914. 

  15914.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_select_group", 19))
    15915. 

  15915.         {
    15916. 

  15916.           ret = GLXEW_SGIX_visual_select_group;
    15917. 

  15917.           continue;
    15918. 

  15918.         }
    15919. 

  15919. #endif
    15920. 

  15920.       }
    15921. 

  15921.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4))
    15922. 

  15922.       {
    15923. 

  15923. #ifdef GLX_SGI_cushion
    15924. 

  15924.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"cushion", 7))
    15925. 

  15925.         {
    15926. 

  15926.           ret = GLXEW_SGI_cushion;
    15927. 

  15927.           continue;
    15928. 

  15928.         }
    15929. 

  15929. #endif
    15930. 

  15930. #ifdef GLX_SGI_make_current_read
    15931. 

  15931.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17))
    15932. 

  15932.         {
    15933. 

  15933.           ret = GLXEW_SGI_make_current_read;
    15934. 

  15934.           continue;
    15935. 

  15935.         }
    15936. 

  15936. #endif
    15937. 

  15937. #ifdef GLX_SGI_swap_control
    15938. 

  15938.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12))
    15939. 

  15939.         {
    15940. 

  15940.           ret = GLXEW_SGI_swap_control;
    15941. 

  15941.           continue;
    15942. 

  15942.         }
    15943. 

  15943. #endif
    15944. 

  15944. #ifdef GLX_SGI_video_sync
    15945. 

  15945.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_sync", 10))
    15946. 

  15946.         {
    15947. 

  15947.           ret = GLXEW_SGI_video_sync;
    15948. 

  15948.           continue;
    15949. 

  15949.         }
    15950. 

  15950. #endif
    15951. 

  15951.       }
    15952. 

  15952.       if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4))
    15953. 

  15953.       {
    15954. 

  15954. #ifdef GLX_SUN_get_transparent_index
    15955. 

  15955.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_transparent_index", 21))
    15956. 

  15956.         {
    15957. 

  15957.           ret = GLXEW_SUN_get_transparent_index;
    15958. 

  15958.           continue;
    15959. 

  15959.         }
    15960. 

  15960. #endif
    15961. 

  15961. #ifdef GLX_SUN_video_resize
    15962. 

  15962.         if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12))
    15963. 

  15963.         {
    15964. 

  15964.           ret = GLXEW_SUN_video_resize;
    15965. 

  15965.           continue;
    15966. 

  15966.         }
    15967. 

  15967. #endif
    15968. 

  15968.       }
    15969. 

  15969.     }
    15970. 

  15970.     ret = (len == 0);
    15971. 

  15971.   }
    15972. 

  15972.   return ret;
    15973. 

  15973. }
    15974. 

  15974. 

  15975. #endif /* _WIN32 */
    15976.