From 5713df7d72c01c434e0fc92a8d4c09b57b02b416 Mon Sep 17 00:00:00 2001 From: ikits Date: Fri, 13 Dec 2002 08:31:58 +0000 Subject: [PATCH] Initial revision git-svn-id: https://glew.svn.sourceforge.net/svnroot/glew/trunk/glew@2 783a27ee-832a-0410-bc00-9f386506c6dd --- GNUmakefile | 63 + bin/.do.not.remove | 0 doc/README.html | 382 ++++ doc/glew.png | Bin 0 -> 9298 bytes doc/glx.txt | 206 ++ doc/lgpl.txt | 502 +++++ doc/sgi.txt | 42 + include/GL/glew.h | 4575 ++++++++++++++++++++++++++++++++++++++++++++ include/GL/glxew.h | 796 ++++++++ include/GL/wglew.h | 757 ++++++++ lib/.do.not.remove | 0 src/glew.c | 3383 ++++++++++++++++++++++++++++++++ src/glewinfo.c | 2238 ++++++++++++++++++++++ 13 files changed, 12944 insertions(+) create mode 100644 GNUmakefile create mode 100644 bin/.do.not.remove create mode 100644 doc/README.html create mode 100644 doc/glew.png create mode 100644 doc/glx.txt create mode 100644 doc/lgpl.txt create mode 100644 doc/sgi.txt create mode 100644 include/GL/glew.h create mode 100644 include/GL/glxew.h create mode 100644 include/GL/wglew.h create mode 100644 lib/.do.not.remove create mode 100644 src/glew.c create mode 100644 src/glewinfo.c diff --git a/GNUmakefile b/GNUmakefile new file mode 100644 index 0000000..0f971ab --- /dev/null +++ b/GNUmakefile @@ -0,0 +1,63 @@ +## The OpenGL Extension Wrangler Library +## Copyright (C) 2002 Milan Ikits +## +## This library is free software; you can redistribute it and/or +## modify it under the terms of the GNU Lesser General Public +## License as published by the Free Software Foundation; either +## version 2.1 of the License, or (at your option) any later version. +## +## This library is distributed in the hope that it will be useful, +## but WITHOUT ANY WARRANTY; without even the implied warranty of +## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +## Lesser General Public License for more details. +## +## You should have received a copy of the GNU Lesser General Public +## License along with this library; if not, write to the Free Software +## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +GLEW_TARGET ?= /usr + +CC = \cc +LD = \ld +INSTALL = \install +RM = \rm -f +OPT = -O2 +INCLUDE = -Iinclude +CFLAGS = $(OPT) $(INCLUDE) + +LIB = lib/libGLEW.so +LIB.SRCS = src/glew.c +LIB.OBJS = $(LIB.SRCS:.c=.o) +LIB.LIBS = + +BIN = bin/glewinfo +BIN.SRCS = src/glewinfo.c +BIN.OBJS = $(BIN.SRCS:.c=.o) +BIN.LIBS = -Llib -L/usr/X11R6/lib -lglut -lGLEW -lGL -lXmu -lX11 + +all: $(LIB) $(BIN) + +$(LIB): $(LIB.OBJS) + $(LD) -shared -o $@ $^ $(LIB.LIBS) + +$(BIN): $(BIN.SRCS) + $(CC) $(CFLAGS) -o $@ $^ $(BIN.LIBS) + +%.o: %.c + $(CC) -c $(CFLAGS) -o $@ $< + +install: all + $(INSTALL) -d -m 755 $(GLEW_TARGET)/include/GL + $(INSTALL) -m 644 include/GL/glew.h include/GL/glxew.h $(GLEW_TARGET)/include/GL + $(INSTALL) -d -m 755 $(GLEW_TARGET)/lib + $(INSTALL) -s -m 755 lib/libGLEW.so $(GLEW_TARGET)/lib + $(INSTALL) -d -m 755 $(GLEW_TARGET)/bin + $(INSTALL) -s -m 755 lib/glewinfo $(GLEW_TARGET)/bin + +uninstall: + $(RM) $(GLEW_TARGET)/include/GL/glew.h $(GLEW_TARGET)/include/GL/glxew.h + $(RM) $(GLEW_TARGET)/lib/libGLEW.so + $(RM) $(GLEW_TARGET)/bin/glewinfo + +clean: + $(RM) $(LIB.OBJS) $(LIB) $(BIN.OBJS) $(BIN) diff --git a/bin/.do.not.remove b/bin/.do.not.remove new file mode 100644 index 0000000..e69de29 diff --git a/doc/README.html b/doc/README.html new file mode 100644 index 0000000..20556cb --- /dev/null +++ b/doc/README.html @@ -0,0 +1,382 @@ + + + + + +GLEW: The OpenGL Extension Wrangler Library + + + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
glew
The OpenGL Extension Wrangler Library
+ + + + + + + + +
Introduction
Obtaining GLEW
How to Build Your Project with GLEW
How to Install GLEW
How to Use GLEW
Known Issues
Credits, Copyright
+
+
Introduction +
+The goal of the OpenGL Extension Wrangler Library (GLEW) is to assist +C/C++ OpenGL developers with two tedious tasks: initializing and +using extensions and writing portable applications. GLEW provides +an efficient run-time mechanism to determine whether a certain +extension is supported by the driver or not. OpenGL core and +extension functionality is exposed via a single header file. GLEW +currently supports the products of two commodity graphics card +vendors, NVIDIA and ATI, on two operating systems, Windows and Linux. +

+

Obtaining GLEW +
+The source and precompiled binaries are available at the project website. + +

+

How to Build Your Project with GLEW +
+ +There are two ways to build your project with GLEW. +

+ +Including the source files / project file +

+ +The simpler but less flexible way is to include glew.h and +glew.c into your project and define the GLEW_STATIC +preprocessor constant for the static library or executable you are +building together with GLEW. You also need to replace +<GL/gl.h> and <GL/glu.h> with +<glew.h> and set the appropriate include flag +(-I) to tell the compiler where to look for it. +For example: + +

#include <glew.h>
+#include <GL/glut.h>
+<gl, glu, and glut functionality is available here>
+
+ +Note that if you are using GLEW together with GLUT, you have to +include glew.h first. In addition, glew.h includes +glu.h, so you don't need to include it separately. + +

+On Windows you can also add the supplied project file +(glew.dsp or glew.vcproj) to your workspace or +solution and compile it together with your other projects. In this +case you need to change the GLEW_BUILD preprocessor constant +to GLEW_STATIC, otherwise you get build errors. Note that +GLEW does not use the C runtime library, so it does not matter +which version (single-threaded, multi-threaded or multi-threaded DLL) it +is linked with. + +

+ +Using GLEW as a shared library +

+ +Alternatively, you can use the provided project files / makefile to +build a separate shared library you can link your projects with later. +In this case the best practice is to install glew.h, +glew32.lib, and glew32.dll / libGLEW.so to +where the OpenGL equivalents gl.h, opengl32.lib, and +opengl32.dll / libGL.so are located. Note that you +need administrative privileges to do this. If you do not have +administrator access and your system administrator will not do it for +you, you can install GLEW into your own lib and include subdirectories +and tell the compiler where to find it. Then you can just replace +<GL/gl.h> with <GL/glew.h> in your +program: + +

#include <GL/glew.h>
+#include <GL/glut.h>
+<gl, glu, and glut functionality is available here>
+
+ +or: + +
#include <GL/glew.h>
+<gl and glu functionality is available here>
+
+ +

+Don't forget to link your project with glew32.lib, +glu32.lib, and opengl32.lib on Windows and +libGLEW.so, libGLU.so, and libGL.so on +Linux (-lGLEW -lGLU -lGL). + +

+It is important to keep in mind that glew.h includes neither +windows.h nor gl.h. Also, GLEW will warn you by +issuing a preprocessor error in case you have included gl.h, +glext.h, or glATI.h before glew.h. +

+

How to Install GLEW +
+ +

+To install the shared library version of GLEW you need to copy the +headers and libraries into their destination directories. On Windows +this boils down to copying (no, we will not write a Windows installer +for you). +

+ +

+ + + + + + + + + +
lib/glew32.dll    to    %SystemRoot%/system32, usually C:/WINDOWS/system32
lib/glew32.lib    to    {VC Root}/Lib
include/GL/glew.h    to    {VC Root}/Include/GL
include/GL/wglew.h    to    {VC Root}/Include/GL
+
+

+ +where {VC Root} is your Visual C++ directory, typically +C:/Program Files/Microsoft Visual Studio/VC98 for Visual +Studio 6.0 or C:/Program Files/Microsoft Visual +Studio/Vc7/PlatformSDK for Visual Studio .NET. However, if you +build GLEW with Visual Studio .NET, the project file will +automatically install it into these directories, so you +don't have to worry about installation at all. + +

+On Linux, typing "make install" will attempt to install GLEW +into /usr/include/GL and /usr/lib. You can +customize the installation target via the GLEW_TARGET +environment variable if you do not have write access +to these directories. +

+

How to Use GLEW +
+ +Initializing GLEW +

+ +First you need to create a valid OpenGL rendering context and call +glewInit() to initialize the extension entry points. If +glewInit() returns GLEW_OK the initialization +succeeded and you can use the available extensions as well as core +OpenGL functionality. For example: + +

#include <GL/glew.h>
+#include <GL/glut.h>
+...
+glutInit(&argc, argv);
+glutCreateWindow("GLEW Test");
+int err = glewInit();
+if (GLEW_OK != err)
+{
+  /* problem: glewInit failed, something is seriously wrong */
+  fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
+  ...
+}
+
+ +

+ +Querying the available OpenGL extensions +

+ +To find out if a particular extension is available on your +platform, use the globally defined structure glew: + +

if (glew.ARB_vertex_program)
+{
+  /* it is safe to use the ARB_vertex_program extension here */
+  glGenProgramsARB(...);
+}
+
+ +You can also check for core OpenGL functionality. For example, to +see if OpenGL 1.3 is supported you can use the following: + +
if (glew.GL_13)
+{
+  /* Yay! OpenGL 1.3 is supported! */
+}
+
+ +In general, you can check if glew.{extension_name} or +glew.GL_{version} is set or not. + +

+ +Experimental drivers +

+ +GLEW works by querying the supported extensions from the graphics +driver. Experimental drivers, however, might not report every +available extension through the standard mechanism, in which case GLEW +will report it unsupported. To circumvent this situation, the +glewExperimental global switch can be turned on by setting it +to GL_TRUE before calling glewInit(). This makes +sure that all extensions with valid entry points will be exposed. + +

+ +Platform specific extensions +

+ +Platform specific extensions are separated into two header files: +wglew.h and glxew.h. These files define the +available WGL and GLX extensions as well as the +global wglew and glxew structs, which work similarly +to the glew structure. To determine if a given WGL or +GLX extension is supported, query wglew.{extension name} or +glxew.{extension_name}. For example: + +

#include <GL/wglew.h>
+
+if (wglew.ARB_pbuffer)
+{
+  /* OK, we can use pbuffers */
+}
+else
+{
+  /* Sorry, pbuffers will not work on this platform */
+}
+
+ +

+ +glewinfo: a command line extension reporting utility +

+ +GLEW comes with a command line utility called glewinfo that +allows you to make a list of the extensions supported on your platform. +The glewinfo utility uses GLEW to find out which extensions +and entry points are available and reports the results to a text file +called glewinfo.txt. + +

+

Known Issues +
+ +GLEW requires GLX 1.2 to assure compatibility with GLUT. In addition, +the SGI GLX video extensions are not supported, because they depend on +external libraries. +

+Note that according to the WGL and GLX specifications you have to +initialize the entry points for every rendering context you create. +GLEW ignores this requirement, and does not define per context entry +points. This means that you need to call glewInit() only +once in your program. We have not noticed any problems so far from +ignoring this requirement. +

+ +

Credits, Copyright +
+Aaron Lefohn, Joe Kniss, +and Chris Wyman were the first users of GLEW and also assisted with +the design and debugging process. The acronym GLEW originates from +Aaron Lefohn. +

+GLEW is derived from the EXTGL project by Lev Povalahev. It is +licensed under the LGPL, the BSD license, the SGI Free Software +License B, and the GLX Public License. We encourage those who are not +in favor of the LGPL to read this excellent +tutorial. + +


+
+

+
+
+
+
+

+Last update: 12-12-02

+

+

+
+
diff --git a/doc/glew.png b/doc/glew.png
new file mode 100644
index 0000000000000000000000000000000000000000..d46550f194988fe99362932b29f48aeded97111e
GIT binary patch
literal 9298
zcmW++dpuMB|3BNz+(+*Bxt8)_E+t)TBve8rx5V5jNh*=cHkT;mR-qE1QYj;)i)^S|
zLq*7C?s99G%dY4A_Wk{F_I_-8?7ZKv*B-Ce^Ywf_&rKI6dr2`BF#rH0k2u(#6s&%N
z>zD{!@X9!qSRq(MBON?11Aw^f|1KDC|DlrLL!l7su>i0@0Dygk0HAm=&-bex0O+(Gv9)%M`Qy)nAY98hK!tc*7P!$m
zkex_O;LdFoK*U5-9)A_0YunT=HG8hR>?H=y7?F1kL6F!W#8&m=FMDl
zxVP=Z^Pc28KYP?Yr1p%rQ-0Yc-zSq#?A$%0aycyOceHSMejT!_b6>Obx)|o;jUV;Z
zzM5xo9h(eEMb#;YNc*yiZr93GQ(NllGK4@r>UwcnF}Wy}4Etwphvnj0s;LqE-$^F~AtcRj{yWg)d#&ffRB+6HJ9O93=L~de;qQ-;%+1UY7OL2M
z>(jttC9S3}UsmQcTedXY{KTh0PWwya>Z&6;1%exhk8b-h^=S@j{M4zpoyou<4wzF~
zRdo>9+ypx@k;rjU(mI_OI(tZRgb0DW(&A1SJl)A}eR+5Qo!u?YjI61tfw)`QuFFe?
z5=-Hwr5sS!1N#^$tFxmAaEf-5lIn(Z^|cA<6qA;PF~oBeOAglZmz!vjBbGOZG0xZKXmQa(QV`n6TbcYbH~YHKLjDa|P9h`01;
z(y2e&_yEkd0DFCd#NM({2;O6Qt`{2TXt;eQi@52pF9|yqH9T}=JffH9as_eTlu}-1
zcB(pNLS(;`m)b38ke@b>KuJ?9VMLS`;orSCta=!8#B(1F#oa!%MtXqK#4!b9ll*`|omz>4XNlTi()ZC#1eo692
zBzluX2ZiPchyMEjnMGczg%Yn#{d$(|x`q7z-&iHGR+js(DiFp9ft<}5Gs?@uCr@(F
zuiFMaa+1`ZK1jYx&X?caYJwGuG;4TI1U298ml6crf`z|xf8>qp;xP|WP{K=ZKt7+#
zsK!a?dbKsd7jm^0-a_d@NXMhJcQeH4dveme_|4gV*@f#uf{^6xXl)Ib=f|_>6v>u|
zK5N0hjnk2>%!f)+Y=y$lym_OoR|Yv8hdDHTfxVa=e=a(>xozB!&-&Zk<4b-1SCIsi
zomTpsxH;Z3s#BFY-joHEN?EDyq67!%nP!s4f`ec)`ggv`=-j&}TPfO|DWY$uAM7*R
zWBl*z(=uNGo}Pl`uoru>OK?<(1@c?7eW}po_aLZb)T;g43hGWYtvkeTPI_Ab!Ove?
zU(1@q_f{LnveWK-1$FeaJ$@th9Q!aN)2~*!GV9M}&UbUKF)HQl1W6%;3+>pN`Sr}b
z=O4u5a0Ujph(w6B#n_Im^%!Cgen^c?t@v7Tmn16m`P$}Wd%0|ho|t`#%>>{g2QwQJxY3NYCdl{S<;%6EZz#L~Ap4pLKEua$AuX!Ow3Nc-
z^0_^X%m(c!eImqzV$SbxVQ5N>H;WAJ&2u~HZ)4AGWmGNp{9L}_3=i(oi!H*~r%pEL;Gt*i8=8UB>z4pyzKH`Z?Of#ACcpuGDBdk)n
zOiT$wg!rtDt>so$FL#NF(6N^76sK!MwW&7aV$fC`R(w
z{)dHtP1JCGNog!B^!OIU$hfH1A?#CS*d^5RcXK13u317L_=n8qyZ^pAO}a}FY`SBU
zF?yf{~OGQfGcb9%Fy0Zi{6%$!uW{41ZpzOZ)t4zg-vinE{Jah@w
zOB{iv2$2#LV@?4cDr;s$K|$_p0yrCsjDdk{R?G)Bd(e}Ldmndcz`5`Z3@)N#$Dn`a
zZ}LpHqqxMFJo0{&ceeH1j`6TGnXw~DJ5uDPUE~FbAfvEtd{&XeTArgqL}CK;E&bXR
z$x1H6*ToWU?CGNNJ91Ge7ml^lM8yxVXHLttq;G72VmZNjCAIKC#AKtn@6EC#U67B(%;nHY7G@zNn=f(!V?DIDXkxS&coqv>=*&E-qa|&py5C
zw~27=%VBvL06cTEYOi^g@?ql8JbFsqME3GSwT}8cxvc|h^|S;eOGPLuf{BFe#tQA!
zbKV{M^XA-5o6{Aduj|AyggMg0M!xF9@bL*N{pm89ZIvqoo2X7=49H3A6DJ|HDyXod
zMB3Ve6EGE^S>g*GI`aWvT&hF}^a}>JR!0{@0N9r`?f|2j!N`cJ
zNt%XClHx_`vt%CKq*$sdcX)GqQcu#AjI#Zqn?Lqn7gUoRS|~
zJXf>nRHegrz0ehy_!JRJ5sD%5SnP%V^I-<2)`xEE
z<#a5RU356P71cYgSvSgrwz7>6R8>I}yWy47glR%Z9JDGx?59=UqSi`cNkTIsm;zUG
z5JC@n?VC~@^z@Lyq~N7R^CBg_pJxU$qqo$7@@%PZ#ZO<~nONkx+t)
z2iM>`cOou(@sOcjN1JMYCk
zC2Ny+mx}4qklyNPhw9b7J(W;J>!1B|bjxn3DxJ9PZ{6;GZ%=~TuvX@_j)%W~VD`2*
zze0l?VP2#yM`BG2wH*H#19AWrh=Wsp9=FMtS7+iJNTGJZR
zKFKNxiOD?elRqa7OLOhN5h1_3!tY&d+H}u9y(75?1yrbvSm~hR_-9%U$ix$ydJhn{5PfSr_97v`WfhIEj%jzZe*~|
zP&~;7v&qRB#koZ?4WSt_tpt_ex0{--qhJX9NjWs`zkmxpE{3%SkwNyt(N0n@>%`Cp
zYD+VkxJKVk@eK5?>dN=J+A^Qx+t#@Ub?OearnlKq{81QEp@2xVr-y!MUNqIO&=4JY
zn-iH*{~#xBC#6<&Qo&`6hmstD96(+Vi#uoRsdu<_Iur69DSdJqD-QA4T!>CoYq{;{
za8Rbphk+Bm)2^^rQO>`sstaFF+dy1kZEfMqWE-f6DilObj3KAx&(n!9YC2DSNv{Qy
zsIUnB$a*`i_SGb(sjqQ2_mMpxUkGr@*AhuOw8cEWakYP>!(A_iJrLj#
z#+iG(eC*eIUaZA=>wu>})eqge~Ls2$Iw>}L2y-Xju3Uut>pK7!{DA$Z(kUq7Y3IpAI`84d1KG^M2FotmZw>L#
z0}_4ugrv-98}Z3{<1rqOjZk9KUQ2|6c`||0SO?NqDJ)1jY=JGpCO@qpS%vud!)^dN
zp%Owr|Cim(;ei5U-$R$%aXHR=2Q6Li9%jU|HWa<_2J
zowch?DdT2=+kH7jaG7a&Q1iVFIBtvq#>7{*vXhSI{BhQuj5&2RogvfY8EG2&-Iuzpwx8VvV
zcv%oz3nm}d#bypFL4bI$K4B^Y=?brb1w2f?dyIrqI#wD~K?A!4lr0g0SvGCPFM`*k~
zmLVT5my0%rI~GdieCkJZCdT3M$OBQ
zBAuqpkDd~l$TZvGc}iNvzRmrWtIo_BvC}ubDrY@A)?gc>zck&G`PV}aAGG_Zsx~os
z_0bWncVBDvmMm58vCuHDzEQqHv3qG)(e4hIj5S02mGDx?bMGL?=kVu8A8ci7B*bhk{o-DuS|z~ULh#70uBrptWl7ue{EzNT
zGCf%}GD3T5f`uqGwV$u^|9xk=!{fcx9xfS{E)?bZx}-aM0EM=Aq-;$3lBVuqEQYgA
z>l4Zn)C~dTAeR7;$6g)f+FxTd#IEs}!|n`?gKXC159p$=;G3SdrpMYH8(F@84(>`z
zdm!8QiOoed_yJ+A=`!~{5@G7!%3lOe3rXV*N8%)I~P?Tfp+
z3vw{nQ$RpraWTK2sR$)PvxI=zY2;INA3_vjvwhVuh#>VMvbHAj*s=6u=?&L6)s#%A
zAdkDjAAWVd-s!bZ6Ax@fDJy4ByJ~0{5eN{tw!vp^FFU$3rva_L$wvQYL^8e5tLiy&)c4Xc;hm=pA1=
z^bD$ab&rn@yMz!o2-c7AAy;c!nVOldtgd$KY%307Z4WD*FDm+P$4;Otm2TBQyv(>=
zcuPemw0l;w>wIstF(re!sQIZO1>Wl@0DB>~hZf!c0=bt;QY9x<>y)+nVwD}v$nWbC
zdcILw9!;yAK1y?1kFd*KU{_l
zu`V{JR9%B1khv+4PcDufOTT%v{gxSdPcBdIYNs$Il|9o^py;fTlvbfsVin8&+kG~U
zs2O3UL74hG^J>v|jC%LS?~ti!xI)JGJ+THcc&HaxT=jz`d&+H-VeUpaa;jQ=nvwGu)LMgr%Wut?2-k*V2i&`7})l9Ca
z%B-xA+iszV4JB`^FA5GZ+K6(kn3@b9pXuDLwF+5anf!P*Z#TtS*TBF?+fZcP?ESG#
zG}J8HR;uozM_~w5uw#UG$UP-i5bJx#SDkXq*N%?Onb8Nst+y$cS9jd^!oD&2-~46O
zjYMNGAaCPS&i#TqiO^0(!O1fbdv?6mJge0uZip^&Id>(r75Q7mR<6sjG=h(d6oVH;
zmmc<@CPsut#PC^`s;d5ONPpuiLQ4LFzQTu(AD6$N?s87JK%eF&MS0GfY2n7zM_7I2
z7TS|~1_zFfj^*YTpbJYI6SUE;-o+X{zSMqTf%p>3qt}aopVMDbd6w
z#&cQo!v#IG-@Wy82*R3Vq>E%672)&wTmNqApu5ik_eiyz8>L?IK`&Bd{$y}aRl;Bc
zxBW?g@;70h5D{s-bh+~DVtVK1%pURms4DH`x>iUh>nau>(nnsFW6`8_Z^99`QrTMt
z7tcS~Y1Ig}b!7Hsr78o}T9%f3yVTBlT7R+wF+DJ{f)LiUk;q)=e%o2CL6tp~XS&He
zWx6L|Y7*|2D-b+bEB}7gU!;@mn9S7`CQKEzv=m;I1K;d1#_(3Tt#mrIk;q=#u)u~V
zA`m3<&Eiuo4tQ5@R!>jKR!=eY5(^MleG}`FLaH*y-Ys(->Qw+@`U+u%p^awZsxRif
zY!1Mr@x33GEUJADe6F)5Wg`k#WtK6a`6_!VMcTb{0L~WLq)X&HPz(c<#ww-yyJNM151dU
z%A@0mo?{J#;G7_h8(0=-c-m25vQ7^krcYBDb{8P*tGmQ3k}qW0Ms6`J~M6
z$vUDVC;fvb#>WGBTinG~boD=a!u5@gQh66Nq|k&O+f$2_JTcPYc+hX_@al2b+E{|H3Ds@zdnJt>rLNHF(2Ih
zcy5fnSZdgr-WQ*W{KcS4K~%xO2~}~9M(+!Gb+TF
zmoAXb%U8UUD}N_%T4vkqtSrIb5BVgVa2lFJQ|?2orB$w?@z}vc-rB!c)eIaTSsgB$
zBPVfTnJ_iWW-e~8(@r`rWrDF=c>Kz~RCA0Nn4os2naijoAcWl$0l&i$WRC@jEZy)2a-pwtyxR(aYM7@MHWQuys#)B&w9@j}6
zS*R#CY6w?%!oJsbQ`6<*J!cnNyoc?PL)^|e=ZhuOnAnZA;sAU6uOiw%eZ~Fz6)h-|
z$naedXH$OgnSh@4KsX87{aab;(~)jQH+<ErTlHd`Nq`7#dtYtMJWGV>qGiqFyao-%R>gLfJb;4KAkUu6OGFGZf1XT(y&Y=mS
z$UDOK=#Gvw?MY*bUQ<&Of0aM{Y2Y=mD}k_Y+v%Kjqn8uoQ+(9W2jucl%cSJ@W-1j2
zPW0D_*bFyHNaJ_-2?d_r|0Zo?_`;rOrxhjLwZe9sEud8|p(L#%nsf9~YAU~VE;~)p
z_$dhTme~+1$y_&
zN^Pvd-J@aWAmMx7D-rq)Eu^+f7z4r|&iY0{<&9@4chtNdhzsak?^BgP*W*+$80GHM
zwtB11Gzk_4-h+McAt|H?_6VGtxZ2+F?v}*d_#}(1{-h1IZ-za^EwLg7-VoAQSkvo5
z9}%NmY4l)Qa?+W1B7?Pr)wA(g8m|=(lw^reo}c5
zr=RK081u0Ea`WX2KDZ&9;FT$pa86_-ipQVW{_I7Vw1tIYuo6s2`W_a(IUez7^ebly
zrn)~yN%3c(od(VyuMrhslWAmvdG!XCW+<+@3)@)Y-59^v)|6Jz4Y7Cychx^?XE>+$
z9zWyj;VPk&RysBaQK28RduxoVzW(-Rp^Nf(tpYPbOPlxL?(vhS9wZlR^;G+&!$p3e
zgYf6y0*kfTbnxi8*o>nNe#>-0bKBe)qBjz$SFa;9J3|P|WK%Z6xTy#%U%%9gkeVmbm)c>WPv6M&>LSq#AM8&gOQEwwBgTBO}btrmtVWHg_}wi$OfpwIsin
zTgf>4Gc_^{imTcQEq*0S-A0ML#D*_JTz2gm5OQmHTDO0M8l8{v(
zxC!sk_e8Sxrlwe?+72R-h1P-u=U;)Kfah<(raVl14gCGAfGX~KP+3!Z8~G^F6c0=c
zi?2=&CA(W}t-(}N9J_WX1n9ck0*}9JJ8-GVOstKL*My&eQ%S{T&YA)^;;=UsHGQoT
zA=b<=_Zp6x06QKG@mssUw}0zsf_rIqi?ug*ErpLHHIKk~Y9qXnGMlQ04TcXN;;r@F
z+z5}k=)RTIjYp8#VzECX+=s4
z;Q<+|i_
zDn#gnyEMq>&7kY+YLae<=Emg-+{eMo=MzC*0`%txol$-HG6jgs8*h@V2;PNQaM>bG
zJAm2d+>{S_%5HWTi$(HsKapY*X*-PiT|rV}X*TY?E2Af4g85J5kW=#biU7h|=jh>O
zM}M1&=`PvBMKIgC1$4#eka2ISCEs_4+~YpkQ}U_zpXtb=!jxI
zxVF=Riz7(#HGkalvl)%p)clOWhiPI7#>Xc#2_`pXp8~;X!=eD{*aD^nUbh0X(rr!xc5ar6#nl8E0yFmm9
zN|r1tU%#q!qFLocm(JaYwl@{&IUKaWz+LK1068V8?oM{2j-)Ts2$aBk1ueaxCRHIH
ztA@?RmW1f1CElfy&4xK&r3U$=%C#JRkI=E*Z5!r>^<{?B_(uorI;VDU6KKb5K|y^j
zE@nfHBR{pHIFor%j&e(W2ocQAhr2h~%((*Rh=kay88Zxfw^<^sOzdYCtEY{0(nbe;
zsr*`pOGuA$u2`J#v@*)>j{N#cyH%V2xn7SQmF+^|EFP=1xy`^p|CzDAL8t91TU~I<
zx6HvrKFC}fN;bY&63<^r-+(Ok%tGO`F}S#@xjZ@g9Y0x5Z~9vwu`f*2)d&$2v7i~x
zn!x?}hHKlWvl9OY*L#wIlYk0Yv9|Ilx~GLwZHttiPnrp)tTM3ZDlQR(Z?;=CB(fG4
zKb83UP)ztiejG&j@#Lr1Y2tT4GundTN_acbwo~?%W%9d^Qt!l+P0t|51_Y+XMZ)JT
zK6;9%uMuH=*!oCpqP5A&!)?1^f~N#lym5qeh_^b`!gVhhJHY2IG8rW$|FgKaTHPa@
z6bRSg2V%tT!zL%kfoKN;cS=cF>+v_>QJBB2gaj<^65X2nntV_xn6Q6y(OICoTDv(}
zDMa}BU9!~hv3`M)R1>s+ezz5mE&fxH%LPXlOXya7Hgk&3D1ks8Zv!!yjoj>OOitS9
zLHGJAM(PQgykz^~E*d6q23|X48Cx{8x2SOFLu@KC^(+2-%%JD|coYdh0L@MfiQ9h>
SQv}cd07nix*}k?RB>f+9$xcWB

literal 0
HcmV?d00001

diff --git a/doc/glx.txt b/doc/glx.txt
new file mode 100644
index 0000000..df91bcd
--- /dev/null
+++ b/doc/glx.txt
@@ -0,0 +1,206 @@
+GLX PUBLIC LICENSE (Version 1.0 (2/11/99)) ("License")
+
+Subject to any third party claims, Silicon Graphics, Inc. ("SGI") hereby
+grants permission to Recipient (defined below), under Recipient's
+copyrights in the Original Software (defined below), to use, copy,
+modify, merge, publish, distribute, sublicense and/or sell copies of
+Subject Software (defined below), and to permit persons to whom the
+Subject Software is furnished in accordance with this License to do the
+same, subject to all of the following terms and conditions, which
+Recipient accepts by engaging in any such use, copying, modifying,
+merging, publishing, distributing, sublicensing or selling:
+
+1. Definitions.
+
+    (a) "Original Software" means source code of computer software code
+    which is described in Exhibit A as Original Software.
+
+    (b) "Modifications" means any addition to or deletion from the
+    substance or structure of either the Original Software or any
+    previous Modifications. When Subject Software is released as a
+    series of files, a Modification means (i) any addition to or
+    deletion from the contents of a file containing Original Software or
+    previous Modifications and (ii) any new file that contains any part
+    of the Original Code or previous Modifications.
+
+    (c) "Subject Software" means the Original Software or Modifications
+    or the combination of the Original Software and Modifications, or
+    portions of any of the foregoing.
+
+    (d) "Recipient" means an individual or a legal entity exercising
+    rights under, and complying with all of the terms of, this License.
+    For legal entities, "Recipient" includes any entity which controls,
+    is controlled by, or is under common control with Recipient. For
+    purposes of this definition, "control" of an entity means (a) the
+    power, direct or indirect, to direct or manage such entity, or (b)
+    ownership of fifty percent (50%) or more of the outstanding shares
+    or beneficial ownership of such entity.
+
+2. Redistribution of Source Code Subject to These Terms. Redistributions
+of Subject Software in source code form must retain the notice set forth
+in Exhibit A, below, in every file. A copy of this License must be
+included in any documentation for such Subject Software where the
+recipients' rights relating to Subject Software are described. Recipient
+may distribute the source code version of Subject Software under a
+license of Recipient's choice, which may contain terms different from
+this License, provided that (i) Recipient is in compliance with the
+terms of this License, and (ii) the license terms include this Section 2
+and Sections 3, 4, 7, 8, 10, 12 and 13 of this License, which terms may
+not be modified or superseded by any other terms of such license. If
+Recipient distributes the source code version under a different license
+Recipient must make it absolutely clear that any terms which differ from
+this License are offered by Recipient alone, not by SGI. Recipient
+hereby agrees to indemnify SGI for any liability incurred by SGI as a
+result of any such terms Recipient offers.
+
+3. Redistribution in Executable Form. The notice set forth in Exhibit A
+must be conspicuously included in any notice in an executable version of
+Subject Software, related documentation or collateral in which Recipient
+describes the user's rights relating to the Subject Software. Recipient
+may distribute the executable version of Subject Software under a
+license of Recipient's choice, which may contain terms different from
+this License, provided that (i) Recipient is in compliance with the
+terms of this License, and (ii) the license terms include this Section 3
+and Sections 4, 7, 8, 10, 12 and 13 of this License, which terms may not
+be modified or superseded by any other terms of such license. If
+Recipient distributes the executable version under a different license
+Recipient must make it absolutely clear that any terms which differ from
+this License are offered by Recipient alone, not by SGI. Recipient
+hereby agrees to indemnify SGI for any liability incurred by SGI as a
+result of any such terms Recipient offers.
+
+4. Termination. This License and the rights granted hereunder will
+terminate automatically if Recipient fails to comply with terms herein
+and fails to cure such breach within 30 days of the breach. Any
+sublicense to the Subject Software which is properly granted shall
+survive any termination of this License absent termination by the terms
+of such sublicense. Provisions which, by their nature, must remain in
+effect beyond the termination of this License shall survive.
+
+5. No Trademark Rights. This License does not grant any rights to use
+any trade name, trademark or service mark whatsoever. No trade name,
+trademark or service mark of SGI may be used to endorse or promote
+products derived from the Subject Software without prior written
+permission of SGI.
+
+6. No Other Rights. This License does not grant any rights with respect
+to the OpenGL API or to any software or hardware implementation thereof
+or to any other software whatsoever, nor shall any other rights or
+licenses not expressly granted hereunder arise by implication, estoppel
+or otherwise with respect to the Subject Software. Title to and
+ownership of the Original Software at all times remains with SGI. All
+rights in the Original Software not expressly granted under this License
+are reserved.
+
+7. Compliance with Laws; Non-Infringement. Recipient shall comply with
+all applicable laws and regulations in connection with use and
+distribution of the Subject Software, including but not limited to, all
+export and import control laws and regulations of the U.S. government
+and other countries. Recipient may not distribute Subject Software that
+(i) in any way infringes (directly or contributorily) the rights
+(including patent, copyright, trade secret, trademark or other
+intellectual property rights of any kind) of any other person or entity
+or (ii) breaches any representation or warranty, express, implied or
+statutory, which under any applicable law it might be deemed to have
+been distributed.
+
+8. Claims of Infringement. If Recipient at any time has knowledge of any
+one or more third party claims that reproduction, modification, use,
+distribution, import or sale of Subject Software (including particular
+functionality or code incorporated in Subject Software) infringes the
+third party's intellectual property rights, Recipient must place in a
+well-identified web page bearing the title "LEGAL" a description of each
+such claim and a description of the party making each such claim in
+sufficient detail that a user of the Subject Software will know whom to
+contact regarding the claim. Also, upon gaining such knowledge of any
+such claim, Recipient must conspicuously include the URL for such web
+page in the Exhibit A notice required under Sections 2 and 3, above, and
+in the text of any related documentation, license agreement or
+collateral in which Recipient describes end user's rights relating to
+the Subject Software. If Recipient obtains such knowledge after it makes
+Subject Software available to any other person or entity, Recipient
+shall take other steps (such as notifying appropriate mailing lists or
+newsgroups) reasonably calculated to inform those who received the
+Subject Software that new knowledge has been obtained.
+
+9. DISCLAIMER OF WARRANTY. SUBJECT SOFTWARE IS PROVIDED ON AN "AS IS"
+BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
+INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE SUBJECT SOFTWARE IS
+FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-
+INFRINGING. SGI ASSUMES NO RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+SOFTWARE. SHOULD ANY SOFTWARE PROVE DEFECTIVE IN ANY RESPECT, SGI
+ASSUMES NO COST OR LIABILITY FOR ANY SERVICING, REPAIR OR CORRECTION.
+THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+LICENSE. NO USE OF ANY SUBJECT SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT
+UNDER THIS DISCLAIMER.
+
+10. LIMITATION OF LIABILITY. UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL
+THEORY, WHETHER TORT (INCLUDING, WITHOUT LIMITATION, NEGLIGENCE OR
+STRICT LIABILITY), CONTRACT, OR OTHERWISE, SHALL SGI OR ANY SGI LICENSOR
+BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR
+CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION,
+DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, LOSS OF DATA, COMPUTER
+FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR
+LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY
+OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO
+LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SGI's NEGLIGENCE
+TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME
+JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR
+CONSEQUENTIAL DAMAGES, SO THAT EXCLUSION AND LIMITATION MAY NOT APPLY TO
+RECIPIENT.
+
+11. Indemnity. Recipient shall be solely responsible for damages
+arising, directly or indirectly, out of its utilization of rights under
+this License. Recipient will defend, indemnify and hold harmless Silicon
+Graphics, Inc. from and against any loss, liability, damages, costs or
+expenses (including the payment of reasonable attorneys fees) arising
+out of Recipient's use, modification, reproduction and distribution of
+the Subject Software or out of any representation or warranty made by
+Recipient.
+
+12. U.S. Government End Users. The Subject Software is a "commercial
+item" consisting of "commercial computer software" as such terms are
+defined in title 48 of the Code of Federal Regulations and all U.S.
+Government End Users acquire only the rights set forth in this License
+and are subject to the terms of this License.
+
+13. Miscellaneous. This License represents the complete agreement
+concerning subject matter hereof. If any provision of this License is
+held to be unenforceable, such provision shall be reformed so as to
+achieve as nearly as possible the same economic effect as the original
+provision and the remainder of this License will remain in effect. This
+License shall be governed by and construed in accordance with the laws
+of the United States and the State of California as applied to
+agreements entered into and to be performed entirely within California
+between California residents. Any litigation relating to this License
+shall be subject to the exclusive jurisdiction of the Federal Courts of
+the Northern District of California (or, absent subject matter
+jurisdiction in such courts, the courts of the State of California),
+with venue lying exclusively in Santa Clara County, California, with the
+losing party responsible for costs, including without limitation, court
+costs and reasonable attorneys fees and expenses. The application of the
+United Nations Convention on Contracts for the International Sale of
+Goods is expressly excluded. Any law or regulation which provides that
+the language of a contract shall be construed against the drafter shall
+not apply to this License.
+
+Exhibit A
+
+The contents of this file are subject to Sections 2, 3, 4, 7, 8, 10, 12
+and 13 of the GLX Public License Version 1.0 (the "License"). You may
+not use this file except in compliance with those sections of the
+License. You may obtain a copy of the License at Silicon Graphics, Inc.,
+attn: Legal Services, 2011 N. Shoreline Blvd., Mountain View, CA 94043
+or at http://www.sgi.com/software/opensource/glx/license.html.
+
+Software distributed under the License is distributed on an "AS IS"
+basis. ALL WARRANTIES ARE DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY
+IMPLIED WARRANTIES OF MERCHANTABILITY, OF FITNESS FOR A PARTICULAR
+PURPOSE OR OF NON- INFRINGEMENT. See the License for the specific
+language governing rights and limitations under the License.
+
+The Original Software is GLX version 1.2 source code, released February,
+1999. The developer of the Original Software is Silicon Graphics, Inc.
+Those portions of the Subject Software created by Silicon Graphics, Inc.
+are Copyright (c) 1991-9 Silicon Graphics, Inc. All Rights Reserved.
+
diff --git a/doc/lgpl.txt b/doc/lgpl.txt
new file mode 100644
index 0000000..6b2d1c5
--- /dev/null
+++ b/doc/lgpl.txt
@@ -0,0 +1,502 @@
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    
+    Copyright (C)   
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  , 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
diff --git a/doc/sgi.txt b/doc/sgi.txt
new file mode 100644
index 0000000..7c27328
--- /dev/null
+++ b/doc/sgi.txt
@@ -0,0 +1,42 @@
+SGI FREE SOFTWARE LICENSE B (Version 1.1 [02/22/2000]) 
+1. Definitions.
+1.1. "Additional Notice Provisions" means such additional provisions as appear in the Notice in Original Code under the heading "Additional Notice Provisions."
+1.2. "Covered Code" means the Original Code or Modifications, or any combination thereof.
+1.3. "Hardware" means any physical device that accepts input, processes input, stores the results of processing, and/or provides output.
+1.4. "Larger Work" means a work that combines Covered Code or portions thereof with code not governed by the terms of this License.
+1.5. "Licensable" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.
+1.6. "License" means this document.
+1.7. "Licensed Patents" means patent claims Licensable by SGI that are infringed by the use or sale of Original Code or any Modifications provided by SGI, or any combination thereof.
+1.8. "Modifications" means any addition to or deletion from the substance or structure of the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is: 
+A. Any addition to the contents of a file containing Original Code and/or addition to or deletion from the contents of a file containing previous Modifications.
+B. Any new file that contains any part of the Original Code or previous Modifications.
+1.9. "Notice" means any notice in Original Code or Covered Code, as required by and in compliance with this License.
+1.10. "Original Code" means source code of computer software code that is described in the source code Notice required by Exhibit A as Original Code, and updates and error corrections specifically thereto.
+1.11. "Recipient" means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 8. For legal entities, "Recipient" includes any entity that controls, is controlled by, or is under common control with Recipient. For purposes of this definition, "control" of an entity means (a) the power, direct or indirect, to direct or manage such entity, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.
+1.12. "Recipient Patents" means patent claims Licensable by a Recipient that are infringed by the use or sale of Original Code or any Modifications provided by SGI, or any combination thereof. 
+1.13. "SGI" means Silicon Graphics, Inc.
+1.14. "SGI Patents" means patent claims Licensable by SGI other than the Licensed Patents.
+2. License Grant and Restrictions.
+2.1. SGI License Grant. Subject to the terms of this License and any third party intellectual property claims, for the duration of intellectual property protections inherent in the Original Code, SGI hereby grants Recipient a worldwide, royalty-free, non-exclusive license, to do the following: (i) under copyrights Licensable by SGI, to reproduce, distribute, create derivative works from, and, to the extent applicable, display and perform the Original Code and/or any Modifications provided by SGI alone and/or as part of a Larger Work; and (ii) under any Licensable Patents, to make, have made, use, sell, offer for sale, import and/or otherwise transfer the Original Code and/or any Modifications provided by SGI. Recipient accepts the terms and conditions of this License by undertaking any of the aforementioned actions. The patent license shall apply to the Covered Code if, at the time any related Modification is added, such addition of the Modification causes such combination to be covered by the Licensed Patents. The patent license in Section 2.1(ii) shall not apply to any other combinations that include the Modification. No patent license is provided under SGI Patents for infringements of SGI Patents by Modifications not provided by SGI or combinations of Original Code and Modifications not provided by SGI. 
+2.2. Recipient License Grant. Subject to the terms of this License and any third party intellectual property claims, Recipient hereby grants SGI and any other Recipients a worldwide, royalty-free, non-exclusive license, under any Recipient Patents, to make, have made, use, sell, offer for sale, import and/or otherwise transfer the Original Code and/or any Modifications provided by SGI.
+2.3. No License For Hardware Implementations. The licenses granted in Section 2.1 and 2.2 are not applicable to implementation in Hardware of the algorithms embodied in the Original Code or any Modifications provided by SGI .
+3. Redistributions. 
+3.1. Retention of Notice/Copy of License. The Notice set forth in Exhibit A, below, must be conspicuously retained or included in any and all redistributions of Covered Code. For distributions of the Covered Code in source code form, the Notice must appear in every file that can include a text comments field; in executable form, the Notice and a copy of this License must appear in related documentation or collateral where the Recipient's rights relating to Covered Code are described. Any Additional Notice Provisions which actually appears in the Original Code must also be retained or included in any and all redistributions of Covered Code.
+3.2. Alternative License. Provided that Recipient is in compliance with the terms of this License, Recipient may, so long as without derogation of any of SGI's rights in and to the Original Code, distribute the source code and/or executable version(s) of Covered Code under (1) this License; (2) a license identical to this License but for only such changes as are necessary in order to clarify Recipient's role as licensor of Modifications; and/or (3) a license of Recipient's choosing, containing terms different from this License, provided that the license terms include this Section 3 and Sections 4, 6, 7, 10, 12, and 13, which terms may not be modified or superseded by any other terms of such license. If Recipient elects to use any license other than this License, Recipient must make it absolutely clear that any of its terms which differ from this License are offered by Recipient alone, and not by SGI. It is emphasized that this License is a limited license, and, regardless of the license form employed by Recipient in accordance with this Section 3.2, Recipient may relicense only such rights, in Original Code and Modifications by SGI, as it has actually been granted by SGI in this License.
+3.3. Indemnity. Recipient hereby agrees to indemnify SGI for any liability incurred by SGI as a result of any such alternative license terms Recipient offers.
+4. Termination. This License and the rights granted hereunder will terminate automatically if Recipient breaches any term herein and fails to cure such breach within 30 days thereof. Any sublicense to the Covered Code that is properly granted shall survive any termination of this License, absent termination by the terms of such sublicense. Provisions that, by their nature, must remain in effect beyond the termination of this License, shall survive.
+5. No Trademark Or Other Rights. This License does not grant any rights to: (i) any software apart from the Covered Code, nor shall any other rights or licenses not expressly granted hereunder arise by implication, estoppel or otherwise with respect to the Covered Code; (ii) any trade name, trademark or service mark whatsoever, including without limitation any related right for purposes of endorsement or promotion of products derived from the Covered Code, without prior written permission of SGI; or (iii) any title to or ownership of the Original Code, which shall at all times remains with SGI. All rights in the Original Code not expressly granted under this License are reserved. 
+6. Compliance with Laws; Non-Infringement. There are various worldwide laws, regulations, and executive orders applicable to dispositions of Covered Code, including without limitation export, re-export, and import control laws, regulations, and executive orders, of the U.S. government and other countries, and Recipient is reminded it is obliged to obey such laws, regulations, and executive orders. Recipient may not distribute Covered Code that (i) in any way infringes (directly or contributorily) any intellectual property rights of any kind of any other person or entity or (ii) breaches any representation or warranty, express, implied or statutory, to which, under any applicable law, it might be deemed to have been subject.
+7. Claims of Infringement. If Recipient learns of any third party claim that any disposition of Covered Code and/or functionality wholly or partially infringes the third party's intellectual property rights, Recipient will promptly notify SGI of such claim.
+8. Versions of the License. SGI may publish revised and/or new versions of the License from time to time, each with a distinguishing version number. Once Covered Code has been published under a particular version of the License, Recipient may, for the duration of the license, continue to use it under the terms of that version, or choose to use such Covered Code under the terms of any subsequent version published by SGI. Subject to the provisions of Sections 3 and 4 of this License, only SGI may modify the terms applicable to Covered Code created under this License.
+9. DISCLAIMER OF WARRANTY. COVERED CODE IS PROVIDED "AS IS." ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS ARE DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. SGI ASSUMES NO RISK AS TO THE QUALITY AND PERFORMANCE OF THE SOFTWARE. SHOULD THE SOFTWARE PROVE DEFECTIVE IN ANY RESPECT, SGI ASSUMES NO COST OR LIABILITY FOR SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY IS AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT SUBJECT TO THIS DISCLAIMER.
+10. LIMITATION OF LIABILITY. UNDER NO CIRCUMSTANCES NOR LEGAL THEORY, WHETHER TORT (INCLUDING, WITHOUT LIMITATION, NEGLIGENCE OR STRICT LIABILITY), CONTRACT, OR OTHERWISE, SHALL SGI OR ANY SGI LICENSOR BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, LOSS OF DATA, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SGI's NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THAT EXCLUSION AND LIMITATION MAY NOT APPLY TO RECIPIENT.
+11. Indemnity. Recipient shall be solely responsible for damages arising, directly or indirectly, out of its utilization of rights under this License. Recipient will defend, indemnify and hold harmless Silicon Graphics, Inc. from and against any loss, liability, damages, costs or expenses (including the payment of reasonable attorneys fees) arising out of Recipient's use, modification, reproduction and distribution of the Covered Code or out of any representation or warranty made by Recipient.
+12. U.S. Government End Users. The Covered Code is a "commercial item" consisting of "commercial computer software" as such terms are defined in title 48 of the Code of Federal Regulations and all U.S. Government End Users acquire only the rights set forth in this License and are subject to the terms of this License.
+13. Miscellaneous. This License represents the complete agreement concerning the its subject matter. If any provision of this License is held to be unenforceable, such provision shall be reformed so as to achieve as nearly as possible the same legal and economic effect as the original provision and the remainder of this License will remain in effect. This License shall be governed by and construed in accordance with the laws of the United States and the State of California as applied to agreements entered into and to be performed entirely within California between California residents. Any litigation relating to this License shall be subject to the exclusive jurisdiction of the Federal Courts of the Northern District of California (or, absent subject matter jurisdiction in such courts, the courts of the State of California), with venue lying exclusively in Santa Clara County, California, with the losing party responsible for costs, including without limitation, court costs and reasonable attorneys fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation that provides that the language of a contract shall be construed against the drafter shall not apply to this License.
+Exhibit A
+License Applicability. Except to the extent portions of this file are made subject to an alternative license as permitted in the SGI Free Software License B, Version 1.1 (the "License"), the contents of this file are subject only to the provisions of the License. You may not use this file except in compliance with the License. You may obtain a copy of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: 
+http://oss.sgi.com/projects/FreeB
+Note that, as provided in the License, the Software is distributed on an "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+Original Code. The Original Code is: [name of software, version number, and release date], developed by Silicon Graphics, Inc. The Original Code is Copyright (c) [dates of first publication, as appearing in the Notice in the Original Code] Silicon Graphics, Inc. Copyright in any portions created by third parties is as indicated elsewhere herein. All Rights Reserved.
+Additional Notice Provisions: [such additional provisions, if any, as appear in the Notice in the Original Code under the heading "Additional Notice Provisions"]
diff --git a/include/GL/glew.h b/include/GL/glew.h
new file mode 100644
index 0000000..839fd44
--- /dev/null
+++ b/include/GL/glew.h
@@ -0,0 +1,4575 @@
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: This software was created using the
+** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+** not been independently verified as being compliant with the OpenGL(R)
+** version 1.2.1 Specification.
+*/
+
+/*
+** Copyright (C) 2002, Lev Povalahev
+** All rights reserved.
+** 
+** Redistribution and use in source and binary forms, with or without modification, 
+** are permitted provided that the following conditions are met:
+** 
+** * Redistributions of source code must retain the above copyright notice, 
+**   this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright notice, 
+**   this list of conditions and the following disclaimer in the documentation 
+**   and/or other materials provided with the distribution.
+** * The name of the author may be used to endorse or promote products 
+**   derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
+** IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+** INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+** BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 
+** OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+** WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
+** THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+** The OpenGL Extension Wrangler Library
+** Copyright (C) 2002 Milan Ikits
+**
+** This library is free software; you can redistribute it and/or
+** modify it under the terms of the GNU Lesser General Public
+** License as published by the Free Software Foundation; either
+** version 2.1 of the License, or (at your option) any later version.
+**
+** This library is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+** Lesser General Public License for more details.
+**
+** You should have received a copy of the GNU Lesser General Public
+** License along with this library; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#ifndef __glew_h__
+#define __glew_h__
+
+#if defined(__gl_h_) || defined(__GL_H__)
+#error gl.h included before glew.h
+#endif
+#if defined(__glext_h_) || defined(__GLEXT_H_)
+#error glext.h included before glew.h
+#endif
+#if defined(__gl_ATI_h_)
+#error glATI.h included before glew.h
+#endif
+
+#define __gl_h_
+#define __GL_H__
+#define __glext_h_
+#define __GLEXT_H_
+#define __gl_ATI_h_
+
+#ifdef _WIN32
+
+/*
+ * GLEW does not include  to avoid name space pollution.
+ * GL needs APIENTRY and WINGDIAPI, GLU needs CALLBACK and wchar_t 
+ * defined properly.
+ */
+/*  */
+#ifndef APIENTRY
+#define GLEW_APIENTRY_DEFINED
+#if (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED)
+#define APIENTRY __stdcall
+#else
+#define APIENTRY
+#endif
+#endif
+/*  */
+#ifndef CALLBACK
+#if (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS)
+#define CALLBACK __stdcall
+#else
+#define CALLBACK
+#endif
+#endif
+/*  and  */
+#ifndef WINGDIAPI
+#define GLEW_WINGDIAPI_DEFINED
+#define WINGDIAPI __declspec(dllimport)
+#endif
+/*  */
+#ifndef _WCHAR_T_DEFINED
+typedef unsigned short wchar_t;
+#define _WCHAR_T_DEFINED
+#endif
+
+/*
+ * GLEW_STATIC needs to be set when including the
+ * source directly in the project.  
+ * GLEW_BUILD is set when building the dll version.
+ */
+#ifdef GLEW_STATIC
+#define GLEW_EXPORT
+#else
+#ifdef GLEW_BUILD
+#define GLEW_EXPORT __declspec(dllexport)
+#else
+#define GLEW_EXPORT __declspec(dllimport)
+#endif
+#endif
+
+#else /* _UNIX */
+
+#define APIENTRY
+#define GLEW_EXPORT
+
+#endif /* _WIN32 */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* core OpenGL */
+#define GL_VERSION_1_1 1
+#define GL_VERSION_1_2 1
+#define GL_VERSION_1_3 1
+#define GL_VERSION_1_4 1
+
+/* ARB extensions */
+#define GL_ARB_depth_texture 1 /* (1.4) */
+#define GL_ARB_fragment_program 1
+#define GL_ARB_imaging 1 /* (1.2) */
+#define GL_ARB_matrix_palette 1 
+#define GL_ARB_multisample 1 /* (1.3) */
+#define GL_ARB_multitexture 1 /* (1.3) */
+#define GL_ARB_point_parameters 1 /* (1.4) */
+#define GL_ARB_shadow 1 /* (1.4) */
+#define GL_ARB_shadow_ambient 1
+#define GL_ARB_texture_border_clamp 1 /* (1.3) */
+#define GL_ARB_texture_compression 1 /* (1.3) */
+#define GL_ARB_texture_cube_map 1 /* (1.3) */
+#define GL_ARB_texture_env_add 1 /* (1.3) */
+#define GL_ARB_texture_env_combine 1 /* (1.3) */
+#define GL_ARB_texture_env_crossbar 1 /* (1.3) */
+#define GL_ARB_texture_env_dot3 1 /* (1.3) */
+#define GL_ARB_texture_mirrored_repeat 1 /* (1.4) */
+#define GL_ARB_transpose_matrix 1 /* (1.3) */
+#define GL_ARB_vertex_blend 1
+#define GL_ARB_vertex_program 1
+#define GL_ARB_window_pos 1 /* (1.4) */
+
+/* multi-vendor extensions */
+#define GL_EXT_abgr 1
+#define GL_EXT_bgra 1 /* (1.2) */
+#define GL_EXT_blend_color 1 /* (1.2) */
+#define GL_EXT_blend_func_separate 1 /* (1.4) */
+#define GL_EXT_blend_minmax 1 /* (1.2) */
+#define GL_EXT_blend_subtract 1 /* (1.4) */
+#define GL_EXT_clip_volume_hint 1
+#define GL_EXT_compiled_vertex_array 1 
+#define GL_EXT_draw_range_elements 1 /* (1.2) */
+#define GL_EXT_cull_vertex 1
+#define GL_EXT_fog_coord 1 /* (1.4) */
+#define GL_EXT_multi_draw_arrays 1 /* (1.4) */
+#define GL_EXT_packed_pixels 1 /* (1.2) */
+#define GL_EXT_point_parameters 1 /* (1.4) */
+#define GL_EXT_secondary_color 1 /* (1.4) */
+#define GL_EXT_separate_specular_color 1 /* (1.2) */
+#define GL_EXT_shadow_funcs 1 /* ??? */
+#define GL_EXT_stencil_two_side 1
+#define GL_EXT_stencil_wrap 1 /* (1.4) */
+#define GL_EXT_texture_compression_s3tc 1
+#define GL_EXT_texture_filter_anisotropic 1
+#define GL_EXT_texture_lod_bias 1 /* (1.4) */
+#define GL_EXT_texture_rectangle 1
+#define GL_EXT_vertex_shader 1
+#define GL_EXT_vertex_weighting 1
+
+/* vendor-specific extensions */
+#define GL_SGIS_generate_mipmap 1
+#define GL_SGIS_texture_lod 1
+#define GL_SGIX_depth_texture 1 /* (1.4) */
+#define GL_SGIX_shadow 1
+
+#define GL_HP_occlusion_test 1
+#define GL_S3_s3tc 1
+#define GL_WIN_swap_hint 1
+
+/* ATI extensions */
+#define GL_ATI_draw_buffers 1
+#define GL_ATI_element_array 1
+#define GL_ATI_envmap_bumpmap 1
+#define GL_ATI_fragment_shader 1
+#define GL_ATI_map_object_buffer 1
+#define GL_ATI_mapped_texture 1
+#define GL_ATI_pn_triangles 1
+#define GL_ATI_point_cull_mode 1
+#define GL_ATI_separate_stencil 1
+#define GL_ATI_text_fragment_shader 1
+#define GL_ATI_texture_float 1
+#define GL_ATI_texture_mirror_once 1
+#define GL_ATI_timestamp 1
+#define GL_ATI_vertex_array_object 1
+#define GL_ATI_vertex_attrib_array_object 1
+#define GL_ATI_vertex_streams 1
+#define GL_ATIX_point_sprites 1
+#define GL_ATIX_texture_env_combine3 1
+#define GL_ATIX_texture_env_route 1
+#define GL_ATIX_vertex_shader_output_point_size 1
+
+/* NVIDIA extensions */
+#define GL_NV_blend_square 1
+#define GL_NV_copy_depth_to_color 1
+#define GL_NV_depth_clamp 1
+#define GL_NV_element_array 1
+#define GL_NV_evaluators 1
+#define GL_NV_fence 1
+#define GL_NV_fog_distance 1
+#define GL_NV_float_buffer 1
+#define GL_NV_fragment_program 1
+#define GL_NV_light_max_exponent 1
+#define GL_NV_multisample_filter_hint 1
+#define GL_NV_occlusion_query 1
+#define GL_NV_packed_depth_stencil 1
+#define GL_NV_pixel_data_range 1
+#define GL_NV_point_sprite 1
+#define GL_NV_primitive_restart 1
+#define GL_NV_register_combiners 1
+#define GL_NV_register_combiners2 1
+#define GL_NV_texgen_reflection 1
+#define GL_NV_texture_compression_vtc 1
+#define GL_NV_texture_env_combine4 1
+#define GL_NV_texture_rectangle 1
+#define GL_NV_texture_shader 1
+#define GL_NV_texture_shader2 1
+#define GL_NV_texture_shader3 1
+#define GL_NV_vertex_array_range 1
+#define GL_NV_vertex_array_range2 1
+#define GL_NV_vertex_program 1
+#define GL_NV_vertex_program1_1 1
+#define GL_NV_vertex_program2 1
+
+/* ------------------------------ OpenGL 1.1 ------------------------------ */
+
+#ifdef GL_VERSION_1_1
+
+typedef unsigned int GLenum;
+typedef unsigned char GLboolean;
+typedef unsigned int GLbitfield;
+typedef signed char GLbyte;
+typedef short GLshort;
+typedef int GLint;
+typedef int GLsizei;
+typedef unsigned char GLubyte;
+typedef unsigned short GLushort;
+typedef unsigned int GLuint;
+typedef float GLfloat;
+typedef float GLclampf;
+typedef double GLdouble;
+typedef double GLclampd;
+typedef void GLvoid;
+
+#define GL_VERSION_1_1                                          1
+#define GL_ACCUM                                                0x0100
+#define GL_LOAD                                                 0x0101
+#define GL_RETURN                                               0x0102
+#define GL_MULT                                                 0x0103
+#define GL_ADD                                                  0x0104
+#define GL_NEVER                                                0x0200
+#define GL_LESS                                                 0x0201
+#define GL_EQUAL                                                0x0202
+#define GL_LEQUAL                                               0x0203
+#define GL_GREATER                                              0x0204
+#define GL_NOTEQUAL                                             0x0205
+#define GL_GEQUAL                                               0x0206
+#define GL_ALWAYS                                               0x0207
+#define GL_CURRENT_BIT                                          0x00000001
+#define GL_POINT_BIT                                            0x00000002
+#define GL_LINE_BIT                                             0x00000004
+#define GL_POLYGON_BIT                                          0x00000008
+#define GL_POLYGON_STIPPLE_BIT                                  0x00000010
+#define GL_PIXEL_MODE_BIT                                       0x00000020
+#define GL_LIGHTING_BIT                                         0x00000040
+#define GL_FOG_BIT                                              0x00000080
+#define GL_DEPTH_BUFFER_BIT                                     0x00000100
+#define GL_ACCUM_BUFFER_BIT                                     0x00000200
+#define GL_STENCIL_BUFFER_BIT                                   0x00000400
+#define GL_VIEWPORT_BIT                                         0x00000800
+#define GL_TRANSFORM_BIT                                        0x00001000
+#define GL_ENABLE_BIT                                           0x00002000
+#define GL_COLOR_BUFFER_BIT                                     0x00004000
+#define GL_HINT_BIT                                             0x00008000
+#define GL_EVAL_BIT                                             0x00010000
+#define GL_LIST_BIT                                             0x00020000
+#define GL_TEXTURE_BIT                                          0x00040000
+#define GL_SCISSOR_BIT                                          0x00080000
+#define GL_ALL_ATTRIB_BITS                                      0x000fffff
+#define GL_POINTS                                               0x0000
+#define GL_LINES                                                0x0001
+#define GL_LINE_LOOP                                            0x0002
+#define GL_LINE_STRIP                                           0x0003
+#define GL_TRIANGLES                                            0x0004
+#define GL_TRIANGLE_STRIP                                       0x0005
+#define GL_TRIANGLE_FAN                                         0x0006
+#define GL_QUADS                                                0x0007
+#define GL_QUAD_STRIP                                           0x0008
+#define GL_POLYGON                                              0x0009
+#define GL_ZERO                                                 0
+#define GL_ONE                                                  1
+#define GL_SRC_COLOR                                            0x0300
+#define GL_ONE_MINUS_SRC_COLOR                                  0x0301
+#define GL_SRC_ALPHA                                            0x0302
+#define GL_ONE_MINUS_SRC_ALPHA                                  0x0303
+#define GL_DST_ALPHA                                            0x0304
+#define GL_ONE_MINUS_DST_ALPHA                                  0x0305
+#define GL_DST_COLOR                                            0x0306
+#define GL_ONE_MINUS_DST_COLOR                                  0x0307
+#define GL_SRC_ALPHA_SATURATE                                   0x0308
+#define GL_TRUE                                                 1
+#define GL_FALSE                                                0
+#define GL_CLIP_PLANE0                                          0x3000
+#define GL_CLIP_PLANE1                                          0x3001
+#define GL_CLIP_PLANE2                                          0x3002
+#define GL_CLIP_PLANE3                                          0x3003
+#define GL_CLIP_PLANE4                                          0x3004
+#define GL_CLIP_PLANE5                                          0x3005
+#define GL_BYTE                                                 0x1400
+#define GL_UNSIGNED_BYTE                                        0x1401
+#define GL_SHORT                                                0x1402
+#define GL_UNSIGNED_SHORT                                       0x1403
+#define GL_INT                                                  0x1404
+#define GL_UNSIGNED_INT                                         0x1405
+#define GL_FLOAT                                                0x1406
+#define GL_2_BYTES                                              0x1407
+#define GL_3_BYTES                                              0x1408
+#define GL_4_BYTES                                              0x1409
+#define GL_DOUBLE                                               0x140A
+#define GL_NONE                                                 0
+#define GL_FRONT_LEFT                                           0x0400
+#define GL_FRONT_RIGHT                                          0x0401
+#define GL_BACK_LEFT                                            0x0402
+#define GL_BACK_RIGHT                                           0x0403
+#define GL_FRONT                                                0x0404
+#define GL_BACK                                                 0x0405
+#define GL_LEFT                                                 0x0406
+#define GL_RIGHT                                                0x0407
+#define GL_FRONT_AND_BACK                                       0x0408
+#define GL_AUX0                                                 0x0409
+#define GL_AUX1                                                 0x040A
+#define GL_AUX2                                                 0x040B
+#define GL_AUX3                                                 0x040C
+#define GL_NO_ERROR                                             0
+#define GL_INVALID_ENUM                                         0x0500
+#define GL_INVALID_VALUE                                        0x0501
+#define GL_INVALID_OPERATION                                    0x0502
+#define GL_STACK_OVERFLOW                                       0x0503
+#define GL_STACK_UNDERFLOW                                      0x0504
+#define GL_OUT_OF_MEMORY                                        0x0505
+#define GL_2D                                                   0x0600
+#define GL_3D                                                   0x0601
+#define GL_3D_COLOR                                             0x0602
+#define GL_3D_COLOR_TEXTURE                                     0x0603
+#define GL_4D_COLOR_TEXTURE                                     0x0604
+#define GL_PASS_THROUGH_TOKEN                                   0x0700
+#define GL_POINT_TOKEN                                          0x0701
+#define GL_LINE_TOKEN                                           0x0702
+#define GL_POLYGON_TOKEN                                        0x0703
+#define GL_BITMAP_TOKEN                                         0x0704
+#define GL_DRAW_PIXEL_TOKEN                                     0x0705
+#define GL_COPY_PIXEL_TOKEN                                     0x0706
+#define GL_LINE_RESET_TOKEN                                     0x0707
+#define GL_EXP                                                  0x0800
+#define GL_EXP2                                                 0x0801
+#define GL_CW                                                   0x0900
+#define GL_CCW                                                  0x0901
+#define GL_COEFF                                                0x0A00
+#define GL_ORDER                                                0x0A01
+#define GL_DOMAIN                                               0x0A02
+#define GL_CURRENT_COLOR                                        0x0B00
+#define GL_CURRENT_INDEX                                        0x0B01
+#define GL_CURRENT_NORMAL                                       0x0B02
+#define GL_CURRENT_TEXTURE_COORDS                               0x0B03
+#define GL_CURRENT_RASTER_COLOR                                 0x0B04
+#define GL_CURRENT_RASTER_INDEX                                 0x0B05
+#define GL_CURRENT_RASTER_TEXTURE_COORDS                        0x0B06
+#define GL_CURRENT_RASTER_POSITION                              0x0B07
+#define GL_CURRENT_RASTER_POSITION_VALID                        0x0B08
+#define GL_CURRENT_RASTER_DISTANCE                              0x0B09
+#define GL_POINT_SMOOTH                                         0x0B10
+#define GL_POINT_SIZE                                           0x0B11
+#define GL_POINT_SIZE_RANGE                                     0x0B12
+#define GL_POINT_SIZE_GRANULARITY                               0x0B13
+#define GL_LINE_SMOOTH                                          0x0B20
+#define GL_LINE_WIDTH                                           0x0B21
+#define GL_LINE_WIDTH_RANGE                                     0x0B22
+#define GL_LINE_WIDTH_GRANULARITY                               0x0B23
+#define GL_LINE_STIPPLE                                         0x0B24
+#define GL_LINE_STIPPLE_PATTERN                                 0x0B25
+#define GL_LINE_STIPPLE_REPEAT                                  0x0B26
+#define GL_LIST_MODE                                            0x0B30
+#define GL_MAX_LIST_NESTING                                     0x0B31
+#define GL_LIST_BASE                                            0x0B32
+#define GL_LIST_INDEX                                           0x0B33
+#define GL_POLYGON_MODE                                         0x0B40
+#define GL_POLYGON_SMOOTH                                       0x0B41
+#define GL_POLYGON_STIPPLE                                      0x0B42
+#define GL_EDGE_FLAG                                            0x0B43
+#define GL_CULL_FACE                                            0x0B44
+#define GL_CULL_FACE_MODE                                       0x0B45
+#define GL_FRONT_FACE                                           0x0B46
+#define GL_LIGHTING                                             0x0B50
+#define GL_LIGHT_MODEL_LOCAL_VIEWER                             0x0B51
+#define GL_LIGHT_MODEL_TWO_SIDE                                 0x0B52
+#define GL_LIGHT_MODEL_AMBIENT                                  0x0B53
+#define GL_SHADE_MODEL                                          0x0B54
+#define GL_COLOR_MATERIAL_FACE                                  0x0B55
+#define GL_COLOR_MATERIAL_PARAMETER                             0x0B56
+#define GL_COLOR_MATERIAL                                       0x0B57
+#define GL_FOG                                                  0x0B60
+#define GL_FOG_INDEX                                            0x0B61
+#define GL_FOG_DENSITY                                          0x0B62
+#define GL_FOG_START                                            0x0B63
+#define GL_FOG_END                                              0x0B64
+#define GL_FOG_MODE                                             0x0B65
+#define GL_FOG_COLOR                                            0x0B66
+#define GL_DEPTH_RANGE                                          0x0B70
+#define GL_DEPTH_TEST                                           0x0B71
+#define GL_DEPTH_WRITEMASK                                      0x0B72
+#define GL_DEPTH_CLEAR_VALUE                                    0x0B73
+#define GL_DEPTH_FUNC                                           0x0B74
+#define GL_ACCUM_CLEAR_VALUE                                    0x0B80
+#define GL_STENCIL_TEST                                         0x0B90
+#define GL_STENCIL_CLEAR_VALUE                                  0x0B91
+#define GL_STENCIL_FUNC                                         0x0B92
+#define GL_STENCIL_VALUE_MASK                                   0x0B93
+#define GL_STENCIL_FAIL                                         0x0B94
+#define GL_STENCIL_PASS_DEPTH_FAIL                              0x0B95
+#define GL_STENCIL_PASS_DEPTH_PASS                              0x0B96
+#define GL_STENCIL_REF                                          0x0B97
+#define GL_STENCIL_WRITEMASK                                    0x0B98
+#define GL_MATRIX_MODE                                          0x0BA0
+#define GL_NORMALIZE                                            0x0BA1
+#define GL_VIEWPORT                                             0x0BA2
+#define GL_MODELVIEW_STACK_DEPTH                                0x0BA3
+#define GL_PROJECTION_STACK_DEPTH                               0x0BA4
+#define GL_TEXTURE_STACK_DEPTH                                  0x0BA5
+#define GL_MODELVIEW_MATRIX                                     0x0BA6
+#define GL_PROJECTION_MATRIX                                    0x0BA7
+#define GL_TEXTURE_MATRIX                                       0x0BA8
+#define GL_ATTRIB_STACK_DEPTH                                   0x0BB0
+#define GL_CLIENT_ATTRIB_STACK_DEPTH                            0x0BB1
+#define GL_ALPHA_TEST                                           0x0BC0
+#define GL_ALPHA_TEST_FUNC                                      0x0BC1
+#define GL_ALPHA_TEST_REF                                       0x0BC2
+#define GL_DITHER                                               0x0BD0
+#define GL_BLEND_DST                                            0x0BE0
+#define GL_BLEND_SRC                                            0x0BE1
+#define GL_BLEND                                                0x0BE2
+#define GL_LOGIC_OP_MODE                                        0x0BF0
+#define GL_INDEX_LOGIC_OP                                       0x0BF1
+#define GL_COLOR_LOGIC_OP                                       0x0BF2
+#define GL_AUX_BUFFERS                                          0x0C00
+#define GL_DRAW_BUFFER                                          0x0C01
+#define GL_READ_BUFFER                                          0x0C02
+#define GL_SCISSOR_BOX                                          0x0C10
+#define GL_SCISSOR_TEST                                         0x0C11
+#define GL_INDEX_CLEAR_VALUE                                    0x0C20
+#define GL_INDEX_WRITEMASK                                      0x0C21
+#define GL_COLOR_CLEAR_VALUE                                    0x0C22
+#define GL_COLOR_WRITEMASK                                      0x0C23
+#define GL_INDEX_MODE                                           0x0C30
+#define GL_RGBA_MODE                                            0x0C31
+#define GL_DOUBLEBUFFER                                         0x0C32
+#define GL_STEREO                                               0x0C33
+#define GL_RENDER_MODE                                          0x0C40
+#define GL_PERSPECTIVE_CORRECTION_HINT                          0x0C50
+#define GL_POINT_SMOOTH_HINT                                    0x0C51
+#define GL_LINE_SMOOTH_HINT                                     0x0C52
+#define GL_POLYGON_SMOOTH_HINT                                  0x0C53
+#define GL_FOG_HINT                                             0x0C54
+#define GL_TEXTURE_GEN_S                                        0x0C60
+#define GL_TEXTURE_GEN_T                                        0x0C61
+#define GL_TEXTURE_GEN_R                                        0x0C62
+#define GL_TEXTURE_GEN_Q                                        0x0C63
+#define GL_PIXEL_MAP_I_TO_I                                     0x0C70
+#define GL_PIXEL_MAP_S_TO_S                                     0x0C71
+#define GL_PIXEL_MAP_I_TO_R                                     0x0C72
+#define GL_PIXEL_MAP_I_TO_G                                     0x0C73
+#define GL_PIXEL_MAP_I_TO_B                                     0x0C74
+#define GL_PIXEL_MAP_I_TO_A                                     0x0C75
+#define GL_PIXEL_MAP_R_TO_R                                     0x0C76
+#define GL_PIXEL_MAP_G_TO_G                                     0x0C77
+#define GL_PIXEL_MAP_B_TO_B                                     0x0C78
+#define GL_PIXEL_MAP_A_TO_A                                     0x0C79
+#define GL_PIXEL_MAP_I_TO_I_SIZE                                0x0CB0
+#define GL_PIXEL_MAP_S_TO_S_SIZE                                0x0CB1
+#define GL_PIXEL_MAP_I_TO_R_SIZE                                0x0CB2
+#define GL_PIXEL_MAP_I_TO_G_SIZE                                0x0CB3
+#define GL_PIXEL_MAP_I_TO_B_SIZE                                0x0CB4
+#define GL_PIXEL_MAP_I_TO_A_SIZE                                0x0CB5
+#define GL_PIXEL_MAP_R_TO_R_SIZE                                0x0CB6
+#define GL_PIXEL_MAP_G_TO_G_SIZE                                0x0CB7
+#define GL_PIXEL_MAP_B_TO_B_SIZE                                0x0CB8
+#define GL_PIXEL_MAP_A_TO_A_SIZE                                0x0CB9
+#define GL_UNPACK_SWAP_BYTES                                    0x0CF0
+#define GL_UNPACK_LSB_FIRST                                     0x0CF1
+#define GL_UNPACK_ROW_LENGTH                                    0x0CF2
+#define GL_UNPACK_SKIP_ROWS                                     0x0CF3
+#define GL_UNPACK_SKIP_PIXELS                                   0x0CF4
+#define GL_UNPACK_ALIGNMENT                                     0x0CF5
+#define GL_PACK_SWAP_BYTES                                      0x0D00
+#define GL_PACK_LSB_FIRST                                       0x0D01
+#define GL_PACK_ROW_LENGTH                                      0x0D02
+#define GL_PACK_SKIP_ROWS                                       0x0D03
+#define GL_PACK_SKIP_PIXELS                                     0x0D04
+#define GL_PACK_ALIGNMENT                                       0x0D05
+#define GL_MAP_COLOR                                            0x0D10
+#define GL_MAP_STENCIL                                          0x0D11
+#define GL_INDEX_SHIFT                                          0x0D12
+#define GL_INDEX_OFFSET                                         0x0D13
+#define GL_RED_SCALE                                            0x0D14
+#define GL_RED_BIAS                                             0x0D15
+#define GL_ZOOM_X                                               0x0D16
+#define GL_ZOOM_Y                                               0x0D17
+#define GL_GREEN_SCALE                                          0x0D18
+#define GL_GREEN_BIAS                                           0x0D19
+#define GL_BLUE_SCALE                                           0x0D1A
+#define GL_BLUE_BIAS                                            0x0D1B
+#define GL_ALPHA_SCALE                                          0x0D1C
+#define GL_ALPHA_BIAS                                           0x0D1D
+#define GL_DEPTH_SCALE                                          0x0D1E
+#define GL_DEPTH_BIAS                                           0x0D1F
+#define GL_MAX_EVAL_ORDER                                       0x0D30
+#define GL_MAX_LIGHTS                                           0x0D31
+#define GL_MAX_CLIP_PLANES                                      0x0D32
+#define GL_MAX_TEXTURE_SIZE                                     0x0D33
+#define GL_MAX_PIXEL_MAP_TABLE                                  0x0D34
+#define GL_MAX_ATTRIB_STACK_DEPTH                               0x0D35
+#define GL_MAX_MODELVIEW_STACK_DEPTH                            0x0D36
+#define GL_MAX_NAME_STACK_DEPTH                                 0x0D37
+#define GL_MAX_PROJECTION_STACK_DEPTH                           0x0D38
+#define GL_MAX_TEXTURE_STACK_DEPTH                              0x0D39
+#define GL_MAX_VIEWPORT_DIMS                                    0x0D3A
+#define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH                        0x0D3B
+#define GL_SUBPIXEL_BITS                                        0x0D50
+#define GL_INDEX_BITS                                           0x0D51
+#define GL_RED_BITS                                             0x0D52
+#define GL_GREEN_BITS                                           0x0D53
+#define GL_BLUE_BITS                                            0x0D54
+#define GL_ALPHA_BITS                                           0x0D55
+#define GL_DEPTH_BITS                                           0x0D56
+#define GL_STENCIL_BITS                                         0x0D57
+#define GL_ACCUM_RED_BITS                                       0x0D58
+#define GL_ACCUM_GREEN_BITS                                     0x0D59
+#define GL_ACCUM_BLUE_BITS                                      0x0D5A
+#define GL_ACCUM_ALPHA_BITS                                     0x0D5B
+#define GL_NAME_STACK_DEPTH                                     0x0D70
+#define GL_AUTO_NORMAL                                          0x0D80
+#define GL_MAP1_COLOR_4                                         0x0D90
+#define GL_MAP1_INDEX                                           0x0D91
+#define GL_MAP1_NORMAL                                          0x0D92
+#define GL_MAP1_TEXTURE_COORD_1                                 0x0D93
+#define GL_MAP1_TEXTURE_COORD_2                                 0x0D94
+#define GL_MAP1_TEXTURE_COORD_3                                 0x0D95
+#define GL_MAP1_TEXTURE_COORD_4                                 0x0D96
+#define GL_MAP1_VERTEX_3                                        0x0D97
+#define GL_MAP1_VERTEX_4                                        0x0D98
+#define GL_MAP2_COLOR_4                                         0x0DB0
+#define GL_MAP2_INDEX                                           0x0DB1
+#define GL_MAP2_NORMAL                                          0x0DB2
+#define GL_MAP2_TEXTURE_COORD_1                                 0x0DB3
+#define GL_MAP2_TEXTURE_COORD_2                                 0x0DB4
+#define GL_MAP2_TEXTURE_COORD_3                                 0x0DB5
+#define GL_MAP2_TEXTURE_COORD_4                                 0x0DB6
+#define GL_MAP2_VERTEX_3                                        0x0DB7
+#define GL_MAP2_VERTEX_4                                        0x0DB8
+#define GL_MAP1_GRID_DOMAIN                                     0x0DD0
+#define GL_MAP1_GRID_SEGMENTS                                   0x0DD1
+#define GL_MAP2_GRID_DOMAIN                                     0x0DD2
+#define GL_MAP2_GRID_SEGMENTS                                   0x0DD3
+#define GL_TEXTURE_1D                                           0x0DE0
+#define GL_TEXTURE_2D                                           0x0DE1
+#define GL_FEEDBACK_BUFFER_POINTER                              0x0DF0
+#define GL_FEEDBACK_BUFFER_SIZE                                 0x0DF1
+#define GL_FEEDBACK_BUFFER_TYPE                                 0x0DF2
+#define GL_SELECTION_BUFFER_POINTER                             0x0DF3
+#define GL_SELECTION_BUFFER_SIZE                                0x0DF4
+#define GL_TEXTURE_WIDTH                                        0x1000
+#define GL_TEXTURE_HEIGHT                                       0x1001
+#define GL_TEXTURE_INTERNAL_FORMAT                              0x1003
+#define GL_TEXTURE_BORDER_COLOR                                 0x1004
+#define GL_TEXTURE_BORDER                                       0x1005
+#define GL_DONT_CARE                                            0x1100
+#define GL_FASTEST                                              0x1101
+#define GL_NICEST                                               0x1102
+#define GL_LIGHT0                                               0x4000
+#define GL_LIGHT1                                               0x4001
+#define GL_LIGHT2                                               0x4002
+#define GL_LIGHT3                                               0x4003
+#define GL_LIGHT4                                               0x4004
+#define GL_LIGHT5                                               0x4005
+#define GL_LIGHT6                                               0x4006
+#define GL_LIGHT7                                               0x4007
+#define GL_AMBIENT                                              0x1200
+#define GL_DIFFUSE                                              0x1201
+#define GL_SPECULAR                                             0x1202
+#define GL_POSITION                                             0x1203
+#define GL_SPOT_DIRECTION                                       0x1204
+#define GL_SPOT_EXPONENT                                        0x1205
+#define GL_SPOT_CUTOFF                                          0x1206
+#define GL_CONSTANT_ATTENUATION                                 0x1207
+#define GL_LINEAR_ATTENUATION                                   0x1208
+#define GL_QUADRATIC_ATTENUATION                                0x1209
+#define GL_COMPILE                                              0x1300
+#define GL_COMPILE_AND_EXECUTE                                  0x1301
+#define GL_CLEAR                                                0x1500
+#define GL_AND                                                  0x1501
+#define GL_AND_REVERSE                                          0x1502
+#define GL_COPY                                                 0x1503
+#define GL_AND_INVERTED                                         0x1504
+#define GL_NOOP                                                 0x1505
+#define GL_XOR                                                  0x1506
+#define GL_OR                                                   0x1507
+#define GL_NOR                                                  0x1508
+#define GL_EQUIV                                                0x1509
+#define GL_INVERT                                               0x150A
+#define GL_OR_REVERSE                                           0x150B
+#define GL_COPY_INVERTED                                        0x150C
+#define GL_OR_INVERTED                                          0x150D
+#define GL_NAND                                                 0x150E
+#define GL_SET                                                  0x150F
+#define GL_EMISSION                                             0x1600
+#define GL_SHININESS                                            0x1601
+#define GL_AMBIENT_AND_DIFFUSE                                  0x1602
+#define GL_COLOR_INDEXES                                        0x1603
+#define GL_MODELVIEW                                            0x1700
+#define GL_PROJECTION                                           0x1701
+#define GL_TEXTURE                                              0x1702
+#define GL_COLOR                                                0x1800
+#define GL_DEPTH                                                0x1801
+#define GL_STENCIL                                              0x1802
+#define GL_COLOR_INDEX                                          0x1900
+#define GL_STENCIL_INDEX                                        0x1901
+#define GL_DEPTH_COMPONENT                                      0x1902
+#define GL_RED                                                  0x1903
+#define GL_GREEN                                                0x1904
+#define GL_BLUE                                                 0x1905
+#define GL_ALPHA                                                0x1906
+#define GL_RGB                                                  0x1907
+#define GL_RGBA                                                 0x1908
+#define GL_LUMINANCE                                            0x1909
+#define GL_LUMINANCE_ALPHA                                      0x190A
+#define GL_BITMAP                                               0x1A00
+#define GL_POINT                                                0x1B00
+#define GL_LINE                                                 0x1B01
+#define GL_FILL                                                 0x1B02
+#define GL_RENDER                                               0x1C00
+#define GL_FEEDBACK                                             0x1C01
+#define GL_SELECT                                               0x1C02
+#define GL_FLAT                                                 0x1D00
+#define GL_SMOOTH                                               0x1D01
+#define GL_KEEP                                                 0x1E00
+#define GL_REPLACE                                              0x1E01
+#define GL_INCR                                                 0x1E02
+#define GL_DECR                                                 0x1E03
+#define GL_VENDOR                                               0x1F00
+#define GL_RENDERER                                             0x1F01
+#define GL_VERSION                                              0x1F02
+#define GL_EXTENSIONS                                           0x1F03
+#define GL_S                                                    0x2000
+#define GL_T                                                    0x2001
+#define GL_R                                                    0x2002
+#define GL_Q                                                    0x2003
+#define GL_MODULATE                                             0x2100
+#define GL_DECAL                                                0x2101
+#define GL_TEXTURE_ENV_MODE                                     0x2200
+#define GL_TEXTURE_ENV_COLOR                                    0x2201
+#define GL_TEXTURE_ENV                                          0x2300
+#define GL_EYE_LINEAR                                           0x2400
+#define GL_OBJECT_LINEAR                                        0x2401
+#define GL_SPHERE_MAP                                           0x2402
+#define GL_TEXTURE_GEN_MODE                                     0x2500
+#define GL_OBJECT_PLANE                                         0x2501
+#define GL_EYE_PLANE                                            0x2502
+#define GL_NEAREST                                              0x2600
+#define GL_LINEAR                                               0x2601
+#define GL_NEAREST_MIPMAP_NEAREST                               0x2700
+#define GL_LINEAR_MIPMAP_NEAREST                                0x2701
+#define GL_NEAREST_MIPMAP_LINEAR                                0x2702
+#define GL_LINEAR_MIPMAP_LINEAR                                 0x2703
+#define GL_TEXTURE_MAG_FILTER                                   0x2800
+#define GL_TEXTURE_MIN_FILTER                                   0x2801
+#define GL_TEXTURE_WRAP_S                                       0x2802
+#define GL_TEXTURE_WRAP_T                                       0x2803
+#define GL_CLAMP                                                0x2900
+#define GL_REPEAT                                               0x2901
+#define GL_CLIENT_PIXEL_STORE_BIT                               0x00000001
+#define GL_CLIENT_VERTEX_ARRAY_BIT                              0x00000002
+#define GL_CLIENT_ALL_ATTRIB_BITS                               0xffffffff
+#define GL_POLYGON_OFFSET_FACTOR                                0x8038
+#define GL_POLYGON_OFFSET_UNITS                                 0x2A00
+#define GL_POLYGON_OFFSET_POINT                                 0x2A01
+#define GL_POLYGON_OFFSET_LINE                                  0x2A02
+#define GL_POLYGON_OFFSET_FILL                                  0x8037
+#define GL_ALPHA4                                               0x803B
+#define GL_ALPHA8                                               0x803C
+#define GL_ALPHA12                                              0x803D
+#define GL_ALPHA16                                              0x803E
+#define GL_LUMINANCE4                                           0x803F
+#define GL_LUMINANCE8                                           0x8040
+#define GL_LUMINANCE12                                          0x8041
+#define GL_LUMINANCE16                                          0x8042
+#define GL_LUMINANCE4_ALPHA4                                    0x8043
+#define GL_LUMINANCE6_ALPHA2                                    0x8044
+#define GL_LUMINANCE8_ALPHA8                                    0x8045
+#define GL_LUMINANCE12_ALPHA4                                   0x8046
+#define GL_LUMINANCE12_ALPHA12                                  0x8047
+#define GL_LUMINANCE16_ALPHA16                                  0x8048
+#define GL_INTENSITY                                            0x8049
+#define GL_INTENSITY4                                           0x804A
+#define GL_INTENSITY8                                           0x804B
+#define GL_INTENSITY12                                          0x804C
+#define GL_INTENSITY16                                          0x804D
+#define GL_R3_G3_B2                                             0x2A10
+#define GL_RGB4                                                 0x804F
+#define GL_RGB5                                                 0x8050
+#define GL_RGB8                                                 0x8051
+#define GL_RGB10                                                0x8052
+#define GL_RGB12                                                0x8053
+#define GL_RGB16                                                0x8054
+#define GL_RGBA2                                                0x8055
+#define GL_RGBA4                                                0x8056
+#define GL_RGB5_A1                                              0x8057
+#define GL_RGBA8                                                0x8058
+#define GL_RGB10_A2                                             0x8059
+#define GL_RGBA12                                               0x805A
+#define GL_RGBA16                                               0x805B
+#define GL_TEXTURE_RED_SIZE                                     0x805C
+#define GL_TEXTURE_GREEN_SIZE                                   0x805D
+#define GL_TEXTURE_BLUE_SIZE                                    0x805E
+#define GL_TEXTURE_ALPHA_SIZE                                   0x805F
+#define GL_TEXTURE_LUMINANCE_SIZE                               0x8060
+#define GL_TEXTURE_INTENSITY_SIZE                               0x8061
+#define GL_PROXY_TEXTURE_1D                                     0x8063
+#define GL_PROXY_TEXTURE_2D                                     0x8064
+#define GL_TEXTURE_PRIORITY                                     0x8066
+#define GL_TEXTURE_RESIDENT                                     0x8067
+#define GL_TEXTURE_BINDING_1D                                   0x8068
+#define GL_TEXTURE_BINDING_2D                                   0x8069
+#define GL_VERTEX_ARRAY                                         0x8074
+#define GL_NORMAL_ARRAY                                         0x8075
+#define GL_COLOR_ARRAY                                          0x8076
+#define GL_INDEX_ARRAY                                          0x8077
+#define GL_TEXTURE_COORD_ARRAY                                  0x8078
+#define GL_EDGE_FLAG_ARRAY                                      0x8079
+#define GL_VERTEX_ARRAY_SIZE                                    0x807A
+#define GL_VERTEX_ARRAY_TYPE                                    0x807B
+#define GL_VERTEX_ARRAY_STRIDE                                  0x807C
+#define GL_NORMAL_ARRAY_TYPE                                    0x807E
+#define GL_NORMAL_ARRAY_STRIDE                                  0x807F
+#define GL_COLOR_ARRAY_SIZE                                     0x8081
+#define GL_COLOR_ARRAY_TYPE                                     0x8082
+#define GL_COLOR_ARRAY_STRIDE                                   0x8083
+#define GL_INDEX_ARRAY_TYPE                                     0x8085
+#define GL_INDEX_ARRAY_STRIDE                                   0x8086
+#define GL_TEXTURE_COORD_ARRAY_SIZE                             0x8088
+#define GL_TEXTURE_COORD_ARRAY_TYPE                             0x8089
+#define GL_TEXTURE_COORD_ARRAY_STRIDE                           0x808A
+#define GL_EDGE_FLAG_ARRAY_STRIDE                               0x808C
+#define GL_VERTEX_ARRAY_POINTER                                 0x808E
+#define GL_NORMAL_ARRAY_POINTER                                 0x808F
+#define GL_COLOR_ARRAY_POINTER                                  0x8090
+#define GL_INDEX_ARRAY_POINTER                                  0x8091
+#define GL_TEXTURE_COORD_ARRAY_POINTER                          0x8092
+#define GL_EDGE_FLAG_ARRAY_POINTER                              0x8093
+#define GL_V2F                                                  0x2A20
+#define GL_V3F                                                  0x2A21
+#define GL_C4UB_V2F                                             0x2A22
+#define GL_C4UB_V3F                                             0x2A23
+#define GL_C3F_V3F                                              0x2A24
+#define GL_N3F_V3F                                              0x2A25
+#define GL_C4F_N3F_V3F                                          0x2A26
+#define GL_T2F_V3F                                              0x2A27
+#define GL_T4F_V4F                                              0x2A28
+#define GL_T2F_C4UB_V3F                                         0x2A29
+#define GL_T2F_C3F_V3F                                          0x2A2A
+#define GL_T2F_N3F_V3F                                          0x2A2B
+#define GL_T2F_C4F_N3F_V3F                                      0x2A2C
+#define GL_T4F_C4F_N3F_V4F                                      0x2A2D
+#define GL_LOGIC_OP GL_INDEX_LOGIC_OP
+#define GL_TEXTURE_COMPONENTS GL_TEXTURE_INTERNAL_FORMAT
+#define GL_COLOR_INDEX1_EXT                                     0x80E2
+#define GL_COLOR_INDEX2_EXT                                     0x80E3
+#define GL_COLOR_INDEX4_EXT                                     0x80E4
+#define GL_COLOR_INDEX8_EXT                                     0x80E5
+#define GL_COLOR_INDEX12_EXT                                    0x80E6
+#define GL_COLOR_INDEX16_EXT                                    0x80E7
+
+extern void APIENTRY glAccum (GLenum op, GLfloat value);
+extern void APIENTRY glAlphaFunc (GLenum func, GLclampf ref);
+extern GLboolean APIENTRY glAreTexturesResident (GLsizei n, const GLuint *textures, GLboolean *residences);
+extern void APIENTRY glArrayElement (GLint i);
+extern void APIENTRY glBegin (GLenum mode);
+extern void APIENTRY glBindTexture (GLenum target, GLuint texture);
+extern void APIENTRY glBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+extern void APIENTRY glBlendFunc (GLenum sfactor, GLenum dfactor);
+extern void APIENTRY glCallList (GLuint list);
+extern void APIENTRY glCallLists (GLsizei n, GLenum type, const GLvoid *lists);
+extern void APIENTRY glClear (GLbitfield mask);
+extern void APIENTRY glClearAccum (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+extern void APIENTRY glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+extern void APIENTRY glClearDepth (GLclampd depth);
+extern void APIENTRY glClearIndex (GLfloat c);
+extern void APIENTRY glClearStencil (GLint s);
+extern void APIENTRY glClipPlane (GLenum plane, const GLdouble *equation);
+extern void APIENTRY glColor3b (GLbyte red, GLbyte green, GLbyte blue);
+extern void APIENTRY glColor3bv (const GLbyte *v);
+extern void APIENTRY glColor3d (GLdouble red, GLdouble green, GLdouble blue);
+extern void APIENTRY glColor3dv (const GLdouble *v);
+extern void APIENTRY glColor3f (GLfloat red, GLfloat green, GLfloat blue);
+extern void APIENTRY glColor3fv (const GLfloat *v);
+extern void APIENTRY glColor3i (GLint red, GLint green, GLint blue);
+extern void APIENTRY glColor3iv (const GLint *v);
+extern void APIENTRY glColor3s (GLshort red, GLshort green, GLshort blue);
+extern void APIENTRY glColor3sv (const GLshort *v);
+extern void APIENTRY glColor3ub (GLubyte red, GLubyte green, GLubyte blue);
+extern void APIENTRY glColor3ubv (const GLubyte *v);
+extern void APIENTRY glColor3ui (GLuint red, GLuint green, GLuint blue);
+extern void APIENTRY glColor3uiv (const GLuint *v);
+extern void APIENTRY glColor3us (GLushort red, GLushort green, GLushort blue);
+extern void APIENTRY glColor3usv (const GLushort *v);
+extern void APIENTRY glColor4b (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+extern void APIENTRY glColor4bv (const GLbyte *v);
+extern void APIENTRY glColor4d (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+extern void APIENTRY glColor4dv (const GLdouble *v);
+extern void APIENTRY glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+extern void APIENTRY glColor4fv (const GLfloat *v);
+extern void APIENTRY glColor4i (GLint red, GLint green, GLint blue, GLint alpha);
+extern void APIENTRY glColor4iv (const GLint *v);
+extern void APIENTRY glColor4s (GLshort red, GLshort green, GLshort blue, GLshort alpha);
+extern void APIENTRY glColor4sv (const GLshort *v);
+extern void APIENTRY glColor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+extern void APIENTRY glColor4ubv (const GLubyte *v);
+extern void APIENTRY glColor4ui (GLuint red, GLuint green, GLuint blue, GLuint alpha);
+extern void APIENTRY glColor4uiv (const GLuint *v);
+extern void APIENTRY glColor4us (GLushort red, GLushort green, GLushort blue, GLushort alpha);
+extern void APIENTRY glColor4usv (const GLushort *v);
+extern void APIENTRY glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+extern void APIENTRY glColorMaterial (GLenum face, GLenum mode);
+extern void APIENTRY glColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+extern void APIENTRY glCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+extern void APIENTRY glCopyTexImage1D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
+extern void APIENTRY glCopyTexImage2D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+extern void APIENTRY glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+extern void APIENTRY glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+extern void APIENTRY glCullFace (GLenum mode);
+extern void APIENTRY glDeleteLists (GLuint list, GLsizei range);
+extern void APIENTRY glDeleteTextures (GLsizei n, const GLuint *textures);
+extern void APIENTRY glDepthFunc (GLenum func);
+extern void APIENTRY glDepthMask (GLboolean flag);
+extern void APIENTRY glDepthRange (GLclampd zNear, GLclampd zFar);
+extern void APIENTRY glDisable (GLenum cap);
+extern void APIENTRY glDisableClientState (GLenum array);
+extern void APIENTRY glDrawArrays (GLenum mode, GLint first, GLsizei count);
+extern void APIENTRY glDrawBuffer (GLenum mode);
+extern void APIENTRY glDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+extern void APIENTRY glDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+extern void APIENTRY glEdgeFlag (GLboolean flag);
+extern void APIENTRY glEdgeFlagPointer (GLsizei stride, const GLvoid *pointer);
+extern void APIENTRY glEdgeFlagv (const GLboolean *flag);
+extern void APIENTRY glEnable (GLenum cap);
+extern void APIENTRY glEnableClientState (GLenum array);
+extern void APIENTRY glEnd (void);
+extern void APIENTRY glEndList (void);
+extern void APIENTRY glEvalCoord1d (GLdouble u);
+extern void APIENTRY glEvalCoord1dv (const GLdouble *u);
+extern void APIENTRY glEvalCoord1f (GLfloat u);
+extern void APIENTRY glEvalCoord1fv (const GLfloat *u);
+extern void APIENTRY glEvalCoord2d (GLdouble u, GLdouble v);
+extern void APIENTRY glEvalCoord2dv (const GLdouble *u);
+extern void APIENTRY glEvalCoord2f (GLfloat u, GLfloat v);
+extern void APIENTRY glEvalCoord2fv (const GLfloat *u);
+extern void APIENTRY glEvalMesh1 (GLenum mode, GLint i1, GLint i2);
+extern void APIENTRY glEvalMesh2 (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+extern void APIENTRY glEvalPoint1 (GLint i);
+extern void APIENTRY glEvalPoint2 (GLint i, GLint j);
+extern void APIENTRY glFeedbackBuffer (GLsizei size, GLenum type, GLfloat *buffer);
+extern void APIENTRY glFinish (void);
+extern void APIENTRY glFlush (void);
+extern void APIENTRY glFogf (GLenum pname, GLfloat param);
+extern void APIENTRY glFogfv (GLenum pname, const GLfloat *params);
+extern void APIENTRY glFogi (GLenum pname, GLint param);
+extern void APIENTRY glFogiv (GLenum pname, const GLint *params);
+extern void APIENTRY glFrontFace (GLenum mode);
+extern void APIENTRY glFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+extern GLuint APIENTRY glGenLists (GLsizei range);
+extern void APIENTRY glGenTextures (GLsizei n, GLuint *textures);
+extern void APIENTRY glGetBooleanv (GLenum pname, GLboolean *params);
+extern void APIENTRY glGetClipPlane (GLenum plane, GLdouble *equation);
+extern void APIENTRY glGetDoublev (GLenum pname, GLdouble *params);
+extern GLenum APIENTRY glGetError (void);
+extern void APIENTRY glGetFloatv (GLenum pname, GLfloat *params);
+extern void APIENTRY glGetIntegerv (GLenum pname, GLint *params);
+extern void APIENTRY glGetLightfv (GLenum light, GLenum pname, GLfloat *params);
+extern void APIENTRY glGetLightiv (GLenum light, GLenum pname, GLint *params);
+extern void APIENTRY glGetMapdv (GLenum target, GLenum query, GLdouble *v);
+extern void APIENTRY glGetMapfv (GLenum target, GLenum query, GLfloat *v);
+extern void APIENTRY glGetMapiv (GLenum target, GLenum query, GLint *v);
+extern void APIENTRY glGetMaterialfv (GLenum face, GLenum pname, GLfloat *params);
+extern void APIENTRY glGetMaterialiv (GLenum face, GLenum pname, GLint *params);
+extern void APIENTRY glGetPixelMapfv (GLenum map, GLfloat *values);
+extern void APIENTRY glGetPixelMapuiv (GLenum map, GLuint *values);
+extern void APIENTRY glGetPixelMapusv (GLenum map, GLushort *values);
+extern void APIENTRY glGetPointerv (GLenum pname, GLvoid* *params);
+extern void APIENTRY glGetPolygonStipple (GLubyte *mask);
+extern const GLubyte * APIENTRY glGetString (GLenum name);
+extern void APIENTRY glGetTexEnvfv (GLenum target, GLenum pname, GLfloat *params);
+extern void APIENTRY glGetTexEnviv (GLenum target, GLenum pname, GLint *params);
+extern void APIENTRY glGetTexGendv (GLenum coord, GLenum pname, GLdouble *params);
+extern void APIENTRY glGetTexGenfv (GLenum coord, GLenum pname, GLfloat *params);
+extern void APIENTRY glGetTexGeniv (GLenum coord, GLenum pname, GLint *params);
+extern void APIENTRY glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+extern void APIENTRY glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params);
+extern void APIENTRY glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params);
+extern void APIENTRY glGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params);
+extern void APIENTRY glGetTexParameteriv (GLenum target, GLenum pname, GLint *params);
+extern void APIENTRY glHint (GLenum target, GLenum mode);
+extern void APIENTRY glIndexMask (GLuint mask);
+extern void APIENTRY glIndexPointer (GLenum type, GLsizei stride, const GLvoid *pointer);
+extern void APIENTRY glIndexd (GLdouble c);
+extern void APIENTRY glIndexdv (const GLdouble *c);
+extern void APIENTRY glIndexf (GLfloat c);
+extern void APIENTRY glIndexfv (const GLfloat *c);
+extern void APIENTRY glIndexi (GLint c);
+extern void APIENTRY glIndexiv (const GLint *c);
+extern void APIENTRY glIndexs (GLshort c);
+extern void APIENTRY glIndexsv (const GLshort *c);
+extern void APIENTRY glIndexub (GLubyte c);
+extern void APIENTRY glIndexubv (const GLubyte *c);
+extern void APIENTRY glInitNames (void);
+extern void APIENTRY glInterleavedArrays (GLenum format, GLsizei stride, const GLvoid *pointer);
+extern GLboolean APIENTRY glIsEnabled (GLenum cap);
+extern GLboolean APIENTRY glIsList (GLuint list);
+extern GLboolean APIENTRY glIsTexture (GLuint texture);
+extern void APIENTRY glLightModelf (GLenum pname, GLfloat param);
+extern void APIENTRY glLightModelfv (GLenum pname, const GLfloat *params);
+extern void APIENTRY glLightModeli (GLenum pname, GLint param);
+extern void APIENTRY glLightModeliv (GLenum pname, const GLint *params);
+extern void APIENTRY glLightf (GLenum light, GLenum pname, GLfloat param);
+extern void APIENTRY glLightfv (GLenum light, GLenum pname, const GLfloat *params);
+extern void APIENTRY glLighti (GLenum light, GLenum pname, GLint param);
+extern void APIENTRY glLightiv (GLenum light, GLenum pname, const GLint *params);
+extern void APIENTRY glLineStipple (GLint factor, GLushort pattern);
+extern void APIENTRY glLineWidth (GLfloat width);
+extern void APIENTRY glListBase (GLuint base);
+extern void APIENTRY glLoadIdentity (void);
+extern void APIENTRY glLoadMatrixd (const GLdouble *m);
+extern void APIENTRY glLoadMatrixf (const GLfloat *m);
+extern void APIENTRY glLoadName (GLuint name);
+extern void APIENTRY glLogicOp (GLenum opcode);
+extern void APIENTRY glMap1d (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+extern void APIENTRY glMap1f (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+extern void APIENTRY glMap2d (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+extern void APIENTRY glMap2f (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+extern void APIENTRY glMapGrid1d (GLint un, GLdouble u1, GLdouble u2);
+extern void APIENTRY glMapGrid1f (GLint un, GLfloat u1, GLfloat u2);
+extern void APIENTRY glMapGrid2d (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+extern void APIENTRY glMapGrid2f (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+extern void APIENTRY glMaterialf (GLenum face, GLenum pname, GLfloat param);
+extern void APIENTRY glMaterialfv (GLenum face, GLenum pname, const GLfloat *params);
+extern void APIENTRY glMateriali (GLenum face, GLenum pname, GLint param);
+extern void APIENTRY glMaterialiv (GLenum face, GLenum pname, const GLint *params);
+extern void APIENTRY glMatrixMode (GLenum mode);
+extern void APIENTRY glMultMatrixd (const GLdouble *m);
+extern void APIENTRY glMultMatrixf (const GLfloat *m);
+extern void APIENTRY glNewList (GLuint list, GLenum mode);
+extern void APIENTRY glNormal3b (GLbyte nx, GLbyte ny, GLbyte nz);
+extern void APIENTRY glNormal3bv (const GLbyte *v);
+extern void APIENTRY glNormal3d (GLdouble nx, GLdouble ny, GLdouble nz);
+extern void APIENTRY glNormal3dv (const GLdouble *v);
+extern void APIENTRY glNormal3f (GLfloat nx, GLfloat ny, GLfloat nz);
+extern void APIENTRY glNormal3fv (const GLfloat *v);
+extern void APIENTRY glNormal3i (GLint nx, GLint ny, GLint nz);
+extern void APIENTRY glNormal3iv (const GLint *v);
+extern void APIENTRY glNormal3s (GLshort nx, GLshort ny, GLshort nz);
+extern void APIENTRY glNormal3sv (const GLshort *v);
+extern void APIENTRY glNormalPointer (GLenum type, GLsizei stride, const GLvoid *pointer);
+extern void APIENTRY glOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+extern void APIENTRY glPassThrough (GLfloat token);
+extern void APIENTRY glPixelMapfv (GLenum map, GLsizei mapsize, const GLfloat *values);
+extern void APIENTRY glPixelMapuiv (GLenum map, GLsizei mapsize, const GLuint *values);
+extern void APIENTRY glPixelMapusv (GLenum map, GLsizei mapsize, const GLushort *values);
+extern void APIENTRY glPixelStoref (GLenum pname, GLfloat param);
+extern void APIENTRY glPixelStorei (GLenum pname, GLint param);
+extern void APIENTRY glPixelTransferf (GLenum pname, GLfloat param);
+extern void APIENTRY glPixelTransferi (GLenum pname, GLint param);
+extern void APIENTRY glPixelZoom (GLfloat xfactor, GLfloat yfactor);
+extern void APIENTRY glPointSize (GLfloat size);
+extern void APIENTRY glPolygonMode (GLenum face, GLenum mode);
+extern void APIENTRY glPolygonOffset (GLfloat factor, GLfloat units);
+extern void APIENTRY glPolygonStipple (const GLubyte *mask);
+extern void APIENTRY glPopAttrib (void);
+extern void APIENTRY glPopClientAttrib (void);
+extern void APIENTRY glPopMatrix (void);
+extern void APIENTRY glPopName (void);
+extern void APIENTRY glPrioritizeTextures (GLsizei n, const GLuint *textures, const GLclampf *priorities);
+extern void APIENTRY glPushAttrib (GLbitfield mask);
+extern void APIENTRY glPushClientAttrib (GLbitfield mask);
+extern void APIENTRY glPushMatrix (void);
+extern void APIENTRY glPushName (GLuint name);
+extern void APIENTRY glRasterPos2d (GLdouble x, GLdouble y);
+extern void APIENTRY glRasterPos2dv (const GLdouble *v);
+extern void APIENTRY glRasterPos2f (GLfloat x, GLfloat y);
+extern void APIENTRY glRasterPos2fv (const GLfloat *v);
+extern void APIENTRY glRasterPos2i (GLint x, GLint y);
+extern void APIENTRY glRasterPos2iv (const GLint *v);
+extern void APIENTRY glRasterPos2s (GLshort x, GLshort y);
+extern void APIENTRY glRasterPos2sv (const GLshort *v);
+extern void APIENTRY glRasterPos3d (GLdouble x, GLdouble y, GLdouble z);
+extern void APIENTRY glRasterPos3dv (const GLdouble *v);
+extern void APIENTRY glRasterPos3f (GLfloat x, GLfloat y, GLfloat z);
+extern void APIENTRY glRasterPos3fv (const GLfloat *v);
+extern void APIENTRY glRasterPos3i (GLint x, GLint y, GLint z);
+extern void APIENTRY glRasterPos3iv (const GLint *v);
+extern void APIENTRY glRasterPos3s (GLshort x, GLshort y, GLshort z);
+extern void APIENTRY glRasterPos3sv (const GLshort *v);
+extern void APIENTRY glRasterPos4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern void APIENTRY glRasterPos4dv (const GLdouble *v);
+extern void APIENTRY glRasterPos4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern void APIENTRY glRasterPos4fv (const GLfloat *v);
+extern void APIENTRY glRasterPos4i (GLint x, GLint y, GLint z, GLint w);
+extern void APIENTRY glRasterPos4iv (const GLint *v);
+extern void APIENTRY glRasterPos4s (GLshort x, GLshort y, GLshort z, GLshort w);
+extern void APIENTRY glRasterPos4sv (const GLshort *v);
+extern void APIENTRY glReadBuffer (GLenum mode);
+extern void APIENTRY glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
+extern void APIENTRY glRectd (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+extern void APIENTRY glRectdv (const GLdouble *v1, const GLdouble *v2);
+extern void APIENTRY glRectf (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+extern void APIENTRY glRectfv (const GLfloat *v1, const GLfloat *v2);
+extern void APIENTRY glRecti (GLint x1, GLint y1, GLint x2, GLint y2);
+extern void APIENTRY glRectiv (const GLint *v1, const GLint *v2);
+extern void APIENTRY glRects (GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+extern void APIENTRY glRectsv (const GLshort *v1, const GLshort *v2);
+extern GLint APIENTRY glRenderMode (GLenum mode);
+extern void APIENTRY glRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+extern void APIENTRY glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+extern void APIENTRY glScaled (GLdouble x, GLdouble y, GLdouble z);
+extern void APIENTRY glScalef (GLfloat x, GLfloat y, GLfloat z);
+extern void APIENTRY glScissor (GLint x, GLint y, GLsizei width, GLsizei height);
+extern void APIENTRY glSelectBuffer (GLsizei size, GLuint *buffer);
+extern void APIENTRY glShadeModel (GLenum mode);
+extern void APIENTRY glStencilFunc (GLenum func, GLint ref, GLuint mask);
+extern void APIENTRY glStencilMask (GLuint mask);
+extern void APIENTRY glStencilOp (GLenum fail, GLenum zfail, GLenum zpass);
+extern void APIENTRY glTexCoord1d (GLdouble s);
+extern void APIENTRY glTexCoord1dv (const GLdouble *v);
+extern void APIENTRY glTexCoord1f (GLfloat s);
+extern void APIENTRY glTexCoord1fv (const GLfloat *v);
+extern void APIENTRY glTexCoord1i (GLint s);
+extern void APIENTRY glTexCoord1iv (const GLint *v);
+extern void APIENTRY glTexCoord1s (GLshort s);
+extern void APIENTRY glTexCoord1sv (const GLshort *v);
+extern void APIENTRY glTexCoord2d (GLdouble s, GLdouble t);
+extern void APIENTRY glTexCoord2dv (const GLdouble *v);
+extern void APIENTRY glTexCoord2f (GLfloat s, GLfloat t);
+extern void APIENTRY glTexCoord2fv (const GLfloat *v);
+extern void APIENTRY glTexCoord2i (GLint s, GLint t);
+extern void APIENTRY glTexCoord2iv (const GLint *v);
+extern void APIENTRY glTexCoord2s (GLshort s, GLshort t);
+extern void APIENTRY glTexCoord2sv (const GLshort *v);
+extern void APIENTRY glTexCoord3d (GLdouble s, GLdouble t, GLdouble r);
+extern void APIENTRY glTexCoord3dv (const GLdouble *v);
+extern void APIENTRY glTexCoord3f (GLfloat s, GLfloat t, GLfloat r);
+extern void APIENTRY glTexCoord3fv (const GLfloat *v);
+extern void APIENTRY glTexCoord3i (GLint s, GLint t, GLint r);
+extern void APIENTRY glTexCoord3iv (const GLint *v);
+extern void APIENTRY glTexCoord3s (GLshort s, GLshort t, GLshort r);
+extern void APIENTRY glTexCoord3sv (const GLshort *v);
+extern void APIENTRY glTexCoord4d (GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+extern void APIENTRY glTexCoord4dv (const GLdouble *v);
+extern void APIENTRY glTexCoord4f (GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+extern void APIENTRY glTexCoord4fv (const GLfloat *v);
+extern void APIENTRY glTexCoord4i (GLint s, GLint t, GLint r, GLint q);
+extern void APIENTRY glTexCoord4iv (const GLint *v);
+extern void APIENTRY glTexCoord4s (GLshort s, GLshort t, GLshort r, GLshort q);
+extern void APIENTRY glTexCoord4sv (const GLshort *v);
+extern void APIENTRY glTexCoordPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+extern void APIENTRY glTexEnvf (GLenum target, GLenum pname, GLfloat param);
+extern void APIENTRY glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params);
+extern void APIENTRY glTexEnvi (GLenum target, GLenum pname, GLint param);
+extern void APIENTRY glTexEnviv (GLenum target, GLenum pname, const GLint *params);
+extern void APIENTRY glTexGend (GLenum coord, GLenum pname, GLdouble param);
+extern void APIENTRY glTexGendv (GLenum coord, GLenum pname, const GLdouble *params);
+extern void APIENTRY glTexGenf (GLenum coord, GLenum pname, GLfloat param);
+extern void APIENTRY glTexGenfv (GLenum coord, GLenum pname, const GLfloat *params);
+extern void APIENTRY glTexGeni (GLenum coord, GLenum pname, GLint param);
+extern void APIENTRY glTexGeniv (GLenum coord, GLenum pname, const GLint *params);
+extern void APIENTRY glTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+extern void APIENTRY glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+extern void APIENTRY glTexParameterf (GLenum target, GLenum pname, GLfloat param);
+extern void APIENTRY glTexParameterfv (GLenum target, GLenum pname, const GLfloat *params);
+extern void APIENTRY glTexParameteri (GLenum target, GLenum pname, GLint param);
+extern void APIENTRY glTexParameteriv (GLenum target, GLenum pname, const GLint *params);
+extern void APIENTRY glTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+extern void APIENTRY glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+extern void APIENTRY glTranslated (GLdouble x, GLdouble y, GLdouble z);
+extern void APIENTRY glTranslatef (GLfloat x, GLfloat y, GLfloat z);
+extern void APIENTRY glVertex2d (GLdouble x, GLdouble y);
+extern void APIENTRY glVertex2dv (const GLdouble *v);
+extern void APIENTRY glVertex2f (GLfloat x, GLfloat y);
+extern void APIENTRY glVertex2fv (const GLfloat *v);
+extern void APIENTRY glVertex2i (GLint x, GLint y);
+extern void APIENTRY glVertex2iv (const GLint *v);
+extern void APIENTRY glVertex2s (GLshort x, GLshort y);
+extern void APIENTRY glVertex2sv (const GLshort *v);
+extern void APIENTRY glVertex3d (GLdouble x, GLdouble y, GLdouble z);
+extern void APIENTRY glVertex3dv (const GLdouble *v);
+extern void APIENTRY glVertex3f (GLfloat x, GLfloat y, GLfloat z);
+extern void APIENTRY glVertex3fv (const GLfloat *v);
+extern void APIENTRY glVertex3i (GLint x, GLint y, GLint z);
+extern void APIENTRY glVertex3iv (const GLint *v);
+extern void APIENTRY glVertex3s (GLshort x, GLshort y, GLshort z);
+extern void APIENTRY glVertex3sv (const GLshort *v);
+extern void APIENTRY glVertex4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern void APIENTRY glVertex4dv (const GLdouble *v);
+extern void APIENTRY glVertex4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern void APIENTRY glVertex4fv (const GLfloat *v);
+extern void APIENTRY glVertex4i (GLint x, GLint y, GLint z, GLint w);
+extern void APIENTRY glVertex4iv (const GLint *v);
+extern void APIENTRY glVertex4s (GLshort x, GLshort y, GLshort z, GLshort w);
+extern void APIENTRY glVertex4sv (const GLshort *v);
+extern void APIENTRY glVertexPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+extern void APIENTRY glViewport (GLint x, GLint y, GLsizei width, GLsizei height);
+
+#endif /* GL_VERSION_1_1 */
+
+/* this is where we can safely include GLU */
+#include 
+
+/* ------------------------------ OpenGL 1.2 ------------------------------ */
+
+#ifdef GL_VERSION_1_2
+
+#define GL_UNSIGNED_BYTE_3_3_2                                  0x8032
+#define GL_UNSIGNED_SHORT_4_4_4_4                               0x8033
+#define GL_UNSIGNED_SHORT_5_5_5_1                               0x8034
+#define GL_UNSIGNED_INT_8_8_8_8                                 0x8035
+#define GL_UNSIGNED_INT_10_10_10_2                              0x8036
+#define GL_RESCALE_NORMAL                                       0x803A
+#define GL_UNSIGNED_BYTE_2_3_3_REV                              0x8362
+#define GL_UNSIGNED_SHORT_5_6_5                                 0x8363
+#define GL_UNSIGNED_SHORT_5_6_5_REV                             0x8364
+#define GL_UNSIGNED_SHORT_4_4_4_4_REV                           0x8365
+#define GL_UNSIGNED_SHORT_1_5_5_5_REV                           0x8366
+#define GL_UNSIGNED_INT_8_8_8_8_REV                             0x8367
+#define GL_UNSIGNED_INT_2_10_10_10_REV                          0x8368
+#define GL_BGR                                                  0x80E0
+#define GL_BGRA                                                 0x80E1
+#define GL_MAX_ELEMENTS_VERTICES                                0x80E8
+#define GL_MAX_ELEMENTS_INDICES                                 0x80E9
+#define GL_CLAMP_TO_EDGE                                        0x812F
+#define GL_TEXTURE_MIN_LOD                                      0x813A
+#define GL_TEXTURE_MAX_LOD                                      0x813B
+#define GL_TEXTURE_BASE_LEVEL                                   0x813C
+#define GL_TEXTURE_MAX_LEVEL                                    0x813D
+#define GL_LIGHT_MODEL_COLOR_CONTROL                            0x81F8
+#define GL_SINGLE_COLOR                                         0x81F9
+#define GL_SEPARATE_SPECULAR_COLOR                              0x81FA
+#define GL_SMOOTH_POINT_SIZE_RANGE                              0x0B12
+#define GL_SMOOTH_POINT_SIZE_GRANULARITY                        0x0B13
+#define GL_SMOOTH_LINE_WIDTH_RANGE                              0x0B22
+#define GL_SMOOTH_LINE_WIDTH_GRANULARITY                        0x0B23
+#define GL_ALIASED_POINT_SIZE_RANGE                             0x846D
+#define GL_ALIASED_LINE_WIDTH_RANGE                             0x846E
+#define GL_PACK_SKIP_IMAGES                                     0x806B
+#define GL_PACK_IMAGE_HEIGHT                                    0x806C
+#define GL_UNPACK_SKIP_IMAGES                                   0x806D
+#define GL_UNPACK_IMAGE_HEIGHT                                  0x806E
+#define GL_TEXTURE_3D                                           0x806F
+#define GL_PROXY_TEXTURE_3D                                     0x8070
+#define GL_TEXTURE_DEPTH                                        0x8071
+#define GL_TEXTURE_WRAP_R                                       0x8072
+#define GL_MAX_3D_TEXTURE_SIZE                                  0x8073
+#define GL_TEXTURE_BINDING_3D                                   0x806A
+
+typedef void (APIENTRY * glDrawRangeElementsPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
+typedef void (APIENTRY * glTexImage3DPROC) (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRY * glTexSubImage3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRY * glCopyTexSubImage3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+
+extern GLEW_EXPORT glDrawRangeElementsPROC glDrawRangeElements;
+extern GLEW_EXPORT glTexImage3DPROC glTexImage3D;
+extern GLEW_EXPORT glTexSubImage3DPROC glTexSubImage3D;
+extern GLEW_EXPORT glCopyTexSubImage3DPROC glCopyTexSubImage3D;
+
+#endif /* GL_VERSION_1_2 */
+
+/* ------------------------------ OpenGL 1.3 ------------------------------ */
+
+#ifdef GL_VERSION_1_3
+
+#define GL_TEXTURE0                                             0x84C0
+#define GL_TEXTURE1                                             0x84C1
+#define GL_TEXTURE2                                             0x84C2
+#define GL_TEXTURE3                                             0x84C3
+#define GL_TEXTURE4                                             0x84C4
+#define GL_TEXTURE5                                             0x84C5
+#define GL_TEXTURE6                                             0x84C6
+#define GL_TEXTURE7                                             0x84C7
+#define GL_TEXTURE8                                             0x84C8
+#define GL_TEXTURE9                                             0x84C9
+#define GL_TEXTURE10                                            0x84CA
+#define GL_TEXTURE11                                            0x84CB
+#define GL_TEXTURE12                                            0x84CC
+#define GL_TEXTURE13                                            0x84CD
+#define GL_TEXTURE14                                            0x84CE
+#define GL_TEXTURE15                                            0x84CF
+#define GL_TEXTURE16                                            0x84D0
+#define GL_TEXTURE17                                            0x84D1
+#define GL_TEXTURE18                                            0x84D2
+#define GL_TEXTURE19                                            0x84D3
+#define GL_TEXTURE20                                            0x84D4
+#define GL_TEXTURE21                                            0x84D5
+#define GL_TEXTURE22                                            0x84D6
+#define GL_TEXTURE23                                            0x84D7
+#define GL_TEXTURE24                                            0x84D8
+#define GL_TEXTURE25                                            0x84D9
+#define GL_TEXTURE26                                            0x84DA
+#define GL_TEXTURE27                                            0x84DB
+#define GL_TEXTURE28                                            0x84DC
+#define GL_TEXTURE29                                            0x84DD
+#define GL_TEXTURE30                                            0x84DE
+#define GL_TEXTURE31                                            0x84DF
+#define GL_ACTIVE_TEXTURE                                       0x84E0
+#define GL_CLIENT_ACTIVE_TEXTURE                                0x84E1
+#define GL_MAX_TEXTURE_UNITS                                    0x84E2
+
+#define GL_NORMAL_MAP                                           0x8511
+#define GL_REFLECTION_MAP                                       0x8512
+#define GL_TEXTURE_CUBE_MAP                                     0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP                             0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X                          0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X                          0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y                          0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y                          0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z                          0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z                          0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP                               0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE                            0x851C
+
+#define GL_COMPRESSED_ALPHA                                     0x84E9
+#define GL_COMPRESSED_LUMINANCE                                 0x84EA
+#define GL_COMPRESSED_LUMINANCE_ALPHA                           0x84EB
+#define GL_COMPRESSED_INTENSITY                                 0x84EC
+#define GL_COMPRESSED_RGB                                       0x84ED
+#define GL_COMPRESSED_RGBA                                      0x84EE
+#define GL_TEXTURE_COMPRESSION_HINT                             0x84EF
+#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE                        0x86A0
+#define GL_TEXTURE_COMPRESSED                                   0x86A1
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS                       0x86A2
+#define GL_COMPRESSED_TEXTURE_FORMATS                           0x86A3
+
+#define GL_MULTISAMPLE                                          0x809D
+#define GL_SAMPLE_ALPHA_TO_COVERAGE                             0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE                                  0x809F
+#define GL_SAMPLE_COVERAGE                                      0x80A0
+#define GL_SAMPLE_BUFFERS                                       0x80A8
+#define GL_SAMPLES                                              0x80A9
+#define GL_SAMPLE_COVERAGE_VALUE                                0x80AA
+#define GL_SAMPLE_COVERAGE_INVERT                               0x80AB
+#define GL_MULTISAMPLE_BIT                                      0x20000000
+
+#define GL_TRANSPOSE_MODELVIEW_MATRIX                           0x84E3
+#define GL_TRANSPOSE_PROJECTION_MATRIX                          0x84E4
+#define GL_TRANSPOSE_TEXTURE_MATRIX                             0x84E5
+#define GL_TRANSPOSE_COLOR_MATRIX                               0x84E6
+
+#define GL_COMBINE                                              0x8570
+#define GL_COMBINE_RGB                                          0x8571
+#define GL_COMBINE_ALPHA                                        0x8572
+#define GL_SOURCE0_RGB                                          0x8580
+#define GL_SOURCE1_RGB                                          0x8581
+#define GL_SOURCE2_RGB                                          0x8582
+#define GL_SOURCE0_ALPHA                                        0x8588
+#define GL_SOURCE1_ALPHA                                        0x8589
+#define GL_SOURCE2_ALPHA                                        0x858A
+#define GL_OPERAND0_RGB                                         0x8590
+#define GL_OPERAND1_RGB                                         0x8591
+#define GL_OPERAND2_RGB                                         0x8592
+#define GL_OPERAND0_ALPHA                                       0x8598
+#define GL_OPERAND1_ALPHA                                       0x8599
+#define GL_OPERAND2_ALPHA                                       0x859A
+#define GL_RGB_SCALE                                            0x8573
+#define GL_ADD_SIGNED                                           0x8574
+#define GL_INTERPOLATE                                          0x8575
+#define GL_SUBTRACT                                             0x84E7
+#define GL_CONSTANT                                             0x8576
+#define GL_PRIMARY_COLOR                                        0x8577
+#define GL_PREVIOUS                                             0x8578
+#define GL_DOT3_RGB                                             0x86AE
+#define GL_DOT3_RGBA                                            0x86AF
+#define GL_CLAMP_TO_BORDER                                      0x812D
+
+typedef void (APIENTRY * glActiveTexturePROC) (GLenum texture);
+typedef void (APIENTRY * glClientActiveTexturePROC) (GLenum texture);
+typedef void (APIENTRY * glCompressedTexImage1DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * glCompressedTexImage2DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * glCompressedTexImage3DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * glCompressedTexSubImage1DPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * glCompressedTexSubImage2DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * glCompressedTexSubImage3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * glGetCompressedTexImagePROC) (GLenum target, GLint lod, GLvoid *img);
+typedef void (APIENTRY * glMultiTexCoord1dPROC) (GLenum target, GLdouble s);
+typedef void (APIENTRY * glMultiTexCoord1dvPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * glMultiTexCoord1fPROC) (GLenum target, GLfloat s);
+typedef void (APIENTRY * glMultiTexCoord1fvPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * glMultiTexCoord1iPROC) (GLenum target, GLint s);
+typedef void (APIENTRY * glMultiTexCoord1ivPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * glMultiTexCoord1sPROC) (GLenum target, GLshort s);
+typedef void (APIENTRY * glMultiTexCoord1svPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * glMultiTexCoord2dPROC) (GLenum target, GLdouble s, GLdouble t);
+typedef void (APIENTRY * glMultiTexCoord2dvPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * glMultiTexCoord2fPROC) (GLenum target, GLfloat s, GLfloat t);
+typedef void (APIENTRY * glMultiTexCoord2fvPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * glMultiTexCoord2iPROC) (GLenum target, GLint s, GLint t);
+typedef void (APIENTRY * glMultiTexCoord2ivPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * glMultiTexCoord2sPROC) (GLenum target, GLshort s, GLshort t);
+typedef void (APIENTRY * glMultiTexCoord2svPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * glMultiTexCoord3dPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r);
+typedef void (APIENTRY * glMultiTexCoord3dvPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * glMultiTexCoord3fPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
+typedef void (APIENTRY * glMultiTexCoord3fvPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * glMultiTexCoord3iPROC) (GLenum target, GLint s, GLint t, GLint r);
+typedef void (APIENTRY * glMultiTexCoord3ivPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * glMultiTexCoord3sPROC) (GLenum target, GLshort s, GLshort t, GLshort r);
+typedef void (APIENTRY * glMultiTexCoord3svPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * glMultiTexCoord4dPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+typedef void (APIENTRY * glMultiTexCoord4dvPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * glMultiTexCoord4fPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+typedef void (APIENTRY * glMultiTexCoord4fvPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * glMultiTexCoord4iPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q);
+typedef void (APIENTRY * glMultiTexCoord4ivPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * glMultiTexCoord4sPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+typedef void (APIENTRY * glMultiTexCoord4svPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * glLoadTransposeMatrixdPROC) (const GLdouble m[16]);
+typedef void (APIENTRY * glLoadTransposeMatrixfPROC) (const GLfloat m[16]);
+typedef void (APIENTRY * glMultTransposeMatrixdPROC) (const GLdouble m[16]);
+typedef void (APIENTRY * glMultTransposeMatrixfPROC) (const GLfloat m[16]);
+typedef void (APIENTRY * glSampleCoveragePROC) (GLclampf value, GLboolean invert);
+
+extern GLEW_EXPORT glActiveTexturePROC glActiveTexture;
+extern GLEW_EXPORT glClientActiveTexturePROC glClientActiveTexture;
+extern GLEW_EXPORT glMultiTexCoord1dPROC glMultiTexCoord1d;
+extern GLEW_EXPORT glMultiTexCoord1dvPROC glMultiTexCoord1dv;
+extern GLEW_EXPORT glMultiTexCoord1fPROC glMultiTexCoord1f;
+extern GLEW_EXPORT glMultiTexCoord1fvPROC glMultiTexCoord1fv;
+extern GLEW_EXPORT glMultiTexCoord1iPROC glMultiTexCoord1i;
+extern GLEW_EXPORT glMultiTexCoord1ivPROC glMultiTexCoord1iv;
+extern GLEW_EXPORT glMultiTexCoord1sPROC glMultiTexCoord1s;
+extern GLEW_EXPORT glMultiTexCoord1svPROC glMultiTexCoord1sv;
+extern GLEW_EXPORT glMultiTexCoord2dPROC glMultiTexCoord2d;
+extern GLEW_EXPORT glMultiTexCoord2dvPROC glMultiTexCoord2dv;
+extern GLEW_EXPORT glMultiTexCoord2fPROC glMultiTexCoord2f;
+extern GLEW_EXPORT glMultiTexCoord2fvPROC glMultiTexCoord2fv;
+extern GLEW_EXPORT glMultiTexCoord2iPROC glMultiTexCoord2i;
+extern GLEW_EXPORT glMultiTexCoord2ivPROC glMultiTexCoord2iv;
+extern GLEW_EXPORT glMultiTexCoord2sPROC glMultiTexCoord2s;
+extern GLEW_EXPORT glMultiTexCoord2svPROC glMultiTexCoord2sv;
+extern GLEW_EXPORT glMultiTexCoord3dPROC glMultiTexCoord3d;
+extern GLEW_EXPORT glMultiTexCoord3dvPROC glMultiTexCoord3dv;
+extern GLEW_EXPORT glMultiTexCoord3fPROC glMultiTexCoord3f;
+extern GLEW_EXPORT glMultiTexCoord3fvPROC glMultiTexCoord3fv;
+extern GLEW_EXPORT glMultiTexCoord3iPROC glMultiTexCoord3i;
+extern GLEW_EXPORT glMultiTexCoord3ivPROC glMultiTexCoord3iv;
+extern GLEW_EXPORT glMultiTexCoord3sPROC glMultiTexCoord3s;
+extern GLEW_EXPORT glMultiTexCoord3svPROC glMultiTexCoord3sv;
+extern GLEW_EXPORT glMultiTexCoord4dPROC glMultiTexCoord4d;
+extern GLEW_EXPORT glMultiTexCoord4dvPROC glMultiTexCoord4dv;
+extern GLEW_EXPORT glMultiTexCoord4fPROC glMultiTexCoord4f;
+extern GLEW_EXPORT glMultiTexCoord4fvPROC glMultiTexCoord4fv;
+extern GLEW_EXPORT glMultiTexCoord4iPROC glMultiTexCoord4i;
+extern GLEW_EXPORT glMultiTexCoord4ivPROC glMultiTexCoord4iv;
+extern GLEW_EXPORT glMultiTexCoord4sPROC glMultiTexCoord4s;
+extern GLEW_EXPORT glMultiTexCoord4svPROC glMultiTexCoord4sv;
+extern GLEW_EXPORT glLoadTransposeMatrixfPROC glLoadTransposeMatrixf;
+extern GLEW_EXPORT glLoadTransposeMatrixdPROC glLoadTransposeMatrixd;
+extern GLEW_EXPORT glMultTransposeMatrixfPROC glMultTransposeMatrixf;
+extern GLEW_EXPORT glMultTransposeMatrixdPROC glMultTransposeMatrixd;
+extern GLEW_EXPORT glCompressedTexImage3DPROC glCompressedTexImage3D;
+extern GLEW_EXPORT glCompressedTexImage2DPROC glCompressedTexImage2D;
+extern GLEW_EXPORT glCompressedTexImage1DPROC glCompressedTexImage1D;
+extern GLEW_EXPORT glCompressedTexSubImage3DPROC glCompressedTexSubImage3D;
+extern GLEW_EXPORT glCompressedTexSubImage2DPROC glCompressedTexSubImage2D;
+extern GLEW_EXPORT glCompressedTexSubImage1DPROC glCompressedTexSubImage1D;
+extern GLEW_EXPORT glGetCompressedTexImagePROC glGetCompressedTexImage;
+extern GLEW_EXPORT glSampleCoveragePROC glSampleCoverage;
+
+#endif /* GL_VERSION_1_3 */
+
+/* ------------------------------ OpenGL 1.4 ------------------------------ */
+
+#ifdef GL_VERSION_1_4
+
+#ifndef GL_ARB_imaging
+#define GL_BLEND_EQUATION                                       0x8009
+#define GL_MIN                                                  0x8007
+#define GL_MAX                                                  0x8008
+#define GL_FUNC_ADD                                             0x8006
+#define GL_FUNC_SUBTRACT                                        0x800A
+#define GL_FUNC_REVERSE_SUBTRACT                                0x800B
+#define GL_BLEND_COLOR                                          0x8005
+#define GL_CONSTANT_COLOR                                       0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR                             0x8002
+#define GL_CONSTANT_ALPHA                                       0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA                             0x8004
+#endif /* GL_ARB_imaging */
+
+#define GL_GENERATE_MIPMAP                                      0x8191
+#define GL_GENERATE_MIPMAP_HINT                                 0x8192
+#define GL_DEPTH_COMPONENT16                                    0x81A5
+#define GL_DEPTH_COMPONENT24                                    0x81A6
+#define GL_DEPTH_COMPONENT32                                    0x81A7
+#define GL_TEXTURE_DEPTH_SIZE                                   0x884A
+#define GL_DEPTH_TEXTURE_MODE                                   0x884B
+#define GL_TEXTURE_COMPARE_MODE                                 0x884C
+#define GL_TEXTURE_COMPARE_FUNC                                 0x884D
+#define GL_COMPARE_R_TO_TEXTURE                                 0x884E
+#define GL_FOG_COORDINATE_SOURCE                                0x8450
+#define GL_FOG_COORDINATE                                       0x8451
+#define GL_FRAGMENT_DEPTH                                       0x8452
+#define GL_CURRENT_FOG_COORDINATE                               0x8453
+#define GL_FOG_COORDINATE_ARRAY_TYPE                            0x8454
+#define GL_FOG_COORDINATE_ARRAY_STRIDE                          0x8455
+#define GL_FOG_COORDINATE_ARRAY_POINTER                         0x8456
+#define GL_FOG_COORDINATE_ARRAY                                 0x8457
+#define GL_POINT_SIZE_MIN                                       0x8126
+#define GL_POINT_SIZE_MAX                                       0x8127
+#define GL_POINT_FADE_THRESHOLD_SIZE                            0x8128
+#define GL_POINT_DISTANCE_ATTENUATION                           0x8129
+#define GL_COLOR_SUM                                            0x8458
+#define GL_CURRENT_SECONDARY_COLOR                              0x8459
+#define GL_SECONDARY_COLOR_ARRAY_SIZE                           0x845A
+#define GL_SECONDARY_COLOR_ARRAY_TYPE                           0x845B
+#define GL_SECONDARY_COLOR_ARRAY_STRIDE                         0x845C
+#define GL_SECONDARY_COLOR_ARRAY_POINTER                        0x845D
+#define GL_SECONDARY_COLOR_ARRAY                                0x845E
+#define GL_BLEND_DST_RGB                                        0x80C8
+#define GL_BLEND_SRC_RGB                                        0x80C9
+#define GL_BLEND_DST_ALPHA                                      0x80CA
+#define GL_BLEND_SRC_ALPHA                                      0x80CB
+#define GL_INCR_WRAP                                            0x8507
+#define GL_DECR_WRAP                                            0x8508
+#define GL_TEXTURE_FILTER_CONTROL                               0x8500
+#define GL_TEXTURE_LOD_BIAS                                     0x8501
+#define GL_MAX_TEXTURE_LOD_BIAS                                 0x84FD
+#define GL_MIRRORED_REPEAT                                      0x8370
+
+#ifndef GL_ARB_imaging
+typedef void (APIENTRY * glBlendEquationPROC) (GLenum mode);
+typedef void (APIENTRY * glBlendColorPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+#endif /* GL_ARB_imaging */
+typedef void (APIENTRY * glFogCoordfPROC) (GLfloat coord);
+typedef void (APIENTRY * glFogCoordfvPROC) (const GLfloat *coord);
+typedef void (APIENTRY * glFogCoorddPROC) (GLdouble coord);
+typedef void (APIENTRY * glFogCoorddvPROC) (const GLdouble *coord);
+typedef void (APIENTRY * glFogCoordPointerPROC) (GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRY * glMultiDrawArraysPROC) (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount);
+typedef void (APIENTRY * glMultiDrawElementsPROC) (GLenum mode, GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount);
+typedef void (APIENTRY * glPointParameterfPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * glPointParameterfvPROC) (GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glSecondaryColor3bPROC) (GLbyte red, GLbyte green, GLbyte blue);
+typedef void (APIENTRY * glSecondaryColor3bvPROC) (const GLbyte *v);
+typedef void (APIENTRY * glSecondaryColor3dPROC) (GLdouble red, GLdouble green, GLdouble blue);
+typedef void (APIENTRY * glSecondaryColor3dvPROC) (const GLdouble *v);
+typedef void (APIENTRY * glSecondaryColor3fPROC) (GLfloat red, GLfloat green, GLfloat blue);
+typedef void (APIENTRY * glSecondaryColor3fvPROC) (const GLfloat *v);
+typedef void (APIENTRY * glSecondaryColor3iPROC) (GLint red, GLint green, GLint blue);
+typedef void (APIENTRY * glSecondaryColor3ivPROC) (const GLint *v);
+typedef void (APIENTRY * glSecondaryColor3sPROC) (GLshort red, GLshort green, GLshort blue);
+typedef void (APIENTRY * glSecondaryColor3svPROC) (const GLshort *v);
+typedef void (APIENTRY * glSecondaryColor3ubPROC) (GLubyte red, GLubyte green, GLubyte blue);
+typedef void (APIENTRY * glSecondaryColor3ubvPROC) (const GLubyte *v);
+typedef void (APIENTRY * glSecondaryColor3uiPROC) (GLuint red, GLuint green, GLuint blue);
+typedef void (APIENTRY * glSecondaryColor3uivPROC) (const GLuint *v);
+typedef void (APIENTRY * glSecondaryColor3usPROC) (GLushort red, GLushort green, GLushort blue);
+typedef void (APIENTRY * glSecondaryColor3usvPROC) (const GLushort *v);
+typedef void (APIENTRY * glSecondaryColorPointerPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer);
+typedef void (APIENTRY * glBlendFuncSeparatePROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+typedef void (APIENTRY * glWindowPos2dPROC) (GLdouble x, GLdouble y);
+typedef void (APIENTRY * glWindowPos2fPROC) (GLfloat x, GLfloat y);
+typedef void (APIENTRY * glWindowPos2iPROC) (GLint x, GLint y);
+typedef void (APIENTRY * glWindowPos2sPROC) (GLshort x, GLshort y);
+typedef void (APIENTRY * glWindowPos2dvPROC) (const GLdouble *p);
+typedef void (APIENTRY * glWindowPos2fvPROC) (const GLfloat *p);
+typedef void (APIENTRY * glWindowPos2ivPROC) (const GLint *p);
+typedef void (APIENTRY * glWindowPos2svPROC) (const GLshort *p);
+typedef void (APIENTRY * glWindowPos3dPROC) (GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRY * glWindowPos3fPROC) (GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * glWindowPos3iPROC) (GLint x, GLint y, GLint z);
+typedef void (APIENTRY * glWindowPos3sPROC) (GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY * glWindowPos3dvPROC) (const GLdouble *p);
+typedef void (APIENTRY * glWindowPos3fvPROC) (const GLfloat *p);
+typedef void (APIENTRY * glWindowPos3ivPROC) (const GLint *p);
+typedef void (APIENTRY * glWindowPos3svPROC) (const GLshort *p);
+
+#ifndef GL_ARB_imaging
+extern GLEW_EXPORT glBlendColorPROC glBlendColor;
+extern GLEW_EXPORT glBlendEquationPROC glBlendEquation;
+#endif /* GL_ARB_imaging */
+extern GLEW_EXPORT glFogCoordfPROC glFogCoordf;
+extern GLEW_EXPORT glFogCoordfvPROC glFogCoordfv;
+extern GLEW_EXPORT glFogCoorddPROC glFogCoordd;
+extern GLEW_EXPORT glFogCoorddvPROC glFogCoorddv;
+extern GLEW_EXPORT glFogCoordPointerPROC glFogCoordPointer;
+extern GLEW_EXPORT glMultiDrawArraysPROC glMultiDrawArrays;
+extern GLEW_EXPORT glMultiDrawElementsPROC glMultiDrawElements;
+extern GLEW_EXPORT glPointParameterfPROC glPointParameterf;
+extern GLEW_EXPORT glPointParameterfvPROC glPointParameterfv;
+extern GLEW_EXPORT glSecondaryColor3bPROC glSecondaryColor3b;
+extern GLEW_EXPORT glSecondaryColor3bvPROC glSecondaryColor3bv;
+extern GLEW_EXPORT glSecondaryColor3dPROC glSecondaryColor3d;
+extern GLEW_EXPORT glSecondaryColor3dvPROC glSecondaryColor3dv;
+extern GLEW_EXPORT glSecondaryColor3fPROC glSecondaryColor3f;
+extern GLEW_EXPORT glSecondaryColor3fvPROC glSecondaryColor3fv;
+extern GLEW_EXPORT glSecondaryColor3iPROC glSecondaryColor3i;
+extern GLEW_EXPORT glSecondaryColor3ivPROC glSecondaryColor3iv;
+extern GLEW_EXPORT glSecondaryColor3sPROC glSecondaryColor3s;
+extern GLEW_EXPORT glSecondaryColor3svPROC glSecondaryColor3sv;
+extern GLEW_EXPORT glSecondaryColor3ubPROC glSecondaryColor3ub;
+extern GLEW_EXPORT glSecondaryColor3ubvPROC glSecondaryColor3ubv;
+extern GLEW_EXPORT glSecondaryColor3uiPROC glSecondaryColor3ui;
+extern GLEW_EXPORT glSecondaryColor3uivPROC glSecondaryColor3uiv;
+extern GLEW_EXPORT glSecondaryColor3usPROC glSecondaryColor3us;
+extern GLEW_EXPORT glSecondaryColor3usvPROC glSecondaryColor3usv;
+extern GLEW_EXPORT glSecondaryColorPointerPROC glSecondaryColorPointer;
+extern GLEW_EXPORT glBlendFuncSeparatePROC glBlendFuncSeparate;
+extern GLEW_EXPORT glWindowPos2dPROC glWindowPos2d;
+extern GLEW_EXPORT glWindowPos2fPROC glWindowPos2f;
+extern GLEW_EXPORT glWindowPos2iPROC glWindowPos2i;
+extern GLEW_EXPORT glWindowPos2sPROC glWindowPos2s;
+extern GLEW_EXPORT glWindowPos2dvPROC glWindowPos2dv;
+extern GLEW_EXPORT glWindowPos2fvPROC glWindowPos2fv;
+extern GLEW_EXPORT glWindowPos2ivPROC glWindowPos2iv;
+extern GLEW_EXPORT glWindowPos2svPROC glWindowPos2sv;
+extern GLEW_EXPORT glWindowPos3dPROC glWindowPos3d;
+extern GLEW_EXPORT glWindowPos3fPROC glWindowPos3f;
+extern GLEW_EXPORT glWindowPos3iPROC glWindowPos3i;
+extern GLEW_EXPORT glWindowPos3sPROC glWindowPos3s;
+extern GLEW_EXPORT glWindowPos3dvPROC glWindowPos3dv;
+extern GLEW_EXPORT glWindowPos3fvPROC glWindowPos3fv;
+extern GLEW_EXPORT glWindowPos3ivPROC glWindowPos3iv;
+extern GLEW_EXPORT glWindowPos3svPROC glWindowPos3sv;
+
+#endif /* GL_VERSION_1_4 */
+
+/* --------------------------- ARB_depth_texture -------------------------- */
+
+#ifdef GL_ARB_depth_texture
+
+#define GL_DEPTH_COMPONENT16_ARB                                0x81A5
+#define GL_DEPTH_COMPONENT24_ARB                                0x81A6
+#define GL_DEPTH_COMPONENT32_ARB                                0x81A7
+#define GL_TEXTURE_DEPTH_SIZE_ARB                               0x884A
+#define GL_DEPTH_TEXTURE_MODE_ARB                               0x884B
+
+#endif /* GL_ARB_depth_texture */
+
+/* -------------------------- ARB_fragment_program ------------------------ */
+
+#ifdef GL_ARB_fragment_program
+
+#define GL_FRAGMENT_PROGRAM_ARB                                 0x8804
+#define GL_PROGRAM_ALU_INSTRUCTIONS_ARB                         0x8805
+#define GL_PROGRAM_TEX_INSTRUCTIONS_ARB                         0x8806
+#define GL_PROGRAM_TEX_INDIRECTIONS_ARB                         0x8807
+#define GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB                  0x8808
+#define GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB                  0x8809
+#define GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB                  0x880A
+#define GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB                     0x880B
+#define GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB                     0x880C
+#define GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB                     0x880D
+#define GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB              0x880E
+#define GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB              0x880F
+#define GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB              0x8810
+#define GL_MAX_TEXTURE_COORDS_ARB                               0x8871
+#define GL_MAX_TEXTURE_IMAGE_UNITS_ARB                          0x8872
+
+#endif /* GL_ARB_fragment_program */
+
+/* ------------------------------ ARB_imaging ----------------------------- */
+
+#ifdef GL_ARB_imaging
+
+#define GL_CONSTANT_COLOR                                       0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR                             0x8002
+#define GL_CONSTANT_ALPHA                                       0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA                             0x8004
+#define GL_BLEND_COLOR                                          0x8005
+#define GL_FUNC_ADD                                             0x8006
+#define GL_MIN                                                  0x8007
+#define GL_MAX                                                  0x8008
+#define GL_BLEND_EQUATION                                       0x8009
+#define GL_FUNC_SUBTRACT                                        0x800A
+#define GL_FUNC_REVERSE_SUBTRACT                                0x800B
+#define GL_CONVOLUTION_1D                                       0x8010
+#define GL_CONVOLUTION_2D                                       0x8011
+#define GL_SEPARABLE_2D                                         0x8012
+#define GL_CONVOLUTION_BORDER_MODE                              0x8013
+#define GL_CONVOLUTION_FILTER_SCALE                             0x8014
+#define GL_CONVOLUTION_FILTER_BIAS                              0x8015
+#define GL_REDUCE                                               0x8016
+#define GL_CONVOLUTION_FORMAT                                   0x8017
+#define GL_CONVOLUTION_WIDTH                                    0x8018
+#define GL_CONVOLUTION_HEIGHT                                   0x8019
+#define GL_MAX_CONVOLUTION_WIDTH                                0x801A
+#define GL_MAX_CONVOLUTION_HEIGHT                               0x801B
+#define GL_POST_CONVOLUTION_RED_SCALE                           0x801C
+#define GL_POST_CONVOLUTION_GREEN_SCALE                         0x801D
+#define GL_POST_CONVOLUTION_BLUE_SCALE                          0x801E
+#define GL_POST_CONVOLUTION_ALPHA_SCALE                         0x801F
+#define GL_POST_CONVOLUTION_RED_BIAS                            0x8020
+#define GL_POST_CONVOLUTION_GREEN_BIAS                          0x8021
+#define GL_POST_CONVOLUTION_BLUE_BIAS                           0x8022
+#define GL_POST_CONVOLUTION_ALPHA_BIAS                          0x8023
+#define GL_HISTOGRAM                                            0x8024
+#define GL_PROXY_HISTOGRAM                                      0x8025
+#define GL_HISTOGRAM_WIDTH                                      0x8026
+#define GL_HISTOGRAM_FORMAT                                     0x8027
+#define GL_HISTOGRAM_RED_SIZE                                   0x8028
+#define GL_HISTOGRAM_GREEN_SIZE                                 0x8029
+#define GL_HISTOGRAM_BLUE_SIZE                                  0x802A
+#define GL_HISTOGRAM_ALPHA_SIZE                                 0x802B
+#define GL_HISTOGRAM_LUMINANCE_SIZE                             0x802C
+#define GL_HISTOGRAM_SINK                                       0x802D
+#define GL_MINMAX                                               0x802E
+#define GL_MINMAX_FORMAT                                        0x802F
+#define GL_MINMAX_SINK                                          0x8030
+#define GL_TABLE_TOO_LARGE                                      0x8031
+#define GL_COLOR_MATRIX                                         0x80B1
+#define GL_COLOR_MATRIX_STACK_DEPTH                             0x80B2
+#define GL_MAX_COLOR_MATRIX_STACK_DEPTH                         0x80B3
+#define GL_POST_COLOR_MATRIX_RED_SCALE                          0x80B4
+#define GL_POST_COLOR_MATRIX_GREEN_SCALE                        0x80B5
+#define GL_POST_COLOR_MATRIX_BLUE_SCALE                         0x80B6
+#define GL_POST_COLOR_MATRIX_ALPHA_SCALE                        0x80B7
+#define GL_POST_COLOR_MATRIX_RED_BIAS                           0x80B8
+#define GL_POST_COLOR_MATRIX_GREEN_BIAS                         0x80B9
+#define GL_POST_COLOR_MATRIX_BLUE_BIAS                          0x80BA
+#define GL_POST_COLOR_MATIX_ALPHA_BIAS                          0x80BB
+#define GL_COLOR_TABLE                                          0x80D0
+#define GL_POST_CONVOLUTION_COLOR_TABLE                         0x80D1
+#define GL_POST_COLOR_MATRIX_COLOR_TABLE                        0x80D2
+#define GL_PROXY_COLOR_TABLE                                    0x80D3
+#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE                   0x80D4
+#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE                  0x80D5
+#define GL_COLOR_TABLE_SCALE                                    0x80D6
+#define GL_COLOR_TABLE_BIAS                                     0x80D7
+#define GL_COLOR_TABLE_FORMAT                                   0x80D8
+#define GL_COLOR_TABLE_WIDTH                                    0x80D9
+#define GL_COLOR_TABLE_RED_SIZE                                 0x80DA
+#define GL_COLOR_TABLE_GREEN_SIZE                               0x80DB
+#define GL_COLOR_TABLE_BLUE_SIZE                                0x80DC
+#define GL_COLOR_TABLE_ALPHA_SIZE                               0x80DD
+#define GL_COLOR_TABLE_LUMINANCE_SIZE                           0x80DE
+#define GL_COLOR_TABLE_INTENSITY_SIZE                           0x80DF
+#define GL_IGNORE_BORDER                                        0x8150
+#define GL_CONSTANT_BORDER                                      0x8151
+#define GL_WRAP_BORDER                                          0x8152
+#define GL_REPLICATE_BORDER                                     0x8153
+#define GL_CONVOLUTION_BORDER_COLOR                             0x8154
+
+typedef void (APIENTRY * glColorTablePROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
+typedef void (APIENTRY * glColorSubTablePROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
+typedef void (APIENTRY * glColorTableParameterivPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRY * glColorTableParameterfvPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * glCopyColorSubTablePROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRY * glCopyColorTablePROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRY * glGetColorTablePROC) (GLenum target, GLenum format, GLenum type, GLvoid *table);
+typedef void (APIENTRY * glGetColorTableParameterfvPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetColorTableParameterivPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * glBlendEquationPROC) (GLenum mode);
+typedef void (APIENTRY * glBlendColorPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+typedef void (APIENTRY * glHistogramPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
+typedef void (APIENTRY * glResetHistogramPROC) (GLenum target);
+typedef void (APIENTRY * glGetHistogramPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+typedef void (APIENTRY * glGetHistogramParameterfvPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetHistogramParameterivPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * glMinmaxPROC) (GLenum target, GLenum internalformat, GLboolean sink);
+typedef void (APIENTRY * glResetMinmaxPROC) (GLenum target);
+typedef void (APIENTRY * glGetMinmaxPROC) (GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values);
+typedef void (APIENTRY * glGetMinmaxParameterfvPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetMinmaxParameterivPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * glConvolutionFilter1DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
+typedef void (APIENTRY * glConvolutionFilter2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
+typedef void (APIENTRY * glConvolutionParameterfPROC) (GLenum target, GLenum pname, GLfloat params);
+typedef void (APIENTRY * glConvolutionParameterfvPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * glConvolutionParameteriPROC) (GLenum target, GLenum pname, GLint params);
+typedef void (APIENTRY * glConvolutionParameterivPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRY * glCopyConvolutionFilter1DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRY * glCopyConvolutionFilter2DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (APIENTRY * glGetConvolutionFilterPROC) (GLenum target, GLenum format, GLenum type, GLvoid *image);
+typedef void (APIENTRY * glGetConvolutionParameterfvPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetConvolutionParameterivPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * glSeparableFilter2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
+typedef void (APIENTRY * glGetSeparableFilterPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
+
+extern GLEW_EXPORT glBlendColorPROC glBlendColor;
+extern GLEW_EXPORT glBlendEquationPROC glBlendEquation;
+extern GLEW_EXPORT glColorTablePROC glColorTable;
+extern GLEW_EXPORT glColorTableParameterfvPROC glColorTableParameterfv;
+extern GLEW_EXPORT glColorTableParameterivPROC glColorTableParameteriv;
+extern GLEW_EXPORT glCopyColorTablePROC glCopyColorTable;
+extern GLEW_EXPORT glGetColorTablePROC glGetColorTable;
+extern GLEW_EXPORT glGetColorTableParameterfvPROC glGetColorTableParameterfv;
+extern GLEW_EXPORT glGetColorTableParameterivPROC glGetColorTableParameteriv;
+extern GLEW_EXPORT glColorSubTablePROC glColorSubTable;
+extern GLEW_EXPORT glCopyColorSubTablePROC glCopyColorSubTable;
+extern GLEW_EXPORT glConvolutionFilter1DPROC glConvolutionFilter1D;
+extern GLEW_EXPORT glConvolutionFilter2DPROC glConvolutionFilter2D;
+extern GLEW_EXPORT glConvolutionParameterfPROC glConvolutionParameterf;
+extern GLEW_EXPORT glConvolutionParameterfvPROC glConvolutionParameterfv;
+extern GLEW_EXPORT glConvolutionParameteriPROC glConvolutionParameteri;
+extern GLEW_EXPORT glConvolutionParameterivPROC glConvolutionParameteriv;
+extern GLEW_EXPORT glCopyConvolutionFilter1DPROC glCopyConvolutionFilter1D;
+extern GLEW_EXPORT glCopyConvolutionFilter2DPROC glCopyConvolutionFilter2D;
+extern GLEW_EXPORT glGetConvolutionFilterPROC glGetConvolutionFilter;
+extern GLEW_EXPORT glGetConvolutionParameterfvPROC glGetConvolutionParameterfv;
+extern GLEW_EXPORT glGetConvolutionParameterivPROC glGetConvolutionParameteriv;
+extern GLEW_EXPORT glGetSeparableFilterPROC glGetSeparableFilter;
+extern GLEW_EXPORT glSeparableFilter2DPROC glSeparableFilter2D;
+extern GLEW_EXPORT glGetHistogramPROC glGetHistogram;
+extern GLEW_EXPORT glGetHistogramParameterfvPROC glGetHistogramParameterfv;
+extern GLEW_EXPORT glGetHistogramParameterivPROC glGetHistogramParameteriv;
+extern GLEW_EXPORT glGetMinmaxPROC glGetMinmax;
+extern GLEW_EXPORT glGetMinmaxParameterfvPROC glGetMinmaxParameterfv;
+extern GLEW_EXPORT glGetMinmaxParameterivPROC glGetMinmaxParameteriv;
+extern GLEW_EXPORT glHistogramPROC glHistogram;
+extern GLEW_EXPORT glMinmaxPROC glMinmax;
+extern GLEW_EXPORT glResetHistogramPROC glResetHistogram;
+extern GLEW_EXPORT glResetMinmaxPROC glResetMinmax;
+
+#endif /* GL_ARB_imaging */ 
+
+/* -------------------------- ARB_matrix_palette -------------------------- */
+
+#ifdef GL_ARB_matrix_palette
+
+#define GL_MATRIX_PALETTE_ARB                                   0x8840
+#define GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB                   0x8841
+#define GL_MAX_PALETTE_MATRICES_ARB                             0x8842
+#define GL_CURRENT_PALETTE_MATRIX_ARB                           0x8843
+#define GL_MATRIX_INDEX_ARRAY_ARB                               0x8844
+#define GL_CURRENT_MATRIX_INDEX_ARB                             0x8845
+#define GL_MATRIX_INDEX_ARRAY_SIZE_ARB                          0x8846
+#define GL_MATRIX_INDEX_ARRAY_TYPE_ARB                          0x8847
+#define GL_MATRIX_INDEX_ARRAY_STRIDE_ARB                        0x8848
+#define GL_MATRIX_INDEX_ARRAY_POINTER_ARB                       0x8849
+
+typedef void (APIENTRY * glCurrentPaletteMatrixARBPROC) (GLint index);
+typedef void (APIENTRY * glMatrixIndexubvARBPROC) (GLint size, GLubyte *indices);
+typedef void (APIENTRY * glMatrixIndexusvARBPROC) (GLint size, GLushort *indices);
+typedef void (APIENTRY * glMatrixIndexuivARBPROC) (GLint size, GLuint *indices);
+typedef void (APIENTRY * glMatrixIndexPointerARBPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer);
+
+extern GLEW_EXPORT glCurrentPaletteMatrixARBPROC glCurrentPaletteMatrixARB;
+extern GLEW_EXPORT glMatrixIndexubvARBPROC glMatrixIndexubvARB;
+extern GLEW_EXPORT glMatrixIndexusvARBPROC glMatrixIndexusvARB;
+extern GLEW_EXPORT glMatrixIndexuivARBPROC glMatrixIndexuivARB;
+extern GLEW_EXPORT glMatrixIndexPointerARBPROC glMatrixIndexPointerARB;
+
+#endif /* GL_ARB_matrix_palette */
+
+/* ---------------------------- ARB_multisample --------------------------- */
+
+#ifdef GL_ARB_multisample
+
+#define GL_MULTISAMPLE_ARB                                      0x809D
+#define GL_SAMPLE_ALPHA_TO_COVERAGE_ARB                         0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE_ARB                              0x809F
+#define GL_SAMPLE_COVERAGE_ARB                                  0x80A0
+#define GL_SAMPLE_BUFFERS_ARB                                   0x80A8
+#define GL_SAMPLES_ARB                                          0x80A9
+#define GL_SAMPLE_COVERAGE_VALUE_ARB                            0x80AA
+#define GL_SAMPLE_COVERAGE_INVERT_ARB                           0x80AB
+#define GL_MULTISAMPLE_BIT_ARB                                  0x20000000
+
+typedef void (APIENTRY * glSampleCoverageARBPROC) (GLclampf value, GLboolean invert);
+
+extern GLEW_EXPORT glSampleCoverageARBPROC glSampleCoverageARB;
+
+#endif /* GL_ARB_multisample */
+
+/* --------------------------- ARB_multitexture --------------------------- */
+
+#ifdef GL_ARB_multitexture
+
+#define GL_TEXTURE0_ARB                                         0x84C0
+#define GL_TEXTURE1_ARB                                         0x84C1
+#define GL_TEXTURE2_ARB                                         0x84C2
+#define GL_TEXTURE3_ARB                                         0x84C3
+#define GL_TEXTURE4_ARB                                         0x84C4
+#define GL_TEXTURE5_ARB                                         0x84C5
+#define GL_TEXTURE6_ARB                                         0x84C6
+#define GL_TEXTURE7_ARB                                         0x84C7
+#define GL_TEXTURE8_ARB                                         0x84C8
+#define GL_TEXTURE9_ARB                                         0x84C9
+#define GL_TEXTURE10_ARB                                        0x84CA
+#define GL_TEXTURE11_ARB                                        0x84CB
+#define GL_TEXTURE12_ARB                                        0x84CC
+#define GL_TEXTURE13_ARB                                        0x84CD
+#define GL_TEXTURE14_ARB                                        0x84CE
+#define GL_TEXTURE15_ARB                                        0x84CF
+#define GL_TEXTURE16_ARB                                        0x84D0
+#define GL_TEXTURE17_ARB                                        0x84D1
+#define GL_TEXTURE18_ARB                                        0x84D2
+#define GL_TEXTURE19_ARB                                        0x84D3
+#define GL_TEXTURE20_ARB                                        0x84D4
+#define GL_TEXTURE21_ARB                                        0x84D5
+#define GL_TEXTURE22_ARB                                        0x84D6
+#define GL_TEXTURE23_ARB                                        0x84D7
+#define GL_TEXTURE24_ARB                                        0x84D8
+#define GL_TEXTURE25_ARB                                        0x84D9
+#define GL_TEXTURE26_ARB                                        0x84DA
+#define GL_TEXTURE27_ARB                                        0x84DB
+#define GL_TEXTURE28_ARB                                        0x84DC
+#define GL_TEXTURE29_ARB                                        0x84DD
+#define GL_TEXTURE30_ARB                                        0x84DE
+#define GL_TEXTURE31_ARB                                        0x84DF
+#define GL_ACTIVE_TEXTURE_ARB                                   0x84E0
+#define GL_CLIENT_ACTIVE_TEXTURE_ARB                            0x84E1
+#define GL_MAX_TEXTURE_UNITS_ARB                                0x84E2
+
+typedef void (APIENTRY * glActiveTextureARBPROC) (GLenum texture);
+typedef void (APIENTRY * glClientActiveTextureARBPROC) (GLenum texture);
+typedef void (APIENTRY * glMultiTexCoord1dARBPROC) (GLenum target, GLdouble s);
+typedef void (APIENTRY * glMultiTexCoord1dvARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * glMultiTexCoord1fARBPROC) (GLenum target, GLfloat s);
+typedef void (APIENTRY * glMultiTexCoord1fvARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * glMultiTexCoord1iARBPROC) (GLenum target, GLint s);
+typedef void (APIENTRY * glMultiTexCoord1ivARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * glMultiTexCoord1sARBPROC) (GLenum target, GLshort s);
+typedef void (APIENTRY * glMultiTexCoord1svARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * glMultiTexCoord2dARBPROC) (GLenum target, GLdouble s, GLdouble t);
+typedef void (APIENTRY * glMultiTexCoord2dvARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * glMultiTexCoord2fARBPROC) (GLenum target, GLfloat s, GLfloat t);
+typedef void (APIENTRY * glMultiTexCoord2fvARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * glMultiTexCoord2iARBPROC) (GLenum target, GLint s, GLint t);
+typedef void (APIENTRY * glMultiTexCoord2ivARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * glMultiTexCoord2sARBPROC) (GLenum target, GLshort s, GLshort t);
+typedef void (APIENTRY * glMultiTexCoord2svARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * glMultiTexCoord3dARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r);
+typedef void (APIENTRY * glMultiTexCoord3dvARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * glMultiTexCoord3fARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
+typedef void (APIENTRY * glMultiTexCoord3fvARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * glMultiTexCoord3iARBPROC) (GLenum target, GLint s, GLint t, GLint r);
+typedef void (APIENTRY * glMultiTexCoord3ivARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * glMultiTexCoord3sARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r);
+typedef void (APIENTRY * glMultiTexCoord3svARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * glMultiTexCoord4dARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+typedef void (APIENTRY * glMultiTexCoord4dvARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * glMultiTexCoord4fARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+typedef void (APIENTRY * glMultiTexCoord4fvARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * glMultiTexCoord4iARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q);
+typedef void (APIENTRY * glMultiTexCoord4ivARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * glMultiTexCoord4sARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+typedef void (APIENTRY * glMultiTexCoord4svARBPROC) (GLenum target, const GLshort *v);
+
+extern GLEW_EXPORT glActiveTextureARBPROC glActiveTextureARB;
+extern GLEW_EXPORT glClientActiveTextureARBPROC glClientActiveTextureARB;
+extern GLEW_EXPORT glMultiTexCoord1dARBPROC glMultiTexCoord1dARB;
+extern GLEW_EXPORT glMultiTexCoord1dvARBPROC glMultiTexCoord1dvARB;
+extern GLEW_EXPORT glMultiTexCoord1fARBPROC glMultiTexCoord1fARB;
+extern GLEW_EXPORT glMultiTexCoord1fvARBPROC glMultiTexCoord1fvARB;
+extern GLEW_EXPORT glMultiTexCoord1iARBPROC glMultiTexCoord1iARB;
+extern GLEW_EXPORT glMultiTexCoord1ivARBPROC glMultiTexCoord1ivARB;
+extern GLEW_EXPORT glMultiTexCoord1sARBPROC glMultiTexCoord1sARB;
+extern GLEW_EXPORT glMultiTexCoord1svARBPROC glMultiTexCoord1svARB;
+extern GLEW_EXPORT glMultiTexCoord2dARBPROC glMultiTexCoord2dARB;
+extern GLEW_EXPORT glMultiTexCoord2dvARBPROC glMultiTexCoord2dvARB;
+extern GLEW_EXPORT glMultiTexCoord2fARBPROC glMultiTexCoord2fARB;
+extern GLEW_EXPORT glMultiTexCoord2fvARBPROC glMultiTexCoord2fvARB;
+extern GLEW_EXPORT glMultiTexCoord2iARBPROC glMultiTexCoord2iARB;
+extern GLEW_EXPORT glMultiTexCoord2ivARBPROC glMultiTexCoord2ivARB;
+extern GLEW_EXPORT glMultiTexCoord2sARBPROC glMultiTexCoord2sARB;
+extern GLEW_EXPORT glMultiTexCoord2svARBPROC glMultiTexCoord2svARB;
+extern GLEW_EXPORT glMultiTexCoord3dARBPROC glMultiTexCoord3dARB;
+extern GLEW_EXPORT glMultiTexCoord3dvARBPROC glMultiTexCoord3dvARB;
+extern GLEW_EXPORT glMultiTexCoord3fARBPROC glMultiTexCoord3fARB;
+extern GLEW_EXPORT glMultiTexCoord3fvARBPROC glMultiTexCoord3fvARB;
+extern GLEW_EXPORT glMultiTexCoord3iARBPROC glMultiTexCoord3iARB;
+extern GLEW_EXPORT glMultiTexCoord3ivARBPROC glMultiTexCoord3ivARB;
+extern GLEW_EXPORT glMultiTexCoord3sARBPROC glMultiTexCoord3sARB;
+extern GLEW_EXPORT glMultiTexCoord3svARBPROC glMultiTexCoord3svARB;
+extern GLEW_EXPORT glMultiTexCoord4dARBPROC glMultiTexCoord4dARB;
+extern GLEW_EXPORT glMultiTexCoord4dvARBPROC glMultiTexCoord4dvARB;
+extern GLEW_EXPORT glMultiTexCoord4fARBPROC glMultiTexCoord4fARB;
+extern GLEW_EXPORT glMultiTexCoord4fvARBPROC glMultiTexCoord4fvARB;
+extern GLEW_EXPORT glMultiTexCoord4iARBPROC glMultiTexCoord4iARB;
+extern GLEW_EXPORT glMultiTexCoord4ivARBPROC glMultiTexCoord4ivARB;
+extern GLEW_EXPORT glMultiTexCoord4sARBPROC glMultiTexCoord4sARB;
+extern GLEW_EXPORT glMultiTexCoord4svARBPROC glMultiTexCoord4svARB;
+
+#endif /* GL_ARB_multitexture */
+
+/* ------------------------- ARB_point_parameters ------------------------- */
+
+#ifdef GL_ARB_point_parameters
+
+#define GL_POINT_SIZE_MIN_ARB                                   0x8126
+#define GL_POINT_SIZE_MAX_ARB                                   0x8127
+#define GL_POINT_FADE_THRESHOLD_SIZE_ARB                        0x8128
+#define GL_POINT_DISTANCE_ATTENUATION_ARB                       0x8129
+
+typedef void (APIENTRY * glPointParameterfARBPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * glPointParameterfvARBPROC) (GLenum pname, GLfloat *params);
+
+extern GLEW_EXPORT glPointParameterfARBPROC glPointParameterfARB;
+extern GLEW_EXPORT glPointParameterfvARBPROC glPointParameterfvARB;
+
+#endif /* GL_ARB_point_parameters */
+
+/* ------------------------------ ARB_shadow ------------------------------ */
+
+#ifdef GL_ARB_shadow
+
+#define GL_TEXTURE_COMPARE_MODE_ARB                             0x884C
+#define GL_TEXTURE_COMPARE_FUNC_ARB                             0x884D
+#define GL_COMPARE_R_TO_TEXTURE_ARB                             0x884E
+
+#endif /* GL_ARB_shadow */
+
+/* -------------------------- ARB_shadow_ambient -------------------------- */
+
+#ifdef GL_ARB_shadow_ambient
+
+#define GL_TEXTURE_COMPARE_FAIL_VALUE_ARB                       0x80BF 
+
+#endif /* GL_ARB_shadow_ambient */
+
+/* ----------------------- ARB_texture_border_clamp ----------------------- */
+
+#ifdef GL_ARB_texture_border_clamp
+
+#define GL_CLAMP_TO_BORDER_ARB                                  0x812D
+
+#endif /* GL_ARB_texture_border_clamp */
+
+/* ------------------------ ARB_texture_compression ----------------------- */
+
+#ifdef GL_ARB_texture_compression
+
+#define GL_COMPRESSED_ALPHA_ARB                                 0x84E9
+#define GL_COMPRESSED_LUMINANCE_ARB                             0x84EA
+#define GL_COMPRESSED_LUMINANCE_ALPHA_ARB                       0x84EB
+#define GL_COMPRESSED_INTENSITY_ARB                             0x84EC
+#define GL_COMPRESSED_RGB_ARB                                   0x84ED
+#define GL_COMPRESSED_RGBA_ARB                                  0x84EE
+#define GL_TEXTURE_COMPRESSION_HINT_ARB                         0x84EF
+#define GL_TEXTURE_IMAGE_SIZE_ARB                               0x86A0
+#define GL_TEXTURE_COMPRESSED_ARB                               0x86A1
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB                   0x86A2
+#define GL_COMPRESSED_TEXTURE_FORMATS_ARB                       0x86A3
+
+typedef void (APIENTRY * glCompressedTexImage1DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * glCompressedTexImage2DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * glCompressedTexImage3DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * glCompressedTexSubImage1DARBPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * glCompressedTexSubImage2DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * glCompressedTexSubImage3DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * glGetCompressedTexImageARBPROC) (GLenum target, GLint lod, GLvoid *img);
+
+extern GLEW_EXPORT glCompressedTexImage3DARBPROC glCompressedTexImage3DARB;
+extern GLEW_EXPORT glCompressedTexImage2DARBPROC glCompressedTexImage2DARB;
+extern GLEW_EXPORT glCompressedTexImage1DARBPROC glCompressedTexImage1DARB; 
+extern GLEW_EXPORT glCompressedTexSubImage3DARBPROC glCompressedTexSubImage3DARB;
+extern GLEW_EXPORT glCompressedTexSubImage2DARBPROC glCompressedTexSubImage2DARB;
+extern GLEW_EXPORT glCompressedTexSubImage1DARBPROC glCompressedTexSubImage1DARB;
+extern GLEW_EXPORT glGetCompressedTexImageARBPROC glGetCompressedTexImageARB;
+
+#endif /* GL_ARB_texture_compression */
+
+/* ------------------------- ARB_texture_cube_map ------------------------- */
+
+#ifdef GL_ARB_texture_cube_map
+
+#define GL_NORMAL_MAP_ARB                                       0x8511
+#define GL_REFLECTION_MAP_ARB                                   0x8512
+#define GL_TEXTURE_CUBE_MAP_ARB                                 0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP_ARB                         0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB                      0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB                      0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB                      0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB                      0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB                      0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB                      0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP_ARB                           0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB                        0x851C
+
+#endif /* GL_ARB_texture_cube_map */
+
+/* -------------------------- ARB_texture_env_add ------------------------- */
+
+/* ------------------------ ARB_texture_env_combine ----------------------- */
+
+#ifdef GL_ARB_texture_env_combine
+
+#define GL_COMBINE_ARB                                          0x8570
+#define GL_COMBINE_RGB_ARB                                      0x8571
+#define GL_COMBINE_ALPHA_ARB                                    0x8572
+#define GL_RGB_SCALE_ARB                                        0x8573
+#define GL_ADD_SIGNED_ARB                                       0x8574
+#define GL_INTERPOLATE_ARB                                      0x8575
+#define GL_CONSTANT_ARB                                         0x8576
+#define GL_PRIMARY_COLOR_ARB                                    0x8577
+#define GL_PREVIOUS_ARB                                         0x8578
+#define GL_SOURCE0_RGB_ARB                                      0x8580
+#define GL_SOURCE1_RGB_ARB                                      0x8581
+#define GL_SOURCE2_RGB_ARB                                      0x8582
+#define GL_SOURCE0_ALPHA_ARB                                    0x8588
+#define GL_SOURCE1_ALPHA_ARB                                    0x8589
+#define GL_SOURCE2_ALPHA_ARB                                    0x858A
+#define GL_OPERAND0_RGB_ARB                                     0x8590
+#define GL_OPERAND1_RGB_ARB                                     0x8591
+#define GL_OPERAND2_RGB_ARB                                     0x8592
+#define GL_OPERAND0_ALPHA_ARB                                   0x8598
+#define GL_OPERAND1_ALPHA_ARB                                   0x8599
+#define GL_OPERAND2_ALPHA_ARB                                   0x859A
+
+#endif /* GL_ARB_texture_env_combine */
+
+/* ----------------------- ARB_texture_env_crossbar ----------------------- */
+
+/* ------------------------- ARB_texture_env_dot3 ------------------------- */
+
+#ifdef GL_ARB_texture_env_dot3
+
+#define GL_DOT3_RGB_ARB                                         0x86AE
+#define GL_DOT3_RGBA_ARB                                        0x86AF
+
+#endif /* GL_ARB_texture_env_dot3 */
+
+/* ---------------------- ARB_texture_mirrored_repeat --------------------- */
+
+#ifdef GL_ARB_texture_mirrored_repeat
+
+#define GL_MIRRORED_REPEAT_ARB                                  0x8370
+
+#endif /* GL_ARB_texture_mirrored_repeat */
+
+/* ------------------------- ARB_transpose_matrix ------------------------- */
+
+#ifdef GL_ARB_transpose_matrix
+
+#define GL_TRANSPOSE_MODELVIEW_MATRIX_ARB                       0x84E3
+#define GL_TRANSPOSE_PROJECTION_MATRIX_ARB                      0x84E4
+#define GL_TRANSPOSE_TEXTURE_MATRIX_ARB                         0x84E5
+#define GL_TRANSPOSE_COLOR_MATRIX_ARB                           0x84E6
+
+typedef void (APIENTRY * glLoadTransposeMatrixdARBPROC) (const GLdouble m[16]);
+typedef void (APIENTRY * glLoadTransposeMatrixfARBPROC) (const GLfloat m[16]);
+typedef void (APIENTRY * glMultTransposeMatrixdARBPROC) (const GLdouble m[16]);
+typedef void (APIENTRY * glMultTransposeMatrixfARBPROC) (const GLfloat m[16]);
+
+extern GLEW_EXPORT glLoadTransposeMatrixfARBPROC glLoadTransposeMatrixfARB;
+extern GLEW_EXPORT glLoadTransposeMatrixdARBPROC glLoadTransposeMatrixdARB;
+extern GLEW_EXPORT glMultTransposeMatrixfARBPROC glMultTransposeMatrixfARB;
+extern GLEW_EXPORT glMultTransposeMatrixdARBPROC glMultTransposeMatrixdARB;
+
+#endif /* GL_ARB_transpose_matrix */
+
+/* --------------------------- ARB_vertex_blend --------------------------- */
+
+#ifdef GL_ARB_vertex_blend
+
+#define GL_MAX_VERTEX_UNITS_ARB                                 0x86A4
+#define GL_ACTIVE_VERTEX_UNITS_ARB                              0x86A5
+#define GL_WEIGHT_SUM_UNITY_ARB                                 0x86A6      
+#define GL_VERTEX_BLEND_ARB                                     0x86A7
+#define GL_CURRENT_WEIGHT_ARB                                   0x86A8
+#define GL_WEIGHT_ARRAY_TYPE_ARB                                0x86A9
+#define GL_WEIGHT_ARRAY_STRIDE_ARB                              0x86AA
+#define GL_WEIGHT_ARRAY_SIZE_ARB                                0x86AB
+#define GL_WEIGHT_ARRAY_POINTER_ARB                             0x86AC
+#define GL_WEIGHT_ARRAY_ARB                                     0x86AD
+#define GL_MODELVIEW0_ARB                                       0x1700
+#define GL_MODELVIEW1_ARB                                       0x850A
+#define GL_MODELVIEW2_ARB                                       0x8722
+#define GL_MODELVIEW3_ARB                                       0x8723
+#define GL_MODELVIEW4_ARB                                       0x8724
+#define GL_MODELVIEW5_ARB                                       0x8725
+#define GL_MODELVIEW6_ARB                                       0x8726
+#define GL_MODELVIEW7_ARB                                       0x8727
+#define GL_MODELVIEW8_ARB                                       0x8728
+#define GL_MODELVIEW9_ARB                                       0x8729
+#define GL_MODELVIEW10_ARB                                      0x872A
+#define GL_MODELVIEW11_ARB                                      0x872B
+#define GL_MODELVIEW12_ARB                                      0x872C
+#define GL_MODELVIEW13_ARB                                      0x872D
+#define GL_MODELVIEW14_ARB                                      0x872E
+#define GL_MODELVIEW15_ARB                                      0x872F
+#define GL_MODELVIEW16_ARB                                      0x8730
+#define GL_MODELVIEW17_ARB                                      0x8731
+#define GL_MODELVIEW18_ARB                                      0x8732
+#define GL_MODELVIEW19_ARB                                      0x8733
+#define GL_MODELVIEW20_ARB                                      0x8734
+#define GL_MODELVIEW21_ARB                                      0x8735
+#define GL_MODELVIEW22_ARB                                      0x8736
+#define GL_MODELVIEW23_ARB                                      0x8737
+#define GL_MODELVIEW24_ARB                                      0x8738
+#define GL_MODELVIEW25_ARB                                      0x8739
+#define GL_MODELVIEW26_ARB                                      0x873A
+#define GL_MODELVIEW27_ARB                                      0x873B
+#define GL_MODELVIEW28_ARB                                      0x873C
+#define GL_MODELVIEW29_ARB                                      0x873D
+#define GL_MODELVIEW30_ARB                                      0x873E
+#define GL_MODELVIEW31_ARB                                      0x873F
+
+typedef void (APIENTRY * glWeightbvARBPROC) (GLint size, GLbyte *weights);
+typedef void (APIENTRY * glWeightsvARBPROC) (GLint size, GLshort *weights);
+typedef void (APIENTRY * glWeightivARBPROC) (GLint size, GLint *weights);
+typedef void (APIENTRY * glWeightfvARBPROC) (GLint size, GLfloat *weights);
+typedef void (APIENTRY * glWeightdvARBPROC) (GLint size, GLdouble *weights);
+typedef void (APIENTRY * glWeightubvARBPROC) (GLint size, GLubyte *weights);
+typedef void (APIENTRY * glWeightusvARBPROC) (GLint size, GLushort *weights);
+typedef void (APIENTRY * glWeightuivARBPROC) (GLint size, GLuint *weights);
+typedef void (APIENTRY * glWeightPointerARBPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer);
+typedef void (APIENTRY * glVertexBlendARBPROC) (GLint count);
+
+extern GLEW_EXPORT glWeightbvARBPROC glWeightbvARB;
+extern GLEW_EXPORT glWeightsvARBPROC glWeightsvARB;
+extern GLEW_EXPORT glWeightivARBPROC glWeightivARB;
+extern GLEW_EXPORT glWeightfvARBPROC glWeightfvARB;
+extern GLEW_EXPORT glWeightdvARBPROC glWeightdvARB;
+extern GLEW_EXPORT glWeightubvARBPROC glWeightubvARB;
+extern GLEW_EXPORT glWeightusvARBPROC glWeightusvARB;
+extern GLEW_EXPORT glWeightuivARBPROC glWeightuivARB;
+extern GLEW_EXPORT glWeightPointerARBPROC glWeightPointerARB;
+extern GLEW_EXPORT glVertexBlendARBPROC glVertexBlendARB;
+
+#endif /* GL_ARB_vertex_blend */
+
+/* -------------------------- ARB_vertex_program -------------------------- */
+
+#ifdef GL_ARB_vertex_program
+
+#define GL_VERTEX_PROGRAM_ARB                                   0x8620
+#define GL_VERTEX_PROGRAM_POINT_SIZE_ARB                        0x8642
+#define GL_VERTEX_PROGRAM_TWO_SIDE_ARB                          0x8643
+#define GL_COLOR_SUM_ARB                                        0x8458
+#define GL_PROGRAM_FORMAT_ASCII_ARB                             0x8875
+#define GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB                      0x8622
+#define GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB                         0x8623
+#define GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB                       0x8624
+#define GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB                         0x8625
+#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB                   0x886A
+#define GL_CURRENT_VERTEX_ATTRIB_ARB                            0x8626
+#define GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB                      0x8645
+#define GL_PROGRAM_LENGTH_ARB                                   0x8627
+#define GL_PROGRAM_FORMAT_ARB                                   0x8876
+#define GL_PROGRAM_BINDING_ARB                                  0x8677
+#define GL_PROGRAM_INSTRUCTIONS_ARB                             0x88A0
+#define GL_MAX_PROGRAM_INSTRUCTIONS_ARB                         0x88A1
+#define GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB                      0x88A2
+#define GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB                  0x88A3
+#define GL_PROGRAM_TEMPORARIES_ARB                              0x88A4
+#define GL_MAX_PROGRAM_TEMPORARIES_ARB                          0x88A5
+#define GL_PROGRAM_NATIVE_TEMPORARIES_ARB                       0x88A6
+#define GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB                   0x88A7
+#define GL_PROGRAM_PARAMETERS_ARB                               0x88A8
+#define GL_MAX_PROGRAM_PARAMETERS_ARB                           0x88A9
+#define GL_PROGRAM_NATIVE_PARAMETERS_ARB                        0x88AA
+#define GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB                    0x88AB
+#define GL_PROGRAM_ATTRIBS_ARB                                  0x88AC
+#define GL_MAX_PROGRAM_ATTRIBS_ARB                              0x88AD
+#define GL_PROGRAM_NATIVE_ATTRIBS_ARB                           0x88AE
+#define GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB                       0x88AF
+#define GL_PROGRAM_ADDRESS_REGISTERS_ARB                        0x88B0
+#define GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB                    0x88B1
+#define GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB                 0x88B2
+#define GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB             0x88B3
+#define GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB                     0x88B4
+#define GL_MAX_PROGRAM_ENV_PARAMETERS_ARB                       0x88B5
+#define GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB                      0x88B6
+#define GL_PROGRAM_STRING_ARB                                   0x8628
+#define GL_PROGRAM_ERROR_POSITION_ARB                           0x864B
+#define GL_CURRENT_MATRIX_ARB                                   0x8641
+#define GL_TRANSPOSE_CURRENT_MATRIX_ARB                         0x88B7
+#define GL_CURRENT_MATRIX_STACK_DEPTH_ARB                       0x8640
+#define GL_MAX_VERTEX_ATTRIBS_ARB                               0x8869
+#define GL_MAX_PROGRAM_MATRICES_ARB                             0x862F
+#define GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB                   0x862E
+#define GL_PROGRAM_ERROR_STRING_ARB                             0x8874
+#define GL_MATRIX0_ARB                                          0x88C0
+#define GL_MATRIX1_ARB                                          0x88C1
+#define GL_MATRIX2_ARB                                          0x88C2
+#define GL_MATRIX3_ARB                                          0x88C3
+#define GL_MATRIX4_ARB                                          0x88C4
+#define GL_MATRIX5_ARB                                          0x88C5
+#define GL_MATRIX6_ARB                                          0x88C6
+#define GL_MATRIX7_ARB                                          0x88C7
+#define GL_MATRIX8_ARB                                          0x88C8
+#define GL_MATRIX9_ARB                                          0x88C9
+#define GL_MATRIX10_ARB                                         0x88CA
+#define GL_MATRIX11_ARB                                         0x88CB
+#define GL_MATRIX12_ARB                                         0x88CC
+#define GL_MATRIX13_ARB                                         0x88CD
+#define GL_MATRIX14_ARB                                         0x88CE
+#define GL_MATRIX15_ARB                                         0x88CF
+#define GL_MATRIX16_ARB                                         0x88D0
+#define GL_MATRIX17_ARB                                         0x88D1
+#define GL_MATRIX18_ARB                                         0x88D2
+#define GL_MATRIX19_ARB                                         0x88D3
+#define GL_MATRIX20_ARB                                         0x88D4
+#define GL_MATRIX21_ARB                                         0x88D5
+#define GL_MATRIX22_ARB                                         0x88D6
+#define GL_MATRIX23_ARB                                         0x88D7
+#define GL_MATRIX24_ARB                                         0x88D8
+#define GL_MATRIX25_ARB                                         0x88D9
+#define GL_MATRIX26_ARB                                         0x88DA
+#define GL_MATRIX27_ARB                                         0x88DB
+#define GL_MATRIX28_ARB                                         0x88DC
+#define GL_MATRIX29_ARB                                         0x88DD
+#define GL_MATRIX30_ARB                                         0x88DE
+#define GL_MATRIX31_ARB                                         0x88DF
+
+typedef void (APIENTRY * glVertexAttrib1sARBPROC) (GLuint index, GLshort x);
+typedef void (APIENTRY * glVertexAttrib1fARBPROC) (GLuint index, GLfloat x);
+typedef void (APIENTRY * glVertexAttrib1dARBPROC) (GLuint index, GLdouble x);
+typedef void (APIENTRY * glVertexAttrib2sARBPROC) (GLuint index, GLshort x, GLshort y);
+typedef void (APIENTRY * glVertexAttrib2fARBPROC) (GLuint index, GLfloat x, GLfloat y);
+typedef void (APIENTRY * glVertexAttrib2dARBPROC) (GLuint index, GLdouble x, GLdouble y);
+typedef void (APIENTRY * glVertexAttrib3sARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY * glVertexAttrib3fARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * glVertexAttrib3dARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRY * glVertexAttrib4sARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (APIENTRY * glVertexAttrib4fARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * glVertexAttrib4dARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * glVertexAttrib4NubARBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+typedef void (APIENTRY * glVertexAttrib1svARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * glVertexAttrib1fvARBPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttrib1dvARBPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttrib2svARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * glVertexAttrib2fvARBPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttrib2dvARBPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttrib3svARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * glVertexAttrib3fvARBPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttrib3dvARBPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttrib4bvARBPROC) (GLuint index, const GLbyte *v);
+typedef void (APIENTRY * glVertexAttrib4svARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * glVertexAttrib4ivARBPROC) (GLuint index, const GLint *v);
+typedef void (APIENTRY * glVertexAttrib4ubvARBPROC) (GLuint index, const GLubyte *v);
+typedef void (APIENTRY * glVertexAttrib4usvARBPROC) (GLuint index, const GLushort *v);
+typedef void (APIENTRY * glVertexAttrib4uivARBPROC) (GLuint index, const GLuint *v);
+typedef void (APIENTRY * glVertexAttrib4fvARBPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttrib4dvARBPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttrib4NbvARBPROC) (GLuint index, const GLbyte *v);
+typedef void (APIENTRY * glVertexAttrib4NsvARBPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * glVertexAttrib4NivARBPROC) (GLuint index, const GLint *v);
+typedef void (APIENTRY * glVertexAttrib4NubvARBPROC) (GLuint index, const GLubyte *v);
+typedef void (APIENTRY * glVertexAttrib4NusvARBPROC) (GLuint index, const GLushort *v);
+typedef void (APIENTRY * glVertexAttrib4NuivARBPROC) (GLuint index, const GLuint *v);
+typedef void (APIENTRY * glVertexAttribPointerARBPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRY * glEnableVertexAttribArrayARBPROC) (GLuint index);
+typedef void (APIENTRY * glDisableVertexAttribArrayARBPROC) (GLuint index);
+typedef void (APIENTRY * glProgramStringARBPROC) (GLenum target, GLenum format, GLsizei len, const GLvoid *string); 
+typedef void (APIENTRY * glBindProgramARBPROC) (GLenum target, GLuint program);
+typedef void (APIENTRY * glDeleteProgramsARBPROC) (GLsizei n, const GLuint *programs);
+typedef void (APIENTRY * glGenProgramsARBPROC) (GLsizei n, GLuint *programs);
+typedef void (APIENTRY * glProgramEnvParameter4dARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * glProgramEnvParameter4dvARBPROC) (GLenum target, GLuint index, const GLdouble *params);
+typedef void (APIENTRY * glProgramEnvParameter4fARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * glProgramEnvParameter4fvARBPROC) (GLenum target, GLuint index, const GLfloat *params);
+typedef void (APIENTRY * glProgramLocalParameter4dARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * glProgramLocalParameter4dvARBPROC) (GLenum target, GLuint index, const GLdouble *params);
+typedef void (APIENTRY * glProgramLocalParameter4fARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * glProgramLocalParameter4fvARBPROC) (GLenum target, GLuint index, const GLfloat *params);
+typedef void (APIENTRY * glGetProgramEnvParameterdvARBPROC) (GLenum target, GLuint index, GLdouble *params);
+typedef void (APIENTRY * glGetProgramEnvParameterfvARBPROC) (GLenum target, GLuint index, GLfloat *params);
+typedef void (APIENTRY * glGetProgramLocalParameterdvARBPROC) (GLenum target, GLuint index, GLdouble *params);
+typedef void (APIENTRY * glGetProgramLocalParameterfvARBPROC) (GLenum target, GLuint index, GLfloat *params);
+typedef void (APIENTRY * glGetProgramivARBPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetProgramStringARBPROC) (GLenum target, GLenum pname, GLvoid *string);
+typedef void (APIENTRY * glGetVertexAttribdvARBPROC) (GLuint index, GLenum pname, GLdouble *params);
+typedef void (APIENTRY * glGetVertexAttribfvARBPROC) (GLuint index, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetVertexAttribivARBPROC) (GLuint index, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetVertexAttribPointervARBPROC) (GLuint index, GLenum pname, GLvoid **pointer);
+typedef GLboolean (APIENTRY * glIsProgramARBPROC) (GLuint program);
+
+extern GLEW_EXPORT glVertexAttrib1sARBPROC glVertexAttrib1sARB;
+extern GLEW_EXPORT glVertexAttrib1fARBPROC glVertexAttrib1fARB;
+extern GLEW_EXPORT glVertexAttrib1dARBPROC glVertexAttrib1dARB;
+extern GLEW_EXPORT glVertexAttrib2sARBPROC glVertexAttrib2sARB;
+extern GLEW_EXPORT glVertexAttrib2fARBPROC glVertexAttrib2fARB;
+extern GLEW_EXPORT glVertexAttrib2dARBPROC glVertexAttrib2dARB;
+extern GLEW_EXPORT glVertexAttrib3sARBPROC glVertexAttrib3sARB;
+extern GLEW_EXPORT glVertexAttrib3fARBPROC glVertexAttrib3fARB;
+extern GLEW_EXPORT glVertexAttrib3dARBPROC glVertexAttrib3dARB;
+extern GLEW_EXPORT glVertexAttrib4sARBPROC glVertexAttrib4sARB;
+extern GLEW_EXPORT glVertexAttrib4fARBPROC glVertexAttrib4fARB;
+extern GLEW_EXPORT glVertexAttrib4dARBPROC glVertexAttrib4dARB;
+extern GLEW_EXPORT glVertexAttrib4NubARBPROC glVertexAttrib4NubARB;
+extern GLEW_EXPORT glVertexAttrib1svARBPROC glVertexAttrib1svARB;
+extern GLEW_EXPORT glVertexAttrib1fvARBPROC glVertexAttrib1fvARB;
+extern GLEW_EXPORT glVertexAttrib1dvARBPROC glVertexAttrib1dvARB;
+extern GLEW_EXPORT glVertexAttrib2svARBPROC glVertexAttrib2svARB;
+extern GLEW_EXPORT glVertexAttrib2fvARBPROC glVertexAttrib2fvARB;
+extern GLEW_EXPORT glVertexAttrib2dvARBPROC glVertexAttrib2dvARB;
+extern GLEW_EXPORT glVertexAttrib3svARBPROC glVertexAttrib3svARB;
+extern GLEW_EXPORT glVertexAttrib3fvARBPROC glVertexAttrib3fvARB;
+extern GLEW_EXPORT glVertexAttrib3dvARBPROC glVertexAttrib3dvARB;
+extern GLEW_EXPORT glVertexAttrib4bvARBPROC glVertexAttrib4bvARB;
+extern GLEW_EXPORT glVertexAttrib4svARBPROC glVertexAttrib4svARB;
+extern GLEW_EXPORT glVertexAttrib4ivARBPROC glVertexAttrib4ivARB;
+extern GLEW_EXPORT glVertexAttrib4ubvARBPROC glVertexAttrib4ubvARB;
+extern GLEW_EXPORT glVertexAttrib4usvARBPROC glVertexAttrib4usvARB;
+extern GLEW_EXPORT glVertexAttrib4uivARBPROC glVertexAttrib4uivARB;
+extern GLEW_EXPORT glVertexAttrib4fvARBPROC glVertexAttrib4fvARB;
+extern GLEW_EXPORT glVertexAttrib4dvARBPROC glVertexAttrib4dvARB;
+extern GLEW_EXPORT glVertexAttrib4NbvARBPROC glVertexAttrib4NbvARB;
+extern GLEW_EXPORT glVertexAttrib4NsvARBPROC glVertexAttrib4NsvARB;
+extern GLEW_EXPORT glVertexAttrib4NivARBPROC glVertexAttrib4NivARB;
+extern GLEW_EXPORT glVertexAttrib4NubvARBPROC glVertexAttrib4NubvARB;
+extern GLEW_EXPORT glVertexAttrib4NusvARBPROC glVertexAttrib4NusvARB;
+extern GLEW_EXPORT glVertexAttrib4NuivARBPROC glVertexAttrib4NuivARB;
+extern GLEW_EXPORT glVertexAttribPointerARBPROC glVertexAttribPointerARB;
+extern GLEW_EXPORT glEnableVertexAttribArrayARBPROC glEnableVertexAttribArrayARB;
+extern GLEW_EXPORT glDisableVertexAttribArrayARBPROC glDisableVertexAttribArrayARB;
+extern GLEW_EXPORT glProgramStringARBPROC glProgramStringARB;
+extern GLEW_EXPORT glBindProgramARBPROC glBindProgramARB;
+extern GLEW_EXPORT glDeleteProgramsARBPROC glDeleteProgramsARB;
+extern GLEW_EXPORT glGenProgramsARBPROC glGenProgramsARB;
+extern GLEW_EXPORT glProgramEnvParameter4dARBPROC glProgramEnvParameter4dARB;
+extern GLEW_EXPORT glProgramEnvParameter4dvARBPROC glProgramEnvParameter4dvARB;
+extern GLEW_EXPORT glProgramEnvParameter4fARBPROC glProgramEnvParameter4fARB;
+extern GLEW_EXPORT glProgramEnvParameter4fvARBPROC glProgramEnvParameter4fvARB;
+extern GLEW_EXPORT glProgramLocalParameter4dARBPROC glProgramLocalParameter4dARB;
+extern GLEW_EXPORT glProgramLocalParameter4dvARBPROC glProgramLocalParameter4dvARB;
+extern GLEW_EXPORT glProgramLocalParameter4fARBPROC glProgramLocalParameter4fARB;
+extern GLEW_EXPORT glProgramLocalParameter4fvARBPROC glProgramLocalParameter4fvARB;
+extern GLEW_EXPORT glGetProgramEnvParameterdvARBPROC glGetProgramEnvParameterdvARB;
+extern GLEW_EXPORT glGetProgramEnvParameterfvARBPROC glGetProgramEnvParameterfvARB;
+extern GLEW_EXPORT glGetProgramLocalParameterdvARBPROC glGetProgramLocalParameterdvARB;
+extern GLEW_EXPORT glGetProgramLocalParameterfvARBPROC glGetProgramLocalParameterfvARB;
+extern GLEW_EXPORT glGetProgramivARBPROC glGetProgramivARB;
+extern GLEW_EXPORT glGetProgramStringARBPROC glGetProgramStringARB;
+extern GLEW_EXPORT glGetVertexAttribdvARBPROC glGetVertexAttribdvARB;
+extern GLEW_EXPORT glGetVertexAttribfvARBPROC glGetVertexAttribfvARB;
+extern GLEW_EXPORT glGetVertexAttribivARBPROC glGetVertexAttribivARB;
+extern GLEW_EXPORT glGetVertexAttribPointervARBPROC glGetVertexAttribPointervARB;
+extern GLEW_EXPORT glIsProgramARBPROC glIsProgramARB;
+
+#endif /* GL_ARB_vertex_program */
+
+/* ---------------------------- ARB_window_pos ---------------------------- */
+
+#ifdef GL_ARB_window_pos
+
+typedef void (APIENTRY * glWindowPos2dARBPROC) (GLdouble x, GLdouble y);
+typedef void (APIENTRY * glWindowPos2fARBPROC) (GLfloat x, GLfloat y);
+typedef void (APIENTRY * glWindowPos2iARBPROC) (GLint x, GLint y);
+typedef void (APIENTRY * glWindowPos2sARBPROC) (GLshort x, GLshort y);
+typedef void (APIENTRY * glWindowPos2dvARBPROC) (const GLdouble *p);
+typedef void (APIENTRY * glWindowPos2fvARBPROC) (const GLfloat *p);
+typedef void (APIENTRY * glWindowPos2ivARBPROC) (const GLint *p);
+typedef void (APIENTRY * glWindowPos2svARBPROC) (const GLshort *p);
+typedef void (APIENTRY * glWindowPos3dARBPROC) (GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRY * glWindowPos3fARBPROC) (GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * glWindowPos3iARBPROC) (GLint x, GLint y, GLint z);
+typedef void (APIENTRY * glWindowPos3sARBPROC) (GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY * glWindowPos3dvARBPROC) (const GLdouble *p);
+typedef void (APIENTRY * glWindowPos3fvARBPROC) (const GLfloat *p);
+typedef void (APIENTRY * glWindowPos3ivARBPROC) (const GLint *p);
+typedef void (APIENTRY * glWindowPos3svARBPROC) (const GLshort *p);
+
+extern GLEW_EXPORT glWindowPos2dARBPROC glWindowPos2dARB;
+extern GLEW_EXPORT glWindowPos2fARBPROC glWindowPos2fARB;
+extern GLEW_EXPORT glWindowPos2iARBPROC glWindowPos2iARB;
+extern GLEW_EXPORT glWindowPos2sARBPROC glWindowPos2sARB;
+extern GLEW_EXPORT glWindowPos2dvARBPROC glWindowPos2dvARB;
+extern GLEW_EXPORT glWindowPos2fvARBPROC glWindowPos2fvARB;
+extern GLEW_EXPORT glWindowPos2ivARBPROC glWindowPos2ivARB;
+extern GLEW_EXPORT glWindowPos2svARBPROC glWindowPos2svARB;
+extern GLEW_EXPORT glWindowPos3dARBPROC glWindowPos3dARB;
+extern GLEW_EXPORT glWindowPos3fARBPROC glWindowPos3fARB;
+extern GLEW_EXPORT glWindowPos3iARBPROC glWindowPos3iARB;
+extern GLEW_EXPORT glWindowPos3sARBPROC glWindowPos3sARB;
+extern GLEW_EXPORT glWindowPos3dvARBPROC glWindowPos3dvARB;
+extern GLEW_EXPORT glWindowPos3fvARBPROC glWindowPos3fvARB;
+extern GLEW_EXPORT glWindowPos3ivARBPROC glWindowPos3ivARB;
+extern GLEW_EXPORT glWindowPos3svARBPROC glWindowPos3svARB;
+
+#endif /* GL_ARB_window_pos */
+
+/* ------------------------------- EXT_abgr ------------------------------- */
+
+#ifdef GL_EXT_abgr
+
+#define GL_ABGR_EXT                                             0x8000
+
+#endif /* GL_EXT_abgr */
+
+/* ------------------------------- EXT_bgra ------------------------------- */
+
+#ifdef GL_EXT_bgra
+
+#define GL_BGR_EXT                                              0x80E0
+#define GL_BGRA_EXT                                             0x80E1
+
+#endif /* GL_EXT_bgra */
+
+/* --------------------------- EXT_blend_color ---------------------------- */
+
+#ifdef GL_EXT_blend_color
+
+#define GL_CONSTANT_COLOR_EXT                                   0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR_EXT                         0x8002
+#define GL_CONSTANT_ALPHA_EXT                                   0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA_EXT                         0x8004
+#define GL_BLEND_COLOR_EXT                                      0x8005
+
+typedef void (APIENTRY * glBlendColorEXTPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+
+extern GLEW_EXPORT glBlendColorEXTPROC glBlendColorEXT;
+
+#endif /* GL_EXT_blend_color */
+
+/* ------------------------ EXT_blend_func_separate ----------------------- */
+
+#ifdef GL_EXT_blend_func_separate
+
+#define GL_BLEND_DST_RGB_EXT                                    0x80C8
+#define GL_BLEND_SRC_RGB_EXT                                    0x80C9
+#define GL_BLEND_DST_ALPHA_EXT                                  0x80CA
+#define GL_BLEND_SRC_ALPHA_EXT                                  0x80CB
+
+typedef void (APIENTRY * glBlendFuncSeparateEXTPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+
+extern GLEW_EXPORT glBlendFuncSeparateEXTPROC glBlendFuncSeparateEXT;
+
+#endif /* GL_EXT_blend_func_separate */
+
+/* --------------------------- EXT_blend_minmax --------------------------- */
+
+#ifdef GL_EXT_blend_minmax
+
+#define GL_FUNC_ADD_EXT                                         0x8006
+#define GL_MIN_EXT                                              0x8007
+#define GL_MAX_EXT                                              0x8008
+#define GL_BLEND_EQUATION_EXT                                   0x8009
+
+typedef void (APIENTRY * glBlendEquationEXTPROC) (GLenum mode);
+
+extern GLEW_EXPORT glBlendEquationEXTPROC glBlendEquationEXT;
+
+#endif /* GL_EXT_blend_minmax */
+
+/* ------------------------- EXT_blend_subtract --------------------------- */
+
+#ifdef GL_EXT_blend_subtract
+
+#define GL_FUNC_SUBTRACT_EXT                                    0x800A
+#define GL_FUNC_REVERSE_SUBTRACT_EXT                            0x800B
+
+#endif /* GL_EXT_blend_subtract */
+
+/* -------------------------- EXT_clip_volume_hint ------------------------ */
+
+#ifdef GL_EXT_clip_volume_hint
+
+#define GL_CLIP_VOLUME_CLIPPING_HINT_EXT                        0x80F0
+
+#endif /* GL_EXT_clip_volume_hint */
+
+/* ----------------------- EXT_compiled_vertex_array ---------------------- */
+
+#ifdef GL_EXT_compiled_vertex_array
+
+#define GL_ARRAY_ELEMENT_LOCK_FIRST_EXT                         0x81A8
+#define GL_ARRAY_ELEMENT_LOCK_COUNT_EXT                         0x81A9
+
+typedef void (APIENTRY * glLockArraysEXTPROC) (GLint first, GLsizei count);
+typedef void (APIENTRY * glUnlockArraysEXTPROC) (void);
+
+extern GLEW_EXPORT glLockArraysEXTPROC glLockArraysEXT;
+extern GLEW_EXPORT glUnlockArraysEXTPROC glUnlockArraysEXT;
+
+#endif /* GL_EXT_compiled_vertex_array */
+
+/* ---------------------------- EXT_cull_vertex --------------------------- */
+
+#ifdef GL_EXT_cull_vertex
+
+typedef void (APIENTRY * glCullParameterfvEXTPROC) (GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glCullParameterdvEXTPROC) (GLenum pname, GLdouble *params);
+
+extern GLEW_EXPORT glCullParameterfvEXTPROC glCullParameterfvEXT;
+extern GLEW_EXPORT glCullParameterdvEXTPROC glCullParameterdvEXT;
+ 
+#define GL_CULL_VERTEX_EXT                                      0x81AA
+#define GL_CULL_VERTEX_EYE_POSITION_EXT                         0x81AB
+#define GL_CULL_VERTEX_OBJECT_POSITION_EXT                      0x81AC
+
+#endif /* GL_EXT_cull_vertex */
+
+/* ------------------------ EXT_draw_range_elements ----------------------- */
+
+#ifdef GL_EXT_draw_range_elements
+
+typedef void (APIENTRY * glDrawRangeElementsEXTPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
+
+extern GLEW_EXPORT glDrawRangeElementsEXTPROC glDrawRangeElementsEXT;
+
+#define GL_MAX_ELEMENTS_VERTICES_EXT                            0x80E8
+#define GL_MAX_ELEMENTS_INDICES_EXT                             0x80E9
+
+#endif /* GL_EXT_draw_range_elements */
+
+/* ----------------------------- EXT_fog_coord ---------------------------- */
+
+#ifdef GL_EXT_fog_coord
+
+#define GL_FOG_COORDINATE_SOURCE_EXT                            0x8450
+#define GL_FOG_COORDINATE_EXT                                   0x8451
+#define GL_FRAGMENT_DEPTH_EXT                                   0x8452
+#define GL_CURRENT_FOG_COORDINATE_EXT                           0x8453
+#define GL_FOG_COORDINATE_ARRAY_TYPE_EXT                        0x8454
+#define GL_FOG_COORDINATE_ARRAY_STRIDE_EXT                      0x8455
+#define GL_FOG_COORDINATE_ARRAY_POINTER_EXT                     0x8456
+#define GL_FOG_COORDINATE_ARRAY_EXT                             0x8457
+
+typedef void (APIENTRY * glFogCoordfEXTPROC) (GLfloat coord);
+typedef void (APIENTRY * glFogCoordfvEXTPROC) (const GLfloat *coord);
+typedef void (APIENTRY * glFogCoorddEXTPROC) (GLdouble coord);
+typedef void (APIENTRY * glFogCoorddvEXTPROC) (const GLdouble *coord);
+typedef void (APIENTRY * glFogCoordPointerEXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer);
+
+extern GLEW_EXPORT glFogCoordfEXTPROC glFogCoordfEXT;
+extern GLEW_EXPORT glFogCoordfvEXTPROC glFogCoordfvEXT;
+extern GLEW_EXPORT glFogCoorddEXTPROC glFogCoorddEXT;
+extern GLEW_EXPORT glFogCoorddvEXTPROC glFogCoorddvEXT;
+extern GLEW_EXPORT glFogCoordPointerEXTPROC glFogCoordPointerEXT;
+
+#endif /* GL_EXT_fog_coord */
+
+/* ------------------------- EXT_multi_draw_arrays ------------------------ */
+
+#ifdef GL_EXT_multi_draw_arrays
+
+typedef void (APIENTRY * glMultiDrawArraysEXTPROC) (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount);
+typedef void (APIENTRY * glMultiDrawElementsEXTPROC) (GLenum mode, GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount);
+
+extern GLEW_EXPORT glMultiDrawArraysEXTPROC glMultiDrawArraysEXT;
+extern GLEW_EXPORT glMultiDrawElementsEXTPROC glMultiDrawElementsEXT;
+
+#endif /* GL_EXT_multi_draw_arrays */
+
+/* --------------------------- EXT_packed_pixels -------------------------- */
+
+#ifdef GL_EXT_packed_pixels
+
+#define GL_UNSIGNED_BYTE_3_3_2_EXT                              0x8032
+#define GL_UNSIGNED_SHORT_4_4_4_4_EXT                           0x8033
+#define GL_UNSIGNED_SHORT_5_5_5_1_EXT                           0x8034
+#define GL_UNSIGNED_INT_8_8_8_8_EXT                             0x8035
+#define GL_UNSIGNED_INT_10_10_10_2_EXT                          0x8036
+
+#endif /* GL_EXT_packed_pixels */
+
+/* ------------------------- EXT_point_parameters ------------------------- */
+
+#ifdef GL_EXT_point_parameters
+
+#define GL_POINT_SIZE_MIN_EXT                                   0x8126
+#define GL_POINT_SIZE_MAX_EXT                                   0x8127
+#define GL_POINT_FADE_THRESHOLD_SIZE_EXT                        0x8128
+#define GL_DISTANCE_ATTENUATION_EXT                             0x8129
+
+typedef void (APIENTRY * glPointParameterfEXTPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * glPointParameterfvEXTPROC) (GLenum pname, const GLfloat *params);
+
+extern GLEW_EXPORT glPointParameterfEXTPROC glPointParameterfEXT;
+extern GLEW_EXPORT glPointParameterfvEXTPROC glPointParameterfvEXT;
+
+#endif /* GL_EXT_point_parameters */
+
+/* -------------------------- EXT_secondary_color ------------------------- */
+
+#ifdef GL_EXT_secondary_color
+
+#define GL_COLOR_SUM_EXT                                        0x8458
+#define GL_CURRENT_SECONDARY_COLOR_EXT                          0x8459
+#define GL_SECONDARY_COLOR_ARRAY_SIZE_EXT                       0x845A
+#define GL_SECONDARY_COLOR_ARRAY_TYPE_EXT                       0x845B
+#define GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT                     0x845C
+#define GL_SECONDARY_COLOR_ARRAY_POINTER_EXT                    0x845D
+#define GL_SECONDARY_COLOR_ARRAY_EXT                            0x845E
+
+typedef void (APIENTRY * glSecondaryColor3bEXTPROC) (GLbyte red, GLbyte green, GLbyte blue);
+typedef void (APIENTRY * glSecondaryColor3bvEXTPROC) (const GLbyte *v);
+typedef void (APIENTRY * glSecondaryColor3dEXTPROC) (GLdouble red, GLdouble green, GLdouble blue);
+typedef void (APIENTRY * glSecondaryColor3dvEXTPROC) (const GLdouble *v);
+typedef void (APIENTRY * glSecondaryColor3fEXTPROC) (GLfloat red, GLfloat green, GLfloat blue);
+typedef void (APIENTRY * glSecondaryColor3fvEXTPROC) (const GLfloat *v);
+typedef void (APIENTRY * glSecondaryColor3iEXTPROC) (GLint red, GLint green, GLint blue);
+typedef void (APIENTRY * glSecondaryColor3ivEXTPROC) (const GLint *v);
+typedef void (APIENTRY * glSecondaryColor3sEXTPROC) (GLshort red, GLshort green, GLshort blue);
+typedef void (APIENTRY * glSecondaryColor3svEXTPROC) (const GLshort *v);
+typedef void (APIENTRY * glSecondaryColor3ubEXTPROC) (GLubyte red, GLubyte green, GLubyte blue);
+typedef void (APIENTRY * glSecondaryColor3ubvEXTPROC) (const GLubyte *v);
+typedef void (APIENTRY * glSecondaryColor3uiEXTPROC) (GLuint red, GLuint green, GLuint blue);
+typedef void (APIENTRY * glSecondaryColor3uivEXTPROC) (const GLuint *v);
+typedef void (APIENTRY * glSecondaryColor3usEXTPROC) (GLushort red, GLushort green, GLushort blue);
+typedef void (APIENTRY * glSecondaryColor3usvEXTPROC) (const GLushort *v);
+typedef void (APIENTRY * glSecondaryColorPointerEXTPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer);
+
+extern GLEW_EXPORT glSecondaryColor3bEXTPROC glSecondaryColor3bEXT;
+extern GLEW_EXPORT glSecondaryColor3bvEXTPROC glSecondaryColor3bvEXT;
+extern GLEW_EXPORT glSecondaryColor3dEXTPROC glSecondaryColor3dEXT;
+extern GLEW_EXPORT glSecondaryColor3dvEXTPROC glSecondaryColor3dvEXT;
+extern GLEW_EXPORT glSecondaryColor3fEXTPROC glSecondaryColor3fEXT;
+extern GLEW_EXPORT glSecondaryColor3fvEXTPROC glSecondaryColor3fvEXT;
+extern GLEW_EXPORT glSecondaryColor3iEXTPROC glSecondaryColor3iEXT;
+extern GLEW_EXPORT glSecondaryColor3ivEXTPROC glSecondaryColor3ivEXT;
+extern GLEW_EXPORT glSecondaryColor3sEXTPROC glSecondaryColor3sEXT;
+extern GLEW_EXPORT glSecondaryColor3svEXTPROC glSecondaryColor3svEXT;
+extern GLEW_EXPORT glSecondaryColor3ubEXTPROC glSecondaryColor3ubEXT;
+extern GLEW_EXPORT glSecondaryColor3ubvEXTPROC glSecondaryColor3ubvEXT;
+extern GLEW_EXPORT glSecondaryColor3uiEXTPROC glSecondaryColor3uiEXT;
+extern GLEW_EXPORT glSecondaryColor3uivEXTPROC glSecondaryColor3uivEXT;
+extern GLEW_EXPORT glSecondaryColor3usEXTPROC glSecondaryColor3usEXT;
+extern GLEW_EXPORT glSecondaryColor3usvEXTPROC glSecondaryColor3usvEXT;
+extern GLEW_EXPORT glSecondaryColorPointerEXTPROC glSecondaryColorPointerEXT;
+
+#endif /* GL_EXT_secondary_color */
+
+/* ---------------------- EXT_separate_specular_color --------------------- */
+
+#ifdef GL_EXT_separate_specular_color
+
+#define GL_LIGHT_MODEL_COLOR_CONTROL_EXT                        0x81F8
+#define GL_SINGLE_COLOR_EXT                                     0x81F9
+#define GL_SEPARATE_SPECULAR_COLOR_EXT                          0x81FA
+
+#endif /* GL_EXT_separate_specular_color */
+
+/* --------------------------- EXT_shadow_funcs --------------------------- */
+
+/* ------------------------- EXT_stencil_two_side ------------------------- */
+
+#ifdef GL_EXT_stencil_two_side
+
+typedef void (APIENTRY * glActiveStencilFaceEXTPROC) (GLenum face);
+
+extern GLEW_EXPORT glActiveStencilFaceEXTPROC glActiveStencilFaceEXT;
+
+#define GL_STENCIL_TEST_TWO_SIDE_EXT                            0x8910
+#define GL_ACTIVE_STENCIL_FACE_EXT                              0x8911
+
+#endif /* GL_EXT_stencil_two_side */
+
+/* --------------------------- EXT_stencil_wrap --------------------------- */
+
+#ifdef GL_EXT_stencil_wrap
+
+#define GL_INCR_WRAP_EXT                                        0x8507
+#define GL_DECR_WRAP_EXT                                        0x8508
+
+#endif /* GL_EXT_stencil_wrap */
+
+/* --------------------- EXT_texture_compression_s3tc --------------------- */
+
+#ifdef GL_EXT_texture_compression_s3tc
+
+#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT                         0x83F0
+#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT                        0x83F1
+#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT                        0x83F2
+#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT                        0x83F3
+
+#endif /* GL_EXT_texture_compression_s3tc */
+
+/* ------------------------ EXT_texture_env_combine ----------------------- */
+
+#ifdef GL_EXT_texture_env_combine
+
+#define GL_COMBINE_EXT                                          0x8570
+#define GL_COMBINE_RGB_EXT                                      0x8571
+#define GL_COMBINE_ALPHA_EXT                                    0x8572
+#define GL_RGB_SCALE_EXT                                        0x8573
+#define GL_ADD_SIGNED_EXT                                       0x8574
+#define GL_INTERPOLATE_EXT                                      0x8575
+#define GL_CONSTANT_EXT                                         0x8576
+#define GL_PRIMARY_COLOR_EXT                                    0x8577
+#define GL_PREVIOUS_EXT                                         0x8578
+#define GL_SOURCE0_RGB_EXT                                      0x8580
+#define GL_SOURCE1_RGB_EXT                                      0x8581
+#define GL_SOURCE2_RGB_EXT                                      0x8582
+#define GL_SOURCE0_ALPHA_EXT                                    0x8588
+#define GL_SOURCE1_ALPHA_EXT                                    0x8589
+#define GL_SOURCE2_ALPHA_EXT                                    0x858A
+#define GL_OPERAND0_RGB_EXT                                     0x8590
+#define GL_OPERAND1_RGB_EXT                                     0x8591
+#define GL_OPERAND2_RGB_EXT                                     0x8592
+#define GL_OPERAND0_ALPHA_EXT                                   0x8598
+#define GL_OPERAND1_ALPHA_EXT                                   0x8599
+#define GL_OPERAND2_ALPHA_EXT                                   0x859A
+
+#endif /* GL_EXT_texture_env_combine */
+
+/* -------------------- EXT_texture_filter_anisotropic -------------------- */
+
+#ifdef GL_EXT_texture_filter_anisotropic
+
+#define GL_TEXTURE_MAX_ANISOTROPY_EXT                           0x84FE
+#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT                       0x84FF
+
+#endif /* GL_EXT_texture_filter_anisotropic */
+
+/* ------------------------- EXT_texture_lod_bias ------------------------- */
+
+#ifdef GL_EXT_texture_lod_bias
+
+#define GL_TEXTURE_FILTER_CONTROL_EXT                           0x8500
+#define GL_TEXTURE_LOD_BIAS_EXT                                 0x8501
+#define GL_MAX_TEXTURE_LOD_BIAS_EXT                             0x84FD
+
+#endif /* GL_EXT_texture_lod_bias */
+
+/* ------------------------- EXT_texture_rectangle ------------------------ */
+
+#ifdef GL_EXT_texture_rectangle
+
+#define GL_TEXTURE_RECTANGLE_EXT                                0x85B3
+#define GL_TEXTURE_BINDING_RECTANGLE_EXT                        0x85B4
+#define GL_PROXY_TEXTURE_RECTANGLE_EXT                          0x85B5
+#define GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT                       0x85B6
+
+#endif /* GL_EXT_texture_rectangle */
+
+/* --------------------------- EXT_vertex_shader -------------------------- */
+
+#ifdef GL_EXT_vertex_shader
+
+#define GL_VERTEX_SHADER_EXT                                    0x8780
+#define GL_VERTEX_SHADER_BINDING_EXT                            0x8781
+#define GL_OP_INDEX_EXT                                         0x8782
+#define GL_OP_NEGATE_EXT                                        0x8783
+#define GL_OP_DOT3_EXT                                          0x8784
+#define GL_OP_DOT4_EXT                                          0x8785
+#define GL_OP_MUL_EXT                                           0x8786
+#define GL_OP_ADD_EXT                                           0x8787
+#define GL_OP_MADD_EXT                                          0x8788
+#define GL_OP_FRAC_EXT                                          0x8789
+#define GL_OP_MAX_EXT                                           0x878A
+#define GL_OP_MIN_EXT                                           0x878B
+#define GL_OP_SET_GE_EXT                                        0x878C
+#define GL_OP_SET_LT_EXT                                        0x878D
+#define GL_OP_CLAMP_EXT                                         0x878E
+#define GL_OP_FLOOR_EXT                                         0x878F
+#define GL_OP_ROUND_EXT                                         0x8790
+#define GL_OP_EXP_BASE_2_EXT                                    0x8791
+#define GL_OP_LOG_BASE_2_EXT                                    0x8792
+#define GL_OP_POWER_EXT                                         0x8793
+#define GL_OP_RECIP_EXT                                         0x8794
+#define GL_OP_RECIP_SQRT_EXT                                    0x8795
+#define GL_OP_SUB_EXT                                           0x8796
+#define GL_OP_CROSS_PRODUCT_EXT                                 0x8797
+#define GL_OP_MULTIPLY_MATRIX_EXT                               0x8798
+#define GL_OP_MOV_EXT                                           0x8799
+#define GL_OUTPUT_VERTEX_EXT                                    0x879A
+#define GL_OUTPUT_COLOR0_EXT                                    0x879B
+#define GL_OUTPUT_COLOR1_EXT                                    0x879C
+#define GL_OUTPUT_TEXTURE_COORD0_EXT                            0x879D
+#define GL_OUTPUT_TEXTURE_COORD1_EXT                            0x879E
+#define GL_OUTPUT_TEXTURE_COORD2_EXT                            0x879F
+#define GL_OUTPUT_TEXTURE_COORD3_EXT                            0x87A0
+#define GL_OUTPUT_TEXTURE_COORD4_EXT                            0x87A1
+#define GL_OUTPUT_TEXTURE_COORD5_EXT                            0x87A2
+#define GL_OUTPUT_TEXTURE_COORD6_EXT                            0x87A3
+#define GL_OUTPUT_TEXTURE_COORD7_EXT                            0x87A4
+#define GL_OUTPUT_TEXTURE_COORD8_EXT                            0x87A5
+#define GL_OUTPUT_TEXTURE_COORD9_EXT                            0x87A6
+#define GL_OUTPUT_TEXTURE_COORD10_EXT                           0x87A7
+#define GL_OUTPUT_TEXTURE_COORD11_EXT                           0x87A8
+#define GL_OUTPUT_TEXTURE_COORD12_EXT                           0x87A9
+#define GL_OUTPUT_TEXTURE_COORD13_EXT                           0x87AA
+#define GL_OUTPUT_TEXTURE_COORD14_EXT                           0x87AB
+#define GL_OUTPUT_TEXTURE_COORD15_EXT                           0x87AC
+#define GL_OUTPUT_TEXTURE_COORD16_EXT                           0x87AD
+#define GL_OUTPUT_TEXTURE_COORD17_EXT                           0x87AE
+#define GL_OUTPUT_TEXTURE_COORD18_EXT                           0x87AF
+#define GL_OUTPUT_TEXTURE_COORD19_EXT                           0x87B0
+#define GL_OUTPUT_TEXTURE_COORD20_EXT                           0x87B1
+#define GL_OUTPUT_TEXTURE_COORD21_EXT                           0x87B2
+#define GL_OUTPUT_TEXTURE_COORD22_EXT                           0x87B3
+#define GL_OUTPUT_TEXTURE_COORD23_EXT                           0x87B4
+#define GL_OUTPUT_TEXTURE_COORD24_EXT                           0x87B5
+#define GL_OUTPUT_TEXTURE_COORD25_EXT                           0x87B6
+#define GL_OUTPUT_TEXTURE_COORD26_EXT                           0x87B7
+#define GL_OUTPUT_TEXTURE_COORD27_EXT                           0x87B8
+#define GL_OUTPUT_TEXTURE_COORD28_EXT                           0x87B9
+#define GL_OUTPUT_TEXTURE_COORD29_EXT                           0x87BA
+#define GL_OUTPUT_TEXTURE_COORD30_EXT                           0x87BB
+#define GL_OUTPUT_TEXTURE_COORD31_EXT                           0x87BC
+#define GL_OUTPUT_FOG_EXT                                       0x87BD
+#define GL_SCALAR_EXT                                           0x87BE
+#define GL_VECTOR_EXT                                           0x87BF
+#define GL_MATRIX_EXT                                           0x87C0
+#define GL_VARIANT_EXT                                          0x87C1
+#define GL_INVARIANT_EXT                                        0x87C2
+#define GL_LOCAL_CONSTANT_EXT                                   0x87C3
+#define GL_LOCAL_EXT                                            0x87C4
+#define GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT                   0x87C5
+#define GL_MAX_VERTEX_SHADER_VARIANTS_EXT                       0x87C6
+#define GL_MAX_VERTEX_SHADER_INVARIANTS_EXT                     0x87C7
+#define GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT                0x87C8
+#define GL_MAX_VERTEX_SHADER_LOCALS_EXT                         0x87C9
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT         0x87CA
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT             0x87CB
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT           0x87CC
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT      0x87CD
+#define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT               0x87CE
+#define GL_VERTEX_SHADER_INSTRUCTIONS_EXT                       0x87CF
+#define GL_VERTEX_SHADER_VARIANTS_EXT                           0x87D0
+#define GL_VERTEX_SHADER_INVARIANTS_EXT                         0x87D1
+#define GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT                    0x87D2
+#define GL_VERTEX_SHADER_LOCALS_EXT                             0x87D3
+#define GL_VERTEX_SHADER_OPTIMIZED_EXT                          0x87D4
+#define GL_X_EXT                                                0x87D5
+#define GL_Y_EXT                                                0x87D6
+#define GL_Z_EXT                                                0x87D7
+#define GL_W_EXT                                                0x87D8
+#define GL_NEGATIVE_X_EXT                                       0x87D9
+#define GL_NEGATIVE_Y_EXT                                       0x87DA
+#define GL_NEGATIVE_Z_EXT                                       0x87DB
+#define GL_NEGATIVE_W_EXT                                       0x87DC
+#define GL_ZERO_EXT                                             0x87DD
+#define GL_ONE_EXT                                              0x87DE
+#define GL_NEGATIVE_ONE_EXT                                     0x87DF
+#define GL_NORMALIZED_RANGE_EXT                                 0x87E0
+#define GL_FULL_RANGE_EXT                                       0x87E1
+#define GL_CURRENT_VERTEX_EXT                                   0x87E2
+#define GL_MVP_MATRIX_EXT                                       0x87E3
+#define GL_VARIANT_VALUE_EXT                                    0x87E4
+#define GL_VARIANT_DATATYPE_EXT                                 0x87E5
+#define GL_VARIANT_ARRAY_STRIDE_EXT                             0x87E6
+#define GL_VARIANT_ARRAY_TYPE_EXT                               0x87E7
+#define GL_VARIANT_ARRAY_EXT                                    0x87E8
+#define GL_VARIANT_ARRAY_POINTER_EXT                            0x87E9
+#define GL_INVARIANT_VALUE_EXT                                  0x87EA
+#define GL_INVARIANT_DATATYPE_EXT                               0x87EB
+#define GL_LOCAL_CONSTANT_VALUE_EXT                             0x87EC
+#define GL_LOCAL_CONSTANT_DATATYPE_EXT                          0x87ED
+
+typedef void (APIENTRY * glBeginVertexShaderEXTPROC) ();
+typedef void (APIENTRY * glEndVertexShaderEXTPROC) ();
+typedef void (APIENTRY * glBindVertexShaderEXTPROC) (GLuint id);
+typedef GLuint (APIENTRY * glGenVertexShadersEXTPROC) (GLuint range);
+typedef void (APIENTRY * glDeleteVertexShaderEXTPROC) (GLuint id);
+typedef void (APIENTRY * glShaderOp1EXTPROC) (GLenum op, GLuint res, GLuint arg1);
+typedef void (APIENTRY * glShaderOp2EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2);
+typedef void (APIENTRY * glShaderOp3EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3);
+typedef void (APIENTRY * glSwizzleEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
+typedef void (APIENTRY * glWriteMaskEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
+typedef void (APIENTRY * glInsertComponentEXTPROC) (GLuint res, GLuint src, GLuint num);
+typedef void (APIENTRY * glExtractComponentEXTPROC) (GLuint res, GLuint src, GLuint num);
+typedef GLuint (APIENTRY * glGenSymbolsEXTPROC) (GLenum dataType, GLenum storageType, GLenum range, GLuint components);
+typedef void (APIENTRY * glSetInvariantEXTPROC) (GLuint id, GLenum type, GLvoid *addr);
+typedef void (APIENTRY * glSetLocalConstantEXTPROC) (GLuint id, GLenum type, GLvoid *addr);
+typedef void (APIENTRY * glVariantbvEXTPROC) (GLuint id, GLbyte *addr);
+typedef void (APIENTRY * glVariantsvEXTPROC) (GLuint id, GLshort *addr);
+typedef void (APIENTRY * glVariantivEXTPROC) (GLuint id, GLint *addr);
+typedef void (APIENTRY * glVariantfvEXTPROC) (GLuint id, GLfloat *addr);
+typedef void (APIENTRY * glVariantdvEXTPROC) (GLuint id, GLdouble *addr);
+typedef void (APIENTRY * glVariantubvEXTPROC) (GLuint id, GLubyte *addr);
+typedef void (APIENTRY * glVariantusvEXTPROC) (GLuint id, GLushort *addr);
+typedef void (APIENTRY * glVariantuivEXTPROC) (GLuint id, GLuint *addr);
+typedef void (APIENTRY * glVariantPointerEXTPROC) (GLuint id, GLenum type, GLuint stride, GLvoid *addr);
+typedef void (APIENTRY * glEnableVariantClientStateEXTPROC) (GLuint id);
+typedef void (APIENTRY * glDisableVariantClientStateEXTPROC) (GLuint id);
+typedef GLuint (APIENTRY * glBindLightParameterEXTPROC) (GLenum light, GLenum value);
+typedef GLuint (APIENTRY * glBindMaterialParameterEXTPROC) (GLenum face, GLenum value);
+typedef GLuint (APIENTRY * glBindTexGenParameterEXTPROC) (GLenum unit, GLenum coord, GLenum value);
+typedef GLuint (APIENTRY * glBindTextureUnitParameterEXTPROC) (GLenum unit, GLenum value);
+typedef GLuint (APIENTRY * glBindParameterEXTPROC) (GLenum value);
+typedef GLboolean (APIENTRY * glIsVariantEnabledEXTPROC) (GLuint id, GLenum cap);
+typedef void (APIENTRY * glGetVariantBooleanvEXTPROC) (GLuint id, GLenum value, GLboolean *data);
+typedef void (APIENTRY * glGetVariantIntegervEXTPROC) (GLuint id, GLenum value, GLint *data);
+typedef void (APIENTRY * glGetVariantFloatvEXTPROC) (GLuint id, GLenum value, GLfloat *data);
+typedef void (APIENTRY * glGetVariantPointervEXTPROC) (GLuint id, GLenum value, GLvoid **data);
+typedef void (APIENTRY * glGetInvariantBooleanvEXTPROC) (GLuint id, GLenum value, GLboolean *data);
+typedef void (APIENTRY * glGetInvariantIntegervEXTPROC) (GLuint id, GLenum value, GLint *data);
+typedef void (APIENTRY * glGetInvariantFloatvEXTPROC) (GLuint id, GLenum value, GLfloat *data);
+typedef void (APIENTRY * glGetLocalConstantBooleanvEXTPROC) (GLuint id, GLenum value, GLboolean *data);
+typedef void (APIENTRY * glGetLocalConstantIntegervEXTPROC) (GLuint id, GLenum value, GLint *data);
+typedef void (APIENTRY * glGetLocalConstantFloatvEXTPROC) (GLuint id, GLenum value, GLfloat *data);
+
+extern GLEW_EXPORT glBeginVertexShaderEXTPROC glBeginVertexShaderEXT;
+extern GLEW_EXPORT glEndVertexShaderEXTPROC glEndVertexShaderEXT;
+extern GLEW_EXPORT glBindVertexShaderEXTPROC glBindVertexShaderEXT;
+extern GLEW_EXPORT glGenVertexShadersEXTPROC glGenVertexShadersEXT;
+extern GLEW_EXPORT glDeleteVertexShaderEXTPROC glDeleteVertexShaderEXT;
+extern GLEW_EXPORT glShaderOp1EXTPROC glShaderOp1EXT;
+extern GLEW_EXPORT glShaderOp2EXTPROC glShaderOp2EXT;
+extern GLEW_EXPORT glShaderOp3EXTPROC glShaderOp3EXT;
+extern GLEW_EXPORT glSwizzleEXTPROC glSwizzleEXT;
+extern GLEW_EXPORT glWriteMaskEXTPROC glWriteMaskEXT;
+extern GLEW_EXPORT glInsertComponentEXTPROC glInsertComponentEXT;
+extern GLEW_EXPORT glExtractComponentEXTPROC glExtractComponentEXT;
+extern GLEW_EXPORT glGenSymbolsEXTPROC glGenSymbolsEXT;
+extern GLEW_EXPORT glSetInvariantEXTPROC glSetInvariantEXT;
+extern GLEW_EXPORT glSetLocalConstantEXTPROC glSetLocalConstantEXT;
+extern GLEW_EXPORT glVariantbvEXTPROC glVariantbvEXT;
+extern GLEW_EXPORT glVariantsvEXTPROC glVariantsvEXT;
+extern GLEW_EXPORT glVariantivEXTPROC glVariantivEXT;
+extern GLEW_EXPORT glVariantfvEXTPROC glVariantfvEXT;
+extern GLEW_EXPORT glVariantdvEXTPROC glVariantdvEXT;
+extern GLEW_EXPORT glVariantubvEXTPROC glVariantubvEXT;
+extern GLEW_EXPORT glVariantusvEXTPROC glVariantusvEXT;
+extern GLEW_EXPORT glVariantuivEXTPROC glVariantuivEXT;
+extern GLEW_EXPORT glVariantPointerEXTPROC glVariantPointerEXT;
+extern GLEW_EXPORT glEnableVariantClientStateEXTPROC glEnableVariantClientStateEXT;
+extern GLEW_EXPORT glDisableVariantClientStateEXTPROC glDisableVariantClientStateEXT;
+extern GLEW_EXPORT glBindLightParameterEXTPROC glBindLightParameterEXT;
+extern GLEW_EXPORT glBindMaterialParameterEXTPROC glBindMaterialParameterEXT;
+extern GLEW_EXPORT glBindTexGenParameterEXTPROC glBindTexGenParameterEXT;
+extern GLEW_EXPORT glBindTextureUnitParameterEXTPROC glBindTextureUnitParameterEXT;
+extern GLEW_EXPORT glBindParameterEXTPROC glBindParameterEXT;
+extern GLEW_EXPORT glIsVariantEnabledEXTPROC glIsVariantEnabledEXT;
+extern GLEW_EXPORT glGetVariantBooleanvEXTPROC glGetVariantBooleanvEXT;
+extern GLEW_EXPORT glGetVariantIntegervEXTPROC glGetVariantIntegervEXT;
+extern GLEW_EXPORT glGetVariantFloatvEXTPROC glGetVariantFloatvEXT;
+extern GLEW_EXPORT glGetVariantPointervEXTPROC glGetVariantPointervEXT;
+extern GLEW_EXPORT glGetInvariantBooleanvEXTPROC glGetInvariantBooleanvEXT;
+extern GLEW_EXPORT glGetInvariantIntegervEXTPROC glGetInvariantIntegervEXT;
+extern GLEW_EXPORT glGetInvariantFloatvEXTPROC glGetInvariantFloatvEXT;
+extern GLEW_EXPORT glGetLocalConstantBooleanvEXTPROC glGetLocalConstantBooleanvEXT;
+extern GLEW_EXPORT glGetLocalConstantIntegervEXTPROC glGetLocalConstantIntegervEXT;
+extern GLEW_EXPORT glGetLocalConstantFloatvEXTPROC glGetLocalConstantFloatvEXT;
+
+#endif /* GL_EXT_vertex_shader */
+
+/* ------------------------- EXT_vertex_weighting ------------------------- */
+
+#ifdef GL_EXT_vertex_weighting
+
+#define GL_MODELVIEW0_STACK_DEPTH_EXT                           0x0BA3  /* alias to GL_MODELVIEW_STACK_DEPTH */
+#define GL_MODELVIEW1_STACK_DEPTH_EXT                           0x8502
+#define GL_MODELVIEW0_MATRIX_EXT                                0x0BA6  /* alias to GL_MODELVIEW_MATRIX */
+#define GL_MODELVIEW1_MATRIX_EXT                                0x8506
+#define GL_VERTEX_WEIGHTING_EXT                                 0x8509
+#define GL_MODELVIEW0_EXT                                       0x1700  /* alias to GL_MODELVIEW */
+#define GL_MODELVIEW1_EXT                                       0x850A
+#define GL_CURRENT_VERTEX_WEIGHT_EXT                            0x850B
+#define GL_VERTEX_WEIGHT_ARRAY_EXT                              0x850C
+#define GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT                         0x850D
+#define GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT                         0x850E
+#define GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT                       0x850F
+#define GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT                      0x8510
+
+typedef void (APIENTRY * glVertexWeightfEXTPROC) (GLfloat weight);
+typedef void (APIENTRY * glVertexWeightfvEXTPROC) (const GLfloat *weight);
+typedef void (APIENTRY * glVertexWeightPointerEXTPROC) (GLsizei size, GLenum type, GLsizei stride, const GLvoid *pointer);
+
+extern GLEW_EXPORT glVertexWeightfEXTPROC glVertexWeightfEXT;
+extern GLEW_EXPORT glVertexWeightfvEXTPROC glVertexWeightfvEXT;
+extern GLEW_EXPORT glVertexWeightPointerEXTPROC glVertexWeightPointerEXT;
+
+#endif /* GL_EXT_vertex_weighting */
+
+/* ------------------------- SGIS_generate_mipmap ------------------------- */
+
+#ifdef GL_SGIS_generate_mipmap
+
+#define GL_GENERATE_MIPMAP_SGIS                                 0x8191
+#define GL_GENERATE_MIPMAP_HINT_SGIS                            0x8192
+
+#endif /* GL_SGIS_generate_mipmap */
+
+/* --------------------------- SGIS_texture_lod --------------------------- */
+
+#ifdef GL_SGIS_texture_lod
+
+#define GL_TEXTURE_MIN_LOD_SGIS                                 0x813A
+#define GL_TEXTURE_MAX_LOD_SGIS                                 0x813B
+#define GL_TEXTURE_BASE_LEVEL_SGIS                              0x813C
+#define GL_TEXTURE_MAX_LEVEL_SGIS                               0x813D
+
+#endif /* GL_SGIS_texture_lod */
+
+/* --------------------------- SGIX_depth_texture ------------------------- */
+
+#ifdef GL_SGIX_depth_texture
+
+#define GL_DEPTH_COMPONENT16_SGIX                               0x81A5
+#define GL_DEPTH_COMPONENT24_SGIX                               0x81A6
+#define GL_DEPTH_COMPONENT32_SGIX                               0x81A7
+
+#endif /* GL_SGIX_depth_texture */
+
+/* ------------------------------ SGIX_shadow ----------------------------- */
+
+#ifdef GL_SGIX_shadow
+
+#define GL_TEXTURE_COMPARE_SGIX                                 0x819A
+#define GL_TEXTURE_COMPARE_OPERATOR_SGIX                        0x819B
+#define GL_TEXTURE_LEQUAL_R_SGIX                                0x819C
+#define GL_TEXTURE_GEQUAL_R_SGIX                                0x819D
+
+#endif /* GL_SGIX_shadow */
+
+/* --------------------------- HP_occlusion_test -------------------------- */
+
+#ifdef GL_HP_occlusion_test
+
+#define GL_OCCLUSION_TEST_HP                                    0x8165
+#define GL_OCCLUSION_TEST_RESULT_HP                             0x8166
+
+#endif /* GL_HP_occlusion_test */
+
+/* -------------------------------- S3_s3tc ------------------------------- */
+
+#ifdef GL_S3_s3tc
+
+#define GL_RGB_S3TC                                             0x83A0
+#define GL_RGB4_S3TC                                            0x83A1
+#define GL_RGBA_S3TC                                            0x83A2
+#define GL_RGBA4_S3TC                                           0x83A3
+
+#endif /* S3_s3tc */
+
+/* ------------------------------ WIN_swap_hint --------------------------- */
+
+#ifdef GL_WIN_swap_hint
+
+typedef void (APIENTRY * glAddSwapHintRectWinPROC) (GLint x, GLint y, GLsizei width, GLsizei height);
+
+extern GLEW_EXPORT glAddSwapHintRectWinPROC glAddSwapHintRectWin;
+
+#endif /* GL_WIN_swap_hint */
+
+/* ---------------------------- ATI_draw_buffers -------------------------- */
+
+#ifdef GL_ATI_draw_buffers
+
+#define GL_MAX_DRAW_BUFFERS_ATI                                 0x8824
+#define GL_DRAW_BUFFER0_ATI                                     0x8825
+#define GL_DRAW_BUFFER1_ATI                                     0x8826
+#define GL_DRAW_BUFFER2_ATI                                     0x8827
+#define GL_DRAW_BUFFER3_ATI                                     0x8828
+#define GL_DRAW_BUFFER4_ATI                                     0x8829
+#define GL_DRAW_BUFFER5_ATI                                     0x882A
+#define GL_DRAW_BUFFER6_ATI                                     0x882B
+#define GL_DRAW_BUFFER7_ATI                                     0x882C
+#define GL_DRAW_BUFFER8_ATI                                     0x882D
+#define GL_DRAW_BUFFER9_ATI                                     0x882E
+#define GL_DRAW_BUFFER10_ATI                                    0x882F
+#define GL_DRAW_BUFFER11_ATI                                    0x8830
+#define GL_DRAW_BUFFER12_ATI                                    0x8831
+#define GL_DRAW_BUFFER13_ATI                                    0x8832
+#define GL_DRAW_BUFFER14_ATI                                    0x8833
+#define GL_DRAW_BUFFER15_ATI                                    0x8834
+
+typedef void (APIENTRY * glDrawBuffersPROC) (GLsizei n, const GLenum *bufs);
+
+extern GLEW_EXPORT glDrawBuffersPROC glDrawBuffers;
+
+#endif /* GL_ATI_draw_buffers */
+
+/* --------------------------- ATI_element_array -------------------------- */
+
+#ifdef GL_ATI_element_array
+
+#define GL_ELEMENT_ARRAY_ATI                                    0x8768
+#define GL_ELEMENT_ARRAY_TYPE_ATI                               0x8769
+#define GL_ELEMENT_ARRAY_POINTER_ATI                            0x876A
+
+typedef void (APIENTRY * glElementPointerATIPROC) (GLenum type, const GLvoid *pointer);
+typedef void (APIENTRY * glDrawElementArrayATIPROC) (GLenum mode, GLsizei count);
+typedef void (APIENTRY * glDrawRangeElementArrayATIPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count);
+
+extern GLEW_EXPORT glElementPointerATIPROC glElementPointerATI;
+extern GLEW_EXPORT glDrawElementArrayATIPROC glDrawElementArrayATI;
+extern GLEW_EXPORT glDrawRangeElementArrayATIPROC glDrawRangeElementArrayATI;
+
+#endif /* GL_ATI_element_array */
+
+/* -------------------------- ATI_envmap_bumpmap -------------------------- */
+
+#ifdef GL_ATI_envmap_bumpmap
+
+#define GL_BUMP_ROT_MATRIX_ATI                                  0x8775
+#define GL_BUMP_ROT_MATRIX_SIZE_ATI                             0x8776
+#define GL_BUMP_NUM_TEX_UNITS_ATI                               0x8777
+#define GL_BUMP_TEX_UNITS_ATI                                   0x8778
+#define GL_DUDV_ATI                                             0x8779
+#define GL_DU8DV8_ATI                                           0x877A
+#define GL_BUMP_ENVMAP_ATI                                      0x877B
+#define GL_BUMP_TARGET_ATI                                      0x877C
+
+typedef void (APIENTRY * glTexBumpParameterivATIPROC) (GLenum pname, GLint *param);
+typedef void (APIENTRY * glTexBumpParameterfvATIPROC) (GLenum pname, GLfloat *param);
+typedef void (APIENTRY * glGetTexBumpParameterivATIPROC) (GLenum pname, GLint *param);
+typedef void (APIENTRY * glGetTexBumpParameterfvATIPROC) (GLenum pname, GLfloat *param);
+
+extern GLEW_EXPORT glTexBumpParameterivATIPROC glTexBumpParameterivATI;
+extern GLEW_EXPORT glTexBumpParameterfvATIPROC glTexBumpParameterfvATI;
+extern GLEW_EXPORT glGetTexBumpParameterivATIPROC glGetTexBumpParameterivATI;
+extern GLEW_EXPORT glGetTexBumpParameterfvATIPROC glGetTexBumpParameterfvATI;
+
+#endif /* GL_ATI_envmap_bumpmap */
+
+/* ------------------------- ATI_fragment_shader ------------------------- */
+
+#ifdef GL_ATI_fragment_shader
+
+#define GL_FRAGMENT_SHADER_ATI                                  0x8920
+#define GL_REG_0_ATI                                            0x8921
+#define GL_REG_1_ATI                                            0x8922
+#define GL_REG_2_ATI                                            0x8923
+#define GL_REG_3_ATI                                            0x8924
+#define GL_REG_4_ATI                                            0x8925
+#define GL_REG_5_ATI                                            0x8926
+#define GL_REG_6_ATI                                            0x8927
+#define GL_REG_7_ATI                                            0x8928
+#define GL_REG_8_ATI                                            0x8929
+#define GL_REG_9_ATI                                            0x892A
+#define GL_REG_10_ATI                                           0x892B
+#define GL_REG_11_ATI                                           0x892C
+#define GL_REG_12_ATI                                           0x892D
+#define GL_REG_13_ATI                                           0x892E
+#define GL_REG_14_ATI                                           0x892F
+#define GL_REG_15_ATI                                           0x8930
+#define GL_REG_16_ATI                                           0x8931
+#define GL_REG_17_ATI                                           0x8932
+#define GL_REG_18_ATI                                           0x8933
+#define GL_REG_19_ATI                                           0x8934
+#define GL_REG_20_ATI                                           0x8935
+#define GL_REG_21_ATI                                           0x8936
+#define GL_REG_22_ATI                                           0x8937
+#define GL_REG_23_ATI                                           0x8938
+#define GL_REG_24_ATI                                           0x8939
+#define GL_REG_25_ATI                                           0x893A
+#define GL_REG_26_ATI                                           0x893B
+#define GL_REG_27_ATI                                           0x893C
+#define GL_REG_28_ATI                                           0x893D
+#define GL_REG_29_ATI                                           0x893E
+#define GL_REG_30_ATI                                           0x893F
+#define GL_REG_31_ATI                                           0x8940
+#define GL_CON_0_ATI                                            0x8941
+#define GL_CON_1_ATI                                            0x8942
+#define GL_CON_2_ATI                                            0x8943
+#define GL_CON_3_ATI                                            0x8944
+#define GL_CON_4_ATI                                            0x8945
+#define GL_CON_5_ATI                                            0x8946
+#define GL_CON_6_ATI                                            0x8947
+#define GL_CON_7_ATI                                            0x8948
+#define GL_CON_8_ATI                                            0x8949
+#define GL_CON_9_ATI                                            0x894A
+#define GL_CON_10_ATI                                           0x894B
+#define GL_CON_11_ATI                                           0x894C
+#define GL_CON_12_ATI                                           0x894D
+#define GL_CON_13_ATI                                           0x894E
+#define GL_CON_14_ATI                                           0x894F
+#define GL_CON_15_ATI                                           0x8950
+#define GL_CON_16_ATI                                           0x8951
+#define GL_CON_17_ATI                                           0x8952
+#define GL_CON_18_ATI                                           0x8953
+#define GL_CON_19_ATI                                           0x8954
+#define GL_CON_20_ATI                                           0x8955
+#define GL_CON_21_ATI                                           0x8956
+#define GL_CON_22_ATI                                           0x8957
+#define GL_CON_23_ATI                                           0x8958
+#define GL_CON_24_ATI                                           0x8959
+#define GL_CON_25_ATI                                           0x895A
+#define GL_CON_26_ATI                                           0x895B
+#define GL_CON_27_ATI                                           0x895C
+#define GL_CON_28_ATI                                           0x895D
+#define GL_CON_29_ATI                                           0x895E
+#define GL_CON_30_ATI                                           0x895F
+#define GL_CON_31_ATI                                           0x8960
+#define GL_MOV_ATI                                              0x8961
+#define GL_ADD_ATI                                              0x8963
+#define GL_MUL_ATI                                              0x8964
+#define GL_SUB_ATI                                              0x8965
+#define GL_DOT3_ATI                                             0x8966
+#define GL_DOT4_ATI                                             0x8967
+#define GL_MAD_ATI                                              0x8968
+#define GL_LERP_ATI                                             0x8969
+#define GL_CND_ATI                                              0x896A
+#define GL_CND0_ATI                                             0x896B
+#define GL_DOT2_ADD_ATI                                         0x896C
+#define GL_SECONDARY_INTERPOLATOR_ATI                           0x896D
+#define GL_NUM_FRAGMENT_REGISTERS_ATI                           0x896E
+#define GL_NUM_FRAGMENT_CONSTANTS_ATI                           0x896F
+#define GL_NUM_PASSES_ATI                                       0x8970
+#define GL_NUM_INSTRUCTIONS_PER_PASS_ATI                        0x8971
+#define GL_NUM_INSTRUCTIONS_TOTAL_ATI                           0x8972
+#define GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI                0x8973
+#define GL_NUM_LOOPBACK_COMPONENTS_ATI                          0x8974
+#define GL_COLOR_ALPHA_PAIRING_ATI                              0x8975
+#define GL_SWIZZLE_STR_ATI                                      0x8976
+#define GL_SWIZZLE_STQ_ATI                                      0x8977
+#define GL_SWIZZLE_STR_DR_ATI                                   0x8978
+#define GL_SWIZZLE_STQ_DQ_ATI                                   0x8979
+#define GL_SWIZZLE_STRQ_ATI                                     0x897A
+#define GL_SWIZZLE_STRQ_DQ_ATI                                  0x897B
+#define GL_RED_BIT_ATI                                          0x00000001
+#define GL_GREEN_BIT_ATI                                        0x00000002
+#define GL_BLUE_BIT_ATI                                         0x00000004
+#define GL_2X_BIT_ATI                                           0x00000001
+#define GL_4X_BIT_ATI                                           0x00000002
+#define GL_8X_BIT_ATI                                           0x00000004
+#define GL_HALF_BIT_ATI                                         0x00000008
+#define GL_QUARTER_BIT_ATI                                      0x00000010
+#define GL_EIGHTH_BIT_ATI                                       0x00000020
+#define GL_SATURATE_BIT_ATI                                     0x00000040
+#define GL_COMP_BIT_ATI                                         0x00000002
+#define GL_NEGATE_BIT_ATI                                       0x00000004
+#define GL_BIAS_BIT_ATI                                         0x00000008
+
+typedef GLuint (APIENTRY * glGenFragmentShadersATIPROC) (GLuint range);
+typedef void (APIENTRY * glBindFragmentShaderATIPROC) (GLuint id);
+typedef void (APIENTRY * glDeleteFragmentShaderATIPROC) (GLuint id);
+typedef void (APIENTRY * glBeginFragmentShaderATIPROC) (GLvoid);
+typedef void (APIENTRY * glEndFragmentShaderATIPROC) (GLvoid);
+typedef void (APIENTRY * glPassTexCoordATIPROC) (GLuint dst, GLuint coord, GLenum swizzle);
+typedef void (APIENTRY * glSampleMapATIPROC) (GLuint dst, GLuint interp, GLenum swizzle);
+typedef void (APIENTRY * glColorFragmentOp1ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
+typedef void (APIENTRY * glColorFragmentOp2ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
+typedef void (APIENTRY * glColorFragmentOp3ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod);
+typedef void (APIENTRY * glAlphaFragmentOp1ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
+typedef void (APIENTRY * glAlphaFragmentOp2ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
+typedef void (APIENTRY * glAlphaFragmentOp3ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod);
+typedef void (APIENTRY * glSetFragmentShaderConstantATIPROC) (GLuint dst, const GLfloat *value);
+
+extern GLEW_EXPORT glGenFragmentShadersATIPROC glGenFragmentShadersATI;
+extern GLEW_EXPORT glBindFragmentShaderATIPROC glBindFragmentShaderATI;
+extern GLEW_EXPORT glDeleteFragmentShaderATIPROC glDeleteFragmentShaderATI;
+extern GLEW_EXPORT glBeginFragmentShaderATIPROC glBeginFragmentShaderATI;
+extern GLEW_EXPORT glEndFragmentShaderATIPROC glEndFragmentShaderATI;
+extern GLEW_EXPORT glPassTexCoordATIPROC glPassTexCoordATI;
+extern GLEW_EXPORT glSampleMapATIPROC glSampleMapATI;
+extern GLEW_EXPORT glColorFragmentOp1ATIPROC glColorFragmentOp1ATI;
+extern GLEW_EXPORT glColorFragmentOp2ATIPROC glColorFragmentOp2ATI;
+extern GLEW_EXPORT glColorFragmentOp3ATIPROC glColorFragmentOp3ATI;
+extern GLEW_EXPORT glAlphaFragmentOp1ATIPROC glAlphaFragmentOp1ATI;
+extern GLEW_EXPORT glAlphaFragmentOp2ATIPROC glAlphaFragmentOp2ATI;
+extern GLEW_EXPORT glAlphaFragmentOp3ATIPROC glAlphaFragmentOp3ATI;
+extern GLEW_EXPORT glSetFragmentShaderConstantATIPROC glSetFragmentShaderConstantATI;
+
+#endif /* GL_ATI_fragment_shader */
+
+/* ------------------------- ATI_map_object_buffer ------------------------ */
+
+#ifdef GL_ATI_map_object_buffer
+
+typedef void *(APIENTRY * glMapObjectBufferATIPROC)(GLuint buffer);
+typedef void (APIENTRY * glUnmapObjectBufferATIPROC)(GLuint buffer);
+
+extern GLEW_EXPORT glMapObjectBufferATIPROC glMapObjectBufferATI;
+extern GLEW_EXPORT glUnmapObjectBufferATIPROC glUnmapObjectBufferATI;
+
+#endif /* GL_ATI_map_object_buffer */
+
+/* -------------------------- ATI_mapped_texture -------------------------- */
+
+#ifdef GL_ATI_mapped_texture
+
+#define GL_MAPPED_TEXTURE_PIXEL_STRIDE_ATI                      0x8820
+#define GL_MAPPED_TEXTURE_ROW_STRIDE_ATI                        0x8821
+#define GL_MAPPED_TEXTURE_LAYER_STRIDE_ATI                      0x8822
+
+typedef void (APIENTRY * glMapTexture3DPROC) (GLenum level, GLvoid **buffer);
+typedef void (APIENTRY * glUnmapTexture3DPROC) (void);
+
+extern GLEW_EXPORT glMapTexture3DPROC glMapTexture3D;
+extern GLEW_EXPORT glUnmapTexture3DPROC glUnmapTexture3D;
+
+#endif /* GL_ATI_mapped_texture */
+
+/* --------------------------- ATI_pn_triangles --------------------------- */
+
+#ifdef GL_ATI_pn_triangles
+
+#define GL_PN_TRIANGLES_ATI                                     0x87F0
+#define GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI               0x87F1
+#define GL_PN_TRIANGLES_POINT_MODE_ATI                          0x87F2
+#define GL_PN_TRIANGLES_NORMAL_MODE_ATI                         0x87F3
+#define GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI                   0x87F4
+#define GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI                   0x87F5
+#define GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI                    0x87F6
+#define GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI                  0x87F7
+#define GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI               0x87F8
+
+typedef void (APIENTRY * glPNTrianglesiATIPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * glPNTrianglesfATIPROC) (GLenum pname, GLfloat param);
+
+extern GLEW_EXPORT glPNTrianglesiATIPROC glPNTrianglesiATI;
+extern GLEW_EXPORT glPNTrianglesfATIPROC glPNTrianglesfATI;
+
+#endif /* GL_ATI_pn_triangles */
+
+/* -------------------------- ATI_point_cull_mode ------------------------- */
+
+#ifdef GL_ATI_point_cull_mode
+
+#define GL_POINT_CULL_MODE_ATI                                  0x60b3
+#define GL_POINT_CULL_CENTER_ATI                                0x60b4
+#define GL_POINT_CLIP_ATI                                       0x60b5
+
+#endif /* GL_ATI_point_cull_mode */
+
+/* -------------------------- ATI_separate_stencil ------------------------ */
+
+#ifdef GL_ATI_separate_stencil
+
+#define GL_STENCIL_BACK_FUNC_ATI                                0x8800
+#define GL_STENCIL_BACK_FAIL_ATI                                0x8801
+#define GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI                     0x8802
+#define GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI                     0x8803
+
+typedef void (APIENTRY * glStencilOpSeparateATIPROC) (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
+typedef void (APIENTRY * glStencilFuncSeparateATIPROC) (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
+
+extern GLEW_EXPORT glStencilOpSeparateATIPROC glStencilOpSeparateATI;
+extern GLEW_EXPORT glStencilFuncSeparateATIPROC glStencilFuncSeparateATI;
+
+#endif /* GL_ATI_separate_stencil */
+
+/* ----------------------- ATI_text_fragment_shader ----------------------- */
+
+#ifdef GL_ATI_text_fragment_shader
+
+#define GL_TEXT_FRAGMENT_SHADER_ATI                             0x8200
+
+#endif /* GL_ATI_text_fragment_shader */
+
+/* --------------------------- ATI_texture_float -------------------------- */
+
+#ifdef GL_ATI_texture_float
+
+#define GL_RGBA_FLOAT32_ATI                                     0x8814
+#define GL_RGB_FLOAT32_ATI                                      0x8815
+#define GL_ALPHA_FLOAT32_ATI                                    0x8816
+#define GL_INTENSITY_FLOAT32_ATI                                0x8817
+#define GL_LUMINANCE_FLOAT32_ATI                                0x8818
+#define GL_LUMINANCE_ALPHA_FLOAT32_ATI                          0x8819
+#define GL_RGBA_FLOAT16_ATI                                     0x881A
+#define GL_RGB_FLOAT16_ATI                                      0x881B
+#define GL_ALPHA_FLOAT16_ATI                                    0x881C
+#define GL_INTENSITY_FLOAT16_ATI                                0x881D
+#define GL_LUMINANCE_FLOAT16_ATI                                0x881E
+#define GL_LUMINANCE_ALPHA_FLOAT16_ATI                          0x881F
+
+#endif /* GL_ATI_texture_float */
+
+/* ------------------------ ATI_texture_mirror_once ----------------------- */
+
+#ifdef GL_ATI_texture_mirror_once
+
+#define GL_MIRROR_CLAMP_ATI                                     0x8742
+#define GL_MIRROR_CLAMP_TO_EDGE_ATI                             0x8743
+
+#endif
+
+/* ----------------------------- ATI_timestamp ---------------------------- */
+
+#ifdef GL_ATI_timestamp
+
+typedef void (APIENTRY * glNewTimeStampPROC) (GLvoid **);
+typedef void (APIENTRY * glDeleteTimeStampPROC) (GLvoid *);
+typedef void (APIENTRY * glSendTimeStampPROC) (GLvoid *);
+typedef void (APIENTRY * glWaitTimeStampPROC) (GLvoid *);
+
+extern GLEW_EXPORT glNewTimeStampPROC glNewTimeStamp;
+extern GLEW_EXPORT glDeleteTimeStampPROC glDeleteTimeStamp;
+extern GLEW_EXPORT glSendTimeStampPROC glSendTimeStamp;
+extern GLEW_EXPORT glWaitTimeStampPROC glWaitTimeStamp;
+
+#endif /* GL_ATI_timestamp */
+
+/* ------------------------ ATI_vertex_array_object ----------------------- */
+
+#ifdef GL_ATI_vertex_array_object
+
+#define GL_EXTERN GLEW_EXPORT_ATI                                           0x8760
+#define GL_DYNAMIC_ATI                                          0x8761
+#define GL_PRESERVE_ATI                                         0x8762
+#define GL_DISCARD_ATI                                          0x8763
+#define GL_OBJECT_BUFFER_SIZE_ATI                               0x8764
+#define GL_OBJECT_BUFFER_USAGE_ATI                              0x8765
+#define GL_ARRAY_OBJECT_BUFFER_ATI                              0x8766
+#define GL_ARRAY_OBJECT_OFFSET_ATI                              0x8767
+
+typedef GLuint (APIENTRY * glNewObjectBufferATIPROC) (GLsizei size, const GLvoid *pointer, GLenum usage);
+typedef GLboolean (APIENTRY * glIsObjectBufferATIPROC) (GLuint buffer);
+typedef void (APIENTRY * glUpdateObjectBufferATIPROC) (GLuint buffer, GLuint offset, GLsizei size, const GLvoid *pointer, GLenum preserve);
+typedef void (APIENTRY * glGetObjectBufferfvATIPROC) (GLuint buffer, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetObjectBufferivATIPROC) (GLuint buffer, GLenum pname, GLint *params);
+typedef void (APIENTRY * glFreeObjectBufferATIPROC) (GLuint buffer);
+typedef void (APIENTRY * glArrayObjectATIPROC) (GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
+typedef void (APIENTRY * glGetArrayObjectfvATIPROC) (GLenum array, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetArrayObjectivATIPROC) (GLenum array, GLenum pname, GLint *params);
+typedef void (APIENTRY * glVariantArrayObjectATIPROC) (GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
+typedef void (APIENTRY * glGetVariantArrayObjectfvATIPROC) (GLuint id, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetVariantArrayObjectivATIPROC) (GLuint id, GLenum pname, GLint *params);
+
+extern GLEW_EXPORT glNewObjectBufferATIPROC glNewObjectBufferATI;
+extern GLEW_EXPORT glIsObjectBufferATIPROC glIsObjectBufferATI;
+extern GLEW_EXPORT glUpdateObjectBufferATIPROC glUpdateObjectBufferATI;
+extern GLEW_EXPORT glGetObjectBufferfvATIPROC glGetObjectBufferfvATI;
+extern GLEW_EXPORT glGetObjectBufferivATIPROC glGetObjectBufferivATI;
+extern GLEW_EXPORT glFreeObjectBufferATIPROC glFreeObjectBufferATI;
+extern GLEW_EXPORT glArrayObjectATIPROC glArrayObjectATI;
+extern GLEW_EXPORT glGetArrayObjectfvATIPROC glGetArrayObjectfvATI;
+extern GLEW_EXPORT glGetArrayObjectivATIPROC glGetArrayObjectivATI;
+extern GLEW_EXPORT glVariantArrayObjectATIPROC glVariantArrayObjectATI;
+extern GLEW_EXPORT glGetVariantArrayObjectfvATIPROC glGetVariantArrayObjectfvATI;
+extern GLEW_EXPORT glGetVariantArrayObjectivATIPROC glGetVariantArrayObjectivATI;
+
+#endif /* GL_ATI_vertex_array_object */
+
+/* -------------------- ATI_vertex_attrib_array_object -------------------- */
+
+#ifdef GL_ATI_vertex_attrib_array_object
+
+typedef void (APIENTRY * glVertexAttribArratObjectATIPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset);
+typedef void (APIENTRY * glGetVertexAttribArratObjectfvATIPROC)(GLuint index, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetVertexAttrubAttatObjectivATIPROC)(GLuint index, GLenum pname, GLint *params);
+
+extern GLEW_EXPORT glVertexAttribArratObjectATIPROC glVertexAttribArratObjectATI;
+extern GLEW_EXPORT glGetVertexAttribArratObjectfvATIPROC glGetVertexAttribArratObjectfvATI;
+extern GLEW_EXPORT glGetVertexAttrubAttatObjectivATIPROC glGetVertexAttrubAttatObjectivATI;
+
+#endif /* GL_ATI_vertex_attrib_array_object */
+
+/* -------------------------- ATI_vertex_streams -------------------------- */
+
+#ifdef GL_ATI_vertex_streams 
+
+#define GL_MAX_VERTEX_STREAMS_ATI                               0x876B  
+#define GL_VERTEX_SOURCE_ATI                                    0x876C
+#define GL_VERTEX_STREAM0_ATI                                   0x876D
+#define GL_VERTEX_STREAM1_ATI                                   0x876E
+#define GL_VERTEX_STREAM2_ATI                                   0x876F
+#define GL_VERTEX_STREAM3_ATI                                   0x8770
+#define GL_VERTEX_STREAM4_ATI                                   0x8771
+#define GL_VERTEX_STREAM5_ATI                                   0x8772
+#define GL_VERTEX_STREAM6_ATI                                   0x8773
+#define GL_VERTEX_STREAM7_ATI                                   0x8774
+
+typedef void (APIENTRY * glClientActiveVertexStreamATIPROC) (GLenum stream);
+typedef void (APIENTRY * glVertexBlendEnviATIPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * glVertexBlendEnvfATIPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * glVertexStream2sATIPROC) (GLenum stream, GLshort x, GLshort y);
+typedef void (APIENTRY * glVertexStream2svATIPROC) (GLenum stream, const GLshort *v);
+typedef void (APIENTRY * glVertexStream2iATIPROC) (GLenum stream, GLint x, GLint y);
+typedef void (APIENTRY * glVertexStream2ivATIPROC) (GLenum stream, const GLint *v);
+typedef void (APIENTRY * glVertexStream2fATIPROC) (GLenum stream, GLfloat x, GLfloat y);
+typedef void (APIENTRY * glVertexStream2fvATIPROC) (GLenum stream, const GLfloat *v);
+typedef void (APIENTRY * glVertexStream2dATIPROC) (GLenum stream, GLdouble x, GLdouble y);
+typedef void (APIENTRY * glVertexStream2dvATIPROC) (GLenum stream, const GLdouble *v);
+typedef void (APIENTRY * glVertexStream3sATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY * glVertexStream3svATIPROC) (GLenum stream, const GLshort *v);
+typedef void (APIENTRY * glVertexStream3iATIPROC) (GLenum stream, GLint x, GLint y, GLint z);
+typedef void (APIENTRY * glVertexStream3ivATIPROC) (GLenum stream, const GLint *v);
+typedef void (APIENTRY * glVertexStream3fATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * glVertexStream3fvATIPROC) (GLenum stream, const GLfloat *v);
+typedef void (APIENTRY * glVertexStream3dATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRY * glVertexStream3dvATIPROC) (GLenum stream, const GLdouble *v);
+typedef void (APIENTRY * glVertexStream4sATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (APIENTRY * glVertexStream4svATIPROC) (GLenum stream, const GLshort *v);
+typedef void (APIENTRY * glVertexStream4iATIPROC) (GLenum stream, GLint x, GLint y, GLint z, GLint w);
+typedef void (APIENTRY * glVertexStream4ivATIPROC) (GLenum stream, const GLint *v);
+typedef void (APIENTRY * glVertexStream4fATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * glVertexStream4fvATIPROC) (GLenum stream, const GLfloat *v);
+typedef void (APIENTRY * glVertexStream4dATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * glVertexStream4dvATIPROC) (GLenum stream, const GLdouble *v);
+typedef void (APIENTRY * glNormalStream3bATIPROC) (GLenum stream, GLbyte x, GLbyte y, GLbyte z);
+typedef void (APIENTRY * glNormalStream3bvATIPROC) (GLenum stream, const GLbyte *v);
+typedef void (APIENTRY * glNormalStream3sATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY * glNormalStream3svATIPROC) (GLenum stream, const GLshort *v);
+typedef void (APIENTRY * glNormalStream3iATIPROC) (GLenum stream, GLint x, GLint y, GLint z);
+typedef void (APIENTRY * glNormalStream3ivATIPROC) (GLenum stream, const GLint *v);
+typedef void (APIENTRY * glNormalStream3fATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * glNormalStream3fvATIPROC) (GLenum stream, const GLfloat *v);
+typedef void (APIENTRY * glNormalStream3dATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRY * glNormalStream3dvATIPROC) (GLenum stream, const GLdouble *v);
+
+extern GLEW_EXPORT glClientActiveVertexStreamATIPROC glClientActiveVertexStreamATI;
+extern GLEW_EXPORT glVertexBlendEnviATIPROC glVertexBlendEnviATI;
+extern GLEW_EXPORT glVertexBlendEnvfATIPROC glVertexBlendEnvfATI;
+extern GLEW_EXPORT glVertexStream2sATIPROC glVertexStream2sATI;
+extern GLEW_EXPORT glVertexStream2svATIPROC glVertexStream2svATI;
+extern GLEW_EXPORT glVertexStream2iATIPROC glVertexStream2iATI;
+extern GLEW_EXPORT glVertexStream2ivATIPROC glVertexStream2ivATI;
+extern GLEW_EXPORT glVertexStream2fATIPROC glVertexStream2fATI;
+extern GLEW_EXPORT glVertexStream2fvATIPROC glVertexStream2fvATI;
+extern GLEW_EXPORT glVertexStream2dATIPROC glVertexStream2dATI;
+extern GLEW_EXPORT glVertexStream2dvATIPROC glVertexStream2dvATI;
+extern GLEW_EXPORT glVertexStream3sATIPROC glVertexStream3sATI;
+extern GLEW_EXPORT glVertexStream3svATIPROC glVertexStream3svATI;
+extern GLEW_EXPORT glVertexStream3iATIPROC glVertexStream3iATI;
+extern GLEW_EXPORT glVertexStream3ivATIPROC glVertexStream3ivATI;
+extern GLEW_EXPORT glVertexStream3fATIPROC glVertexStream3fATI;
+extern GLEW_EXPORT glVertexStream3fvATIPROC glVertexStream3fvATI;
+extern GLEW_EXPORT glVertexStream3dATIPROC glVertexStream3dATI;
+extern GLEW_EXPORT glVertexStream3dvATIPROC glVertexStream3dvATI;
+extern GLEW_EXPORT glVertexStream4sATIPROC glVertexStream4sATI;
+extern GLEW_EXPORT glVertexStream4svATIPROC glVertexStream4svATI;
+extern GLEW_EXPORT glVertexStream4iATIPROC glVertexStream4iATI;
+extern GLEW_EXPORT glVertexStream4ivATIPROC glVertexStream4ivATI;
+extern GLEW_EXPORT glVertexStream4fATIPROC glVertexStream4fATI;
+extern GLEW_EXPORT glVertexStream4fvATIPROC glVertexStream4fvATI;
+extern GLEW_EXPORT glVertexStream4dATIPROC glVertexStream4dATI;
+extern GLEW_EXPORT glVertexStream4dvATIPROC glVertexStream4dvATI;
+extern GLEW_EXPORT glNormalStream3bATIPROC glNormalStream3bATI;
+extern GLEW_EXPORT glNormalStream3bvATIPROC glNormalStream3bvATI;
+extern GLEW_EXPORT glNormalStream3sATIPROC glNormalStream3sATI;
+extern GLEW_EXPORT glNormalStream3svATIPROC glNormalStream3svATI;
+extern GLEW_EXPORT glNormalStream3iATIPROC glNormalStream3iATI;
+extern GLEW_EXPORT glNormalStream3ivATIPROC glNormalStream3ivATI;
+extern GLEW_EXPORT glNormalStream3fATIPROC glNormalStream3fATI;
+extern GLEW_EXPORT glNormalStream3fvATIPROC glNormalStream3fvATI;
+extern GLEW_EXPORT glNormalStream3dATIPROC glNormalStream3dATI;
+extern GLEW_EXPORT glNormalStream3dvATIPROC glNormalStream3dvATI;
+
+#endif /* GL_ATI_vertex_streams */
+
+/* -------------------------- ATIX_point_sprites -------------------------- */
+
+#ifdef GL_ATIX_point_sprites
+
+#define GL_TEXTURE_POINT_MODE_ATIX                              0x60b0
+#define	GL_TEXTURE_POINT_ONE_COORD_ATIX                         0x60b1
+#define	GL_TEXTURE_POINT_SPRITE_ATIX                            0x60b2
+#define GL_POINT_SPRITE_CULL_MODE_ATIX                          0x60b3
+#define GL_POINT_SPRITE_CULL_CENTER_ATIX                        0x60b4
+#define GL_POINT_SPRITE_CULL_CLIP_ATIX                          0x60b5
+
+#endif /* GL_ATIX_point_sprites */
+
+/* ----------------------- ATIX_texture_env_combine3 ---------------------- */
+
+#ifdef GL_ATIX_texture_env_combine3
+
+#define GL_MODULATE_ADD_ATIX                                    0x8744
+#define GL_MODULATE_SIGNED_ADD_ATIX                             0x8745
+#define GL_MODULATE_SUBTRACT_ATIX                               0x8746
+
+#endif /* GL_ATIX_texture_env_combine3 */
+
+/* ------------------------ ATIX_texture_env_route ------------------------ */
+
+#ifdef GL_ATIX_texture_env_route
+
+#define GL_SECONDARY_COLOR_ATIX                                 0x8747
+#define GL_TEXTURE_OUTPUT_RGB_ATIX                              0x8748
+#define GL_TEXTURE_OUTPUT_ALPHA_ATIX                            0x8749
+
+#endif /* GL_ATIX_texture_env_route */
+
+/* ----------------- ATIX_vertex_shader_output_point_size ----------------- */
+
+#ifdef GL_ATIX_vertex_shader_output_point_size
+
+#define GL_OUTPUT_POINT_SIZE_ATIX                               0x610E
+
+#endif /* GL_ATIX_vertex_shader_output_point_size */
+
+/* ---------------------------- NV_blend_square --------------------------- */
+
+/* ------------------------ NV_copy_depth_to_color ------------------------ */
+
+#ifdef GL_NV_copy_depth_to_color
+
+#define GL_DEPTH_STENCIL_TO_RGBA_NV                             0x886E
+#define GL_DEPTH_STENCIL_TO_BGRA_NV                             0x886F
+
+#endif /* GL_NV_copy_depth_to_color */
+
+/* ---------------------------- NV_depth_clamp ---------------------------- */
+
+#ifdef GL_NV_depth_clamp
+
+#define GL_DEPTH_CLAMP_NV                                       0x864F
+
+#endif /* GL_NV_depth_clamp */
+
+/* --------------------------- NV_element_array --------------------------- */
+
+#ifdef GL_NV_element_array
+
+#define GL_ELEMENT_ARRAY_TYPE_NV                                0x8769
+#define GL_ELEMENT_ARRAY_POINTER_NV                             0x876A
+
+typedef void (APIENTRY * glElementPointerNVPROC) (GLenum type, const GLvoid *pointer);
+typedef void (APIENTRY * glDrawElementArrayNVPROC) (GLenum mode, GLint first, GLsizei count);
+typedef void (APIENTRY * glDrawRangeElementArrayNVPROC) (GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count);
+typedef void (APIENTRY * glMultiDrawElementArrayNVPROC) (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount);
+typedef void (APIENTRY * glMultiDrawRangeElementArrayNVPROC) (GLenum mode, GLuint start, GLuint end, const GLint *first, const GLsizei *count, GLsizei primcount);
+
+extern GLEW_EXPORT glElementPointerNVPROC glElementPointerNV;
+extern GLEW_EXPORT glDrawElementArrayNVPROC glDrawElementArrayNV;
+extern GLEW_EXPORT glDrawRangeElementArrayNVPROC glDrawRangeElementArrayNV;
+extern GLEW_EXPORT glMultiDrawElementArrayNVPROC glMultiDrawElementArrayNV;
+extern GLEW_EXPORT glMultiDrawRangeElementArrayNVPROC glMultiDrawRangeElementArrayNV;
+
+#endif /* GL_NV_element_array */
+
+/* ----------------------------- NV_evaluators ---------------------------- */
+
+#ifdef GL_NV_evaluators
+
+#define GL_EVAL_2D_NV                                           0x86C0
+#define GL_EVAL_TRIANGULAR_2D_NV                                0x86C1
+#define GL_MAP_TESSELLATION_NV                                  0x86C2
+#define GL_MAP_ATTRIB_U_ORDER_NV                                0x86C3
+#define GL_MAP_ATTRIB_V_ORDER_NV                                0x86C4
+#define GL_EVAL_FRACTIONAL_TESSELLATION_NV                      0x86C5
+#define GL_EVAL_VERTEX_ATTRIB0_NV                               0x86C6
+#define GL_EVAL_VERTEX_ATTRIB1_NV                               0x86C7
+#define GL_EVAL_VERTEX_ATTRIB2_NV                               0x86C8
+#define GL_EVAL_VERTEX_ATTRIB3_NV                               0x86C9
+#define GL_EVAL_VERTEX_ATTRIB4_NV                               0x86CA
+#define GL_EVAL_VERTEX_ATTRIB5_NV                               0x86CB
+#define GL_EVAL_VERTEX_ATTRIB6_NV                               0x86CC
+#define GL_EVAL_VERTEX_ATTRIB7_NV                               0x86CD
+#define GL_EVAL_VERTEX_ATTRIB8_NV                               0x86CE
+#define GL_EVAL_VERTEX_ATTRIB9_NV                               0x86CF
+#define GL_EVAL_VERTEX_ATTRIB10_NV                              0x86D0
+#define GL_EVAL_VERTEX_ATTRIB11_NV                              0x86D1
+#define GL_EVAL_VERTEX_ATTRIB12_NV                              0x86D2
+#define GL_EVAL_VERTEX_ATTRIB13_NV                              0x86D3
+#define GL_EVAL_VERTEX_ATTRIB14_NV                              0x86D4
+#define GL_EVAL_VERTEX_ATTRIB15_NV                              0x86D5
+#define GL_MAX_MAP_TESSELLATION_NV                              0x86D6
+#define GL_MAX_RATIONAL_EVAL_ORDER_NV                           0x86D7
+
+typedef void (APIENTRY * glMapControlPointsNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid *points);
+typedef void (APIENTRY * glMapParameterivNVPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRY * glMapParameterfvNVPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * glGetMapControlPointsNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, GLvoid *points);
+typedef void (APIENTRY * glGetMapParameterivNVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetMapParameterfvNVPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetMapAttribParameterivNVPROC) (GLenum target, GLuint index, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetMapAttribParameterfvNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glEvalMapsNVPROC) (GLenum target, GLenum mode);
+
+extern GLEW_EXPORT glMapControlPointsNVPROC glMapControlPointsNV;
+extern GLEW_EXPORT glMapParameterivNVPROC glMapParameterivNV;
+extern GLEW_EXPORT glMapParameterfvNVPROC glMapParameterfvNV;
+extern GLEW_EXPORT glGetMapControlPointsNVPROC glGetMapControlPointsNV;
+extern GLEW_EXPORT glGetMapParameterivNVPROC glGetMapParameterivNV;
+extern GLEW_EXPORT glGetMapParameterfvNVPROC glGetMapParameterfvNV;
+extern GLEW_EXPORT glGetMapAttribParameterivNVPROC glGetMapAttribParameterivNV;
+extern GLEW_EXPORT glGetMapAttribParameterfvNVPROC glGetMapAttribParameterfvNV;
+extern GLEW_EXPORT glEvalMapsNVPROC glEvalMapsNV;
+
+#endif /* GL_NV_evaluators */
+
+/* ------------------------------- NV_fence ------------------------------- */
+
+#ifdef GL_NV_fence
+
+#define GL_ALL_COMPLETED_NV                                     0x84F2
+#define GL_FENCE_STATUS_NV                                      0x84F3
+#define GL_FENCE_CONDITION_NV                                   0x84F4
+
+typedef void (APIENTRY * glGenFencesNVPROC) (GLsizei n, GLuint *fences);
+typedef void (APIENTRY * glDeleteFencesNVPROC) (GLsizei n, const GLuint *fences);
+typedef void (APIENTRY * glSetFenceNVPROC) (GLuint fence, GLenum condition);
+typedef GLboolean (APIENTRY * glTestFenceNVPROC) (GLuint fence);
+typedef void (APIENTRY * glFinishFenceNVPROC) (GLuint fence);
+typedef GLboolean (APIENTRY * glIsFenceNVPROC) (GLuint fence);
+typedef void (APIENTRY * glGetFenceivNVPROC) (GLuint fence, GLenum pname, GLint *params);
+
+extern GLEW_EXPORT glGenFencesNVPROC glGenFencesNV;
+extern GLEW_EXPORT glDeleteFencesNVPROC glDeleteFencesNV;
+extern GLEW_EXPORT glSetFenceNVPROC glSetFenceNV;
+extern GLEW_EXPORT glTestFenceNVPROC glTestFenceNV;
+extern GLEW_EXPORT glFinishFenceNVPROC glFinishFenceNV;
+extern GLEW_EXPORT glIsFenceNVPROC glIsFenceNV;
+extern GLEW_EXPORT glGetFenceivNVPROC glGetFenceivNV;
+
+#endif /* GL_NV_fence */
+
+/* ---------------------------- NV_float_buffer --------------------------- */
+
+#ifdef GL_NV_float_buffer
+
+#define GL_FLOAT_R_NV                                           0x8880
+#define GL_FLOAT_RG_NV                                          0x8881
+#define GL_FLOAT_RGB_NV                                         0x8882
+#define GL_FLOAT_RGBA_NV                                        0x8883
+#define GL_FLOAT_R32_NV                                         0x8885
+#define GL_FLOAT_R16_NV                                         0x8884
+#define GL_FLOAT_R32_NV                                         0x8885
+#define GL_FLOAT_RG16_NV                                        0x8886
+#define GL_FLOAT_RG32_NV                                        0x8887
+#define GL_FLOAT_RGB16_NV                                       0x8888
+#define GL_FLOAT_RGB32_NV                                       0x8889
+#define GL_FLOAT_RGBA16_NV                                      0x888A
+#define GL_FLOAT_RGBA32_NV                                      0x888B
+#define GL_TEXTURE_FLOAT_COMPONENTS_NV                          0x888C
+#define GL_FLOAT_CLEAR_COLOR_VALUE_NV                           0x888D
+#define GL_FLOAT_RGBA_MODE_NV                                   0x888E
+
+#endif /* GL_NV_float_buffer */
+
+/* ---------------------------- NV_fog_distance --------------------------- */
+
+#ifdef GL_NV_fog_distance
+
+#define GL_FOG_DISTANCE_MODE_NV                                 0x855A
+#define GL_EYE_RADIAL_NV                                        0x855B
+#define GL_EYE_PLANE_ABSOLUTE_NV                                0x855C
+
+#endif /* GL_NV_fog_distance */
+
+/* -------------------------- NV_fragment_program ------------------------- */
+
+#ifdef GL_NV_fragment_program
+
+#define GL_FRAGMENT_PROGRAM_NV                                  0x8870
+#define GL_MAX_TEXTURE_COORDS_NV                                0x8871
+#define GL_MAX_TEXTURE_IMAGE_UNITS_NV                           0x8872
+#define GL_FRAGMENT_PROGRAM_BINDING_NV                          0x8873
+#define GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV             0x8868
+#define GL_PROGRAM_ERROR_STRING_NV                              0x8874
+
+typedef void (APIENTRY * glProgramNamedParameter4fNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * glProgramNamedParameter4dNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * glProgramNamedParameter4fvNVPROC) (GLuint id, GLsizei len, const GLubyte *name, const GLfloat v[]);
+typedef void (APIENTRY * glProgramNamedParameter4dvNVPROC) (GLuint id, GLsizei len, const GLubyte *name, const GLdouble v[]);
+typedef void (APIENTRY * glGetProgramNamedParameterfvNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat *params);
+typedef void (APIENTRY * glGetProgramNamedParameterdvNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLdouble *params);
+
+#ifndef GL_ARB_vertex_program
+typedef void (APIENTRY * glProgramLocalParameter4dARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * glProgramLocalParameter4dvARBPROC) (GLenum target, GLuint index, const GLdouble *params);
+typedef void (APIENTRY * glProgramLocalParameter4fARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * glProgramLocalParameter4fvARBPROC) (GLenum target, GLuint index, const GLfloat *params);
+typedef void (APIENTRY * glGetProgramLocalParameterdvARBPROC) (GLenum target, GLuint index, GLdouble *params);
+typedef void (APIENTRY * glGetProgramLocalParameterfvARBPROC) (GLenum target, GLuint index, GLfloat *params);
+#endif /* GL_ARB_vertex_program */
+
+extern GLEW_EXPORT glProgramNamedParameter4fNVPROC glProgramNamedParameter4fNV;
+extern GLEW_EXPORT glProgramNamedParameter4dNVPROC glProgramNamedParameter4dNV;
+extern GLEW_EXPORT glProgramNamedParameter4fvNVPROC glProgramNamedParameter4fvNV;
+extern GLEW_EXPORT glProgramNamedParameter4dvNVPROC glProgramNamedParameter4dvNV;
+extern GLEW_EXPORT glGetProgramNamedParameterfvNVPROC glGetProgramNamedParameterfvNV;
+extern GLEW_EXPORT glGetProgramNamedParameterdvNVPROC glGetProgramNamedParameterdvNV;
+
+#ifndef GL_ARB_vertex_program
+extern GLEW_EXPORT glProgramLocalParameter4dARBPROC glProgramLocalParameter4dARB;
+extern GLEW_EXPORT glProgramLocalParameter4dvARBPROC glProgramLocalParameter4dvARB;
+extern GLEW_EXPORT glProgramLocalParameter4fARBPROC glProgramLocalParameter4fARB;
+extern GLEW_EXPORT glProgramLocalParameter4fvARBPROC glProgramLocalParameter4fvARB;
+extern GLEW_EXPORT glGetProgramLocalParameterdvARBPROC glGetProgramLocalParameterdvARB;
+extern GLEW_EXPORT glGetProgramLocalParameterfvARBPROC glGetProgramLocalParameterfvARB;
+#endif /* GL_ARB_vertex_program */
+
+#endif /* GL_NV_fragment_program */
+
+/* ------------------------- NV_light_max_exponent ------------------------ */
+
+#ifdef GL_NV_light_max_exponent
+
+#define GL_MAX_SHININESS_NV                                     0x8504
+#define GL_MAX_SPOT_EXPONENT_NV                                 0x8505
+
+#endif /* GL_NV_light_max_exponent */
+
+/* ----------------------- NV_multisample_filter_hint --------------------- */
+
+#ifdef GL_NV_multisample_filter_hint
+
+#define GL_MULTISAMPLE_FILTER_HINT_NV                           0x8534
+
+#endif /* GL_NV_multisample_filter_hint */
+
+/* -------------------------- NV_occlusion_query -------------------------- */
+
+#ifdef GL_NV_occlusion_query
+
+#ifndef GL_HP_occlusion_test
+#define GL_OCCLUSION_TEST_HP                                    0x8165
+#define GL_OCCLUSION_TEST_RESULT_HP                             0x8166
+#endif /* GL_HP_occlusion_test */
+#define GL_PIXEL_COUNTER_BITS_NV                                0x8864
+#define GL_CURRENT_OCCLUSION_QUERY_ID_NV                        0x8865
+#define GL_PIXEL_COUNT_NV                                       0x8866
+#define GL_PIXEL_COUNT_AVAILABLE_NV                             0x8867
+
+typedef void (APIENTRY * glGenOcclusionQueriesNVPROC) (GLsizei n, GLuint *ids);
+typedef void (APIENTRY * glDeleteOcclusionQueriesNVPROC) (GLsizei n, const GLuint *ids);
+typedef GLboolean (APIENTRY * glIsOcclusionQueryNVPROC) (GLuint id);
+typedef void (APIENTRY * glBeginOcclusionQueryNVPROC) (GLuint id);
+typedef void (APIENTRY * glEndOcclusionQueryNVPROC) (void);
+typedef void (APIENTRY * glGetOcclusionQueryivNVPROC) (GLuint id, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetOcclusionQueryuivNVPROC) (GLuint id, GLenum pname, GLuint *params);
+
+extern GLEW_EXPORT glGenOcclusionQueriesNVPROC glGenOcclusionQueriesNV;
+extern GLEW_EXPORT glDeleteOcclusionQueriesNVPROC glDeleteOcclusionQueriesNV;
+extern GLEW_EXPORT glIsOcclusionQueryNVPROC glIsOcclusionQueryNV;
+extern GLEW_EXPORT glBeginOcclusionQueryNVPROC glBeginOcclusionQueryNV;
+extern GLEW_EXPORT glEndOcclusionQueryNVPROC glEndOcclusionQueryNV;
+extern GLEW_EXPORT glGetOcclusionQueryivNVPROC glGetOcclusionQueryivNV;
+extern GLEW_EXPORT glGetOcclusionQueryuivNVPROC glGetOcclusionQueryuivNV;
+
+#endif /* GL_NV_occlusion_query */
+
+/* ------------------------ NV_packed_depth_stencil ----------------------- */
+
+#ifdef GL_NV_packed_depth_stencil
+
+#define GL_DEPTH_STENCIL_NV                                     0x84F9
+#define GL_UNSIGNED_INT_24_8_NV                                 0x84FA
+
+#endif /* GL_NV_packed_depth_stencil */
+
+/* -------------------------- NV_pixel_data_range ------------------------- */
+
+#ifdef GL_NV_pixel_data_range
+
+#define WRITE_PIXEL_DATA_RANGE_NV                               0x8878
+#define READ_PIXEL_DATA_RANGE_NV                                0x8879
+#define WRITE_PIXEL_DATA_RANGE_LENGTH_NV                        0x887A
+#define READ_PIXEL_DATA_RANGE_LENGTH_NV                         0x887B
+#define WRITE_PIXEL_DATA_RANGE_POINTER_NV                       0x887C
+#define READ_PIXEL_DATA_RANGE_POINTER_NV                        0x887D
+
+typedef void (APIENTRY * glPixelDataRangeNVPROC) (GLenum target, GLsizei length, GLvoid *pointer);
+typedef void (APIENTRY * glFlushPixelDataRangeNVPROC) (GLenum target);
+
+extern GLEW_EXPORT glPixelDataRangeNVPROC glPixelDataRangeNV;
+extern GLEW_EXPORT glFlushPixelDataRangeNVPROC glFlushPixelDataRangeNV;
+
+#endif /* GL_NV_pixel_data_range */
+
+/* ---------------------------- NV_point_sprite --------------------------- */
+
+#ifdef GL_NV_point_sprite
+
+#define GL_POINT_SPRITE_NV                                      0x8861
+#define GL_COORD_REPLACE_NV                                     0x8862
+#define GL_POINT_SPRITE_R_MODE_NV                               0x8863
+
+typedef void (APIENTRY * glPointParameteriNVPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * glPointParameterivNVPROC) (GLenum pname, const GLint *params);
+
+extern GLEW_EXPORT glPointParameteriNVPROC glPointParameteriNV;
+extern GLEW_EXPORT glPointParameterivNVPROC glPointParameterivNV;
+
+#endif /* GL_NV_point_sprite */
+
+/* ------------------------- NV_primitive_restart ------------------------- */
+
+#ifdef GL_NV_primitive_restart
+
+#define GL_PRIMITIVE_RESTART_NV                                 0x8558
+#define GL_PRIMITIVE_RESTART_INDEX_NV                           0x8559
+
+typedef void (APIENTRY * glPrimitiveRestartNVPROC) ();
+typedef void (APIENTRY * glPrimitiveRestartIndexNVPROC) (GLuint index);
+
+extern GLEW_EXPORT glPrimitiveRestartNVPROC glPrimitiveRestartNV;
+extern GLEW_EXPORT glPrimitiveRestartIndexNVPROC glPrimitiveRestartIndexNV;
+
+#endif /* GL_NV_primitive_restart */
+
+/* ------------------------- NV_register_combiners ------------------------ */
+
+#ifdef GL_NV_register_combiners
+
+#define GL_REGISTER_COMBINERS_NV                                0x8522
+#define GL_COMBINER0_NV                                         0x8550
+#define GL_COMBINER1_NV                                         0x8551
+#define GL_COMBINER2_NV                                         0x8552
+#define GL_COMBINER3_NV                                         0x8553
+#define GL_COMBINER4_NV                                         0x8554
+#define GL_COMBINER5_NV                                         0x8555
+#define GL_COMBINER6_NV                                         0x8556
+#define GL_COMBINER7_NV                                         0x8557
+#define GL_VARIABLE_A_NV                                        0x8523
+#define GL_VARIABLE_B_NV                                        0x8524
+#define GL_VARIABLE_C_NV                                        0x8525
+#define GL_VARIABLE_D_NV                                        0x8526
+#define GL_VARIABLE_E_NV                                        0x8527
+#define GL_VARIABLE_F_NV                                        0x8528
+#define GL_VARIABLE_G_NV                                        0x8529
+#define GL_CONSTANT_COLOR0_NV                                   0x852A
+#define GL_CONSTANT_COLOR1_NV                                   0x852B
+#define GL_PRIMARY_COLOR_NV                                     0x852C
+#define GL_SECONDARY_COLOR_NV                                   0x852D
+#define GL_SPARE0_NV                                            0x852E
+#define GL_SPARE1_NV                                            0x852F
+#define GL_UNSIGNED_IDENTITY_NV                                 0x8536
+#define GL_UNSIGNED_INVERT_NV                                   0x8537
+#define GL_EXPAND_NORMAL_NV                                     0x8538
+#define GL_EXPAND_NEGATE_NV                                     0x8539
+#define GL_HALF_BIAS_NORMAL_NV                                  0x853A
+#define GL_HALF_BIAS_NEGATE_NV                                  0x853B
+#define GL_SIGNED_IDENTITY_NV                                   0x853C
+#define GL_SIGNED_NEGATE_NV                                     0x853D
+#define GL_E_TIMES_F_NV                                         0x8531
+#define GL_SPARE0_PLUS_SECONDARY_COLOR_NV                       0x8532
+#define GL_SCALE_BY_TWO_NV                                      0x853E
+#define GL_SCALE_BY_FOUR_NV                                     0x853F
+#define GL_SCALE_BY_ONE_HALF_NV                                 0x8540
+#define GL_BIAS_BY_NEGATIVE_ONE_HALF_NV                         0x8541
+#define GL_DISCARD_NV                                           0x8530
+#define GL_COMBINER_INPUT_NV                                    0x8542
+#define GL_COMBINER_MAPPING_NV                                  0x8543
+#define GL_COMBINER_COMPONENT_USAGE_NV                          0x8544
+#define GL_COMBINER_AB_DOT_PRODUCT_NV                           0x8545
+#define GL_COMBINER_CD_DOT_PRODUCT_NV                           0x8546
+#define GL_COMBINER_MUX_SUM_NV                                  0x8547
+#define GL_COMBINER_SCALE_NV                                    0x8548
+#define GL_COMBINER_BIAS_NV                                     0x8549
+#define GL_COMBINER_AB_OUTPUT_NV                                0x854A
+#define GL_COMBINER_CD_OUTPUT_NV                                0x854B
+#define GL_COMBINER_SUM_OUTPUT_NV                               0x854C
+#define GL_NUM_GENERAL_COMBINERS_NV                             0x854E
+#define GL_COLOR_SUM_CLAMP_NV                                   0x854F
+#define GL_MAX_GENERAL_COMBINERS_NV                             0x854D
+
+typedef void (APIENTRY * glCombinerParameterfvNVPROC) (GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * glCombinerParameterfNVPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * glCombinerParameterivNVPROC) (GLenum pname, const GLint *params);
+typedef void (APIENTRY * glCombinerParameteriNVPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * glCombinerInputNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
+typedef void (APIENTRY * glCombinerOutputNVPROC) (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum);
+typedef void (APIENTRY * glFinalCombinerInputNVPROC) (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
+typedef void (APIENTRY * glGetCombinerInputParameterfvNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetCombinerInputParameterivNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetCombinerOutputParameterfvNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetCombinerOutputParameterivNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetFinalCombinerInputParameterfvNVPROC) (GLenum variable, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetFinalCombinerInputParameterivNVPROC) (GLenum variable, GLenum pname, GLint *params);
+
+extern GLEW_EXPORT glCombinerParameterfvNVPROC glCombinerParameterfvNV;
+extern GLEW_EXPORT glCombinerParameterfNVPROC  glCombinerParameterfNV;
+extern GLEW_EXPORT glCombinerParameterivNVPROC glCombinerParameterivNV;
+extern GLEW_EXPORT glCombinerParameteriNVPROC glCombinerParameteriNV;
+extern GLEW_EXPORT glCombinerInputNVPROC glCombinerInputNV;
+extern GLEW_EXPORT glCombinerOutputNVPROC glCombinerOutputNV;
+extern GLEW_EXPORT glFinalCombinerInputNVPROC glFinalCombinerInputNV;
+extern GLEW_EXPORT glGetCombinerInputParameterfvNVPROC glGetCombinerInputParameterfvNV;
+extern GLEW_EXPORT glGetCombinerInputParameterivNVPROC glGetCombinerInputParameterivNV;
+extern GLEW_EXPORT glGetCombinerOutputParameterfvNVPROC glGetCombinerOutputParameterfvNV;
+extern GLEW_EXPORT glGetCombinerOutputParameterivNVPROC glGetCombinerOutputParameterivNV;
+extern GLEW_EXPORT glGetFinalCombinerInputParameterfvNVPROC glGetFinalCombinerInputParameterfvNV;
+extern GLEW_EXPORT glGetFinalCombinerInputParameterivNVPROC glGetFinalCombinerInputParameterivNV;
+
+#endif /* GL_NV_register_combiners */
+
+/* ------------------------ NV_register_combiners2 ------------------------ */
+
+#ifdef GL_NV_register_combiners2
+
+#define GL_PER_STAGE_CONSTANTS_NV                               0x8535
+
+typedef void (APIENTRY * glCombinerStageParameterfvNVPROC) (GLenum stage, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * glGetCombinerStageParameterfvNVPROC) (GLenum stage, GLenum pname, GLfloat *params);
+
+extern GLEW_EXPORT glCombinerStageParameterfvNVPROC glCombinerStageParameterfvNV;
+extern GLEW_EXPORT glGetCombinerStageParameterfvNVPROC glGetCombinerStageParameterfvNV;
+
+#endif /* GL_NV_register_combiners2 */
+
+/* ------------------------- NV_texgen_reflection ------------------------- */
+
+#ifdef GL_NV_texgen_reflection
+
+#define GL_NORMAL_MAP_NV                                        0x8511
+#define GL_REFLECTION_MAP_NV                                    0x8512
+
+#endif /* GL_NV_texgen_reflection */
+
+/* ---------------------- NV_texture_compression_vtc ---------------------- */
+
+/* ------------------------ NV_texture_env_combine4 ----------------------- */
+
+#ifdef GL_NV_texture_env_combine4
+
+#define GL_COMBINE4_NV                                          0x8503
+#define GL_SOURCE3_RGB_NV                                       0x8583
+#define GL_SOURCE3_ALPHA_NV                                     0x858B
+#define GL_OPERAND3_RGB_NV                                      0x8593
+#define GL_OPERAND3_ALPHA_NV                                    0x859B
+
+#endif /* GL_NV_texture_env_combine */
+
+/* ------------------------- NV_texture_rectangle ------------------------- */
+
+#ifdef GL_NV_texture_rectangle
+
+#define GL_TEXTURE_RECTANGLE_NV                                 0x84F5
+#define GL_TEXTURE_BINDING_RECTANGLE_NV                         0x84F6
+#define GL_PROXY_TEXTURE_RECTANGLE_NV                           0x84F7
+#define GL_MAX_RECTANGLE_TEXTURE_SIZE_NV                        0x84F8
+
+#endif /* GL_NV_texture_rectangle */
+
+/* --------------------------- NV_texture_shader -------------------------- */
+
+#ifdef GL_NV_texture_shader
+
+#define GL_TEXTURE_SHADER_NV                                    0x86DE
+#define GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV                 0x86D9
+#define GL_SHADER_OPERATION_NV                                  0x86DF
+#define GL_CULL_MODES_NV                                        0x86E0
+#define GL_OFFSET_TEXTURE_MATRIX_NV                             0x86E1
+#define GL_OFFSET_TEXTURE_SCALE_NV                              0x86E2
+#define GL_OFFSET_TEXTURE_BIAS_NV                               0x86E3
+#define GL_PREVIOUS_TEXTURE_INPUT_NV                            0x86E4
+#define GL_CONST_EYE_NV                                         0x86E5
+#define GL_SHADER_CONSISTENT_NV                                 0x86DD
+#define GL_PASS_THROUGH_NV                                      0x86E6
+#define GL_CULL_FRAGMENT_NV                                     0x86E7
+#define GL_OFFSET_TEXTURE_2D_NV                                 0x86E8
+#define GL_OFFSET_TEXTURE_RECTANGLE_NV                          0x864C
+#define GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV                    0x864D
+#define GL_DEPENDENT_AR_TEXTURE_2D_NV                           0x86E9
+#define GL_DEPENDENT_GB_TEXTURE_2D_NV                           0x86EA
+#define GL_DOT_PRODUCT_NV                                       0x86EC
+#define GL_DOT_PRODUCT_DEPTH_REPLACE_NV                         0x86ED
+#define GL_DOT_PRODUCT_TEXTURE_2D_NV                            0x86EE
+#define GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV                     0x864E
+#define GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV                      0x86F0
+#define GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV                      0x86F1
+#define GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV                      0x86F2
+#define GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV            0x86F3
+#define GL_HILO_NV                                              0x86F4
+#define GL_DSDT_NV                                              0x86F5
+#define GL_DSDT_MAG_NV                                          0x86F6
+#define GL_DSDT_MAG_VIB_NV                                      0x86F7
+#define GL_UNSIGNED_INT_S8_S8_8_8_NV                            0x86DA
+#define GL_UNSIGNED_INT_8_8_S8_S8_REV_NV                        0x86DB
+#define GL_SIGNED_RGBA_NV                                       0x86FB
+#define GL_SIGNED_RGBA8_NV                                      0x86FC
+#define GL_SIGNED_RGB_NV                                        0x86FE
+#define GL_SIGNED_RGB8_NV                                       0x86FF
+#define GL_SIGNED_LUMINANCE_NV                                  0x8701
+#define GL_SIGNED_LUMINANCE8_NV                                 0x8702
+#define GL_SIGNED_LUMINANCE_ALPHA_NV                            0x8703
+#define GL_SIGNED_LUMINANCE8_ALPHA8_NV                          0x8704
+#define GL_SIGNED_ALPHA_NV                                      0x8705
+#define GL_SIGNED_ALPHA8_NV                                     0x8706
+#define GL_SIGNED_INTENSITY_NV                                  0x8707
+#define GL_SIGNED_INTENSITY8_NV                                 0x8708
+#define GL_SIGNED_RGB_UNSIGNED_ALPHA_NV                         0x870C
+#define GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV                       0x870D
+#define GL_HILO16_NV                                            0x86F8
+#define GL_SIGNED_HILO_NV                                       0x86F9
+#define GL_SIGNED_HILO16_NV                                     0x86FA
+#define GL_DSDT8_NV                                             0x8709
+#define GL_DSDT8_MAG8_NV                                        0x870A
+#define GL_DSDT_MAG_INTENSITY_NV                                0x86DC
+#define GL_DSDT8_MAG8_INTENSITY8_NV                             0x870B
+#define GL_HI_SCALE_NV                                          0x870E
+#define GL_LO_SCALE_NV                                          0x870F
+#define GL_DS_SCALE_NV                                          0x8710
+#define GL_DT_SCALE_NV                                          0x8711
+#define GL_MAGNITUDE_SCALE_NV                                   0x8712
+#define GL_VIBRANCE_SCALE_NV                                    0x8713
+#define GL_HI_BIAS_NV                                           0x8714
+#define GL_LO_BIAS_NV                                           0x8715
+#define GL_DS_BIAS_NV                                           0x8716
+#define GL_DT_BIAS_NV                                           0x8717
+#define GL_MAGNITUDE_BIAS_NV                                    0x8718
+#define GL_VIBRANCE_BIAS_NV                                     0x8719
+#define GL_TEXTURE_BORDER_VALUES_NV                             0x871A
+#define GL_TEXTURE_HI_SIZE_NV                                   0x871B
+#define GL_TEXTURE_LO_SIZE_NV                                   0x871C
+#define GL_TEXTURE_DS_SIZE_NV                                   0x871D
+#define GL_TEXTURE_DT_SIZE_NV                                   0x871E
+#define GL_TEXTURE_MAG_SIZE_NV                                  0x871F
+
+#endif /* GL_NV_texture_shader */
+
+/* -------------------------- NV_texture_shader2 -------------------------- */
+
+#ifdef GL_NV_texture_shader2
+
+#define GL_DOT_PRODUCT_TEXTURE_3D_NV                            0x86EF
+#define GL_HILO_NV                                              0x86F4
+#define GL_DSDT_NV                                              0x86F5
+#define GL_DSDT_MAG_NV                                          0x86F6
+#define GL_DSDT_MAG_VIB_NV                                      0x86F7
+#define GL_UNSIGNED_INT_S8_S8_8_8_NV                            0x86DA
+#define GL_UNSIGNED_INT_8_8_S8_S8_REV_NV                        0x86DB
+#define GL_SIGNED_RGBA_NV                                       0x86FB
+#define GL_SIGNED_RGBA8_NV                                      0x86FC
+#define GL_SIGNED_RGB_NV                                        0x86FE
+#define GL_SIGNED_RGB8_NV                                       0x86FF
+#define GL_SIGNED_LUMINANCE_NV                                  0x8701
+#define GL_SIGNED_LUMINANCE8_NV                                 0x8702
+#define GL_SIGNED_LUMINANCE_ALPHA_NV                            0x8703
+#define GL_SIGNED_LUMINANCE8_ALPHA8_NV                          0x8704
+#define GL_SIGNED_ALPHA_NV                                      0x8705
+#define GL_SIGNED_ALPHA8_NV                                     0x8706
+#define GL_SIGNED_INTENSITY_NV                                  0x8707
+#define GL_SIGNED_INTENSITY8_NV                                 0x8708
+#define GL_SIGNED_RGB_UNSIGNED_ALPHA_NV                         0x870C
+#define GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV                       0x870D
+#define GL_HILO16_NV                                            0x86F8
+#define GL_SIGNED_HILO_NV                                       0x86F9
+#define GL_SIGNED_HILO16_NV                                     0x86FA
+#define GL_DSDT8_NV                                             0x8709
+#define GL_DSDT8_MAG8_NV                                        0x870A
+#define GL_DSDT_MAG_INTENSITY_NV                                0x86DC
+#define GL_DSDT8_MAG8_INTENSITY8_NV                             0x870B 
+
+#endif /* GL_NV_texture_shader2 */
+
+/* -------------------------- NV_texture_shader3 -------------------------- */
+
+#ifdef GL_NV_texture_shader3
+
+#define GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV                      0x8850
+#define GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV                0x8851
+#define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV               0x8852
+#define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV         0x8853
+#define GL_OFFSET_HILO_TEXTURE_2D_NV                            0x8854
+#define GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV                     0x8855
+#define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV                 0x8856
+#define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV          0x8857
+#define GL_DEPENDENT_HILO_TEXTURE_2D_NV                         0x8858
+#define GL_DEPENDENT_RGB_TEXTURE_3D_NV                          0x8859
+#define GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV                    0x885A
+#define GL_DOT_PRODUCT_PASS_THROUGH_NV                          0x885B
+#define GL_DOT_PRODUCT_TEXTURE_1D_NV                            0x885C
+#define GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV                  0x885D
+#define GL_HILO8_NV                                             0x885E
+#define GL_SIGNED_HILO8_NV                                      0x885F
+#define GL_FORCE_BLUE_TO_ONE_NV                                 0x8860
+
+#endif /* GL_NV_texture_shader3 */
+
+/* ------------------------- NV_vertex_array_range ------------------------ */
+
+#ifdef GL_NV_vertex_array_range
+
+#define GL_VERTEX_ARRAY_RANGE_NV                                0x851D
+#define GL_VERTEX_ARRAY_RANGE_LENGTH_NV                         0x851E
+#define GL_VERTEX_ARRAY_RANGE_VALID_NV                          0x851F
+#define GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV                    0x8520
+#define GL_VERTEX_ARRAY_RANGE_POINTER_NV                        0x8521
+
+typedef void (APIENTRY * glFlushVertexArrayRangeNVPROC) (void);
+typedef void (APIENTRY * glVertexArrayRangeNVPROC) (GLsizei size, const GLvoid *pointer);
+
+extern GLEW_EXPORT glFlushVertexArrayRangeNVPROC glFlushVertexArrayRangeNV;
+extern GLEW_EXPORT glVertexArrayRangeNVPROC glVertexArrayRangeNV;
+
+#endif /* GL_NV_vertex_array_range */
+
+/* ------------------------ NV_vertex_array_range2 ------------------------ */
+
+#ifdef GL_NV_vertex_array_range2
+
+#define GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV                  0x8533
+
+#endif /* GL_NV_vertex_array_range2 */
+
+/* --------------------------- NV_vertex_program -------------------------- */
+
+#ifdef GL_NV_vertex_program
+
+#define GL_VERTEX_PROGRAM_NV                                    0x8620
+#define GL_VERTEX_PROGRAM_POINT_SIZE_NV                         0x8642
+#define GL_VERTEX_PROGRAM_TWO_SIDE_NV                           0x8643
+#define GL_VERTEX_STATE_PROGRAM_NV                              0x8621
+#define GL_ATTRIB_ARRAY_SIZE_NV                                 0x8623
+#define GL_ATTRIB_ARRAY_STRIDE_NV                               0x8624
+#define GL_ATTRIB_ARRAY_TYPE_NV                                 0x8625
+#define GL_CURRENT_ATTRIB_NV                                    0x8626
+#define GL_PROGRAM_PARAMETER_NV                                 0x8644
+#define GL_ATTRIB_ARRAY_POINTER_NV                              0x8645
+#define GL_PROGRAM_TARGET_NV                                    0x8646
+#define GL_PROGRAM_LENGTH_NV                                    0x8627
+#define GL_PROGRAM_RESIDENT_NV                                  0x8647
+#define GL_PROGRAM_STRING_NV                                    0x8628
+#define GL_TRACK_MATRIX_NV                                      0x8648
+#define GL_TRACK_MATRIX_TRANSFORM_NV                            0x8649
+#define GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV                      0x862E
+#define GL_MAX_TRACK_MATRICES_NV                                0x862F
+#define GL_CURRENT_MATRIX_STACK_DEPTH_NV                        0x8640
+#define GL_CURRENT_MATRIX_NV                                    0x8641
+#define GL_VERTEX_PROGRAM_BINDING_NV                            0x864A
+#define GL_PROGRAM_ERROR_POSITION_NV                            0x864B
+#define GL_MODELVIEW_PROJECTION_NV                              0x8629
+#define GL_MATRIX0_NV                                           0x8630
+#define GL_MATRIX1_NV                                           0x8631
+#define GL_MATRIX2_NV                                           0x8632
+#define GL_MATRIX3_NV                                           0x8633
+#define GL_MATRIX4_NV                                           0x8634
+#define GL_MATRIX5_NV                                           0x8635
+#define GL_MATRIX6_NV                                           0x8636
+#define GL_MATRIX7_NV                                           0x8637
+#define GL_IDENTITY_NV                                          0x862A
+#define GL_INVERSE_NV                                           0x862B
+#define GL_TRANSPOSE_NV                                         0x862C
+#define GL_INVERSE_TRANSPOSE_NV                                 0x862D
+#define GL_VERTEX_ATTRIB_ARRAY0_NV                              0x8650
+#define GL_VERTEX_ATTRIB_ARRAY1_NV                              0x8651
+#define GL_VERTEX_ATTRIB_ARRAY2_NV                              0x8652
+#define GL_VERTEX_ATTRIB_ARRAY3_NV                              0x8653
+#define GL_VERTEX_ATTRIB_ARRAY4_NV                              0x8654
+#define GL_VERTEX_ATTRIB_ARRAY5_NV                              0x8655
+#define GL_VERTEX_ATTRIB_ARRAY6_NV                              0x8656
+#define GL_VERTEX_ATTRIB_ARRAY7_NV                              0x8657
+#define GL_VERTEX_ATTRIB_ARRAY8_NV                              0x8658
+#define GL_VERTEX_ATTRIB_ARRAY9_NV                              0x8659
+#define GL_VERTEX_ATTRIB_ARRAY10_NV                             0x865A
+#define GL_VERTEX_ATTRIB_ARRAY11_NV                             0x865B
+#define GL_VERTEX_ATTRIB_ARRAY12_NV                             0x865C
+#define GL_VERTEX_ATTRIB_ARRAY13_NV                             0x865D
+#define GL_VERTEX_ATTRIB_ARRAY14_NV                             0x865E
+#define GL_VERTEX_ATTRIB_ARRAY15_NV                             0x865F
+#define GL_MAP1_VERTEX_ATTRIB0_4_NV                             0x8660
+#define GL_MAP1_VERTEX_ATTRIB1_4_NV                             0x8661
+#define GL_MAP1_VERTEX_ATTRIB2_4_NV                             0x8662
+#define GL_MAP1_VERTEX_ATTRIB3_4_NV                             0x8663
+#define GL_MAP1_VERTEX_ATTRIB4_4_NV                             0x8664
+#define GL_MAP1_VERTEX_ATTRIB5_4_NV                             0x8665
+#define GL_MAP1_VERTEX_ATTRIB6_4_NV                             0x8666
+#define GL_MAP1_VERTEX_ATTRIB7_4_NV                             0x8667
+#define GL_MAP1_VERTEX_ATTRIB8_4_NV                             0x8668
+#define GL_MAP1_VERTEX_ATTRIB9_4_NV                             0x8669
+#define GL_MAP1_VERTEX_ATTRIB10_4_NV                            0x866A
+#define GL_MAP1_VERTEX_ATTRIB11_4_NV                            0x866B
+#define GL_MAP1_VERTEX_ATTRIB12_4_NV                            0x866C
+#define GL_MAP1_VERTEX_ATTRIB13_4_NV                            0x866D
+#define GL_MAP1_VERTEX_ATTRIB14_4_NV                            0x866E
+#define GL_MAP1_VERTEX_ATTRIB15_4_NV                            0x866F
+#define GL_MAP2_VERTEX_ATTRIB0_4_NV                             0x8670
+#define GL_MAP2_VERTEX_ATTRIB1_4_NV                             0x8671
+#define GL_MAP2_VERTEX_ATTRIB2_4_NV                             0x8672
+#define GL_MAP2_VERTEX_ATTRIB3_4_NV                             0x8673
+#define GL_MAP2_VERTEX_ATTRIB4_4_NV                             0x8674
+#define GL_MAP2_VERTEX_ATTRIB5_4_NV                             0x8675
+#define GL_MAP2_VERTEX_ATTRIB6_4_NV                             0x8676
+#define GL_MAP2_VERTEX_ATTRIB7_4_NV                             0x8677
+#define GL_MAP2_VERTEX_ATTRIB8_4_NV                             0x8678
+#define GL_MAP2_VERTEX_ATTRIB9_4_NV                             0x8679
+#define GL_MAP2_VERTEX_ATTRIB10_4_NV                            0x867A
+#define GL_MAP2_VERTEX_ATTRIB11_4_NV                            0x867B
+#define GL_MAP2_VERTEX_ATTRIB12_4_NV                            0x867C
+#define GL_MAP2_VERTEX_ATTRIB13_4_NV                            0x867D
+#define GL_MAP2_VERTEX_ATTRIB14_4_NV                            0x867E
+#define GL_MAP2_VERTEX_ATTRIB15_4_NV                            0x867F
+
+typedef void (APIENTRY * glBindProgramNVPROC) (GLenum target, GLuint id);
+typedef void (APIENTRY * glDeleteProgramsNVPROC) (GLsizei n, const GLuint *ids);
+typedef void (APIENTRY * glExecuteProgramNVPROC) (GLenum target, GLuint id, const GLfloat *params);
+typedef void (APIENTRY * glGenProgramsNVPROC) (GLsizei n, GLuint *ids);
+typedef GLboolean (APIENTRY * glAreProgramsResidentNVPROC) (GLsizei n, const GLuint *ids, GLboolean *residences);
+typedef void (APIENTRY * glRequestResidentProgramsNVPROC) (GLsizei n, GLuint *ids);
+typedef void (APIENTRY * glGetProgramParameterfvNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetProgramParameterdvNVPROC) (GLenum target, GLuint index, GLenum pname, GLdouble *params);
+typedef void (APIENTRY * glGetProgramivNVPROC) (GLuint id, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetProgramStringNVPROC) (GLuint id, GLenum pname, GLubyte *program);
+typedef void (APIENTRY * glGetTrackMatrixivNVPROC) (GLenum target, GLuint address, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetVertexAttribdvNVPROC) (GLuint index, GLenum pname, GLdouble *params);
+typedef void (APIENTRY * glGetVertexAttribfvNVPROC) (GLuint index, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * glGetVertexAttribivNVPROC) (GLuint index, GLenum pname, GLint *params);
+typedef void (APIENTRY * glGetVertexAttribPointervNVPROC) (GLuint index, GLenum pname, GLvoid **pointer);
+typedef GLboolean (APIENTRY * glIsProgramNVPROC) (GLuint id);
+typedef void (APIENTRY * glLoadProgramNVPROC) (GLenum target, GLuint id, GLsizei len, const GLubyte *program);
+typedef void (APIENTRY * glProgramParameter4fNVPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * glProgramParameter4dNVPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * glProgramParameter4dvNVPROC) (GLenum target, GLuint index, const GLdouble *params);
+typedef void (APIENTRY * glProgramParameter4fvNVPROC) (GLenum target, GLuint index, const GLfloat *params);
+typedef void (APIENTRY * glProgramParameters4dvNVPROC) (GLenum target, GLuint index, GLuint num, const GLdouble *params);
+typedef void (APIENTRY * glProgramParameters4fvNVPROC) (GLenum target, GLuint index, GLuint num, const GLfloat *params);
+typedef void (APIENTRY * glTrackMatrixNVPROC) (GLenum target, GLuint address, GLenum matrix, GLenum transform);
+typedef void (APIENTRY * glVertexAttribPointerNVPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRY * glVertexAttrib1sNVPROC) (GLuint index, GLshort x);
+typedef void (APIENTRY * glVertexAttrib1fNVPROC) (GLuint index, GLfloat x);
+typedef void (APIENTRY * glVertexAttrib1dNVPROC) (GLuint index, GLdouble x);
+typedef void (APIENTRY * glVertexAttrib2sNVPROC) (GLuint index, GLshort x, GLshort y);
+typedef void (APIENTRY * glVertexAttrib2fNVPROC) (GLuint index, GLfloat x, GLfloat y);
+typedef void (APIENTRY * glVertexAttrib2dNVPROC) (GLuint index, GLdouble x, GLdouble y);
+typedef void (APIENTRY * glVertexAttrib3sNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY * glVertexAttrib3fNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * glVertexAttrib3dNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRY * glVertexAttrib4sNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (APIENTRY * glVertexAttrib4fNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * glVertexAttrib4dNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * glVertexAttrib4ubNVPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+typedef void (APIENTRY * glVertexAttrib1svNVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * glVertexAttrib1fvNVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttrib1dvNVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttrib2svNVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * glVertexAttrib2fvNVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttrib2dvNVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttrib3svNVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * glVertexAttrib3fvNVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttrib3dvNVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttrib4svNVPROC) (GLuint index, const GLshort *v);
+typedef void (APIENTRY * glVertexAttrib4fvNVPROC) (GLuint index, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttrib4dvNVPROC) (GLuint index, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttrib4ubvNVPROC) (GLuint index, const GLubyte *v);
+typedef void (APIENTRY * glVertexAttribs1svNVPROC) (GLuint index, GLsizei n, const GLshort *v);
+typedef void (APIENTRY * glVertexAttribs1fvNVPROC) (GLuint index, GLsizei n, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttribs1dvNVPROC) (GLuint index, GLsizei n, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttribs2svNVPROC) (GLuint index, GLsizei n, const GLshort *v);
+typedef void (APIENTRY * glVertexAttribs2fvNVPROC) (GLuint index, GLsizei n, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttribs2dvNVPROC) (GLuint index, GLsizei n, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttribs3svNVPROC) (GLuint index, GLsizei n, const GLshort *v);
+typedef void (APIENTRY * glVertexAttribs3fvNVPROC) (GLuint index, GLsizei n, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttribs3dvNVPROC) (GLuint index, GLsizei n, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttribs4svNVPROC) (GLuint index, GLsizei n, const GLshort *v);
+typedef void (APIENTRY * glVertexAttribs4fvNVPROC) (GLuint index, GLsizei n, const GLfloat *v);
+typedef void (APIENTRY * glVertexAttribs4dvNVPROC) (GLuint index, GLsizei n, const GLdouble *v);
+typedef void (APIENTRY * glVertexAttribs4ubvNVPROC) (GLuint index, GLsizei n, const GLubyte *v);
+
+extern GLEW_EXPORT glBindProgramNVPROC glBindProgramNV;
+extern GLEW_EXPORT glDeleteProgramsNVPROC glDeleteProgramsNV;
+extern GLEW_EXPORT glExecuteProgramNVPROC glExecuteProgramNV;
+extern GLEW_EXPORT glGenProgramsNVPROC glGenProgramsNV;
+extern GLEW_EXPORT glAreProgramsResidentNVPROC glAreProgramsResidentNV;
+extern GLEW_EXPORT glRequestResidentProgramsNVPROC glRequestResidentProgramsNV;
+extern GLEW_EXPORT glGetProgramParameterfvNVPROC glGetProgramParameterfvNV;
+extern GLEW_EXPORT glGetProgramParameterdvNVPROC glGetProgramParameterdvNV;
+extern GLEW_EXPORT glGetProgramivNVPROC glGetProgramivNV;
+extern GLEW_EXPORT glGetProgramStringNVPROC glGetProgramStringNV;
+extern GLEW_EXPORT glGetTrackMatrixivNVPROC glGetTrackMatrixivNV;
+extern GLEW_EXPORT glGetVertexAttribdvNVPROC glGetVertexAttribdvNV;
+extern GLEW_EXPORT glGetVertexAttribfvNVPROC glGetVertexAttribfvNV;
+extern GLEW_EXPORT glGetVertexAttribivNVPROC glGetVertexAttribivNV;
+extern GLEW_EXPORT glGetVertexAttribPointervNVPROC glGetVertexAttribPointervNV;
+extern GLEW_EXPORT glIsProgramNVPROC glIsProgramNV;
+extern GLEW_EXPORT glLoadProgramNVPROC glLoadProgramNV;
+extern GLEW_EXPORT glProgramParameter4fNVPROC glProgramParameter4fNV;
+extern GLEW_EXPORT glProgramParameter4dNVPROC glProgramParameter4dNV;
+extern GLEW_EXPORT glProgramParameter4dvNVPROC glProgramParameter4dvNV;
+extern GLEW_EXPORT glProgramParameter4fvNVPROC glProgramParameter4fvNV;
+extern GLEW_EXPORT glProgramParameters4dvNVPROC glProgramParameters4dvNV;
+extern GLEW_EXPORT glProgramParameters4fvNVPROC glProgramParameters4fvNV;
+extern GLEW_EXPORT glTrackMatrixNVPROC glTrackMatrixNV;
+extern GLEW_EXPORT glVertexAttribPointerNVPROC glVertexAttribPointerNV;
+extern GLEW_EXPORT glVertexAttrib1sNVPROC glVertexAttrib1sNV;
+extern GLEW_EXPORT glVertexAttrib1fNVPROC glVertexAttrib1fNV;
+extern GLEW_EXPORT glVertexAttrib1dNVPROC glVertexAttrib1dNV;
+extern GLEW_EXPORT glVertexAttrib2sNVPROC glVertexAttrib2sNV;
+extern GLEW_EXPORT glVertexAttrib2fNVPROC glVertexAttrib2fNV;
+extern GLEW_EXPORT glVertexAttrib2dNVPROC glVertexAttrib2dNV;
+extern GLEW_EXPORT glVertexAttrib3sNVPROC glVertexAttrib3sNV;
+extern GLEW_EXPORT glVertexAttrib3fNVPROC glVertexAttrib3fNV;
+extern GLEW_EXPORT glVertexAttrib3dNVPROC glVertexAttrib3dNV;
+extern GLEW_EXPORT glVertexAttrib4sNVPROC glVertexAttrib4sNV;
+extern GLEW_EXPORT glVertexAttrib4fNVPROC glVertexAttrib4fNV;
+extern GLEW_EXPORT glVertexAttrib4dNVPROC glVertexAttrib4dNV;
+extern GLEW_EXPORT glVertexAttrib4ubNVPROC glVertexAttrib4ubNV;
+extern GLEW_EXPORT glVertexAttrib1svNVPROC glVertexAttrib1svNV;
+extern GLEW_EXPORT glVertexAttrib1fvNVPROC glVertexAttrib1fvNV;
+extern GLEW_EXPORT glVertexAttrib1dvNVPROC glVertexAttrib1dvNV;
+extern GLEW_EXPORT glVertexAttrib2svNVPROC glVertexAttrib2svNV;
+extern GLEW_EXPORT glVertexAttrib2fvNVPROC glVertexAttrib2fvNV;
+extern GLEW_EXPORT glVertexAttrib2dvNVPROC glVertexAttrib2dvNV;
+extern GLEW_EXPORT glVertexAttrib3svNVPROC glVertexAttrib3svNV;
+extern GLEW_EXPORT glVertexAttrib3fvNVPROC glVertexAttrib3fvNV;
+extern GLEW_EXPORT glVertexAttrib3dvNVPROC glVertexAttrib3dvNV;
+extern GLEW_EXPORT glVertexAttrib4svNVPROC glVertexAttrib4svNV;
+extern GLEW_EXPORT glVertexAttrib4fvNVPROC glVertexAttrib4fvNV;
+extern GLEW_EXPORT glVertexAttrib4dvNVPROC glVertexAttrib4dvNV;
+extern GLEW_EXPORT glVertexAttrib4ubvNVPROC glVertexAttrib4ubvNV;
+extern GLEW_EXPORT glVertexAttribs1svNVPROC glVertexAttribs1svNV;
+extern GLEW_EXPORT glVertexAttribs1fvNVPROC glVertexAttribs1fvNV;
+extern GLEW_EXPORT glVertexAttribs1dvNVPROC glVertexAttribs1dvNV;
+extern GLEW_EXPORT glVertexAttribs2svNVPROC glVertexAttribs2svNV;
+extern GLEW_EXPORT glVertexAttribs2fvNVPROC glVertexAttribs2fvNV;
+extern GLEW_EXPORT glVertexAttribs2dvNVPROC glVertexAttribs2dvNV;
+extern GLEW_EXPORT glVertexAttribs3svNVPROC glVertexAttribs3svNV;
+extern GLEW_EXPORT glVertexAttribs3fvNVPROC glVertexAttribs3fvNV;
+extern GLEW_EXPORT glVertexAttribs3dvNVPROC glVertexAttribs3dvNV;
+extern GLEW_EXPORT glVertexAttribs4svNVPROC glVertexAttribs4svNV;
+extern GLEW_EXPORT glVertexAttribs4fvNVPROC glVertexAttribs4fvNV;
+extern GLEW_EXPORT glVertexAttribs4dvNVPROC glVertexAttribs4dvNV;
+extern GLEW_EXPORT glVertexAttribs4ubvNVPROC glVertexAttribs4ubvNV;
+
+#endif /* GL_NV_vertex_program */
+
+/* ------------------------- NV_vertex_program1_1 ------------------------- */
+
+/* -------------------------- NV_vertex_program2 -------------------------- */
+
+/* ------------------------------------------------------------------------ */
+
+struct GLEW
+{
+  unsigned int GL_11 : 1;
+  unsigned int GL_12 : 1;
+  unsigned int GL_13 : 1;
+  unsigned int GL_14 : 1;
+
+  unsigned int ARB_depth_texture : 1;
+  unsigned int ARB_fragment_program : 1;
+  unsigned int ARB_imaging : 1;
+  unsigned int ARB_matrix_palette : 1;
+  unsigned int ARB_multisample : 1;
+  unsigned int ARB_multitexture : 1;
+  unsigned int ARB_point_parameters : 1;
+  unsigned int ARB_shadow : 1;
+  unsigned int ARB_shadow_ambient : 1;
+  unsigned int ARB_texture_border_clamp : 1;
+  unsigned int ARB_texture_compression : 1;
+  unsigned int ARB_texture_cube_map : 1;
+  unsigned int ARB_texture_env_add : 1;
+  unsigned int ARB_texture_env_combine : 1;
+  unsigned int ARB_texture_env_crossbar : 1;
+  unsigned int ARB_texture_env_dot3 : 1;
+  unsigned int ARB_texture_mirrored_repeat : 1;
+  unsigned int ARB_transpose_matrix : 1;
+  unsigned int ARB_vertex_blend : 1;
+  unsigned int ARB_vertex_program : 1;
+  unsigned int ARB_window_pos : 1;
+
+  unsigned int EXT_abgr : 1;
+  unsigned int EXT_bgra : 1;
+  unsigned int EXT_blend_color : 1;
+  unsigned int EXT_blend_minmax : 1;
+  unsigned int EXT_blend_subtract : 1;
+  unsigned int EXT_blend_func_separate : 1;
+  unsigned int EXT_clip_volume_hint : 1;
+  unsigned int EXT_compiled_vertex_array : 1;
+  unsigned int EXT_cull_vertex : 1;
+  unsigned int EXT_draw_range_elements : 1;
+  unsigned int EXT_fog_coord : 1;
+  unsigned int EXT_multi_draw_arrays : 1;
+  unsigned int EXT_packed_pixels : 1;
+  unsigned int EXT_point_parameters : 1;
+  unsigned int EXT_secondary_color : 1;
+  unsigned int EXT_separate_specular_color : 1;
+  unsigned int EXT_shadow_funcs : 1;
+  unsigned int EXT_stencil_two_side : 1;
+  unsigned int EXT_stencil_wrap : 1;
+  unsigned int EXT_texture_compression_s3tc : 1;
+  unsigned int EXT_texture_env_combine : 1;
+  unsigned int EXT_texture_filter_anisotropic : 1;
+  unsigned int EXT_texture_lod_bias : 1;
+  unsigned int EXT_texture_rectangle : 1;
+  unsigned int EXT_vertex_shader : 1;
+  unsigned int EXT_vertex_weighting : 1;
+
+  unsigned int SGIS_generate_mipmap : 1;
+  unsigned int SGIS_texture_lod : 1;
+  unsigned int SGIX_depth_texture : 1;
+  unsigned int SGIX_shadow : 1;
+
+  unsigned int HP_occlusion_test : 1;
+  unsigned int S3_s3tc : 1;
+  unsigned int WIN_swap_hint : 1;
+
+  unsigned int ATI_draw_buffers : 1;
+  unsigned int ATI_element_array : 1;
+  unsigned int ATI_envmap_bumpmap : 1;
+  unsigned int ATI_fragment_shader : 1;
+  unsigned int ATI_map_object_buffer : 1;
+  unsigned int ATI_mapped_texture : 1;
+  unsigned int ATI_pn_triangles : 1;
+  unsigned int ATI_point_cull_mode : 1;
+  unsigned int ATI_separate_stencil : 1;
+  unsigned int ATI_text_fragment_shader : 1;
+  unsigned int ATI_texture_float : 1;
+  unsigned int ATI_texture_mirror_once : 1;
+  unsigned int ATI_timestamp : 1;
+  unsigned int ATI_vertex_array_object : 1;
+  unsigned int ATI_vertex_attrib_array_object : 1;
+  unsigned int ATI_vertex_streams : 1;
+  unsigned int ATIX_point_sprites : 1;
+  unsigned int ATIX_texture_env_combine3 : 1;
+  unsigned int ATIX_texture_env_route : 1;
+  unsigned int ATIX_vertex_shader_output_point_size : 1;
+
+  unsigned int NV_blend_square : 1;
+  unsigned int NV_copy_depth_to_color : 1;
+  unsigned int NV_depth_clamp : 1;
+  unsigned int NV_element_array : 1;
+  unsigned int NV_evaluators : 1;
+  unsigned int NV_fence : 1;
+  unsigned int NV_float_buffer : 1;
+  unsigned int NV_fog_distance : 1;
+  unsigned int NV_fragment_program : 1;
+  unsigned int NV_light_max_exponent : 1;
+  unsigned int NV_multisample_filter_hint : 1;
+  unsigned int NV_occlusion_query : 1;
+  unsigned int NV_packed_depth_stencil : 1;
+  unsigned int NV_pixel_data_range : 1;
+  unsigned int NV_primitive_restart : 1;
+  unsigned int NV_point_sprite : 1;
+  unsigned int NV_register_combiners : 1;
+  unsigned int NV_register_combiners2 : 1;
+  unsigned int NV_texgen_reflection : 1;
+  unsigned int NV_texture_compression_vtc : 1;
+  unsigned int NV_texture_env_combine4 : 1;
+  unsigned int NV_texture_rectangle : 1;
+  unsigned int NV_texture_shader : 1;
+  unsigned int NV_texture_shader2 : 1;
+  unsigned int NV_texture_shader3 : 1;
+  unsigned int NV_vertex_array_range : 1;
+  unsigned int NV_vertex_array_range2 : 1;
+  unsigned int NV_vertex_program : 1;
+  unsigned int NV_vertex_program1_1 : 1;
+  unsigned int NV_vertex_program2 : 1;
+};
+
+/* error codes */
+#define GLEW_OK                         0
+#define GLEW_ERROR_NO_GL_VERSION        1  /* missing GL version */
+#define GLEW_ERROR_NO_EXTENSIONS_STRING 2  /* missing {ARB,EXT}_extensions_string */
+#define GLEW_ERROR_GL_VERSION_10_ONLY   3  /* GL 1.1 and up are not supported */
+#define GLEW_ERROR_GLX_VERSION_11_ONLY  4  /* GLX 1.2 and up are not supported */
+
+extern GLEW_EXPORT struct GLEW glew;
+extern GLEW_EXPORT GLboolean glewExperimental;
+extern GLEW_EXPORT GLint glewInit ();
+extern GLEW_EXPORT const char* glewGetErrorString (GLint error);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef GLEW_APIENTRY_DEFINED
+#undef GLEW_APIENTRY_DEFINED
+#undef APIENTRY
+#endif
+
+#ifdef GLEW_WINGDIAPI_DEFINED
+#undef GLEW_WINGDIAPI_DEFINED
+#undef WINGDIAPI
+#endif
+
+#undef GLEW_EXPORT
+
+#endif /* __glew_h__ */
diff --git a/include/GL/glxew.h b/include/GL/glxew.h
new file mode 100644
index 0000000..90769e8
--- /dev/null
+++ b/include/GL/glxew.h
@@ -0,0 +1,796 @@
+/*
+** The contents of this file are subject to the GLX Public License Version 1.0
+** (the "License"). You may not use this file except in compliance with the
+** License. You may obtain a copy of the License at Silicon Graphics, Inc.,
+** attn: Legal Services, 2011 N. Shoreline Blvd., Mountain View, CA 94043
+** or at http://www.sgi.com/software/opensource/glx/license.html.
+**
+** Software distributed under the License is distributed on an "AS IS"
+** basis. ALL WARRANTIES ARE DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY
+** IMPLIED WARRANTIES OF MERCHANTABILITY, OF FITNESS FOR A PARTICULAR
+** PURPOSE OR OF NON- INFRINGEMENT. See the License for the specific
+** language governing rights and limitations under the License.
+**
+** The Original Software is GLX version 1.2 source code, released February,
+** 1999. The developer of the Original Software is Silicon Graphics, Inc.
+** Those portions of the Subject Software created by Silicon Graphics, Inc.
+** are Copyright (c) 1991-9 Silicon Graphics, Inc. All Rights Reserved.
+*/
+
+/*
+** The OpenGL Extension Wrangler Library
+** Copyright (C) 2002 Milan Ikits
+**
+** This library is free software; you can redistribute it and/or
+** modify it under the terms of the GNU Lesser General Public
+** License as published by the Free Software Foundation; either
+** version 2.1 of the License, or (at your option) any later version.
+**
+** This library is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+** Lesser General Public License for more details.
+**
+** You should have received a copy of the GNU Lesser General Public
+** License along with this library; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#ifndef __glxew_h__
+#define __glxew_h__
+
+#ifdef __glxext_h_
+#error glxext.h included before glxew.h
+#endif
+
+#define __glxext_h_
+
+#ifndef _WIN32
+
+#include 
+#include 
+#include 
+#include 
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* core GLX */
+#define GLX_VERSION_1_0 1
+#define GLX_VERSION_1_1 1
+#define GLX_VERSION_1_2 1
+#define GLX_VERSION_1_3 1
+#define GLX_VERSION_1_4 1
+/* ARB extensions */
+#define GLX_ARB_get_proc_address 1
+#define GLX_ARB_multisample 1
+/* multi-vendor extensions */
+#define GLX_EXT_import_context 1
+#define GLX_EXT_visual_info 1
+#define GLX_EXT_visual_rating 1
+/* MESA extensions */
+#define GLX_MESA_copy_sub_buffer 1
+#define GLX_MESA_pixmap_colormap 1
+#define GLX_MESA_release_buffers 1
+#define GLX_MESA_set_3dfx_mode 1
+/* NVIDIA extensions */
+#define GLX_NV_vertex_array_range 1
+/* OML extensions */
+#define GLX_OML_swap_method 1
+#define GLX_OML_sync_control 1
+/* SGI extensions */
+#define GLX_SGI_cushion 1
+#define GLX_SGI_make_current_read 1
+#define GLX_SGI_swap_control 1
+#define GLX_SGI_video_sync 1
+#define GLX_SGIS_blended_overlay 1
+#define GLX_SGIS_multisample 1
+#define GLX_SGIS_shared_multisample 1
+/* #define GLX_SGIX_dm_buffer 1 */
+#define GLX_SGIX_fbconfig 1
+#define GLX_SGIX_pbuffer 1
+#define GLX_SGIX_swap_group 1
+#define GLX_SGIX_swap_barrier 1
+/* #define GLX_SGIX_video_source 1*/
+/* #define GLX_SGIX_video_resize 1*/
+#define GLX_SGIX_visual_select_group 1
+/* SUN extensions */
+#define GLX_SUN_get_transparent_index 1
+
+/* -------------------------------- GLX 1.0 ------------------------------- */
+
+#ifdef GLX_VERSION_1_0
+
+#define GLX_USE_GL                                              1
+#define GLX_BUFFER_SIZE                                         2
+#define GLX_LEVEL                                               3
+#define GLX_RGBA                                                4
+#define GLX_DOUBLEBUFFER                                        5
+#define GLX_STEREO                                              6
+#define GLX_AUX_BUFFERS                                         7
+#define GLX_RED_SIZE                                            8
+#define GLX_GREEN_SIZE                                          9
+#define GLX_BLUE_SIZE                                           10
+#define GLX_ALPHA_SIZE                                          11
+#define GLX_DEPTH_SIZE                                          12
+#define GLX_STENCIL_SIZE                                        13
+#define GLX_ACCUM_RED_SIZE                                      14
+#define GLX_ACCUM_GREEN_SIZE                                    15
+#define GLX_ACCUM_BLUE_SIZE                                     16
+#define GLX_ACCUM_ALPHA_SIZE                                    17
+#define GLX_BAD_SCREEN                                          1
+#define GLX_BAD_ATTRIBUTE                                       2
+#define GLX_NO_EXTENSION                                        3
+#define GLX_BAD_VISUAL                                          4
+#define GLX_BAD_CONTEXT                                         5
+#define GLX_BAD_VALUE                                           6
+#define GLX_BAD_ENUM                                            7
+
+typedef XID GLXDrawable;
+typedef XID GLXPixmap;
+typedef struct __GLXcontextRec *GLXContext;
+
+#ifdef GLEW_PROTOTYPES
+typedef Bool ( * glXQueryExtensionPROC) (Display *dpy, int *errorBase, int *eventBase);
+typedef Bool ( * glXQueryVersionPROC) (Display *dpy, int *major, int *minor);
+typedef int ( * glXGetConfigPROC) (Display *dpy, XVisualInfo *vis, int attrib, int *value);
+typedef XVisualInfo* ( * glXChooseVisualPROC) (Display *dpy, int screen, int *attribList);
+typedef GLXPixmap ( * glXCreateGLXPixmapPROC) (Display *dpy, XVisualInfo *vis, Pixmap pixmap);
+typedef void ( * glXDestroyGLXPixmapPROC) (Display *dpy, GLXPixmap pix);
+typedef GLXContext ( * glXCreateContextPROC) (Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
+typedef void ( * glXDestroyContextPROC) (Display *dpy, GLXContext ctx);
+typedef Bool ( * glXIsDirectPROC) (Display *dpy, GLXContext ctx);
+typedef void ( * glXCopyContextPROC) (Display *dpy, GLXContext src, GLXContext dst, GLuint mask);
+typedef Bool ( * glXMakeCurrentPROC) (Display *dpy, GLXDrawable drawable, GLXContext ctx);
+typedef GLXContext ( * glXGetCurrentContextPROC) (void);
+typedef GLXDrawable ( * glXGetCurrentDrawablePROC) (void);
+typedef void ( * glXWaitGLPROC) (void);
+typedef void ( * glXWaitXPROC) (void);
+typedef void ( * glXSwapBuffersPROC) (Display *dpy, GLXDrawable drawable);
+typedef void ( * glXUseXFontPROC) (Font font, int first, int count, int listBase);
+
+extern glXQueryExtensionPROC glXQueryExtension;
+extern glXQueryVersionPROC glXQueryVersion;
+extern glXGetConfigPROC glXGetConfig;
+extern glXChooseVisualPROC glXChooseVisual;
+extern glXCreateGLXPixmapPROC glXCreateGLXPixmap;
+extern glXDestroyGLXPixmapPROC glXDestroyGLXPixmap;
+extern glXCreateContextPROC glXCreateContext;
+extern glXDestroyContextPROC glXDestroyContext;
+extern glXIsDirectPROC glXIsDirect;
+extern glXCopyContextPROC glXCopyContext;
+extern glXMakeCurrentPROC glXMakeCurrent;
+extern glXGetCurrentContextPROC glXGetCurrentContext;
+extern glXGetCurrentDrawablePROC glXGetCurrentDrawable;
+extern glXWaitGLPROC glXWaitGL;
+extern glXWaitXPROC glXWaitX;
+extern glXSwapBuffersPROC glXSwapBuffers;
+extern glXUseXFontPROC glXUseXFont;
+#else
+extern Bool glXQueryExtension (Display *dpy, int *errorBase, int *eventBase);
+extern Bool glXQueryVersion (Display *dpy, int *major, int *minor);
+extern int glXGetConfig (Display *dpy, XVisualInfo *vis, int attrib, int *value);
+extern XVisualInfo* glXChooseVisual (Display *dpy, int screen, int *attribList);
+extern GLXPixmap glXCreateGLXPixmap (Display *dpy, XVisualInfo *vis, Pixmap pixmap);
+extern void glXDestroyGLXPixmap (Display *dpy, GLXPixmap pix);
+extern GLXContext glXCreateContext (Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
+extern void glXDestroyContext (Display *dpy, GLXContext ctx);
+extern Bool glXIsDirect (Display *dpy, GLXContext ctx);
+extern void glXCopyContext (Display *dpy, GLXContext src, GLXContext dst, GLuint mask);
+extern Bool glXMakeCurrent (Display *dpy, GLXDrawable drawable, GLXContext ctx);
+extern GLXContext glXGetCurrentContext (void);
+extern GLXDrawable glXGetCurrentDrawable (void);
+extern void glXWaitGL (void);
+extern void glXWaitX (void);
+extern void glXSwapBuffers (Display *dpy, GLXDrawable drawable);
+extern void glXUseXFont (Font font, int first, int count, int listBase);
+#endif
+
+#endif /* GLX_VERSION_1_0 */
+
+/* -------------------------------- GLX 1.1 ------------------------------- */
+
+#ifdef GLX_VERSION_1_1
+
+#define GLX_VENDOR                                              0x1
+#define GLX_VERSION                                             0x2
+#define GLX_EXTENSIONS                                          0x3
+
+#ifdef GLEW_PROTOTYPES
+typedef const char* ( * glXQueryExtensionsStringPROC) (Display *dpy, int screen);
+typedef const char* ( * glXGetClientStringPROC) (Display *dpy, int name);
+typedef const char* ( * glXQueryServerStringPROC) (Display *dpy, int screen, int name);
+
+extern glXQueryExtensionsStringPROC glXQueryExtensionsString;
+extern glXGetClientStringPROC glXGetClientString;
+extern glXQueryServerStringPROC glXQueryServerString;
+#else
+extern const char* glXQueryExtensionsString (Display *dpy, int screen);
+extern const char* glXGetClientString (Display *dpy, int name);
+extern const char* glXQueryServerString (Display *dpy, int screen, int name);
+#endif
+
+#endif /* GLX_VERSION_1_1 */
+
+/* -------------------------------- GLX 1.2 ------------------------------- */
+
+#ifdef GLX_VERSION_1_2
+
+typedef Display* ( * glXGetCurrentDisplayPROC) (void);
+
+extern glXGetCurrentDisplayPROC glXGetCurrentDisplay;
+
+#endif /* GLX_VERSION_1_2 */
+
+/* -------------------------------- GLX 1.3 ------------------------------- */
+
+#ifdef GLX_VERSION_1_3
+
+#define GLX_WINDOW_BIT                                          0x00000001
+#define GLX_PIXMAP_BIT                                          0x00000002
+#define GLX_PBUFFER_BIT                                         0x00000004
+#define GLX_RGBA_BIT                                            0x00000001
+#define GLX_COLOR_INDEX_BIT                                     0x00000002
+#define GLX_PBUFFER_CLOBBER_MASK                                0x08000000
+#define GLX_FRONT_LEFT_BUFFER_BIT                               0x00000001
+#define GLX_FRONT_RIGHT_BUFFER_BIT                              0x00000002
+#define GLX_BACK_LEFT_BUFFER_BIT                                0x00000004
+#define GLX_BACK_RIGHT_BUFFER_BIT                               0x00000008
+#define GLX_AUX_BUFFERS_BIT                                     0x00000010
+#define GLX_DEPTH_BUFFER_BIT                                    0x00000020
+#define GLX_STENCIL_BUFFER_BIT                                  0x00000040
+#define GLX_ACCUM_BUFFER_BIT                                    0x00000080
+#define GLX_CONFIG_CAVEAT                                       0x20
+#define GLX_X_VISUAL_TYPE                                       0x22
+#define GLX_TRANSPARENT_TYPE                                    0x23
+#define GLX_TRANSPARENT_INDEX_VALUE                             0x24
+#define GLX_TRANSPARENT_RED_VALUE                               0x25
+#define GLX_TRANSPARENT_GREEN_VALUE                             0x26
+#define GLX_TRANSPARENT_BLUE_VALUE                              0x27
+#define GLX_TRANSPARENT_ALPHA_VALUE                             0x28
+#define GLX_DONT_CARE                                           0xFFFFFFFF
+#define GLX_NONE                                                0x8000
+#define GLX_SLOW_CONFIG                                         0x8001
+#define GLX_TRUE_COLOR                                          0x8002
+#define GLX_DIRECT_COLOR                                        0x8003
+#define GLX_PSEUDO_COLOR                                        0x8004
+#define GLX_STATIC_COLOR                                        0x8005
+#define GLX_GRAY_SCALE                                          0x8006
+#define GLX_STATIC_GRAY                                         0x8007
+#define GLX_TRANSPARENT_RGB                                     0x8008
+#define GLX_TRANSPARENT_INDEX                                   0x8009
+#define GLX_VISUAL_ID                                           0x800B
+#define GLX_SCREEN                                              0x800C
+#define GLX_NON_CONFORMANT_CONFIG                               0x800D
+#define GLX_DRAWABLE_TYPE                                       0x8010
+#define GLX_RENDER_TYPE                                         0x8011
+#define GLX_X_RENDERABLE                                        0x8012
+#define GLX_FBCONFIG_ID                                         0x8013
+#define GLX_RGBA_TYPE                                           0x8014
+#define GLX_COLOR_INDEX_TYPE                                    0x8015
+#define GLX_MAX_PBUFFER_WIDTH                                   0x8016
+#define GLX_MAX_PBUFFER_HEIGHT                                  0x8017
+#define GLX_MAX_PBUFFER_PIXELS                                  0x8018
+#define GLX_PRESERVED_CONTENTS                                  0x801B
+#define GLX_LARGEST_PBUFFER                                     0x801C
+#define GLX_WIDTH                                               0x801D
+#define GLX_HEIGHT                                              0x801E
+#define GLX_EVENT_MASK                                          0x801F
+#define GLX_DAMAGED                                             0x8020
+#define GLX_SAVED                                               0x8021
+#define GLX_WINDOW                                              0x8022
+#define GLX_PBUFFER                                             0x8023
+#define GLX_PBUFFER_HEIGHT                                      0x8040
+#define GLX_PBUFFER_WIDTH                                       0x8041
+
+typedef XID GLXWindow;
+typedef XID GLXPbuffer;
+typedef XID GLXFBConfigID;
+typedef struct __GLXFBConfigRec *GLXFBConfig;
+typedef struct {
+  int event_type;
+  int draw_type;
+  unsigned long serial;
+  Bool send_event;
+  Display *display;
+  GLXDrawable drawable;
+  unsigned int buffer_mask;
+  unsigned int aux_buffer;
+  int x, y;
+  int width, height;
+  int count;
+} GLXPbufferClobberEvent;
+typedef union __GLXEvent {
+  GLXPbufferClobberEvent glxpbufferclobber;
+  long pad[24];
+} GLXEvent;                                                                       
+
+typedef GLXFBConfig* ( * glXChooseFBConfigPROC) (Display *dpy, int screen, const int *attrib_list, int *nelements);
+typedef GLXFBConfig* ( * glXGetFBConfigsPROC) (Display *dpy, int screen, int *nelements);
+typedef XVisualInfo* ( * glXGetVisualFromFBConfigPROC) (Display *dpy, GLXFBConfig config);
+typedef int ( * glXGetFBConfigAttribPROC) (Display *dpy, GLXFBConfig config, int attribute, int *value);
+typedef GLXWindow ( * glXCreateWindowPROC) (Display *dpy, GLXFBConfig config, Window win, const int *attrib_list);
+typedef void ( * glXDestroyWindowPROC) (Display *dpy, GLXWindow win);
+typedef GLXPixmap ( * glXCreatePixmapPROC) (Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attrib_list);
+typedef void ( * glXDestroyPixmapPROC) (Display *dpy, GLXPixmap pixmap);
+typedef GLXPbuffer ( * glXCreatePbufferPROC) (Display *dpy, GLXFBConfig config, const int *attrib_list);
+typedef void ( * glXDestroyPbufferPROC) (Display *dpy, GLXPbuffer pbuf);
+typedef void ( * glXQueryDrawablePROC) (Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
+typedef GLXContext ( * glXCreateNewContextPROC) (Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct);
+typedef Bool ( * glXMakeContextCurrentPROC) (Display *display, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+typedef GLXDrawable ( * glXGetCurrentReadDrawablePROC) (void);
+typedef int ( * glXQueryContextPROC) (Display *dpy, GLXContext ctx, int attribute, int *value);
+typedef void ( * glXSelectEventPROC) (Display *dpy, GLXDrawable draw, unsigned long event_mask);
+typedef void ( * glXGetSelectedEventPROC) (Display *dpy, GLXDrawable draw, unsigned long *event_mask);                                 
+
+extern glXChooseFBConfigPROC glXChooseFBConfig;
+extern glXGetFBConfigsPROC glXGetFBConfigs;
+extern glXGetVisualFromFBConfigPROC glXGetVisualFromFBConfig;
+extern glXGetFBConfigAttribPROC glXGetFBConfigAttrib;
+extern glXCreateWindowPROC glXCreateWindow;
+extern glXDestroyWindowPROC glXDestroyWindow;
+extern glXCreatePixmapPROC glXCreatePixmap;
+extern glXDestroyPixmapPROC glXDestroyPixmap;
+extern glXCreatePbufferPROC glXCreatePbuffer;
+extern glXDestroyPbufferPROC glXDestroyPbuffer;
+extern glXQueryDrawablePROC glXQueryDrawable;
+extern glXCreateNewContextPROC glXCreateNewContext;
+extern glXMakeContextCurrentPROC glXMakeContextCurrent;
+extern glXGetCurrentReadDrawablePROC glXGetCurrentReadDrawable;
+extern glXQueryContextPROC glXQueryContext;
+extern glXSelectEventPROC glXSelectEvent;
+extern glXGetSelectedEventPROC glXGetSelectedEvent;
+
+#if 0
+extern GLXFBConfig* glXChooseFBConfig (Display *dpy, int screen, const int *attrib_list, int *nelements);
+extern GLXFBConfig* glXGetFBConfigs (Display *dpy, int screen, int *nelements);
+extern XVisualInfo* glXGetVisualFromFBConfig (Display *dpy, GLXFBConfig config);
+extern int glXGetFBConfigAttrib (Display *dpy, GLXFBConfig config, int attribute, int *value);
+extern GLXWindow glXCreateWindow (Display *dpy, GLXFBConfig config, Window win, const int *attrib_list);
+extern void glXDestroyWindow (Display *dpy, GLXWindow win);
+extern GLXPixmap glXCreatePixmap (Display *dpy, GLXFBConfig config, Pixmap pixmap, const int *attrib_list);
+extern void glXDestroyPixmap (Display *dpy, GLXPixmap pixmap);
+extern GLXPbuffer glXCreatePbuffer (Display *dpy, GLXFBConfig config, const int *attrib_list);
+extern void glXDestroyPbuffer (Display *dpy, GLXPbuffer pbuf);
+extern void glXQueryDrawable (Display *dpy, GLXDrawable draw, int attribute, unsigned int *value);
+extern GLXContext glXCreateNewContext (Display *dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct);
+extern Bool glXMakeContextCurrent (Display *display, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+extern GLXDrawable glXGetCurrentReadDrawable (void);
+extern int glXQueryContext (Display *dpy, GLXContext ctx, int attribute, int *value);
+extern void glXSelectEvent (Display *dpy, GLXDrawable draw, unsigned long event_mask);
+extern void glXGetSelectedEvent (Display *dpy, GLXDrawable draw, unsigned long *event_mask);                                 
+#endif
+
+#endif /* GLX_VERSION_1_3 */
+
+/* -------------------------------- GLX 1.4 ------------------------------- */
+
+#ifdef GLX_VERSION_1_4
+
+#define GLX_SAMPLE_BUFFERS                                      100000
+#define GLX_SAMPLES                                             100001
+
+extern void ( * glXGetProcAddress(const GLubyte *procName))(void);
+
+#endif /* GLX_VERSION_1_4 */
+
+/* ------------------------- ARB_get_proc_address ------------------------- */
+
+#ifdef GLX_ARB_get_proc_address
+
+extern void ( * glXGetProcAddressARB(const GLubyte *procName))(void);
+
+#endif /* GLX_ARB_get_proc_address */
+
+/* ---------------------------- ARB_multisample --------------------------- */
+
+#ifdef GLX_ARB_multisample
+
+#define GLX_SAMPLE_BUFFERS_ARB                                  100000
+#define GLX_SAMPLES_ARB                                         100001
+
+#endif /* GLX_ARB_multisample */
+
+/* ---------------------------- EXT_visual_info --------------------------- */
+
+#ifdef GLX_EXT_visual_info
+
+#define GLX_X_VISUAL_TYPE_EXT                                   0x22
+#define GLX_TRANSPARENT_TYPE_EXT                                0x23
+#define GLX_TRANSPARENT_INDEX_VALUE_EXT                         0x24
+#define GLX_TRANSPARENT_RED_VALUE_EXT                           0x25
+#define GLX_TRANSPARENT_GREEN_VALUE_EXT                         0x26
+#define GLX_TRANSPARENT_BLUE_VALUE_EXT                          0x27
+#define GLX_TRANSPARENT_ALPHA_VALUE_EXT                         0x28
+#define GLX_NONE_EXT                                            0x8000
+#define GLX_TRUE_COLOR_EXT                                      0x8002
+#define GLX_DIRECT_COLOR_EXT                                    0x8003
+#define GLX_PSEUDO_COLOR_EXT                                    0x8004
+#define GLX_STATIC_COLOR_EXT                                    0x8005
+#define GLX_GRAY_SCALE_EXT                                      0x8006
+#define GLX_STATIC_GRAY_EXT                                     0x8007
+#define GLX_TRANSPARENT_RGB_EXT                                 0x8008
+#define GLX_TRANSPARENT_INDEX_EXT                               0x8009
+
+#endif /* GLX_EXT_visual_info */
+
+/* --------------------------- EXT_visual_rating -------------------------- */
+
+#ifdef GLX_EXT_visual_rating
+
+#define GLX_VISUAL_CAVEAT_EXT                                   0x20
+#define GLX_SLOW_VISUAL_EXT                                     0x8001
+#define GLX_NON_CONFORMANT_VISUAL_EXT                           0x800D
+
+#endif /* GLX_EXT_visual_rating */
+
+/* --------------------------- EXT_import_context -------------------------- */
+
+#ifdef GLX_EXT_import_context
+
+#define GLX_SHARE_CONTEXT_EXT                                   0x800A
+#define GLX_VISUAL_ID_EXT                                       0x800B
+#define GLX_SCREEN_EXT                                          0x800C
+
+typedef XID GLXContextID;
+
+typedef Display * ( * glXGetCurrentDisplayEXTPROC) (void);
+typedef int ( * glXQueryContextInfoEXTPROC) (Display *dpy, GLXContext context, int attribute, int *value);
+typedef GLXContextID ( * glXGetContextIDEXTPROC) (const GLXContext context);
+typedef GLXContext ( * glXImportContextEXTPROC) (Display *dpy, GLXContextID contextID);
+typedef void ( * glXFreeContextEXTPROC) (Display *dpy, GLXContext context);
+
+extern glXGetCurrentDisplayEXTPROC glXGetCurrentDisplayEXT;
+extern glXQueryContextInfoEXTPROC glXQueryContextInfoEXT;
+extern glXGetContextIDEXTPROC glXGetContextIDEXT;
+extern glXImportContextEXTPROC glXImportContextEXT;
+extern glXFreeContextEXTPROC glXFreeContextEXT;
+
+#endif /* GLX_EXT_import_context */
+
+/* --------------------------- MESA_copy_sub_buffer ----------------------- */
+
+#ifdef GLX_MESA_copy_sub_buffer
+
+typedef void ( * glXCopySubBufferMESAPROC) (Display *dpy, GLXDrawable drawable, int x, int y, int width, int height);
+
+extern glXCopySubBufferMESAPROC glXCopySubBufferMESA;
+
+#endif /* GLX_MESA_copy_sub_buffer */
+
+/* -------------------------- MESA_pixmap_colormap ------------------------ */
+
+#ifdef GLX_MESA_pixmap_colormap
+
+typedef GLXPixmap ( * glXCreateGLXPixmapMESAPROC) (Display *dpy, XVisualInfo *visual, Pixmap pixmap, Colormap cmap);
+
+extern glXCreateGLXPixmapMESAPROC glXCreateGLXPixmapMESA;
+
+#endif /* GLX_MESA_pixmap_colormap */
+
+/* -------------------------- MESA_release_buffers ------------------------ */
+
+#ifdef GLX_MESA_release_buffers
+
+typedef Bool ( * glXReleaseBuffersMESAPROC) (Display *dpy, GLXDrawable drawable);
+
+extern glXReleaseBuffersMESAPROC glXReleaseBuffersMESA;
+
+#endif /* GLX_MESA_release_buffers */
+
+/* --------------------------- MESA_set_3dfx_mode ------------------------- */
+
+#ifdef GLX_MESA_set_3dfx_mode
+
+typedef Bool ( * glXSet3DfxModeMESAPROC) (int mode);
+
+extern glXSet3DfxModeMESAPROC glXSet3DfxModeMESA;
+
+#endif /* GLX_MESA_set_3dfx_mode */
+
+/* ---------------------------- OML_swap_method --------------------------- */
+
+#ifdef GLX_OML_swap_method
+
+#define GLX_SWAP_METHOD_OML                                     0x8060
+#define GLX_SWAP_EXCHANGE_OML                                   0x8061
+#define GLX_SWAP_COPY_OML                                       0x8062
+#define GLX_SWAP_UNDEFINED_OML                                  0x8063
+
+#endif /* GLX_OML_swap_method */
+
+/* ---------------------------- OML_sync_control -------------------------- */
+
+#ifdef GLX_OML_sync_control
+
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+#include 
+typedef Bool ( * glXGetSyncValuesOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t *ust, int64_t *msc, int64_t *sbc);
+typedef Bool ( * glXGetMscRateOMLPROC) (Display *dpy, GLXDrawable drawable, int32_t *numerator, int32_t *denominator);
+typedef int64_t ( * glXSwapBuffersMscOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder);
+typedef Bool ( * glXWaitForMscOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder, int64_t *ust, int64_t *msc, int64_t *sbc);
+typedef Bool ( * glXWaitForSbcOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t target_sbc, int64_t *ust, int64_t *msc, int64_t *sbc);
+
+extern glXGetSyncValuesOMLPROC glXGetSyncValuesOML;
+extern glXGetMscRateOMLPROC glXGetMscRateOML;
+extern glXSwapBuffersMscOMLPROC glXSwapBuffersMscOML;
+extern glXWaitForMscOMLPROC glXWaitForMscOML;
+extern glXWaitForSbcOMLPROC glXWaitForSbcOML;
+#endif /* __STDC_VERSION__ */
+
+#endif /* GLX_OML_sync_control */
+
+/* ------------------------- NV_vertex_array_range ------------------------ */
+
+#ifdef GLX_NV_vertex_array_range
+
+typedef void * ( * glXAllocateMemoryNVPROC) (GLsizei size, GLfloat readFrequency, GLfloat writeFrequency, GLfloat priority);
+typedef void ( * glXFreeMemoryNVPROC) (void *pointer);
+
+extern glXAllocateMemoryNVPROC glXAllocateMemoryNV;
+extern glXFreeMemoryNVPROC glXFreeMemoryNV;
+
+#endif /* GLX_NV_vertex_array_range */
+
+/* ------------------------------- SGI_cushion ---------------------------- */
+
+#ifdef GLX_SGI_cushion
+
+typedef void ( * glXCushionSGIPROC) (Display *dpy, Window window, float cushion);
+
+extern glXCushionSGIPROC glXCushionSGI;
+
+#endif /* GLX_SGI_cushion */
+
+/* -------------------------- SGI_make_current_read ----------------------- */
+
+#ifdef GLX_SGI_make_current_read
+
+typedef Bool ( * glXMakeCurrentReadSGIPROC) (Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
+typedef GLXDrawable ( * glXGetCurrentReadDrawableSGIPROC) (void);
+
+extern glXMakeCurrentReadSGIPROC glXMakeCurrentReadSGI;
+extern glXGetCurrentReadDrawableSGIPROC glXGetCurrentReadDrawableSGI;
+
+#endif /* GLX_SGI_make_current_read */
+
+/* ---------------------------- SGI_swap_control -------------------------- */
+
+#ifdef GLX_SGI_swap_control
+
+typedef int ( * glXSwapIntervalSGIPROC) (int interval);
+
+extern glXSwapIntervalSGIPROC glXSwapIntervalSGI;
+
+#endif /* GLX_SGI_swap_control */
+
+/* ----------------------------- SGI_video_sync --------------------------- */
+
+#ifdef GLX_SGI_video_sync
+
+typedef int ( * glXGetVideoSyncSGIPROC) (unsigned int *count);
+typedef int ( * glXWaitVideoSyncSGIPROC) (int divisor, int remainder, unsigned int *count);
+typedef int ( * glXGetRefreshRateSGIPROC) (unsigned int *rate);
+
+extern glXGetVideoSyncSGIPROC glXGetVideoSyncSGI;
+extern glXWaitVideoSyncSGIPROC glXWaitVideoSyncSGI;
+extern glXGetRefreshRateSGIPROC glXGetRefreshRateSGI;
+
+#endif /* GLX_SGI_video_sync */
+
+/* -------------------------- SGIS_blended_overlay ------------------------ */
+
+#ifdef GLX_SGIS_blended_overlay
+
+#define GLX_BLENDED_RGBA_SGIS                                   0x8025
+
+#endif
+
+/* ---------------------------- SGIS_multisample -------------------------- */
+
+#ifdef GLX_SGIS_multisample
+
+#define GLX_SAMPLE_BUFFERS_SGIS                                 100000
+#define GLX_SAMPLES_SGIS                                        100001
+
+#endif
+
+/* ------------------------ SGIS_shared_multisample ----------------------- */
+
+#ifdef GLX_SGIS_shared_multisample
+
+#define GLX_MULTISAMPLE_SUB_RECT_WIDTH_SGIS                     0x8026
+#define GLX_MULTISAMPLE_SUB_RECT_HEIGHT_SGIS                    0x8027
+
+#endif
+
+/* ------------------------------ SGIX_fbconfig --------------------------- */
+
+#ifdef GLX_SGIX_fbconfig
+
+#define GLX_WINDOW_BIT_SGIX                                     0x00000001
+#define GLX_PIXMAP_BIT_SGIX                                     0x00000002
+#define GLX_RGBA_BIT_SGIX                                       0x00000001
+#define GLX_COLOR_INDEX_BIT_SGIX                                0x00000002
+#define GLX_DRAWABLE_TYPE_SGIX                                  0x8010
+#define GLX_RENDER_TYPE_SGIX                                    0x8011
+#define GLX_X_RENDERABLE_SGIX                                   0x8012
+#define GLX_FBCONFIG_ID_SGIX                                    0x8013
+#define GLX_RGBA_TYPE_SGIX                                      0x8014
+#define GLX_COLOR_INDEX_TYPE_SGIX                               0x8015
+
+typedef XID GLXFBConfigIDSGIX;
+typedef struct __GLXFBConfigRec *GLXFBConfigSGIX;
+
+typedef int ( * glXGetFBConfigAttribSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, int attribute, int *value);
+typedef GLXFBConfigSGIX * ( * glXChooseFBConfigSGIXPROC) (Display *dpy, int screen, int *attrib_list, int *nelements);
+typedef GLXPixmap ( * glXCreateGLXPixmapWithConfigSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap);
+typedef GLXContext ( * glXCreateContextWithConfigSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct);
+typedef XVisualInfo * ( * glXGetVisualFromFBConfigSGIXPROC) (Display *dpy, GLXFBConfigSGIX config);
+typedef GLXFBConfigSGIX ( * glXGetFBConfigFromVisualSGIXPROC) (Display *dpy, XVisualInfo *vis);
+
+extern glXGetFBConfigAttribSGIXPROC glXGetFBConfigAttribSGIX;
+extern glXChooseFBConfigSGIXPROC glXChooseFBConfigSGIX;
+extern glXCreateGLXPixmapWithConfigSGIXPROC glXCreateGLXPixmapWithConfigSGIX;
+extern glXCreateContextWithConfigSGIXPROC glXCreateContextWithConfigSGIX;
+extern glXGetVisualFromFBConfigSGIXPROC glXGetVisualFromFBConfigSGIX;
+extern glXGetFBConfigFromVisualSGIXPROC glXGetFBConfigFromVisualSGIX;
+
+#endif /* GLX_SGIX_fbconfig */
+
+/* ------------------------------- SGIX_pbuffer --------------------------- */
+
+#ifdef GLX_SGIX_pbuffer
+
+#define GLX_PBUFFER_BIT_SGIX                                    0x00000004
+#define GLX_BUFFER_CLOBBER_MASK_SGIX                            0x08000000
+#define GLX_FRONT_LEFT_BUFFER_BIT_SGIX                          0x00000001
+#define GLX_FRONT_RIGHT_BUFFER_BIT_SGIX                         0x00000002
+#define GLX_BACK_LEFT_BUFFER_BIT_SGIX                           0x00000004
+#define GLX_BACK_RIGHT_BUFFER_BIT_SGIX                          0x00000008
+#define GLX_AUX_BUFFERS_BIT_SGIX                                0x00000010
+#define GLX_DEPTH_BUFFER_BIT_SGIX                               0x00000020
+#define GLX_STENCIL_BUFFER_BIT_SGIX                             0x00000040
+#define GLX_ACCUM_BUFFER_BIT_SGIX                               0x00000080
+#define GLX_SAMPLE_BUFFERS_BIT_SGIX                             0x00000100
+#define GLX_MAX_PBUFFER_WIDTH_SGIX                              0x8016
+#define GLX_MAX_PBUFFER_HEIGHT_SGIX                             0x8017
+#define GLX_MAX_PBUFFER_PIXELS_SGIX                             0x8018
+#define GLX_OPTIMAL_PBUFFER_WIDTH_SGIX                          0x8019
+#define GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX                         0x801A
+#define GLX_PRESERVED_CONTENTS_SGIX                             0x801B
+#define GLX_LARGEST_PBUFFER_SGIX                                0x801C
+#define GLX_WIDTH_SGIX                                          0x801D
+#define GLX_HEIGHT_SGIX                                         0x801E
+#define GLX_EVENT_MASK_SGIX                                     0x801F
+#define GLX_DAMAGED_SGIX                                        0x8020
+#define GLX_SAVED_SGIX                                          0x8021
+#define GLX_WINDOW_SGIX                                         0x8022
+#define GLX_PBUFFER_SGIX                                        0x8023
+
+typedef XID GLXPbufferSGIX;
+typedef struct {
+  int type;
+  unsigned long serial;
+  Bool send_event;
+  Display *display;
+  GLXDrawable drawable;
+  int event_type;
+  int draw_type;
+  unsigned int mask;
+  int x, y;
+  int width, height;
+  int count;
+} GLXBufferClobberEventSGIX;
+
+typedef GLXPbufferSGIX ( * glXCreateGLXPbufferSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, unsigned int width, unsigned int height, int *attrib_list);
+typedef void ( * glXDestroyGLXPbufferSGIXPROC) (Display *dpy, GLXPbufferSGIX pbuf);
+typedef int ( * glXQueryGLXPbufferSGIXPROC) (Display *dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int *value);
+typedef void ( * glXSelectEventSGIXPROC) (Display *dpy, GLXDrawable drawable, unsigned long mask);
+typedef void ( * glXGetSelectedEventSGIXPROC) (Display *dpy, GLXDrawable drawable, unsigned long *mask);
+
+extern glXCreateGLXPbufferSGIXPROC glXCreateGLXPbufferSGIX;
+extern glXDestroyGLXPbufferSGIXPROC glXDestroyGLXPbufferSGIX;
+extern glXQueryGLXPbufferSGIXPROC glXQueryGLXPbufferSGIX;
+extern glXSelectEventSGIXPROC glXSelectEventSGIX;
+extern glXGetSelectedEventSGIXPROC glXGetSelectedEventSGIX;
+
+#endif /* GLX_SGIX_pbuffer */
+
+/* ---------------------------- SGIX_swap_barrier ------------------------- */
+
+#ifdef GLX_SGIX_swap_barrier
+
+typedef void ( * glXBindSwapBarrierSGIXPROC) (Display *dpy, GLXDrawable drawable, int barrier);
+typedef Bool ( * glXQueryMaxSwapBarriersSGIXPROC) (Display *dpy, int screen, int *max);
+
+extern glXBindSwapBarrierSGIXPROC glXBindSwapBarrierSGIX;
+extern glXQueryMaxSwapBarriersSGIXPROC glXQueryMaxSwapBarriersSGIX;
+
+#endif /* GLX_SGIX_swap_barrier */
+
+/* ----------------------------- SGIX_swap_group -------------------------- */
+
+#ifdef GLX_SGIX_swap_group
+
+typedef void ( * glXJoinSwapGroupSGIXPROC) (Display *dpy, GLXDrawable drawable, GLXDrawable member);
+
+extern glXJoinSwapGroupSGIXPROC glXJoinSwapGroupSGIX;
+
+#endif /* GLX_SGIX_swap_group */
+
+/* ------------------------- SGIX_visual_select_group --------------------- */
+
+#ifndef GLX_SGIX_visual_select_group
+
+#define GLX_VISUAL_SELECT_GROUP_SGIX                            0x8028
+
+#endif
+
+/* ------------------------ SUN_get_transparent_index --------------------- */
+
+#ifdef GLX_SUN_get_transparent_index
+
+typedef Status ( * glXGetTransparentIndexSUNPROC) (Display *dpy, Window overlay, Window underlay, long *pTransparentIndex);
+
+extern glXGetTransparentIndexSUNPROC glXGetTransparentIndexSUN;
+
+#endif /* GLX_SUN_get_transparent_index */
+
+/* ------------------------------------------------------------------------ */
+
+struct GLXEW
+{
+  unsigned int GLX_10 : 1;
+  unsigned int GLX_11 : 1;
+  unsigned int GLX_12 : 1;
+  unsigned int GLX_13 : 1;
+  unsigned int GLX_14 : 1;
+
+  unsigned int ARB_get_proc_address : 1;
+  unsigned int ARB_multisample : 1;
+
+  unsigned int EXT_import_context : 1;  
+  unsigned int EXT_visual_info : 1;  
+  unsigned int EXT_visual_rating : 1;  
+
+  unsigned int MESA_copy_sub_buffer : 1;
+  unsigned int MESA_pixmap_colormap : 1;
+  unsigned int MESA_release_buffers : 1;
+  unsigned int MESA_set_3dfx_mode : 1;
+
+  unsigned int NV_vertex_array_range : 1;
+
+  unsigned int OML_swap_method : 1;
+  unsigned int OML_sync_control : 1;
+
+  unsigned int SGI_cushion : 1;
+  unsigned int SGI_make_current_read : 1;
+  unsigned int SGI_swap_control : 1;
+  unsigned int SGI_video_sync : 1;
+  unsigned int SGIS_blended_overlay : 1;
+  unsigned int SGIS_multisample : 1;
+  unsigned int SGIS_shared_multisample : 1;
+
+  /* unsigned int SGIX_dm_buffer : 1; */
+  unsigned int SGIX_fbconfig : 1;
+  unsigned int SGIX_pbuffer : 1;
+  unsigned int SGIX_swap_group : 1;
+  unsigned int SGIX_swap_barrier : 1;
+  /* unsigned int SGIX_video_source : 1; */
+  /* unsigned int SGIX_video_resize : 1; */
+  unsigned int SGIX_visual_select_group : 1;
+
+  unsigned int SUN_get_transparent_index : 1;
+};
+
+extern struct GLXEW glxew;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _WIN32 */
+
+#endif /* __glxew_h__ */
diff --git a/include/GL/wglew.h b/include/GL/wglew.h
new file mode 100644
index 0000000..388a6d4
--- /dev/null
+++ b/include/GL/wglew.h
@@ -0,0 +1,757 @@
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: This software was created using the
+** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+** not been independently verified as being compliant with the OpenGL(R)
+** version 1.2.1 Specification.
+*/
+
+/*
+** Copyright (C) 2002, Lev Povalahev
+** All rights reserved.
+** 
+** Redistribution and use in source and binary forms, with or without modification, 
+** are permitted provided that the following conditions are met:
+** 
+** * Redistributions of source code must retain the above copyright notice, 
+**   this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright notice, 
+**   this list of conditions and the following disclaimer in the documentation 
+**   and/or other materials provided with the distribution.
+** * The name of the authors may be used to endorse or promote products 
+**   derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
+** IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+** INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+** BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 
+** OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+** WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
+** THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+** The OpenGL Extension Wrangler Library
+** Copyright (C) 2002 Milan Ikits
+**
+** This library is free software; you can redistribute it and/or
+** modify it under the terms of the GNU Lesser General Public
+** License as published by the Free Software Foundation; either
+** version 2.1 of the License, or (at your option) any later version.
+**
+** This library is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+** Lesser General Public License for more details.
+**
+** You should have received a copy of the GNU Lesser General Public
+** License along with this library; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#ifndef __wglew_h__
+#define __wglew_h__
+
+#ifdef __wglext_h_
+#error wglext.h included before wglew.h
+#endif
+
+#define __wglext_h_
+
+#ifdef _WIN32
+
+#if !defined(APIENTRY) && !defined(__CYGWIN__)
+#define WIN32_LEAN_AND_MEAN 1
+#include 
+#endif
+
+/*
+ * GLEW_STATIC needs to be set when including the
+ * source directly in the project.  
+ * GLEW_BUILD is set when building the dll version.
+ */
+#ifdef GLEW_STATIC
+#define GLEW_EXPORT
+#else
+#ifdef GLEW_BUILD
+#define GLEW_EXPORT __declspec(dllexport)
+#else
+#define GLEW_EXPORT __declspec(dllimport)
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ARB extensions */
+#define WGL_ARB_buffer_region 1
+#define WGL_ARB_extensions_string 1
+#define WGL_ARB_make_current_read 1
+#define WGL_ARB_multisample 1
+#define WGL_ARB_pbuffer 1
+#define WGL_ARB_pixel_format 1
+#define WGL_ARB_render_texture 1
+/* multi-vendor extensions */
+#define WGL_EXT_depth_float 1
+#define WGL_EXT_display_color_table 1
+#define WGL_EXT_extensions_string 1
+#define WGL_EXT_make_current_read 1
+#define WGL_EXT_multisample 1
+#define WGL_EXT_swap_control 1
+#define WGL_EXT_pixel_format 1
+#define WGL_EXT_pbuffer 1
+/* vendor-specific extensions */
+#define WGL_I3D_digital_video_control 1
+#define WGL_I3D_gamma 1
+#define WGL_I3D_genlock 1
+#define WGL_I3D_image_buffer 1 
+#define WGL_I3D_swap_frame_lock 1
+#define WGL_I3D_swap_frame_usage 1
+#define WGL_OML_sync_control 1
+/* ATI extensions */
+#define WGL_ATI_pixel_format_float 1
+/* NVIDIA extensions */
+#define WGL_NV_float_buffer 1
+#define WGL_NV_render_depth_texture 1
+#define WGL_NV_render_texture_rectangle 1
+#define WGL_NV_vertex_array_range 1
+
+/* ---------------------------- ARB_buffer_region ------------------------- */
+
+#ifdef WGL_ARB_buffer_region
+
+#define WGL_FRONT_COLOR_BUFFER_BIT_ARB                          0x00000001
+#define WGL_BACK_COLOR_BUFFER_BIT_ARB                           0x00000002
+#define WGL_DEPTH_BUFFER_BIT_ARB                                0x00000004
+#define WGL_STENCIL_BUFFER_BIT_ARB                              0x00000008
+
+typedef HANDLE (APIENTRY * wglCreateBufferRegionARBPROC) (HDC hDC, int iLayerPlane, UINT uType);
+typedef VOID (APIENTRY * wglDeleteBufferRegionARBPROC) (HANDLE hRegion);
+typedef BOOL (APIENTRY * wglSaveBufferRegionARBPROC) (HANDLE hRegion, int x, int y, int width, int height);
+typedef BOOL (APIENTRY * wglRestoreBufferRegionARBPROC) (HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc);
+
+extern GLEW_EXPORT wglCreateBufferRegionARBPROC wglCreateBufferRegionARB;
+extern GLEW_EXPORT wglDeleteBufferRegionARBPROC wglDeleteBufferRegionARB;
+extern GLEW_EXPORT wglSaveBufferRegionARBPROC wglSaveBufferRegionARB;
+extern GLEW_EXPORT wglRestoreBufferRegionARBPROC wglRestoreBufferRegionARB;
+
+#endif /* WGL_ARB_buffer_region */
+
+/* -------------------------- ARB_extensions_string ----------------------- */
+
+#ifdef WGL_ARB_extensions_string
+
+typedef const char* (APIENTRY * wglGetExtensionsStringARBPROC) (HDC hdc);
+
+extern GLEW_EXPORT wglGetExtensionsStringARBPROC wglGetExtensionsStringARB;
+
+#endif /* WGL_ARB_extensions_string */
+
+/* -------------------------- ARB_make_current_read ----------------------- */
+
+#ifdef WGL_ARB_make_current_read
+
+#define ERROR_INVALID_PIXEL_TYPE_ARB                            0x2043
+#define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB	                0x2054
+
+typedef BOOL (APIENTRY * wglMakeContextCurrentARBPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
+typedef HDC (APIENTRY * wglGetCurrentReadDCARBPROC) (void);
+
+extern GLEW_EXPORT wglMakeContextCurrentARBPROC wglMakeContextCurrentARB;
+extern GLEW_EXPORT wglGetCurrentReadDCARBPROC wglGetCurrentReadDCARB;
+
+#endif /* WGL_ARB_make_current_read */
+
+/* ----------------------------- ARB_multisample -------------------------- */
+
+#ifdef WGL_ARB_multisample
+
+#define WGL_SAMPLE_BUFFERS_ARB                                  0x2041
+#define WGL_SAMPLES_ARB                                         0x2042
+
+#endif /* WGL_ARB_multisample */
+
+/* ------------------------------- ARB_pbuffer ---------------------------- */
+
+#ifdef WGL_ARB_pbuffer
+
+#define WGL_DRAW_TO_PBUFFER_ARB                                 0x202D
+#define WGL_MAX_PBUFFER_PIXELS_ARB                              0x202E
+#define WGL_MAX_PBUFFER_WIDTH_ARB                               0x202F
+#define WGL_MAX_PBUFFER_HEIGHT_ARB                              0x2030
+#define WGL_PBUFFER_LARGEST_ARB                                 0x2033
+#define WGL_PBUFFER_WIDTH_ARB                                   0x2034
+#define WGL_PBUFFER_HEIGHT_ARB                                  0x2035
+#define WGL_PBUFFER_LOST_ARB                                    0x2036
+
+DECLARE_HANDLE(HPBUFFERARB);
+
+typedef HPBUFFERARB (APIENTRY * wglCreatePbufferARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
+typedef HDC (APIENTRY * wglGetPbufferDCARBPROC) (HPBUFFERARB hPbuffer);
+typedef int (APIENTRY * wglReleasePbufferDCARBPROC) (HPBUFFERARB hPbuffer, HDC hDC);
+typedef BOOL (APIENTRY * wglDestroyPbufferARBPROC) (HPBUFFERARB hPbuffer);
+typedef BOOL (APIENTRY * wglQueryPbufferARBPROC) (HPBUFFERARB hPbuffer, int iAttribute, int *piValue);
+
+extern GLEW_EXPORT wglCreatePbufferARBPROC wglCreatePbufferARB;
+extern GLEW_EXPORT wglGetPbufferDCARBPROC wglGetPbufferDCARB;
+extern GLEW_EXPORT wglReleasePbufferDCARBPROC wglReleasePbufferDCARB;
+extern GLEW_EXPORT wglDestroyPbufferARBPROC wglDestroyPbufferARB;
+extern GLEW_EXPORT wglQueryPbufferARBPROC wglQueryPbufferARB;
+
+#endif /* WGL_ARB_pbuffer */
+
+/* ---------------------------- ARB_pixel_format -------------------------- */
+
+#ifdef WGL_ARB_pixel_format
+
+#define WGL_NUMBER_PIXEL_FORMATS_ARB                            0x2000
+#define WGL_DRAW_TO_WINDOW_ARB                                  0x2001
+#define WGL_DRAW_TO_BITMAP_ARB                                  0x2002
+#define WGL_ACCELERATION_ARB                                    0x2003
+#define WGL_NEED_PALETTE_ARB                                    0x2004
+#define WGL_NEED_SYSTEM_PALETTE_ARB                             0x2005
+#define WGL_SWAP_LAYER_BUFFERS_ARB                              0x2006
+#define WGL_SWAP_METHOD_ARB                                     0x2007
+#define WGL_NUMBER_OVERLAYS_ARB                                 0x2008
+#define WGL_NUMBER_UNDERLAYS_ARB                                0x2009
+#define WGL_TRANSPARENT_ARB                                     0x200A
+#define WGL_TRANSPARENT_RED_VALUE_ARB                           0x2037
+#define WGL_TRANSPARENT_GREEN_VALUE_ARB                         0x2038
+#define WGL_TRANSPARENT_BLUE_VALUE_ARB                          0x2039
+#define WGL_TRANSPARENT_ALPHA_VALUE_ARB                         0x203A
+#define WGL_TRANSPARENT_INDEX_VALUE_ARB                         0x203B
+#define WGL_SHARE_DEPTH_ARB                                     0x200C
+#define WGL_SHARE_STENCIL_ARB                                   0x200D
+#define WGL_SHARE_ACCUM_ARB                                     0x200E
+#define WGL_SUPPORT_GDI_ARB                                     0x200F
+#define WGL_SUPPORT_OPENGL_ARB                                  0x2010
+#define WGL_DOUBLE_BUFFER_ARB                                   0x2011
+#define WGL_STEREO_ARB                                          0x2012
+#define WGL_PIXEL_TYPE_ARB                                      0x2013
+#define WGL_COLOR_BITS_ARB                                      0x2014
+#define WGL_RED_BITS_ARB                                        0x2015
+#define WGL_RED_SHIFT_ARB                                       0x2016
+#define WGL_GREEN_BITS_ARB                                      0x2017
+#define WGL_GREEN_SHIFT_ARB                                     0x2018
+#define WGL_BLUE_BITS_ARB                                       0x2019
+#define WGL_BLUE_SHIFT_ARB                                      0x201A
+#define WGL_ALPHA_BITS_ARB                                      0x201B
+#define WGL_ALPHA_SHIFT_ARB                                     0x201C
+#define WGL_ACCUM_BITS_ARB                                      0x201D
+#define WGL_ACCUM_RED_BITS_ARB                                  0x201E
+#define WGL_ACCUM_GREEN_BITS_ARB                                0x201F
+#define WGL_ACCUM_BLUE_BITS_ARB                                 0x2020
+#define WGL_ACCUM_ALPHA_BITS_ARB                                0x2021
+#define WGL_DEPTH_BITS_ARB                                      0x2022
+#define WGL_STENCIL_BITS_ARB                                    0x2023
+#define WGL_AUX_BUFFERS_ARB                                     0x2024
+#define WGL_NO_ACCELERATION_ARB                                 0x2025
+#define WGL_GENERIC_ACCELERATION_ARB                            0x2026
+#define WGL_FULL_ACCELERATION_ARB                               0x2027
+#define WGL_SWAP_EXCHANGE_ARB                                   0x2028
+#define WGL_SWAP_COPY_ARB                                       0x2029
+#define WGL_SWAP_UNDEFINED_ARB                                  0x202A
+#define WGL_TYPE_RGBA_ARB                                       0x202B
+#define WGL_TYPE_COLORINDEX_ARB                                 0x202C
+
+typedef BOOL (APIENTRY * wglGetPixelFormatAttribivARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues);
+typedef BOOL (APIENTRY * wglGetPixelFormatAttribfvARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues);
+typedef BOOL (APIENTRY * wglChoosePixelFormatARBPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
+
+extern GLEW_EXPORT wglGetPixelFormatAttribivARBPROC wglGetPixelFormatAttribivARB;
+extern GLEW_EXPORT wglGetPixelFormatAttribfvARBPROC wglGetPixelFormatAttribfvARB;
+extern GLEW_EXPORT wglChoosePixelFormatARBPROC wglChoosePixelFormatARB;
+
+#endif /* WGL_ARB_pixel_format */
+
+/* --------------------------- ARB_render_texture ------------------------- */
+
+#ifdef WGL_ARB_render_texture
+
+#define WGL_BIND_TO_TEXTURE_RGB_ARB                             0x2070
+#define WGL_BIND_TO_TEXTURE_RGBA_ARB                            0x2071
+#define WGL_TEXTURE_FORMAT_ARB                                  0x2072
+#define WGL_TEXTURE_TARGET_ARB                                  0x2073
+#define WGL_MIPMAP_TEXTURE_ARB                                  0x2074
+#define WGL_TEXTURE_RGB_ARB                                     0x2075
+#define WGL_TEXTURE_RGBA_ARB                                    0x2076
+#define WGL_NO_TEXTURE_ARB                                      0x2077
+#define WGL_TEXTURE_CUBE_MAP_ARB                                0x2078
+#define WGL_TEXTURE_1D_ARB                                      0x2079
+#define WGL_TEXTURE_2D_ARB                                      0x207A
+#define WGL_NO_TEXTURE_ARB                                      0x2077
+#define WGL_MIPMAP_LEVEL_ARB                                    0x207B
+#define WGL_CUBE_MAP_FACE_ARB                                   0x207C
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB                     0x207D
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB                     0x207E
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB                     0x207F
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB                     0x2080
+#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB                     0x2081
+#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB                     0x2082
+#define WGL_FRONT_LEFT_ARB                                      0x2083
+#define WGL_FRONT_RIGHT_ARB                                     0x2084
+#define WGL_BACK_LEFT_ARB                                       0x2085
+#define WGL_BACK_RIGHT_ARB                                      0x2086
+#define WGL_AUX0_ARB                                            0x2087
+#define WGL_AUX1_ARB                                            0x2088
+#define WGL_AUX2_ARB                                            0x2089
+#define WGL_AUX3_ARB                                            0x208A
+#define WGL_AUX4_ARB                                            0x208B
+#define WGL_AUX5_ARB                                            0x208C
+#define WGL_AUX6_ARB                                            0x208D
+#define WGL_AUX7_ARB                                            0x208E
+#define WGL_AUX8_ARB                                            0x208F
+#define WGL_AUX9_ARB                                            0x2090
+
+typedef BOOL (APIENTRY * wglBindTexImageARBPROC) (HPBUFFERARB hPbuffer, int iBuffer);
+typedef BOOL (APIENTRY * wglReleaseTexImageARBPROC) (HPBUFFERARB hPbuffer, int iBuffer);
+typedef BOOL (APIENTRY * wglSetPbufferAttribARBPROC) (HPBUFFERARB hPbuffer, const int *piAttribList);
+
+extern GLEW_EXPORT wglBindTexImageARBPROC wglBindTexImageARB;
+extern GLEW_EXPORT wglReleaseTexImageARBPROC wglReleaseTexImageARB;
+extern GLEW_EXPORT wglSetPbufferAttribARBPROC wglSetPbufferAttribARB;
+
+#endif /* WGL_ARB_render_texture */
+
+/* ----------------------------- EXT_depth_float -------------------------- */
+
+#ifdef WGL_EXT_depth_float
+
+#define WGL_DEPTH_FLOAT_EXT                                     0x2040
+
+#endif /* WGL_EXT_depth_float */
+
+/* ------------------------- EXT_display_color_table ---------------------- */
+
+#ifdef WGL_EXT_display_color_table
+
+typedef GLboolean (APIENTRY * wglCreateDisplayColorTableEXTPROC) (GLushort id);
+typedef GLboolean (APIENTRY * wglLoadDisplayColorTableEXTPROC) (const GLushort *table, GLuint length);
+typedef GLboolean (APIENTRY * wglBindDisplayColorTableEXTPROC) (GLushort id);
+typedef void (APIENTRY * wglDestroyDisplayColorTableEXTPROC) (GLushort id);
+
+extern GLEW_EXPORT wglCreateDisplayColorTableEXTPROC wglCreateDisplayColorTableEXT;
+extern GLEW_EXPORT wglLoadDisplayColorTableEXTPROC wglLoadDisplayColorTableEXT;
+extern GLEW_EXPORT wglBindDisplayColorTableEXTPROC wglBindDisplayColorTableEXT;
+extern GLEW_EXPORT wglDestroyDisplayColorTableEXTPROC wglDestroyDisplayColorTableEXT;
+
+#endif /* WGL_EXT_display_color_table */
+
+/* -------------------------- EXT_extensions_string ----------------------- */
+
+#ifdef WGL_EXT_extensions_string
+
+typedef const char* (APIENTRY * wglGetExtensionsStringEXTPROC) ();
+
+extern GLEW_EXPORT wglGetExtensionsStringEXTPROC wglGetExtensionsStringEXT;
+
+#endif /* WGL_EXT_extensions_string */
+
+/* -------------------------- EXT_make_current_read ----------------------- */
+
+#ifdef WGL_EXT_make_current_read
+
+#define ERROR_INVALID_PIXEL_TYPE_EXT                            0x2043
+
+typedef BOOL (APIENTRY * wglMakeContextCurrentEXTPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc);
+typedef HDC (APIENTRY * wglGetCurrentReadDCEXTPROC) (void);
+
+extern GLEW_EXPORT wglMakeContextCurrentEXTPROC wglMakeContextCurrentEXT;
+extern GLEW_EXPORT wglGetCurrentReadDCEXTPROC wglGetCurrentReadDCEXT;
+
+#endif /* WGL_EXT_make_current_read */
+
+/* ----------------------------- EXT_multisample -------------------------- */
+
+#ifdef WGL_EXT_multisample
+
+#define WGL_SAMPLE_BUFFERS_EXT                                  0x2041
+#define WGL_SAMPLES_EXT                                         0x2042
+
+#endif /* WGL_EXT_multisample */
+
+/* ----------------------------- EXT_pixel_format ------------------------- */
+
+#ifdef WGL_EXT_pixel_format
+
+#define WGL_NUMBER_PIXEL_FORMATS_EXT                            0x2000
+#define WGL_DRAW_TO_WINDOW_EXT                                  0x2001
+#define WGL_DRAW_TO_BITMAP_EXT                                  0x2002
+#define WGL_ACCELERATION_EXT                                    0x2003
+#define WGL_NEED_PALETTE_EXT                                    0x2004
+#define WGL_NEED_SYSTEM_PALETTE_EXT                             0x2005
+#define WGL_SWAP_LAYER_BUFFERS_EXT                              0x2006
+#define WGL_SWAP_METHOD_EXT                                     0x2007
+#define WGL_NUMBER_OVERLAYS_EXT                                 0x2008
+#define WGL_NUMBER_UNDERLAYS_EXT                                0x2009
+#define WGL_TRANSPARENT_EXT                                     0x200A
+#define WGL_TRANSPARENT_VALUE_EXT                               0x200B
+#define WGL_SHARE_DEPTH_EXT                                     0x200C
+#define WGL_SHARE_STENCIL_EXT                                   0x200D
+#define WGL_SHARE_ACCUM_EXT                                     0x200E
+#define WGL_SUPPORT_GDI_EXT                                     0x200F
+#define WGL_SUPPORT_OPENGL_EXT                                  0x2010
+#define WGL_DOUBLE_BUFFER_EXT                                   0x2011
+#define WGL_STEREO_EXT                                          0x2012
+#define WGL_PIXEL_TYPE_EXT                                      0x2013
+#define WGL_COLOR_BITS_EXT                                      0x2014
+#define WGL_RED_BITS_EXT                                        0x2015
+#define WGL_RED_SHIFT_EXT                                       0x2016
+#define WGL_GREEN_BITS_EXT                                      0x2017
+#define WGL_GREEN_SHIFT_EXT                                     0x2018
+#define WGL_BLUE_BITS_EXT                                       0x2019
+#define WGL_BLUE_SHIFT_EXT                                      0x201A
+#define WGL_ALPHA_BITS_EXT                                      0x201B
+#define WGL_ALPHA_SHIFT_EXT                                     0x201C
+#define WGL_ACCUM_BITS_EXT                                      0x201D
+#define WGL_ACCUM_RED_BITS_EXT                                  0x201E
+#define WGL_ACCUM_GREEN_BITS_EXT                                0x201F
+#define WGL_ACCUM_BLUE_BITS_EXT                                 0x2020
+#define WGL_ACCUM_ALPHA_BITS_EXT                                0x2021
+#define WGL_DEPTH_BITS_EXT                                      0x2022
+#define WGL_STENCIL_BITS_EXT                                    0x2023
+#define WGL_AUX_BUFFERS_EXT                                     0x2024
+#define WGL_NO_ACCELERATION_EXT                                 0x2025
+#define WGL_GENERIC_ACCELERATION_EXT                            0x2026
+#define WGL_FULL_ACCELERATION_EXT                               0x2027
+#define WGL_SWAP_EXCHANGE_EXT                                   0x2028
+#define WGL_SWAP_COPY_EXT                                       0x2029
+#define WGL_SWAP_UNDEFINED_EXT                                  0x202A
+#define WGL_TYPE_RGBA_EXT                                       0x202B
+#define WGL_TYPE_COLORINDEX_EXT                                 0x202C
+
+typedef BOOL (APIENTRY * wglGetPixelFormatAttribivEXTPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, int *piValues);
+typedef BOOL (APIENTRY * wglGetPixelFormatAttribfvEXTPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, FLOAT *pfValues);
+typedef BOOL (APIENTRY * wglChoosePixelFormatEXTPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
+
+extern GLEW_EXPORT wglGetPixelFormatAttribivEXTPROC wglGetPixelFormatAttribivEXT;
+extern GLEW_EXPORT wglGetPixelFormatAttribfvEXTPROC wglGetPixelFormatAttribfvEXT;
+extern GLEW_EXPORT wglChoosePixelFormatEXTPROC wglChoosePixelFormatEXT;
+
+#endif /* WGL_EXT_pixel_format */
+
+/* ------------------------------- EXT_pbuffer ---------------------------- */
+
+#ifdef WGL_EXT_pbuffer
+
+#define WGL_DRAW_TO_PBUFFER_EXT                                 0x202D
+#define WGL_MAX_PBUFFER_PIXELS_EXT                              0x202E
+#define WGL_MAX_PBUFFER_WIDTH_EXT                               0x202F
+#define WGL_MAX_PBUFFER_HEIGHT_EXT                              0x2030
+#define WGL_OPTIMAL_PBUFFER_WIDTH_EXT                           0x2031
+#define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT                          0x2032
+#define WGL_PBUFFER_LARGEST_EXT                                 0x2033
+#define WGL_PBUFFER_WIDTH_EXT                                   0x2034
+#define WGL_PBUFFER_HEIGHT_EXT                                  0x2035
+
+DECLARE_HANDLE(HPBUFFEREXT);
+
+typedef HPBUFFEREXT (APIENTRY * wglCreatePbufferEXTPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
+typedef HDC (APIENTRY * wglGetPbufferDCEXTPROC) (HPBUFFEREXT hPbuffer);
+typedef int (APIENTRY * wglReleasePbufferDCEXTPROC) (HPBUFFEREXT hPbuffer, HDC hDC);
+typedef BOOL (APIENTRY * wglDestroyPbufferEXTPROC) (HPBUFFEREXT hPbuffer);
+typedef BOOL (APIENTRY * wglQueryPbufferEXTPROC) (HPBUFFEREXT hPbuffer, int iAttribute, int *piValue);
+
+extern GLEW_EXPORT wglCreatePbufferEXTPROC wglCreatePbufferEXT;
+extern GLEW_EXPORT wglGetPbufferDCEXTPROC wglGetPbufferDCEXT;
+extern GLEW_EXPORT wglReleasePbufferDCEXTPROC wglReleasePbufferDCEXT;
+extern GLEW_EXPORT wglDestroyPbufferEXTPROC wglDestroyPbufferEXT;
+extern GLEW_EXPORT wglQueryPbufferEXTPROC wglQueryPbufferEXT;
+
+#endif /* WGL_EXT_pbuffer */
+
+/* ---------------------------- EXT_swap_control -------------------------- */
+
+#ifdef WGL_EXT_swap_control
+
+typedef BOOL (APIENTRY * wglSwapIntervalEXTPROC) (int interval);
+typedef int (APIENTRY * wglGetSwapIntervalEXTPROC) (void);
+
+extern GLEW_EXPORT wglSwapIntervalEXTPROC wglSwapIntervalEXT;
+extern GLEW_EXPORT wglGetSwapIntervalEXTPROC wglGetSwapIntervalEXT;
+
+#endif /* WGL_EXT_swap_control */
+
+/* ------------------------ I3D_digital_video_control --------------------- */
+
+#ifdef WGL_I3D_digital_video_control
+
+#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D          0x2050
+#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D                0x2051
+#define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D                   0x2052
+#define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D                   0x2053
+
+typedef BOOL (APIENTRY * wglGetDigitalVideoParametersI3DPROC) (HDC hDC, int iAttribute, int *piValue);
+typedef BOOL (APIENTRY * wglSetDigitalVideoParametersI3DPROC) (HDC hDC, int iAttribute, const int *piValue);
+
+extern GLEW_EXPORT wglGetDigitalVideoParametersI3DPROC wglGetDigitalVideoParametersI3D;
+extern GLEW_EXPORT wglSetDigitalVideoParametersI3DPROC wglSetDigitalVideoParametersI3D;
+
+#endif /* WGL_I3D_digital_video_control */
+
+/* -------------------------------- I3D_gamma ----------------------------- */
+
+#ifdef WGL_I3D_gamma
+
+#define WGL_GAMMA_TABLE_SIZE_I3D                                0x204E
+#define WGL_GAMMA_EXCLUDE_DESKTOP_I3D                           0x204F
+
+typedef BOOL (APIENTRY * wglGetGammaTableParametersI3DPROC) (HDC hDC, int iAttribute, int *piValue);
+typedef BOOL (APIENTRY * wglSetGammaTableParametersI3DPROC) (HDC hDC, int iAttribute, const int *piValue);
+typedef BOOL (APIENTRY * wglGetGammaTableI3DPROC) (HDC hDC, int iEntries, USHORT *puRed, USHORT *puGreen, USHORT *puBlue);
+typedef BOOL (APIENTRY * wglSetGammaTableI3DPROC) (HDC hDC, int iEntries, const USHORT *puRed, const USHORT *puGreen, const USHORT *puBlue);
+
+extern GLEW_EXPORT wglGetGammaTableParametersI3DPROC wglGetGammaTableParametersI3D;
+extern GLEW_EXPORT wglSetGammaTableParametersI3DPROC wglSetGammaTableParametersI3D;
+extern GLEW_EXPORT wglGetGammaTableI3DPROC wglGetGammaTableI3D;
+extern GLEW_EXPORT wglSetGammaTableI3DPROC wglSetGammaTableI3D;
+
+#endif /* WGL_I3D_gamma */
+
+/* ------------------------------- I3D_genlock ---------------------------- */
+
+#ifdef WGL_I3D_genlock
+
+#define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D                        0x2044
+#define WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D                     0x2045
+#define WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D                    0x2046
+#define WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D                      0x2047
+#define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D                     0x2048
+#define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D                    0x2049
+#define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D                     0x204A
+#define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D                      0x204B
+#define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D                        0x204C
+
+typedef BOOL (APIENTRY * wglEnableGenlockI3DPROC) (HDC hDC);
+typedef BOOL (APIENTRY * wglDisableGenlockI3DPROC) (HDC hDC);
+typedef BOOL (APIENTRY * wglIsEnabledGenlockI3DPROC) (HDC hDC, BOOL *pFlag);
+typedef BOOL (APIENTRY * wglGenlockSourceI3DPROC) (HDC hDC, UINT uSource);
+typedef BOOL (APIENTRY * wglGetGenlockSourceI3DPROC) (HDC hDC, UINT *uSource);
+typedef BOOL (APIENTRY * wglGenlockSourceEdgeI3DPROC) (HDC hDC, UINT uEdge);
+typedef BOOL (APIENTRY * wglGetGenlockSourceEdgeI3DPROC) (HDC hDC, UINT *uEdge);
+typedef BOOL (APIENTRY * wglGenlockSampleRateI3DPROC) (HDC hDC, UINT uRate);
+typedef BOOL (APIENTRY * wglGetGenlockSampleRateI3DPROC) (HDC hDC, UINT *uRate);
+typedef BOOL (APIENTRY * wglGenlockSourceDelayI3DPROC) (HDC hDC, UINT uDelay);
+typedef BOOL (APIENTRY * wglGetGenlockSourceDelayI3DPROC) (HDC hDC, UINT *uDelay);
+typedef BOOL (APIENTRY * wglQueryGenlockMaxSourceDelayI3DPROC) (HDC hDC, UINT *uMaxLineDelay, UINT *uMaxPixelDelay);
+
+extern GLEW_EXPORT wglEnableGenlockI3DPROC wglEnableGenlockI3D;
+extern GLEW_EXPORT wglDisableGenlockI3DPROC wglDisableGenlockI3D;
+extern GLEW_EXPORT wglIsEnabledGenlockI3DPROC wglIsEnabledGenlockI3D;
+extern GLEW_EXPORT wglGenlockSourceI3DPROC wglGenlockSourceI3D;
+extern GLEW_EXPORT wglGetGenlockSourceI3DPROC wglGetGenlockSourceI3D;
+extern GLEW_EXPORT wglGenlockSourceEdgeI3DPROC wglGenlockSourceEdgeI3D;
+extern GLEW_EXPORT wglGetGenlockSourceEdgeI3DPROC wglGetGenlockSourceEdgeI3D;
+extern GLEW_EXPORT wglGenlockSampleRateI3DPROC wglGenlockSampleRateI3D;
+extern GLEW_EXPORT wglGetGenlockSampleRateI3DPROC wglGetGenlockSampleRateI3D;
+extern GLEW_EXPORT wglGenlockSourceDelayI3DPROC wglGenlockSourceDelayI3D;
+extern GLEW_EXPORT wglGetGenlockSourceDelayI3DPROC wglGetGenlockSourceDelayI3D;
+extern GLEW_EXPORT wglQueryGenlockMaxSourceDelayI3DPROC wglQueryGenlockMaxSourceDelayI3D;
+
+#endif /* WGL_I3D_genlock */
+
+/* ---------------------------- I3D_image_buffer -------------------------- */
+
+#ifdef WGL_I3D_image_buffer
+
+#define WGL_IMAGE_BUFFER_MIN_ACCESS_I3D                         0x00000001
+#define WGL_IMAGE_BUFFER_LOCK_I3D                               0x00000002
+
+typedef LPVOID (APIENTRY * wglCreateImageBufferI3DPROC) (HDC hDC, DWORD dwSize, UINT uFlags);
+typedef BOOL (APIENTRY * wglDestroyImageBufferI3DPROC) (HDC hDC, LPVOID pAddress);
+typedef BOOL (APIENTRY * wglAssociateImageBufferEventsI3DPROC) (HDC hDC, const HANDLE *pEvent, const LPVOID *pAddress, const DWORD *pSize, UINT count);
+typedef BOOL (APIENTRY * wglReleaseImageBufferEventsI3DPROC) (HDC hDC, const LPVOID *pAddress, UINT count);
+
+extern GLEW_EXPORT wglCreateImageBufferI3DPROC wglCreateImageBufferI3D;
+extern GLEW_EXPORT wglDestroyImageBufferI3DPROC wglDestroyImageBufferI3D;
+extern GLEW_EXPORT wglAssociateImageBufferEventsI3DPROC wglAssociateImageBufferEventsI3D; 
+extern GLEW_EXPORT wglReleaseImageBufferEventsI3DPROC wglReleaseImageBufferEventsI3D;
+
+#endif /* WGL_I3D_image_buffer */
+
+/* --------------------------- I3D_swap_frame_lock ------------------------ */
+
+#ifdef WGL_I3D_swap_frame_lock
+
+typedef BOOL (APIENTRY * wglEnableFrameLockI3DPROC) (void);
+typedef BOOL (APIENTRY * wglDisableFrameLockI3DPROC) (void);
+typedef BOOL (APIENTRY * wglIsEnabledFrameLockI3DPROC) (BOOL *pFlag);
+typedef BOOL (APIENTRY * wglQueryFrameLockMasterI3DPROC) (BOOL *pFlag);
+
+extern GLEW_EXPORT wglEnableFrameLockI3DPROC wglEnableFrameLockI3D;
+extern GLEW_EXPORT wglDisableFrameLockI3DPROC wglDisableFrameLockI3D;
+extern GLEW_EXPORT wglIsEnabledFrameLockI3DPROC wglIsEnabledFrameLockI3D;
+extern GLEW_EXPORT wglQueryFrameLockMasterI3DPROC wglQueryFrameLockMasterI3D;
+
+#endif /* WGL_I3D_swap_frame_lock */
+
+/* -------------------------- I3D_swap_frame_usage ------------------------ */
+
+#ifdef WGL_I3D_swap_frame_usage
+
+typedef BOOL (APIENTRY * wglGetFrameUsageI3DPROC) (float *pUsage);
+typedef BOOL (APIENTRY * wglBeginFrameTrackingI3DPROC) (void);
+typedef BOOL (APIENTRY * wglEndFrameTrackingI3DPROC) (void);
+typedef BOOL (APIENTRY * wglQueryFrameTrackingI3DPROC) (DWORD *pFrameCount, DWORD *pMissedFrames, float *pLastMissedUsage);
+
+extern GLEW_EXPORT wglGetFrameUsageI3DPROC wglGetFrameUsageI3D;
+extern GLEW_EXPORT wglBeginFrameTrackingI3DPROC wglBeginFrameTrackingI3D;
+extern GLEW_EXPORT wglEndFrameTrackingI3DPROC wglEndFrameTrackingI3D;
+extern GLEW_EXPORT wglQueryFrameTrackingI3DPROC wglQueryFrameTrackingI3D;
+
+#endif /* WGL_I3D_swap_frame_usage */
+
+/* ---------------------------- OML_sync_control -------------------------- */
+
+#ifdef WGL_OML_sync_control
+
+typedef BOOL (APIENTRY * wglGetSyncValuesOMLPROC) (HDC hdc, INT64 *ust, INT64 *msc, INT64 *sbc);
+typedef BOOL (APIENTRY * wglGetMscRateOMLPROC) (HDC hdc, INT32 *numerator, INT32 *denominator);
+typedef INT64 (APIENTRY * wglSwapBuffersMscOMLPROC) (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder);
+typedef INT64 (APIENTRY * wglSwapLayerBuffersMscOMLPROC) (HDC hdc, int fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder);
+typedef BOOL (APIENTRY * wglWaitForMscOMLPROC) (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64 *ust, INT64 *msc, INT64 *sbc);
+typedef BOOL (APIENTRY * wglWaitForSbcOMLPROC) (HDC hdc, INT64 target_sbc, INT64 *ust, INT64 *msc, INT64 *sbc);
+
+extern GLEW_EXPORT wglGetSyncValuesOMLPROC wglGetSyncValuesOML;
+extern GLEW_EXPORT wglGetMscRateOMLPROC wglGetMscRateOML;
+extern GLEW_EXPORT wglSwapBuffersMscOMLPROC wglSwapBuffersMscOML;
+extern GLEW_EXPORT wglSwapLayerBuffersMscOMLPROC wglSwapLayerBuffersMscOML;
+extern GLEW_EXPORT wglWaitForMscOMLPROC wglWaitForMscOML;
+extern GLEW_EXPORT wglWaitForSbcOMLPROC wglWaitForSbcOML;
+
+#endif /* WGL_OML_sync_control */
+
+/* ------------------------- ATI_pixel_format_float ----------------------- */
+
+#ifdef WGL_ATI_pixel_format_float
+
+#define WGL_TYPE_RGBA_FLOAT_ATI                                 0x21A0
+#define GL_TYPE_RGBA_FLOAT_ATI                                  0x8820
+#define GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI                      0x8835
+
+#endif /* WGL_ATI_pixel_format_float */
+
+/* ---------------------------- NV_float_buffer --------------------------- */
+
+#ifdef WGL_NV_float_buffer
+
+#define WGL_FLOAT_COMPONENTS_NV                                 0x20B0
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV                0x20B1
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV               0x20B2
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV              0x20B3
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV             0x20B4
+#define WGL_TEXTURE_FLOAT_R_NV                                  0x20B5
+#define WGL_TEXTURE_FLOAT_RG_NV                                 0x20B6
+#define WGL_TEXTURE_FLOAT_RGB_NV                                0x20B7
+#define WGL_TEXTURE_FLOAT_RGBA_NV                               0x20B8
+
+#endif /* WGL_NV_float_buffer */
+
+/* ------------------------- NV_render_depth_texture ---------------------- */
+
+#ifdef WGL_NV_render_depth_texture
+
+#define WGL_BIND_TO_TEXTURE_DEPTH_NV                            0x20A3
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV                  0x20A4
+#define WGL_DEPTH_TEXTURE_FORMAT_NV                             0x20A5
+#define WGL_TEXTURE_DEPTH_COMPONENT_NV                          0x20A6
+#define WGL_NO_TEXTURE_ARB                                      0x2077
+#define WGL_DEPTH_COMPONENT_NV                                  0x20A7
+
+#endif /* WGL_NV_render_depth_texture */
+
+/* ----------------------- NV_render_texture_rectangle -------------------- */
+
+#ifdef WGL_NV_render_texture_rectangle 
+
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV                    0x20A0
+#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV                   0x20A1
+#define WGL_TEXTURE_RECTANGLE_NV                                0x20A2
+
+#endif /* WGL_NV_render_texture_rectangle */
+
+/* ------------------------- NV_vertex_array_range ------------------------ */
+
+#ifdef WGL_NV_vertex_array_range
+
+typedef void * (APIENTRY * wglAllocateMemoryNVPROC) (GLsizei size, GLfloat readFrequency, GLfloat writeFrequency, GLfloat priority);
+typedef void (APIENTRY * wglFreeMemoryNVPROC) (void *pointer);
+
+extern GLEW_EXPORT wglAllocateMemoryNVPROC wglAllocateMemoryNV;
+extern GLEW_EXPORT wglFreeMemoryNVPROC wglFreeMemoryNV;
+
+#endif /* WGL_NV_vertex_array_range */
+
+/* ------------------------------------------------------------------------ */
+
+struct WGLEW
+{
+  unsigned int ARB_buffer_region : 1;
+  unsigned int ARB_extensions_string : 1;
+  unsigned int ARB_make_current_read : 1;
+  unsigned int ARB_multisample : 1;
+  unsigned int ARB_pbuffer : 1;
+  unsigned int ARB_pixel_format : 1;
+  unsigned int ARB_render_texture : 1;
+
+  unsigned int EXT_depth_float : 1;
+  unsigned int EXT_display_color_table : 1;
+  unsigned int EXT_extensions_string : 1;
+  unsigned int EXT_make_current_read : 1;
+  unsigned int EXT_multisample : 1;
+  unsigned int EXT_pixel_format : 1;
+  unsigned int EXT_pbuffer : 1;
+  unsigned int EXT_swap_control : 1;
+
+  unsigned int I3D_digital_video_control : 1;
+  unsigned int I3D_gamma : 1;
+  unsigned int I3D_genlock : 1;
+  unsigned int I3D_image_buffer : 1;
+  unsigned int I3D_swap_frame_lock : 1;
+  unsigned int I3D_swap_frame_usage : 1;
+  unsigned int OML_sync_control : 1;
+
+  unsigned int ATI_pixel_format_float : 1;
+
+  unsigned int NV_float_buffer : 1;
+  unsigned int NV_render_depth_texture : 1;
+  unsigned int NV_render_texture_rectangle : 1;
+  unsigned int NV_vertex_array_range : 1;
+};
+
+extern GLEW_EXPORT struct WGLEW wglew;
+
+#ifdef __cplusplus
+}
+#endif
+
+#undef GLEW_EXPORT
+
+#endif /* _WIN32 */
+
+#endif /* __wglew_h__ */
diff --git a/lib/.do.not.remove b/lib/.do.not.remove
new file mode 100644
index 0000000..e69de29
diff --git a/src/glew.c b/src/glew.c
new file mode 100644
index 0000000..7f02124
--- /dev/null
+++ b/src/glew.c
@@ -0,0 +1,3383 @@
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: This software was created using the
+** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+** not been independently verified as being compliant with the OpenGL(R)
+** version 1.2.1 Specification.
+*/
+
+/*
+** The contents of this file are subject to the GLX Public License Version 1.0
+** (the "License"). You may not use this file except in compliance with the
+** License. You may obtain a copy of the License at Silicon Graphics, Inc.,
+** attn: Legal Services, 2011 N. Shoreline Blvd., Mountain View, CA 94043
+** or at http://www.sgi.com/software/opensource/glx/license.html.
+**
+** Software distributed under the License is distributed on an "AS IS"
+** basis. ALL WARRANTIES ARE DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY
+** IMPLIED WARRANTIES OF MERCHANTABILITY, OF FITNESS FOR A PARTICULAR
+** PURPOSE OR OF NON- INFRINGEMENT. See the License for the specific
+** language governing rights and limitations under the License.
+**
+** The Original Software is GLX version 1.2 source code, released February,
+** 1999. The developer of the Original Software is Silicon Graphics, Inc.
+** Those portions of the Subject Software created by Silicon Graphics, Inc.
+** are Copyright (c) 1991-9 Silicon Graphics, Inc. All Rights Reserved.
+*/
+
+/*
+** Copyright (C) 2002, Lev Povalahev
+** All rights reserved.
+** 
+** Redistribution and use in source and binary forms, with or without modification, 
+** are permitted provided that the following conditions are met:
+** 
+** * Redistributions of source code must retain the above copyright notice, 
+**   this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright notice, 
+**   this list of conditions and the following disclaimer in the documentation 
+**   and/or other materials provided with the distribution.
+** * The name of the author may be used to endorse or promote products 
+**   derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
+** IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+** INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+** BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 
+** OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+** WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
+** THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+** The OpenGL Extension Wrangler Library
+** Copyright (C) 2002 Milan Ikits
+**
+** This library is free software; you can redistribute it and/or
+** modify it under the terms of the GNU Lesser General Public
+** License as published by the Free Software Foundation; either
+** version 2.1 of the License, or (at your option) any later version.
+**
+** This library is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+** Lesser General Public License for more details.
+**
+** You should have received a copy of the GNU Lesser General Public
+** License along with this library; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include 
+#include 
+#include 
+
+#ifdef _WIN32
+#define glewGetProcAddress(name) wglGetProcAddress(name)
+#else
+#define glewGetProcAddress(name) (*glXGetProcAddressARB)(name)
+#endif
+
+/* ------------------------------ OpenGL 1.2 ------------------------------ */
+
+#ifdef GL_VERSION_1_2
+glCopyTexSubImage3DPROC glCopyTexSubImage3D = NULL;
+glDrawRangeElementsPROC glDrawRangeElements = NULL;
+glTexImage3DPROC glTexImage3D = NULL;
+glTexSubImage3DPROC glTexSubImage3D = NULL;
+
+static GLboolean _glewInit_12 ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glCopyTexSubImage3D = (glCopyTexSubImage3DPROC)glewGetProcAddress("glCopyTexSubImage3D")) == NULL;
+  r = r || (glDrawRangeElements = (glDrawRangeElementsPROC)glewGetProcAddress("glDrawRangeElements")) == NULL;
+  r = r || (glTexImage3D = (glTexImage3DPROC)glewGetProcAddress("glTexImage3D")) == NULL;
+  r = r || (glTexSubImage3D = (glTexSubImage3DPROC)glewGetProcAddress("glTexSubImage3D")) == NULL;
+  return r;
+}
+#endif /* GL_VERSION_1_2 */
+
+/* ------------------------------ OpenGL 1.3 ------------------------------ */
+
+#ifdef GL_VERSION_1_3
+glActiveTexturePROC glActiveTexture = NULL;
+glClientActiveTexturePROC glClientActiveTexture = NULL;
+glMultiTexCoord1dPROC glMultiTexCoord1d = NULL;
+glMultiTexCoord1dvPROC glMultiTexCoord1dv = NULL;
+glMultiTexCoord1fPROC glMultiTexCoord1f = NULL;
+glMultiTexCoord1fvPROC glMultiTexCoord1fv = NULL;
+glMultiTexCoord1iPROC glMultiTexCoord1i = NULL;
+glMultiTexCoord1ivPROC glMultiTexCoord1iv = NULL;
+glMultiTexCoord1sPROC glMultiTexCoord1s = NULL;
+glMultiTexCoord1svPROC glMultiTexCoord1sv = NULL;
+glMultiTexCoord2dPROC glMultiTexCoord2d = NULL;
+glMultiTexCoord2dvPROC glMultiTexCoord2dv = NULL;
+glMultiTexCoord2fPROC glMultiTexCoord2f = NULL;
+glMultiTexCoord2fvPROC glMultiTexCoord2fv = NULL;
+glMultiTexCoord2iPROC glMultiTexCoord2i = NULL;
+glMultiTexCoord2ivPROC glMultiTexCoord2iv = NULL;
+glMultiTexCoord2sPROC glMultiTexCoord2s = NULL;
+glMultiTexCoord2svPROC glMultiTexCoord2sv = NULL;
+glMultiTexCoord3dPROC glMultiTexCoord3d = NULL;
+glMultiTexCoord3dvPROC glMultiTexCoord3dv = NULL;
+glMultiTexCoord3fPROC glMultiTexCoord3f = NULL;
+glMultiTexCoord3fvPROC glMultiTexCoord3fv = NULL;
+glMultiTexCoord3iPROC glMultiTexCoord3i = NULL;
+glMultiTexCoord3ivPROC glMultiTexCoord3iv = NULL;
+glMultiTexCoord3sPROC glMultiTexCoord3s = NULL;
+glMultiTexCoord3svPROC glMultiTexCoord3sv = NULL;
+glMultiTexCoord4dPROC glMultiTexCoord4d = NULL;
+glMultiTexCoord4dvPROC glMultiTexCoord4dv = NULL;
+glMultiTexCoord4fPROC glMultiTexCoord4f = NULL;
+glMultiTexCoord4fvPROC glMultiTexCoord4fv = NULL;
+glMultiTexCoord4iPROC glMultiTexCoord4i = NULL;
+glMultiTexCoord4ivPROC glMultiTexCoord4iv = NULL;
+glMultiTexCoord4sPROC glMultiTexCoord4s = NULL;
+glMultiTexCoord4svPROC glMultiTexCoord4sv = NULL;
+glLoadTransposeMatrixfPROC glLoadTransposeMatrixf = NULL;
+glLoadTransposeMatrixdPROC glLoadTransposeMatrixd = NULL;
+glMultTransposeMatrixfPROC glMultTransposeMatrixf = NULL;
+glMultTransposeMatrixdPROC glMultTransposeMatrixd = NULL;
+glCompressedTexImage3DPROC glCompressedTexImage3D = NULL;
+glCompressedTexImage2DPROC glCompressedTexImage2D = NULL;
+glCompressedTexImage1DPROC glCompressedTexImage1D = NULL;
+glCompressedTexSubImage3DPROC glCompressedTexSubImage3D = NULL;
+glCompressedTexSubImage2DPROC glCompressedTexSubImage2D = NULL;
+glCompressedTexSubImage1DPROC glCompressedTexSubImage1D = NULL;
+glGetCompressedTexImagePROC glGetCompressedTexImage = NULL;
+glSampleCoveragePROC glSampleCoverage = NULL;
+
+static GLboolean _glewInit_13 ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glActiveTexture = (glActiveTexturePROC)glewGetProcAddress("glActiveTexture")) == NULL;
+  r = r || (glClientActiveTexture = (glClientActiveTexturePROC)glewGetProcAddress("glClientActiveTexture")) == NULL;
+  r = r || (glMultiTexCoord1d = (glMultiTexCoord1dPROC)glewGetProcAddress("glMultiTexCoord1d")) == NULL;
+  r = r || (glMultiTexCoord1dv = (glMultiTexCoord1dvPROC)glewGetProcAddress("glMultiTexCoord1dv")) == NULL;
+  r = r || (glMultiTexCoord1f = (glMultiTexCoord1fPROC)glewGetProcAddress("glMultiTexCoord1f")) == NULL;
+  r = r || (glMultiTexCoord1fv = (glMultiTexCoord1fvPROC)glewGetProcAddress("glMultiTexCoord1fv")) == NULL;
+  r = r || (glMultiTexCoord1i = (glMultiTexCoord1iPROC)glewGetProcAddress("glMultiTexCoord1i")) == NULL;
+  r = r || (glMultiTexCoord1iv = (glMultiTexCoord1ivPROC)glewGetProcAddress("glMultiTexCoord1iv")) == NULL;
+  r = r || (glMultiTexCoord1s = (glMultiTexCoord1sPROC)glewGetProcAddress("glMultiTexCoord1s")) == NULL;
+  r = r || (glMultiTexCoord1sv = (glMultiTexCoord1svPROC)glewGetProcAddress("glMultiTexCoord1sv")) == NULL;
+  r = r || (glMultiTexCoord2d = (glMultiTexCoord2dPROC)glewGetProcAddress("glMultiTexCoord2d")) == NULL;
+  r = r || (glMultiTexCoord2dv = (glMultiTexCoord2dvPROC)glewGetProcAddress("glMultiTexCoord2dv")) == NULL;
+  r = r || (glMultiTexCoord2f = (glMultiTexCoord2fPROC)glewGetProcAddress("glMultiTexCoord2f")) == NULL;
+  r = r || (glMultiTexCoord2fv = (glMultiTexCoord2fvPROC)glewGetProcAddress("glMultiTexCoord2fv")) == NULL;
+  r = r || (glMultiTexCoord2i = (glMultiTexCoord2iPROC)glewGetProcAddress("glMultiTexCoord2i")) == NULL;
+  r = r || (glMultiTexCoord2iv = (glMultiTexCoord2ivPROC)glewGetProcAddress("glMultiTexCoord2iv")) == NULL;
+  r = r || (glMultiTexCoord2s = (glMultiTexCoord2sPROC)glewGetProcAddress("glMultiTexCoord2s")) == NULL;
+  r = r || (glMultiTexCoord2sv = (glMultiTexCoord2svPROC)glewGetProcAddress("glMultiTexCoord2sv")) == NULL;
+  r = r || (glMultiTexCoord3d = (glMultiTexCoord3dPROC)glewGetProcAddress("glMultiTexCoord3d")) == NULL;
+  r = r || (glMultiTexCoord3dv = (glMultiTexCoord3dvPROC)glewGetProcAddress("glMultiTexCoord3dv")) == NULL;
+  r = r || (glMultiTexCoord3f = (glMultiTexCoord3fPROC)glewGetProcAddress("glMultiTexCoord3f")) == NULL;
+  r = r || (glMultiTexCoord3fv = (glMultiTexCoord3fvPROC)glewGetProcAddress("glMultiTexCoord3fv")) == NULL;
+  r = r || (glMultiTexCoord3i = (glMultiTexCoord3iPROC)glewGetProcAddress("glMultiTexCoord3i")) == NULL;
+  r = r || (glMultiTexCoord3iv = (glMultiTexCoord3ivPROC)glewGetProcAddress("glMultiTexCoord3iv")) == NULL;
+  r = r || (glMultiTexCoord3s = (glMultiTexCoord3sPROC)glewGetProcAddress("glMultiTexCoord3s")) == NULL;
+  r = r || (glMultiTexCoord3sv = (glMultiTexCoord3svPROC)glewGetProcAddress("glMultiTexCoord3sv")) == NULL;
+  r = r || (glMultiTexCoord4d = (glMultiTexCoord4dPROC)glewGetProcAddress("glMultiTexCoord4d")) == NULL;
+  r = r || (glMultiTexCoord4dv = (glMultiTexCoord4dvPROC)glewGetProcAddress("glMultiTexCoord4dv")) == NULL;
+  r = r || (glMultiTexCoord4f = (glMultiTexCoord4fPROC)glewGetProcAddress("glMultiTexCoord4f")) == NULL;
+  r = r || (glMultiTexCoord4fv = (glMultiTexCoord4fvPROC)glewGetProcAddress("glMultiTexCoord4fv")) == NULL;
+  r = r || (glMultiTexCoord4i = (glMultiTexCoord4iPROC)glewGetProcAddress("glMultiTexCoord4i")) == NULL;
+  r = r || (glMultiTexCoord4iv = (glMultiTexCoord4ivPROC)glewGetProcAddress("glMultiTexCoord4iv")) == NULL;
+  r = r || (glMultiTexCoord4s = (glMultiTexCoord4sPROC)glewGetProcAddress("glMultiTexCoord4s")) == NULL;
+  r = r || (glMultiTexCoord4sv = (glMultiTexCoord4svPROC)glewGetProcAddress("glMultiTexCoord4sv")) == NULL;
+  r = r || (glLoadTransposeMatrixf = (glLoadTransposeMatrixfPROC)glewGetProcAddress("glLoadTransposeMatrixf")) == NULL;
+  r = r || (glLoadTransposeMatrixd = (glLoadTransposeMatrixdPROC)glewGetProcAddress("glLoadTransposeMatrixd")) == NULL;
+  r = r || (glMultTransposeMatrixf = (glMultTransposeMatrixfPROC)glewGetProcAddress("glMultTransposeMatrixf")) == NULL;
+  r = r || (glMultTransposeMatrixd = (glMultTransposeMatrixdPROC)glewGetProcAddress("glMultTransposeMatrixd")) == NULL;
+  r = r || (glCompressedTexImage3D = (glCompressedTexImage3DPROC)glewGetProcAddress("glCompressedTexImage3D")) == NULL;
+  r = r || (glCompressedTexImage2D = (glCompressedTexImage2DPROC)glewGetProcAddress("glCompressedTexImage2D")) == NULL;
+  r = r || (glCompressedTexImage1D = (glCompressedTexImage1DPROC)glewGetProcAddress("glCompressedTexImage1D")) == NULL;
+  r = r || (glCompressedTexSubImage3D = (glCompressedTexSubImage3DPROC)glewGetProcAddress("glCompressedTexSubImage3D")) == NULL;
+  r = r || (glCompressedTexSubImage2D = (glCompressedTexSubImage2DPROC)glewGetProcAddress("glCompressedTexSubImage2D")) == NULL;
+  r = r || (glCompressedTexSubImage1D = (glCompressedTexSubImage1DPROC)glewGetProcAddress("glCompressedTexSubImage1D")) == NULL;
+  r = r || (glGetCompressedTexImage = (glGetCompressedTexImagePROC)glewGetProcAddress("glGetCompressedTexImage")) == NULL;
+  r = r || (glSampleCoverage = (glSampleCoveragePROC)glewGetProcAddress("glSampleCoverage")) == NULL;
+  return r;
+}
+#endif /* GL_VERSION_1_3 */
+
+/* ------------------------------ OpenGL 1.4 ------------------------------ */
+
+#ifdef GL_VERSION_1_4
+#ifndef GL_ARB_imaging
+glBlendColorPROC glBlendColor = NULL;
+glBlendEquationPROC glBlendEquation = NULL;
+#endif /* GL_ARB_imaging */
+glFogCoordfPROC glFogCoordf = NULL;
+glFogCoordfvPROC glFogCoordfv = NULL;
+glFogCoorddPROC glFogCoordd = NULL;
+glFogCoorddvPROC glFogCoorddv = NULL;
+glFogCoordPointerPROC glFogCoordPointer = NULL;
+glMultiDrawArraysPROC glMultiDrawArrays = NULL;
+glMultiDrawElementsPROC glMultiDrawElements = NULL;
+glPointParameterfPROC glPointParameterf = NULL;
+glPointParameterfvPROC glPointParameterfv = NULL;
+glSecondaryColor3bPROC glSecondaryColor3b = NULL;
+glSecondaryColor3bvPROC glSecondaryColor3bv = NULL;
+glSecondaryColor3dPROC glSecondaryColor3d = NULL;
+glSecondaryColor3dvPROC glSecondaryColor3dv = NULL;
+glSecondaryColor3fPROC glSecondaryColor3f = NULL;
+glSecondaryColor3fvPROC glSecondaryColor3fv = NULL;
+glSecondaryColor3iPROC glSecondaryColor3i = NULL;
+glSecondaryColor3ivPROC glSecondaryColor3iv = NULL;
+glSecondaryColor3sPROC glSecondaryColor3s = NULL;
+glSecondaryColor3svPROC glSecondaryColor3sv = NULL;
+glSecondaryColor3ubPROC glSecondaryColor3ub = NULL;
+glSecondaryColor3ubvPROC glSecondaryColor3ubv = NULL;
+glSecondaryColor3uiPROC glSecondaryColor3ui = NULL;
+glSecondaryColor3uivPROC glSecondaryColor3uiv = NULL;
+glSecondaryColor3usPROC glSecondaryColor3us = NULL;
+glSecondaryColor3usvPROC glSecondaryColor3usv = NULL;
+glSecondaryColorPointerPROC glSecondaryColorPointer = NULL;
+glBlendFuncSeparatePROC glBlendFuncSeparate = NULL;
+glWindowPos2dPROC glWindowPos2d = NULL;
+glWindowPos2fPROC glWindowPos2f = NULL;
+glWindowPos2iPROC glWindowPos2i = NULL;
+glWindowPos2sPROC glWindowPos2s = NULL;
+glWindowPos2dvPROC glWindowPos2dv = NULL;
+glWindowPos2fvPROC glWindowPos2fv = NULL;
+glWindowPos2ivPROC glWindowPos2iv = NULL;
+glWindowPos2svPROC glWindowPos2sv = NULL;
+glWindowPos3dPROC glWindowPos3d = NULL;
+glWindowPos3fPROC glWindowPos3f = NULL;
+glWindowPos3iPROC glWindowPos3i = NULL;
+glWindowPos3sPROC glWindowPos3s = NULL;
+glWindowPos3dvPROC glWindowPos3dv = NULL;
+glWindowPos3fvPROC glWindowPos3fv = NULL;
+glWindowPos3ivPROC glWindowPos3iv = NULL;
+glWindowPos3svPROC glWindowPos3sv = NULL;
+
+static GLboolean _glewInit_14 ()
+{
+  GLboolean r = GL_FALSE;
+#ifndef GL_ARB_imaging
+  r = r || (glBlendColor = (glBlendColorPROC)glewGetProcAddress("glBlendColor")) == NULL;
+  r = r || (glBlendEquation = (glBlendEquationPROC)glewGetProcAddress("glBlendEquation")) == NULL;
+#endif /* GL_ARB_imaging */
+  r = r || (glFogCoordf = (glFogCoordfPROC)glewGetProcAddress("glFogCoordf")) == NULL;
+  r = r || (glFogCoordfv = (glFogCoordfvPROC)glewGetProcAddress("glFogCoordfv")) == NULL;
+  r = r || (glFogCoordd = (glFogCoorddPROC)glewGetProcAddress("glFogCoordd")) == NULL;
+  r = r || (glFogCoorddv = (glFogCoorddvPROC)glewGetProcAddress("glFogCoorddv")) == NULL;
+  r = r || (glFogCoordPointer = (glFogCoordPointerPROC)glewGetProcAddress("glFogCoordPointer")) == NULL;
+  r = r || (glMultiDrawArrays = (glMultiDrawArraysPROC)glewGetProcAddress("glMultiDrawArrays")) == NULL;
+  r = r || (glMultiDrawElements = (glMultiDrawElementsPROC)glewGetProcAddress("glMultiDrawElements")) == NULL;
+  r = r || (glPointParameterf = (glPointParameterfPROC)glewGetProcAddress("glPointParameterf")) == NULL;
+  r = r || (glPointParameterfv = (glPointParameterfvPROC)glewGetProcAddress("glPointParameterfv")) == NULL;
+  r = r || (glSecondaryColor3b = (glSecondaryColor3bPROC)glewGetProcAddress("glSecondaryColor3b")) == NULL;
+  r = r || (glSecondaryColor3bv = (glSecondaryColor3bvPROC)glewGetProcAddress("glSecondaryColor3bv")) == NULL;
+  r = r || (glSecondaryColor3d = (glSecondaryColor3dPROC)glewGetProcAddress("glSecondaryColor3d")) == NULL;
+  r = r || (glSecondaryColor3dv = (glSecondaryColor3dvPROC)glewGetProcAddress("glSecondaryColor3dv")) == NULL;
+  r = r || (glSecondaryColor3f = (glSecondaryColor3fPROC)glewGetProcAddress("glSecondaryColor3f")) == NULL;
+  r = r || (glSecondaryColor3fv = (glSecondaryColor3fvPROC)glewGetProcAddress("glSecondaryColor3fv")) == NULL;
+  r = r || (glSecondaryColor3i = (glSecondaryColor3iPROC)glewGetProcAddress("glSecondaryColor3i")) == NULL;
+  r = r || (glSecondaryColor3iv = (glSecondaryColor3ivPROC)glewGetProcAddress("glSecondaryColor3iv")) == NULL;
+  r = r || (glSecondaryColor3s = (glSecondaryColor3sPROC)glewGetProcAddress("glSecondaryColor3s")) == NULL;
+  r = r || (glSecondaryColor3sv = (glSecondaryColor3svPROC)glewGetProcAddress("glSecondaryColor3sv")) == NULL;
+  r = r || (glSecondaryColor3ub = (glSecondaryColor3ubPROC)glewGetProcAddress("glSecondaryColor3ub")) == NULL;
+  r = r || (glSecondaryColor3ubv = (glSecondaryColor3ubvPROC)glewGetProcAddress("glSecondaryColor3ubv")) == NULL;
+  r = r || (glSecondaryColor3ui = (glSecondaryColor3uiPROC)glewGetProcAddress("glSecondaryColor3ui")) == NULL;
+  r = r || (glSecondaryColor3uiv = (glSecondaryColor3uivPROC)glewGetProcAddress("glSecondaryColor3uiv")) == NULL;
+  r = r || (glSecondaryColor3us = (glSecondaryColor3usPROC)glewGetProcAddress("glSecondaryColor3us")) == NULL;
+  r = r || (glSecondaryColor3usv = (glSecondaryColor3usvPROC)glewGetProcAddress("glSecondaryColor3usv")) == NULL;
+  r = r || (glSecondaryColorPointer = (glSecondaryColorPointerPROC)glewGetProcAddress("glSecondaryColorPointer")) == NULL;
+  r = r || (glBlendFuncSeparate = (glBlendFuncSeparatePROC)glewGetProcAddress("glBlendFuncSeparate")) == NULL;
+  r = r || (glWindowPos2d = (glWindowPos2dPROC)glewGetProcAddress("glWindowPos2d")) == NULL;
+  r = r || (glWindowPos2f = (glWindowPos2fPROC)glewGetProcAddress("glWindowPos2f")) == NULL;
+  r = r || (glWindowPos2i = (glWindowPos2iPROC)glewGetProcAddress("glWindowPos2i")) == NULL;
+  r = r || (glWindowPos2s = (glWindowPos2sPROC)glewGetProcAddress("glWindowPos2s")) == NULL;
+  r = r || (glWindowPos2dv = (glWindowPos2dvPROC)glewGetProcAddress("glWindowPos2dv")) == NULL;
+  r = r || (glWindowPos2fv = (glWindowPos2fvPROC)glewGetProcAddress("glWindowPos2fv")) == NULL;
+  r = r || (glWindowPos2iv = (glWindowPos2ivPROC)glewGetProcAddress("glWindowPos2iv")) == NULL;
+  r = r || (glWindowPos2sv = (glWindowPos2svPROC)glewGetProcAddress("glWindowPos2sv")) == NULL;
+  r = r || (glWindowPos3d = (glWindowPos3dPROC)glewGetProcAddress("glWindowPos3d")) == NULL;
+  r = r || (glWindowPos3f = (glWindowPos3fPROC)glewGetProcAddress("glWindowPos3f")) == NULL;
+  r = r || (glWindowPos3i = (glWindowPos3iPROC)glewGetProcAddress("glWindowPos3i")) == NULL;
+  r = r || (glWindowPos3s = (glWindowPos3sPROC)glewGetProcAddress("glWindowPos3s")) == NULL;
+  r = r || (glWindowPos3dv = (glWindowPos3dvPROC)glewGetProcAddress("glWindowPos3dv")) == NULL;
+  r = r || (glWindowPos3fv = (glWindowPos3fvPROC)glewGetProcAddress("glWindowPos3fv")) == NULL;
+  r = r || (glWindowPos3iv = (glWindowPos3ivPROC)glewGetProcAddress("glWindowPos3iv")) == NULL;
+  r = r || (glWindowPos3sv = (glWindowPos3svPROC)glewGetProcAddress("glWindowPos3sv")) == NULL;
+  return r;
+}
+#endif /* GL_VERSION_1_4 */
+
+/* ------------------------------ ARB_imaging ----------------------------- */
+
+#ifdef GL_ARB_imaging
+glBlendColorPROC glBlendColor = NULL;
+glBlendEquationPROC glBlendEquation = NULL;
+glColorTablePROC glColorTable = NULL;
+glColorTableParameterfvPROC glColorTableParameterfv = NULL;
+glColorTableParameterivPROC glColorTableParameteriv = NULL;
+glCopyColorTablePROC glCopyColorTable = NULL;
+glGetColorTablePROC glGetColorTable = NULL;
+glGetColorTableParameterfvPROC glGetColorTableParameterfv = NULL;
+glGetColorTableParameterivPROC glGetColorTableParameteriv = NULL;
+glColorSubTablePROC glColorSubTable = NULL;
+glCopyColorSubTablePROC glCopyColorSubTable = NULL;
+glConvolutionFilter1DPROC glConvolutionFilter1D = NULL;
+glConvolutionFilter2DPROC glConvolutionFilter2D = NULL;
+glConvolutionParameterfPROC glConvolutionParameterf = NULL;
+glConvolutionParameterfvPROC glConvolutionParameterfv = NULL;
+glConvolutionParameteriPROC glConvolutionParameteri = NULL;
+glConvolutionParameterivPROC glConvolutionParameteriv = NULL;
+glCopyConvolutionFilter1DPROC glCopyConvolutionFilter1D = NULL;
+glCopyConvolutionFilter2DPROC glCopyConvolutionFilter2D = NULL;
+glGetConvolutionFilterPROC glGetConvolutionFilter = NULL;
+glGetConvolutionParameterfvPROC glGetConvolutionParameterfv = NULL;
+glGetConvolutionParameterivPROC glGetConvolutionParameteriv = NULL;
+glGetSeparableFilterPROC glGetSeparableFilter = NULL;
+glSeparableFilter2DPROC glSeparableFilter2D = NULL;
+glGetHistogramPROC glGetHistogram = NULL;
+glGetHistogramParameterfvPROC glGetHistogramParameterfv = NULL;
+glGetHistogramParameterivPROC glGetHistogramParameteriv = NULL;
+glGetMinmaxPROC glGetMinmax = NULL;
+glGetMinmaxParameterfvPROC glGetMinmaxParameterfv = NULL;
+glGetMinmaxParameterivPROC glGetMinmaxParameteriv = NULL;
+glHistogramPROC glHistogram = NULL;
+glMinmaxPROC glMinmax = NULL;
+glResetHistogramPROC glResetHistogram = NULL;
+glResetMinmaxPROC glResetMinmax = NULL;
+
+static GLboolean _glewInit_ARB_imaging ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glBlendColor = (glBlendColorPROC)glewGetProcAddress("glBlendColor")) == NULL;
+  r = r || (glBlendEquation = (glBlendEquationPROC)glewGetProcAddress("glBlendEquation")) == NULL;
+  r = r || (glColorTable = (glColorTablePROC)glewGetProcAddress("glColorTable")) == NULL;
+  r = r || (glColorTableParameterfv = (glColorTableParameterfvPROC)glewGetProcAddress("glColorTableParameterfv")) == NULL;
+  r = r || (glColorTableParameteriv = (glColorTableParameterivPROC)glewGetProcAddress("glColorTableParameteriv")) == NULL;
+  r = r || (glCopyColorTable = (glCopyColorTablePROC)glewGetProcAddress("glCopyColorTable")) == NULL;
+  r = r || (glGetColorTable = (glGetColorTablePROC)glewGetProcAddress("glGetColorTable")) == NULL;
+  r = r || (glGetColorTableParameterfv = (glGetColorTableParameterfvPROC)glewGetProcAddress("glGetColorTableParameterfv")) == NULL;
+  r = r || (glGetColorTableParameteriv = (glGetColorTableParameterivPROC)glewGetProcAddress("glGetColorTableParameteriv")) == NULL;
+  r = r || (glColorSubTable = (glColorSubTablePROC)glewGetProcAddress("glColorSubTable")) == NULL;
+  r = r || (glCopyColorSubTable = (glCopyColorSubTablePROC)glewGetProcAddress("glCopyColorSubTable")) == NULL;
+  r = r || (glConvolutionFilter1D = (glConvolutionFilter1DPROC)glewGetProcAddress("glConvolutionFilter1D")) == NULL;
+  r = r || (glConvolutionFilter2D = (glConvolutionFilter2DPROC)glewGetProcAddress("glConvolutionFilter2D")) == NULL;
+  r = r || (glConvolutionParameterf = (glConvolutionParameterfPROC)glewGetProcAddress("glConvolutionParameterf")) == NULL;
+  r = r || (glConvolutionParameterfv = (glConvolutionParameterfvPROC)glewGetProcAddress("glConvolutionParameterfv")) == NULL;
+  r = r || (glConvolutionParameteri = (glConvolutionParameteriPROC)glewGetProcAddress("glConvolutionParameteri")) == NULL;
+  r = r || (glConvolutionParameteriv = (glConvolutionParameterivPROC)glewGetProcAddress("glConvolutionParameteriv")) == NULL;
+  r = r || (glCopyConvolutionFilter1D = (glCopyConvolutionFilter1DPROC)glewGetProcAddress("glCopyConvolutionFilter1D")) == NULL;
+  r = r || (glCopyConvolutionFilter2D = (glCopyConvolutionFilter2DPROC)glewGetProcAddress("glCopyConvolutionFilter2D")) == NULL;
+  r = r || (glGetConvolutionFilter = (glGetConvolutionFilterPROC)glewGetProcAddress("glGetConvolutionFilter")) == NULL;
+  r = r || (glGetConvolutionParameterfv = (glGetConvolutionParameterfvPROC)glewGetProcAddress("glGetConvolutionParameterfv")) == NULL;
+  r = r || (glGetConvolutionParameteriv = (glGetConvolutionParameterivPROC)glewGetProcAddress("glGetConvolutionParameteriv")) == NULL;
+  r = r || (glGetSeparableFilter = (glGetSeparableFilterPROC)glewGetProcAddress("glGetSeparableFilter")) == NULL;
+  r = r || (glSeparableFilter2D = (glSeparableFilter2DPROC)glewGetProcAddress("glSeparableFilter2D")) == NULL;
+  r = r || (glGetHistogram = (glGetHistogramPROC)glewGetProcAddress("glGetHistogram")) == NULL;
+  r = r || (glGetHistogramParameterfv = (glGetHistogramParameterfvPROC)glewGetProcAddress("glGetHistogramParameterfv")) == NULL;
+  r = r || (glGetHistogramParameteriv = (glGetHistogramParameterivPROC)glewGetProcAddress("glGetHistogramParameteriv")) == NULL;
+  r = r || (glGetMinmax = (glGetMinmaxPROC)glewGetProcAddress("glGetMinmax")) == NULL;
+  r = r || (glGetMinmaxParameterfv = (glGetMinmaxParameterfvPROC)glewGetProcAddress("glGetMinmaxParameterfv")) == NULL;
+  r = r || (glGetMinmaxParameteriv = (glGetMinmaxParameterivPROC)glewGetProcAddress("glGetMinmaxParameteriv")) == NULL;
+  r = r || (glHistogram = (glHistogramPROC)glewGetProcAddress("glHistogram")) == NULL;
+  r = r || (glMinmax = (glMinmaxPROC)glewGetProcAddress("glMinmax")) == NULL;
+  r = r || (glResetHistogram = (glResetHistogramPROC)glewGetProcAddress("glResetHistogram")) == NULL;
+  r = r || (glResetMinmax = (glResetMinmaxPROC)glewGetProcAddress("glResetMinmax")) == NULL;
+  return r;
+}
+#endif /* GL_ARB_imaging */
+
+/* -------------------------- ARB_matrix_palette -------------------------- */
+
+#ifdef GL_ARB_matrix_palette
+glCurrentPaletteMatrixARBPROC glCurrentPaletteMatrixARB = NULL;
+glMatrixIndexubvARBPROC glMatrixIndexubvARB = NULL;
+glMatrixIndexusvARBPROC glMatrixIndexusvARB = NULL;
+glMatrixIndexuivARBPROC glMatrixIndexuivARB = NULL;
+glMatrixIndexPointerARBPROC glMatrixIndexPointerARB = NULL;
+
+static GLboolean _glewInit_ARB_matrix_palette ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glCurrentPaletteMatrixARB = (glCurrentPaletteMatrixARBPROC)glewGetProcAddress("glCurrentPaletteMatrixARB")) == NULL;
+  r = r || (glMatrixIndexubvARB = (glMatrixIndexubvARBPROC)glewGetProcAddress("glMatrixIndexubvARB")) == NULL;
+  r = r || (glMatrixIndexusvARB = (glMatrixIndexusvARBPROC)glewGetProcAddress("glMatrixIndexusvARB")) == NULL;
+  r = r || (glMatrixIndexuivARB = (glMatrixIndexuivARBPROC)glewGetProcAddress("glMatrixIndexuivARB")) == NULL;
+  r = r || (glMatrixIndexPointerARB = (glMatrixIndexPointerARBPROC)glewGetProcAddress("glMatrixIndexPointerARB")) == NULL;
+  return r;
+}
+#endif /* GL_ARB_matrix_palette */
+
+/* ---------------------------- ARB_multisample --------------------------- */
+
+#ifdef GL_ARB_multisample
+glSampleCoverageARBPROC glSampleCoverageARB = NULL;
+
+static GLboolean _glewInit_ARB_multisample ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glSampleCoverageARB = (glSampleCoverageARBPROC)glewGetProcAddress("glSampleCoverageARB")) == NULL;
+  return r;
+}
+#endif /* GL_ARB_multisample */
+
+/* --------------------------- ARB_multitexture --------------------------- */
+
+#ifdef GL_ARB_multitexture
+glActiveTextureARBPROC glActiveTextureARB = NULL;
+glClientActiveTextureARBPROC glClientActiveTextureARB = NULL;
+glMultiTexCoord1dARBPROC glMultiTexCoord1dARB = NULL;
+glMultiTexCoord1dvARBPROC glMultiTexCoord1dvARB = NULL;
+glMultiTexCoord1fARBPROC glMultiTexCoord1fARB = NULL;
+glMultiTexCoord1fvARBPROC glMultiTexCoord1fvARB = NULL;
+glMultiTexCoord1iARBPROC glMultiTexCoord1iARB = NULL;
+glMultiTexCoord1ivARBPROC glMultiTexCoord1ivARB = NULL;
+glMultiTexCoord1sARBPROC glMultiTexCoord1sARB = NULL;
+glMultiTexCoord1svARBPROC glMultiTexCoord1svARB = NULL;
+glMultiTexCoord2dARBPROC glMultiTexCoord2dARB = NULL;
+glMultiTexCoord2dvARBPROC glMultiTexCoord2dvARB = NULL;
+glMultiTexCoord2fARBPROC glMultiTexCoord2fARB = NULL;
+glMultiTexCoord2fvARBPROC glMultiTexCoord2fvARB = NULL;
+glMultiTexCoord2iARBPROC glMultiTexCoord2iARB = NULL;
+glMultiTexCoord2ivARBPROC glMultiTexCoord2ivARB = NULL;
+glMultiTexCoord2sARBPROC glMultiTexCoord2sARB = NULL;
+glMultiTexCoord2svARBPROC glMultiTexCoord2svARB = NULL;
+glMultiTexCoord3dARBPROC glMultiTexCoord3dARB = NULL;
+glMultiTexCoord3dvARBPROC glMultiTexCoord3dvARB = NULL;
+glMultiTexCoord3fARBPROC glMultiTexCoord3fARB = NULL;
+glMultiTexCoord3fvARBPROC glMultiTexCoord3fvARB = NULL;
+glMultiTexCoord3iARBPROC glMultiTexCoord3iARB = NULL;
+glMultiTexCoord3ivARBPROC glMultiTexCoord3ivARB = NULL;
+glMultiTexCoord3sARBPROC glMultiTexCoord3sARB = NULL;
+glMultiTexCoord3svARBPROC glMultiTexCoord3svARB = NULL;
+glMultiTexCoord4dARBPROC glMultiTexCoord4dARB = NULL;
+glMultiTexCoord4dvARBPROC glMultiTexCoord4dvARB = NULL;
+glMultiTexCoord4fARBPROC glMultiTexCoord4fARB = NULL;
+glMultiTexCoord4fvARBPROC glMultiTexCoord4fvARB = NULL;
+glMultiTexCoord4iARBPROC glMultiTexCoord4iARB = NULL;
+glMultiTexCoord4ivARBPROC glMultiTexCoord4ivARB = NULL;
+glMultiTexCoord4sARBPROC glMultiTexCoord4sARB = NULL;
+glMultiTexCoord4svARBPROC glMultiTexCoord4svARB = NULL;
+
+static GLboolean _glewInit_ARB_multitexture ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glActiveTextureARB = (glActiveTextureARBPROC)glewGetProcAddress("glActiveTextureARB")) == NULL;
+  r = r || (glClientActiveTextureARB = (glClientActiveTextureARBPROC)glewGetProcAddress("glClientActiveTextureARB")) == NULL;
+  r = r || (glMultiTexCoord1dARB = (glMultiTexCoord1dARBPROC)glewGetProcAddress("glMultiTexCoord1dARB")) == NULL;
+  r = r || (glMultiTexCoord1dvARB = (glMultiTexCoord1dvARBPROC)glewGetProcAddress("glMultiTexCoord1dvARB")) == NULL;
+  r = r || (glMultiTexCoord1fARB = (glMultiTexCoord1fARBPROC)glewGetProcAddress("glMultiTexCoord1fARB")) == NULL;
+  r = r || (glMultiTexCoord1fvARB = (glMultiTexCoord1fvARBPROC)glewGetProcAddress("glMultiTexCoord1fvARB")) == NULL;
+  r = r || (glMultiTexCoord1iARB = (glMultiTexCoord1iARBPROC)glewGetProcAddress("glMultiTexCoord1iARB")) == NULL;
+  r = r || (glMultiTexCoord1ivARB = (glMultiTexCoord1ivARBPROC)glewGetProcAddress("glMultiTexCoord1ivARB")) == NULL;
+  r = r || (glMultiTexCoord1sARB = (glMultiTexCoord1sARBPROC)glewGetProcAddress("glMultiTexCoord1sARB")) == NULL;
+  r = r || (glMultiTexCoord1svARB = (glMultiTexCoord1svARBPROC)glewGetProcAddress("glMultiTexCoord1svARB")) == NULL;
+  r = r || (glMultiTexCoord2dARB = (glMultiTexCoord2dARBPROC)glewGetProcAddress("glMultiTexCoord2dARB")) == NULL;
+  r = r || (glMultiTexCoord2dvARB = (glMultiTexCoord2dvARBPROC)glewGetProcAddress("glMultiTexCoord2dvARB")) == NULL;
+  r = r || (glMultiTexCoord2fARB = (glMultiTexCoord2fARBPROC)glewGetProcAddress("glMultiTexCoord2fARB")) == NULL;
+  r = r || (glMultiTexCoord2fvARB = (glMultiTexCoord2fvARBPROC)glewGetProcAddress("glMultiTexCoord2fvARB")) == NULL;
+  r = r || (glMultiTexCoord2iARB = (glMultiTexCoord2iARBPROC)glewGetProcAddress("glMultiTexCoord2iARB")) == NULL;
+  r = r || (glMultiTexCoord2ivARB = (glMultiTexCoord2ivARBPROC)glewGetProcAddress("glMultiTexCoord2ivARB")) == NULL;
+  r = r || (glMultiTexCoord2sARB = (glMultiTexCoord2sARBPROC)glewGetProcAddress("glMultiTexCoord2sARB")) == NULL;
+  r = r || (glMultiTexCoord2svARB = (glMultiTexCoord2svARBPROC)glewGetProcAddress("glMultiTexCoord2svARB")) == NULL;
+  r = r || (glMultiTexCoord3dARB = (glMultiTexCoord3dARBPROC)glewGetProcAddress("glMultiTexCoord3dARB")) == NULL;
+  r = r || (glMultiTexCoord3dvARB = (glMultiTexCoord3dvARBPROC)glewGetProcAddress("glMultiTexCoord3dvARB")) == NULL;
+  r = r || (glMultiTexCoord3fARB = (glMultiTexCoord3fARBPROC)glewGetProcAddress("glMultiTexCoord3fARB")) == NULL;
+  r = r || (glMultiTexCoord3fvARB = (glMultiTexCoord3fvARBPROC)glewGetProcAddress("glMultiTexCoord3fvARB")) == NULL;
+  r = r || (glMultiTexCoord3iARB = (glMultiTexCoord3iARBPROC)glewGetProcAddress("glMultiTexCoord3iARB")) == NULL;
+  r = r || (glMultiTexCoord3ivARB = (glMultiTexCoord3ivARBPROC)glewGetProcAddress("glMultiTexCoord3ivARB")) == NULL;
+  r = r || (glMultiTexCoord3sARB = (glMultiTexCoord3sARBPROC)glewGetProcAddress("glMultiTexCoord3sARB")) == NULL;
+  r = r || (glMultiTexCoord3svARB = (glMultiTexCoord3svARBPROC)glewGetProcAddress("glMultiTexCoord3svARB")) == NULL;
+  r = r || (glMultiTexCoord4dARB = (glMultiTexCoord4dARBPROC)glewGetProcAddress("glMultiTexCoord4dARB")) == NULL;
+  r = r || (glMultiTexCoord4dvARB = (glMultiTexCoord4dvARBPROC)glewGetProcAddress("glMultiTexCoord4dvARB")) == NULL;
+  r = r || (glMultiTexCoord4fARB = (glMultiTexCoord4fARBPROC)glewGetProcAddress("glMultiTexCoord4fARB")) == NULL;
+  r = r || (glMultiTexCoord4fvARB = (glMultiTexCoord4fvARBPROC)glewGetProcAddress("glMultiTexCoord4fvARB")) == NULL;
+  r = r || (glMultiTexCoord4iARB = (glMultiTexCoord4iARBPROC)glewGetProcAddress("glMultiTexCoord4iARB")) == NULL;
+  r = r || (glMultiTexCoord4ivARB = (glMultiTexCoord4ivARBPROC)glewGetProcAddress("glMultiTexCoord4ivARB")) == NULL;
+  r = r || (glMultiTexCoord4sARB = (glMultiTexCoord4sARBPROC)glewGetProcAddress("glMultiTexCoord4sARB")) == NULL;
+  r = r || (glMultiTexCoord4svARB = (glMultiTexCoord4svARBPROC)glewGetProcAddress("glMultiTexCoord4svARB")) == NULL;
+  return r;
+}
+#endif /* GL_ARB_multitexture */
+
+/* ------------------------- ARB_point_parameters ------------------------- */
+
+#ifdef GL_ARB_point_parameters
+glPointParameterfARBPROC glPointParameterfARB = NULL;
+glPointParameterfvARBPROC glPointParameterfvARB = NULL;
+
+static GLboolean _glewInit_ARB_point_parameters ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glPointParameterfARB = (glPointParameterfARBPROC)glewGetProcAddress("glPointParameterfARB")) == NULL;
+  r = r || (glPointParameterfvARB = (glPointParameterfvARBPROC)glewGetProcAddress("glPointParameterfvARB")) == NULL;
+  return r;
+}
+#endif /* GL_ARB_point_parameters */
+
+/* ------------------------ ARB_texture_compression ----------------------- */
+
+#ifdef GL_ARB_texture_compression
+glCompressedTexImage3DARBPROC glCompressedTexImage3DARB = NULL;
+glCompressedTexImage2DARBPROC glCompressedTexImage2DARB = NULL;
+glCompressedTexImage1DARBPROC glCompressedTexImage1DARB = NULL; 
+glCompressedTexSubImage3DARBPROC glCompressedTexSubImage3DARB = NULL;
+glCompressedTexSubImage2DARBPROC glCompressedTexSubImage2DARB = NULL;
+glCompressedTexSubImage1DARBPROC glCompressedTexSubImage1DARB = NULL;
+glGetCompressedTexImageARBPROC glGetCompressedTexImageARB = NULL;
+
+static GLboolean _glewInit_ARB_texture_compression ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glCompressedTexImage3DARB = (glCompressedTexImage3DARBPROC)glewGetProcAddress("glCompressedTexImage3DARB")) == NULL;
+  r = r || (glCompressedTexImage2DARB = (glCompressedTexImage2DARBPROC)glewGetProcAddress("glCompressedTexImage2DARB")) == NULL;
+  r = r || (glCompressedTexImage1DARB = (glCompressedTexImage1DARBPROC)glewGetProcAddress("glCompressedTexImage1DARB")) == NULL;
+  r = r || (glCompressedTexSubImage3DARB = (glCompressedTexSubImage3DARBPROC)glewGetProcAddress("glCompressedTexSubImage3DARB")) == NULL;
+  r = r || (glCompressedTexSubImage2DARB = (glCompressedTexSubImage2DARBPROC)glewGetProcAddress("glCompressedTexSubImage2DARB")) == NULL;
+  r = r || (glCompressedTexSubImage1DARB = (glCompressedTexSubImage1DARBPROC)glewGetProcAddress("glCompressedTexSubImage1DARB")) == NULL;
+  r = r || (glGetCompressedTexImageARB = (glGetCompressedTexImageARBPROC)glewGetProcAddress("glGetCompressedTexImageARB")) == NULL;
+  return r;
+}
+#endif /* GL_ARB_texture_compression */
+
+/* ------------------------- ARB_transpose_matrix ------------------------- */
+
+#ifdef GL_ARB_transpose_matrix
+glLoadTransposeMatrixfARBPROC glLoadTransposeMatrixfARB = NULL;
+glLoadTransposeMatrixdARBPROC glLoadTransposeMatrixdARB = NULL;
+glMultTransposeMatrixfARBPROC glMultTransposeMatrixfARB = NULL;
+glMultTransposeMatrixdARBPROC glMultTransposeMatrixdARB = NULL;
+
+static GLboolean _glewInit_ARB_transpose_matrix ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glLoadTransposeMatrixfARB = (glLoadTransposeMatrixfARBPROC)glewGetProcAddress("glLoadTransposeMatrixfARB")) == NULL;
+  r = r || (glLoadTransposeMatrixdARB = (glLoadTransposeMatrixdARBPROC)glewGetProcAddress("glLoadTransposeMatrixdARB")) == NULL;
+  r = r || (glMultTransposeMatrixfARB = (glMultTransposeMatrixfARBPROC)glewGetProcAddress("glMultTransposeMatrixfARB")) == NULL;
+  r = r || (glMultTransposeMatrixdARB = (glMultTransposeMatrixdARBPROC)glewGetProcAddress("glMultTransposeMatrixdARB")) == NULL;
+  return r;
+}
+#endif /* GL_ARB_transpose_matrix */
+
+/* --------------------------- ARB_vertex_blend --------------------------- */
+
+#ifdef GL_ARB_vertex_blend
+glWeightbvARBPROC glWeightbvARB = NULL;
+glWeightsvARBPROC glWeightsvARB = NULL;
+glWeightivARBPROC glWeightivARB = NULL;
+glWeightfvARBPROC glWeightfvARB = NULL;
+glWeightdvARBPROC glWeightdvARB = NULL;
+glWeightubvARBPROC glWeightubvARB = NULL;
+glWeightusvARBPROC glWeightusvARB = NULL;
+glWeightuivARBPROC glWeightuivARB = NULL;
+glWeightPointerARBPROC glWeightPointerARB = NULL;
+glVertexBlendARBPROC glVertexBlendARB = NULL;
+
+static GLboolean _glewInit_ARB_vertex_blend ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glWeightbvARB = (glWeightbvARBPROC)glewGetProcAddress("glWeightbvARB")) == NULL;
+  r = r || (glWeightsvARB = (glWeightsvARBPROC)glewGetProcAddress("glWeightsvARB")) == NULL;
+  r = r || (glWeightivARB = (glWeightivARBPROC)glewGetProcAddress("glWeightivARB")) == NULL;
+  r = r || (glWeightfvARB = (glWeightfvARBPROC)glewGetProcAddress("glWeightfvARB")) == NULL;
+  r = r || (glWeightdvARB = (glWeightdvARBPROC)glewGetProcAddress("glWeightdvARB")) == NULL;
+  r = r || (glWeightubvARB = (glWeightubvARBPROC)glewGetProcAddress("glWeightubvARB")) == NULL;
+  r = r || (glWeightusvARB = (glWeightusvARBPROC)glewGetProcAddress("glWeightusvARB")) == NULL;
+  r = r || (glWeightuivARB = (glWeightuivARBPROC)glewGetProcAddress("glWeightuivARB")) == NULL;
+  r = r || (glWeightPointerARB = (glWeightPointerARBPROC)glewGetProcAddress("glWeightPointerARB")) == NULL;
+  r = r || (glVertexBlendARB = (glVertexBlendARBPROC)glewGetProcAddress("glVertexBlendARB")) == NULL;
+  return r;
+}
+#endif /* GL_ARB_vertex_blend */
+
+/* -------------------------- ARB_vertex_program -------------------------- */
+
+#ifdef GL_ARB_vertex_program
+glVertexAttrib1sARBPROC glVertexAttrib1sARB = NULL;
+glVertexAttrib1fARBPROC glVertexAttrib1fARB = NULL;
+glVertexAttrib1dARBPROC glVertexAttrib1dARB = NULL;
+glVertexAttrib2sARBPROC glVertexAttrib2sARB = NULL;
+glVertexAttrib2fARBPROC glVertexAttrib2fARB = NULL;
+glVertexAttrib2dARBPROC glVertexAttrib2dARB = NULL;
+glVertexAttrib3sARBPROC glVertexAttrib3sARB = NULL;
+glVertexAttrib3fARBPROC glVertexAttrib3fARB = NULL;
+glVertexAttrib3dARBPROC glVertexAttrib3dARB = NULL;
+glVertexAttrib4sARBPROC glVertexAttrib4sARB = NULL;
+glVertexAttrib4fARBPROC glVertexAttrib4fARB = NULL;
+glVertexAttrib4dARBPROC glVertexAttrib4dARB = NULL;
+glVertexAttrib4NubARBPROC glVertexAttrib4NubARB = NULL;
+glVertexAttrib1svARBPROC glVertexAttrib1svARB = NULL;
+glVertexAttrib1fvARBPROC glVertexAttrib1fvARB = NULL;
+glVertexAttrib1dvARBPROC glVertexAttrib1dvARB = NULL;
+glVertexAttrib2svARBPROC glVertexAttrib2svARB = NULL;
+glVertexAttrib2fvARBPROC glVertexAttrib2fvARB = NULL;
+glVertexAttrib2dvARBPROC glVertexAttrib2dvARB = NULL;
+glVertexAttrib3svARBPROC glVertexAttrib3svARB = NULL;
+glVertexAttrib3fvARBPROC glVertexAttrib3fvARB = NULL;
+glVertexAttrib3dvARBPROC glVertexAttrib3dvARB = NULL;
+glVertexAttrib4bvARBPROC glVertexAttrib4bvARB = NULL;
+glVertexAttrib4svARBPROC glVertexAttrib4svARB = NULL;
+glVertexAttrib4ivARBPROC glVertexAttrib4ivARB = NULL;
+glVertexAttrib4ubvARBPROC glVertexAttrib4ubvARB = NULL;
+glVertexAttrib4usvARBPROC glVertexAttrib4usvARB = NULL;
+glVertexAttrib4uivARBPROC glVertexAttrib4uivARB = NULL;
+glVertexAttrib4fvARBPROC glVertexAttrib4fvARB = NULL;
+glVertexAttrib4dvARBPROC glVertexAttrib4dvARB = NULL;
+glVertexAttrib4NbvARBPROC glVertexAttrib4NbvARB = NULL;
+glVertexAttrib4NsvARBPROC glVertexAttrib4NsvARB = NULL;
+glVertexAttrib4NivARBPROC glVertexAttrib4NivARB = NULL;
+glVertexAttrib4NubvARBPROC glVertexAttrib4NubvARB = NULL;
+glVertexAttrib4NusvARBPROC glVertexAttrib4NusvARB = NULL;
+glVertexAttrib4NuivARBPROC glVertexAttrib4NuivARB = NULL;
+glVertexAttribPointerARBPROC glVertexAttribPointerARB = NULL;
+glEnableVertexAttribArrayARBPROC glEnableVertexAttribArrayARB = NULL;
+glDisableVertexAttribArrayARBPROC glDisableVertexAttribArrayARB = NULL;
+glProgramStringARBPROC glProgramStringARB = NULL;
+glBindProgramARBPROC glBindProgramARB = NULL;
+glDeleteProgramsARBPROC glDeleteProgramsARB = NULL;
+glGenProgramsARBPROC glGenProgramsARB = NULL;
+glProgramEnvParameter4dARBPROC glProgramEnvParameter4dARB = NULL;
+glProgramEnvParameter4dvARBPROC glProgramEnvParameter4dvARB = NULL;
+glProgramEnvParameter4fARBPROC glProgramEnvParameter4fARB = NULL;
+glProgramEnvParameter4fvARBPROC glProgramEnvParameter4fvARB = NULL;
+glProgramLocalParameter4dARBPROC glProgramLocalParameter4dARB = NULL;
+glProgramLocalParameter4dvARBPROC glProgramLocalParameter4dvARB = NULL;
+glProgramLocalParameter4fARBPROC glProgramLocalParameter4fARB = NULL;
+glProgramLocalParameter4fvARBPROC glProgramLocalParameter4fvARB = NULL;
+glGetProgramEnvParameterdvARBPROC glGetProgramEnvParameterdvARB = NULL;
+glGetProgramEnvParameterfvARBPROC glGetProgramEnvParameterfvARB = NULL;
+glGetProgramLocalParameterdvARBPROC glGetProgramLocalParameterdvARB = NULL;
+glGetProgramLocalParameterfvARBPROC glGetProgramLocalParameterfvARB = NULL;
+glGetProgramivARBPROC glGetProgramivARB = NULL;
+glGetProgramStringARBPROC glGetProgramStringARB = NULL;
+glGetVertexAttribdvARBPROC glGetVertexAttribdvARB = NULL;
+glGetVertexAttribfvARBPROC glGetVertexAttribfvARB = NULL;
+glGetVertexAttribivARBPROC glGetVertexAttribivARB = NULL;
+glGetVertexAttribPointervARBPROC glGetVertexAttribPointervARB = NULL;
+glIsProgramARBPROC glIsProgramARB = NULL;
+
+static GLboolean _glewInit_ARB_vertex_program ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glVertexAttrib1sARB = (glVertexAttrib1sARBPROC)glewGetProcAddress("glVertexAttrib1sARB")) == NULL;
+  r = r || (glVertexAttrib1fARB = (glVertexAttrib1fARBPROC)glewGetProcAddress("glVertexAttrib1fARB")) == NULL;
+  r = r || (glVertexAttrib1dARB = (glVertexAttrib1dARBPROC)glewGetProcAddress("glVertexAttrib1dARB")) == NULL;
+  r = r || (glVertexAttrib2sARB = (glVertexAttrib2sARBPROC)glewGetProcAddress("glVertexAttrib2sARB")) == NULL;
+  r = r || (glVertexAttrib2fARB = (glVertexAttrib2fARBPROC)glewGetProcAddress("glVertexAttrib2fARB")) == NULL;
+  r = r || (glVertexAttrib2dARB = (glVertexAttrib2dARBPROC)glewGetProcAddress("glVertexAttrib2dARB")) == NULL;
+  r = r || (glVertexAttrib3sARB = (glVertexAttrib3sARBPROC)glewGetProcAddress("glVertexAttrib3sARB")) == NULL;
+  r = r || (glVertexAttrib3fARB = (glVertexAttrib3fARBPROC)glewGetProcAddress("glVertexAttrib3fARB")) == NULL;
+  r = r || (glVertexAttrib3dARB = (glVertexAttrib3dARBPROC)glewGetProcAddress("glVertexAttrib3dARB")) == NULL;
+  r = r || (glVertexAttrib4sARB = (glVertexAttrib4sARBPROC)glewGetProcAddress("glVertexAttrib4sARB")) == NULL;
+  r = r || (glVertexAttrib4fARB = (glVertexAttrib4fARBPROC)glewGetProcAddress("glVertexAttrib4fARB")) == NULL;
+  r = r || (glVertexAttrib4dARB = (glVertexAttrib4dARBPROC)glewGetProcAddress("glVertexAttrib4dARB")) == NULL;
+  r = r || (glVertexAttrib4NubARB = (glVertexAttrib4NubARBPROC)glewGetProcAddress("glVertexAttrib4NubARB")) == NULL;
+  r = r || (glVertexAttrib1svARB = (glVertexAttrib1svARBPROC)glewGetProcAddress("glVertexAttrib1svARB")) == NULL;
+  r = r || (glVertexAttrib1fvARB = (glVertexAttrib1fvARBPROC)glewGetProcAddress("glVertexAttrib1fvARB")) == NULL;
+  r = r || (glVertexAttrib1dvARB = (glVertexAttrib1dvARBPROC)glewGetProcAddress("glVertexAttrib1dvARB")) == NULL;
+  r = r || (glVertexAttrib2svARB = (glVertexAttrib2svARBPROC)glewGetProcAddress("glVertexAttrib2svARB")) == NULL;
+  r = r || (glVertexAttrib2fvARB = (glVertexAttrib2fvARBPROC)glewGetProcAddress("glVertexAttrib2fvARB")) == NULL;
+  r = r || (glVertexAttrib2dvARB = (glVertexAttrib2dvARBPROC)glewGetProcAddress("glVertexAttrib2dvARB")) == NULL;
+  r = r || (glVertexAttrib3svARB = (glVertexAttrib3svARBPROC)glewGetProcAddress("glVertexAttrib3svARB")) == NULL;
+  r = r || (glVertexAttrib3fvARB = (glVertexAttrib3fvARBPROC)glewGetProcAddress("glVertexAttrib3fvARB")) == NULL;
+  r = r || (glVertexAttrib3dvARB = (glVertexAttrib3dvARBPROC)glewGetProcAddress("glVertexAttrib3dvARB")) == NULL;
+  r = r || (glVertexAttrib4bvARB = (glVertexAttrib4bvARBPROC)glewGetProcAddress("glVertexAttrib4bvARB")) == NULL;
+  r = r || (glVertexAttrib4svARB = (glVertexAttrib4svARBPROC)glewGetProcAddress("glVertexAttrib4svARB")) == NULL;
+  r = r || (glVertexAttrib4ivARB = (glVertexAttrib4ivARBPROC)glewGetProcAddress("glVertexAttrib4ivARB")) == NULL;
+  r = r || (glVertexAttrib4ubvARB = (glVertexAttrib4ubvARBPROC)glewGetProcAddress("glVertexAttrib4ubvARB")) == NULL;
+  r = r || (glVertexAttrib4usvARB = (glVertexAttrib4usvARBPROC)glewGetProcAddress("glVertexAttrib4usvARB")) == NULL;
+  r = r || (glVertexAttrib4uivARB = (glVertexAttrib4uivARBPROC)glewGetProcAddress("glVertexAttrib4uivARB")) == NULL;
+  r = r || (glVertexAttrib4fvARB = (glVertexAttrib4fvARBPROC)glewGetProcAddress("glVertexAttrib4fvARB")) == NULL;
+  r = r || (glVertexAttrib4dvARB = (glVertexAttrib4dvARBPROC)glewGetProcAddress("glVertexAttrib4dvARB")) == NULL;
+  r = r || (glVertexAttrib4NbvARB = (glVertexAttrib4NbvARBPROC)glewGetProcAddress("glVertexAttrib4NbvARB")) == NULL;
+  r = r || (glVertexAttrib4NsvARB = (glVertexAttrib4NsvARBPROC)glewGetProcAddress("glVertexAttrib4NsvARB")) == NULL;
+  r = r || (glVertexAttrib4NivARB = (glVertexAttrib4NivARBPROC)glewGetProcAddress("glVertexAttrib4NivARB")) == NULL;
+  r = r || (glVertexAttrib4NubvARB = (glVertexAttrib4NubvARBPROC)glewGetProcAddress("glVertexAttrib4NubvARB")) == NULL;
+  r = r || (glVertexAttrib4NusvARB = (glVertexAttrib4NusvARBPROC)glewGetProcAddress("glVertexAttrib4NusvARB")) == NULL;
+  r = r || (glVertexAttrib4NuivARB = (glVertexAttrib4NuivARBPROC)glewGetProcAddress("glVertexAttrib4NuivARB")) == NULL;
+  r = r || (glVertexAttribPointerARB = (glVertexAttribPointerARBPROC)glewGetProcAddress("glVertexAttribPointerARB")) == NULL;
+  r = r || (glEnableVertexAttribArrayARB = (glEnableVertexAttribArrayARBPROC)glewGetProcAddress("glEnableVertexAttribArrayARB")) == NULL;
+  r = r || (glDisableVertexAttribArrayARB = (glDisableVertexAttribArrayARBPROC)glewGetProcAddress("glDisableVertexAttribArrayARB")) == NULL;
+  r = r || (glProgramStringARB = (glProgramStringARBPROC)glewGetProcAddress("glProgramStringARB")) == NULL;
+  r = r || (glBindProgramARB = (glBindProgramARBPROC)glewGetProcAddress("glBindProgramARB")) == NULL;
+  r = r || (glDeleteProgramsARB = (glDeleteProgramsARBPROC)glewGetProcAddress("glDeleteProgramsARB")) == NULL;
+  r = r || (glGenProgramsARB = (glGenProgramsARBPROC)glewGetProcAddress("glGenProgramsARB")) == NULL;
+  r = r || (glProgramEnvParameter4dARB = (glProgramEnvParameter4dARBPROC)glewGetProcAddress("glProgramEnvParameter4dARB")) == NULL;
+  r = r || (glProgramEnvParameter4dvARB = (glProgramEnvParameter4dvARBPROC)glewGetProcAddress("glProgramEnvParameter4dvARB")) == NULL;
+  r = r || (glProgramEnvParameter4fARB = (glProgramEnvParameter4fARBPROC)glewGetProcAddress("glProgramEnvParameter4fARB")) == NULL;
+  r = r || (glProgramEnvParameter4fvARB = (glProgramEnvParameter4fvARBPROC)glewGetProcAddress("glProgramEnvParameter4fvARB")) == NULL;
+  r = r || (glProgramLocalParameter4dARB = (glProgramLocalParameter4dARBPROC)glewGetProcAddress("glProgramLocalParameter4dARB")) == NULL;
+  r = r || (glProgramLocalParameter4dvARB = (glProgramLocalParameter4dvARBPROC)glewGetProcAddress("glProgramLocalParameter4dvARB")) == NULL;
+  r = r || (glProgramLocalParameter4fARB = (glProgramLocalParameter4fARBPROC)glewGetProcAddress("glProgramLocalParameter4fARB")) == NULL;
+  r = r || (glProgramLocalParameter4fvARB = (glProgramLocalParameter4fvARBPROC)glewGetProcAddress("glProgramLocalParameter4fvARB")) == NULL;
+  r = r || (glGetProgramEnvParameterdvARB = (glGetProgramEnvParameterdvARBPROC)glewGetProcAddress("glGetProgramEnvParameterdvARB")) == NULL;
+  r = r || (glGetProgramEnvParameterfvARB = (glGetProgramEnvParameterfvARBPROC)glewGetProcAddress("glGetProgramEnvParameterfvARB")) == NULL;
+  r = r || (glGetProgramLocalParameterdvARB = (glGetProgramLocalParameterdvARBPROC)glewGetProcAddress("glGetProgramLocalParameterdvARB")) == NULL;
+  r = r || (glGetProgramLocalParameterfvARB = (glGetProgramLocalParameterfvARBPROC)glewGetProcAddress("glGetProgramLocalParameterfvARB")) == NULL;
+  r = r || (glGetProgramivARB = (glGetProgramivARBPROC)glewGetProcAddress("glGetProgramivARB")) == NULL;
+  r = r || (glGetProgramStringARB = (glGetProgramStringARBPROC)glewGetProcAddress("glGetProgramStringARB")) == NULL;
+  r = r || (glGetVertexAttribdvARB = (glGetVertexAttribdvARBPROC)glewGetProcAddress("glGetVertexAttribdvARB")) == NULL;
+  r = r || (glGetVertexAttribfvARB = (glGetVertexAttribfvARBPROC)glewGetProcAddress("glGetVertexAttribfvARB")) == NULL;
+  r = r || (glGetVertexAttribivARB = (glGetVertexAttribivARBPROC)glewGetProcAddress("glGetVertexAttribivARB")) == NULL;
+  r = r || (glGetVertexAttribPointervARB = (glGetVertexAttribPointervARBPROC)glewGetProcAddress("glGetVertexAttribPointervARB")) == NULL;
+  r = r || (glIsProgramARB = (glIsProgramARBPROC)glewGetProcAddress("glIsProgramARB")) == NULL;
+  return r;
+}
+#endif /* GL_ARB_vertex_program */
+
+/* ---------------------------- ARB_window_pos ---------------------------- */
+
+#ifdef GL_ARB_window_pos
+glWindowPos2dARBPROC glWindowPos2dARB = NULL;
+glWindowPos2fARBPROC glWindowPos2fARB = NULL;
+glWindowPos2iARBPROC glWindowPos2iARB = NULL;
+glWindowPos2sARBPROC glWindowPos2sARB = NULL;
+glWindowPos2dvARBPROC glWindowPos2dvARB = NULL;
+glWindowPos2fvARBPROC glWindowPos2fvARB = NULL;
+glWindowPos2ivARBPROC glWindowPos2ivARB = NULL;
+glWindowPos2svARBPROC glWindowPos2svARB = NULL;
+glWindowPos3dARBPROC glWindowPos3dARB = NULL;
+glWindowPos3fARBPROC glWindowPos3fARB = NULL;
+glWindowPos3iARBPROC glWindowPos3iARB = NULL;
+glWindowPos3sARBPROC glWindowPos3sARB = NULL;
+glWindowPos3dvARBPROC glWindowPos3dvARB = NULL;
+glWindowPos3fvARBPROC glWindowPos3fvARB = NULL;
+glWindowPos3ivARBPROC glWindowPos3ivARB = NULL;
+glWindowPos3svARBPROC glWindowPos3svARB = NULL;
+
+static GLboolean _glewInit_ARB_window_pos ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glWindowPos2dARB = (glWindowPos2dARBPROC)glewGetProcAddress("glWindowPos2dARB")) == NULL;
+  r = r || (glWindowPos2fARB = (glWindowPos2fARBPROC)glewGetProcAddress("glWindowPos2fARB")) == NULL;
+  r = r || (glWindowPos2iARB = (glWindowPos2iARBPROC)glewGetProcAddress("glWindowPos2iARB")) == NULL;
+  r = r || (glWindowPos2sARB = (glWindowPos2sARBPROC)glewGetProcAddress("glWindowPos2sARB")) == NULL;
+  r = r || (glWindowPos2dvARB = (glWindowPos2dvARBPROC)glewGetProcAddress("glWindowPos2dvARB")) == NULL;
+  r = r || (glWindowPos2fvARB = (glWindowPos2fvARBPROC)glewGetProcAddress("glWindowPos2fvARB")) == NULL;
+  r = r || (glWindowPos2ivARB = (glWindowPos2ivARBPROC)glewGetProcAddress("glWindowPos2ivARB")) == NULL;
+  r = r || (glWindowPos2svARB = (glWindowPos2svARBPROC)glewGetProcAddress("glWindowPos2svARB")) == NULL;
+  r = r || (glWindowPos3dARB = (glWindowPos3dARBPROC)glewGetProcAddress("glWindowPos3dARB")) == NULL;
+  r = r || (glWindowPos3fARB = (glWindowPos3fARBPROC)glewGetProcAddress("glWindowPos3fARB")) == NULL;
+  r = r || (glWindowPos3iARB = (glWindowPos3iARBPROC)glewGetProcAddress("glWindowPos3iARB")) == NULL;
+  r = r || (glWindowPos3sARB = (glWindowPos3sARBPROC)glewGetProcAddress("glWindowPos3sARB")) == NULL;
+  r = r || (glWindowPos3dvARB = (glWindowPos3dvARBPROC)glewGetProcAddress("glWindowPos3dvARB")) == NULL;
+  r = r || (glWindowPos3fvARB = (glWindowPos3fvARBPROC)glewGetProcAddress("glWindowPos3fvARB")) == NULL;
+  r = r || (glWindowPos3ivARB = (glWindowPos3ivARBPROC)glewGetProcAddress("glWindowPos3ivARB")) == NULL;
+  r = r || (glWindowPos3svARB = (glWindowPos3svARBPROC)glewGetProcAddress("glWindowPos3svARB")) == NULL;
+  return r;
+}
+#endif /* GL_ARB_window_pos */
+
+/* ---------------------------- EXT_blend_color --------------------------- */
+
+#ifdef GL_EXT_blend_color
+glBlendColorEXTPROC glBlendColorEXT;
+
+static GLboolean _glewInit_EXT_blend_color ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glBlendColorEXT = (glBlendColorEXTPROC)glewGetProcAddress("glBlendColorEXT")) == NULL;
+  return r;
+}
+#endif /* GL_EXT_blend_color */
+
+/* ------------------------ EXT_blend_func_separate ----------------------- */
+
+#ifdef GL_EXT_blend_func_separate
+glBlendFuncSeparateEXTPROC glBlendFuncSeparateEXT = NULL;
+
+static GLboolean _glewInit_EXT_blend_function_separate ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glBlendFuncSeparateEXT = (glBlendFuncSeparateEXTPROC)glewGetProcAddress("glBlendFuncSeparateEXT")) == NULL;
+  return r;
+}
+#endif /* GL_EXT_blend_func_separate */
+
+/* ---------------------------- EXT_blend_minmax -------------------------- */
+
+#ifdef GL_EXT_blend_minmax
+glBlendEquationEXTPROC glBlendEquationEXT;
+
+static GLboolean _glewInit_EXT_blend_minmax ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glBlendEquationEXT = (glBlendEquationEXTPROC)glewGetProcAddress("glBlendEquationEXT")) == NULL;
+  return r;
+}
+#endif /* GL_EXT_blend_minmax */
+
+/* ----------------------- EXT_compiled_vertex_array ---------------------- */
+
+#ifdef GL_EXT_compiled_vertex_array
+glLockArraysEXTPROC glLockArraysEXT = NULL;
+glUnlockArraysEXTPROC glUnlockArraysEXT = NULL;
+
+static GLboolean _glewInit_EXT_compiled_vertex_array ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glLockArraysEXT = (glLockArraysEXTPROC)glewGetProcAddress("glLockArraysEXT")) == NULL;
+  r = r || (glUnlockArraysEXT = (glUnlockArraysEXTPROC)glewGetProcAddress("glUnlockArraysEXT")) == NULL;
+  return r;
+}
+#endif /* GL_EXT_compiled_vertex_array */
+
+/* ---------------------------- EXT_cull_vertex --------------------------- */
+
+#ifdef GL_EXT_cull_vertex
+glCullParameterfvEXTPROC glCullParameterfvEXT = NULL;
+glCullParameterdvEXTPROC glCullParameterdvEXT = NULL;
+
+static GLboolean _glewInit_EXT_cull_vertex ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glCullParameterfvEXT = (glCullParameterfvEXTPROC)glewGetProcAddress("glCullParameterfvEXT")) == NULL;
+  r = r || (glCullParameterdvEXT = (glCullParameterdvEXTPROC)glewGetProcAddress("glCullParameterdvEXT")) == NULL;
+  return r;
+}
+#endif /* GL_EXT_cull_vertex */
+
+/* ------------------------ EXT_draw_range_elements ----------------------- */
+
+#ifdef GL_EXT_draw_range_elements
+glDrawRangeElementsEXTPROC glDrawRangeElementsEXT = NULL;
+
+static GLboolean _glewInit_EXT_draw_range_elements ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glDrawRangeElementsEXT = (glDrawRangeElementsEXTPROC)glewGetProcAddress("glDrawRangeElementsEXT")) == NULL;
+  return r;
+}
+#endif /* GL_EXT_draw_range_elements */
+
+/* ----------------------------- EXT_fog_coord ---------------------------- */
+
+#ifdef GL_EXT_fog_coord
+glFogCoordfEXTPROC glFogCoordfEXT = NULL;
+glFogCoordfvEXTPROC glFogCoordfvEXT = NULL;
+glFogCoorddEXTPROC glFogCoorddEXT = NULL;
+glFogCoorddvEXTPROC glFogCoorddvEXT = NULL;
+glFogCoordPointerEXTPROC glFogCoordPointerEXT = NULL;
+
+static GLboolean _glewInit_EXT_fog_coord ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glFogCoordfEXT = (glFogCoordfEXTPROC)glewGetProcAddress("glFogCoordfEXT")) == NULL;
+  r = r || (glFogCoordfvEXT = (glFogCoordfvEXTPROC)glewGetProcAddress("glFogCoordfvEXT")) == NULL;
+  r = r || (glFogCoorddEXT = (glFogCoorddEXTPROC)glewGetProcAddress("glFogCoorddEXT")) == NULL;
+  r = r || (glFogCoorddvEXT = (glFogCoorddvEXTPROC)glewGetProcAddress("glFogCoorddvEXT")) == NULL;
+  r = r || (glFogCoordPointerEXT = (glFogCoordPointerEXTPROC)glewGetProcAddress("glFogCoordPointerEXT")) == NULL;
+  return r;
+}
+#endif /* GL_EXT_fog_coord */
+
+/* ------------------------- EXT_multi_draw_arrays ------------------------ */
+
+#ifdef GL_EXT_multi_draw_arrays
+glMultiDrawArraysEXTPROC glMultiDrawArraysEXT = NULL;
+glMultiDrawElementsEXTPROC glMultiDrawElementsEXT = NULL;
+
+static GLboolean _glewInit_EXT_multi_draw_arrays ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glMultiDrawArraysEXT = (glMultiDrawArraysEXTPROC) glewGetProcAddress("glMultiDrawArraysEXT")) == NULL;
+  r = r || (glMultiDrawElementsEXT = (glMultiDrawElementsEXTPROC) glewGetProcAddress("glMultiDrawElementsEXT")) == NULL;
+  return r;
+}
+#endif /* GL_EXT_multi_draw_arrays */
+
+/* ------------------------- EXT_point_parameters ------------------------- */
+
+#ifdef GL_EXT_point_parameters
+glPointParameterfEXTPROC glPointParameterfEXT = NULL;
+glPointParameterfvEXTPROC glPointParameterfvEXT = NULL;
+
+static GLboolean _glewInit_EXT_point_parameters ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glPointParameterfEXT = (glPointParameterfEXTPROC)glewGetProcAddress("glPointParameterfEXT")) == NULL;
+  r = r || (glPointParameterfvEXT = (glPointParameterfvEXTPROC)glewGetProcAddress("glPointParameterfvEXT")) == NULL;
+  return r;
+}
+#endif /* GL_EXT_point_parameters */
+
+/* -------------------------- EXT_secondary_color ------------------------- */
+
+#ifdef GL_EXT_secondary_color
+glSecondaryColor3bEXTPROC glSecondaryColor3bEXT = NULL;
+glSecondaryColor3bvEXTPROC glSecondaryColor3bvEXT = NULL;
+glSecondaryColor3dEXTPROC glSecondaryColor3dEXT = NULL;
+glSecondaryColor3dvEXTPROC glSecondaryColor3dvEXT = NULL;
+glSecondaryColor3fEXTPROC glSecondaryColor3fEXT = NULL;
+glSecondaryColor3fvEXTPROC glSecondaryColor3fvEXT = NULL;
+glSecondaryColor3iEXTPROC glSecondaryColor3iEXT = NULL;
+glSecondaryColor3ivEXTPROC glSecondaryColor3ivEXT = NULL;
+glSecondaryColor3sEXTPROC glSecondaryColor3sEXT = NULL;
+glSecondaryColor3svEXTPROC glSecondaryColor3svEXT = NULL;
+glSecondaryColor3ubEXTPROC glSecondaryColor3ubEXT = NULL;
+glSecondaryColor3ubvEXTPROC glSecondaryColor3ubvEXT = NULL;
+glSecondaryColor3uiEXTPROC glSecondaryColor3uiEXT = NULL;
+glSecondaryColor3uivEXTPROC glSecondaryColor3uivEXT = NULL;
+glSecondaryColor3usEXTPROC glSecondaryColor3usEXT = NULL;
+glSecondaryColor3usvEXTPROC glSecondaryColor3usvEXT = NULL;
+glSecondaryColorPointerEXTPROC glSecondaryColorPointerEXT = NULL;
+
+static GLboolean _glewInit_EXT_secondary_color ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glSecondaryColor3bEXT = (glSecondaryColor3bEXTPROC)glewGetProcAddress("glSecondaryColor3bEXT")) == NULL;
+  r = r || (glSecondaryColor3bvEXT = (glSecondaryColor3bvEXTPROC)glewGetProcAddress("glSecondaryColor3bvEXT")) == NULL;
+  r = r || (glSecondaryColor3dEXT = (glSecondaryColor3dEXTPROC)glewGetProcAddress("glSecondaryColor3dEXT")) == NULL;
+  r = r || (glSecondaryColor3dvEXT = (glSecondaryColor3dvEXTPROC)glewGetProcAddress("glSecondaryColor3dvEXT")) == NULL;
+  r = r || (glSecondaryColor3fEXT = (glSecondaryColor3fEXTPROC)glewGetProcAddress("glSecondaryColor3fEXT")) == NULL;
+  r = r || (glSecondaryColor3fvEXT = (glSecondaryColor3fvEXTPROC)glewGetProcAddress("glSecondaryColor3fvEXT")) == NULL;
+  r = r || (glSecondaryColor3iEXT = (glSecondaryColor3iEXTPROC)glewGetProcAddress("glSecondaryColor3iEXT")) == NULL;
+  r = r || (glSecondaryColor3ivEXT = (glSecondaryColor3ivEXTPROC)glewGetProcAddress("glSecondaryColor3ivEXT")) == NULL;
+  r = r || (glSecondaryColor3sEXT = (glSecondaryColor3sEXTPROC)glewGetProcAddress("glSecondaryColor3sEXT")) == NULL;
+  r = r || (glSecondaryColor3svEXT = (glSecondaryColor3svEXTPROC)glewGetProcAddress("glSecondaryColor3svEXT")) == NULL;
+  r = r || (glSecondaryColor3ubEXT = (glSecondaryColor3ubEXTPROC)glewGetProcAddress("glSecondaryColor3ubEXT")) == NULL;
+  r = r || (glSecondaryColor3ubvEXT = (glSecondaryColor3ubvEXTPROC)glewGetProcAddress("glSecondaryColor3ubvEXT")) == NULL;
+  r = r || (glSecondaryColor3uiEXT = (glSecondaryColor3uiEXTPROC)glewGetProcAddress("glSecondaryColor3uiEXT")) == NULL;
+  r = r || (glSecondaryColor3uivEXT = (glSecondaryColor3uivEXTPROC)glewGetProcAddress("glSecondaryColor3uivEXT")) == NULL;
+  r = r || (glSecondaryColor3usEXT = (glSecondaryColor3usEXTPROC)glewGetProcAddress("glSecondaryColor3usEXT")) == NULL;
+  r = r || (glSecondaryColor3usvEXT = (glSecondaryColor3usvEXTPROC)glewGetProcAddress("glSecondaryColor3usvEXT")) == NULL;
+  r = r || (glSecondaryColorPointerEXT = (glSecondaryColorPointerEXTPROC)glewGetProcAddress("glSecondaryColorPointerEXT")) == NULL;
+  return r;
+}
+#endif /* GL_EXT_secondary_color */
+
+/* ------------------------- EXT_stencil_two_side ------------------------- */
+
+#ifdef GL_EXT_stencil_two_side
+glActiveStencilFaceEXTPROC glActiveStencilFaceEXT = NULL;
+
+static GLboolean _glewInit_EXT_stencil_two_side ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glActiveStencilFaceEXT = (glActiveStencilFaceEXTPROC)glewGetProcAddress("glActiveStencilFaceEXT")) == NULL;
+  return r;
+}
+#endif /* GL_EXT_stencil_two_side */
+
+/* --------------------------- EXT_vertex_shader -------------------------- */
+
+#ifdef GL_EXT_vertex_shader
+glBeginVertexShaderEXTPROC glBeginVertexShaderEXT = NULL;
+glEndVertexShaderEXTPROC glEndVertexShaderEXT = NULL;
+glBindVertexShaderEXTPROC glBindVertexShaderEXT = NULL;
+glGenVertexShadersEXTPROC glGenVertexShadersEXT = NULL;
+glDeleteVertexShaderEXTPROC glDeleteVertexShaderEXT = NULL;
+glShaderOp1EXTPROC glShaderOp1EXT = NULL;
+glShaderOp2EXTPROC glShaderOp2EXT = NULL;
+glShaderOp3EXTPROC glShaderOp3EXT = NULL;
+glSwizzleEXTPROC glSwizzleEXT = NULL;
+glWriteMaskEXTPROC glWriteMaskEXT = NULL;
+glInsertComponentEXTPROC glInsertComponentEXT = NULL;
+glExtractComponentEXTPROC glExtractComponentEXT = NULL;
+glGenSymbolsEXTPROC glGenSymbolsEXT = NULL;
+glSetInvariantEXTPROC glSetInvariantEXT = NULL;
+glSetLocalConstantEXTPROC glSetLocalConstantEXT = NULL;
+glVariantbvEXTPROC glVariantbvEXT = NULL;
+glVariantsvEXTPROC glVariantsvEXT = NULL;
+glVariantivEXTPROC glVariantivEXT = NULL;
+glVariantfvEXTPROC glVariantfvEXT = NULL;
+glVariantdvEXTPROC glVariantdvEXT = NULL;
+glVariantubvEXTPROC glVariantubvEXT = NULL;
+glVariantusvEXTPROC glVariantusvEXT = NULL;
+glVariantuivEXTPROC glVariantuivEXT = NULL;
+glVariantPointerEXTPROC glVariantPointerEXT = NULL;
+glEnableVariantClientStateEXTPROC glEnableVariantClientStateEXT = NULL;
+glDisableVariantClientStateEXTPROC glDisableVariantClientStateEXT = NULL;
+glBindLightParameterEXTPROC glBindLightParameterEXT = NULL;
+glBindMaterialParameterEXTPROC glBindMaterialParameterEXT = NULL;
+glBindTexGenParameterEXTPROC glBindTexGenParameterEXT = NULL;
+glBindTextureUnitParameterEXTPROC glBindTextureUnitParameterEXT = NULL;
+glBindParameterEXTPROC glBindParameterEXT = NULL;
+glIsVariantEnabledEXTPROC glIsVariantEnabledEXT = NULL;
+glGetVariantBooleanvEXTPROC glGetVariantBooleanvEXT = NULL;
+glGetVariantIntegervEXTPROC glGetVariantIntegervEXT = NULL;
+glGetVariantFloatvEXTPROC glGetVariantFloatvEXT = NULL;
+glGetVariantPointervEXTPROC glGetVariantPointervEXT = NULL;
+glGetInvariantBooleanvEXTPROC glGetInvariantBooleanvEXT = NULL;
+glGetInvariantIntegervEXTPROC glGetInvariantIntegervEXT = NULL;
+glGetInvariantFloatvEXTPROC glGetInvariantFloatvEXT = NULL;
+glGetLocalConstantBooleanvEXTPROC glGetLocalConstantBooleanvEXT = NULL;
+glGetLocalConstantIntegervEXTPROC glGetLocalConstantIntegervEXT = NULL;
+glGetLocalConstantFloatvEXTPROC glGetLocalConstantFloatvEXT = NULL;
+
+static GLboolean _glewInit_EXT_vertex_shader ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glBeginVertexShaderEXT = (glBeginVertexShaderEXTPROC)glewGetProcAddress("glBeginVertexShaderEXT")) == NULL;
+  r = r || (glEndVertexShaderEXT = (glEndVertexShaderEXTPROC)glewGetProcAddress("glEndVertexShaderEXT")) == NULL;
+  r = r || (glBindVertexShaderEXT = (glBindVertexShaderEXTPROC)glewGetProcAddress("glBindVertexShaderEXT")) == NULL;
+  r = r || (glGenVertexShadersEXT = (glGenVertexShadersEXTPROC)glewGetProcAddress("glGenVertexShadersEXT")) == NULL;
+  r = r || (glDeleteVertexShaderEXT = (glDeleteVertexShaderEXTPROC)glewGetProcAddress("glDeleteVertexShaderEXT")) == NULL;
+  r = r || (glShaderOp1EXT = (glShaderOp1EXTPROC)glewGetProcAddress("glShaderOp1EXT")) == NULL;
+  r = r || (glShaderOp2EXT = (glShaderOp2EXTPROC)glewGetProcAddress("glShaderOp2EXT")) == NULL;
+  r = r || (glShaderOp3EXT = (glShaderOp3EXTPROC)glewGetProcAddress("glShaderOp3EXT")) == NULL;
+  r = r || (glSwizzleEXT = (glSwizzleEXTPROC)glewGetProcAddress("glSwizzleEXT")) == NULL;
+  r = r || (glWriteMaskEXT = (glWriteMaskEXTPROC)glewGetProcAddress("glWriteMaskEXT")) == NULL;
+  r = r || (glInsertComponentEXT = (glInsertComponentEXTPROC)glewGetProcAddress("glInsertComponentEXT")) == NULL;
+  r = r || (glExtractComponentEXT = (glExtractComponentEXTPROC)glewGetProcAddress("glExtractComponentEXT")) == NULL;
+  r = r || (glGenSymbolsEXT = (glGenSymbolsEXTPROC)glewGetProcAddress("glGenSymbolsEXT")) == NULL;
+  r = r || (glSetInvariantEXT = (glSetInvariantEXTPROC)glewGetProcAddress("glSetInvariantEXT")) == NULL;
+  r = r || (glSetLocalConstantEXT = (glSetLocalConstantEXTPROC)glewGetProcAddress("glSetLocalConstantEXT")) == NULL;
+  r = r || (glVariantbvEXT = (glVariantbvEXTPROC)glewGetProcAddress("glVariantbvEXT")) == NULL;
+  r = r || (glVariantsvEXT = (glVariantsvEXTPROC)glewGetProcAddress("glVariantsvEXT")) == NULL;
+  r = r || (glVariantivEXT = (glVariantivEXTPROC)glewGetProcAddress("glVariantivEXT")) == NULL;
+  r = r || (glVariantfvEXT = (glVariantfvEXTPROC)glewGetProcAddress("glVariantfvEXT")) == NULL;
+  r = r || (glVariantdvEXT = (glVariantdvEXTPROC)glewGetProcAddress("glVariantdvEXT")) == NULL;
+  r = r || (glVariantubvEXT = (glVariantubvEXTPROC)glewGetProcAddress("glVariantubvEXT")) == NULL;
+  r = r || (glVariantusvEXT = (glVariantusvEXTPROC)glewGetProcAddress("glVariantusvEXT")) == NULL;
+  r = r || (glVariantuivEXT = (glVariantuivEXTPROC)glewGetProcAddress("glVariantuivEXT")) == NULL;
+  r = r || (glVariantPointerEXT = (glVariantPointerEXTPROC)glewGetProcAddress("glVariantPointerEXT")) == NULL;
+  r = r || (glEnableVariantClientStateEXT = (glEnableVariantClientStateEXTPROC)glewGetProcAddress("glEnableVariantClientStateEXT")) == NULL;
+  r = r || (glDisableVariantClientStateEXT = (glDisableVariantClientStateEXTPROC)glewGetProcAddress("glDisableVariantClientStateEXT")) == NULL;
+  r = r || (glBindLightParameterEXT = (glBindLightParameterEXTPROC)glewGetProcAddress("glBindLightParameterEXT")) == NULL;
+  r = r || (glBindMaterialParameterEXT = (glBindMaterialParameterEXTPROC)glewGetProcAddress("glBindMaterialParameterEXT")) == NULL;
+  r = r || (glBindTexGenParameterEXT = (glBindTexGenParameterEXTPROC)glewGetProcAddress("glBindTexGenParameterEXT")) == NULL;
+  r = r || (glBindTextureUnitParameterEXT = (glBindTextureUnitParameterEXTPROC)glewGetProcAddress("glBindTextureUnitParameterEXT")) == NULL;
+  r = r || (glBindParameterEXT = (glBindParameterEXTPROC)glewGetProcAddress("glBindParameterEXT")) == NULL;
+  r = r || (glIsVariantEnabledEXT = (glIsVariantEnabledEXTPROC)glewGetProcAddress("glIsVariantEnabledEXT")) == NULL;
+  r = r || (glGetVariantBooleanvEXT = (glGetVariantBooleanvEXTPROC)glewGetProcAddress("glGetVariantBooleanvEXT")) == NULL;
+  r = r || (glGetVariantIntegervEXT = (glGetVariantIntegervEXTPROC)glewGetProcAddress("glGetVariantIntegervEXT")) == NULL;
+  r = r || (glGetVariantFloatvEXT = (glGetVariantFloatvEXTPROC)glewGetProcAddress("glGetVariantFloatvEXT")) == NULL;
+  r = r || (glGetVariantPointervEXT = (glGetVariantPointervEXTPROC)glewGetProcAddress("glGetVariantPointervEXT")) == NULL;
+  r = r || (glGetInvariantBooleanvEXT = (glGetInvariantBooleanvEXTPROC)glewGetProcAddress("glGetInvariantBooleanvEXT")) == NULL;
+  r = r || (glGetInvariantIntegervEXT = (glGetInvariantIntegervEXTPROC)glewGetProcAddress("glGetInvariantIntegervEXT")) == NULL;
+  r = r || (glGetInvariantFloatvEXT = (glGetInvariantFloatvEXTPROC)glewGetProcAddress("glGetInvariantFloatvEXT")) == NULL;
+  r = r || (glGetLocalConstantBooleanvEXT = (glGetLocalConstantBooleanvEXTPROC)glewGetProcAddress("glGetLocalConstantBooleanvEXT")) == NULL;
+  r = r || (glGetLocalConstantIntegervEXT = (glGetLocalConstantIntegervEXTPROC)glewGetProcAddress("glGetLocalConstantIntegervEXT")) == NULL;
+  r = r || (glGetLocalConstantFloatvEXT = (glGetLocalConstantFloatvEXTPROC)glewGetProcAddress("glGetLocalConstantFloatvEXT")) == NULL;
+  return r;
+}
+#endif /* GL_EXT_vertex_shader */
+
+/* ------------------------- EXT_vertex_weighting ------------------------- */
+
+#ifdef GL_EXT_vertex_weighting
+glVertexWeightfEXTPROC glVertexWeightfEXT = NULL;
+glVertexWeightfvEXTPROC glVertexWeightfvEXT = NULL;
+glVertexWeightPointerEXTPROC glVertexWeightPointerEXT = NULL;
+
+static GLboolean _glewInit_EXT_vertex_weighting ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glVertexWeightfEXT = (glVertexWeightfEXTPROC)glewGetProcAddress("glVertexWeightfEXT")) == NULL;
+  r = r || (glVertexWeightfvEXT = (glVertexWeightfvEXTPROC)glewGetProcAddress("glVertexWeightfvEXT")) == NULL;
+  r = r || (glVertexWeightPointerEXT = (glVertexWeightPointerEXTPROC)glewGetProcAddress("glVertexWeightPointerEXT")) == NULL;
+  return r;
+}
+#endif /* GL_EXT_vertex_weighting */
+
+/* --------------------------- KTX_buffer_region -------------------------- */
+
+#ifdef GL_KTX_buffer_region
+glBufferRegionEnabledEXTPROC glBufferRegionEnabledEXT = NULL;
+glNewBufferRegionEXTPROC glNewBufferRegionEXT = NULL;
+glDeleteBufferRegionEXTPROC glDeleteBufferRegionEXT = NULL;
+glReadBufferRegionEXTPROC glReadBufferRegionEXT = NULL;
+glDrawBufferRegionEXTPROC glDrawBufferRegionEXT = NULL;
+
+static GLboolean _glewInit_KTX_buffer_region ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glBufferRegionEnabledEXT = (glBufferRegionEnabledEXTPROC)glewGetProcAddress("glBufferRegionEnabledKTX")) == NULL;
+  r = r || (glNewBufferRegionEXT = (glNewBufferRegionEXTPROC)glewGetProcAddress("glNewBufferRegionKTX")) == NULL;
+  r = r || (glDeleteBufferRegionEXT = (glDeleteBufferRegionEXTPROC)glewGetProcAddress("glDeleteBufferRegionKTX")) == NULL;
+  r = r || (glReadBufferRegionEXT = (glReadBufferRegionEXTPROC)glewGetProcAddress("glReadBufferRegionKTX")) == NULL;
+  r = r || (glDrawBufferRegionEXT = (glDrawBufferRegionEXTPROC)glewGetProcAddress("glDrawBufferRegionKTX")) == NULL;
+  return r;
+}
+#endif /* GL_KTX_buffer_region */
+
+/* ------------------------------ WIN_swap_hint --------------------------- */
+
+#ifdef GL_WIN_swap_hint
+glAddSwapHintRectWinPROC glAddSwapHintRectWin = NULL;
+
+static GLboolean _glewInit_WIN_swap_hint ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glAddSwapHintRectWin = (glAddSwapHintRectWinPROC)glewGetProcAddress("glAddSwapHintRectWIN")) == NULL;
+  return r;
+}
+#endif /* GL_WIN_swap_hint */
+
+/* ---------------------------- ATI_draw_buffers -------------------------- */
+
+#ifdef GL_ATI_draw_buffers
+glDrawBuffersPROC glDrawBuffers = NULL;
+
+static GLboolean _glewInit_ATI_draw_buffers ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glDrawBuffers = (glDrawBuffersPROC)glewGetProcAddress("glDrawBuffers")) == NULL;
+  return r;
+}
+#endif /* GL_ATI_draw_buffers */
+
+/* --------------------------- ATI_element_array -------------------------- */
+
+#ifdef GL_ATI_element_array
+glElementPointerATIPROC glElementPointerATI = NULL;
+glDrawElementArrayATIPROC glDrawElementArrayATI = NULL;
+glDrawRangeElementArrayATIPROC glDrawRangeElementArrayATI = NULL;
+
+static GLboolean _glewInit_ATI_element_array ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glElementPointerATI = (glElementPointerATIPROC)glewGetProcAddress("glElementPointerATI")) == NULL;
+  r = r || (glDrawElementArrayATI = (glDrawElementArrayATIPROC)glewGetProcAddress("glDrawElementArrayATI")) == NULL;
+  r = r || (glDrawRangeElementArrayATI = (glDrawRangeElementArrayATIPROC)glewGetProcAddress("glDrawRangeElementArrayATI")) == NULL;
+  return r;
+}
+#endif /* GL_ATI_element_array */
+
+/* -------------------------- ATI_envmap_bumpmap -------------------------- */
+
+#ifdef GL_ATI_envmap_bumpmap
+glTexBumpParameterivATIPROC glTexBumpParameterivATI = NULL;
+glTexBumpParameterfvATIPROC glTexBumpParameterfvATI = NULL;
+glGetTexBumpParameterivATIPROC glGetTexBumpParameterivATI = NULL;
+glGetTexBumpParameterfvATIPROC glGetTexBumpParameterfvATI = NULL;
+
+static GLboolean _glewInit_ATI_envmap_bumpmap ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glTexBumpParameterivATI = (glTexBumpParameterivATIPROC)glewGetProcAddress("glTexBumpParameterivATI")) == NULL;
+  r = r || (glTexBumpParameterfvATI = (glTexBumpParameterfvATIPROC)glewGetProcAddress("glTexBumpParameterfvATI")) == NULL;
+  r = r || (glGetTexBumpParameterivATI = (glGetTexBumpParameterivATIPROC)glewGetProcAddress("glGetTexBumpParameterivATI")) == NULL;
+  r = r || (glGetTexBumpParameterfvATI = (glGetTexBumpParameterfvATIPROC)glewGetProcAddress("glGetTexBumpParameterfvATI")) == NULL;
+  return r;
+}
+#endif /* GL_ATI_envmap_bumpmap */
+
+/* ------------------------- ATI_fragment_shader ------------------------- */
+
+#ifdef GL_ATI_fragment_shader
+glGenFragmentShadersATIPROC glGenFragmentShadersATI = NULL;
+glBindFragmentShaderATIPROC glBindFragmentShaderATI = NULL;
+glDeleteFragmentShaderATIPROC glDeleteFragmentShaderATI = NULL;
+glBeginFragmentShaderATIPROC glBeginFragmentShaderATI = NULL;
+glEndFragmentShaderATIPROC glEndFragmentShaderATI = NULL;
+glPassTexCoordATIPROC glPassTexCoordATI = NULL;
+glSampleMapATIPROC glSampleMapATI = NULL;
+glColorFragmentOp1ATIPROC glColorFragmentOp1ATI = NULL;
+glColorFragmentOp2ATIPROC glColorFragmentOp2ATI = NULL;
+glColorFragmentOp3ATIPROC glColorFragmentOp3ATI = NULL;
+glAlphaFragmentOp1ATIPROC glAlphaFragmentOp1ATI = NULL;
+glAlphaFragmentOp2ATIPROC glAlphaFragmentOp2ATI = NULL;
+glAlphaFragmentOp3ATIPROC glAlphaFragmentOp3ATI = NULL;
+glSetFragmentShaderConstantATIPROC glSetFragmentShaderConstantATI = NULL;
+
+static GLboolean _glewInit_ATI_fragment_shader ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glGenFragmentShadersATI = (glGenFragmentShadersATIPROC)glewGetProcAddress("glGenFragmentShadersATI")) == NULL;
+  r = r || (glBindFragmentShaderATI = (glBindFragmentShaderATIPROC)glewGetProcAddress("glBindFragmentShaderATI")) == NULL;
+  r = r || (glDeleteFragmentShaderATI = (glDeleteFragmentShaderATIPROC)glewGetProcAddress("glDeleteFragmentShaderATI")) == NULL;
+  r = r || (glBeginFragmentShaderATI = (glBeginFragmentShaderATIPROC)glewGetProcAddress("glBeginFragmentShaderATI")) == NULL;
+  r = r || (glEndFragmentShaderATI = (glEndFragmentShaderATIPROC)glewGetProcAddress("glEndFragmentShaderATI")) == NULL;
+  r = r || (glPassTexCoordATI = (glPassTexCoordATIPROC)glewGetProcAddress("glPassTexCoordATI")) == NULL;
+  r = r || (glSampleMapATI = (glSampleMapATIPROC)glewGetProcAddress("glSampleMapATI")) == NULL;
+  r = r || (glColorFragmentOp1ATI = (glColorFragmentOp1ATIPROC)glewGetProcAddress("glColorFragmentOp1ATI")) == NULL;
+  r = r || (glColorFragmentOp2ATI = (glColorFragmentOp2ATIPROC)glewGetProcAddress("glColorFragmentOp2ATI")) == NULL;
+  r = r || (glColorFragmentOp3ATI = (glColorFragmentOp3ATIPROC)glewGetProcAddress("glColorFragmentOp3ATI")) == NULL;
+  r = r || (glAlphaFragmentOp1ATI = (glAlphaFragmentOp1ATIPROC)glewGetProcAddress("glAlphaFragmentOp1ATI")) == NULL;
+  r = r || (glAlphaFragmentOp2ATI = (glAlphaFragmentOp2ATIPROC)glewGetProcAddress("glAlphaFragmentOp2ATI")) == NULL;
+  r = r || (glAlphaFragmentOp3ATI = (glAlphaFragmentOp3ATIPROC)glewGetProcAddress("glAlphaFragmentOp3ATI")) == NULL;
+  r = r || (glSetFragmentShaderConstantATI = (glSetFragmentShaderConstantATIPROC)glewGetProcAddress("glSetFragmentShaderConstantATI")) == NULL;
+  return r;
+}
+#endif /* GL_ATI_fragment_shader */
+
+/* ------------------------- ATI_map_object_buffer ------------------------ */
+
+#ifdef GL_ATI_map_object_buffer
+glMapObjectBufferATIPROC glMapObjectBufferATI = NULL;
+glUnmapObjectBufferATIPROC glUnmapObjectBufferATI = NULL;
+
+static GLboolean _glewInit_ATI_map_object_buffer ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glMapObjectBufferATI = (glMapObjectBufferATIPROC)glewGetProcAddress("glMapObjectBufferATI")) == NULL;
+  r = r || (glUnmapObjectBufferATI = (glUnmapObjectBufferATIPROC)glewGetProcAddress("glUnmapObjectBufferATI")) == NULL;
+  return r;
+}
+#endif /* GL_ATI_map_object_buffer */
+
+/* --------------------------- ATI_mapped_texture ------------------------- */
+
+#ifdef GL_ATI_mapped_texture
+glMapTexture3DPROC glMapTexture3D;
+glUnmapTexture3DPROC glUnmapTexture3D;
+
+static GLboolean _glewInit_ATI_mapped_texture ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glMapTexture3D = (glMapTexture3DPROC)glewGetProcAddress("glMapTexture3D")) == NULL;
+  r = r || (glUnmapTexture3D = (glUnmapTexture3DPROC)glewGetProcAddress("glUnmapTexture3D")) == NULL;
+  return r;
+}
+#endif /* GL_ATI_mapped_texture */
+
+/* --------------------------- ATI_pn_triangles --------------------------- */
+
+#ifdef GL_ATI_pn_triangles
+glPNTrianglesiATIPROC glPNTrianglesiATI = NULL;
+glPNTrianglesfATIPROC glPNTrianglesfATI = NULL;
+
+static GLboolean _glewInit_ATI_pn_triangles ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glPNTrianglesiATI = (glPNTrianglesiATIPROC)glewGetProcAddress("glPNTrianglesiATI")) == NULL;
+  r = r || (glPNTrianglesfATI = (glPNTrianglesfATIPROC)glewGetProcAddress("glPNTrianglesfATI")) == NULL;
+  return r;
+}
+#endif /* GL_ATI_pn_triangles */
+
+/* -------------------------- ATI_separate_stencil ------------------------ */
+
+#ifdef GL_ATI_separate_stencil
+glStencilOpSeparateATIPROC glStencilOpSeparateATI = NULL;
+glStencilFuncSeparateATIPROC glStencilFuncSeparateATI = NULL;
+
+static GLboolean _glewInit_ATI_separate_stencil ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glStencilOpSeparateATI = (glStencilOpSeparateATIPROC)glewGetProcAddress("glStencilOpSeparateATI")) == NULL;
+  r = r || (glStencilFuncSeparateATI = (glStencilFuncSeparateATIPROC)glewGetProcAddress("glStencilFuncSeparateATI")) == NULL;
+  return r;
+}
+#endif /* GL_ATI_separate_stencil */
+
+/* ----------------------------- ATI_timestamp ---------------------------- */
+
+#ifdef GL_ATI_timestamp
+glNewTimeStampPROC glNewTimeStamp = NULL;
+glDeleteTimeStampPROC glDeleteTimeStamp = NULL;
+glSendTimeStampPROC glSendTimeStamp = NULL;
+glWaitTimeStampPROC glWaitTimeStamp = NULL;
+
+static GLboolean _glewInit_ATI_timestamp ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glNewTimeStamp = (glNewTimeStampPROC) glewGetProcAddress("glNewTimeStamp")) == NULL;
+  r = r || (glDeleteTimeStamp = (glDeleteTimeStampPROC)glewGetProcAddress("glDeleteTimeStamp")) == NULL;
+  r = r || (glSendTimeStamp = (glSendTimeStampPROC)glewGetProcAddress("glSendTimeStamp")) == NULL;
+  r = r || (glWaitTimeStamp = (glWaitTimeStampPROC)glewGetProcAddress("glWaitTimeStamp")) == NULL;
+  return r;
+}
+#endif /* GL_ATI_timestamp */
+
+/* ------------------------ ATI_vertex_array_object ----------------------- */
+
+#ifdef GL_ATI_vertex_array_object
+glNewObjectBufferATIPROC glNewObjectBufferATI = NULL;
+glIsObjectBufferATIPROC glIsObjectBufferATI = NULL;
+glUpdateObjectBufferATIPROC glUpdateObjectBufferATI = NULL;
+glGetObjectBufferfvATIPROC glGetObjectBufferfvATI = NULL;
+glGetObjectBufferivATIPROC glGetObjectBufferivATI = NULL;
+glFreeObjectBufferATIPROC glFreeObjectBufferATI = NULL;
+glArrayObjectATIPROC glArrayObjectATI = NULL;
+glGetArrayObjectfvATIPROC glGetArrayObjectfvATI = NULL;
+glGetArrayObjectivATIPROC glGetArrayObjectivATI = NULL;
+glVariantArrayObjectATIPROC glVariantArrayObjectATI = NULL;
+glGetVariantArrayObjectfvATIPROC glGetVariantArrayObjectfvATI = NULL;
+glGetVariantArrayObjectivATIPROC glGetVariantArrayObjectivATI = NULL;
+
+static GLboolean _glewInit_ATI_vertex_array_object ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glNewObjectBufferATI = (glNewObjectBufferATIPROC)glewGetProcAddress("glNewObjectBufferATI")) == NULL;
+  r = r || (glIsObjectBufferATI = (glIsObjectBufferATIPROC)glewGetProcAddress("glIsObjectBufferATI")) == NULL;
+  r = r || (glUpdateObjectBufferATI = (glUpdateObjectBufferATIPROC)glewGetProcAddress("glUpdateObjectBufferATI")) == NULL;
+  r = r || (glGetObjectBufferfvATI = (glGetObjectBufferfvATIPROC)glewGetProcAddress("glGetObjectBufferfvATI")) == NULL;
+  r = r || (glGetObjectBufferivATI = (glGetObjectBufferivATIPROC)glewGetProcAddress("glGetObjectBufferivATI")) == NULL;
+  r = r || (glFreeObjectBufferATI = (glFreeObjectBufferATIPROC)glewGetProcAddress("glFreeObjectBufferATI")) == NULL;
+  r = r || (glArrayObjectATI = (glArrayObjectATIPROC)glewGetProcAddress("glArrayObjectATI")) == NULL;
+  r = r || (glGetArrayObjectfvATI = (glGetArrayObjectfvATIPROC)glewGetProcAddress("glGetArrayObjectfvATI")) == NULL;
+  r = r || (glGetArrayObjectivATI = (glGetArrayObjectivATIPROC)glewGetProcAddress("glGetArrayObjectivATI")) == NULL;
+  r = r || (glVariantArrayObjectATI = (glVariantArrayObjectATIPROC)glewGetProcAddress("glVariantArrayObjectATI")) == NULL;
+  r = r || (glGetVariantArrayObjectfvATI = (glGetVariantArrayObjectfvATIPROC)glewGetProcAddress("glGetVariantArrayObjectfvATI")) == NULL;
+  r = r || (glGetVariantArrayObjectivATI = (glGetVariantArrayObjectivATIPROC)glewGetProcAddress("glGetVariantArrayObjectivATI")) == NULL;
+  return r;
+}
+#endif /* GL_ATI_vertex_array_object */
+
+/* -------------------- ATI_vertex_attrib_array_object -------------------- */
+
+#ifdef GL_ATI_vertex_attrib_array_object
+glVertexAttribArratObjectATIPROC glVertexAttribArratObjectATI = NULL;
+glGetVertexAttribArratObjectfvATIPROC glGetVertexAttribArratObjectfvATI = NULL;
+glGetVertexAttrubAttatObjectivATIPROC glGetVertexAttrubAttatObjectivATI = NULL;
+
+static GLboolean _glewInit_ATI_vertex_attrib_array_object ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glVertexAttribArratObjectATI = (glVertexAttribArratObjectATIPROC) glewGetProcAddress("glVertexAttribArratObjectATI")) == NULL;
+  r = r || (glGetVertexAttribArratObjectfvATI = (glGetVertexAttribArratObjectfvATIPROC) glewGetProcAddress("glGetVertexAttribArratObjectfvATI")) == NULL;
+  r = r || (glGetVertexAttrubAttatObjectivATI = (glGetVertexAttrubAttatObjectivATIPROC) glewGetProcAddress("glGetVertexAttrubAttatObjectivATI")) == NULL;
+  return r;
+}
+#endif /* GL_ATI_vertex_attrib_array_object */
+
+/* -------------------------- ATI_vertex_streams -------------------------- */
+
+#ifdef GL_ATI_vertex_streams 
+glClientActiveVertexStreamATIPROC glClientActiveVertexStreamATI = NULL;
+glVertexBlendEnviATIPROC glVertexBlendEnviATI = NULL;
+glVertexBlendEnvfATIPROC glVertexBlendEnvfATI = NULL;
+glVertexStream2sATIPROC glVertexStream2sATI = NULL;
+glVertexStream2svATIPROC glVertexStream2svATI = NULL;
+glVertexStream2iATIPROC glVertexStream2iATI = NULL;
+glVertexStream2ivATIPROC glVertexStream2ivATI = NULL;
+glVertexStream2fATIPROC glVertexStream2fATI = NULL;
+glVertexStream2fvATIPROC glVertexStream2fvATI = NULL;
+glVertexStream2dATIPROC glVertexStream2dATI = NULL;
+glVertexStream2dvATIPROC glVertexStream2dvATI = NULL;
+glVertexStream3sATIPROC glVertexStream3sATI = NULL;
+glVertexStream3svATIPROC glVertexStream3svATI = NULL;
+glVertexStream3iATIPROC glVertexStream3iATI = NULL;
+glVertexStream3ivATIPROC glVertexStream3ivATI = NULL;
+glVertexStream3fATIPROC glVertexStream3fATI = NULL;
+glVertexStream3fvATIPROC glVertexStream3fvATI = NULL;
+glVertexStream3dATIPROC glVertexStream3dATI = NULL;
+glVertexStream3dvATIPROC glVertexStream3dvATI = NULL;
+glVertexStream4sATIPROC glVertexStream4sATI = NULL;
+glVertexStream4svATIPROC glVertexStream4svATI = NULL;
+glVertexStream4iATIPROC glVertexStream4iATI = NULL;
+glVertexStream4ivATIPROC glVertexStream4ivATI = NULL;
+glVertexStream4fATIPROC glVertexStream4fATI = NULL;
+glVertexStream4fvATIPROC glVertexStream4fvATI = NULL;
+glVertexStream4dATIPROC glVertexStream4dATI = NULL;
+glVertexStream4dvATIPROC glVertexStream4dvATI = NULL;
+glNormalStream3bATIPROC glNormalStream3bATI = NULL;
+glNormalStream3bvATIPROC glNormalStream3bvATI = NULL;
+glNormalStream3sATIPROC glNormalStream3sATI = NULL;
+glNormalStream3svATIPROC glNormalStream3svATI = NULL;
+glNormalStream3iATIPROC glNormalStream3iATI = NULL;
+glNormalStream3ivATIPROC glNormalStream3ivATI = NULL;
+glNormalStream3fATIPROC glNormalStream3fATI = NULL;
+glNormalStream3fvATIPROC glNormalStream3fvATI = NULL;
+glNormalStream3dATIPROC glNormalStream3dATI = NULL;
+glNormalStream3dvATIPROC glNormalStream3dvATI = NULL;
+
+static GLboolean _glewInit_ATI_vertex_streams ()
+{
+  GLboolean r = GL_FALSE;
+  glClientActiveVertexStreamATI = (glClientActiveVertexStreamATIPROC)glewGetProcAddress("glClientActiveVertexStreamATI");
+  r = r || (glVertexBlendEnviATI = (glVertexBlendEnviATIPROC)glewGetProcAddress("glVertexBlendEnviATI")) == NULL;
+  r = r || (glVertexBlendEnvfATI = (glVertexBlendEnvfATIPROC)glewGetProcAddress("glVertexBlendEnvfATI")) == NULL;
+  r = r || (glVertexStream2sATI = (glVertexStream2sATIPROC)glewGetProcAddress("glVertexStream2sATI")) == NULL;
+  r = r || (glVertexStream2svATI = (glVertexStream2svATIPROC)glewGetProcAddress("glVertexStream2svATI")) == NULL;
+  r = r || (glVertexStream2iATI = (glVertexStream2iATIPROC)glewGetProcAddress("glVertexStream2iATI")) == NULL;
+  r = r || (glVertexStream2ivATI = (glVertexStream2ivATIPROC)glewGetProcAddress("glVertexStream2ivATI")) == NULL;
+  r = r || (glVertexStream2fATI = (glVertexStream2fATIPROC)glewGetProcAddress("glVertexStream2fATI")) == NULL;
+  r = r || (glVertexStream2fvATI = (glVertexStream2fvATIPROC)glewGetProcAddress("glVertexStream2fvATI")) == NULL;
+  r = r || (glVertexStream2dATI = (glVertexStream2dATIPROC)glewGetProcAddress("glVertexStream2dATI")) == NULL;
+  r = r || (glVertexStream2dvATI = (glVertexStream2dvATIPROC)glewGetProcAddress("glVertexStream2dvATI")) == NULL;
+  r = r || (glVertexStream3sATI = (glVertexStream3sATIPROC)glewGetProcAddress("glVertexStream3sATI")) == NULL;
+  r = r || (glVertexStream3svATI = (glVertexStream3svATIPROC)glewGetProcAddress("glVertexStream3svATI")) == NULL;
+  r = r || (glVertexStream3iATI = (glVertexStream3iATIPROC)glewGetProcAddress("glVertexStream3iATI")) == NULL;
+  r = r || (glVertexStream3ivATI = (glVertexStream3ivATIPROC)glewGetProcAddress("glVertexStream3ivATI")) == NULL;
+  r = r || (glVertexStream3fATI = (glVertexStream3fATIPROC)glewGetProcAddress("glVertexStream3fATI")) == NULL;
+  r = r || (glVertexStream3fvATI = (glVertexStream3fvATIPROC)glewGetProcAddress("glVertexStream3fvATI")) == NULL;
+  r = r || (glVertexStream3dATI = (glVertexStream3dATIPROC)glewGetProcAddress("glVertexStream3dATI")) == NULL;
+  r = r || (glVertexStream3dvATI = (glVertexStream3dvATIPROC)glewGetProcAddress("glVertexStream3dvATI")) == NULL;
+  r = r || (glVertexStream4sATI = (glVertexStream4sATIPROC)glewGetProcAddress("glVertexStream4sATI")) == NULL;
+  r = r || (glVertexStream4svATI = (glVertexStream4svATIPROC)glewGetProcAddress("glVertexStream4svATI")) == NULL;
+  r = r || (glVertexStream4iATI = (glVertexStream4iATIPROC)glewGetProcAddress("glVertexStream4iATI")) == NULL;
+  r = r || (glVertexStream4ivATI = (glVertexStream4ivATIPROC)glewGetProcAddress("glVertexStream4ivATI")) == NULL;
+  r = r || (glVertexStream4fATI = (glVertexStream4fATIPROC)glewGetProcAddress("glVertexStream4fATI")) == NULL;
+  r = r || (glVertexStream4fvATI = (glVertexStream4fvATIPROC)glewGetProcAddress("glVertexStream4fvATI")) == NULL;
+  r = r || (glVertexStream4dATI = (glVertexStream4dATIPROC)glewGetProcAddress("glVertexStream4dATI")) == NULL;
+  r = r || (glVertexStream4dvATI = (glVertexStream4dvATIPROC)glewGetProcAddress("glVertexStream4dvATI")) == NULL;
+  r = r || (glNormalStream3bATI = (glNormalStream3bATIPROC)glewGetProcAddress("glNormalStream3bATI")) == NULL;
+  r = r || (glNormalStream3bvATI = (glNormalStream3bvATIPROC)glewGetProcAddress("glNormalStream3bvATI")) == NULL;
+  r = r || (glNormalStream3sATI = (glNormalStream3sATIPROC)glewGetProcAddress("glNormalStream3sATI")) == NULL;
+  r = r || (glNormalStream3svATI = (glNormalStream3svATIPROC)glewGetProcAddress("glNormalStream3svATI")) == NULL;
+  r = r || (glNormalStream3iATI = (glNormalStream3iATIPROC)glewGetProcAddress("glNormalStream3iATI")) == NULL;
+  r = r || (glNormalStream3ivATI = (glNormalStream3ivATIPROC)glewGetProcAddress("glNormalStream3ivATI")) == NULL;
+  r = r || (glNormalStream3fATI = (glNormalStream3fATIPROC)glewGetProcAddress("glNormalStream3fATI")) == NULL;
+  r = r || (glNormalStream3fvATI = (glNormalStream3fvATIPROC)glewGetProcAddress("glNormalStream3fvATI")) == NULL;
+  r = r || (glNormalStream3dATI = (glNormalStream3dATIPROC)glewGetProcAddress("glNormalStream3dATI")) == NULL;
+  r = r || (glNormalStream3dvATI = (glNormalStream3dvATIPROC)glewGetProcAddress("glNormalStream3dvATI")) == NULL;
+  return r;
+}
+#endif /* GL_ATI_vertex_streams */
+
+/* --------------------------- NV_element_array --------------------------- */
+
+#ifdef GL_NV_element_array
+glElementPointerNVPROC glElementPointerNV = NULL;
+glDrawElementArrayNVPROC glDrawElementArrayNV = NULL;
+glDrawRangeElementArrayNVPROC glDrawRangeElementArrayNV = NULL;
+glMultiDrawElementArrayNVPROC glMultiDrawElementArrayNV = NULL;
+glMultiDrawRangeElementArrayNVPROC glMultiDrawRangeElementArrayNV = NULL;
+
+static GLboolean _glewInit_NV_element_array ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glElementPointerNV = (glElementPointerNVPROC)glewGetProcAddress("glElementPointerNV")) == NULL;
+  r = r || (glDrawElementArrayNV = (glDrawElementArrayNVPROC)glewGetProcAddress("glDrawElementArrayNV")) == NULL;
+  r = r || (glDrawRangeElementArrayNV = (glDrawRangeElementArrayNVPROC)glewGetProcAddress("glDrawRangeElementArrayNV")) == NULL;
+  r = r || (glMultiDrawElementArrayNV = (glMultiDrawElementArrayNVPROC)glewGetProcAddress("glMultiDrawElementArrayNV")) == NULL;
+  r = r || (glMultiDrawRangeElementArrayNV = (glMultiDrawRangeElementArrayNVPROC)glewGetProcAddress("glMultiDrawRangeElementArrayNV")) == NULL;
+  return r;
+}
+#endif /* GL_NV_element_array */
+
+/* ----------------------------- NV_evaluators ---------------------------- */
+
+#ifdef GL_NV_evaluators
+glMapControlPointsNVPROC glMapControlPointsNV = NULL;
+glMapParameterivNVPROC glMapParameterivNV = NULL;
+glMapParameterfvNVPROC glMapParameterfvNV = NULL;
+glGetMapControlPointsNVPROC glGetMapControlPointsNV = NULL;
+glGetMapParameterivNVPROC glGetMapParameterivNV = NULL;
+glGetMapParameterfvNVPROC glGetMapParameterfvNV = NULL;
+glGetMapAttribParameterivNVPROC glGetMapAttribParameterivNV = NULL;
+glGetMapAttribParameterfvNVPROC glGetMapAttribParameterfvNV = NULL;
+glEvalMapsNVPROC glEvalMapsNV = NULL;
+
+static GLboolean _glewInit_NV_evaluators ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glMapControlPointsNV = (glMapControlPointsNVPROC)glewGetProcAddress("glMapControlPointsNV")) == NULL;
+  r = r || (glMapParameterivNV = (glMapParameterivNVPROC)glewGetProcAddress("glMapParameterivNV")) == NULL;
+  r = r || (glMapParameterfvNV = (glMapParameterfvNVPROC)glewGetProcAddress("glMapParameterfvNV")) == NULL;
+  r = r || (glGetMapControlPointsNV = (glGetMapControlPointsNVPROC)glewGetProcAddress("glGetMapControlPointsNV")) == NULL;
+  r = r || (glGetMapParameterivNV = (glGetMapParameterivNVPROC)glewGetProcAddress("glGetMapParameterivNV")) == NULL;
+  r = r || (glGetMapParameterfvNV = (glGetMapParameterfvNVPROC)glewGetProcAddress("glGetMapParameterfvNV")) == NULL;
+  r = r || (glGetMapAttribParameterivNV = (glGetMapAttribParameterivNVPROC)glewGetProcAddress("glGetMapAttribParameterivNV")) == NULL;
+  r = r || (glGetMapAttribParameterfvNV = (glGetMapAttribParameterfvNVPROC)glewGetProcAddress("glGetMapAttribParameterfvNV")) == NULL;
+  r = r || (glEvalMapsNV = (glEvalMapsNVPROC)glewGetProcAddress("glEvalMapsNV")) == NULL;
+  return r;
+}
+#endif /* GL_NV_evaluators */
+
+/* -------------------------- NV_fragment_program ------------------------- */
+
+#ifdef GL_NV_fragment_program
+glProgramNamedParameter4fNVPROC glProgramNamedParameter4fNV = NULL;
+glProgramNamedParameter4dNVPROC glProgramNamedParameter4dNV = NULL;
+glProgramNamedParameter4fvNVPROC glProgramNamedParameter4fvNV = NULL;
+glProgramNamedParameter4dvNVPROC glProgramNamedParameter4dvNV = NULL;
+glGetProgramNamedParameterfvNVPROC glGetProgramNamedParameterfvNV = NULL;
+glGetProgramNamedParameterdvNVPROC glGetProgramNamedParameterdvNV = NULL;
+#ifndef GL_ARB_vertex_program
+glProgramLocalParameter4dARBPROC glProgramLocalParameter4dARB = NULL;
+glProgramLocalParameter4dvARBPROC glProgramLocalParameter4dvARB = NULL;
+glProgramLocalParameter4fARBPROC glProgramLocalParameter4fARB = NULL;
+glProgramLocalParameter4fvARBPROC glProgramLocalParameter4fvARB = NULL;
+glGetProgramLocalParameterdvARBPROC glGetProgramLocalParameterdvARB = NULL;
+glGetProgramLocalParameterfvARBPROC glGetProgramLocalParameterfvARB = NULL;
+#endif /* GL_ARB_vertex_program */
+
+static GLboolean _glewInit_NV_fragment_program ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glProgramNamedParameter4fNV = (glProgramNamedParameter4fNVPROC)glewGetProcAddress("glProgramNamedParameter4fNV")) == NULL;
+  r = r || (glProgramNamedParameter4dNV = (glProgramNamedParameter4dNVPROC)glewGetProcAddress("glProgramNamedParameter4dNV")) == NULL;
+  r = r || (glProgramNamedParameter4fvNV = (glProgramNamedParameter4fvNVPROC)glewGetProcAddress("glProgramNamedParameter4fvNV")) == NULL;
+  r = r || (glProgramNamedParameter4dvNV = (glProgramNamedParameter4dvNVPROC)glewGetProcAddress("glProgramNamedParameter4dvNV")) == NULL;
+  r = r || (glGetProgramNamedParameterfvNV = (glGetProgramNamedParameterfvNVPROC)glewGetProcAddress("glGetProgramNamedParameterfvNV")) == NULL;
+  r = r || (glGetProgramNamedParameterdvNV = (glGetProgramNamedParameterdvNVPROC)glewGetProcAddress("glGetProgramNamedParameterdvNV")) == NULL;
+#ifndef GL_ARB_vertex_program
+  r = r || (glProgramLocalParameter4dARB = (glProgramLocalParameter4dARBPROC)glewGetProcAddress("glProgramLocalParameter4dARB")) == NULL;
+  r = r || (glProgramLocalParameter4dvARB = (glProgramLocalParameter4dvARBPROC)glewGetProcAddress("glProgramLocalParameter4dvARB")) == NULL;
+  r = r || (glProgramLocalParameter4fARB = (glProgramLocalParameter4fARBPROC)glewGetProcAddress("glProgramLocalParameter4fARB")) == NULL;
+  r = r || (glProgramLocalParameter4fvARB = (glProgramLocalParameter4fvARBPROC)glewGetProcAddress("glProgramLocalParameter4fvARB")) == NULL;
+  r = r || (glGetProgramLocalParameterdvARB = (glGetProgramLocalParameterdvARBPROC)glewGetProcAddress("glGetProgramLocalParameterdvARB")) == NULL;
+  r = r || (glGetProgramLocalParameterfvARB = (glGetProgramLocalParameterfvARBPROC)glewGetProcAddress("glGetProgramLocalParameterfvARB")) == NULL;
+#endif /* GL_ARB_vertex_program */
+  return r;
+}
+#endif /* GL_NV_fragment_program */
+
+/* ------------------------------- NV_fence ------------------------------- */
+
+#ifdef GL_NV_fence
+glGenFencesNVPROC glGenFencesNV = NULL;
+glDeleteFencesNVPROC glDeleteFencesNV = NULL;
+glSetFenceNVPROC glSetFenceNV = NULL;
+glTestFenceNVPROC glTestFenceNV = NULL;
+glFinishFenceNVPROC glFinishFenceNV = NULL;
+glIsFenceNVPROC glIsFenceNV = NULL;
+glGetFenceivNVPROC glGetFenceivNV = NULL;
+
+static GLboolean _glewInit_NV_fence ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glGenFencesNV = (glGenFencesNVPROC)glewGetProcAddress("glGenFencesNV")) == NULL;
+  r = r || (glDeleteFencesNV = (glDeleteFencesNVPROC)glewGetProcAddress("glDeleteFencesNV")) == NULL;
+  r = r || (glSetFenceNV = (glSetFenceNVPROC)glewGetProcAddress("glSetFenceNV")) == NULL;
+  r = r || (glTestFenceNV = (glTestFenceNVPROC)glewGetProcAddress("glTestFenceNV")) == NULL;
+  r = r || (glFinishFenceNV = (glFinishFenceNVPROC)glewGetProcAddress("glFinishFenceNV")) == NULL;
+  r = r || (glIsFenceNV = (glIsFenceNVPROC)glewGetProcAddress("glIsFenceNV")) == NULL;
+  r = r || (glGetFenceivNV = (glGetFenceivNVPROC)glewGetProcAddress("glGetFenceivNV")) == NULL;
+  return r;
+}
+#endif /* GL_NV_fence */
+
+/* -------------------------- NV_occlusion_query -------------------------- */
+
+#ifdef GL_NV_occlusion_query
+glGenOcclusionQueriesNVPROC glGenOcclusionQueriesNV = NULL;
+glDeleteOcclusionQueriesNVPROC glDeleteOcclusionQueriesNV = NULL;
+glIsOcclusionQueryNVPROC glIsOcclusionQueryNV = NULL;
+glBeginOcclusionQueryNVPROC glBeginOcclusionQueryNV = NULL;
+glEndOcclusionQueryNVPROC glEndOcclusionQueryNV = NULL;
+glGetOcclusionQueryivNVPROC glGetOcclusionQueryivNV = NULL;
+glGetOcclusionQueryuivNVPROC glGetOcclusionQueryuivNV = NULL;
+
+static GLboolean _glewInit_NV_occlusion_query ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glGenOcclusionQueriesNV = (glGenOcclusionQueriesNVPROC)glewGetProcAddress("glGenOcclusionQueriesNV")) == NULL;
+  r = r || (glDeleteOcclusionQueriesNV = (glDeleteOcclusionQueriesNVPROC)glewGetProcAddress("glDeleteOcclusionQueriesNV")) == NULL;
+  r = r || (glIsOcclusionQueryNV = (glIsOcclusionQueryNVPROC)glewGetProcAddress("glIsOcclusionQueryNV")) == NULL;
+  r = r || (glBeginOcclusionQueryNV = (glBeginOcclusionQueryNVPROC)glewGetProcAddress("glBeginOcclusionQueryNV")) == NULL;
+  r = r || (glEndOcclusionQueryNV = (glEndOcclusionQueryNVPROC)glewGetProcAddress("glEndOcclusionQueryNV")) == NULL;
+  r = r || (glGetOcclusionQueryivNV = (glGetOcclusionQueryivNVPROC)glewGetProcAddress("glGetOcclusionQueryivNV")) == NULL;
+  r = r || (glGetOcclusionQueryuivNV = (glGetOcclusionQueryuivNVPROC)glewGetProcAddress("glGetOcclusionQueryuivNV")) == NULL;
+  return r;
+}
+#endif /* GL_NV_occlusion_query */
+
+/* -------------------------- NV_pixel_data_range ------------------------- */
+
+#ifdef GL_NV_pixel_data_range
+glPixelDataRangeNVPROC glPixelDataRangeNV = NULL;
+glFlushPixelDataRangeNVPROC glFlushPixelDataRangeNV = NULL;
+
+static GLboolean _glewInit_NV_pixel_data_range ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glPixelDataRangeNV = (glPixelDataRangeNVPROC)glewGetProcAddress("glPixelDataRangeNV")) == NULL;
+  r = r || (glFlushPixelDataRangeNV = (glFlushPixelDataRangeNVPROC)glewGetProcAddress("glFlushPixelDataRangeNV")) == NULL;
+  return r;
+}
+#endif /* GL_NV_pixel_data_range */
+
+/* ---------------------------- NV_point_sprite --------------------------- */
+
+#ifdef GL_NV_point_sprite
+glPointParameteriNVPROC glPointParameteriNV = NULL;
+glPointParameterivNVPROC glPointParameterivNV = NULL;
+
+static GLboolean _glewInit_NV_point_sprite ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glPointParameteriNV = (glPointParameteriNVPROC)glewGetProcAddress("glPointParameteriNV")) == NULL;
+  r = r || (glPointParameterivNV = (glPointParameterivNVPROC)glewGetProcAddress("glPointParameterivNV")) == NULL;
+  return r;
+}
+#endif /* GL_NV_point_sprite */
+
+/* ------------------------- NV_primitive_restart ------------------------- */
+
+#ifdef GL_NV_primitive_restart
+glPrimitiveRestartNVPROC glPrimitiveRestartNV = NULL;
+glPrimitiveRestartIndexNVPROC glPrimitiveRestartIndexNV = NULL;
+
+static GLboolean _glewInit_NV_primitive_restart ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glPrimitiveRestartNV = (glPrimitiveRestartNVPROC)glewGetProcAddress("glPrimitiveRestartNV")) == NULL;
+  r = r || (glPrimitiveRestartIndexNV = (glPrimitiveRestartIndexNVPROC)glewGetProcAddress("glPrimitiveRestartIndexNV")) == NULL;
+  return r;
+}
+#endif /* GL_NV_primitive_restart */
+
+/* ------------------------- NV_register_combiners ------------------------ */
+
+#ifdef GL_NV_register_combiners
+glCombinerParameterfvNVPROC glCombinerParameterfvNV = NULL;
+glCombinerParameterfNVPROC  glCombinerParameterfNV = NULL;
+glCombinerParameterivNVPROC glCombinerParameterivNV = NULL;
+glCombinerParameteriNVPROC glCombinerParameteriNV = NULL;
+glCombinerInputNVPROC glCombinerInputNV = NULL;
+glCombinerOutputNVPROC glCombinerOutputNV = NULL;
+glFinalCombinerInputNVPROC glFinalCombinerInputNV = NULL;
+glGetCombinerInputParameterfvNVPROC glGetCombinerInputParameterfvNV = NULL;
+glGetCombinerInputParameterivNVPROC glGetCombinerInputParameterivNV = NULL;
+glGetCombinerOutputParameterfvNVPROC glGetCombinerOutputParameterfvNV = NULL;
+glGetCombinerOutputParameterivNVPROC glGetCombinerOutputParameterivNV = NULL;
+glGetFinalCombinerInputParameterfvNVPROC glGetFinalCombinerInputParameterfvNV = NULL;
+glGetFinalCombinerInputParameterivNVPROC glGetFinalCombinerInputParameterivNV = NULL;
+
+static GLboolean _glewInit_NV_register_combiners ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glCombinerParameterfvNV = (glCombinerParameterfvNVPROC)glewGetProcAddress("glCombinerParameterfvNV")) == NULL;
+  r = r || (glCombinerParameterfNV = (glCombinerParameterfNVPROC)glewGetProcAddress("glCombinerParameterfNV")) == NULL;
+  r = r || (glCombinerParameterivNV = (glCombinerParameterivNVPROC)glewGetProcAddress("glCombinerParameterivNV")) == NULL;
+  r = r || (glCombinerParameteriNV = (glCombinerParameteriNVPROC)glewGetProcAddress("glCombinerParameteriNV")) == NULL;
+  r = r || (glCombinerInputNV = (glCombinerInputNVPROC)glewGetProcAddress("glCombinerInputNV")) == NULL;
+  r = r || (glCombinerOutputNV = (glCombinerOutputNVPROC)glewGetProcAddress("glCombinerOutputNV")) == NULL;
+  r = r || (glFinalCombinerInputNV = (glFinalCombinerInputNVPROC)glewGetProcAddress("glFinalCombinerInputNV")) == NULL;
+  r = r || (glGetCombinerInputParameterfvNV = (glGetCombinerInputParameterfvNVPROC)glewGetProcAddress("glGetCombinerInputParameterfvNV")) == NULL;
+  r = r || (glGetCombinerInputParameterivNV = (glGetCombinerInputParameterivNVPROC)glewGetProcAddress("glGetCombinerInputParameterivNV")) == NULL;
+  r = r || (glGetCombinerOutputParameterfvNV = (glGetCombinerOutputParameterfvNVPROC)glewGetProcAddress("glGetCombinerOutputParameterfvNV")) == NULL;
+  r = r || (glGetCombinerOutputParameterivNV = (glGetCombinerOutputParameterivNVPROC)glewGetProcAddress("glGetCombinerOutputParameterivNV")) == NULL;
+  r = r || (glGetFinalCombinerInputParameterfvNV = (glGetFinalCombinerInputParameterfvNVPROC)glewGetProcAddress("glGetFinalCombinerInputParameterfvNV")) == NULL;
+  r = r || (glGetFinalCombinerInputParameterivNV = (glGetFinalCombinerInputParameterivNVPROC)glewGetProcAddress("glGetFinalCombinerInputParameterivNV")) == NULL;
+  return r;
+}
+#endif /* GL_NV_register_combiners */
+
+/* ------------------------ NV_register_combiners2 ------------------------ */
+
+#ifdef GL_NV_register_combiners2
+glCombinerStageParameterfvNVPROC glCombinerStageParameterfvNV = NULL;
+glGetCombinerStageParameterfvNVPROC glGetCombinerStageParameterfvNV = NULL;
+
+static GLboolean _glewInit_NV_register_combiners2 ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glCombinerStageParameterfvNV = (glCombinerStageParameterfvNVPROC)glewGetProcAddress("glCombinerStageParameterfvNV")) == NULL;
+  r = r || (glGetCombinerStageParameterfvNV = (glGetCombinerStageParameterfvNVPROC)glewGetProcAddress("glGetCombinerStageParameterfvNV")) == NULL;
+  return r;
+}
+#endif /* GL_NV_register_combiners2 */
+
+/* ------------------------- NV_vertex_array_range ------------------------ */
+
+#ifdef GL_NV_vertex_array_range
+glFlushVertexArrayRangeNVPROC glFlushVertexArrayRangeNV = NULL;
+glVertexArrayRangeNVPROC glVertexArrayRangeNV = NULL;
+
+static GLboolean _glewInit_NV_vertex_array_range ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glFlushVertexArrayRangeNV = (glFlushVertexArrayRangeNVPROC)glewGetProcAddress("glFlushVertexArrayRangeNV")) == NULL;
+  r = r || (glVertexArrayRangeNV = (glVertexArrayRangeNVPROC)glewGetProcAddress("glVertexArrayRangeNV")) == NULL;
+  return r;
+}
+#endif /* GL_NV_vertex_array_range */
+
+/* --------------------------- NV_vertex_program -------------------------- */
+
+#ifdef GL_NV_vertex_program
+glBindProgramNVPROC glBindProgramNV = NULL;
+glDeleteProgramsNVPROC glDeleteProgramsNV = NULL;
+glExecuteProgramNVPROC glExecuteProgramNV = NULL;
+glGenProgramsNVPROC glGenProgramsNV = NULL;
+glAreProgramsResidentNVPROC glAreProgramsResidentNV = NULL;
+glRequestResidentProgramsNVPROC glRequestResidentProgramsNV = NULL;
+glGetProgramParameterfvNVPROC glGetProgramParameterfvNV = NULL;
+glGetProgramParameterdvNVPROC glGetProgramParameterdvNV = NULL;
+glGetProgramivNVPROC glGetProgramivNV = NULL;
+glGetProgramStringNVPROC glGetProgramStringNV = NULL;
+glGetTrackMatrixivNVPROC glGetTrackMatrixivNV = NULL;
+glGetVertexAttribdvNVPROC glGetVertexAttribdvNV = NULL;
+glGetVertexAttribfvNVPROC glGetVertexAttribfvNV = NULL;
+glGetVertexAttribivNVPROC glGetVertexAttribivNV = NULL;
+glGetVertexAttribPointervNVPROC glGetVertexAttribPointervNV = NULL;
+glIsProgramNVPROC glIsProgramNV = NULL;
+glLoadProgramNVPROC glLoadProgramNV = NULL;
+glProgramParameter4fNVPROC glProgramParameter4fNV = NULL;
+glProgramParameter4dNVPROC glProgramParameter4dNV = NULL;
+glProgramParameter4dvNVPROC glProgramParameter4dvNV = NULL;
+glProgramParameter4fvNVPROC glProgramParameter4fvNV = NULL;
+glProgramParameters4dvNVPROC glProgramParameters4dvNV = NULL;
+glProgramParameters4fvNVPROC glProgramParameters4fvNV = NULL;
+glTrackMatrixNVPROC glTrackMatrixNV = NULL;
+glVertexAttribPointerNVPROC glVertexAttribPointerNV = NULL;
+glVertexAttrib1sNVPROC glVertexAttrib1sNV = NULL;
+glVertexAttrib1fNVPROC glVertexAttrib1fNV = NULL;
+glVertexAttrib1dNVPROC glVertexAttrib1dNV = NULL;
+glVertexAttrib2sNVPROC glVertexAttrib2sNV = NULL;
+glVertexAttrib2fNVPROC glVertexAttrib2fNV = NULL;
+glVertexAttrib2dNVPROC glVertexAttrib2dNV = NULL;
+glVertexAttrib3sNVPROC glVertexAttrib3sNV = NULL;
+glVertexAttrib3fNVPROC glVertexAttrib3fNV = NULL;
+glVertexAttrib3dNVPROC glVertexAttrib3dNV = NULL;
+glVertexAttrib4sNVPROC glVertexAttrib4sNV = NULL;
+glVertexAttrib4fNVPROC glVertexAttrib4fNV = NULL;
+glVertexAttrib4dNVPROC glVertexAttrib4dNV = NULL;
+glVertexAttrib4ubNVPROC glVertexAttrib4ubNV = NULL;
+glVertexAttrib1svNVPROC glVertexAttrib1svNV = NULL;
+glVertexAttrib1fvNVPROC glVertexAttrib1fvNV = NULL;
+glVertexAttrib1dvNVPROC glVertexAttrib1dvNV = NULL;
+glVertexAttrib2svNVPROC glVertexAttrib2svNV = NULL;
+glVertexAttrib2fvNVPROC glVertexAttrib2fvNV = NULL;
+glVertexAttrib2dvNVPROC glVertexAttrib2dvNV = NULL;
+glVertexAttrib3svNVPROC glVertexAttrib3svNV = NULL;
+glVertexAttrib3fvNVPROC glVertexAttrib3fvNV = NULL;
+glVertexAttrib3dvNVPROC glVertexAttrib3dvNV = NULL;
+glVertexAttrib4svNVPROC glVertexAttrib4svNV = NULL;
+glVertexAttrib4fvNVPROC glVertexAttrib4fvNV = NULL;
+glVertexAttrib4dvNVPROC glVertexAttrib4dvNV = NULL;
+glVertexAttrib4ubvNVPROC glVertexAttrib4ubvNV = NULL;
+glVertexAttribs1svNVPROC glVertexAttribs1svNV = NULL;
+glVertexAttribs1fvNVPROC glVertexAttribs1fvNV = NULL;
+glVertexAttribs1dvNVPROC glVertexAttribs1dvNV = NULL;
+glVertexAttribs2svNVPROC glVertexAttribs2svNV = NULL;
+glVertexAttribs2fvNVPROC glVertexAttribs2fvNV = NULL;
+glVertexAttribs2dvNVPROC glVertexAttribs2dvNV = NULL;
+glVertexAttribs3svNVPROC glVertexAttribs3svNV = NULL;
+glVertexAttribs3fvNVPROC glVertexAttribs3fvNV = NULL;
+glVertexAttribs3dvNVPROC glVertexAttribs3dvNV = NULL;
+glVertexAttribs4svNVPROC glVertexAttribs4svNV = NULL;
+glVertexAttribs4fvNVPROC glVertexAttribs4fvNV = NULL;
+glVertexAttribs4dvNVPROC glVertexAttribs4dvNV = NULL;
+glVertexAttribs4ubvNVPROC glVertexAttribs4ubvNV = NULL;
+
+static GLboolean _glewInit_NV_vertex_program ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glBindProgramNV = (glBindProgramNVPROC)glewGetProcAddress("glBindProgramNV")) == NULL;
+  r = r || (glDeleteProgramsNV = (glDeleteProgramsNVPROC)glewGetProcAddress("glDeleteProgramsNV")) == NULL;
+  r = r || (glExecuteProgramNV = (glExecuteProgramNVPROC)glewGetProcAddress("glExecuteProgramNV")) == NULL;
+  r = r || (glGenProgramsNV = (glGenProgramsNVPROC)glewGetProcAddress("glGenProgramsNV")) == NULL;
+  r = r || (glAreProgramsResidentNV = (glAreProgramsResidentNVPROC)glewGetProcAddress("glAreProgramsResidentNV")) == NULL;
+  r = r || (glRequestResidentProgramsNV = (glRequestResidentProgramsNVPROC)glewGetProcAddress("glRequestResidentProgramsNV")) == NULL;
+  r = r || (glGetProgramParameterfvNV = (glGetProgramParameterfvNVPROC)glewGetProcAddress("glGetProgramParameterfvNV")) == NULL;
+  r = r || (glGetProgramParameterdvNV = (glGetProgramParameterdvNVPROC)glewGetProcAddress("glGetProgramParameterdvNV")) == NULL;
+  r = r || (glGetProgramivNV = (glGetProgramivNVPROC)glewGetProcAddress("glGetProgramivNV")) == NULL;
+  r = r || (glGetProgramStringNV = (glGetProgramStringNVPROC)glewGetProcAddress("glGetProgramStringNV")) == NULL;
+  r = r || (glGetTrackMatrixivNV = (glGetTrackMatrixivNVPROC)glewGetProcAddress("glGetTrackMatrixivNV")) == NULL;
+  r = r || (glGetVertexAttribdvNV = (glGetVertexAttribdvNVPROC)glewGetProcAddress("glGetVertexAttribdvNV")) == NULL;
+  r = r || (glGetVertexAttribfvNV = (glGetVertexAttribfvNVPROC)glewGetProcAddress("glGetVertexAttribfvNV")) == NULL;
+  r = r || (glGetVertexAttribivNV = (glGetVertexAttribivNVPROC)glewGetProcAddress("glGetVertexAttribivNV")) == NULL;
+  r = r || (glGetVertexAttribPointervNV = (glGetVertexAttribPointervNVPROC)glewGetProcAddress("glGetVertexAttribPointervNV")) == NULL;
+  r = r || (glIsProgramNV = (glIsProgramNVPROC)glewGetProcAddress("glIsProgramNV")) == NULL;
+  r = r || (glLoadProgramNV = (glLoadProgramNVPROC)glewGetProcAddress("glLoadProgramNV")) == NULL;
+  r = r || (glProgramParameter4fNV = (glProgramParameter4fNVPROC)glewGetProcAddress("glProgramParameter4fNV")) == NULL;
+  r = r || (glProgramParameter4dNV = (glProgramParameter4dNVPROC)glewGetProcAddress("glProgramParameter4dNV")) == NULL;
+  r = r || (glProgramParameter4dvNV = (glProgramParameter4dvNVPROC)glewGetProcAddress("glProgramParameter4dvNV")) == NULL;
+  r = r || (glProgramParameter4fvNV = (glProgramParameter4fvNVPROC)glewGetProcAddress("glProgramParameter4fvNV")) == NULL;
+  r = r || (glProgramParameters4dvNV = (glProgramParameters4dvNVPROC)glewGetProcAddress("glProgramParameters4dvNV")) == NULL;
+  r = r || (glProgramParameters4fvNV = (glProgramParameters4fvNVPROC)glewGetProcAddress("glProgramParameters4fvNV")) == NULL;
+  r = r || (glTrackMatrixNV = (glTrackMatrixNVPROC)glewGetProcAddress("glTrackMatrixNV")) == NULL;
+  r = r || (glVertexAttribPointerNV = (glVertexAttribPointerNVPROC)glewGetProcAddress("glVertexAttribPointerNV")) == NULL;
+  r = r || (glVertexAttrib1sNV = (glVertexAttrib1sNVPROC)glewGetProcAddress("glVertexAttrib1sNV")) == NULL;
+  r = r || (glVertexAttrib1fNV = (glVertexAttrib1fNVPROC)glewGetProcAddress("glVertexAttrib1fNV")) == NULL;
+  r = r || (glVertexAttrib1dNV = (glVertexAttrib1dNVPROC)glewGetProcAddress("glVertexAttrib1dNV")) == NULL;
+  r = r || (glVertexAttrib2sNV = (glVertexAttrib2sNVPROC)glewGetProcAddress("glVertexAttrib2sNV")) == NULL;
+  r = r || (glVertexAttrib2fNV = (glVertexAttrib2fNVPROC)glewGetProcAddress("glVertexAttrib2fNV")) == NULL;
+  r = r || (glVertexAttrib2dNV = (glVertexAttrib2dNVPROC)glewGetProcAddress("glVertexAttrib2dNV")) == NULL;
+  r = r || (glVertexAttrib3sNV = (glVertexAttrib3sNVPROC)glewGetProcAddress("glVertexAttrib3sNV")) == NULL;
+  r = r || (glVertexAttrib3fNV = (glVertexAttrib3fNVPROC)glewGetProcAddress("glVertexAttrib3fNV")) == NULL;
+  r = r || (glVertexAttrib3dNV = (glVertexAttrib3dNVPROC)glewGetProcAddress("glVertexAttrib3dNV")) == NULL;
+  r = r || (glVertexAttrib4sNV = (glVertexAttrib4sNVPROC)glewGetProcAddress("glVertexAttrib4sNV")) == NULL;
+  r = r || (glVertexAttrib4fNV = (glVertexAttrib4fNVPROC)glewGetProcAddress("glVertexAttrib4fNV")) == NULL;
+  r = r || (glVertexAttrib4dNV = (glVertexAttrib4dNVPROC)glewGetProcAddress("glVertexAttrib4dNV")) == NULL;
+  r = r || (glVertexAttrib4ubNV = (glVertexAttrib4ubNVPROC)glewGetProcAddress("glVertexAttrib4ubNV")) == NULL;
+  r = r || (glVertexAttrib1svNV = (glVertexAttrib1svNVPROC)glewGetProcAddress("glVertexAttrib1svNV")) == NULL;
+  r = r || (glVertexAttrib1fvNV = (glVertexAttrib1fvNVPROC)glewGetProcAddress("glVertexAttrib1fvNV")) == NULL;
+  r = r || (glVertexAttrib1dvNV = (glVertexAttrib1dvNVPROC)glewGetProcAddress("glVertexAttrib1dvNV")) == NULL;
+  r = r || (glVertexAttrib2svNV = (glVertexAttrib2svNVPROC)glewGetProcAddress("glVertexAttrib2svNV")) == NULL;
+  r = r || (glVertexAttrib2fvNV = (glVertexAttrib2fvNVPROC)glewGetProcAddress("glVertexAttrib2fvNV")) == NULL;
+  r = r || (glVertexAttrib2dvNV = (glVertexAttrib2dvNVPROC)glewGetProcAddress("glVertexAttrib2dvNV")) == NULL;
+  r = r || (glVertexAttrib3svNV = (glVertexAttrib3svNVPROC)glewGetProcAddress("glVertexAttrib3svNV")) == NULL;
+  r = r || (glVertexAttrib3fvNV = (glVertexAttrib3fvNVPROC)glewGetProcAddress("glVertexAttrib3fvNV")) == NULL;
+  r = r || (glVertexAttrib3dvNV = (glVertexAttrib3dvNVPROC)glewGetProcAddress("glVertexAttrib3dvNV")) == NULL;
+  r = r || (glVertexAttrib4svNV = (glVertexAttrib4svNVPROC)glewGetProcAddress("glVertexAttrib4svNV")) == NULL;
+  r = r || (glVertexAttrib4fvNV = (glVertexAttrib4fvNVPROC)glewGetProcAddress("glVertexAttrib4fvNV")) == NULL;
+  r = r || (glVertexAttrib4dvNV = (glVertexAttrib4dvNVPROC)glewGetProcAddress("glVertexAttrib4dvNV")) == NULL;
+  r = r || (glVertexAttrib4ubvNV = (glVertexAttrib4ubvNVPROC)glewGetProcAddress("glVertexAttrib4ubvNV")) == NULL;
+  r = r || (glVertexAttribs1svNV = (glVertexAttribs1svNVPROC)glewGetProcAddress("glVertexAttribs1svNV")) == NULL;
+  r = r || (glVertexAttribs1fvNV = (glVertexAttribs1fvNVPROC)glewGetProcAddress("glVertexAttribs1fvNV")) == NULL;
+  r = r || (glVertexAttribs1dvNV = (glVertexAttribs1dvNVPROC)glewGetProcAddress("glVertexAttribs1dvNV")) == NULL;
+  r = r || (glVertexAttribs2svNV = (glVertexAttribs2svNVPROC)glewGetProcAddress("glVertexAttribs2svNV")) == NULL;
+  r = r || (glVertexAttribs2fvNV = (glVertexAttribs2fvNVPROC)glewGetProcAddress("glVertexAttribs2fvNV")) == NULL;
+  r = r || (glVertexAttribs2dvNV = (glVertexAttribs2dvNVPROC)glewGetProcAddress("glVertexAttribs2dvNV")) == NULL;
+  r = r || (glVertexAttribs3svNV = (glVertexAttribs3svNVPROC)glewGetProcAddress("glVertexAttribs3svNV")) == NULL;
+  r = r || (glVertexAttribs3fvNV = (glVertexAttribs3fvNVPROC)glewGetProcAddress("glVertexAttribs3fvNV")) == NULL;
+  r = r || (glVertexAttribs3dvNV = (glVertexAttribs3dvNVPROC)glewGetProcAddress("glVertexAttribs3dvNV")) == NULL;
+  r = r || (glVertexAttribs4svNV = (glVertexAttribs4svNVPROC)glewGetProcAddress("glVertexAttribs4svNV")) == NULL;
+  r = r || (glVertexAttribs4fvNV = (glVertexAttribs4fvNVPROC)glewGetProcAddress("glVertexAttribs4fvNV")) == NULL;
+  r = r || (glVertexAttribs4dvNV = (glVertexAttribs4dvNVPROC)glewGetProcAddress("glVertexAttribs4dvNV")) == NULL;
+  r = r || (glVertexAttribs4ubvNV = (glVertexAttribs4ubvNVPROC)glewGetProcAddress("glVertexAttribs4ubvNV")) == NULL;
+  return r;
+}
+#endif /* GL_NV_vertex_program */
+
+#ifdef _WIN32
+
+/* ---------------------------- ARB_buffer_region ------------------------- */
+
+#ifdef WGL_ARB_buffer_region
+wglCreateBufferRegionARBPROC wglCreateBufferRegionARB = NULL;
+wglDeleteBufferRegionARBPROC wglDeleteBufferRegionARB = NULL;
+wglSaveBufferRegionARBPROC wglSaveBufferRegionARB = NULL;
+wglRestoreBufferRegionARBPROC wglRestoreBufferRegionARB = NULL;
+
+static GLboolean _wglewInit_ARB_buffer_region ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglCreateBufferRegionARB = (wglCreateBufferRegionARBPROC)glewGetProcAddress("wglCreateBufferRegionARB")) == NULL;
+  r = r || (wglDeleteBufferRegionARB = (wglDeleteBufferRegionARBPROC)glewGetProcAddress("wglDeleteBufferRegionARB")) == NULL;
+  r = r || (wglSaveBufferRegionARB = (wglSaveBufferRegionARBPROC)glewGetProcAddress("wglSaveBufferRegionARB")) == NULL;
+  r = r || (wglRestoreBufferRegionARB = (wglRestoreBufferRegionARBPROC)glewGetProcAddress("wglRestoreBufferRegionARB")) == NULL;
+  return r;
+}
+#endif /* WGL_ARB_buffer_region */
+
+/* -------------------------- ARB_extensions_string ----------------------- */
+
+#ifdef WGL_ARB_extensions_string
+wglGetExtensionsStringARBPROC wglGetExtensionsStringARB = NULL;
+
+static GLboolean _wglewInit_ARB_extensions_string ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglGetExtensionsStringARB = (wglGetExtensionsStringARBPROC)glewGetProcAddress("wglGetExtensionsStringARB")) == NULL;
+  return r;
+}
+#endif /* WGL_ARB_extensions_string */
+
+/* -------------------------- ARB_make_current_read ----------------------- */
+
+#ifdef WGL_ARB_make_current_read
+wglMakeContextCurrentARBPROC wglMakeContextCurrentARB = NULL;
+wglGetCurrentReadDCARBPROC wglGetCurrentReadDCARB = NULL;
+
+static GLboolean _wglewInit_ARB_make_current_read ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglMakeContextCurrentARB = (wglMakeContextCurrentARBPROC)glewGetProcAddress("wglMakeContextCurrentARB")) == NULL;
+  r = r || (wglGetCurrentReadDCARB = (wglGetCurrentReadDCARBPROC)glewGetProcAddress("wglGetCurrentReadDCARB")) == NULL;
+  return r;
+}
+#endif /* WGL_ARB_make_current_read */
+
+/* ------------------------------ ARB_pbuffer ----------------------------- */
+
+#ifdef WGL_ARB_pbuffer
+wglCreatePbufferARBPROC wglCreatePbufferARB = NULL;
+wglGetPbufferDCARBPROC wglGetPbufferDCARB = NULL;
+wglReleasePbufferDCARBPROC wglReleasePbufferDCARB = NULL;
+wglDestroyPbufferARBPROC wglDestroyPbufferARB = NULL;
+wglQueryPbufferARBPROC wglQueryPbufferARB = NULL;
+
+static GLboolean _wglewInit_ARB_pbuffer ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglCreatePbufferARB = (wglCreatePbufferARBPROC)glewGetProcAddress("wglCreatePbufferARB")) == NULL;
+  r = r || (wglGetPbufferDCARB = (wglGetPbufferDCARBPROC)glewGetProcAddress("wglGetPbufferDCARB")) == NULL;
+  r = r || (wglReleasePbufferDCARB = (wglReleasePbufferDCARBPROC)glewGetProcAddress("wglReleasePbufferDCARB")) == NULL;
+  r = r || (wglDestroyPbufferARB = (wglDestroyPbufferARBPROC)glewGetProcAddress("wglDestroyPbufferARB")) == NULL;
+  r = r || (wglQueryPbufferARB = (wglQueryPbufferARBPROC)glewGetProcAddress("wglQueryPbufferARB")) == NULL;
+  return r;
+}
+#endif /* WGL_ARB_pbuffer */
+
+/* --------------------------- ARB_pixel_format --------------------------- */
+
+#ifdef WGL_ARB_pixel_format
+wglGetPixelFormatAttribivARBPROC wglGetPixelFormatAttribivARB = NULL;
+wglGetPixelFormatAttribfvARBPROC wglGetPixelFormatAttribfvARB = NULL;
+wglChoosePixelFormatARBPROC wglChoosePixelFormatARB = NULL;
+
+static GLboolean _wglewInit_ARB_pixel_format ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglGetPixelFormatAttribivARB = (wglGetPixelFormatAttribivARBPROC)glewGetProcAddress("wglGetPixelFormatAttribivARB")) == NULL;
+  r = r || (wglGetPixelFormatAttribfvARB = (wglGetPixelFormatAttribfvARBPROC)glewGetProcAddress("wglGetPixelFormatAttribfvARB")) == NULL;
+  r = r || (wglChoosePixelFormatARB = (wglChoosePixelFormatARBPROC)glewGetProcAddress("wglChoosePixelFormatARB")) == NULL;
+  return r;
+}
+#endif /* WGL_ARB_pixel_format */
+
+/* -------------------------- ARB_render_texture -------------------------- */
+
+#ifdef WGL_ARB_render_texture
+wglBindTexImageARBPROC wglBindTexImageARB = NULL;
+wglReleaseTexImageARBPROC wglReleaseTexImageARB = NULL;
+wglSetPbufferAttribARBPROC wglSetPbufferAttribARB = NULL;
+
+static GLboolean _wglewInit_ARB_render_texture ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglBindTexImageARB = (wglBindTexImageARBPROC)glewGetProcAddress("wglBindTexImageARB")) == NULL;
+  r = r || (wglReleaseTexImageARB = (wglReleaseTexImageARBPROC)glewGetProcAddress("wglReleaseTexImageARB")) == NULL;
+  r = r || (wglSetPbufferAttribARB = (wglSetPbufferAttribARBPROC)glewGetProcAddress("wglSetPbufferAttribARB")) == NULL;
+  return r;
+}
+#endif /* WGL_ARB_render_texture */
+
+/* ------------------------- EXT_display_color_table ---------------------- */
+
+#ifdef WGL_EXT_display_color_table
+
+wglCreateDisplayColorTableEXTPROC wglCreateDisplayColorTableEXT = NULL;
+wglLoadDisplayColorTableEXTPROC wglLoadDisplayColorTableEXT = NULL;
+wglBindDisplayColorTableEXTPROC wglBindDisplayColorTableEXT = NULL;
+wglDestroyDisplayColorTableEXTPROC wglDestroyDisplayColorTableEXT = NULL;
+
+static GLboolean _wglewInit_EXT_display_color_table ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglCreateDisplayColorTableEXT = (wglCreateDisplayColorTableEXTPROC)glewGetProcAddress("wglCreateDisplayColorTableEXT")) == NULL;
+  r = r || (wglLoadDisplayColorTableEXT = (wglLoadDisplayColorTableEXTPROC)glewGetProcAddress("wglLoadDisplayColorTableEXT")) == NULL;
+  r = r || (wglBindDisplayColorTableEXT = (wglBindDisplayColorTableEXTPROC)glewGetProcAddress("wglBindDisplayColorTableEXT")) == NULL;
+  r = r || (wglDestroyDisplayColorTableEXT = (wglDestroyDisplayColorTableEXTPROC)glewGetProcAddress("wglDestroyDisplayColorTableEXT")) == NULL;
+  return r;
+}
+#endif /* WGL_EXT_display_color_table */
+
+/* -------------------------- EXT_make_current_read ----------------------- */
+
+#ifdef WGL_EXT_make_current_read
+
+wglMakeContextCurrentEXTPROC wglMakeContextCurrentEXT = NULL;
+wglGetCurrentReadDCEXTPROC wglGetCurrentReadDCEXT = NULL;
+
+static GLboolean _wglewInit_EXT_make_current_read ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglMakeContextCurrentEXT = (wglMakeContextCurrentEXTPROC)glewGetProcAddress("wglMakeContextCurrentEXT")) == NULL;
+  r = r || (wglGetCurrentReadDCEXT = (wglGetCurrentReadDCEXTPROC)glewGetProcAddress("wglGetCurrentReadDCEXT")) == NULL;
+  return r;
+}
+#endif /* WGL_EXT_make_current_read */
+
+/* ------------------------- EXT_extensions_string ------------------------ */
+
+#ifdef WGL_EXT_extensions_string
+wglGetExtensionsStringEXTPROC wglGetExtensionsStringEXT = NULL;
+
+static GLboolean _wglewInit_EXT_extensions_string ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglGetExtensionsStringEXT = (wglGetExtensionsStringEXTPROC)glewGetProcAddress("wglGetExtensionsStringEXT")) == NULL;
+  return r;
+}
+#endif /* WGL_EXT_extensions_string */
+
+/* ----------------------------- EXT_pixel_format ------------------------- */
+
+#ifdef WGL_EXT_pixel_format
+
+wglGetPixelFormatAttribivEXTPROC wglGetPixelFormatAttribivEXT = NULL;
+wglGetPixelFormatAttribfvEXTPROC wglGetPixelFormatAttribfvEXT = NULL;
+wglChoosePixelFormatEXTPROC wglChoosePixelFormatEXT = NULL;
+
+static GLboolean _wglewInit_EXT_pixel_format ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglGetPixelFormatAttribivEXT = (wglGetPixelFormatAttribivEXTPROC)glewGetProcAddress("wglGetPixelFormatAttribivEXT")) == NULL;
+  r = r || (wglGetPixelFormatAttribfvEXT = (wglGetPixelFormatAttribfvEXTPROC)glewGetProcAddress("wglGetPixelFormatAttribfvEXT")) == NULL;
+  r = r || (wglChoosePixelFormatEXT = (wglChoosePixelFormatEXTPROC)glewGetProcAddress("wglChoosePixelFormatEXT")) == NULL;
+  return r;
+}
+
+#endif /* WGL_EXT_pixel_format */
+
+/* ------------------------------- EXT_pbuffer ---------------------------- */
+
+#ifdef WGL_EXT_pbuffer
+
+wglCreatePbufferEXTPROC wglCreatePbufferEXT = NULL;
+wglGetPbufferDCEXTPROC wglGetPbufferDCEXT = NULL;
+wglReleasePbufferDCEXTPROC wglReleasePbufferDCEXT = NULL;
+wglDestroyPbufferEXTPROC wglDestroyPbufferEXT = NULL;
+wglQueryPbufferEXTPROC wglQueryPbufferEXT = NULL;
+
+static GLboolean _wglewInit_EXT_pbuffer ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglCreatePbufferEXT = (wglCreatePbufferEXTPROC)glewGetProcAddress("wglCreatePbufferEXT")) == NULL;
+  r = r || (wglGetPbufferDCEXT = (wglGetPbufferDCEXTPROC)glewGetProcAddress("wglGetPbufferDCEXT")) == NULL;
+  r = r || (wglReleasePbufferDCEXT = (wglReleasePbufferDCEXTPROC)glewGetProcAddress("wglReleasePbufferDCEXT")) == NULL;
+  r = r || (wglDestroyPbufferEXT = (wglDestroyPbufferEXTPROC)glewGetProcAddress("wglDestroyPbufferEXT")) == NULL;
+  r = r || (wglQueryPbufferEXT = (wglQueryPbufferEXTPROC)glewGetProcAddress("wglQueryPbufferEXT")) == NULL;
+  return r;
+}
+
+#endif /* WGL_EXT_pbuffer */
+
+/* --------------------------- EXT_swap_control --------------------------- */
+
+#ifdef WGL_EXT_swap_control
+wglSwapIntervalEXTPROC wglSwapIntervalEXT = NULL;
+wglGetSwapIntervalEXTPROC wglGetSwapIntervalEXT = NULL;
+
+static GLboolean _wglewInit_EXT_swap_control ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglSwapIntervalEXT = (wglSwapIntervalEXTPROC)glewGetProcAddress("wglSwapIntervalEXT")) == NULL;
+  r = r || (wglGetSwapIntervalEXT = (wglGetSwapIntervalEXTPROC)glewGetProcAddress("wglGetSwapIntervalEXT")) == NULL;
+  return r;
+}
+#endif /* WGL_EXT_swap_control */
+
+/* ------------------------ I3D_digital_video_control --------------------- */
+
+#ifdef WGL_I3D_digital_video_control
+wglGetDigitalVideoParametersI3DPROC wglGetDigitalVideoParametersI3D = NULL;
+wglSetDigitalVideoParametersI3DPROC wglSetDigitalVideoParametersI3D = NULL;
+
+static GLboolean _wglewInit_I3D_digital_video_control ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglGetDigitalVideoParametersI3D = (wglGetDigitalVideoParametersI3DPROC)glewGetProcAddress("wglGetDigitalVideoParametersI3D")) == NULL;
+  r = r || (wglSetDigitalVideoParametersI3D = (wglSetDigitalVideoParametersI3DPROC)glewGetProcAddress("wglSetDigitalVideoParametersI3D")) == NULL;
+  return r;
+}
+#endif /* WGL_I3D_digital_video_control */
+
+/* -------------------------------- I3D_gamma ----------------------------- */
+
+#ifdef WGL_I3D_gamma
+wglGetGammaTableParametersI3DPROC wglGetGammaTableParametersI3D = NULL;
+wglSetGammaTableParametersI3DPROC wglSetGammaTableParametersI3D = NULL;
+wglGetGammaTableI3DPROC wglGetGammaTableI3D = NULL;
+wglSetGammaTableI3DPROC wglSetGammaTableI3D = NULL;
+
+static GLboolean _wglewInit_I3D_gamma ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglGetGammaTableParametersI3D = (wglGetGammaTableParametersI3DPROC)glewGetProcAddress("wglGetGammaTableParametersI3D")) == NULL;
+  r = r || (wglSetGammaTableParametersI3D = (wglSetGammaTableParametersI3DPROC)glewGetProcAddress("wglSetGammaTableParametersI3D")) == NULL;
+  r = r || (wglGetGammaTableI3D = (wglGetGammaTableI3DPROC)glewGetProcAddress("wglGetGammaTableI3D")) == NULL;
+  r = r || (wglSetGammaTableI3D = (wglSetGammaTableI3DPROC)glewGetProcAddress("wglSetGammaTableI3D")) == NULL;
+  return r;
+}
+#endif /* WGL_I3D_gamma */
+
+/* ------------------------------- I3D_genlock ---------------------------- */
+
+#ifdef WGL_I3D_genlock
+wglEnableGenlockI3DPROC wglEnableGenlockI3D = NULL;
+wglDisableGenlockI3DPROC wglDisableGenlockI3D = NULL;
+wglIsEnabledGenlockI3DPROC wglIsEnabledGenlockI3D = NULL;
+wglGenlockSourceI3DPROC wglGenlockSourceI3D = NULL;
+wglGetGenlockSourceI3DPROC wglGetGenlockSourceI3D = NULL;
+wglGenlockSourceEdgeI3DPROC wglGenlockSourceEdgeI3D = NULL;
+wglGetGenlockSourceEdgeI3DPROC wglGetGenlockSourceEdgeI3D = NULL;
+wglGenlockSampleRateI3DPROC wglGenlockSampleRateI3D = NULL;
+wglGetGenlockSampleRateI3DPROC wglGetGenlockSampleRateI3D = NULL;
+wglGenlockSourceDelayI3DPROC wglGenlockSourceDelayI3D = NULL;
+wglGetGenlockSourceDelayI3DPROC wglGetGenlockSourceDelayI3D = NULL;
+wglQueryGenlockMaxSourceDelayI3DPROC wglQueryGenlockMaxSourceDelayI3D = NULL;
+
+static GLboolean _wglewInit_I3D_genlock ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglEnableGenlockI3D = (wglEnableGenlockI3DPROC)glewGetProcAddress("wglEnableGenlockI3D")) == NULL;
+  r = r || (wglDisableGenlockI3D = (wglDisableGenlockI3DPROC)glewGetProcAddress("wglDisableGenlockI3D")) == NULL;
+  r = r || (wglIsEnabledGenlockI3D = (wglIsEnabledGenlockI3DPROC)glewGetProcAddress("wglIsEnabledGenlockI3D")) == NULL;
+  r = r || (wglGenlockSourceI3D = (wglGenlockSourceI3DPROC)glewGetProcAddress("wglGenlockSourceI3D")) == NULL;
+  r = r || (wglGetGenlockSourceI3D = (wglGetGenlockSourceI3DPROC)glewGetProcAddress("wglGetGenlockSourceI3D")) == NULL;
+  r = r || (wglGenlockSourceEdgeI3D = (wglGenlockSourceEdgeI3DPROC)glewGetProcAddress("wglGenlockSourceEdgeI3D")) == NULL;
+  r = r || (wglGetGenlockSourceEdgeI3D = (wglGetGenlockSourceEdgeI3DPROC)glewGetProcAddress("wglGetGenlockSourceEdgeI3D")) == NULL;
+  r = r || (wglGenlockSampleRateI3D = (wglGenlockSampleRateI3DPROC)glewGetProcAddress("wglGenlockSampleRateI3D")) == NULL;
+  r = r || (wglGetGenlockSampleRateI3D = (wglGetGenlockSampleRateI3DPROC)glewGetProcAddress("wglGetGenlockSampleRateI3D")) == NULL;
+  r = r || (wglGenlockSourceDelayI3D = (wglGenlockSourceDelayI3DPROC)glewGetProcAddress("wglGenlockSourceDelayI3D")) == NULL;
+  r = r || (wglGetGenlockSourceDelayI3D = (wglGetGenlockSourceDelayI3DPROC)glewGetProcAddress("wglGetGenlockSourceDelayI3D")) == NULL;
+  r = r || (wglQueryGenlockMaxSourceDelayI3D = (wglQueryGenlockMaxSourceDelayI3DPROC)glewGetProcAddress("wglQueryGenlockMaxSourceDelayI3D")) == NULL;
+  return r;
+}
+#endif /* WGL_I3D_genlock */
+
+/* ---------------------------- I3D_image_buffer -------------------------- */
+
+#ifdef WGL_I3D_image_buffer
+wglCreateImageBufferI3DPROC wglCreateImageBufferI3D = NULL;
+wglDestroyImageBufferI3DPROC wglDestroyImageBufferI3D = NULL;
+wglAssociateImageBufferEventsI3DPROC wglAssociateImageBufferEventsI3D = NULL; 
+wglReleaseImageBufferEventsI3DPROC wglReleaseImageBufferEventsI3D = NULL;
+
+static GLboolean _wglewInit_I3D_image_buffer ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglCreateImageBufferI3D = (wglCreateImageBufferI3DPROC)glewGetProcAddress("wglCreateImageBufferI3D")) == NULL;
+  r = r || (wglDestroyImageBufferI3D = (wglDestroyImageBufferI3DPROC)glewGetProcAddress("wglDestroyImageBufferI3D")) == NULL;
+  r = r || (wglAssociateImageBufferEventsI3D = (wglAssociateImageBufferEventsI3DPROC)glewGetProcAddress("wglAssociateImageBufferEventsI3D")) == NULL;
+  r = r || (wglReleaseImageBufferEventsI3D = (wglReleaseImageBufferEventsI3DPROC)glewGetProcAddress("wglReleaseImageBufferEventsI3D")) == NULL;
+  return r;
+}
+#endif /* WGL_I3D_image_buffer */
+
+/* --------------------------- I3D_swap_frame_lock ------------------------ */
+
+#ifdef WGL_I3D_swap_frame_lock
+wglEnableFrameLockI3DPROC wglEnableFrameLockI3D = NULL;
+wglDisableFrameLockI3DPROC wglDisableFrameLockI3D = NULL;
+wglIsEnabledFrameLockI3DPROC wglIsEnabledFrameLockI3D = NULL;
+wglQueryFrameLockMasterI3DPROC wglQueryFrameLockMasterI3D = NULL;
+
+static GLboolean _wglewInit_I3D_swap_frame_lock ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglEnableFrameLockI3D = (wglEnableFrameLockI3DPROC)glewGetProcAddress("wglEnableFrameLockI3D")) == NULL;
+  r = r || (wglDisableFrameLockI3D = (wglDisableFrameLockI3DPROC)glewGetProcAddress("wglDisableFrameLockI3D")) == NULL;
+  r = r || (wglIsEnabledFrameLockI3D = (wglIsEnabledFrameLockI3DPROC)glewGetProcAddress("wglIsEnabledFrameLockI3D")) == NULL;
+  r = r || (wglQueryFrameLockMasterI3D = (wglQueryFrameLockMasterI3DPROC)glewGetProcAddress("wglQueryFrameLockMasterI3D")) == NULL;
+  return r;
+}
+#endif /* WGL_I3D_swap_frame_lock */
+
+/* -------------------------- I3D_swap_frame_usage ------------------------ */
+
+#ifdef WGL_I3D_swap_frame_usage
+wglGetFrameUsageI3DPROC wglGetFrameUsageI3D = NULL;
+wglBeginFrameTrackingI3DPROC wglBeginFrameTrackingI3D = NULL;
+wglEndFrameTrackingI3DPROC wglEndFrameTrackingI3D = NULL;
+wglQueryFrameTrackingI3DPROC wglQueryFrameTrackingI3D = NULL;
+
+static GLboolean _wglewInit_I3D_swap_frame_usage ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglGetFrameUsageI3D = (wglGetFrameUsageI3DPROC)glewGetProcAddress("wglGetFrameUsageI3D")) == NULL;
+  r = r || (wglBeginFrameTrackingI3D = (wglBeginFrameTrackingI3DPROC)glewGetProcAddress("wglBeginFrameTrackingI3D")) == NULL;
+  r = r || (wglEndFrameTrackingI3D = (wglEndFrameTrackingI3DPROC)glewGetProcAddress("wglEndFrameTrackingI3D")) == NULL;
+  r = r || (wglQueryFrameTrackingI3D = (wglQueryFrameTrackingI3DPROC)glewGetProcAddress("wglQueryFrameTrackingI3D")) == NULL;
+  return r;
+}
+#endif /* WGL_I3D_swap_frame_usage */
+
+/* ---------------------------- OML_sync_control -------------------------- */
+
+#ifdef WGL_OML_sync_control
+wglGetSyncValuesOMLPROC wglGetSyncValuesOML = NULL;
+wglGetMscRateOMLPROC wglGetMscRateOML = NULL;
+wglSwapBuffersMscOMLPROC wglSwapBuffersMscOML = NULL;
+wglSwapLayerBuffersMscOMLPROC wglSwapLayerBuffersMscOML = NULL;
+wglWaitForMscOMLPROC wglWaitForMscOML = NULL;
+wglWaitForSbcOMLPROC wglWaitForSbcOML = NULL;
+
+static GLboolean _wglewInit_OML_sync_control ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglGetSyncValuesOML = (wglGetSyncValuesOMLPROC)glewGetProcAddress("wglGetSyncValuesOML")) == NULL;
+  r = r || (wglGetMscRateOML = (wglGetMscRateOMLPROC)glewGetProcAddress("wglGetMscRateOML")) == NULL;
+  r = r || (wglSwapBuffersMscOML = (wglSwapBuffersMscOMLPROC)glewGetProcAddress("wglSwapBuffersMscOML")) == NULL;
+  r = r || (wglSwapLayerBuffersMscOML = (wglSwapLayerBuffersMscOMLPROC)glewGetProcAddress("wglSwapLayerBuffersMscOML")) == NULL;
+  r = r || (wglWaitForMscOML = (wglWaitForMscOMLPROC)glewGetProcAddress("wglWaitForMscOML")) == NULL;
+  r = r || (wglWaitForSbcOML = (wglWaitForSbcOMLPROC)glewGetProcAddress("wglWaitForSbcOML")) == NULL;
+  return r;
+}
+#endif /* WGL_OML_sync_control */
+
+/* ------------------------- NV_vertex_array_range ------------------------ */
+
+#ifdef WGL_NV_vertex_array_range
+wglAllocateMemoryNVPROC wglAllocateMemoryNV = NULL;
+wglFreeMemoryNVPROC wglFreeMemoryNV = NULL;
+
+static GLboolean _wglewInit_NV_vertex_array_range ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (wglAllocateMemoryNV = (wglAllocateMemoryNVPROC)glewGetProcAddress("wglAllocateMemoryNV")) == NULL;
+  r = r || (wglFreeMemoryNV = (wglFreeMemoryNVPROC)glewGetProcAddress("wglFreeMemoryNV")) == NULL;
+  return r;
+}
+#endif /* WGL_NV_vertex_array_range */
+
+#else /* _UNIX */
+
+/* -------------------------------- GLX 1.0 ------------------------------- */
+
+#ifdef GLX_VERSION_1_0
+#ifdef GLEW_PROTOTYPES
+glXQueryExtensionPROC glXQueryExtension = NULL;
+glXQueryVersionPROC glXQueryVersion = NULL;
+glXGetConfigPROC glXGetConfig = NULL;
+glXChooseVisualPROC glXChooseVisual = NULL;
+glXCreateGLXPixmapPROC glXCreateGLXPixmap = NULL;
+glXDestroyGLXPixmapPROC glXDestroyGLXPixmap = NULL;
+glXCreateContextPROC glXCreateContext = NULL;
+glXDestroyContextPROC glXDestroyContext = NULL;
+glXIsDirectPROC glXIsDirect = NULL;
+glXCopyContextPROC glXCopyContext = NULL;
+glXMakeCurrentPROC glXMakeCurrent = NULL;
+glXGetCurrentContextPROC glXGetCurrentContext = NULL;
+glXGetCurrentDrawablePROC glXGetCurrentDrawable = NULL;
+glXWaitGLPROC glXWaitGL = NULL;
+glXWaitXPROC glXWaitX = NULL;
+glXSwapBuffersPROC glXSwapBuffers = NULL;
+glXUseXFontPROC glXUseXFont = NULL;
+#endif
+
+static GLboolean _glxewInit_10 ()
+{
+  GLboolean r = GL_FALSE;
+#ifdef GLEW_PROTOTYPES
+  r = r || (glXQueryExtension = (glXQueryExtensionPROC)glewGetProcAddress("glXQueryExtension")) == NULL;
+  r = r || (glXQueryVersion = (glXQueryVersionPROC)glewGetProcAddress("glXQueryVersion")) == NULL;
+  r = r || (glXGetConfig = (glXGetConfigPROC)glewGetProcAddress("glXGetConfig")) == NULL;
+  r = r || (glXChooseVisual = (glXChooseVisualPROC)glewGetProcAddress("glXChooseVisual")) == NULL;
+  r = r || (glXCreateGLXPixmap = (glXCreateGLXPixmapPROC)glewGetProcAddress("glXCreateGLXPixmap")) == NULL;
+  r = r || (glXDestroyGLXPixmap = (glXDestroyGLXPixmapPROC)glewGetProcAddress("glXDestroyGLXPixmap")) == NULL;
+  r = r || (glXCreateContext = (glXCreateContextPROC)glewGetProcAddress("glXCreateContext")) == NULL;
+  r = r || (glXDestroyContext = (glXDestroyContextPROC)glewGetProcAddress("glXDestroyContext")) == NULL;
+  r = r || (glXIsDirect = (glXIsDirectPROC)glewGetProcAddress("glXIsDirect")) == NULL;
+  r = r || (glXCopyContext = (glXCopyContextPROC)glewGetProcAddress("glXCopyContext")) == NULL;
+  r = r || (glXMakeCurrent = (glXMakeCurrentPROC)glewGetProcAddress("glXMakeCurrent")) == NULL;
+  r = r || (glXGetCurrentContext = (glXGetCurrentContextPROC)glewGetProcAddress("glXGetCurrentContext")) == NULL;
+  r = r || (glXGetCurrentDrawable = (glXGetCurrentDrawablePROC)glewGetProcAddress("glXGetCurrentDrawable")) == NULL;
+  r = r || (glXWaitGL = (glXWaitGLPROC)glewGetProcAddress("glXWaitGL")) == NULL;
+  r = r || (glXWaitX = (glXWaitXPROC)glewGetProcAddress("glXWaitX")) == NULL;
+  r = r || (glXSwapBuffers = (glXSwapBuffersPROC)glewGetProcAddress("glXSwapBuffers")) == NULL;
+  r = r || (glXUseXFont = (glXUseXFontPROC)glewGetProcAddress("glXUseXFont")) == NULL;
+#endif
+  return r;
+}
+#endif /* GLX_VERSION_1_0 */
+
+/* -------------------------------- GLX 1.1 ------------------------------- */
+
+#ifdef GLX_VERSION_1_1
+#ifdef GLEW_PROTOTYPES
+glXQueryExtensionsStringPROC glXQueryExtensionsString = NULL;
+glXGetClientStringPROC glXGetClientString = NULL;
+glXQueryServerStringPROC glXQueryServerString = NULL;
+#endif
+
+static GLboolean _glxewInit_11 ()
+{
+  GLboolean r = GL_FALSE;
+#ifdef GLEW_PROTOTYPES
+  r = r || (glXQueryExtensionsString = (glXQueryExtensionsStringPROC)glewGetProcAddress("glXQueryExtensionsString")) == NULL;
+  r = r || (glXGetClientString = (glXGetClientStringPROC)glewGetProcAddress("glXGetClientString")) == NULL;
+  r = r || (glXQueryServerString = (glXQueryServerStringPROC)glewGetProcAddress("glXQueryServerString")) == NULL;
+#endif
+  return r;
+}
+#endif /* GLX_VERSION_1_1 */
+
+/* -------------------------------- GLX 1.2 ------------------------------- */
+
+#ifdef GLX_VERSION_1_2
+glXGetCurrentDisplayPROC glXGetCurrentDisplay = NULL;
+
+static GLboolean _glxewInit_12 ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glXGetCurrentDisplay = (glXGetCurrentDisplayPROC)glewGetProcAddress("glXGetCurrentDisplay")) == NULL;
+  return r;
+}
+#endif /* GLX_VERSION_1_2 */
+
+/* -------------------------------- GLX 1.3 ------------------------------- */
+
+#ifdef GLX_VERSION_1_3
+glXChooseFBConfigPROC glXChooseFBConfig = NULL;
+glXGetFBConfigsPROC glXGetFBConfigs = NULL;
+glXGetVisualFromFBConfigPROC glXGetVisualFromFBConfig = NULL;
+glXGetFBConfigAttribPROC glXGetFBConfigAttrib = NULL;
+glXCreateWindowPROC glXCreateWindow = NULL;
+glXDestroyWindowPROC glXDestroyWindow = NULL;
+glXCreatePixmapPROC glXCreatePixmap = NULL;
+glXDestroyPixmapPROC glXDestroyPixmap = NULL;
+glXCreatePbufferPROC glXCreatePbuffer = NULL;
+glXDestroyPbufferPROC glXDestroyPbuffer = NULL;
+glXQueryDrawablePROC glXQueryDrawable = NULL;
+glXCreateNewContextPROC glXCreateNewContext = NULL;
+glXMakeContextCurrentPROC glXMakeContextCurrent = NULL;
+glXGetCurrentReadDrawablePROC glXGetCurrentReadDrawable = NULL;
+glXQueryContextPROC glXQueryContext = NULL;
+glXSelectEventPROC glXSelectEvent = NULL;
+glXGetSelectedEventPROC glXGetSelectedEvent = NULL;
+
+static GLboolean _glxewInit_13 ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glXChooseFBConfig = (glXChooseFBConfigPROC)glewGetProcAddress("glXChooseFBConfig")) == NULL;
+  r = r || (glXGetFBConfigs = (glXGetFBConfigsPROC)glewGetProcAddress("glXGetFBConfigs")) == NULL;
+  r = r || (glXGetVisualFromFBConfig = (glXGetVisualFromFBConfigPROC)glewGetProcAddress("glXGetVisualFromFBConfig")) == NULL;
+  r = r || (glXGetFBConfigAttrib = (glXGetFBConfigAttribPROC)glewGetProcAddress("glXGetFBConfigAttrib")) == NULL;
+  r = r || (glXCreateWindow = (glXCreateWindowPROC)glewGetProcAddress("glXCreateWindow")) == NULL;
+  r = r || (glXDestroyWindow = (glXDestroyWindowPROC)glewGetProcAddress("glXDestroyWindow")) == NULL;
+  r = r || (glXCreatePixmap = (glXCreatePixmapPROC)glewGetProcAddress("glXCreatePixmap")) == NULL;
+  r = r || (glXDestroyPixmap = (glXDestroyPixmapPROC)glewGetProcAddress("glXDestroyPixmap")) == NULL;
+  r = r || (glXCreatePbuffer = (glXCreatePbufferPROC)glewGetProcAddress("glXCreatePbuffer")) == NULL;
+  r = r || (glXDestroyPbuffer = (glXDestroyPbufferPROC)glewGetProcAddress("glXDestroyPbuffer")) == NULL;
+  r = r || (glXQueryDrawable = (glXQueryDrawablePROC)glewGetProcAddress("glXQueryDrawable")) == NULL;
+  r = r || (glXCreateNewContext = (glXCreateNewContextPROC)glewGetProcAddress("glXCreateNewContext")) == NULL;
+  r = r || (glXMakeContextCurrent = (glXMakeContextCurrentPROC)glewGetProcAddress("glXMakeContextCurrent")) == NULL;
+  r = r || (glXGetCurrentReadDrawable = (glXGetCurrentReadDrawablePROC)glewGetProcAddress("glXGetCurrentReadDrawable")) == NULL;
+  r = r || (glXQueryContext = (glXQueryContextPROC)glewGetProcAddress("glXQueryContext")) == NULL;
+  r = r || (glXSelectEvent = (glXSelectEventPROC)glewGetProcAddress("glXSelectEvent")) == NULL;
+  r = r || (glXGetSelectedEvent = (glXGetSelectedEventPROC)glewGetProcAddress("glXGetSelectedEvent")) == NULL;
+  return r;
+}
+#endif /* GLX_VERSION_1_3 */
+
+/* --------------------------- EXT_import_context -------------------------- */
+
+#ifdef GLX_EXT_import_context
+glXGetCurrentDisplayEXTPROC glXGetCurrentDisplayEXT = NULL;
+glXQueryContextInfoEXTPROC glXQueryContextInfoEXT = NULL;
+glXGetContextIDEXTPROC glXGetContextIDEXT = NULL;
+glXImportContextEXTPROC glXImportContextEXT = NULL;
+glXFreeContextEXTPROC glXFreeContextEXT = NULL;
+
+static GLboolean _glxewInit_EXT_import_context ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glXGetCurrentDisplayEXT = (glXGetCurrentDisplayEXTPROC)glewGetProcAddress("glXGetCurrentDisplayEXT")) == NULL;
+  r = r || (glXQueryContextInfoEXT = (glXQueryContextInfoEXTPROC)glewGetProcAddress("glXQueryContextInfoEXT")) == NULL;
+  r = r || (glXGetContextIDEXT = (glXGetContextIDEXTPROC)glewGetProcAddress("glXGetContextIDEXT")) == NULL;
+  r = r || (glXImportContextEXT = (glXImportContextEXTPROC)glewGetProcAddress("glXImportContextEXT")) == NULL;
+  r = r || (glXFreeContextEXT = (glXFreeContextEXTPROC)glewGetProcAddress("glXFreeContextEXT")) == NULL;
+  return r;
+}
+#endif /* GLX_EXT_import_context */
+
+/* --------------------------- MESA_copy_sub_buffer ----------------------- */
+
+#ifdef GLX_MESA_copy_sub_buffer
+glXCopySubBufferMESAPROC glXCopySubBufferMESA = NULL;
+
+static GLboolean _glxewInit_MESA_copy_sub_buffer ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glXCopySubBufferMESA = (glXCopySubBufferMESAPROC)glewGetProcAddress("glXCopySubBufferMESA")) == NULL;
+  return r;
+}
+#endif /* GLX_MESA_copy_sub_buffer */
+
+/* -------------------------- MESA_pixmap_colormap ------------------------ */
+
+#ifdef GLX_MESA_pixmap_colormap
+glXCreateGLXPixmapMESAPROC glXCreateGLXPixmapMESA = NULL;
+
+static GLboolean _glxewInit_MESA_pixmap_colormap ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glXCreateGLXPixmapMESA = (glXCreateGLXPixmapMESAPROC)glewGetProcAddress("glXCreateGLXPixmapMESA")) == NULL;
+  return r;
+}
+#endif /* GLX_MESA_pixmap_colormap */
+
+/* -------------------------- MESA_release_buffers ------------------------ */
+
+#ifdef GLX_MESA_release_buffers
+glXReleaseBuffersMESAPROC glXReleaseBuffersMESA = NULL;
+
+static GLboolean _glxewInit_MESA_release_buffers ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glXReleaseBuffersMESA = (glXReleaseBuffersMESAPROC)glewGetProcAddress("glXReleaseBuffersMESA")) == NULL;
+  return r;
+}
+#endif /* GLX_MESA_release_buffers */
+
+/* --------------------------- MESA_set_3dfx_mode ------------------------- */
+
+#ifdef GLX_MESA_set_3dfx_mode
+glXSet3DfxModeMESAPROC glXSet3DfxModeMESA = NULL;
+
+static GLboolean _glxewInit_MESA_set_3dfx_mode ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glXSet3DfxModeMESA = (glXSet3DfxModeMESAPROC)glewGetProcAddress("glXSet3DfxModeMESA")) == NULL;
+  return r;
+}
+#endif /* GLX_MESA_set_3dfx_mode */
+
+/* ------------------------- NV_vertex_array_range ------------------------ */
+
+#ifdef GLX_NV_vertex_array_range
+glXAllocateMemoryNVPROC glXAllocateMemoryNV = NULL;
+glXFreeMemoryNVPROC glXFreeMemoryNV = NULL;
+
+static GLboolean _glxewInit_NV_vertex_array_range ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glXAllocateMemoryNV = (glXAllocateMemoryNVPROC)glewGetProcAddress("glXAllocateMemoryNV")) == NULL;
+  r = r || (glXFreeMemoryNV = (glXFreeMemoryNVPROC)glewGetProcAddress("glXFreeMemoryNV")) == NULL;
+  return r;
+}
+#endif /* GLX_NV_vertex_array_range */
+
+/* ---------------------------- OML_sync_control -------------------------- */
+
+#ifdef GLX_OML_sync_control
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+glXGetSyncValuesOMLPROC glXGetSyncValuesOML = NULL;
+glXGetMscRateOMLPROC glXGetMscRateOML = NULL;
+glXSwapBuffersMscOMLPROC glXSwapBuffersMscOML = NULL;
+glXWaitForMscOMLPROC glXWaitForMscOML = NULL;
+glXWaitForSbcOMLPROC glXWaitForSbcOML = NULL;
+
+static GLboolean _glxewInit_OML_sync_control ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glXGetSyncValuesOML = (glXGetSyncValuesOMLPROC)glewGetProcAddress("glXGetSyncValuesOML")) == NULL;
+  r = r || (glXGetMscRateOML = (glXGetMscRateOMLPROC)glewGetProcAddress("glXGetMscRateOML")) == NULL;
+  r = r || (glXSwapBuffersMscOML = (glXSwapBuffersMscOMLPROC)glewGetProcAddress("glXSwapBuffersMscOML")) == NULL;
+  r = r || (glXWaitForMscOML = (glXWaitForMscOMLPROC)glewGetProcAddress("glXWaitForMscOML")) == NULL;
+  r = r || (glXWaitForSbcOML = (glXWaitForSbcOMLPROC)glewGetProcAddress("glXWaitForSbcOML")) == NULL;
+  return r;
+}
+#endif /* __STDC_VERSION__ */
+#endif /* GLX_OML_sync_control */
+
+/* ------------------------------- SGI_cushion ---------------------------- */
+
+#ifdef GLX_SGI_cushion
+glXCushionSGIPROC glXCushionSGI = NULL;
+
+static GLboolean _glxewInit_SGI_cushion ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glXCushionSGI = (glXCushionSGIPROC)glewGetProcAddress("glXCushionSGI")) == NULL;
+  return r;
+}
+#endif /* GLX_SGI_cushion */
+
+/* -------------------------- SGI_make_current_read ----------------------- */
+
+#ifdef GLX_SGI_make_current_read
+glXMakeCurrentReadSGIPROC glXMakeCurrentReadSGI = NULL;
+glXGetCurrentReadDrawableSGIPROC glXGetCurrentReadDrawableSGI = NULL;
+
+static GLboolean _glxewInit_SGI_make_current_read ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glXMakeCurrentReadSGI = (glXMakeCurrentReadSGIPROC)glewGetProcAddress("glXMakeCurrentReadSGI")) == NULL;
+  r = r || (glXGetCurrentReadDrawableSGI = (glXGetCurrentReadDrawableSGIPROC)glewGetProcAddress("glXGetCurrentReadDrawableSGI")) == NULL;
+  return r;
+}
+#endif /* GLX_SGI_make_current_read */
+
+/* ---------------------------- SGI_swap_control -------------------------- */
+
+#ifdef GLX_SGI_swap_control
+glXSwapIntervalSGIPROC glXSwapIntervalSGI = NULL;
+
+static GLboolean _glxewInit_SGI_swap_control ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glXSwapIntervalSGI = (glXSwapIntervalSGIPROC)glewGetProcAddress("glXSwapIntervalSGI")) == NULL;
+  return r;
+}
+#endif /* GLX_SGI_swap_control */
+
+/* ----------------------------- SGI_video_sync --------------------------- */
+
+#ifdef GLX_SGI_video_sync
+glXGetVideoSyncSGIPROC glXGetVideoSyncSGI = NULL;
+glXWaitVideoSyncSGIPROC glXWaitVideoSyncSGI = NULL;
+glXGetRefreshRateSGIPROC glXGetRefreshRateSGI = NULL;
+
+static GLboolean _glxewInit_SGI_video_sync ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glXGetVideoSyncSGI = (glXGetVideoSyncSGIPROC)glewGetProcAddress("glXGetVideoSyncSGI")) == NULL;
+  r = r || (glXWaitVideoSyncSGI = (glXWaitVideoSyncSGIPROC)glewGetProcAddress("glXWaitVideoSyncSGI")) == NULL;
+  r = r || (glXGetRefreshRateSGI = (glXGetRefreshRateSGIPROC)glewGetProcAddress("glXGetRefreshRateSGI")) == NULL;
+  return r;
+}
+#endif /* GLX_SGI_video_sync */
+
+/* ------------------------------ SGIX_fbconfig --------------------------- */
+
+#ifdef GLX_SGIX_fbconfig
+glXGetFBConfigAttribSGIXPROC glXGetFBConfigAttribSGIX = NULL;
+glXChooseFBConfigSGIXPROC glXChooseFBConfigSGIX = NULL;
+glXCreateGLXPixmapWithConfigSGIXPROC glXCreateGLXPixmapWithConfigSGIX = NULL;
+glXCreateContextWithConfigSGIXPROC glXCreateContextWithConfigSGIX = NULL;
+glXGetVisualFromFBConfigSGIXPROC glXGetVisualFromFBConfigSGIX = NULL;
+glXGetFBConfigFromVisualSGIXPROC glXGetFBConfigFromVisualSGIX = NULL;
+
+static GLboolean _glxewInit_SGIX_fbconfig ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glXGetFBConfigAttribSGIX = (glXGetFBConfigAttribSGIXPROC)glewGetProcAddress("glXGetFBConfigAttribSGIX")) == NULL;
+  r = r || (glXChooseFBConfigSGIX = (glXChooseFBConfigSGIXPROC)glewGetProcAddress("glXChooseFBConfigSGIX")) == NULL;
+  r = r || (glXCreateGLXPixmapWithConfigSGIX = (glXCreateGLXPixmapWithConfigSGIXPROC)glewGetProcAddress("glXCreateGLXPixmapWithConfigSGIX")) == NULL;
+  r = r || (glXCreateContextWithConfigSGIX = (glXCreateContextWithConfigSGIXPROC)glewGetProcAddress("glXCreateContextWithConfigSGIX")) == NULL;
+  r = r || (glXGetVisualFromFBConfigSGIX = (glXGetVisualFromFBConfigSGIXPROC)glewGetProcAddress("glXGetVisualFromFBConfigSGIX")) == NULL;
+  r = r || (glXGetFBConfigFromVisualSGIX = (glXGetFBConfigFromVisualSGIXPROC)glewGetProcAddress("glXGetFBConfigFromVisualSGIX")) == NULL;
+  return r;
+}
+#endif /* GLX_SGIX_fbconfig */
+
+/* ------------------------------- SGIX_pbuffer --------------------------- */
+
+#ifdef GLX_SGIX_pbuffer
+glXCreateGLXPbufferSGIXPROC glXCreateGLXPbufferSGIX = NULL;
+glXDestroyGLXPbufferSGIXPROC glXDestroyGLXPbufferSGIX = NULL;
+glXQueryGLXPbufferSGIXPROC glXQueryGLXPbufferSGIX = NULL;
+glXSelectEventSGIXPROC glXSelectEventSGIX = NULL;
+glXGetSelectedEventSGIXPROC glXGetSelectedEventSGIX = NULL;
+
+static GLboolean _glxewInit_SGIX_pbuffer ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glXCreateGLXPbufferSGIX = (glXCreateGLXPbufferSGIXPROC)glewGetProcAddress("glXCreateGLXPbufferSGIX")) == NULL;
+  r = r || (glXDestroyGLXPbufferSGIX = (glXDestroyGLXPbufferSGIXPROC)glewGetProcAddress("glXDestroyGLXPbufferSGIX")) == NULL;
+  r = r || (glXQueryGLXPbufferSGIX = (glXQueryGLXPbufferSGIXPROC)glewGetProcAddress("glXQueryGLXPbufferSGIX")) == NULL;
+  r = r || (glXSelectEventSGIX = (glXSelectEventSGIXPROC)glewGetProcAddress("glXSelectEventSGIX")) == NULL;
+  r = r || (glXGetSelectedEventSGIX = (glXGetSelectedEventSGIXPROC)glewGetProcAddress("glXGetSelectedEventSGIX")) == NULL;
+  return r;
+}
+#endif /* GLX_SGIX_pbuffer */
+
+/* ---------------------------- SGIX_swap_barrier ------------------------- */
+
+#ifdef GLX_SGIX_swap_barrier
+glXBindSwapBarrierSGIXPROC glXBindSwapBarrierSGIX = NULL;
+glXQueryMaxSwapBarriersSGIXPROC glXQueryMaxSwapBarriersSGIX = NULL;
+
+static GLboolean _glxewInit_SGIX_swap_barrier ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glXBindSwapBarrierSGIX = (glXBindSwapBarrierSGIXPROC)glewGetProcAddress("glXBindSwapBarrierSGIX")) == NULL;
+  r = r || (glXQueryMaxSwapBarriersSGIX = (glXQueryMaxSwapBarriersSGIXPROC)glewGetProcAddress("glXQueryMaxSwapBarriersSGIX")) == NULL;
+  return r;
+}
+#endif /* GLX_SGIX_swap_barrier */
+
+/* ----------------------------- SGIX_swap_group -------------------------- */
+
+#ifdef GLX_SGIX_swap_group
+glXJoinSwapGroupSGIXPROC glXJoinSwapGroupSGIX = NULL;
+
+static GLboolean _glxewInit_SGIX_swap_group ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glXJoinSwapGroupSGIX = (glXJoinSwapGroupSGIXPROC)glewGetProcAddress("glXJoinSwapGroupSGIX")) == NULL;
+  return r;
+}
+#endif /* GLX_SGIX_swap_group */
+
+/* ------------------------ SUN_get_transparent_index --------------------- */
+
+#ifdef GLX_SUN_get_transparent_index
+glXGetTransparentIndexSUNPROC glXGetTransparentIndexSUN = NULL;
+
+static GLboolean _glxewInit_SUN_get_transparent_index ()
+{
+  GLboolean r = GL_FALSE;
+  r = r || (glXGetTransparentIndexSUN = (glXGetTransparentIndexSUNPROC)glewGetProcAddress("glXGetTransparentIndexSUN")) == NULL;
+  return r;
+}
+#endif /* GLX_SUN_get_transparent_index */
+
+#endif /* _WIN32 */
+
+/* ------------------------------------------------------------------------ */
+
+/*
+ * GLEW, just like OpenGL or GLU, does not rely on the standard C library.
+ * These functions only implement the functionality required in this file.
+ */
+
+int _glewStrLen (const char *s)
+{
+  int i=0;
+  while (s+i != NULL && s[i] != '\0') i++;
+  return i;
+}
+
+int _glewStrCLen (const char *s, char c)
+{
+  int i=0;
+  while (s+i != NULL && s[i] != '\0' && s[i] != c) i++;
+  return i;
+}
+
+int _glewStrSame (const char *a, const char *b, int n)
+{
+  int i=0;
+  while (i < n && a+i != NULL && b+i != NULL && a[i] == b[i]) i++;
+  return i == n;
+}
+
+void* _glewMemSet (void *s, char c, int n)
+{
+  int i;
+  char* d=(char*)s;
+  for (i=0; i= 199901L)
+  glxew.OML_sync_control = _glxewGetExt("GLX_OML_sync_control");
+  if (glewExperimental || glxew.OML_sync_control) glxew.OML_sync_control = !_glxewInit_OML_sync_control();
+#endif /* __STDC_VERSION__ */
+#endif
+
+#ifdef GLX_SGI_cushion
+  glxew.SGI_cushion = _glxewGetExt("GLX_SGI_cushion");
+  if (glewExperimental || glxew.SGI_cushion) glxew.SGI_cushion = !_glxewInit_SGI_cushion();
+#endif
+#ifdef GLX_SGI_make_current_read
+  glxew.SGI_make_current_read = _glxewGetExt("GLX_SGI_make_current_read");
+  if (glewExperimental || glxew.SGI_make_current_read) glxew.SGI_make_current_read = !_glxewInit_SGI_make_current_read();
+#endif
+#ifdef GLX_SGI_swap_control
+  glxew.SGI_swap_control = _glxewGetExt("GLX_SGI_swap_control");
+  if (glewExperimental || glxew.SGI_swap_control) glxew.SGI_swap_control = !_glxewInit_SGI_swap_control();
+#endif
+#ifdef GLX_SGI_video_sync
+  glxew.SGI_video_sync = _glxewGetExt("GLX_SGI_video_sync");
+  if (glewExperimental || glxew.SGI_video_sync) glxew.SGI_video_sync = !_glxewInit_SGI_video_sync();
+#endif
+
+#ifdef GLX_SGIS_blended_overlay
+  glxew.SGIS_blended_overlay = _glxewGetExt("GLX_SGIS_blended_overlay");
+#endif
+#ifdef GLX_SGIS_multisample
+  glxew.SGIS_multisample = _glxewGetExt("GLX_SGIS_multisample");
+#endif
+#ifdef GLX_SGIS_shared_multisample
+  glxew.SGIS_shared_multisample = _glxewGetExt("GLX_SGIS_shared_multisample");
+#endif
+
+#ifdef GLX_SGIX_fbconfig
+  glxew.SGIX_fbconfig = _glxewGetExt("GLX_SGIX_fbconfig");
+  if (glewExperimental || glxew.SGIX_fbconfig) glxew.SGIX_fbconfig = !_glxewInit_SGIX_fbconfig();
+#endif
+#ifdef GLX_SGIX_pbuffer
+  glxew.SGIX_pbuffer = _glxewGetExt("GLX_SGIX_pbuffer");
+  if (glewExperimental || glxew.SGIX_pbuffer) glxew.SGIX_pbuffer = !_glxewInit_SGIX_pbuffer();
+#endif
+#ifdef GLX_SGIX_swap_barrier
+  glxew.SGIX_swap_barrier = _glxewGetExt("GLX_SGIX_swap_barrier");
+  if (glewExperimental || glxew.SGIX_swap_barrier) glxew.SGIX_swap_barrier = !_glxewInit_SGIX_swap_barrier();
+#endif
+#ifdef GLX_SGIX_swap_group
+  glxew.SGIX_swap_group = _glxewGetExt("GLX_SGIX_swap_group");
+  if (glewExperimental || glxew.SGIX_swap_group) glxew.SGIX_swap_group = !_glxewInit_SGIX_swap_group();
+#endif
+#ifdef GLX_SGIX_visual_select_group
+  glxew.SGIX_visual_select_group = _glxewGetExt("GLX_SGIX_visual_select_group");
+#endif
+
+#ifdef GLX_SUN_get_transparent_index
+  glxew.SUN_get_transparent_index = _glxewGetExt("GLX_SUN_get_transparent_index");
+  if (glewExperimental || glxew.SUN_get_transparent_index) glxew.SUN_get_transparent_index = !_glxewInit_SUN_get_transparent_index();
+#endif
+  return GLEW_OK;
+}
+
+#endif /* _WIN32 */
+
+/* ------------------------------------------------------------------------ */
+
+static char _glewErrorString[6][40] =
+{
+  "no error",
+  "missing GL version",
+  "missing {ARB,EXT}_extensions_string",
+  "GL 1.1 and up are not supported",
+  "GLX 1.2 and up are not supported",
+  "unknown error"
+};
+
+const char* glewGetErrorString (GLint error)
+{
+  if (error > 5) error = 5;
+  return _glewErrorString[error];
+}
+
+/* ------------------------------------------------------------------------ */
+
+struct GLEW glew;
+#ifdef _WIN32
+struct WGLEW wglew;
+#else /* _UNIX */
+struct GLXEW glxew;
+#endif /* _WIN32 */
+GLboolean glewExperimental = GL_FALSE;
+
+GLint glewInit ()
+{
+  GLint r;
+  if (r = _glewInit()) return r;
+#ifdef _WIN32
+  return _wglewInit();
+#else /* _UNIX */
+  return _glxewInit();
+#endif /* _WIN32 */
+}
diff --git a/src/glewinfo.c b/src/glewinfo.c
new file mode 100644
index 0000000..cca2432
--- /dev/null
+++ b/src/glewinfo.c
@@ -0,0 +1,2238 @@
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: This software was created using the
+** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+** not been independently verified as being compliant with the OpenGL(R)
+** version 1.2.1 Specification.
+*/
+
+/*
+** The contents of this file are subject to the GLX Public License Version 1.0
+** (the "License"). You may not use this file except in compliance with the
+** License. You may obtain a copy of the License at Silicon Graphics, Inc.,
+** attn: Legal Services, 2011 N. Shoreline Blvd., Mountain View, CA 94043
+** or at http://www.sgi.com/software/opensource/glx/license.html.
+**
+** Software distributed under the License is distributed on an "AS IS"
+** basis. ALL WARRANTIES ARE DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY
+** IMPLIED WARRANTIES OF MERCHANTABILITY, OF FITNESS FOR A PARTICULAR
+** PURPOSE OR OF NON- INFRINGEMENT. See the License for the specific
+** language governing rights and limitations under the License.
+**
+** The Original Software is GLX version 1.2 source code, released February,
+** 1999. The developer of the Original Software is Silicon Graphics, Inc.
+** Those portions of the Subject Software created by Silicon Graphics, Inc.
+** are Copyright (c) 1991-9 Silicon Graphics, Inc. All Rights Reserved.
+*/
+
+/*
+** Copyright (C) 2002, Lev Povalahev
+** All rights reserved.
+** 
+** Redistribution and use in source and binary forms, with or without modification, 
+** are permitted provided that the following conditions are met:
+** 
+** * Redistributions of source code must retain the above copyright notice, 
+**   this list of conditions and the following disclaimer.
+** * Redistributions in binary form must reproduce the above copyright notice, 
+**   this list of conditions and the following disclaimer in the documentation 
+**   and/or other materials provided with the distribution.
+** * The name of the author may be used to endorse or promote products 
+**   derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
+** IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+** INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+** BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 
+** OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+** WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
+** THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+** The OpenGL Extension Wrangler Library
+** Copyright (C) 2002 Milan Ikits
+**
+** This library is free software; you can redistribute it and/or
+** modify it under the terms of the GNU Lesser General Public
+** License as published by the Free Software Foundation; either
+** version 2.1 of the License, or (at your option) any later version.
+**
+** This library is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+** Lesser General Public License for more details.
+**
+** You should have received a copy of the GNU Lesser General Public
+** License along with this library; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include 
+#include 
+#include 
+#include 
+#include 
+
+static FILE* f;
+
+static void glewPrintExt (const char* name, int defined)
+{
+  unsigned int i;
+  fprintf(f, "\n%s:", name);
+  for (i=0; i<42-strlen(name); i++) fprintf(f, " ");
+  fprintf(f, "%s\n", defined ? "OK" : "MISSING");
+  for (i=0; i= 199901L)
+static void glxewInfo_OML_sync_control ()
+{
+  char me[] = "GLX_OML_sync_control"; glewPrintExt(me, glxew.OML_sync_control);
+  glewInfoFunc(glXGetSyncValuesOML == NULL, "glXGetSyncValuesOML");
+  glewInfoFunc(glXGetMscRateOML == NULL, "glXGetMscRateOML");
+  glewInfoFunc(glXSwapBuffersMscOML == NULL, "glXSwapBuffersMscOML");
+  glewInfoFunc(glXWaitForMscOML == NULL, "glXWaitForMscOML");
+  glewInfoFunc(glXWaitForSbcOML == NULL, "glXWaitForSbcOML");
+}
+#endif /* __STDC_VERSION__ */
+#endif /* GLX_OML_sync_control */
+
+/* ------------------------------- SGI_cushion ---------------------------- */
+
+#ifdef GLX_SGI_cushion
+static void glxewInfo_SGI_cushion ()
+{
+  char me[] = "GLX_SGI_cushion"; glewPrintExt(me, glxew.SGI_cushion);
+  glewInfoFunc(glXCushionSGI == NULL, "glXCushionSGI");
+}
+#endif /* GLX_SGI_cushion */
+
+/* -------------------------- SGI_make_current_read ----------------------- */
+
+#ifdef GLX_SGI_make_current_read
+static void glxewInfo_SGI_make_current_read ()
+{
+  char me[] = "GLX_SGI_make_current_read"; glewPrintExt(me, glxew.SGI_make_current_read);
+  glewInfoFunc(glXMakeCurrentReadSGI == NULL, "glXMakeCurrentReadSGI");
+  glewInfoFunc(glXGetCurrentReadDrawableSGI == NULL, "glXGetCurrentReadDrawableSGI");
+}
+#endif /* GLX_SGI_make_current_read */
+
+/* ---------------------------- SGI_swap_control -------------------------- */
+
+#ifdef GLX_SGI_swap_control
+static void glxewInfo_SGI_swap_control ()
+{
+  char me[] = "GLX_SGI_swap_control"; glewPrintExt(me, glxew.SGI_swap_control);
+  glewInfoFunc(glXSwapIntervalSGI == NULL, "glXSwapIntervalSGI");
+}
+#endif /* GLX_SGI_swap_control */
+
+/* ----------------------------- SGI_video_sync --------------------------- */
+
+#ifdef GLX_SGI_video_sync
+static void glxewInfo_SGI_video_sync ()
+{
+  char me[] = "GLX_SGI_video_sync"; glewPrintExt(me, glxew.SGI_video_sync);
+  glewInfoFunc(glXGetVideoSyncSGI == NULL, "glXGetVideoSyncSGI");
+  glewInfoFunc(glXWaitVideoSyncSGI == NULL, "glXWaitVideoSyncSGI");
+  glewInfoFunc(glXGetRefreshRateSGI == NULL, "glXGetRefreshRateSGI");
+}
+#endif /* GLX_SGI_video_sync */
+
+/* ------------------------------ SGIX_fbconfig --------------------------- */
+
+#ifdef GLX_SGIX_fbconfig
+static void glxewInfo_SGIX_fbconfig ()
+{
+  char me[] = "GLX_SGIX_fbconfig"; glewPrintExt(me, glxew.SGIX_fbconfig);
+  glewInfoFunc(glXGetFBConfigAttribSGIX == NULL, "glXGetFBConfigAttribSGIX");
+  glewInfoFunc(glXChooseFBConfigSGIX == NULL, "glXChooseFBConfigSGIX");
+  glewInfoFunc(glXCreateGLXPixmapWithConfigSGIX == NULL, "glXCreateGLXPixmapWithConfigSGIX");
+  glewInfoFunc(glXCreateContextWithConfigSGIX == NULL, "glXCreateContextWithConfigSGIX");
+  glewInfoFunc(glXGetVisualFromFBConfigSGIX == NULL, "glXGetVisualFromFBConfigSGIX");
+  glewInfoFunc(glXGetFBConfigFromVisualSGIX == NULL, "glXGetFBConfigFromVisualSGIX");
+}
+#endif /* GLX_SGIX_fbconfig */
+
+/* ------------------------------- SGIX_pbuffer --------------------------- */
+
+#ifdef GLX_SGIX_pbuffer
+static void glxewInfo_SGIX_pbuffer ()
+{
+  char me[] = "GLX_SGIX_pbuffer"; glewPrintExt(me, glxew.SGIX_pbuffer);
+  glewInfoFunc(glXCreateGLXPbufferSGIX == NULL, "glXCreateGLXPbufferSGIX");
+  glewInfoFunc(glXDestroyGLXPbufferSGIX == NULL, "glXDestroyGLXPbufferSGIX");
+  glewInfoFunc(glXQueryGLXPbufferSGIX == NULL, "glXQueryGLXPbufferSGIX");
+  glewInfoFunc(glXSelectEventSGIX == NULL, "glXSelectEventSGIX");
+  glewInfoFunc(glXGetSelectedEventSGIX == NULL, "glXGetSelectedEventSGIX");
+}
+#endif /* GLX_SGIX_pbuffer */
+
+/* ---------------------------- SGIX_swap_barrier ------------------------- */
+
+#ifdef GLX_SGIX_swap_barrier
+static void glxewInfo_SGIX_swap_barrier ()
+{
+  char me[] = "GLX_SGIX_swap_barrier"; glewPrintExt(me, glxew.SGIX_swap_barrier);
+  glewInfoFunc(glXBindSwapBarrierSGIX == NULL, "glXBindSwapBarrierSGIX");
+  glewInfoFunc(glXQueryMaxSwapBarriersSGIX == NULL, "glXQueryMaxSwapBarriersSGIX");
+}
+#endif /* GLX_SGIX_swap_barrier */
+
+/* ----------------------------- SGIX_swap_group -------------------------- */
+
+#ifdef GLX_SGIX_swap_group
+static void glxewInfo_SGIX_swap_group ()
+{
+  char me[] = "GLX_SGIX_swap_group"; glewPrintExt(me, glxew.SGIX_swap_group);
+  glewInfoFunc(glXJoinSwapGroupSGIX == NULL, "glXJoinSwapGroupSGIX");
+}
+#endif /* GLX_SGIX_swap_group */
+
+/* ------------------------ SUN_get_transparent_index --------------------- */
+
+#ifdef GLX_SUN_get_transparent_index
+static void glxewInfo_SUN_get_transparent_index ()
+{
+  char me[] = "GLX_SUN_get_transparent_index"; glewPrintExt(me, glxew.SUN_get_transparent_index);
+  glewInfoFunc(glXGetTransparentIndexSUN == NULL, "glXGetTransparentIndexSUN");
+}
+#endif /* GLX_SUN_get_transparent_index */
+
+#endif /* _WIN32 */
+
+/* ------------------------------------------------------------------------ */
+
+static void glewInfo ()
+{
+  /* test core opengl */
+#ifdef GL_VERSION_1_1
+  glewPrintExt("GL_11", glew.GL_11);
+#endif
+#ifdef GL_VERSION_1_2
+  glewInfo_12();
+#endif
+#ifdef GL_VERSION_1_3
+  glewInfo_13();
+#endif
+#ifdef GL_VERSION_1_4
+  glewInfo_14();
+#endif
+  /* test extensions */
+#ifdef GL_ARB_depth_texture
+  glewPrintExt("GL_ARB_depth_texture", glew.ARB_depth_texture);
+#endif
+#ifdef GL_ARB_fragment_program
+  glewPrintExt("GL_ARB_fragment_program", glew.ARB_fragment_program);
+#endif
+#ifdef GL_ARB_imaging
+  glewInfo_ARB_imaging();
+#endif
+#ifdef GL_ARB_matrix_palette
+  glewInfo_ARB_matrix_palette();
+#endif
+#ifdef GL_ARB_multisample
+  glewInfo_ARB_multisample();
+#endif
+#ifdef GL_ARB_multitexture
+  glewInfo_ARB_multitexture();
+#endif
+#ifdef GL_ARB_point_parameters
+  glewInfo_ARB_point_parameters();
+#endif
+#ifdef GL_ARB_shadow
+  glewPrintExt("GL_ARB_shadow", glew.ARB_shadow);
+#endif
+#ifdef GL_ARB_shadow_ambient
+  glewPrintExt("GL_ARB_shadow_ambient", glew.ARB_shadow_ambient);
+#endif
+#ifdef GL_ARB_texture_border_clamp
+  glewPrintExt("GL_ARB_texture_border_clamp", glew.ARB_texture_border_clamp);
+#endif
+#ifdef GL_ARB_texture_compression
+  glewInfo_ARB_texture_compression();
+#endif
+#ifdef GL_ARB_transpose_matrix
+  glewInfo_ARB_transpose_matrix();
+#endif
+#ifdef GL_ARB_texture_cube_map
+  glewPrintExt("GL_ARB_texture_cube_map", glew.ARB_texture_cube_map);
+#endif
+#ifdef GL_ARB_texture_env_add
+  glewPrintExt("GL_ARB_texture_env_add", glew.ARB_texture_env_add);
+#endif
+#ifdef GL_ARB_texture_env_combine
+  glewPrintExt("GL_ARB_texture_env_combine", glew.ARB_texture_env_combine);
+#endif
+#ifdef GL_ARB_texture_env_crossbar
+  glewPrintExt("GL_ARB_texture_env_crossbar", glew.ARB_texture_env_crossbar);
+#endif
+#ifdef GL_ARB_texture_env_dot3
+  glewPrintExt("GL_ARB_texture_env_dot3", glew.ARB_texture_env_dot3);
+#endif
+#ifdef GL_ARB_texture_mirrored_repeat
+  glewPrintExt("GL_ARB_texture_mirrored_repeat", glew.ARB_texture_mirrored_repeat);
+#endif
+#ifdef GL_ARB_vertex_blend
+  glewInfo_ARB_vertex_blend();
+#endif
+#ifdef GL_ARB_vertex_program
+  glewInfo_ARB_vertex_program();
+#endif
+#ifdef GL_ARB_window_pos
+  glewInfo_ARB_window_pos();
+#endif
+
+#ifdef GL_EXT_abgr
+  glewPrintExt("GL_EXT_abgr", glew.EXT_abgr);
+#endif
+#ifdef GL_EXT_bgra
+  glewPrintExt("GL_EXT_bgra", glew.EXT_bgra);
+#endif
+#ifdef GL_EXT_blend_color
+  glewInfo_EXT_blend_color();
+#endif
+#ifdef GL_EXT_blend_function_separate
+  glewInfo_EXT_blend_function_separate();
+#endif
+#ifdef GL_EXT_blend_minmax
+  glewInfo_EXT_blend_minmax();
+#endif
+#ifdef GL_EXT_blend_subtract
+  glewPrintExt("GL_EXT_blend_subtract", glew.EXT_blend_subtract);
+#endif
+#ifdef GL_EXT_clip_volume_hint
+  glewPrintExt("GL_EXT_clip_volume_hint", glew.EXT_clip_volume_hint);
+#endif
+#ifdef GL_EXT_compiled_vertex_array
+  glewInfo_EXT_compiled_vertex_array();
+#endif
+#ifdef GL_EXT_cull_vertex
+  glewInfo_EXT_cull_vertex();
+#endif
+#ifdef GL_EXT_draw_range_elements
+  glewInfo_EXT_draw_range_elements();
+#endif
+#ifdef GL_EXT_fog_coord
+  glewInfo_EXT_fog_coord();
+#endif
+#ifdef GL_EXT_multi_draw_arrays
+  glewInfo_EXT_multi_draw_arrays();
+#endif
+#ifdef GL_EXT_packed_pixels
+  glewPrintExt("GL_EXT_packed_pixels", glew.EXT_packed_pixels);
+#endif
+#ifdef GL_EXT_point_parameters
+  glewInfo_EXT_point_parameters();
+#endif
+#ifdef GL_EXT_secondary_color
+  glewInfo_EXT_secondary_color();
+#endif
+#ifdef GL_EXT_separate_specular_color
+  glewPrintExt("GL_EXT_separate_specular_color", glew.EXT_separate_specular_color);
+#endif
+#ifdef GL_EXT_shadow_funcs
+  glewPrintExt("GL_EXT_shadow_funcs", glew.EXT_shadow_funcs);
+#endif
+#ifdef GL_EXT_stencil_two_side
+  glewInfo_EXT_stencil_two_side();
+#endif
+#ifdef GL_EXT_stencil_wrap
+  glewPrintExt("GL_EXT_stencil_two_side", glew.EXT_stencil_wrap);
+#endif
+#ifdef GL_EXT_texture_compression_s3tc
+  glewPrintExt("GL_EXT_texture_compression_s3tc", glew.EXT_texture_compression_s3tc);
+#endif
+#ifdef GL_EXT_texture_env_combine
+  glewPrintExt("GL_EXT_texture_env_combine", glew.EXT_texture_env_combine);
+#endif
+#ifdef GL_EXT_texture_filter_anisotropic
+  glewPrintExt("GL_EXT_texture_filter_anisotropic", glew.EXT_texture_filter_anisotropic);
+#endif
+#ifdef GL_EXT_texture_lod_bias
+  glewPrintExt("GL_EXT_texture_lod_bias", glew.EXT_texture_lod_bias);
+#endif
+#ifdef GL_EXT_texture_rectangle
+  glewPrintExt("GL_EXT_texture_rectangle", glew.EXT_texture_rectangle);
+#endif
+#ifdef GL_EXT_vertex_shader
+  glewInfo_EXT_vertex_shader();
+#endif
+#ifdef GL_EXT_vertex_weighting
+  glewInfo_EXT_vertex_weighting();
+#endif
+
+#ifdef GL_SGIS_generate_mipmap
+  glewPrintExt("GL_SGIS_generate_mipmap", glew.SGIS_generate_mipmap);
+#endif
+#ifdef GL_SGIS_texture_lod
+  glewPrintExt("GL_SGIS_texture_lod", glew.SGIS_texture_lod);
+#endif
+#ifdef GL_SGIX_depth_texture
+  glewPrintExt("GL_SGIX_depth_texture", glew.SGIX_depth_texture);
+#endif
+#ifdef GL_SGIX_shadow
+  glewPrintExt("GL_SGIX_shadow", glew.SGIX_shadow);
+#endif
+
+#ifdef GL_HP_occlusion_test
+  glewPrintExt("GL_HP_occlusion_test", glew.HP_occlusion_test);
+#endif
+#ifdef GL_S3_s3tc
+  glewPrintExt("GL_S3_s3tc", glew.S3_s3tc);
+#endif
+#ifdef GL_WIN_swap_hint
+  glewInfo_WIN_swap_hint();
+#endif
+
+#ifdef GL_ATI_draw_buffers
+  glewInfo_ATI_draw_buffers();
+#endif
+#ifdef GL_ATI_element_array
+  glewInfo_ATI_element_array();
+#endif
+#ifdef GL_ATI_envmap_bumpmap
+  glewInfo_ATI_envmap_bumpmap();
+#endif
+#ifdef GL_ATI_fragment_shader
+  glewInfo_ATI_fragment_shader();
+#endif
+#ifdef GL_ATI_map_object_buffer
+  glewInfo_ATI_map_object_buffer();
+#endif
+#ifdef GL_ATI_mapped_texture
+  glewInfo_ATI_mapped_texture();
+#endif
+#ifdef GL_ATI_point_cull_mode
+  glewPrintExt("GL_ATI_point_cull_mode", glew.ATI_point_cull_mode);
+#endif
+#ifdef GL_ATI_pn_triangles
+  glewInfo_ATI_pn_triangles();
+#endif
+#ifdef GL_ATI_separate_stencil
+  glewInfo_ATI_separate_stencil();
+#endif
+#ifdef GL_ATI_text_fragment_shader
+  glewPrintExt("GL_ATI_text_fragment_shader", glew.ATI_text_fragment_shader);
+#endif
+#ifdef GL_ATI_texture_float
+  glewPrintExt("GL_ATI_texture_float", glew.ATI_texture_float);
+#endif
+#ifdef GL_ATI_texture_mirror_once
+  glewPrintExt("GL_ATI_texture_mirror_once", glew.ATI_texture_mirror_once);
+#endif
+#ifdef GL_ATI_timestamp
+  glewInfo_ATI_timestamp();
+#endif
+#ifdef GL_ATI_vertex_array_object
+  glewInfo_ATI_vertex_array_object();
+#endif
+#ifdef GL_ATI_vertex_attrib_array_object
+  glewInfo_ATI_vertex_attrib_array_object();
+#endif
+#ifdef GL_ATI_vertex_streams
+  glewInfo_ATI_vertex_streams();
+#endif
+#ifdef GL_ATIX_point_sprites
+  glewPrintExt("GL_ATIX_point_sprites", glew.ATIX_point_sprites);
+#endif
+#ifdef GL_ATIX_texture_env_combine3
+  glewPrintExt("GL_ATIX_texture_env_combine3", glew.ATIX_texture_env_combine3);
+#endif
+#ifdef GL_ATIX_texture_env_route
+  glewPrintExt("GL_ATIX_texture_env_route", glew.ATIX_texture_env_route);
+#endif
+#ifdef GL_ATIX_vertex_shader_output_point_size
+  glewPrintExt("GL_ATIX_vertex_shader_output_point_size", glew.ATIX_vertex_shader_output_point_size);
+#endif
+
+#ifdef GL_NV_blend_square
+  glewPrintExt("GL_NV_blend_square", glew.NV_blend_square);
+#endif
+#ifdef GL_NV_copy_depth_to_color
+  glewPrintExt("GL_NV_copy_depth_to_color", glew.NV_copy_depth_to_color);
+#endif
+#ifdef GL_NV_depth_clamp
+  glewPrintExt("GL_NV_depth_clamp", glew.NV_depth_clamp);
+#endif
+#ifdef GL_NV_element_array
+  glewInfo_NV_element_array();
+#endif
+#ifdef GL_NV_evaluators
+  glewInfo_NV_evaluators();
+#endif
+#ifdef GL_NV_fence
+  glewInfo_NV_fence();
+#endif
+#ifdef GL_NV_float_buffer
+  glewPrintExt("GL_NV_float_buffer", glew.NV_float_buffer);
+#endif
+#ifdef GL_NV_fog_distance
+  glewPrintExt("GL_NV_fog_distance", glew.NV_fog_distance);
+#endif
+#ifdef GL_NV_fragment_program
+  glewInfo_NV_fragment_program();
+#endif
+#ifdef GL_NV_light_max_exponent
+  glewPrintExt("GL_NV_light_max_exponent", glew.NV_light_max_exponent);
+#endif
+#ifdef GL_NV_multisample_filter_hint
+  glewPrintExt("GL_NV_multisample_filter_hint", glew.NV_multisample_filter_hint);
+#endif
+#ifdef GL_NV_occlusion_query
+  glewInfo_NV_occlusion_query();
+#endif
+#ifdef GL_NV_packed_depth_stencil
+  glewPrintExt("GL_NV_packed_depth_stencil", glew.NV_packed_depth_stencil);
+#endif
+#ifdef GL_NV_pixel_data_range
+  glewInfo_NV_pixel_data_range();
+#endif
+#ifdef GL_NV_point_sprite
+  glewInfo_NV_point_sprite();
+#endif
+#ifdef GL_NV_primitive_restart
+  glewInfo_NV_primitive_restart();
+#endif
+#ifdef GL_NV_register_combiners
+  glewInfo_NV_register_combiners();
+#endif
+#ifdef GL_NV_register_combiners2
+  glewInfo_NV_register_combiners2();
+#endif
+#ifdef GL_NV_texgen_reflection
+  glewPrintExt("GL_NV_texgen_reflection", glew.NV_texgen_reflection);
+#endif
+#ifdef GL_NV_texture_compression_vtc
+  glewPrintExt("GL_NV_texture_compression_vtc", glew.NV_texture_compression_vtc);
+#endif
+#ifdef GL_NV_texture_env_combine4
+  glewPrintExt("GL_NV_texture_env_combine4", glew.NV_texture_env_combine4);
+#endif
+#ifdef GL_NV_texture_rectangle
+  glewPrintExt("GL_NV_texture_rectangle", glew.NV_texture_rectangle);
+#endif
+#ifdef GL_NV_texture_shader
+  glewPrintExt("GL_NV_texture_shader", glew.NV_texture_shader);
+#endif
+#ifdef GL_NV_texture_shader2
+  glewPrintExt("GL_NV_texture_shader2", glew.NV_texture_shader2);
+#endif
+#ifdef GL_NV_texture_shader3
+  glewPrintExt("GL_NV_texture_shader3", glew.NV_texture_shader3);
+#endif
+#ifdef GL_NV_vertex_array_range
+  glewInfo_NV_vertex_array_range();
+#endif
+#ifdef GL_NV_vertex_array_range2
+  glewPrintExt("GL_NV_vertex_array_range2", glew.NV_vertex_array_range2);
+#endif
+#ifdef GL_NV_vertex_program
+  glewInfo_NV_vertex_program();
+#endif
+#ifdef GL_NV_vertex_program1_1
+  glewPrintExt("GL_NV_vertex_program1_1", glew.NV_vertex_program1_1);
+#endif
+#ifdef GL_NV_vertex_program2
+  glewPrintExt("GL_NV_vertex_program2", glew.NV_vertex_program2);
+#endif
+}
+
+/* ------------------------------------------------------------------------ */
+
+#ifdef _WIN32
+
+static void wglewInfo ()
+{
+#ifdef WGL_ARB_buffer_region
+  wglewInfo_ARB_buffer_region();
+#endif
+#ifdef WGL_ARB_make_current_read
+  wglewInfo_ARB_make_current_read();
+#endif
+#ifdef WGL_ARB_multisample
+  glewPrintExt("WGL_ARB_multisample", wglew.ARB_multisample);
+#endif   
+#ifdef WGL_ARB_pbuffer
+  wglewInfo_ARB_pbuffer();
+#endif
+#ifdef WGL_ARB_pixel_format
+  wglewInfo_ARB_pixel_format();
+#endif
+#ifdef WGL_ARB_render_texture
+  wglewInfo_ARB_render_texture();
+#endif
+
+#ifdef WGL_EXT_depth_float
+  glewPrintExt("WGL_EXT_depth_float", wglew.EXT_depth_float);
+#endif
+#ifdef WGL_EXT_display_color_table
+  wglewInfo_EXT_display_color_table();
+#endif
+#ifdef WGL_EXT_make_current_read
+  wglewInfo_EXT_make_current_read();
+#endif
+#ifdef WGL_EXT_multisample
+  glewPrintExt("WGL_EXT_multisample", wglew.EXT_multisample);
+#endif
+#ifdef WGL_EXT_pixel_format
+  wglewInfo_EXT_pixel_format();
+#endif
+#ifdef WGL_EXT_pbuffer
+  wglewInfo_EXT_pbuffer();
+#endif
+#ifdef WGL_EXT_swap_control
+  wglewInfo_EXT_swap_control();
+#endif
+
+#ifdef WGL_I3D_digital_video_control
+  wglewInfo_I3D_digital_video_control();
+#endif
+#ifdef WGL_I3D_gamma
+  wglewInfo_I3D_gamma();
+#endif
+#ifdef WGL_I3D_genlock
+  wglewInfo_I3D_genlock();
+#endif
+#ifdef WGL_I3D_image_buffer
+  wglewInfo_I3D_image_buffer();
+#endif
+#ifdef WGL_I3D_swap_frame_lock
+  wglewInfo_I3D_swap_frame_lock();
+#endif
+#ifdef WGL_I3D_swap_frame_usage
+  wglewInfo_I3D_swap_frame_usage();
+#endif
+
+#ifdef WGL_OML_sync_control
+  wglewInfo_OML_sync_control();
+#endif
+
+#ifdef WGL_ATI_pixel_format_float
+  glewPrintExt("WGL_ATI_pixel_format_float", wglew.ATI_pixel_format_float);
+#endif
+
+#ifdef WGL_NV_float_buffer
+  glewPrintExt("WGL_NV_float_buffer", wglew.NV_float_buffer);
+#endif
+#ifdef WGL_NV_render_depth_texture
+  glewPrintExt("WGL_NV_render_depth_texture", wglew.NV_render_depth_texture);
+#endif
+#ifdef WGL_NV_render_texture_rectangle
+  glewPrintExt("WGL_NV_render_texture_rectangle", wglew.NV_render_texture_rectangle);
+#endif
+#ifdef WGL_NV_vertex_array_range
+  wglewInfo_NV_vertex_array_range();
+#endif
+}
+
+#else /* _UNIX */
+
+static void glxewInfo ()
+{
+#ifdef GLX_VERSION_1_0
+  glxewInfo_10();
+#endif
+#ifdef GLX_VERSION_1_1
+  glxewInfo_11();
+#endif
+#ifdef GLX_VERSION_1_2
+  glxewInfo_12();
+#endif
+#ifdef GLX_VERSION_1_3
+  glxewInfo_13();
+#endif
+#ifdef GLX_VERSION_1_4
+  glewPrintExt("GLX_14", glxew.GLX_14);
+#endif
+
+#ifdef GLX_ARB_get_proc_address
+  glewPrintExt("GLX_ARB_get_proc_address", glxew.ARB_get_proc_address);
+#endif
+#ifdef GLX_ARB_multisample
+  glewPrintExt("GLX_ARB_multisample", glxew.ARB_multisample);
+#endif
+
+#ifdef GLX_EXT_import_context
+  glxewInfo_EXT_import_context();
+#endif
+#ifdef GLX_EXT_visual_info
+  glewPrintExt("GLX_EXT_visual_info", glxew.EXT_visual_info);
+#endif
+#ifdef GLX_EXT_visual_rating
+  glewPrintExt("GLX_EXT_visual_rating", glxew.EXT_visual_rating);
+#endif
+
+#ifdef GLX_MESA_copy_sub_buffer
+  glxewInfo_MESA_copy_sub_buffer();
+#endif
+#ifdef GLX_MESA_pixmap_colormap
+  glxewInfo_MESA_pixmap_colormap();
+#endif
+#ifdef GLX_MESA_release_buffers
+  glxewInfo_MESA_release_buffers();
+#endif
+#ifdef GLX_MESA_set_3dfx_mode
+  glxewInfo_MESA_set_3dfx_mode();
+#endif
+
+#ifdef GLX_NV_vertex_array_range
+  glxewInfo_NV_vertex_array_range();
+#endif
+
+#ifdef GLX_OML_swap_method
+  glewPrintExt("GLX_OML_swap_method", glxew.OML_swap_method);
+#endif
+#ifdef GLX_OML_sync_control
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+  glxewInfo_OML_sync_control();
+#endif /* __STDC_VERSION__ */
+#endif
+
+#ifdef GLX_SGI_cushion
+  glxewInfo_SGI_cushion();
+#endif
+#ifdef GLX_SGI_make_current_read
+  glxewInfo_SGI_make_current_read();
+#endif
+#ifdef GLX_SGI_swap_control
+  glxewInfo_SGI_swap_control();
+#endif
+#ifdef GLX_SGI_video_sync
+  glxewInfo_SGI_video_sync();
+#endif
+
+#ifdef GLX_SGIS_blended_overlay
+  glewPrintExt("GLX_SGIS_blended_overlay", glxew.SGIS_blended_overlay);
+#endif
+#ifdef GLX_SGIS_multisample
+  glewPrintExt("GLX_SGIS_multisample", glxew.SGIS_multisample);
+#endif
+#ifdef GLX_SGIS_shared_multisample
+  glewPrintExt("GLX_SGIS_shared_multisample", glxew.SGIS_shared_multisample);
+#endif
+
+#ifdef GLX_SGIX_fbconfig
+  glxewInfo_SGIX_fbconfig();
+#endif
+#ifdef GLX_SGIX_pbuffer
+  glxewInfo_SGIX_pbuffer();
+#endif
+#ifdef GLX_SGIX_swap_barrier
+  glxewInfo_SGIX_swap_barrier();
+#endif
+#ifdef GLX_SGIX_swap_group
+  glxewInfo_SGIX_swap_group();
+#endif
+#ifdef GLX_SGIX_visual_select_group
+  glewPrintExt("GLX_SGIX_visual_select_group", glxew.SGIX_visual_select_group);
+#endif
+
+#ifdef GLX_SUN_get_transparent_index
+  glxewInfo_SUN_get_transparent_index();
+#endif
+}
+
+#endif /* _WIN32 */
+
+/* ------------------------------------------------------------------------ */
+
+int main (int argc, char** argv)
+{
+  GLint err;
+  glutInit(&argc, argv);
+  glutCreateWindow("GLEW Extension Info");
+  glewExperimental = GL_TRUE;
+  err = glewInit();
+  if (GLEW_OK != err)
+  {
+    fprintf(stderr, "Error [main]: glewInit failed: %s\n", glewGetErrorString(err));
+    return 1;
+  }
+  f = fopen("glewinfo.txt", "w");
+  if (f == NULL) f = stdout;
+  fprintf(f, "---------------------------\n");
+  fprintf(f, "    GLEW Extension Info\n");
+  fprintf(f, "---------------------------\n\n");
+  fprintf(f, "Running on a %s from %s\n", 
+	  glGetString(GL_RENDERER), glGetString(GL_VENDOR));
+  fprintf(f, "OpenGL version %s is supported\n", glGetString(GL_VERSION));
+  glewInfo();
+#ifdef WIN32
+  wglewInfo();
+#else
+  glxewInfo();
+#endif
+  if (f != stdout) fclose(f);
+  return 0;
+}