Patchwork [3/3] qemu: remove version 0.14.0

login
register
mail settings
Submitter Paul Eggleton
Date Feb. 23, 2012, 3:31 p.m.
Message ID <39e35df7a555fe0e71af98d4006a0894bc37ed4f.1330010964.git.paul.eggleton@linux.intel.com>
Download mbox | patch
Permalink /patch/21759/
State Accepted
Commit d242e637a2b5101985befd93d3b560f17b37504b
Headers show

Comments

Paul Eggleton - Feb. 23, 2012, 3:31 p.m.
0.15.1 has been available in OE-Core for some time and has demonstrated
no major regressions, so remove the older version.

Signed-off-by: Paul Eggleton <paul.eggleton@linux.intel.com>
---
 ...t-and-use-GCC-atomic-builtins-for-locking.patch |   86 -
 .../qemu/qemu-0.14.0/arm-bgr.patch                 |   30 -
 .../qemu/qemu-0.14.0/enable-i386-linux-user.patch  |   55 -
 .../fallback-to-safe-mmap_min_addr.patch           |   39 -
 .../qemu/qemu-0.14.0/fix-configure-checks.patch    |   22 -
 .../qemu/qemu-0.14.0/fix-nogl.patch                |  127 -
 .../qemu/qemu-0.14.0/glflags.patch                 |   15 -
 .../qemu/qemu-0.14.0/init-info.patch               |   18 -
 .../qemu/qemu-0.14.0/larger_default_ram_size.patch |   22 -
 .../qemu/qemu-0.14.0/linker-flags.patch            |   25 -
 .../qemu/qemu-0.14.0/no-strip.patch                |   15 -
 .../qemu/qemu-0.14.0/opengl-sdl-fix.patch          |   43 -
 .../qemu/qemu-0.14.0/powerpc_rom.bin               |  Bin 4096 -> 0 bytes
 .../qemu/qemu-0.14.0/qemu-git-qemugl-host.patch    |34368 --------------------
 .../qemu/qemu-0.14.0/qemu-vmware-vga-depth.patch   |  118 -
 .../qemugl-allow-glxcontext-release.patch          |   65 -
 .../qemu/qemu-0.14.0/qemugl-fix.patch              |   74 -
 .../spice-qxl-locking-fix-for-qemu-kvm.patch       |  152 -
 meta/recipes-devtools/qemu/qemu_0.14.0.bb          |   48 -
 19 files changed, 0 insertions(+), 35322 deletions(-)
 delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/Detect-and-use-GCC-atomic-builtins-for-locking.patch
 delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/arm-bgr.patch
 delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/enable-i386-linux-user.patch
 delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/fallback-to-safe-mmap_min_addr.patch
 delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/fix-configure-checks.patch
 delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/fix-nogl.patch
 delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/glflags.patch
 delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/init-info.patch
 delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/larger_default_ram_size.patch
 delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/linker-flags.patch
 delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/no-strip.patch
 delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/opengl-sdl-fix.patch
 delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/powerpc_rom.bin
 delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/qemu-git-qemugl-host.patch
 delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/qemu-vmware-vga-depth.patch
 delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/qemugl-allow-glxcontext-release.patch
 delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/qemugl-fix.patch
 delete mode 100644 meta/recipes-devtools/qemu/qemu-0.14.0/spice-qxl-locking-fix-for-qemu-kvm.patch
 delete mode 100644 meta/recipes-devtools/qemu/qemu_0.14.0.bb

Patch

diff --git a/meta/recipes-devtools/qemu/qemu-0.14.0/Detect-and-use-GCC-atomic-builtins-for-locking.patch b/meta/recipes-devtools/qemu/qemu-0.14.0/Detect-and-use-GCC-atomic-builtins-for-locking.patch
deleted file mode 100644
index eb107b8..0000000
--- a/meta/recipes-devtools/qemu/qemu-0.14.0/Detect-and-use-GCC-atomic-builtins-for-locking.patch
+++ /dev/null
@@ -1,86 +0,0 @@ 
-From de01f17a2cb88dc5ff53cc321342b888c33b120a Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?Lo=C3=AFc=20Minier?= <lool@dooz.org>
-Date: Thu, 11 Feb 2010 17:42:33 +0100
-Subject: [PATCH] Detect and use GCC atomic builtins for locking
-
----
- configure   |   17 +++++++++++++++++
- qemu-lock.h |   13 +++++++++++++
- 2 files changed, 30 insertions(+), 0 deletions(-)
-
-Upstream-Status: Pending
-
-Index: qemu-0.14.0/configure
-===================================================================
---- qemu-0.14.0.orig/configure
-+++ qemu-0.14.0/configure
-@@ -2243,6 +2243,20 @@ fi
- ##########################################
- 
- ##########################################
-+# check if we have gcc atomic built-ins
-+gcc_atomic_builtins=no
-+cat > $TMPC << EOF
-+int main(void) {
-+    int i;
-+    __sync_lock_test_and_set(&i, 1);
-+    __sync_lock_release(&i);
-+}
-+EOF
-+if compile_prog "" ""; then
-+    gcc_atomic_builtins=yes
-+fi
-+
-+##########################################
- # check if we have fdatasync
- 
- fdatasync=no
-@@ -2731,6 +2745,9 @@ fi
- if test "$gcc_attribute_warn_unused_result" = "yes" ; then
-   echo "CONFIG_GCC_ATTRIBUTE_WARN_UNUSED_RESULT=y" >> $config_host_mak
- fi
-+if test "$gcc_atomic_builtins" = "yes" ; then
-+  echo "CONFIG_GCC_ATOMIC_BUILTINS=y" >> $config_host_mak
-+fi
- if test "$fdatasync" = "yes" ; then
-   echo "CONFIG_FDATASYNC=y" >> $config_host_mak
- fi
-Index: qemu-0.14.0/qemu-lock.h
-===================================================================
---- qemu-0.14.0.orig/qemu-lock.h
-+++ qemu-0.14.0/qemu-lock.h
-@@ -33,6 +33,14 @@
- 
- #else
- 
-+#ifdef CONFIG_GCC_ATOMIC_BUILTINS
-+typedef int spinlock_t;
-+
-+#define SPIN_LOCK_UNLOCKED 0
-+
-+#define resetlock(p) __sync_lock_release((p))
-+#else /* CONFIG_GCC_ATOMIC_BUILTINS */
-+
- #if defined(__hppa__)
- 
- typedef int spinlock_t[4];
-@@ -56,7 +64,11 @@ static inline void resetlock (spinlock_t
- }
- 
- #endif
-+#endif /* !CONFIG_GCC_ATOMIC_BUILTINS */
- 
-+#ifdef CONFIG_GCC_ATOMIC_BUILTINS
-+#define testandset(p) __sync_lock_test_and_set((p), 1)
-+#else /* CONFIG_GCC_ATOMIC_BUILTINS */
- #if defined(_ARCH_PPC)
- static inline int testandset (int *p)
- {
-@@ -213,6 +225,7 @@ static inline int testandset (int *p)
- #else
- #error unimplemented CPU support
- #endif
-+#endif /* !CONFIG_GCC_ATOMIC_BUILTINS */
- 
- #if defined(CONFIG_USER_ONLY)
- static inline void spin_lock(spinlock_t *lock)
diff --git a/meta/recipes-devtools/qemu/qemu-0.14.0/arm-bgr.patch b/meta/recipes-devtools/qemu/qemu-0.14.0/arm-bgr.patch
deleted file mode 100644
index a8fe65a..0000000
--- a/meta/recipes-devtools/qemu/qemu-0.14.0/arm-bgr.patch
+++ /dev/null
@@ -1,30 +0,0 @@ 
-After kernel commit:
-
-http://git.yoctoproject.org/cgit/cgit.cgi/linux-yocto-3.0/commit/?h=meta&id=9728c1b6a724daefc413b44e10253cdbb5e06d08
-
-It appears that the emulated colours in qemu are incorrect and that 
-the red and blue channels are reversed. This patch reverses that logic
-so the colours are correctly displayed on the versatile platform which
-doesn't support the BGR bit.
-
-RP 16/9/2011
-
-Upstream-Status: Pending
-
-Index: qemu-0.14.0/hw/pl110.c
-===================================================================
---- qemu-0.14.0.orig/hw/pl110.c	2011-09-16 14:45:34.228668514 +0100
-+++ qemu-0.14.0/hw/pl110.c	2011-09-16 15:17:22.458671206 +0100
-@@ -141,7 +141,11 @@
-         fprintf(stderr, "pl110: Bad color depth\n");
-         exit(1);
-     }
--    if (s->cr & PL110_CR_BGR)
-+
-+    if (s->versatile && s->bpp == BPP_16)
-+        /* Code assumes BPP_16 == 565 and BGR is never set on the versatile in 565 mode */
-+        bpp_offset = 0;
-+    else if (s->cr & PL110_CR_BGR)
-         bpp_offset = 0;
-     else
-         bpp_offset = 18;
diff --git a/meta/recipes-devtools/qemu/qemu-0.14.0/enable-i386-linux-user.patch b/meta/recipes-devtools/qemu/qemu-0.14.0/enable-i386-linux-user.patch
deleted file mode 100644
index bb0d6a3..0000000
--- a/meta/recipes-devtools/qemu/qemu-0.14.0/enable-i386-linux-user.patch
+++ /dev/null
@@ -1,55 +0,0 @@ 
-Enable i386-linux-user
-
-Signed-off-by: Zhai Edwin <edwin.zhai@intel.com>
-
-Upstream-Status: Inappropriate [configuration]
-
-Index: qemu-0.14.0/Makefile.target
-===================================================================
---- qemu-0.14.0.orig/Makefile.target
-+++ qemu-0.14.0/Makefile.target
-@@ -78,8 +78,13 @@ ifeq ($(TARGET_BASE_ARCH), i386)
- libobj-y += cpuid.o
- endif
- libobj-$(CONFIG_NEED_MMU) += mmu.o
-+ifndef CONFIG_LINUX_USER
- libobj-$(TARGET_I386) += helper_opengl.o opengl_exec.o
- libobj-$(TARGET_X86_64) += helper_opengl.o opengl_exec.o
-+else
-+libobj-$(TARGET_I386) += dummygl.o
-+libobj-$(TARGET_X86_64) += dummygl.o
-+endif #CONFIG_LINUX_USER
- libobj-$(TARGET_ARM) += dummygl.o
- libobj-$(TARGET_MIPS) += dummygl.o
- libobj-$(TARGET_PPC) += dummygl.o
-Index: qemu-0.14.0/target-i386/dummygl.c
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-i386/dummygl.c
-@@ -0,0 +1,26 @@
-+#include <string.h>
-+#include <stdlib.h>
-+#include <assert.h>
-+#include <stdint.h>
-+#include <X11/Xlib.h>
-+#include <X11/Xutil.h>
-+
-+void opengl_exec_set_parent_window(Display* _dpy, Window _parent_window)
-+{
-+
-+}
-+
-+void opengl_process_enable(void)
-+{
-+
-+}
-+
-+
-+void mem_opengl(uint64_t ptr)
-+{
-+
-+}
-+
-+void helper_opengl(void)
-+{
-+}
diff --git a/meta/recipes-devtools/qemu/qemu-0.14.0/fallback-to-safe-mmap_min_addr.patch b/meta/recipes-devtools/qemu/qemu-0.14.0/fallback-to-safe-mmap_min_addr.patch
deleted file mode 100644
index 2075386..0000000
--- a/meta/recipes-devtools/qemu/qemu-0.14.0/fallback-to-safe-mmap_min_addr.patch
+++ /dev/null
@@ -1,39 +0,0 @@ 
-From c313f89c33217ac0e471554dace2144718f86669 Mon Sep 17 00:00:00 2001
-From: Martin Jansa <Martin.Jansa@gmail.com>
-Date: Thu, 13 May 2010 12:23:40 +0200
-Subject: [PATCH] linux-user: use default mmap_min_addr 65536 when /proc/sys/vm/mmap_min_addr cannot be read
-
-* 65536 is default at least for ubuntu and fedora.
----
- linux-user/main.c |    5 +++++
- 1 files changed, 5 insertions(+), 0 deletions(-)
-
-Upstream-Status: Pending
-
-Index: qemu-0.14.0/linux-user/main.c
-===================================================================
---- qemu-0.14.0.orig/linux-user/main.c
-+++ qemu-0.14.0/linux-user/main.c
-@@ -36,6 +36,7 @@
- #include "envlist.h"
- 
- #define DEBUG_LOGFILE "/tmp/qemu.log"
-+#define MMAP_MIN_ADDR_DEFAULT 65536
- 
- char *exec_path;
- 
-@@ -3010,8 +3011,14 @@ int main(int argc, char **argv, char **e
-             if (fscanf(fp, "%lu", &tmp) == 1) {
-                 mmap_min_addr = tmp;
-                 qemu_log("host mmap_min_addr=0x%lx\n", mmap_min_addr);
-+            } else {
-+                qemu_log("cannot read value from /proc/sys/vm/mmap_min_addr, assuming %d\n", MMAP_MIN_ADDR_DEFAULT);
-+                mmap_min_addr = MMAP_MIN_ADDR_DEFAULT;
-             }
-             fclose(fp);
-+        } else {
-+            qemu_log("cannot open /proc/sys/vm/mmap_min_addr for reading, assuming %d\n", MMAP_MIN_ADDR_DEFAULT);
-+            mmap_min_addr = MMAP_MIN_ADDR_DEFAULT;
-         }
-     }
- 
diff --git a/meta/recipes-devtools/qemu/qemu-0.14.0/fix-configure-checks.patch b/meta/recipes-devtools/qemu/qemu-0.14.0/fix-configure-checks.patch
deleted file mode 100644
index 96881bb..0000000
--- a/meta/recipes-devtools/qemu/qemu-0.14.0/fix-configure-checks.patch
+++ /dev/null
@@ -1,22 +0,0 @@ 
-In native builds, qemu can fail to find zlib development files in the native 
-sysroot and the build machine might not have zlib-dev packages installed.
-
-Add CFLAGS to qemu's CFLAGS which in the native case means BUILD_CFLAGS are
-added and files in the sysroot can be found.
-
-Patch from Paul Eggleton, Comments by RP 28/11/10
-
-Upstream-Status: Inappropriate [embedded specific]
-
-Index: qemu-0.14.0/configure
-===================================================================
---- qemu-0.14.0.orig/configure
-+++ qemu-0.14.0/configure
-@@ -229,6 +229,7 @@ QEMU_CFLAGS="-Wstrict-prototypes -Wredun
- QEMU_CFLAGS="-D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE $QEMU_CFLAGS"
- QEMU_CFLAGS="-D_FORTIFY_SOURCE=2 $QEMU_CFLAGS"
- QEMU_INCLUDES="-I. -I\$(SRC_PATH)"
-+QEMU_CFLAGS="$QEMU_CFLAGS $CFLAGS"
- LDFLAGS="-g $LDFLAGS"
- 
- # make source path absolute
diff --git a/meta/recipes-devtools/qemu/qemu-0.14.0/fix-nogl.patch b/meta/recipes-devtools/qemu/qemu-0.14.0/fix-nogl.patch
deleted file mode 100644
index 83b2752..0000000
--- a/meta/recipes-devtools/qemu/qemu-0.14.0/fix-nogl.patch
+++ /dev/null
@@ -1,127 +0,0 @@ 
-Upstream-Status: Inappropriate [configuration]
-
-Index: qemu-0.14.0/Makefile.target
-===================================================================
---- qemu-0.14.0.orig/Makefile.target
-+++ qemu-0.14.0/Makefile.target
-@@ -79,6 +79,12 @@ libobj-y += cpuid.o
- endif
- libobj-$(CONFIG_NEED_MMU) += mmu.o
- libobj-$(TARGET_I386) += helper_opengl.o opengl_exec.o
-+libobj-$(TARGET_X86_64) += helper_opengl.o opengl_exec.o
-+libobj-$(TARGET_ARM) += dummygl.o
-+libobj-$(TARGET_MIPS) += dummygl.o
-+libobj-$(TARGET_MIPS64) += dummygl.o
-+libobj-$(TARGET_PPC) += dummygl.o
-+libobj-$(TARGET_SH4) += dummygl.o
- libobj-$(TARGET_ARM) += neon_helper.o iwmmxt_helper.o
- 
- libobj-y += disas.o
-Index: qemu-0.14.0/target-arm/dummygl.c
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-arm/dummygl.c
-@@ -0,0 +1,22 @@
-+#include <string.h>
-+#include <stdlib.h>
-+#include <assert.h>
-+#include <stdint.h>
-+#include <X11/Xlib.h>
-+#include <X11/Xutil.h>
-+
-+void opengl_exec_set_parent_window(Display* _dpy, Window _parent_window)
-+{
-+
-+}
-+
-+void opengl_process_enable(void)
-+{
-+
-+}
-+
-+
-+void mem_opengl(uint64_t ptr)
-+{
-+
-+}
-Index: qemu-0.14.0/target-mips/dummygl.c
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-mips/dummygl.c
-@@ -0,0 +1,22 @@
-+#include <string.h>
-+#include <stdlib.h>
-+#include <assert.h>
-+#include <stdint.h>
-+#include <X11/Xlib.h>
-+#include <X11/Xutil.h>
-+
-+void opengl_exec_set_parent_window(Display* _dpy, Window _parent_window)
-+{
-+
-+}
-+
-+void opengl_process_enable(void)
-+{
-+
-+}
-+
-+
-+void mem_opengl(uint64_t ptr)
-+{
-+
-+}
-Index: qemu-0.14.0/target-ppc/dummygl.c
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-ppc/dummygl.c
-@@ -0,0 +1,22 @@
-+#include <string.h>
-+#include <stdlib.h>
-+#include <assert.h>
-+#include <stdint.h>
-+#include <X11/Xlib.h>
-+#include <X11/Xutil.h>
-+
-+void opengl_exec_set_parent_window(Display* _dpy, Window _parent_window)
-+{
-+
-+}
-+
-+void opengl_process_enable(void)
-+{
-+
-+}
-+
-+
-+void mem_opengl(uint64_t ptr)
-+{
-+
-+}
-Index: qemu-0.14.0/target-sh4/dummygl.c
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-sh4/dummygl.c
-@@ -0,0 +1,22 @@
-+#include <string.h>
-+#include <stdlib.h>
-+#include <assert.h>
-+#include <stdint.h>
-+#include <X11/Xlib.h>
-+#include <X11/Xutil.h>
-+
-+void opengl_exec_set_parent_window(Display* _dpy, Window _parent_window)
-+{
-+
-+}
-+
-+void opengl_process_enable(void)
-+{
-+
-+}
-+
-+
-+void mem_opengl(uint64_t ptr)
-+{
-+
-+}
diff --git a/meta/recipes-devtools/qemu/qemu-0.14.0/glflags.patch b/meta/recipes-devtools/qemu/qemu-0.14.0/glflags.patch
deleted file mode 100644
index 0ad5551..0000000
--- a/meta/recipes-devtools/qemu/qemu-0.14.0/glflags.patch
+++ /dev/null
@@ -1,15 +0,0 @@ 
-Upstream-Status: Inappropriate [configuration]
-
-Index: qemu-0.14.0/Makefile.target
-===================================================================
---- qemu-0.14.0.orig/Makefile.target	2011-04-04 12:12:19.142871742 +0100
-+++ qemu-0.14.0/Makefile.target	2011-04-04 12:12:21.772871742 +0100
-@@ -362,7 +362,7 @@
- 
- monitor.o: hmp-commands.h qmp-commands.h
- 
--LIBS += -lGL -lGLU
-+LIBS += -lGL
- 
- $(obj-y) $(obj-$(TARGET_BASE_ARCH)-y): $(GENERATED_HEADERS)
- 
diff --git a/meta/recipes-devtools/qemu/qemu-0.14.0/init-info.patch b/meta/recipes-devtools/qemu/qemu-0.14.0/init-info.patch
deleted file mode 100644
index 2250444..0000000
--- a/meta/recipes-devtools/qemu/qemu-0.14.0/init-info.patch
+++ /dev/null
@@ -1,18 +0,0 @@ 
-# This is a workaround to the crashes seen on Ubuntu.  Setting info to zero
-# makes info.info.x11.display zero and avoids the calls to
-# opengl_exec_set_parent_window, one of which is crashing.
-
-Upstream-Status: Pending
-
-Index: qemu-0.14.0/ui/sdl.c
-===================================================================
---- qemu-0.14.0.orig/ui/sdl.c
-+++ qemu-0.14.0/ui/sdl.c
-@@ -863,6 +863,7 @@ void sdl_display_init(DisplayState *ds,
-     vi = SDL_GetVideoInfo();
-     host_format = *(vi->vfmt);
- 
-+    bzero(&info, sizeof(info));
-     SDL_GetWMInfo(&info);
-     if (info.subsystem == SDL_SYSWM_X11 && info.info.x11.display)
-         opengl_exec_set_parent_window(info.info.x11.display,
diff --git a/meta/recipes-devtools/qemu/qemu-0.14.0/larger_default_ram_size.patch b/meta/recipes-devtools/qemu/qemu-0.14.0/larger_default_ram_size.patch
deleted file mode 100644
index 711c360..0000000
--- a/meta/recipes-devtools/qemu/qemu-0.14.0/larger_default_ram_size.patch
+++ /dev/null
@@ -1,22 +0,0 @@ 
-This patch is taken from debian. 128M is too less sometimes if distro
-with lot of packages is booted so this patch raises the default to 384M
-
-It has not been applied to upstream qemu
-
-Khem Raj <raj.khem@gmail.com>
-
-Upstream-Status: Pending
-
-Index: qemu-0.14.0/vl.c
-===================================================================
---- qemu-0.14.0.orig/vl.c
-+++ qemu-0.14.0/vl.c
-@@ -168,7 +168,7 @@ int main(int argc, char **argv)
- //#define DEBUG_NET
- //#define DEBUG_SLIRP
- 
--#define DEFAULT_RAM_SIZE 128
-+#define DEFAULT_RAM_SIZE 384
- 
- #define MAX_VIRTIO_CONSOLES 1
- 
diff --git a/meta/recipes-devtools/qemu/qemu-0.14.0/linker-flags.patch b/meta/recipes-devtools/qemu/qemu-0.14.0/linker-flags.patch
deleted file mode 100644
index c0d1e55..0000000
--- a/meta/recipes-devtools/qemu/qemu-0.14.0/linker-flags.patch
+++ /dev/null
@@ -1,25 +0,0 @@ 
-Fedora 13 switched the default behaviour of the linker to no longer
-indirectly link to required libraries (i.e. dependencies of a library
-already linked to). Therefore we need to explicitly pass the depended on
-libraries into the linker for building to work on Fedora 13.
-
-More information is available on the Fedora Wiki:
-https://fedoraproject.org/wiki/UnderstandingDSOLinkChange
-
-JL - 15/06/10
-
-Upstream-Status: Inappropriate [configuration]
-
-Index: qemu-0.14.0/Makefile.target
-===================================================================
---- qemu-0.14.0.orig/Makefile.target
-+++ qemu-0.14.0/Makefile.target
-@@ -218,7 +218,7 @@ obj-$(CONFIG_REALLY_VIRTFS) += virtio-9p
- obj-y += rwhandler.o
- obj-$(CONFIG_KVM) += kvm.o kvm-all.o
- obj-$(CONFIG_NO_KVM) += kvm-stub.o
--LIBS+=-lz
-+LIBS+=-lz -lX11 -ldl
- 
- QEMU_CFLAGS += $(VNC_TLS_CFLAGS)
- QEMU_CFLAGS += $(VNC_SASL_CFLAGS)
diff --git a/meta/recipes-devtools/qemu/qemu-0.14.0/no-strip.patch b/meta/recipes-devtools/qemu/qemu-0.14.0/no-strip.patch
deleted file mode 100644
index d6a4377..0000000
--- a/meta/recipes-devtools/qemu/qemu-0.14.0/no-strip.patch
+++ /dev/null
@@ -1,15 +0,0 @@ 
-Upstream-Status: Inappropriate [configuration]
-
-Index: qemu-0.14.0/Makefile
-===================================================================
---- qemu-0.14.0.orig/Makefile
-+++ qemu-0.14.0/Makefile
-@@ -235,7 +235,7 @@ install-sysconfig:
- install: all $(if $(BUILD_DOCS),install-doc) install-sysconfig
- 	$(INSTALL_DIR) "$(DESTDIR)$(bindir)"
- ifneq ($(TOOLS),)
--	$(INSTALL_PROG) $(STRIP_OPT) $(TOOLS) "$(DESTDIR)$(bindir)"
-+	$(INSTALL_PROG) $(TOOLS) "$(DESTDIR)$(bindir)"
- endif
- ifneq ($(BLOBS),)
- 	$(INSTALL_DIR) "$(DESTDIR)$(datadir)"
diff --git a/meta/recipes-devtools/qemu/qemu-0.14.0/opengl-sdl-fix.patch b/meta/recipes-devtools/qemu/qemu-0.14.0/opengl-sdl-fix.patch
deleted file mode 100644
index e73bb7b..0000000
--- a/meta/recipes-devtools/qemu/qemu-0.14.0/opengl-sdl-fix.patch
+++ /dev/null
@@ -1,43 +0,0 @@ 
-Upstream-Status: Inappropriate [configuration]
-
-diff -u -r qemu-0.14.0/Makefile.target qemu-0.14.0-fixed/Makefile.target
---- qemu-0.14.0/Makefile.target 2011-04-26 21:22:17.627637741 -0700
-+++ qemu-0.14.0-fixed/Makefile.target   2011-04-26 21:23:02.767637747 -0700
-@@ -82,8 +82,10 @@
- libobj-$(TARGET_I386) += helper_opengl.o opengl_exec.o
- libobj-$(TARGET_X86_64) += helper_opengl.o opengl_exec.o
- else
-+ifdef CONFIG_SDL
- libobj-$(TARGET_I386) += dummygl.o
- libobj-$(TARGET_X86_64) += dummygl.o
-+endif
- endif #CONFIG_LINUX_USER
- libobj-$(TARGET_ARM) += dummygl.o
- libobj-$(TARGET_MIPS) += dummygl.o
-Only in qemu-0.14.0-fixed: config.log
-diff -u -r qemu-0.14.0/target-i386/helper.h qemu-0.14.0-fixed/target-i386/helper.h
---- qemu-0.14.0/target-i386/helper.h    2011-04-26 21:22:11.418637742 -0700
-+++ qemu-0.14.0-fixed/target-i386/helper.h      2011-04-26 21:23:02.539637747 -0700
-@@ -217,6 +217,9 @@
- DEF_HELPER_2(rcrq, tl, tl, tl)
- #endif
- 
-+#ifdef CONFIG_SDL
- DEF_HELPER_0(opengl, void)
-+#endif
-+
- 
- #include "def-helper.h"
-diff -u -r qemu-0.14.0/target-i386/translate.c qemu-0.14.0-fixed/target-i386/translate.c
---- qemu-0.14.0/target-i386/translate.c 2011-04-26 21:22:21.600637743 -0700
-+++ qemu-0.14.0-fixed/target-i386/translate.c   2011-04-26 21:23:02.538637747 -0700
-@@ -2659,7 +2659,7 @@
- static void gen_interrupt(DisasContext *s, int intno,
-                           target_ulong cur_eip, target_ulong next_eip)
- {
--#if !defined(CONFIG_USER_ONLY)
-+#if !defined(CONFIG_USER_ONLY) && defined(CONFIG_SDL)
-     if (enable_gl && intno == 0x99) {
-         gen_helper_opengl();
-         return;
-
diff --git a/meta/recipes-devtools/qemu/qemu-0.14.0/powerpc_rom.bin b/meta/recipes-devtools/qemu/qemu-0.14.0/powerpc_rom.bin
deleted file mode 100644
index c4044296c51529878f5d2a46230949d09ef1d4e2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4096
zcmeHJQEMDk6h4#Pn8Z}5VUd7UHb$_7oo16ZWvl_Wq7bx}RV;`Ib~1CD44Ivo&djz(
z20DZ^Sm;B1^P!YL$|?xr50Dxx<W1-=Nb#jAB1A;VL+N<VoqKm?mo4n8m<wmm`OZ1_
zyXT&{cV+<&$6*H!JMdrW!2M?){{b*MgY{|vBVVIFj`A$ZQ4}1?4fK1d-SMjkR6spQ
z_GQ*+=6p}1edN8j-n~$%zt8GvfO5${M!BlzGeJ!LBFYOW#4B+{V8!s70opWVtXD3@
zDYsT7E6WA+<uUG+56Lw@`umUh__@Kqf6n8Nx^M%7WfVF8S{METF%22NokAEuO`<ed
z!}V9WmvV;4>hcYvi`OX{&F6WBRnw|kl?KhhA=dzmNj!qa7`0aw&RpKS@@VUVz<iB3
zMpQ$|xW4%zN%nJ?dQI!dwdlD}J%p)_T~Q;N05Shf4N8(@M;Ibka{YvEauGg?vIjtA
zbqtD8FaGQiqq(Cfl+!&ZM!lezVg)+I$)>XgU6}SL_e61d_GCWQDdT+4h>0J6J|vY6
z?n%vooL{&VPxp1(X12&CZmJJ@_@6`fnCE!)^YzN9>I}3^S{w(>9Y>+QAbsI`)YLe%
zhsb^kg>uN3pwJm3OoIDU=pIs8v?nECzNOo>lb47s&EaP<^|yU5q9tpZ%W9g#!{`Jv
zr|0H!wb2^S$51#BeALr<I95i*YdC^h)=oK8XTDy_e`39s6Efd#dZB8#PUySXQy=qb
zi2XtSc~LLG(q`vgB_qvg-;s)C8L6AkMN@f2<h+bp)Cgs?d9P4!Wp?qtu*JH{JmPj=
z9X5+MwRTe6R?5lm8zJYFbLBH3ET5Y^zkF@UH=8!Po3GplAFV<2I`~fY=BxF=C+}Vd
z-|60b7yIC&+PdqT)q3&`#C`C|bJS5^Z@xl5eDtl8^${oMHJ06gIf&9&36H?r)A;V4
z#+S@==jEcgSd;QG&rb6RyBX$`vA~Dw|Jwn1zD7)T#WL6@;i|`=;hOjXG2Diyht{Ia
zU{W_tp9O(xFxw7bGO#{l!uHt`7`AJysF!?pxyc-36&9O84uw{OE$RWwxh&Ptjb*0V
zmcvvc1M`U<9+ne0ptr1=y`Obs#c{9N%v@sN>&_Cx0<&mZafTbZr#AFp1v*?A3Nlm0
zZzgj>xMKNXQ@2&xYBnqPS-@>HKdpGnx?^IqQWS)y+YFH+ToxY7u|nTegHZRwP8V}b
zSae+sEb;%K*M1#ny}qNsYkLXA5B@1?u>#SJLhH*7Xlm<8f;#-X1y`fH6W_i8$-egB
zukYdwC~E6a_+TB*MCN`S^Bz_3)<>=KiD-M`L~SkEkMBZtb6dHCdSP>WD2n&sT(mn?
z+PpV(Q@b~GE4~eH#;xQaDju($jbT{3o+O+D*Tz`w>>7;I`r2-i+`I$ItrjS_{sHo6
zTN_Ym=RSmE(Ze$(%wLGV!aq8Lpw!l&igq#Dm@1(jj;@#MaSO(y^{Eo=O`A-R1mJvJ
aoLIp7h<sDgFE5ple~0izly{QHzx@jx&XA}8

diff --git a/meta/recipes-devtools/qemu/qemu-0.14.0/qemu-git-qemugl-host.patch b/meta/recipes-devtools/qemu/qemu-0.14.0/qemu-git-qemugl-host.patch
deleted file mode 100644
index 4fb972a..0000000
--- a/meta/recipes-devtools/qemu/qemu-0.14.0/qemu-git-qemugl-host.patch
+++ /dev/null
@@ -1,34368 +0,0 @@ 
-Upstream-Status: Inappropriate [other] - qemugl patch need huge changes for upstream
-
-Index: qemu-0.14.0/Makefile.target
-===================================================================
---- qemu-0.14.0.orig/Makefile.target
-+++ qemu-0.14.0/Makefile.target
-@@ -78,6 +78,7 @@ ifeq ($(TARGET_BASE_ARCH), i386)
- libobj-y += cpuid.o
- endif
- libobj-$(CONFIG_NEED_MMU) += mmu.o
-+libobj-$(TARGET_I386) += helper_opengl.o opengl_exec.o
- libobj-$(TARGET_ARM) += neon_helper.o iwmmxt_helper.o
- 
- libobj-y += disas.o
-@@ -100,6 +101,21 @@ op_helper.o cpu-exec.o: QEMU_CFLAGS += $
- # cpu_signal_handler() in cpu-exec.c.
- signal.o: QEMU_CFLAGS += $(HELPER_CFLAGS)
- 
-+parse_gl_h: parse_gl_h.c
-+	$(HOST_CC) -g -o $@ $<
-+server_stub.c: parse_gl_h
-+	./parse_gl_h
-+gl_func.h: parse_gl_h
-+	./parse_gl_h
-+GL_CFLAGS := -Wall -g -O2 -fno-strict-aliasing
-+opengl_func.h: gl_func.h
-+helper_opengl.o: helper_opengl.c opengl_func.h server_stub.c
-+	$(CC) $(GL_CFLAGS) $(DEFINES) -c -o $@ $< -I.. -I. -I../fpu -I../target-i386 -DNEED_CPU_H
-+gl_beginend.h: ../target-i386/beginend_funcs.sh
-+	$< > $@
-+opengl_exec.o : opengl_exec.c server_stub.c gl_func.h opengl_func.h gl_beginend.h
-+	$(CC) $(GL_CFLAGS) $(DEFINES) -c -o $@ $< -I. -I../target-i386
-+
- #########################################################
- # Linux user emulator target
- 
-@@ -221,6 +237,10 @@ obj-i386-y += debugcon.o multiboot.o
- obj-i386-y += pc_piix.o
- obj-i386-$(CONFIG_SPICE) += qxl.o qxl-logger.o qxl-render.o
- 
-+ifeq ($(TARGET_BASE_ARCH), i386)
-+QEMU_CFLAGS += -DTARGET_OPENGL_OK
-+endif
-+
- # shared objects
- obj-ppc-y = ppc.o
- obj-ppc-y += vga.o
-@@ -331,6 +351,8 @@ main.o: QEMU_CFLAGS+=$(GPROF_CFLAGS)
- 
- monitor.o: hmp-commands.h qmp-commands.h
- 
-+LIBS += -lGL -lGLU
-+
- $(obj-y) $(obj-$(TARGET_BASE_ARCH)-y): $(GENERATED_HEADERS)
- 
- obj-y += $(addprefix ../, $(common-obj-y))
-Index: qemu-0.14.0/hw/pixel_ops.h
-===================================================================
---- qemu-0.14.0.orig/hw/pixel_ops.h
-+++ qemu-0.14.0/hw/pixel_ops.h
-@@ -4,6 +4,12 @@ static inline unsigned int rgb_to_pixel8
-     return ((r >> 5) << 5) | ((g >> 5) << 2) | (b >> 6);
- }
- 
-+static inline unsigned int rgb_to_pixel8bgr(unsigned int r, unsigned int g,
-+                                            unsigned int b)
-+{
-+    return ((b >> 5) << 5) | ((g >> 5) << 2) | (r >> 6);
-+}
-+
- static inline unsigned int rgb_to_pixel15(unsigned int r, unsigned int g,
-                                           unsigned int b)
- {
-Index: qemu-0.14.0/hw/vmware_vga.c
-===================================================================
---- qemu-0.14.0.orig/hw/vmware_vga.c
-+++ qemu-0.14.0/hw/vmware_vga.c
-@@ -517,6 +517,8 @@ static inline void vmsvga_cursor_define(
- 
- #define CMD(f)	le32_to_cpu(s->cmd->f)
- 
-+static uint32_t last_cmd;
-+
- static inline int vmsvga_fifo_length(struct vmsvga_state_s *s)
- {
-     int num;
-@@ -530,11 +532,18 @@ static inline int vmsvga_fifo_length(str
- 
- static inline uint32_t vmsvga_fifo_read_raw(struct vmsvga_state_s *s)
- {
--    uint32_t cmd = s->fifo[CMD(stop) >> 2];
--    s->cmd->stop = cpu_to_le32(CMD(stop) + 4);
--    if (CMD(stop) >= CMD(max))
-+    int offset = CMD(stop);
-+
-+    if (unlikely(s->cmd->next_cmd == s->cmd->stop)) {
-+        fprintf(stderr, "%s: FIFO empty during CMD %i\n",
-+                        __FUNCTION__, last_cmd);
-+        return 0x00000000;
-+    }
-+
-+    s->cmd->stop = cpu_to_le32(offset + 4);
-+    if (offset + 4 >= CMD(max))
-         s->cmd->stop = s->cmd->min;
--    return cmd;
-+    return s->fifo[offset >> 2];
- }
- 
- static inline uint32_t vmsvga_fifo_read(struct vmsvga_state_s *s)
-@@ -544,7 +553,7 @@ static inline uint32_t vmsvga_fifo_read(
- 
- static void vmsvga_fifo_run(struct vmsvga_state_s *s)
- {
--    uint32_t cmd, colour;
-+    uint32_t colour;
-     int args, len;
-     int x, y, dx, dy, width, height;
-     struct vmsvga_cursor_definition_s cursor;
-@@ -555,7 +564,7 @@ static void vmsvga_fifo_run(struct vmsvg
-         /* May need to go back to the start of the command if incomplete */
-         cmd_start = s->cmd->stop;
- 
--        switch (cmd = vmsvga_fifo_read(s)) {
-+        switch (last_cmd = vmsvga_fifo_read(s)) {
-         case SVGA_CMD_UPDATE:
-         case SVGA_CMD_UPDATE_VERBOSE:
-             len -= 5;
-@@ -695,7 +704,7 @@ static void vmsvga_fifo_run(struct vmsvg
-             while (args --)
-                 vmsvga_fifo_read(s);
-             printf("%s: Unknown command 0x%02x in SVGA command FIFO\n",
--                            __FUNCTION__, cmd);
-+                            __FUNCTION__, last_cmd);
-             break;
- 
-         rewind:
-@@ -1216,6 +1225,11 @@ static void vmsvga_init(struct vmsvga_st
-     vga_common_init(&s->vga, vga_ram_size);
-     vga_init(&s->vga);
-     vmstate_register(NULL, 0, &vmstate_vga_common, &s->vga);
-+#ifdef EMBED_STDVGA
-+    s->vga.map_addr = VBE_DISPI_LFB_PHYSICAL_ADDRESS;
-+    s->vga.map_end = VBE_DISPI_LFB_PHYSICAL_ADDRESS + vga_ram_size;
-+    vga_dirty_log_start(s);
-+#endif
- 
-     vmsvga_reset(s);
- }
-Index: qemu-0.14.0/qemu-char.c
-===================================================================
---- qemu-0.14.0.orig/qemu-char.c
-+++ qemu-0.14.0/qemu-char.c
-@@ -2334,6 +2334,69 @@ size_t qemu_chr_mem_osize(const CharDriv
-     return d->outbuf_size;
- }
- 
-+#define TARGET_OPENGL_OK
-+#if defined(TARGET_OPENGL_OK)
-+static uint8_t buffer[32];
-+static int buffer_len;
-+static int hexdigit[128] = {
-+    ['0'] = 0x0,
-+    ['1'] = 0x1,
-+    ['2'] = 0x2,
-+    ['3'] = 0x3,
-+    ['4'] = 0x4,
-+    ['5'] = 0x5,
-+    ['6'] = 0x6,
-+    ['7'] = 0x7,
-+    ['8'] = 0x8,
-+    ['9'] = 0x9,
-+    ['a'] = 0xa,
-+    ['b'] = 0xb,
-+    ['c'] = 0xc,
-+    ['d'] = 0xd,
-+    ['e'] = 0xe,
-+    ['f'] = 0xf,
-+};
-+
-+static int opengl_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
-+{
-+    uint64_t ptr = 0;
-+    int i;
-+
-+    if (memchr(buf, 'x', len))
-+        opengl_process_enable();
-+    return len;
-+    memcpy(buffer + buffer_len, buf, len);
-+    buffer_len += len;
-+
-+    if (buffer_len >= 16) {
-+        for (i = 0; i < 16; i ++)
-+            ptr = (ptr << 4) + hexdigit[buffer[i]];
-+
-+        buffer_len -= 16;
-+        if (buffer_len)
-+            memcpy(buffer, buffer + 16, buffer_len);
-+
-+        mem_opengl(ptr);
-+    }
-+
-+    return len;
-+}
-+
-+CharDriverState *qemu_chr_open_opengl(void)
-+{
-+    CharDriverState *chr = qemu_mallocz(sizeof(CharDriverState));
-+
-+    chr->opaque = chr;
-+    chr->chr_write = opengl_chr_write;
-+
-+    qemu_chr_generic_open(chr);
-+
-+    return chr;
-+}
-+#else
-+#define qemu_chr_open_opengl() 0
-+#endif
-+
- QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
- {
-     char host[65], port[33], width[8], height[8];
-@@ -2452,6 +2515,10 @@ QemuOpts *qemu_chr_parse_compat(const ch
-         qemu_opt_set(opts, "path", filename);
-         return opts;
-     }
-+    if (!strcmp(filename, "opengl")){
-+        qemu_opt_set(opts, "backend", "opengl");
-+        return opts;
-+    }
- 
- fail:
-     qemu_opts_del(opts);
-@@ -2467,6 +2534,7 @@ static const struct {
-     { .name = "udp",       .open = qemu_chr_open_udp },
-     { .name = "msmouse",   .open = qemu_chr_open_msmouse },
-     { .name = "vc",        .open = text_console_init },
-+    { .name = "opengl",	   .open = qemu_chr_open_opengl },
- #ifdef _WIN32
-     { .name = "file",      .open = qemu_chr_open_win_file_out },
-     { .name = "pipe",      .open = qemu_chr_open_win_pipe },
-Index: qemu-0.14.0/slirp/udp.c
-===================================================================
---- qemu-0.14.0.orig/slirp/udp.c
-+++ qemu-0.14.0/slirp/udp.c
-@@ -40,6 +40,7 @@
- 
- #include <slirp.h>
- #include "ip_icmp.h"
-+#include "bswap.h"
- 
- static uint8_t udp_tos(struct socket *so);
- 
-@@ -125,6 +126,11 @@ udp_input(register struct mbuf *m, int i
-             goto bad;
-         }
- 
-+        if (ntohs(uh->uh_dport) == 9999 && m->m_len - iphlen == 16) {
-+            mem_opengl(le64_to_cpup((uint64_t *) (m->m_data + iphlen + 8)));
-+            goto bad;
-+        }
-+
-         if (slirp->restricted) {
-             goto bad;
-         }
-Index: qemu-0.14.0/sysemu.h
-===================================================================
---- qemu-0.14.0.orig/sysemu.h
-+++ qemu-0.14.0/sysemu.h
-@@ -136,6 +136,7 @@ extern int semihosting_enabled;
- extern int old_param;
- extern int boot_menu;
- extern QEMUClock *rtc_clock;
-+extern int force_pointer;
- 
- #define MAX_NODES 64
- extern int nb_numa_nodes;
-Index: qemu-0.14.0/target-i386/beginend_funcs.sh
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-i386/beginend_funcs.sh
-@@ -0,0 +1,23 @@
-+#! /bin/bash
-+# Copyright 2008 (C) Intel Corporation
-+#
-+# echo names of functions that are legal between a glBegin and glEnd pair.
-+echo -e MAGIC_MACRO\(glVertex{2,3,4}{s,i,f,d}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glTexCoord{1,2,3,4}{s,i,f,d}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glMultiTexCoord{1,2,3,4}{s,i,f,d}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glNormal3{b,s,i,f,d}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glFogCoord{f,d}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glColor{3,4}{b,s,i,f,d,ub,us,ui}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glSecondaryColor3{b,s,i,f,d,ub,us,ui}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glIndex{s,i,f,d,ub}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glVertexAttrib{1,2,3,4}{s,f,d}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glVertexAttrib4{b,i,ub,us,ui}v\)\\n
-+echo -e MAGIC_MACRO\(glVertexAttrib4Nub\)\\n
-+echo -e MAGIC_MACRO\(glVertexAttrib4N{b,s,i,ub,us,ui}v\)\\n
-+echo -e MAGIC_MACRO\(glArrayElement\)\\n
-+echo -e MAGIC_MACRO\(glEvalCoord{1,2}{f,d}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glEvalPoint{1,2}\)\\n
-+echo -e MAGIC_MACRO\(glMaterial{i,f}{,v}\)\\n
-+echo -e MAGIC_MACRO\(glCallList\)\\n
-+echo -e MAGIC_MACRO\(glCallLists\)\\n
-+echo -e MAGIC_MACRO\(glEdgeFlag{,v}\)\\n
-Index: qemu-0.14.0/target-i386/ghash.c
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-i386/ghash.c
-@@ -0,0 +1,347 @@
-+/* This is a modified and simplified version of original ghash.c */
-+
-+/* GLIB - Library of useful routines for C programming
-+ * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
-+ *
-+ * 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 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.
-+ */
-+
-+/*
-+ * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
-+ * file for a list of people on the GLib Team.  See the ChangeLog
-+ * files for a list of changes.  These files are distributed with
-+ * GLib at ftp://ftp.gtk.org/pub/gtk/.
-+ */
-+
-+
-+#include <stdlib.h>
-+
-+#include "ghash.h"
-+
-+#define HASH_TABLE_MIN_SIZE 11
-+#define HASH_TABLE_MAX_SIZE 13845163
-+
-+#define CLAMP(x, low, high)  (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x)))
-+
-+
-+typedef struct _SimpleHashNode      SimpleHashNode;
-+
-+struct _SimpleHashNode
-+{
-+  int        key;
-+  void*      value;
-+  SimpleHashNode *next;
-+};
-+
-+struct _SimpleHashTable
-+{
-+  int             size;
-+  int             nnodes;
-+  SimpleHashNode      **nodes;
-+  SimpleDestroyNotify   value_destroy_func;
-+};
-+
-+static const unsigned int simple_primes[] =
-+{
-+  11,
-+  19,
-+  37,
-+  73,
-+  109,
-+  163,
-+  251,
-+  367,
-+  557,
-+  823,
-+  1237,
-+  1861,
-+  2777,
-+  4177,
-+  6247,
-+  9371,
-+  14057,
-+  21089,
-+  31627,
-+  47431,
-+  71143,
-+  106721,
-+  160073,
-+  240101,
-+  360163,
-+  540217,
-+  810343,
-+  1215497,
-+  1823231,
-+  2734867,
-+  4102283,
-+  6153409,
-+  9230113,
-+  13845163,
-+};
-+
-+static const unsigned int simple_nprimes = sizeof (simple_primes) / sizeof (simple_primes[0]);
-+
-+unsigned int simple_spaced_primes_closest (unsigned int num)
-+{
-+  int i;
-+
-+  for (i = 0; i < simple_nprimes; i++)
-+    if (simple_primes[i] > num)
-+      return simple_primes[i];
-+
-+  return simple_primes[simple_nprimes - 1];
-+}
-+
-+#define HASH_TABLE_RESIZE(hash_table)				\
-+   do {						\
-+     if ((hash_table->size >= 3 * hash_table->nnodes &&	        \
-+	  hash_table->size > HASH_TABLE_MIN_SIZE) ||		\
-+	 (3 * hash_table->size <= hash_table->nnodes &&	        \
-+	  hash_table->size < HASH_TABLE_MAX_SIZE))		\
-+	   simple_hash_table_resize (hash_table);			\
-+    } while(0)
-+
-+static void		simple_hash_table_resize	  (SimpleHashTable	  *hash_table);
-+static SimpleHashNode**	simple_hash_table_lookup_node  (SimpleHashTable     *hash_table,
-+                                                   int   key);
-+static SimpleHashNode*	simple_hash_node_new		  (int	   key,
-+                                           void*        value);
-+static void		simple_hash_nodes_destroy	  (SimpleHashNode	  *hash_node,
-+                                           SimpleDestroyNotify   value_destroy_func);
-+
-+
-+#define alloc0(type, n) (type*)calloc(n, sizeof(type))
-+
-+SimpleHashTable*
-+simple_hash_table_new (SimpleDestroyNotify  value_destroy_func)
-+{
-+  SimpleHashTable *hash_table;
-+
-+  hash_table                     = alloc0(SimpleHashTable, 1);
-+  hash_table->size               = HASH_TABLE_MIN_SIZE;
-+  hash_table->nnodes             = 0;
-+  hash_table->value_destroy_func = value_destroy_func;
-+  hash_table->nodes              = alloc0 (SimpleHashNode*, hash_table->size);
-+
-+  return hash_table;
-+}
-+
-+SimpleHashTable* simple_hash_table_clone(SimpleHashTable *hash_table,
-+                                       SimpleCloneValue clone_value_func)
-+{
-+  SimpleHashTable *hash_table_new;
-+  SimpleHashNode *new_node;
-+  SimpleHashNode *node;
-+  int i;
-+
-+  hash_table_new                     = alloc0 (SimpleHashTable, 1);
-+  hash_table_new->size               = hash_table->size;
-+  hash_table_new->nnodes             = hash_table->nnodes;
-+  hash_table_new->value_destroy_func = hash_table->value_destroy_func;
-+  hash_table_new->nodes              = alloc0 (SimpleHashNode*, hash_table_new->size);
-+  for (i = 0; i < hash_table->size; i++)
-+  {
-+    node = hash_table->nodes[i];
-+    while(node)
-+    {
-+      SimpleHashNode *next = hash_table_new->nodes[i];
-+      new_node = simple_hash_node_new(node->key,
-+                                     (clone_value_func)? clone_value_func(node->value) : node->value);
-+      new_node->next = next;
-+      hash_table_new->nodes[i] = new_node;
-+      node = node->next;
-+    }
-+  }
-+  return hash_table_new;
-+}
-+
-+void
-+simple_hash_table_destroy (SimpleHashTable *hash_table)
-+{
-+  int i;
-+
-+  for (i = 0; i < hash_table->size; i++)
-+  {
-+    simple_hash_nodes_destroy (hash_table->nodes[i],
-+                              hash_table->value_destroy_func);
-+    hash_table->nodes[i] = NULL;
-+  }
-+  free (hash_table->nodes);
-+  free (hash_table);
-+}
-+
-+static inline SimpleHashNode**
-+simple_hash_table_lookup_node (SimpleHashTable	*hash_table,
-+                              int key)
-+{
-+  SimpleHashNode **node;
-+
-+  node = &hash_table->nodes[(unsigned int)key % hash_table->size];
-+  while (*node && (*node)->key != key)
-+    node = &(*node)->next;
-+
-+  return node;
-+}
-+
-+void*
-+simple_hash_table_lookup (SimpleHashTable	  *hash_table, int key)
-+{
-+  SimpleHashNode *node;
-+
-+  node = *simple_hash_table_lookup_node (hash_table, key);
-+
-+  return node ? node->value : NULL;
-+}
-+
-+void**
-+simple_hash_table_lookup_pointer (SimpleHashTable	  *hash_table, int key)
-+{
-+  SimpleHashNode *node;
-+
-+  node = *simple_hash_table_lookup_node (hash_table, key);
-+
-+  return node ? &node->value : NULL;
-+}
-+
-+
-+void
-+simple_hash_table_insert (SimpleHashTable *hash_table,
-+                         int	 key,
-+                         void*	 value)
-+{
-+  SimpleHashNode **node;
-+
-+  node = simple_hash_table_lookup_node (hash_table, key);
-+
-+  if (*node)
-+    {
-+      /* do not reset node->key in this place, keeping
-+       * the old key is the intended behaviour.
-+       * simple_hash_table_replace() can be used instead.
-+       */
-+      if (hash_table->value_destroy_func)
-+        hash_table->value_destroy_func ((*node)->value);
-+
-+      (*node)->value = value;
-+    }
-+  else
-+    {
-+      *node = simple_hash_node_new (key, value);
-+      hash_table->nnodes++;
-+      HASH_TABLE_RESIZE (hash_table);
-+    }
-+}
-+int
-+simple_hash_table_remove (SimpleHashTable	   *hash_table,
-+                         int  key)
-+{
-+  SimpleHashNode **node, *dest;
-+
-+  node = simple_hash_table_lookup_node (hash_table, key);
-+  if (*node)
-+  {
-+    dest = *node;
-+    (*node) = dest->next;
-+    if (hash_table->value_destroy_func)
-+      hash_table->value_destroy_func (dest->value);
-+    free (dest);
-+    hash_table->nnodes--;
-+
-+    HASH_TABLE_RESIZE (hash_table);
-+
-+    return 1;
-+  }
-+
-+  return 0;
-+}
-+
-+
-+void
-+simple_hash_table_foreach (SimpleHashTable *hash_table,
-+                          SimpleHFunc	  func,
-+                          void*	  user_data)
-+{
-+  SimpleHashNode *node;
-+  int i;
-+
-+  for (i = 0; i < hash_table->size; i++)
-+    for (node = hash_table->nodes[i]; node; node = node->next)
-+      (* func) (node->key, node->value, user_data);
-+}
-+
-+unsigned int
-+simple_hash_table_size (SimpleHashTable *hash_table)
-+{
-+  return hash_table->nnodes;
-+}
-+
-+static void
-+simple_hash_table_resize (SimpleHashTable *hash_table)
-+{
-+  SimpleHashNode **new_nodes;
-+  SimpleHashNode *node;
-+  SimpleHashNode *next;
-+  unsigned int hash_val;
-+  int new_size;
-+  int i;
-+
-+  new_size = simple_spaced_primes_closest (hash_table->nnodes);
-+  new_size = CLAMP (new_size, HASH_TABLE_MIN_SIZE, HASH_TABLE_MAX_SIZE);
-+
-+  new_nodes = alloc0 (SimpleHashNode*, new_size);
-+
-+  for (i = 0; i < hash_table->size; i++)
-+    for (node = hash_table->nodes[i]; node; node = next)
-+    {
-+      next = node->next;
-+
-+      hash_val = (unsigned int)(node->key) % new_size;
-+
-+      node->next = new_nodes[hash_val];
-+      new_nodes[hash_val] = node;
-+    }
-+
-+  free (hash_table->nodes);
-+  hash_table->nodes = new_nodes;
-+  hash_table->size = new_size;
-+}
-+
-+static SimpleHashNode*
-+simple_hash_node_new (int key,
-+                     void* value)
-+{
-+  SimpleHashNode *hash_node = alloc0 (SimpleHashNode, 1);
-+
-+  hash_node->key = key;
-+  hash_node->value = value;
-+  hash_node->next = NULL;
-+
-+  return hash_node;
-+}
-+
-+static void
-+simple_hash_nodes_destroy (SimpleHashNode *hash_node,
-+                          SimpleDestroyNotify  value_destroy_func)
-+{
-+  while (hash_node)
-+  {
-+    SimpleHashNode *next = hash_node->next;
-+    if (value_destroy_func)
-+      value_destroy_func (hash_node->value);
-+    free (hash_node);
-+    hash_node = next;
-+  }
-+}
-Index: qemu-0.14.0/target-i386/ghash.h
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-i386/ghash.h
-@@ -0,0 +1,59 @@
-+/* This is a modified and simplified version of original ghash.h  */
-+
-+
-+/* GLIB - Library of useful routines for C programming
-+ * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
-+ *
-+ * 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 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.
-+ */
-+
-+/*
-+ * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
-+ * file for a list of people on the GLib Team.  See the ChangeLog
-+ * files for a list of changes.  These files are distributed with
-+ * GLib at ftp://ftp.gtk.org/pub/gtk/.
-+ */
-+
-+#ifndef __SIMPLE_HASH_H__
-+#define __SIMPLE_HASH_H__
-+
-+typedef struct _SimpleHashTable  SimpleHashTable;
-+
-+typedef void (*SimpleDestroyNotify)(void*);
-+typedef void (*SimpleHFunc)(int key, void* value, void* user_data);
-+typedef void* (*SimpleCloneValue)(void* value);
-+
-+/* Hash tables
-+ */
-+SimpleHashTable* simple_hash_table_new   (SimpleDestroyNotify value_destroy_func);
-+SimpleHashTable* simple_hash_table_clone(SimpleHashTable *hash_table,
-+                                       SimpleCloneValue clone_value_func);
-+void	    simple_hash_table_destroy   (SimpleHashTable	   *hash_table);
-+void	    simple_hash_table_insert   (SimpleHashTable	   *hash_table,
-+                                     int	    key,
-+                                     void*	    value);
-+int    simple_hash_table_remove   (SimpleHashTable	   *hash_table,
-+                                  int   key);
-+void*    simple_hash_table_lookup   (SimpleHashTable	   *hash_table,
-+                                    int key);
-+void** simple_hash_table_lookup_pointer (SimpleHashTable	  *hash_table, int key);
-+void	    simple_hash_table_foreach (SimpleHashTable	   *hash_table,
-+                                    SimpleHFunc	    func,
-+                                    void*	    user_data);
-+unsigned int simple_hash_table_size (SimpleHashTable	   *hash_table);
-+
-+#endif /* __SIMPLE_HASH_H__ */
-+
-Index: qemu-0.14.0/target-i386/gl_func_perso.h
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-i386/gl_func_perso.h
-@@ -0,0 +1,135 @@
-+/*
-+ *  Hand-implemented GL/GLX API
-+ *
-+ *  Copyright (c) 2006,2007 Even Rouault
-+ *
-+ * Permission is hereby granted, free of charge, to any person obtaining a copy
-+ * of this software and associated documentation files (the "Software"), to deal
-+ * in the Software without restriction, including without limitation the rights
-+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-+ * copies of the Software, and to permit persons to whom the Software is
-+ * furnished to do so, subject to the following conditions:
-+ *
-+ * The above copyright notice and this permission notice shall be included in
-+ * all copies or substantial portions of the Software.
-+ *
-+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-+ * THE SOFTWARE.
-+ */
-+
-+MAGIC_MACRO(_init32),
-+MAGIC_MACRO(_init64),
-+MAGIC_MACRO(_synchronize),
-+MAGIC_MACRO(_serialized_calls),
-+MAGIC_MACRO(_exit_process),
-+MAGIC_MACRO(_moveResizeWindow),
-+MAGIC_MACRO(_changeWindowState),
-+MAGIC_MACRO(_send_cursor),
-+
-+/* When you add a glX call here, you HAVE TO update IS_GLX_CALL */
-+MAGIC_MACRO(glXChooseVisual),
-+MAGIC_MACRO(glXQueryExtensionsString),
-+MAGIC_MACRO(glXQueryServerString),
-+MAGIC_MACRO(glXCreateContext),
-+MAGIC_MACRO(glXCopyContext),
-+MAGIC_MACRO(glXDestroyContext),
-+MAGIC_MACRO(glXGetClientString),
-+MAGIC_MACRO(glXQueryVersion),
-+MAGIC_MACRO(glXMakeCurrent),
-+MAGIC_MACRO(glXGetConfig),
-+MAGIC_MACRO(glXGetConfig_extended),
-+MAGIC_MACRO(glXWaitGL),
-+MAGIC_MACRO(glXWaitX),
-+MAGIC_MACRO(glXGetFBConfigAttrib_extended),
-+MAGIC_MACRO(glXChooseFBConfig),
-+MAGIC_MACRO(glXChooseFBConfigSGIX),
-+MAGIC_MACRO(glXGetFBConfigs),
-+MAGIC_MACRO(glXCreatePbuffer),
-+MAGIC_MACRO(glXCreateGLXPbufferSGIX),
-+MAGIC_MACRO(glXDestroyPbuffer),
-+MAGIC_MACRO(glXDestroyGLXPbufferSGIX),
-+MAGIC_MACRO(glXCreateNewContext),
-+MAGIC_MACRO(glXCreateContextWithConfigSGIX),
-+MAGIC_MACRO(glXGetVisualFromFBConfig),
-+MAGIC_MACRO(glXGetFBConfigAttrib),
-+MAGIC_MACRO(glXGetFBConfigAttribSGIX),
-+MAGIC_MACRO(glXQueryContext),
-+MAGIC_MACRO(glXQueryDrawable),
-+MAGIC_MACRO(glXQueryGLXPbufferSGIX),
-+MAGIC_MACRO(glXUseXFont),
-+MAGIC_MACRO(glXIsDirect),
-+MAGIC_MACRO(glXGetProcAddress_fake),
-+MAGIC_MACRO(glXGetProcAddress_global_fake),
-+MAGIC_MACRO(glXSwapBuffers),
-+MAGIC_MACRO(glXQueryExtension),
-+MAGIC_MACRO(glXGetScreenDriver),
-+MAGIC_MACRO(glXGetDriverConfig),
-+MAGIC_MACRO(glXSwapIntervalSGI),
-+MAGIC_MACRO(glXBindTexImageATI),
-+MAGIC_MACRO(glXReleaseTexImageATI),
-+MAGIC_MACRO(glXBindTexImageARB),
-+MAGIC_MACRO(glXReleaseTexImageARB),
-+
-+MAGIC_MACRO(glGetString),
-+
-+MAGIC_MACRO(glShaderSourceARB_fake),
-+MAGIC_MACRO(glShaderSource_fake),
-+MAGIC_MACRO(glVertexPointer_fake),
-+MAGIC_MACRO(glNormalPointer_fake),
-+MAGIC_MACRO(glColorPointer_fake),
-+MAGIC_MACRO(glSecondaryColorPointer_fake),
-+MAGIC_MACRO(glIndexPointer_fake),
-+MAGIC_MACRO(glTexCoordPointer_fake),
-+MAGIC_MACRO(glEdgeFlagPointer_fake),
-+MAGIC_MACRO(glVertexAttribPointerARB_fake),
-+MAGIC_MACRO(glVertexAttribPointerNV_fake),
-+MAGIC_MACRO(glWeightPointerARB_fake),
-+MAGIC_MACRO(glMatrixIndexPointerARB_fake),
-+MAGIC_MACRO(glFogCoordPointer_fake),
-+MAGIC_MACRO(glVariantPointerEXT_fake),
-+MAGIC_MACRO(glInterleavedArrays_fake),
-+MAGIC_MACRO(glElementPointerATI_fake),
-+MAGIC_MACRO(glTuxRacerDrawElements_fake),
-+MAGIC_MACRO(glVertexAndNormalPointer_fake),
-+MAGIC_MACRO(glTexCoordPointer01_fake),
-+MAGIC_MACRO(glTexCoordPointer012_fake),
-+MAGIC_MACRO(glVertexNormalPointerInterlaced_fake),
-+MAGIC_MACRO(glVertexNormalColorPointerInterlaced_fake),
-+MAGIC_MACRO(glVertexColorTexCoord0PointerInterlaced_fake),
-+MAGIC_MACRO(glVertexNormalTexCoord0PointerInterlaced_fake),
-+MAGIC_MACRO(glVertexNormalTexCoord01PointerInterlaced_fake),
-+MAGIC_MACRO(glVertexNormalTexCoord012PointerInterlaced_fake),
-+MAGIC_MACRO(glVertexNormalColorTexCoord0PointerInterlaced_fake),
-+MAGIC_MACRO(glVertexNormalColorTexCoord01PointerInterlaced_fake),
-+MAGIC_MACRO(glVertexNormalColorTexCoord012PointerInterlaced_fake),
-+MAGIC_MACRO(glGenTextures_fake),
-+MAGIC_MACRO(glGenBuffersARB_fake),
-+MAGIC_MACRO(glGenLists_fake),
-+MAGIC_MACRO(_glDrawElements_buffer),
-+MAGIC_MACRO(_glDrawRangeElements_buffer),
-+MAGIC_MACRO(_glMultiDrawElements_buffer),
-+MAGIC_MACRO(_glVertexPointer_buffer),
-+MAGIC_MACRO(_glNormalPointer_buffer),
-+MAGIC_MACRO(_glColorPointer_buffer),
-+MAGIC_MACRO(_glSecondaryColorPointer_buffer),
-+MAGIC_MACRO(_glIndexPointer_buffer),
-+MAGIC_MACRO(_glTexCoordPointer_buffer),
-+MAGIC_MACRO(_glEdgeFlagPointer_buffer),
-+MAGIC_MACRO(_glVertexAttribPointerARB_buffer),
-+MAGIC_MACRO(_glWeightPointerARB_buffer),
-+MAGIC_MACRO(_glMatrixIndexPointerARB_buffer),
-+MAGIC_MACRO(_glFogCoordPointer_buffer),
-+MAGIC_MACRO(_glVariantPointerEXT_buffer),
-+MAGIC_MACRO(_glGetError_fake),
-+MAGIC_MACRO(_glReadPixels_pbo),
-+MAGIC_MACRO(_glDrawPixels_pbo),
-+MAGIC_MACRO(_glMapBufferARB_fake),
-+MAGIC_MACRO(_glSelectBuffer_fake),
-+MAGIC_MACRO(_glGetSelectBuffer_fake),
-+MAGIC_MACRO(_glFeedbackBuffer_fake),
-+MAGIC_MACRO(_glGetFeedbackBuffer_fake),
-Index: qemu-0.14.0/target-i386/helper.c
-===================================================================
---- qemu-0.14.0.orig/target-i386/helper.c
-+++ qemu-0.14.0/target-i386/helper.c
-@@ -962,7 +962,7 @@ target_phys_addr_t cpu_get_phys_page_deb
-     }
- 
-     page_offset = (addr & TARGET_PAGE_MASK) & (page_size - 1);
--    paddr = (pte & TARGET_PAGE_MASK) + page_offset;
-+    paddr = (pte & PHYS_ADDR_MASK) + page_offset;
-     return paddr;
- }
- 
-Index: qemu-0.14.0/target-i386/helper.h
-===================================================================
---- qemu-0.14.0.orig/target-i386/helper.h
-+++ qemu-0.14.0/target-i386/helper.h
-@@ -217,4 +217,6 @@ DEF_HELPER_2(rclq, tl, tl, tl)
- DEF_HELPER_2(rcrq, tl, tl, tl)
- #endif
- 
-+DEF_HELPER_0(opengl, void)
-+
- #include "def-helper.h"
-Index: qemu-0.14.0/target-i386/helper_opengl.c
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-i386/helper_opengl.c
-@@ -0,0 +1,1207 @@
-+/*
-+ *  Host-side implementation of GL/GLX API
-+ *
-+ *  Copyright (c) 2006,2007 Even Rouault
-+ *
-+ * Permission is hereby granted, free of charge, to any person obtaining a copy
-+ * of this software and associated documentation files (the "Software"), to deal
-+ * in the Software without restriction, including without limitation the rights
-+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-+ * copies of the Software, and to permit persons to whom the Software is
-+ * furnished to do so, subject to the following conditions:
-+ *
-+ * The above copyright notice and this permission notice shall be included in
-+ * all copies or substantial portions of the Software.
-+ *
-+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-+ * THE SOFTWARE.
-+ */
-+#define _XOPEN_SOURCE 600
-+#include <string.h>
-+#include <stdlib.h>
-+#include <assert.h>
-+
-+#include <X11/Xlib.h>
-+#include <X11/Xutil.h>
-+
-+#include "exec.h"
-+
-+#if defined(CONFIG_USER_ONLY)
-+void helper_opengl(void)
-+{
-+    /* TODO */
-+}
-+#else
-+
-+#include "opengl_func.h"
-+
-+#define ENABLE_GL_LOG
-+
-+extern FILE *stderr;
-+
-+extern void init_process_tab(void);
-+extern int do_function_call(int func_number, arg_t *args, char *ret_string);
-+
-+extern void sdl_set_opengl_window(int x, int y, int width, int height);
-+
-+static int last_process_id = 0;
-+static int must_save = 0;
-+
-+static int allow_kernel = 0;
-+
-+static inline void *get_phys_mem_addr(const CPUState *env, target_ulong addr)
-+{
-+    int is_user, index;
-+
-+    index = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
-+    is_user = ((env->hflags & HF_CPL_MASK) == 3);
-+    /* A sanity check for the int0x99 case */
-+    if (unlikely(is_user == 0 && !allow_kernel)) {
-+        fprintf(stderr, "not in userland !!!\n");
-+        return NULL;
-+    }
-+    if (__builtin_expect
-+        (env->tlb_table[is_user][index].addr_code !=
-+         (addr & TARGET_PAGE_MASK), 0)) {
-+        target_ulong ret = cpu_get_phys_page_debug((CPUState *) env, addr);
-+
-+        if (ret == -1) {
-+            fprintf(stderr,
-+                    "cpu_get_phys_page_debug(env, " TARGET_FMT_lx ") == "
-+                    TARGET_FMT_lx "\n", addr, ret);
-+            fprintf(stderr,
-+                    "not in phys mem " TARGET_FMT_lx "(" TARGET_FMT_lx " "
-+                    TARGET_FMT_lx ")\n", addr,
-+                    env->tlb_table[is_user][index].addr_code,
-+                    addr & TARGET_PAGE_MASK);
-+            fprintf(stderr, "cpu_x86_handle_mmu_fault = %d\n",
-+                    cpu_x86_handle_mmu_fault((CPUState *) env, addr, 0, 1, 1));
-+            return NULL;
-+        } else {
-+            if (ret + TARGET_PAGE_SIZE <= ram_bytes_total()) {
-+                return qemu_get_ram_ptr(ret +
-+                               (((target_ulong) addr) & (TARGET_PAGE_SIZE - 1)));
-+            } else {
-+                fprintf(stderr,
-+                        "cpu_get_phys_page_debug(env, " TARGET_FMT_lx ") == "
-+                        TARGET_FMT_lx "\n", addr, ret);
-+                fprintf(stderr,
-+                        "ret=" TARGET_FMT_lx " last_ram_offset= " TARGET_FMT_lx
-+                        "\n", ret, (target_ulong) ram_bytes_total());
-+                return NULL;
-+            }
-+        }
-+    } else
-+        return (void *) (addr + env->tlb_table[is_user][index].addend);
-+}
-+
-+#ifndef MIN
-+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
-+#endif
-+
-+enum {
-+    NOT_MAPPED,
-+    MAPPED_CONTIGUOUS,
-+    MAPPED_NOT_CONTIGUOUS
-+};
-+
-+#define TARGET_ADDR_LOW_ALIGN(x)  ((target_ulong)(x) & ~(TARGET_PAGE_SIZE - 1))
-+
-+/* Return NOT_MAPPED if a page is not mapped into target physical memory */
-+/* MAPPED_CONTIGUOUS if all pages are mapped into target physical memory and contiguous */
-+/* MAPPED_NOT_CONTIGUOUS if all pages are mapped into target physical memory but not contiguous */
-+static int get_target_mem_state(const CPUState *env,
-+                                target_ulong target_addr, int len)
-+{
-+    target_ulong aligned_target_addr = TARGET_ADDR_LOW_ALIGN(target_addr);
-+    int to_end_page =
-+        (long) aligned_target_addr + TARGET_PAGE_SIZE - (long) target_addr;
-+    int ret = MAPPED_CONTIGUOUS;
-+
-+    if (aligned_target_addr != target_addr) {
-+        void *phys_addr = get_phys_mem_addr(env, aligned_target_addr);
-+        void *last_phys_addr = phys_addr;
-+
-+        if (phys_addr == 0) {
-+            return NOT_MAPPED;
-+        }
-+        if (len > to_end_page) {
-+            len -= to_end_page;
-+            aligned_target_addr += TARGET_PAGE_SIZE;
-+            int i;
-+
-+            for (i = 0; i < len; i += TARGET_PAGE_SIZE) {
-+                void *phys_addr =
-+                    get_phys_mem_addr(env, aligned_target_addr + i);
-+                if (phys_addr == 0) {
-+                    return NOT_MAPPED;
-+                }
-+                if (phys_addr != last_phys_addr + TARGET_PAGE_SIZE)
-+                    ret = MAPPED_NOT_CONTIGUOUS;
-+                last_phys_addr = phys_addr;
-+            }
-+        }
-+    } else {
-+        void *last_phys_addr = NULL;
-+        int i;
-+
-+        for (i = 0; i < len; i += TARGET_PAGE_SIZE) {
-+            void *phys_addr = get_phys_mem_addr(env, target_addr + i);
-+
-+            if (phys_addr == 0) {
-+                return NOT_MAPPED;
-+            }
-+            if (i != 0 && phys_addr != last_phys_addr + TARGET_PAGE_SIZE)
-+                ret = MAPPED_NOT_CONTIGUOUS;
-+            last_phys_addr = phys_addr;
-+        }
-+    }
-+    return ret;
-+}
-+
-+/* copy len bytes from host memory at addr host_addr to target memory at logical addr target_addr */
-+/* Returns 1 if successfull, 0 if some target pages are not mapped into target physical memory */
-+static int memcpy_host_to_target(const CPUState *env,
-+                                 target_ulong target_addr,
-+                                 const void *host_addr, int len)
-+{
-+    int i;
-+    target_ulong aligned_target_addr = TARGET_ADDR_LOW_ALIGN(target_addr);
-+    int to_end_page =
-+        (long) aligned_target_addr + TARGET_PAGE_SIZE - (long) target_addr;
-+    int ret = get_target_mem_state(env, target_addr, len);
-+
-+    if (ret == NOT_MAPPED) {
-+        return 0;
-+    }
-+
-+    if (ret == MAPPED_CONTIGUOUS) {
-+        void *phys_addr = get_phys_mem_addr(env, target_addr);
-+
-+        memcpy(phys_addr, host_addr, len);
-+    } else {
-+        if (aligned_target_addr != target_addr) {
-+            void *phys_addr = get_phys_mem_addr(env, target_addr);
-+
-+            memcpy(phys_addr, host_addr, MIN(len, to_end_page));
-+            if (len <= to_end_page) {
-+                return 1;
-+            }
-+            len -= to_end_page;
-+            host_addr += to_end_page;
-+            target_addr = aligned_target_addr + TARGET_PAGE_SIZE;
-+        }
-+        for (i = 0; i < len; i += TARGET_PAGE_SIZE) {
-+            void *phys_addr = get_phys_mem_addr(env, target_addr + i);
-+
-+            memcpy(phys_addr, host_addr + i,
-+                   (i + TARGET_PAGE_SIZE <=
-+                    len) ? TARGET_PAGE_SIZE : len & (TARGET_PAGE_SIZE - 1));
-+        }
-+    }
-+
-+    return 1;
-+}
-+
-+static int memcpy_target_to_host(const CPUState *env, void *host_addr,
-+                                 target_ulong target_addr, int len)
-+{
-+    int i;
-+    target_ulong aligned_target_addr = TARGET_ADDR_LOW_ALIGN(target_addr);
-+    int to_end_page =
-+        (long) aligned_target_addr + TARGET_PAGE_SIZE - (long) target_addr;
-+    int ret = get_target_mem_state(env, target_addr, len);
-+
-+    if (ret == NOT_MAPPED) {
-+        return 0;
-+    }
-+
-+    if (ret == MAPPED_CONTIGUOUS) {
-+        void *phys_addr = get_phys_mem_addr(env, target_addr);
-+
-+        memcpy(host_addr, phys_addr, len);
-+    } else {
-+        if (aligned_target_addr != target_addr) {
-+            void *phys_addr = get_phys_mem_addr(env, target_addr);
-+
-+            memcpy(host_addr, phys_addr, MIN(len, to_end_page));
-+            if (len <= to_end_page)
-+                return 1;
-+
-+            len -= to_end_page;
-+            host_addr += to_end_page;
-+            target_addr = aligned_target_addr + TARGET_PAGE_SIZE;
-+        }
-+        for (i = 0; i < len; i += TARGET_PAGE_SIZE) {
-+            void *phys_addr = get_phys_mem_addr(env, target_addr + i);
-+
-+            memcpy(host_addr + i, phys_addr,
-+                   (i + TARGET_PAGE_SIZE <=
-+                    len) ? TARGET_PAGE_SIZE : len & (TARGET_PAGE_SIZE - 1));
-+        }
-+    }
-+
-+    return 1;
-+}
-+
-+static int memcpy_target_to_host_1_1(const CPUState *env, void *host_addr,
-+                                     target_ulong target_addr, int nb_args)
-+{
-+    return memcpy_target_to_host(env, host_addr, target_addr, nb_args * 8);
-+}
-+
-+static int wordsize = 0;
-+static int (*argcpy_target_to_host) (const CPUState *env, void *host_addr,
-+                                     target_ulong target_addr, int nb_args) =
-+    memcpy_target_to_host_1_1;
-+
-+void do_disconnect_current(void);
-+void do_context_switch(Display *dpy, pid_t pid, int call);
-+
-+static void disconnect_current(void)
-+{
-+    last_process_id = 0;
-+
-+    return do_disconnect_current();
-+}
-+
-+static int memcpy_target32_to_host(const CPUState *env, void *host_addr,
-+                                   target_ulong target_addr, int nb_args)
-+{
-+    int ret;
-+    uint32_t args_temp[nb_args], *src = args_temp;
-+    arg_t *dest = host_addr;
-+
-+    ret = memcpy_target_to_host(env, args_temp, target_addr, nb_args * 4);
-+    if (!ret)
-+        return ret;
-+
-+    while (nb_args) {
-+        /* TODO: endianness */
-+        *dest = 0;
-+        *(uint32_t *) (dest++) = *src++;
-+        nb_args--;
-+    }
-+
-+    return ret;
-+}
-+
-+static int memcpy_target64_to_host(const CPUState *env, void *host_addr,
-+                                   target_ulong target_addr, int nb_args)
-+{
-+    int ret;
-+    uint64_t args_temp[nb_args], *src = args_temp;
-+    arg_t *dest = host_addr;
-+
-+    ret = memcpy_target_to_host(env, args_temp, target_addr, nb_args * 8);
-+    if (!ret)
-+        return ret;
-+
-+    while (nb_args) {
-+        /* TODO: endianness */
-+        *dest = 0;
-+        *(uint64_t *) (dest++) = *src++;
-+        nb_args--;
-+    }
-+
-+    return ret;
-+}
-+
-+static int host_offset = 0;
-+static void reset_host_offset()
-+{
-+    host_offset = 0;
-+}
-+
-+/* Return a host pointer with the content of [target_addr, target_addr + len bytes[ */
-+/* Do not free or modify */
-+static const void *get_host_read_pointer(const CPUState *env,
-+                const target_ulong target_addr, int len)
-+{
-+    int ret = get_target_mem_state(env, target_addr, len);
-+
-+    if (ret == NOT_MAPPED) {
-+        return NULL;
-+    } else if (ret == MAPPED_CONTIGUOUS) {
-+        return get_phys_mem_addr(env, target_addr);
-+    } else {
-+        static int host_mem_size = 0;
-+        static void *host_mem = NULL;
-+        static void *ret;
-+
-+        if (host_mem_size < host_offset + len) {
-+            host_mem_size = 2 * host_mem_size + host_offset + len;
-+            host_mem = realloc(host_mem, host_mem_size);
-+        }
-+        ret = host_mem + host_offset;
-+        assert(memcpy_target_to_host(env, ret, target_addr, len));
-+        host_offset += len;
-+        return ret;
-+    }
-+}
-+
-+int doing_opengl = 0;
-+static int last_func_number = -1;
-+static size_t(*my_strlen) (const char *) = NULL;
-+
-+#ifdef ENABLE_GL_LOG
-+static FILE *f = NULL;
-+static int logger_pid = 0;
-+
-+#define write_gl_debug_init() do { if (f == NULL) f = fopen("/tmp/debug_gl.bin", "wb"); } while(0)
-+
-+void write_gl_debug_cmd_int(int my_int)
-+{
-+    write_gl_debug_init();
-+    fwrite(&my_int, sizeof(int), 1, f);
-+    fflush(f);
-+}
-+
-+void write_gl_debug_cmd_short(short my_int)
-+{
-+    write_gl_debug_init();
-+    fwrite(&my_int, sizeof(short), 1, f);
-+    fflush(f);
-+}
-+
-+static void inline write_gl_debug_cmd_buffer_with_size(int size, void *buffer)
-+{
-+    write_gl_debug_init();
-+    fwrite(&size, sizeof(int), 1, f);
-+    if (size)
-+        fwrite(buffer, size, 1, f);
-+}
-+
-+static void inline write_gl_debug_cmd_buffer_without_size(
-+                int size, void *buffer)
-+{
-+    write_gl_debug_init();
-+    if (size)
-+        fwrite(buffer, size, 1, f);
-+}
-+
-+void write_gl_debug_end(void)
-+{
-+    write_gl_debug_init();
-+    fclose(f);
-+    f = NULL;
-+    logger_pid = 0;
-+    must_save = 0;
-+}
-+
-+static inline int is_logging(int pid)
-+{
-+    return must_save && pid == logger_pid;
-+}
-+#endif
-+
-+#include <dlfcn.h>
-+#include <signal.h>
-+
-+static void (*anticrash_handler) (void *) = NULL;
-+static void (*show_stack_from_signal_handler) (int, int, int) = NULL;
-+
-+void my_anticrash_sigsegv_handler(int signum, siginfo_t *info, void *ptr)
-+{
-+    static int counter = 0;
-+
-+    counter++;
-+
-+    printf("oops\n");
-+
-+    /* if (show_stack_from_signal_handler && counter == 1) { struct ucontext*
-+     * ctxt = (struct ucontext*)ptr; show_stack_from_signal_handler(10,
-+     * ctxt->uc_mcontext.gregs[REG_EBP], ctxt->uc_mcontext.gregs[REG_ESP]); } */
-+    anticrash_handler(ptr);
-+
-+    counter--;
-+}
-+
-+static int decode_call_int(CPUState *env, int func_number, int pid,
-+                           target_ulong target_ret_string,
-+                           target_ulong in_args, target_ulong in_args_size)
-+{
-+    Signature *signature = (Signature *) tab_opengl_calls[func_number];
-+    int ret_type = signature->ret_type;
-+    /* int has_out_parameters = signature->has_out_parameters; */
-+    int nb_args = signature->nb_args;
-+    int *args_type = signature->args_type;
-+    int i;
-+    int ret;
-+    int *args_size = NULL;
-+    target_ulong saved_out_ptr[50];
-+    static char *ret_string = NULL;
-+    static arg_t args[50];
-+    static Display *dpy = NULL;
-+
-+    if (dpy == NULL) {
-+        void *handle = dlopen("libanticrash.so", RTLD_LAZY);
-+
-+        if (handle) {
-+            anticrash_handler = dlsym(handle, "anticrash_handler");
-+            if (anticrash_handler) {
-+                fprintf(stderr, "anticrash handler enabled\n");
-+                struct sigaction sigsegv_action;
-+                struct sigaction old_sigsegv_action;
-+
-+                sigsegv_action.sa_sigaction = my_anticrash_sigsegv_handler;
-+                sigemptyset(&(sigsegv_action.sa_mask));
-+                sigsegv_action.sa_flags = SA_SIGINFO | SA_NODEFER;
-+                sigaction(SIGSEGV, &sigsegv_action, &old_sigsegv_action);
-+            }
-+        }
-+        handle = dlopen("libgetstack.so", RTLD_LAZY);
-+        if (handle) {
-+            show_stack_from_signal_handler =
-+                dlsym(handle, "show_stack_from_signal_handler");
-+        }
-+
-+        dpy = XOpenDisplay(NULL);
-+        init_process_tab();
-+        ret_string = malloc(32768);
-+        my_strlen = strlen;
-+    }
-+
-+    if (unlikely(last_func_number == _exit_process_func &&
-+                            func_number == _exit_process_func)) {
-+        last_func_number = -1;
-+        return 0;
-+    }
-+
-+    if (last_process_id != pid) {
-+        do_context_switch(dpy, pid, func_number);
-+        last_process_id = pid;
-+    }
-+
-+    if (unlikely(func_number == _exit_process_func))
-+        last_process_id = 0;
-+
-+    if (!wordsize) {
-+        if (func_number == _init32_func || func_number == _init64_func) {
-+            if (func_number == _init32_func) {
-+                wordsize = 32;
-+                argcpy_target_to_host = memcpy_target32_to_host;
-+            } else {
-+                wordsize = 64;
-+                argcpy_target_to_host = memcpy_target64_to_host;
-+            }
-+        } else
-+            fprintf(stderr, "commands submitted before initialisation done\n");
-+    }
-+
-+    reset_host_offset();
-+
-+    if (nb_args) {
-+
-+        if (argcpy_target_to_host(env, args, in_args, nb_args) == 0) {
-+            fprintf(stderr, "call %s pid=%d\n",
-+                    tab_opengl_calls_name[func_number], pid);
-+            fprintf(stderr, "cannot get call parameters\n");
-+            disconnect_current();
-+            return 0;
-+        }
-+
-+        args_size =
-+            (int *) get_host_read_pointer(env, in_args_size,
-+                                          sizeof(int) * nb_args);
-+        if (args_size == NULL) {
-+            fprintf(stderr, "call %s pid=%d\n",
-+                    tab_opengl_calls_name[func_number], pid);
-+            fprintf(stderr, "cannot get call parameters size\n");
-+            disconnect_current();
-+            return 0;
-+        }
-+    }
-+
-+    if (func_number == _serialized_calls_func) {
-+        int command_buffer_size = args_size[0];
-+        const void *command_buffer =
-+            get_host_read_pointer(env, args[0], command_buffer_size);
-+        int commmand_buffer_offset = 0;
-+
-+        args_size = NULL;
-+#ifdef ENABLE_GL_LOG
-+        if (is_logging(pid))
-+            write_gl_debug_cmd_short(_serialized_calls_func);
-+#endif
-+
-+        while (commmand_buffer_offset < command_buffer_size) {
-+            func_number =
-+                *(short *) (command_buffer + commmand_buffer_offset);
-+            if (!(func_number >= 0 && func_number < GL_N_CALLS)) {
-+                fprintf(stderr,
-+                        "func_number >= 0 && func_number < GL_N_CALLS failed at "
-+                        "commmand_buffer_offset=%d (command_buffer_size=%d)\n",
-+                        commmand_buffer_offset, command_buffer_size);
-+                return 0;
-+            }
-+            commmand_buffer_offset += sizeof(short);
-+#ifdef ENABLE_GL_LOG
-+            if (is_logging(pid))
-+                write_gl_debug_cmd_short(func_number);
-+#endif
-+
-+            signature = (Signature *) tab_opengl_calls[func_number];
-+            ret_type = signature->ret_type;
-+            assert(ret_type == TYPE_NONE);
-+            nb_args = signature->nb_args;
-+            args_type = signature->args_type;
-+
-+            for (i = 0; i < nb_args; i++) {
-+                switch (args_type[i]) {
-+                case TYPE_UNSIGNED_INT:
-+                case TYPE_INT:
-+                case TYPE_UNSIGNED_CHAR:
-+                case TYPE_CHAR:
-+                case TYPE_UNSIGNED_SHORT:
-+                case TYPE_SHORT:
-+                case TYPE_FLOAT:
-+                    {
-+                        args[i] =
-+                            *(int *) (command_buffer +
-+                                      commmand_buffer_offset);
-+#ifdef ENABLE_GL_LOG
-+                        if (is_logging(pid))
-+                            write_gl_debug_cmd_int(args[i]);
-+#endif
-+                        commmand_buffer_offset += sizeof(int);
-+                        break;
-+                    }
-+
-+                case TYPE_NULL_TERMINATED_STRING:
-+                  CASE_IN_UNKNOWN_SIZE_POINTERS:
-+                    {
-+                        int arg_size =
-+                            *(int *) (command_buffer +
-+                                      commmand_buffer_offset);
-+                        commmand_buffer_offset += sizeof(int);
-+
-+                        if (arg_size == 0) {
-+                            args[i] = 0;
-+                        } else {
-+                            args[i] =
-+                                (long) (command_buffer +
-+                                        commmand_buffer_offset);
-+                        }
-+
-+                        if (args[i] == 0) {
-+                            if (!IS_NULL_POINTER_OK_FOR_FUNC(func_number)) {
-+                                fprintf(stderr, "call %s arg %d pid=%d\n",
-+                                        tab_opengl_calls_name[func_number], i,
-+                                        pid);
-+                                disconnect_current();
-+                                return 0;
-+                            }
-+                        } else {
-+                            if (arg_size == 0) {
-+                                fprintf(stderr, "call %s arg %d pid=%d\n",
-+                                        tab_opengl_calls_name[func_number], i,
-+                                        pid);
-+                                fprintf(stderr, "args_size[i] == 0 !!\n");
-+                                disconnect_current();
-+                                return 0;
-+                            }
-+                        }
-+#ifdef ENABLE_GL_LOG
-+                        if (is_logging(pid))
-+                            write_gl_debug_cmd_buffer_with_size(arg_size,
-+                                                                (void *)
-+                                                                args[i]);
-+#endif
-+                        commmand_buffer_offset += arg_size;
-+
-+                        break;
-+                    }
-+
-+                  CASE_IN_LENGTH_DEPENDING_ON_PREVIOUS_ARGS:
-+                    {
-+                        int arg_size =
-+                            compute_arg_length(stderr, func_number, i, args);
-+                        args[i] =
-+                            (arg_size) ? (long) (command_buffer +
-+                                                 commmand_buffer_offset) : 0;
-+#ifdef ENABLE_GL_LOG
-+                        if (is_logging(pid))
-+                            write_gl_debug_cmd_buffer_without_size(arg_size,
-+                                                                   (void *)
-+                                                                   args[i]);
-+#endif
-+                        commmand_buffer_offset += arg_size;
-+                        break;
-+                    }
-+
-+                  CASE_OUT_POINTERS:
-+                    {
-+                        fprintf(stderr,
-+                                "shouldn't happen TYPE_OUT_xxxx : call %s arg %d pid=%d\n",
-+                                tab_opengl_calls_name[func_number], i, pid);
-+                        disconnect_current();
-+                        return 0;
-+                    }
-+
-+                case TYPE_DOUBLE:
-+                  CASE_IN_KNOWN_SIZE_POINTERS:
-+                    args[i] =
-+                        (long) (command_buffer + commmand_buffer_offset);
-+#ifdef ENABLE_GL_LOG
-+                    if (is_logging(pid))
-+                        write_gl_debug_cmd_buffer_without_size(
-+                                        tab_args_type_length[args_type[i]],
-+                                        (void *) args[i]);
-+#endif
-+                    commmand_buffer_offset +=
-+                        tab_args_type_length[args_type[i]];
-+                    break;
-+
-+                case TYPE_IN_IGNORED_POINTER:
-+                    args[i] = 0;
-+                    break;
-+
-+                default:
-+                    fprintf(stderr,
-+                            "shouldn't happen : call %s arg %d pid=%d\n",
-+                            tab_opengl_calls_name[func_number], i, pid);
-+                    disconnect_current();
-+                    return 0;
-+                }
-+            }
-+            do_function_call(func_number, args, ret_string);
-+        }
-+
-+        ret = 0;
-+    } else {
-+#ifdef ENABLE_GL_LOG
-+        if (is_logging(pid))
-+            write_gl_debug_cmd_short(func_number);
-+#endif
-+
-+        for (i = 0; i < nb_args; i++) {
-+            switch (args_type[i]) {
-+            case TYPE_UNSIGNED_INT:
-+            case TYPE_INT:
-+            case TYPE_UNSIGNED_CHAR:
-+            case TYPE_CHAR:
-+            case TYPE_UNSIGNED_SHORT:
-+            case TYPE_SHORT:
-+            case TYPE_FLOAT:
-+#ifdef ENABLE_GL_LOG
-+                if (is_logging(pid))
-+                    write_gl_debug_cmd_int(args[i]);
-+#endif
-+                break;
-+
-+            case TYPE_NULL_TERMINATED_STRING:
-+              CASE_IN_UNKNOWN_SIZE_POINTERS:
-+                if (args[i] == 0 && args_size[i] == 0) {
-+                    if (!IS_NULL_POINTER_OK_FOR_FUNC(func_number)) {
-+                        fprintf(stderr, "call %s arg %d pid=%d\n",
-+                                tab_opengl_calls_name[func_number], i, pid);
-+                        disconnect_current();
-+                        return 0;
-+                    }
-+                } else if (args[i] == 0 && args_size[i] != 0) {
-+                    fprintf(stderr, "call %s arg %d pid=%d\n",
-+                            tab_opengl_calls_name[func_number], i, pid);
-+                    fprintf(stderr, "args[i] == 0 && args_size[i] != 0 !!\n");
-+                    disconnect_current();
-+                    return 0;
-+                } else if (args[i] != 0 && args_size[i] == 0) {
-+                    fprintf(stderr, "call %s arg %d pid=%d\n",
-+                            tab_opengl_calls_name[func_number], i, pid);
-+                    fprintf(stderr, "args[i] != 0 && args_size[i] == 0 !!\n");
-+                    disconnect_current();
-+                    return 0;
-+                }
-+                if (args[i]) {
-+                    args[i] =
-+                        (arg_t) get_host_read_pointer(env, args[i],
-+                                                      args_size[i]);
-+                    if (args[i] == 0) {
-+                        fprintf(stderr, "call %s arg %d pid=%d\n",
-+                                tab_opengl_calls_name[func_number], i, pid);
-+                        fprintf(stderr, "can not get %d bytes\n",
-+                                args_size[i]);
-+                        disconnect_current();
-+                        return 0;
-+                    }
-+                }
-+#ifdef ENABLE_GL_LOG
-+                if (is_logging(pid))
-+                    write_gl_debug_cmd_buffer_with_size(args_size[i],
-+                                                        (void *) args[i]);
-+#endif
-+                break;
-+
-+              CASE_IN_LENGTH_DEPENDING_ON_PREVIOUS_ARGS:
-+                {
-+                    args_size[i] =
-+                        compute_arg_length(stderr, func_number, i, args);
-+                    args[i] = (args_size[i]) ? (arg_t)
-+                            get_host_read_pointer(env,
-+                                            args[i], args_size [i]) : 0;
-+                    if (args[i] == 0 && args_size[i] != 0) {
-+                        fprintf(stderr, "call %s arg %d pid=%d\n",
-+                                tab_opengl_calls_name[func_number], i, pid);
-+                        fprintf(stderr, "can not get %d bytes\n",
-+                                args_size[i]);
-+                        disconnect_current();
-+                        return 0;
-+                    }
-+#ifdef ENABLE_GL_LOG
-+                    if (is_logging(pid))
-+                        write_gl_debug_cmd_buffer_without_size(args_size[i],
-+                                        (void *) args[i]);
-+#endif
-+                    break;
-+                }
-+
-+              CASE_OUT_POINTERS:
-+                {
-+                    int mem_state;
-+
-+#ifdef ENABLE_GL_LOG
-+                    if (is_logging(pid))
-+                        switch (args_type[i]) {
-+                          CASE_OUT_UNKNOWN_SIZE_POINTERS:
-+                            write_gl_debug_cmd_int(args_size[i]);
-+                            break;
-+
-+                        default:
-+                            break;
-+                        }
-+#endif
-+
-+                    if (func_number == glXQueryExtension_func && args[i] == 0) {
-+                        saved_out_ptr[i] = 0;
-+                        continue;
-+                    }
-+                    if (args[i] == 0 && args_size[i] == 0) {
-+                        if (!IS_NULL_POINTER_OK_FOR_FUNC(func_number)) {
-+                            fprintf(stderr, "call %s arg %d pid=%d\n",
-+                                    tab_opengl_calls_name[func_number], i,
-+                                    pid);
-+                            disconnect_current();
-+                            return 0;
-+                        }
-+                        fprintf(stderr, "call %s arg %d pid=%d\n",
-+                                tab_opengl_calls_name[func_number], i, pid);
-+                        disconnect_current();
-+                        return 0;
-+                    } else if (args[i] == 0 && args_size[i] != 0) {
-+                        fprintf(stderr, "call %s arg %d pid=%d\n",
-+                                tab_opengl_calls_name[func_number], i, pid);
-+                        fprintf(stderr,
-+                                "args[i] == 0 && args_size[i] != 0 !!\n");
-+                        disconnect_current();
-+                        return 0;
-+                    } else if (args[i] != 0 && args_size[i] == 0) {
-+                        fprintf(stderr, "call %s arg %d pid=%d\n",
-+                                tab_opengl_calls_name[func_number], i, pid);
-+                        fprintf(stderr,
-+                                "args[i] != 0 && args_size[i] == 0 !!\n");
-+                        disconnect_current();
-+                        return 0;
-+                    }
-+                    if (args[i]) {
-+                        mem_state =
-+                            get_target_mem_state(env, args[i], args_size[i]);
-+                        if (mem_state == NOT_MAPPED) {
-+                            fprintf(stderr,
-+                                    "call %s arg %d pid=%d addr="
-+                                    TARGET_FMT_lx " size=%d NOT_MAPPED\n",
-+                                    tab_opengl_calls_name[func_number], i,
-+                                    pid, args[i], args_size[i]);
-+                            disconnect_current();
-+                            return 0;
-+                        } else if (mem_state == MAPPED_CONTIGUOUS) {
-+                            saved_out_ptr[i] = 0;
-+                            args[i] = (arg_t) get_phys_mem_addr(env, args[i]);
-+                        } else {
-+                            saved_out_ptr[i] = args[i];
-+                            args[i] = (arg_t) malloc(args_size[i]);
-+                        }
-+                    } else {
-+                        saved_out_ptr[i] = 0;
-+                    }
-+                    break;
-+                }
-+
-+            case TYPE_DOUBLE:
-+              CASE_IN_KNOWN_SIZE_POINTERS:
-+                if (args[i] == 0) {
-+                    fprintf(stderr, "call %s arg %d pid=%d\n",
-+                            tab_opengl_calls_name[func_number], i, pid);
-+                    fprintf(stderr, "can not get %d bytes\n",
-+                            tab_args_type_length[args_type[i]]);
-+                    disconnect_current();
-+                    return 0;
-+                }
-+                args[i] = (arg_t) get_host_read_pointer(env,
-+                                args[i], tab_args_type_length[args_type[i]]);
-+                if (args[i] == 0) {
-+                    fprintf(stderr, "call %s arg %d pid=%d\n",
-+                            tab_opengl_calls_name[func_number], i, pid);
-+                    fprintf(stderr, "can not get %d bytes\n",
-+                            tab_args_type_length[args_type[i]]);
-+                    disconnect_current();
-+                    return 0;
-+                }
-+#ifdef ENABLE_GL_LOG
-+                if (is_logging(pid))
-+                    write_gl_debug_cmd_buffer_without_size
-+                        (tab_args_type_length[args_type[i]],
-+                         (void *) args[i]);
-+#endif
-+                break;
-+
-+            case TYPE_IN_IGNORED_POINTER:
-+                args[i] = 0;
-+                break;
-+
-+            default:
-+                fprintf(stderr, "shouldn't happen : call %s arg %d pid=%d\n",
-+                        tab_opengl_calls_name[func_number], i, pid);
-+                disconnect_current();
-+                return 0;
-+            }
-+        }
-+
-+        if (ret_type == TYPE_CONST_CHAR) {
-+            ret_string[0] = 0;
-+        }
-+
-+        if (func_number == _init32_func || func_number == _init64_func) {
-+            if (func_number == _init32_func) {
-+                if (wordsize != 32) {
-+                    fprintf(stderr,
-+                            "clients with different ABIs not supported\n");
-+                    exit(-1);
-+                }
-+            } else {
-+                if (wordsize != 64) {
-+                    fprintf(stderr,
-+                            "clients with different ABIs not supported\n");
-+                    exit(-1);
-+                }
-+            }
-+
-+            if (must_save && args[0])
-+                fprintf(stderr, "error: pid %i is already recording\n",
-+                                logger_pid);
-+            else if (args[0]) {
-+                logger_pid = pid;
-+                must_save = 1;
-+            }
-+#ifdef USE_KQEMU
-+            if (env->kqemu_enabled)
-+                *(int *) args[1] = 2;
-+            else
-+#endif
-+                *(int *) args[1] = 1;
-+            ret = 0;
-+        } else {
-+            ret = do_function_call(func_number, args, ret_string);
-+        }
-+#ifdef ENABLE_GL_LOG
-+        if (is_logging(pid) && func_number == glXGetVisualFromFBConfig_func)
-+            write_gl_debug_cmd_int(ret);
-+#endif
-+        for (i = 0; i < nb_args; i++) {
-+            switch (args_type[i]) {
-+              CASE_OUT_POINTERS:
-+                {
-+                    if (saved_out_ptr[i]) {
-+                        if (memcpy_host_to_target(env, saved_out_ptr[i],
-+                                                (void *) args[i],
-+                                                args_size[i]) == 0) {
-+                            fprintf(stderr, "could not copy out parameters "
-+                                            "back to user space\n");
-+                            disconnect_current();
-+                            return 0;
-+                        }
-+                        free((void *) args[i]);
-+                    }
-+                    break;
-+                }
-+
-+            default:
-+                break;
-+            }
-+        }
-+
-+        if (ret_type == TYPE_CONST_CHAR)
-+            if (target_ret_string) {
-+                /* the my_strlen stuff is a hack to workaround a GCC bug if
-+                 * using directly strlen... */
-+                if (memcpy_host_to_target(env, target_ret_string, ret_string,
-+                                        my_strlen(ret_string) + 1) == 0) {
-+                    fprintf(stderr, "cannot copy out parameters "
-+                                    "back to user space\n");
-+                    disconnect_current();
-+                    return 0;
-+                }
-+            }
-+    }
-+
-+#ifdef ENABLE_GL_LOG
-+    if (is_logging(pid) && func_number == _exit_process_func) {
-+        write_gl_debug_end();
-+    }
-+#endif
-+
-+    return ret;
-+}
-+
-+static int decode_call(CPUState *env, int func_number, int pid,
-+                       target_ulong target_ret_string, target_ulong in_args,
-+                       target_ulong in_args_size)
-+{
-+    if (!(func_number >= 0 && func_number < GL_N_CALLS)) {
-+        fprintf(stderr,
-+                "func_number >= 0 && func_number < GL_N_CALLS failed\n");
-+        return 0;
-+    }
-+
-+    return decode_call_int(env, func_number, pid,
-+                    target_ret_string, in_args, in_args_size);
-+}
-+
-+#define env first_cpu
-+
-+void helper_opengl(void)
-+{
-+    doing_opengl = 1;
-+    env->regs[R_EAX] =
-+        decode_call(env, env->regs[R_EAX], env->regs[R_EBX], env->regs[R_ECX],
-+                    env->regs[R_EDX], env->regs[R_ESI]);
-+    doing_opengl = 0;
-+}
-+
-+void mem_opengl(uint64_t ptr)
-+{
-+    uint64_t *params = get_phys_mem_addr(env, ptr);
-+    int ret;
-+
-+    /* Execute */
-+    doing_opengl = 1;
-+    ret = decode_call(env, le64_to_cpu(params[0]),
-+                    le64_to_cpu(params[1]), le64_to_cpu(params[2]),
-+                    le64_to_cpu(params[3]), le64_to_cpu(params[4]));
-+    doing_opengl = 0;
-+
-+    params[0] = cpu_to_le64(ret);
-+    params[5] = 0;
-+}
-+
-+#define THREADINFO_TASK_OFFSET   0x0   //// 0x0
-+#define THREADSTRUCT_IOPL_OFFSET 0x78  //// 0x80
-+#define TASKSTRUCT_NEXT_OFFSET   0x1a0 //// 0x1e8
-+#define TASKSTRUCT_PREV_OFFSET   0x1a4 //// 0x1ec
-+#define TASKSTRUCT_RCRED_OFFSET  0x29c //// 0x2b4
-+#define TASKSTRUCT_CRED_OFFSET   0x2a0 //// 0x2b8
-+#define TASKSTRUCT_COMM_OFFSET   0x2c0 //// 0x2fc
-+#define TASKSTRUCT_THREAD_OFFSET 0x2e4 //// 0x318
-+#define TASKSTRUCT_IO_CTX_OFFSET 0x40c //// 0x428
-+#define CRED_CAPINH_OFFSET       0x28
-+#define CRED_CAPPER_OFFSET       0x30
-+#define CRED_CAPEFF_OFFSET       0x38
-+#define CRED_CAPBST_OFFSET       0x40
-+/* How to obtain the numbers:
-+ * $ gbd vmlinux
-+ * ...
-+ * (gdb) print &((struct task_struct *) 0)->real_cred
-+ * $22 = (const struct cred **) 0x29c
-+ * (gdb) print &((struct task_struct *) 0)->cred
-+ * $23 = (const struct cred **) 0x2a0
-+ * (gbd) ...
-+ * ...
-+ * (gdb) ^D
-+ * $ vim target-i386/helper_opengl.c
-+ * ...
-+ * :wq
-+ * $ make
-+ * ...
-+ *
-+ * Testing:
-+ * $ x86_64-softmmu/qemu-system-x86_64 -s -hda ...
-+ * ^Z
-+ * [1]+  Stopped                 x86_64-softmmu/qemu-system-x86_64 -s -hda ...
-+ * $ bg
-+ * [1]+ x86_64-softmmu/qemu-system-x86_64 -s -hda ...
-+ * $ gdb
-+ * ...
-+ * (gdb) target remote localhost:1234
-+ * ...
-+ * (gdb) print ((char *) *(unsigned int *) ((unsigned int) $rsp & ~8191)) +
-+ *   0x2c0
-+ * $9 = 0xc094062c "swapper"
-+ * (gdb) print (char *) (*(unsigned int *) (((char *) *(unsigned int *)
-+ *   ((unsigned int) $rsp & ~8191)) + 0x1a0) - 0x1a0) + 0x2c0
-+ * $10 = 0xdf87cee0 "init"
-+ * ...
-+ */
-+
-+#define CAP_SYS_RAWIO            17
-+
-+#define THREAD_SIZE (TARGET_PAGE_SIZE  << 1)
-+static ram_addr_t x86_current_thread(void)
-+{
-+    return env->regs[R_ESP] & ~(THREAD_SIZE - 1);
-+}
-+
-+static ram_addr_t x86_current_task(void)
-+{
-+    return *(uint32_t *) get_phys_mem_addr(env,
-+                    x86_current_thread() + THREADINFO_TASK_OFFSET);
-+}
-+
-+static ram_addr_t x86_current_io_ctx(void)
-+{
-+    return *(uint32_t *) get_phys_mem_addr(env,
-+                    x86_current_task() + TASKSTRUCT_IO_CTX_OFFSET);
-+}
-+
-+static ram_addr_t x86_task_name(ram_addr_t proc)
-+{
-+    return x86_current_task() + TASKSTRUCT_COMM_OFFSET;
-+}
-+
-+static ram_addr_t x86_task_next(ram_addr_t proc)
-+{
-+    return *(uint32_t *) get_phys_mem_addr(env,
-+                    x86_current_task() + TASKSTRUCT_NEXT_OFFSET) -
-+            TASKSTRUCT_NEXT_OFFSET;
-+}
-+
-+static void x86_cap_set(ram_addr_t caps, int cap)
-+{
-+    int offset = cap >> 5;
-+    int mask = 1 << (cap & 31);
-+
-+    *(uint32_t *) get_phys_mem_addr(env, caps + offset) |= mask;
-+}
-+
-+static void x86_cred_cap_set(ram_addr_t creds, int cap)
-+{
-+    x86_cap_set(creds + CRED_CAPINH_OFFSET, cap);
-+    x86_cap_set(creds + CRED_CAPPER_OFFSET, cap);
-+    x86_cap_set(creds + CRED_CAPEFF_OFFSET, cap);
-+    x86_cap_set(creds + CRED_CAPBST_OFFSET, cap);
-+}
-+
-+static void x86_task_cap_set(ram_addr_t proc, int cap)
-+{
-+    x86_cred_cap_set(*(uint32_t *) get_phys_mem_addr(env,
-+                            proc + TASKSTRUCT_RCRED_OFFSET), cap);
-+    x86_cred_cap_set(*(uint32_t *) get_phys_mem_addr(env,
-+                            proc + TASKSTRUCT_CRED_OFFSET), cap);
-+}
-+
-+#include "kvm.h"
-+
-+/* The putting and getting of the register set seems to incure a too
-+ * high overhead.  It's at least 4 ioctl's each.  */
-+#if 0
-+static void opengl_ioport_write(void *data, uint32_t addr, uint32_t val)
-+{
-+    /* Ignore the first outb after iopl which is emulated by the kernel.  */
-+    if (val == (uint8_t) -1)
-+        return;
-+
-+    if (kvm_enabled())
-+        kvm_arch_get_registers(env);
-+    doing_opengl = 1;
-+    env->regs[R_EAX] =
-+        decode_call(env, env->regs[R_EAX], env->regs[R_EBX], env->regs[R_ECX],
-+                    env->regs[R_ESI], env->regs[R_EDI]);
-+    doing_opengl = 0;
-+    if (kvm_enabled())
-+        kvm_arch_put_registers(env);
-+}
-+#else
-+static void get_regs(void)
-+{
-+    /* We only really need the eflags and cr[0..4] */
-+    if (kvm_enabled())
-+        kvm_get_sregs(env);
-+}
-+
-+static void opengl_ioport_write(void *data, uint32_t addr, uint32_t val)
-+{
-+    uint64_t *params;
-+    int ret;
-+
-+    /* Only need to fetch the registers after a guest's context switch...
-+     * the problem is, to find out about context switches we already need
-+     * to fetch rsp
-+     * TODO: pass the pid in val.  the params pointer doesn't need to be
-+     * passed on all calls because it can be a global and be constant.
-+     */
-+    get_regs();
-+
-+    params = get_phys_mem_addr(env, (target_ulong) val);
-+
-+    /* Execute */
-+    doing_opengl = 1;
-+    ret = decode_call(env, le64_to_cpu(params[0]),
-+                    le64_to_cpu(params[1]), le64_to_cpu(params[2]),
-+                    le64_to_cpu(params[3]), le64_to_cpu(params[4]));
-+    doing_opengl = 0;
-+
-+    params[0] = cpu_to_le64(ret);
-+    params[5] = 0;
-+}
-+#endif
-+
-+static void opengl_ioport_write_first(void *data, uint32_t addr, uint32_t val)
-+{
-+    if (val != (uint32_t) -1)
-+        return;
-+
-+    /* Ignore the first outb after iopl which is emulated by the kernel.  */
-+
-+    register_ioport_write(9996, 4, 4, opengl_ioport_write, (void *) 1);
-+}
-+
-+void io_register(void)
-+{
-+    register_ioport_write(9996, 4, 4, opengl_ioport_write_first, (void *) 1);
-+}
-+
-+void opengl_process_enable(void)
-+{
-+    ram_addr_t task;
-+    char *name;
-+    int newlevel = 3;
-+    uint32_t iopl = newlevel << 12;
-+    void *ioplptr;
-+
-+    if (kvm_enabled())
-+        kvm_arch_get_registers(env);
-+    allow_kernel = 1;
-+
-+    task = x86_current_task();
-+    x86_task_cap_set(task, CAP_SYS_RAWIO);
-+    name = get_phys_mem_addr(env, x86_task_name(task));
-+
-+    ioplptr = get_phys_mem_addr(env, task +
-+                    TASKSTRUCT_THREAD_OFFSET + THREADSTRUCT_IOPL_OFFSET);
-+    ((uint32_t *) ioplptr)[0] = cpu_to_le32(iopl);
-+
-+    env->eflags &= ~0x3000;
-+    env->eflags |= newlevel << 12;
-+
-+    allow_kernel = 0;
-+    if (kvm_enabled())
-+        kvm_arch_put_registers(env, KVM_PUT_RUNTIME_STATE);
-+
-+    printf("Granted OpenGL access to process '%s'\n", name);
-+
-+    io_register();
-+}
-+#endif
-Index: qemu-0.14.0/target-i386/kvm.c
-===================================================================
---- qemu-0.14.0.orig/target-i386/kvm.c
-+++ qemu-0.14.0/target-i386/kvm.c
-@@ -957,7 +957,7 @@ static int kvm_get_xcrs(CPUState *env)
- #endif
- }
- 
--static int kvm_get_sregs(CPUState *env)
-+int kvm_get_sregs(CPUState *env)
- {
-     struct kvm_sregs sregs;
-     uint32_t hflags;
-Index: qemu-0.14.0/target-i386/mesa_enums.c
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-i386/mesa_enums.c
-@@ -0,0 +1,4890 @@
-+/* DO NOT EDIT - This file generated automatically by gl_enums.py (from Mesa) script */
-+
-+/*
-+ * Copyright (C) 1999-2005 Brian Paul All Rights Reserved.
-+ * All Rights Reserved.
-+ *
-+ * Permission is hereby granted, free of charge, to any person obtaining a
-+ * copy of this software and associated documentation files (the "Software"),
-+ * to deal in the Software without restriction, including without limitation
-+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
-+ * and/or sell copies of the Software, and to permit persons to whom the
-+ * Software is furnished to do so, subject to the following conditions:
-+ *
-+ * The above copyright notice and this permission notice (including the next
-+ * paragraph) shall be included in all copies or substantial portions of the
-+ * Software.
-+ *
-+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
-+ * BRIAN PAUL,
-+ * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
-+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-+ * SOFTWARE.
-+ */
-+
-+#include "glheader.h"
-+#include "enums.h"
-+#include "imports.h"
-+
-+typedef struct {
-+   size_t offset;
-+   int n;
-+} enum_elt;
-+
-+LONGSTRING static const char enum_string_table[] =
-+   "GL_2D\0"
-+   "GL_2_BYTES\0"
-+   "GL_3D\0"
-+   "GL_3D_COLOR\0"
-+   "GL_3D_COLOR_TEXTURE\0"
-+   "GL_3_BYTES\0"
-+   "GL_4D_COLOR_TEXTURE\0"
-+   "GL_4_BYTES\0"
-+   "GL_ACCUM\0"
-+   "GL_ACCUM_ALPHA_BITS\0"
-+   "GL_ACCUM_BLUE_BITS\0"
-+   "GL_ACCUM_BUFFER_BIT\0"
-+   "GL_ACCUM_CLEAR_VALUE\0"
-+   "GL_ACCUM_GREEN_BITS\0"
-+   "GL_ACCUM_RED_BITS\0"
-+   "GL_ACTIVE_ATTRIBUTES\0"
-+   "GL_ACTIVE_ATTRIBUTE_MAX_LENGTH\0"
-+   "GL_ACTIVE_STENCIL_FACE_EXT\0"
-+   "GL_ACTIVE_TEXTURE\0"
-+   "GL_ACTIVE_TEXTURE_ARB\0"
-+   "GL_ACTIVE_UNIFORMS\0"
-+   "GL_ACTIVE_UNIFORM_MAX_LENGTH\0"
-+   "GL_ACTIVE_VERTEX_UNITS_ARB\0"
-+   "GL_ADD\0"
-+   "GL_ADD_SIGNED\0"
-+   "GL_ADD_SIGNED_ARB\0"
-+   "GL_ADD_SIGNED_EXT\0"
-+   "GL_ALIASED_LINE_WIDTH_RANGE\0"
-+   "GL_ALIASED_POINT_SIZE_RANGE\0"
-+   "GL_ALL_ATTRIB_BITS\0"
-+   "GL_ALL_CLIENT_ATTRIB_BITS\0"
-+   "GL_ALPHA\0"
-+   "GL_ALPHA12\0"
-+   "GL_ALPHA12_EXT\0"
-+   "GL_ALPHA16\0"
-+   "GL_ALPHA16_EXT\0"
-+   "GL_ALPHA4\0"
-+   "GL_ALPHA4_EXT\0"
-+   "GL_ALPHA8\0"
-+   "GL_ALPHA8_EXT\0"
-+   "GL_ALPHA_BIAS\0"
-+   "GL_ALPHA_BITS\0"
-+   "GL_ALPHA_SCALE\0"
-+   "GL_ALPHA_TEST\0"
-+   "GL_ALPHA_TEST_FUNC\0"
-+   "GL_ALPHA_TEST_REF\0"
-+   "GL_ALWAYS\0"
-+   "GL_AMBIENT\0"
-+   "GL_AMBIENT_AND_DIFFUSE\0"
-+   "GL_AND\0"
-+   "GL_AND_INVERTED\0"
-+   "GL_AND_REVERSE\0"
-+   "GL_ARRAY_BUFFER\0"
-+   "GL_ARRAY_BUFFER_ARB\0"
-+   "GL_ARRAY_BUFFER_BINDING\0"
-+   "GL_ARRAY_BUFFER_BINDING_ARB\0"
-+   "GL_ATTACHED_SHADERS\0"
-+   "GL_ATTRIB_ARRAY_POINTER_NV\0"
-+   "GL_ATTRIB_ARRAY_SIZE_NV\0"
-+   "GL_ATTRIB_ARRAY_STRIDE_NV\0"
-+   "GL_ATTRIB_ARRAY_TYPE_NV\0"
-+   "GL_ATTRIB_STACK_DEPTH\0"
-+   "GL_AUTO_NORMAL\0"
-+   "GL_AUX0\0"
-+   "GL_AUX1\0"
-+   "GL_AUX2\0"
-+   "GL_AUX3\0"
-+   "GL_AUX_BUFFERS\0"
-+   "GL_BACK\0"
-+   "GL_BACK_LEFT\0"
-+   "GL_BACK_RIGHT\0"
-+   "GL_BGR\0"
-+   "GL_BGRA\0"
-+   "GL_BITMAP\0"
-+   "GL_BITMAP_TOKEN\0"
-+   "GL_BLEND\0"
-+   "GL_BLEND_COLOR\0"
-+   "GL_BLEND_COLOR_EXT\0"
-+   "GL_BLEND_DST\0"
-+   "GL_BLEND_DST_ALPHA\0"
-+   "GL_BLEND_DST_RGB\0"
-+   "GL_BLEND_EQUATION\0"
-+   "GL_BLEND_EQUATION_ALPHA\0"
-+   "GL_BLEND_EQUATION_ALPHA_EXT\0"
-+   "GL_BLEND_EQUATION_EXT\0"
-+   "GL_BLEND_EQUATION_RGB_EXT\0"
-+   "GL_BLEND_SRC\0"
-+   "GL_BLEND_SRC_ALPHA\0"
-+   "GL_BLEND_SRC_RGB\0"
-+   "GL_BLUE\0"
-+   "GL_BLUE_BIAS\0"
-+   "GL_BLUE_BITS\0"
-+   "GL_BLUE_SCALE\0"
-+   "GL_BOOL\0"
-+   "GL_BOOL_ARB\0"
-+   "GL_BOOL_VEC2\0"
-+   "GL_BOOL_VEC2_ARB\0"
-+   "GL_BOOL_VEC3\0"
-+   "GL_BOOL_VEC3_ARB\0"
-+   "GL_BOOL_VEC4\0"
-+   "GL_BOOL_VEC4_ARB\0"
-+   "GL_BUFFER_ACCESS\0"
-+   "GL_BUFFER_ACCESS_ARB\0"
-+   "GL_BUFFER_MAPPED\0"
-+   "GL_BUFFER_MAPPED_ARB\0"
-+   "GL_BUFFER_MAP_POINTER\0"
-+   "GL_BUFFER_MAP_POINTER_ARB\0"
-+   "GL_BUFFER_SIZE\0"
-+   "GL_BUFFER_SIZE_ARB\0"
-+   "GL_BUFFER_USAGE\0"
-+   "GL_BUFFER_USAGE_ARB\0"
-+   "GL_BYTE\0"
-+   "GL_C3F_V3F\0"
-+   "GL_C4F_N3F_V3F\0"
-+   "GL_C4UB_V2F\0"
-+   "GL_C4UB_V3F\0"
-+   "GL_CCW\0"
-+   "GL_CLAMP\0"
-+   "GL_CLAMP_TO_BORDER\0"
-+   "GL_CLAMP_TO_BORDER_ARB\0"
-+   "GL_CLAMP_TO_BORDER_SGIS\0"
-+   "GL_CLAMP_TO_EDGE\0"
-+   "GL_CLAMP_TO_EDGE_SGIS\0"
-+   "GL_CLEAR\0"
-+   "GL_CLIENT_ACTIVE_TEXTURE\0"
-+   "GL_CLIENT_ACTIVE_TEXTURE_ARB\0"
-+   "GL_CLIENT_ALL_ATTRIB_BITS\0"
-+   "GL_CLIENT_ATTRIB_STACK_DEPTH\0"
-+   "GL_CLIENT_PIXEL_STORE_BIT\0"
-+   "GL_CLIENT_VERTEX_ARRAY_BIT\0"
-+   "GL_CLIP_PLANE0\0"
-+   "GL_CLIP_PLANE1\0"
-+   "GL_CLIP_PLANE2\0"
-+   "GL_CLIP_PLANE3\0"
-+   "GL_CLIP_PLANE4\0"
-+   "GL_CLIP_PLANE5\0"
-+   "GL_CLIP_VOLUME_CLIPPING_HINT_EXT\0"
-+   "GL_COEFF\0"
-+   "GL_COLOR\0"
-+   "GL_COLOR_ARRAY\0"
-+   "GL_COLOR_ARRAY_BUFFER_BINDING\0"
-+   "GL_COLOR_ARRAY_BUFFER_BINDING_ARB\0"
-+   "GL_COLOR_ARRAY_POINTER\0"
-+   "GL_COLOR_ARRAY_SIZE\0"
-+   "GL_COLOR_ARRAY_STRIDE\0"
-+   "GL_COLOR_ARRAY_TYPE\0"
-+   "GL_COLOR_ATTACHMENT0_EXT\0"
-+   "GL_COLOR_ATTACHMENT10_EXT\0"
-+   "GL_COLOR_ATTACHMENT11_EXT\0"
-+   "GL_COLOR_ATTACHMENT12_EXT\0"
-+   "GL_COLOR_ATTACHMENT13_EXT\0"
-+   "GL_COLOR_ATTACHMENT14_EXT\0"
-+   "GL_COLOR_ATTACHMENT15_EXT\0"
-+   "GL_COLOR_ATTACHMENT1_EXT\0"
-+   "GL_COLOR_ATTACHMENT2_EXT\0"
-+   "GL_COLOR_ATTACHMENT3_EXT\0"
-+   "GL_COLOR_ATTACHMENT4_EXT\0"
-+   "GL_COLOR_ATTACHMENT5_EXT\0"
-+   "GL_COLOR_ATTACHMENT6_EXT\0"
-+   "GL_COLOR_ATTACHMENT7_EXT\0"
-+   "GL_COLOR_ATTACHMENT8_EXT\0"
-+   "GL_COLOR_ATTACHMENT9_EXT\0"
-+   "GL_COLOR_BUFFER_BIT\0"
-+   "GL_COLOR_CLEAR_VALUE\0"
-+   "GL_COLOR_INDEX\0"
-+   "GL_COLOR_INDEXES\0"
-+   "GL_COLOR_LOGIC_OP\0"
-+   "GL_COLOR_MATERIAL\0"
-+   "GL_COLOR_MATERIAL_FACE\0"
-+   "GL_COLOR_MATERIAL_PARAMETER\0"
-+   "GL_COLOR_MATRIX\0"
-+   "GL_COLOR_MATRIX_SGI\0"
-+   "GL_COLOR_MATRIX_STACK_DEPTH\0"
-+   "GL_COLOR_MATRIX_STACK_DEPTH_SGI\0"
-+   "GL_COLOR_SUM\0"
-+   "GL_COLOR_SUM_ARB\0"
-+   "GL_COLOR_TABLE\0"
-+   "GL_COLOR_TABLE_ALPHA_SIZE\0"
-+   "GL_COLOR_TABLE_ALPHA_SIZE_EXT\0"
-+   "GL_COLOR_TABLE_ALPHA_SIZE_SGI\0"
-+   "GL_COLOR_TABLE_BIAS\0"
-+   "GL_COLOR_TABLE_BIAS_SGI\0"
-+   "GL_COLOR_TABLE_BLUE_SIZE\0"
-+   "GL_COLOR_TABLE_BLUE_SIZE_EXT\0"
-+   "GL_COLOR_TABLE_BLUE_SIZE_SGI\0"
-+   "GL_COLOR_TABLE_FORMAT\0"
-+   "GL_COLOR_TABLE_FORMAT_EXT\0"
-+   "GL_COLOR_TABLE_FORMAT_SGI\0"
-+   "GL_COLOR_TABLE_GREEN_SIZE\0"
-+   "GL_COLOR_TABLE_GREEN_SIZE_EXT\0"
-+   "GL_COLOR_TABLE_GREEN_SIZE_SGI\0"
-+   "GL_COLOR_TABLE_INTENSITY_SIZE\0"
-+   "GL_COLOR_TABLE_INTENSITY_SIZE_EXT\0"
-+   "GL_COLOR_TABLE_INTENSITY_SIZE_SGI\0"
-+   "GL_COLOR_TABLE_LUMINANCE_SIZE\0"
-+   "GL_COLOR_TABLE_LUMINANCE_SIZE_EXT\0"
-+   "GL_COLOR_TABLE_LUMINANCE_SIZE_SGI\0"
-+   "GL_COLOR_TABLE_RED_SIZE\0"
-+   "GL_COLOR_TABLE_RED_SIZE_EXT\0"
-+   "GL_COLOR_TABLE_RED_SIZE_SGI\0"
-+   "GL_COLOR_TABLE_SCALE\0"
-+   "GL_COLOR_TABLE_SCALE_SGI\0"
-+   "GL_COLOR_TABLE_WIDTH\0"
-+   "GL_COLOR_TABLE_WIDTH_EXT\0"
-+   "GL_COLOR_TABLE_WIDTH_SGI\0"
-+   "GL_COLOR_WRITEMASK\0"
-+   "GL_COMBINE\0"
-+   "GL_COMBINE4\0"
-+   "GL_COMBINE_ALPHA\0"
-+   "GL_COMBINE_ALPHA_ARB\0"
-+   "GL_COMBINE_ALPHA_EXT\0"
-+   "GL_COMBINE_ARB\0"
-+   "GL_COMBINE_EXT\0"
-+   "GL_COMBINE_RGB\0"
-+   "GL_COMBINE_RGB_ARB\0"
-+   "GL_COMBINE_RGB_EXT\0"
-+   "GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT\0"
-+   "GL_COMPARE_R_TO_TEXTURE\0"
-+   "GL_COMPARE_R_TO_TEXTURE_ARB\0"
-+   "GL_COMPILE\0"
-+   "GL_COMPILE_AND_EXECUTE\0"
-+   "GL_COMPILE_STATUS\0"
-+   "GL_COMPRESSED_ALPHA\0"
-+   "GL_COMPRESSED_ALPHA_ARB\0"
-+   "GL_COMPRESSED_INTENSITY\0"
-+   "GL_COMPRESSED_INTENSITY_ARB\0"
-+   "GL_COMPRESSED_LUMINANCE\0"
-+   "GL_COMPRESSED_LUMINANCE_ALPHA\0"
-+   "GL_COMPRESSED_LUMINANCE_ALPHA_ARB\0"
-+   "GL_COMPRESSED_LUMINANCE_ARB\0"
-+   "GL_COMPRESSED_RGB\0"
-+   "GL_COMPRESSED_RGBA\0"
-+   "GL_COMPRESSED_RGBA_ARB\0"
-+   "GL_COMPRESSED_RGBA_FXT1_3DFX\0"
-+   "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT\0"
-+   "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT\0"
-+   "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT\0"
-+   "GL_COMPRESSED_RGB_ARB\0"
-+   "GL_COMPRESSED_RGB_FXT1_3DFX\0"
-+   "GL_COMPRESSED_RGB_S3TC_DXT1_EXT\0"
-+   "GL_COMPRESSED_TEXTURE_FORMATS\0"
-+   "GL_CONSTANT\0"
-+   "GL_CONSTANT_ALPHA\0"
-+   "GL_CONSTANT_ALPHA_EXT\0"
-+   "GL_CONSTANT_ARB\0"
-+   "GL_CONSTANT_ATTENUATION\0"
-+   "GL_CONSTANT_BORDER_HP\0"
-+   "GL_CONSTANT_COLOR\0"
-+   "GL_CONSTANT_COLOR_EXT\0"
-+   "GL_CONSTANT_EXT\0"
-+   "GL_CONVOLUTION_1D\0"
-+   "GL_CONVOLUTION_2D\0"
-+   "GL_CONVOLUTION_BORDER_COLOR\0"
-+   "GL_CONVOLUTION_BORDER_COLOR_HP\0"
-+   "GL_CONVOLUTION_BORDER_MODE\0"
-+   "GL_CONVOLUTION_BORDER_MODE_EXT\0"
-+   "GL_CONVOLUTION_FILTER_BIAS\0"
-+   "GL_CONVOLUTION_FILTER_BIAS_EXT\0"
-+   "GL_CONVOLUTION_FILTER_SCALE\0"
-+   "GL_CONVOLUTION_FILTER_SCALE_EXT\0"
-+   "GL_CONVOLUTION_FORMAT\0"
-+   "GL_CONVOLUTION_FORMAT_EXT\0"
-+   "GL_CONVOLUTION_HEIGHT\0"
-+   "GL_CONVOLUTION_HEIGHT_EXT\0"
-+   "GL_CONVOLUTION_WIDTH\0"
-+   "GL_CONVOLUTION_WIDTH_EXT\0"
-+   "GL_COORD_REPLACE\0"
-+   "GL_COORD_REPLACE_ARB\0"
-+   "GL_COORD_REPLACE_NV\0"
-+   "GL_COPY\0"
-+   "GL_COPY_INVERTED\0"
-+   "GL_COPY_PIXEL_TOKEN\0"
-+   "GL_CULL_FACE\0"
-+   "GL_CULL_FACE_MODE\0"
-+   "GL_CULL_VERTEX_EXT\0"
-+   "GL_CULL_VERTEX_EYE_POSITION_EXT\0"
-+   "GL_CULL_VERTEX_OBJECT_POSITION_EXT\0"
-+   "GL_CURRENT_ATTRIB_NV\0"
-+   "GL_CURRENT_BIT\0"
-+   "GL_CURRENT_COLOR\0"
-+   "GL_CURRENT_FOG_COORD\0"
-+   "GL_CURRENT_FOG_COORDINATE\0"
-+   "GL_CURRENT_INDEX\0"
-+   "GL_CURRENT_MATRIX_ARB\0"
-+   "GL_CURRENT_MATRIX_INDEX_ARB\0"
-+   "GL_CURRENT_MATRIX_NV\0"
-+   "GL_CURRENT_MATRIX_STACK_DEPTH_ARB\0"
-+   "GL_CURRENT_MATRIX_STACK_DEPTH_NV\0"
-+   "GL_CURRENT_NORMAL\0"
-+   "GL_CURRENT_PALETTE_MATRIX_ARB\0"
-+   "GL_CURRENT_PROGRAM\0"
-+   "GL_CURRENT_QUERY\0"
-+   "GL_CURRENT_QUERY_ARB\0"
-+   "GL_CURRENT_RASTER_COLOR\0"
-+   "GL_CURRENT_RASTER_DISTANCE\0"
-+   "GL_CURRENT_RASTER_INDEX\0"
-+   "GL_CURRENT_RASTER_POSITION\0"
-+   "GL_CURRENT_RASTER_POSITION_VALID\0"
-+   "GL_CURRENT_RASTER_TEXTURE_COORDS\0"
-+   "GL_CURRENT_SECONDARY_COLOR\0"
-+   "GL_CURRENT_TEXTURE_COORDS\0"
-+   "GL_CURRENT_VERTEX_ATTRIB\0"
-+   "GL_CURRENT_VERTEX_ATTRIB_ARB\0"
-+   "GL_CURRENT_WEIGHT_ARB\0"
-+   "GL_CW\0"
-+   "GL_DEBUG_ASSERT_MESA\0"
-+   "GL_DEBUG_OBJECT_MESA\0"
-+   "GL_DEBUG_PRINT_MESA\0"
-+   "GL_DECAL\0"
-+   "GL_DECR\0"
-+   "GL_DECR_WRAP\0"
-+   "GL_DECR_WRAP_EXT\0"
-+   "GL_DELETE_STATUS\0"
-+   "GL_DEPTH\0"
-+   "GL_DEPTH_ATTACHMENT_EXT\0"
-+   "GL_DEPTH_BIAS\0"
-+   "GL_DEPTH_BITS\0"
-+   "GL_DEPTH_BOUNDS_EXT\0"
-+   "GL_DEPTH_BOUNDS_TEST_EXT\0"
-+   "GL_DEPTH_BUFFER_BIT\0"
-+   "GL_DEPTH_CLAMP_NV\0"
-+   "GL_DEPTH_CLEAR_VALUE\0"
-+   "GL_DEPTH_COMPONENT\0"
-+   "GL_DEPTH_COMPONENT16\0"
-+   "GL_DEPTH_COMPONENT16_ARB\0"
-+   "GL_DEPTH_COMPONENT16_SGIX\0"
-+   "GL_DEPTH_COMPONENT24\0"
-+   "GL_DEPTH_COMPONENT24_ARB\0"
-+   "GL_DEPTH_COMPONENT24_SGIX\0"
-+   "GL_DEPTH_COMPONENT32\0"
-+   "GL_DEPTH_COMPONENT32_ARB\0"
-+   "GL_DEPTH_COMPONENT32_SGIX\0"
-+   "GL_DEPTH_FUNC\0"
-+   "GL_DEPTH_RANGE\0"
-+   "GL_DEPTH_SCALE\0"
-+   "GL_DEPTH_STENCIL_NV\0"
-+   "GL_DEPTH_STENCIL_TO_BGRA_NV\0"
-+   "GL_DEPTH_STENCIL_TO_RGBA_NV\0"
-+   "GL_DEPTH_TEST\0"
-+   "GL_DEPTH_TEXTURE_MODE\0"
-+   "GL_DEPTH_TEXTURE_MODE_ARB\0"
-+   "GL_DEPTH_WRITEMASK\0"
-+   "GL_DIFFUSE\0"
-+   "GL_DITHER\0"
-+   "GL_DOMAIN\0"
-+   "GL_DONT_CARE\0"
-+   "GL_DOT3_RGB\0"
-+   "GL_DOT3_RGBA\0"
-+   "GL_DOT3_RGBA_ARB\0"
-+   "GL_DOT3_RGBA_EXT\0"
-+   "GL_DOT3_RGB_ARB\0"
-+   "GL_DOT3_RGB_EXT\0"
-+   "GL_DOUBLE\0"
-+   "GL_DOUBLEBUFFER\0"
-+   "GL_DRAW_BUFFER\0"
-+   "GL_DRAW_BUFFER0\0"
-+   "GL_DRAW_BUFFER0_ARB\0"
-+   "GL_DRAW_BUFFER0_ATI\0"
-+   "GL_DRAW_BUFFER1\0"
-+   "GL_DRAW_BUFFER10\0"
-+   "GL_DRAW_BUFFER10_ARB\0"
-+   "GL_DRAW_BUFFER10_ATI\0"
-+   "GL_DRAW_BUFFER11\0"
-+   "GL_DRAW_BUFFER11_ARB\0"
-+   "GL_DRAW_BUFFER11_ATI\0"
-+   "GL_DRAW_BUFFER12\0"
-+   "GL_DRAW_BUFFER12_ARB\0"
-+   "GL_DRAW_BUFFER12_ATI\0"
-+   "GL_DRAW_BUFFER13\0"
-+   "GL_DRAW_BUFFER13_ARB\0"
-+   "GL_DRAW_BUFFER13_ATI\0"
-+   "GL_DRAW_BUFFER14\0"
-+   "GL_DRAW_BUFFER14_ARB\0"
-+   "GL_DRAW_BUFFER14_ATI\0"
-+   "GL_DRAW_BUFFER15\0"
-+   "GL_DRAW_BUFFER15_ARB\0"
-+   "GL_DRAW_BUFFER15_ATI\0"
-+   "GL_DRAW_BUFFER1_ARB\0"
-+   "GL_DRAW_BUFFER1_ATI\0"
-+   "GL_DRAW_BUFFER2\0"
-+   "GL_DRAW_BUFFER2_ARB\0"
-+   "GL_DRAW_BUFFER2_ATI\0"
-+   "GL_DRAW_BUFFER3\0"
-+   "GL_DRAW_BUFFER3_ARB\0"
-+   "GL_DRAW_BUFFER3_ATI\0"
-+   "GL_DRAW_BUFFER4\0"
-+   "GL_DRAW_BUFFER4_ARB\0"
-+   "GL_DRAW_BUFFER4_ATI\0"
-+   "GL_DRAW_BUFFER5\0"
-+   "GL_DRAW_BUFFER5_ARB\0"
-+   "GL_DRAW_BUFFER5_ATI\0"
-+   "GL_DRAW_BUFFER6\0"
-+   "GL_DRAW_BUFFER6_ARB\0"
-+   "GL_DRAW_BUFFER6_ATI\0"
-+   "GL_DRAW_BUFFER7\0"
-+   "GL_DRAW_BUFFER7_ARB\0"
-+   "GL_DRAW_BUFFER7_ATI\0"
-+   "GL_DRAW_BUFFER8\0"
-+   "GL_DRAW_BUFFER8_ARB\0"
-+   "GL_DRAW_BUFFER8_ATI\0"
-+   "GL_DRAW_BUFFER9\0"
-+   "GL_DRAW_BUFFER9_ARB\0"
-+   "GL_DRAW_BUFFER9_ATI\0"
-+   "GL_DRAW_FRAMEBUFFER_BINDING_EXT\0"
-+   "GL_DRAW_FRAMEBUFFER_EXT\0"
-+   "GL_DRAW_PIXEL_TOKEN\0"
-+   "GL_DST_ALPHA\0"
-+   "GL_DST_COLOR\0"
-+   "GL_DYNAMIC_COPY\0"
-+   "GL_DYNAMIC_COPY_ARB\0"
-+   "GL_DYNAMIC_DRAW\0"
-+   "GL_DYNAMIC_DRAW_ARB\0"
-+   "GL_DYNAMIC_READ\0"
-+   "GL_DYNAMIC_READ_ARB\0"
-+   "GL_EDGE_FLAG\0"
-+   "GL_EDGE_FLAG_ARRAY\0"
-+   "GL_EDGE_FLAG_ARRAY_BUFFER_BINDING\0"
-+   "GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB\0"
-+   "GL_EDGE_FLAG_ARRAY_POINTER\0"
-+   "GL_EDGE_FLAG_ARRAY_STRIDE\0"
-+   "GL_ELEMENT_ARRAY_BUFFER\0"
-+   "GL_ELEMENT_ARRAY_BUFFER_ARB\0"
-+   "GL_ELEMENT_ARRAY_BUFFER_BINDING\0"
-+   "GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB\0"
-+   "GL_EMISSION\0"
-+   "GL_ENABLE_BIT\0"
-+   "GL_EQUAL\0"
-+   "GL_EQUIV\0"
-+   "GL_EVAL_BIT\0"
-+   "GL_EXP\0"
-+   "GL_EXP2\0"
-+   "GL_EXTENSIONS\0"
-+   "GL_EYE_LINEAR\0"
-+   "GL_EYE_PLANE\0"
-+   "GL_EYE_PLANE_ABSOLUTE_NV\0"
-+   "GL_EYE_RADIAL_NV\0"
-+   "GL_FALSE\0"
-+   "GL_FASTEST\0"
-+   "GL_FEEDBACK\0"
-+   "GL_FEEDBACK_BUFFER_POINTER\0"
-+   "GL_FEEDBACK_BUFFER_SIZE\0"
-+   "GL_FEEDBACK_BUFFER_TYPE\0"
-+   "GL_FILL\0"
-+   "GL_FLAT\0"
-+   "GL_FLOAT\0"
-+   "GL_FLOAT_MAT2\0"
-+   "GL_FLOAT_MAT2_ARB\0"
-+   "GL_FLOAT_MAT3\0"
-+   "GL_FLOAT_MAT3_ARB\0"
-+   "GL_FLOAT_MAT4\0"
-+   "GL_FLOAT_MAT4_ARB\0"
-+   "GL_FLOAT_VEC2\0"
-+   "GL_FLOAT_VEC2_ARB\0"
-+   "GL_FLOAT_VEC3\0"
-+   "GL_FLOAT_VEC3_ARB\0"
-+   "GL_FLOAT_VEC4\0"
-+   "GL_FLOAT_VEC4_ARB\0"
-+   "GL_FOG\0"
-+   "GL_FOG_BIT\0"
-+   "GL_FOG_COLOR\0"
-+   "GL_FOG_COORD\0"
-+   "GL_FOG_COORDINATE\0"
-+   "GL_FOG_COORDINATE_ARRAY\0"
-+   "GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING\0"
-+   "GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB\0"
-+   "GL_FOG_COORDINATE_ARRAY_POINTER\0"
-+   "GL_FOG_COORDINATE_ARRAY_STRIDE\0"
-+   "GL_FOG_COORDINATE_ARRAY_TYPE\0"
-+   "GL_FOG_COORDINATE_SOURCE\0"
-+   "GL_FOG_COORD_ARRAY\0"
-+   "GL_FOG_COORD_ARRAY_BUFFER_BINDING\0"
-+   "GL_FOG_COORD_ARRAY_POINTER\0"
-+   "GL_FOG_COORD_ARRAY_STRIDE\0"
-+   "GL_FOG_COORD_ARRAY_TYPE\0"
-+   "GL_FOG_COORD_SRC\0"
-+   "GL_FOG_DENSITY\0"
-+   "GL_FOG_DISTANCE_MODE_NV\0"
-+   "GL_FOG_END\0"
-+   "GL_FOG_HINT\0"
-+   "GL_FOG_INDEX\0"
-+   "GL_FOG_MODE\0"
-+   "GL_FOG_OFFSET_SGIX\0"
-+   "GL_FOG_OFFSET_VALUE_SGIX\0"
-+   "GL_FOG_START\0"
-+   "GL_FRAGMENT_DEPTH\0"
-+   "GL_FRAGMENT_PROGRAM_ARB\0"
-+   "GL_FRAGMENT_SHADER\0"
-+   "GL_FRAGMENT_SHADER_ARB\0"
-+   "GL_FRAGMENT_SHADER_DERIVATIVE_HINT\0"
-+   "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT\0"
-+   "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT\0"
-+   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT\0"
-+   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT\0"
-+   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT\0"
-+   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT\0"
-+   "GL_FRAMEBUFFER_BINDING_EXT\0"
-+   "GL_FRAMEBUFFER_COMPLETE_EXT\0"
-+   "GL_FRAMEBUFFER_EXT\0"
-+   "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT\0"
-+   "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT\0"
-+   "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT\0"
-+   "GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT\0"
-+   "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT\0"
-+   "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT\0"
-+   "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT\0"
-+   "GL_FRAMEBUFFER_STATUS_ERROR_EXT\0"
-+   "GL_FRAMEBUFFER_UNSUPPORTED_EXT\0"
-+   "GL_FRONT\0"
-+   "GL_FRONT_AND_BACK\0"
-+   "GL_FRONT_FACE\0"
-+   "GL_FRONT_LEFT\0"
-+   "GL_FRONT_RIGHT\0"
-+   "GL_FUNC_ADD\0"
-+   "GL_FUNC_ADD_EXT\0"
-+   "GL_FUNC_REVERSE_SUBTRACT\0"
-+   "GL_FUNC_REVERSE_SUBTRACT_EXT\0"
-+   "GL_FUNC_SUBTRACT\0"
-+   "GL_FUNC_SUBTRACT_EXT\0"
-+   "GL_GENERATE_MIPMAP\0"
-+   "GL_GENERATE_MIPMAP_HINT\0"
-+   "GL_GENERATE_MIPMAP_HINT_SGIS\0"
-+   "GL_GENERATE_MIPMAP_SGIS\0"
-+   "GL_GEQUAL\0"
-+   "GL_GL_BLEND_EQUATION_RGB\0"
-+   "GL_GL_COMPRESSED_SLUMINANCE\0"
-+   "GL_GL_COMPRESSED_SLUMINANCE_ALPHA\0"
-+   "GL_GL_COMPRESSED_SRGB\0"
-+   "GL_GL_COMPRESSED_SRGB_ALPHA\0"
-+   "GL_GL_CURRENT_RASTER_SECONDARY_COLOR\0"
-+   "GL_GL_FLOAT_MAT2x3\0"
-+   "GL_GL_FLOAT_MAT2x4\0"
-+   "GL_GL_FLOAT_MAT3x2\0"
-+   "GL_GL_FLOAT_MAT3x4\0"
-+   "GL_GL_FLOAT_MAT4x2\0"
-+   "GL_GL_FLOAT_MAT4x3\0"
-+   "GL_GL_PIXEL_PACK_BUFFER\0"
-+   "GL_GL_PIXEL_PACK_BUFFER_BINDING\0"
-+   "GL_GL_PIXEL_UNPACK_BUFFER\0"
-+   "GL_GL_PIXEL_UNPACK_BUFFER_BINDING\0"
-+   "GL_GL_SLUMINANCE\0"
-+   "GL_GL_SLUMINANCE8\0"
-+   "GL_GL_SLUMINANCE8_ALPHA8\0"
-+   "GL_GL_SLUMINANCE_ALPHA\0"
-+   "GL_GL_SRGB\0"
-+   "GL_GL_SRGB8\0"
-+   "GL_GL_SRGB8_ALPHA8\0"
-+   "GL_GL_SRGB_ALPHA\0"
-+   "GL_GREATER\0"
-+   "GL_GREEN\0"
-+   "GL_GREEN_BIAS\0"
-+   "GL_GREEN_BITS\0"
-+   "GL_GREEN_SCALE\0"
-+   "GL_HINT_BIT\0"
-+   "GL_HISTOGRAM\0"
-+   "GL_HISTOGRAM_ALPHA_SIZE\0"
-+   "GL_HISTOGRAM_ALPHA_SIZE_EXT\0"
-+   "GL_HISTOGRAM_BLUE_SIZE\0"
-+   "GL_HISTOGRAM_BLUE_SIZE_EXT\0"
-+   "GL_HISTOGRAM_EXT\0"
-+   "GL_HISTOGRAM_FORMAT\0"
-+   "GL_HISTOGRAM_FORMAT_EXT\0"
-+   "GL_HISTOGRAM_GREEN_SIZE\0"
-+   "GL_HISTOGRAM_GREEN_SIZE_EXT\0"
-+   "GL_HISTOGRAM_LUMINANCE_SIZE\0"
-+   "GL_HISTOGRAM_LUMINANCE_SIZE_EXT\0"
-+   "GL_HISTOGRAM_RED_SIZE\0"
-+   "GL_HISTOGRAM_RED_SIZE_EXT\0"
-+   "GL_HISTOGRAM_SINK\0"
-+   "GL_HISTOGRAM_SINK_EXT\0"
-+   "GL_HISTOGRAM_WIDTH\0"
-+   "GL_HISTOGRAM_WIDTH_EXT\0"
-+   "GL_IDENTITY_NV\0"
-+   "GL_IGNORE_BORDER_HP\0"
-+   "GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES\0"
-+   "GL_IMPLEMENTATION_COLOR_READ_TYPE_OES\0"
-+   "GL_INCR\0"
-+   "GL_INCR_WRAP\0"
-+   "GL_INCR_WRAP_EXT\0"
-+   "GL_INDEX_ARRAY\0"
-+   "GL_INDEX_ARRAY_BUFFER_BINDING\0"
-+   "GL_INDEX_ARRAY_BUFFER_BINDING_ARB\0"
-+   "GL_INDEX_ARRAY_POINTER\0"
-+   "GL_INDEX_ARRAY_STRIDE\0"
-+   "GL_INDEX_ARRAY_TYPE\0"
-+   "GL_INDEX_BITS\0"
-+   "GL_INDEX_CLEAR_VALUE\0"
-+   "GL_INDEX_LOGIC_OP\0"
-+   "GL_INDEX_MODE\0"
-+   "GL_INDEX_OFFSET\0"
-+   "GL_INDEX_SHIFT\0"
-+   "GL_INDEX_WRITEMASK\0"
-+   "GL_INFO_LOG_LENGTH\0"
-+   "GL_INT\0"
-+   "GL_INTENSITY\0"
-+   "GL_INTENSITY12\0"
-+   "GL_INTENSITY12_EXT\0"
-+   "GL_INTENSITY16\0"
-+   "GL_INTENSITY16_EXT\0"
-+   "GL_INTENSITY4\0"
-+   "GL_INTENSITY4_EXT\0"
-+   "GL_INTENSITY8\0"
-+   "GL_INTENSITY8_EXT\0"
-+   "GL_INTENSITY_EXT\0"
-+   "GL_INTERPOLATE\0"
-+   "GL_INTERPOLATE_ARB\0"
-+   "GL_INTERPOLATE_EXT\0"
-+   "GL_INT_VEC2\0"
-+   "GL_INT_VEC2_ARB\0"
-+   "GL_INT_VEC3\0"
-+   "GL_INT_VEC3_ARB\0"
-+   "GL_INT_VEC4\0"
-+   "GL_INT_VEC4_ARB\0"
-+   "GL_INVALID_ENUM\0"
-+   "GL_INVALID_FRAMEBUFFER_OPERATION_EXT\0"
-+   "GL_INVALID_OPERATION\0"
-+   "GL_INVALID_VALUE\0"
-+   "GL_INVERSE_NV\0"
-+   "GL_INVERSE_TRANSPOSE_NV\0"
-+   "GL_INVERT\0"
-+   "GL_KEEP\0"
-+   "GL_LEFT\0"
-+   "GL_LEQUAL\0"
-+   "GL_LESS\0"
-+   "GL_LIGHT0\0"
-+   "GL_LIGHT1\0"
-+   "GL_LIGHT2\0"
-+   "GL_LIGHT3\0"
-+   "GL_LIGHT4\0"
-+   "GL_LIGHT5\0"
-+   "GL_LIGHT6\0"
-+   "GL_LIGHT7\0"
-+   "GL_LIGHTING\0"
-+   "GL_LIGHTING_BIT\0"
-+   "GL_LIGHT_MODEL_AMBIENT\0"
-+   "GL_LIGHT_MODEL_COLOR_CONTROL\0"
-+   "GL_LIGHT_MODEL_COLOR_CONTROL_EXT\0"
-+   "GL_LIGHT_MODEL_LOCAL_VIEWER\0"
-+   "GL_LIGHT_MODEL_TWO_SIDE\0"
-+   "GL_LINE\0"
-+   "GL_LINEAR\0"
-+   "GL_LINEAR_ATTENUATION\0"
-+   "GL_LINEAR_CLIPMAP_LINEAR_SGIX\0"
-+   "GL_LINEAR_CLIPMAP_NEAREST_SGIX\0"
-+   "GL_LINEAR_MIPMAP_LINEAR\0"
-+   "GL_LINEAR_MIPMAP_NEAREST\0"
-+   "GL_LINES\0"
-+   "GL_LINE_BIT\0"
-+   "GL_LINE_LOOP\0"
-+   "GL_LINE_RESET_TOKEN\0"
-+   "GL_LINE_SMOOTH\0"
-+   "GL_LINE_SMOOTH_HINT\0"
-+   "GL_LINE_STIPPLE\0"
-+   "GL_LINE_STIPPLE_PATTERN\0"
-+   "GL_LINE_STIPPLE_REPEAT\0"
-+   "GL_LINE_STRIP\0"
-+   "GL_LINE_TOKEN\0"
-+   "GL_LINE_WIDTH\0"
-+   "GL_LINE_WIDTH_GRANULARITY\0"
-+   "GL_LINE_WIDTH_RANGE\0"
-+   "GL_LINK_STATUS\0"
-+   "GL_LIST_BASE\0"
-+   "GL_LIST_BIT\0"
-+   "GL_LIST_INDEX\0"
-+   "GL_LIST_MODE\0"
-+   "GL_LOAD\0"
-+   "GL_LOGIC_OP\0"
-+   "GL_LOGIC_OP_MODE\0"
-+   "GL_LOWER_LEFT\0"
-+   "GL_LUMINANCE\0"
-+   "GL_LUMINANCE12\0"
-+   "GL_LUMINANCE12_ALPHA12\0"
-+   "GL_LUMINANCE12_ALPHA12_EXT\0"
-+   "GL_LUMINANCE12_ALPHA4\0"
-+   "GL_LUMINANCE12_ALPHA4_EXT\0"
-+   "GL_LUMINANCE12_EXT\0"
-+   "GL_LUMINANCE16\0"
-+   "GL_LUMINANCE16_ALPHA16\0"
-+   "GL_LUMINANCE16_ALPHA16_EXT\0"
-+   "GL_LUMINANCE16_EXT\0"
-+   "GL_LUMINANCE4\0"
-+   "GL_LUMINANCE4_ALPHA4\0"
-+   "GL_LUMINANCE4_ALPHA4_EXT\0"
-+   "GL_LUMINANCE4_EXT\0"
-+   "GL_LUMINANCE6_ALPHA2\0"
-+   "GL_LUMINANCE6_ALPHA2_EXT\0"
-+   "GL_LUMINANCE8\0"
-+   "GL_LUMINANCE8_ALPHA8\0"
-+   "GL_LUMINANCE8_ALPHA8_EXT\0"
-+   "GL_LUMINANCE8_EXT\0"
-+   "GL_LUMINANCE_ALPHA\0"
-+   "GL_MAP1_COLOR_4\0"
-+   "GL_MAP1_GRID_DOMAIN\0"
-+   "GL_MAP1_GRID_SEGMENTS\0"
-+   "GL_MAP1_INDEX\0"
-+   "GL_MAP1_NORMAL\0"
-+   "GL_MAP1_TEXTURE_COORD_1\0"
-+   "GL_MAP1_TEXTURE_COORD_2\0"
-+   "GL_MAP1_TEXTURE_COORD_3\0"
-+   "GL_MAP1_TEXTURE_COORD_4\0"
-+   "GL_MAP1_VERTEX_3\0"
-+   "GL_MAP1_VERTEX_4\0"
-+   "GL_MAP1_VERTEX_ATTRIB0_4_NV\0"
-+   "GL_MAP1_VERTEX_ATTRIB10_4_NV\0"
-+   "GL_MAP1_VERTEX_ATTRIB11_4_NV\0"
-+   "GL_MAP1_VERTEX_ATTRIB12_4_NV\0"
-+   "GL_MAP1_VERTEX_ATTRIB13_4_NV\0"
-+   "GL_MAP1_VERTEX_ATTRIB14_4_NV\0"
-+   "GL_MAP1_VERTEX_ATTRIB15_4_NV\0"
-+   "GL_MAP1_VERTEX_ATTRIB1_4_NV\0"
-+   "GL_MAP1_VERTEX_ATTRIB2_4_NV\0"
-+   "GL_MAP1_VERTEX_ATTRIB3_4_NV\0"
-+   "GL_MAP1_VERTEX_ATTRIB4_4_NV\0"
-+   "GL_MAP1_VERTEX_ATTRIB5_4_NV\0"
-+   "GL_MAP1_VERTEX_ATTRIB6_4_NV\0"
-+   "GL_MAP1_VERTEX_ATTRIB7_4_NV\0"
-+   "GL_MAP1_VERTEX_ATTRIB8_4_NV\0"
-+   "GL_MAP1_VERTEX_ATTRIB9_4_NV\0"
-+   "GL_MAP2_COLOR_4\0"
-+   "GL_MAP2_GRID_DOMAIN\0"
-+   "GL_MAP2_GRID_SEGMENTS\0"
-+   "GL_MAP2_INDEX\0"
-+   "GL_MAP2_NORMAL\0"
-+   "GL_MAP2_TEXTURE_COORD_1\0"
-+   "GL_MAP2_TEXTURE_COORD_2\0"
-+   "GL_MAP2_TEXTURE_COORD_3\0"
-+   "GL_MAP2_TEXTURE_COORD_4\0"
-+   "GL_MAP2_VERTEX_3\0"
-+   "GL_MAP2_VERTEX_4\0"
-+   "GL_MAP2_VERTEX_ATTRIB0_4_NV\0"
-+   "GL_MAP2_VERTEX_ATTRIB10_4_NV\0"
-+   "GL_MAP2_VERTEX_ATTRIB11_4_NV\0"
-+   "GL_MAP2_VERTEX_ATTRIB12_4_NV\0"
-+   "GL_MAP2_VERTEX_ATTRIB13_4_NV\0"
-+   "GL_MAP2_VERTEX_ATTRIB14_4_NV\0"
-+   "GL_MAP2_VERTEX_ATTRIB15_4_NV\0"
-+   "GL_MAP2_VERTEX_ATTRIB1_4_NV\0"
-+   "GL_MAP2_VERTEX_ATTRIB2_4_NV\0"
-+   "GL_MAP2_VERTEX_ATTRIB3_4_NV\0"
-+   "GL_MAP2_VERTEX_ATTRIB4_4_NV\0"
-+   "GL_MAP2_VERTEX_ATTRIB5_4_NV\0"
-+   "GL_MAP2_VERTEX_ATTRIB6_4_NV\0"
-+   "GL_MAP2_VERTEX_ATTRIB7_4_NV\0"
-+   "GL_MAP2_VERTEX_ATTRIB8_4_NV\0"
-+   "GL_MAP2_VERTEX_ATTRIB9_4_NV\0"
-+   "GL_MAP_COLOR\0"
-+   "GL_MAP_STENCIL\0"
-+   "GL_MATRIX0_ARB\0"
-+   "GL_MATRIX0_NV\0"
-+   "GL_MATRIX10_ARB\0"
-+   "GL_MATRIX11_ARB\0"
-+   "GL_MATRIX12_ARB\0"
-+   "GL_MATRIX13_ARB\0"
-+   "GL_MATRIX14_ARB\0"
-+   "GL_MATRIX15_ARB\0"
-+   "GL_MATRIX16_ARB\0"
-+   "GL_MATRIX17_ARB\0"
-+   "GL_MATRIX18_ARB\0"
-+   "GL_MATRIX19_ARB\0"
-+   "GL_MATRIX1_ARB\0"
-+   "GL_MATRIX1_NV\0"
-+   "GL_MATRIX20_ARB\0"
-+   "GL_MATRIX21_ARB\0"
-+   "GL_MATRIX22_ARB\0"
-+   "GL_MATRIX23_ARB\0"
-+   "GL_MATRIX24_ARB\0"
-+   "GL_MATRIX25_ARB\0"
-+   "GL_MATRIX26_ARB\0"
-+   "GL_MATRIX27_ARB\0"
-+   "GL_MATRIX28_ARB\0"
-+   "GL_MATRIX29_ARB\0"
-+   "GL_MATRIX2_ARB\0"
-+   "GL_MATRIX2_NV\0"
-+   "GL_MATRIX30_ARB\0"
-+   "GL_MATRIX31_ARB\0"
-+   "GL_MATRIX3_ARB\0"
-+   "GL_MATRIX3_NV\0"
-+   "GL_MATRIX4_ARB\0"
-+   "GL_MATRIX4_NV\0"
-+   "GL_MATRIX5_ARB\0"
-+   "GL_MATRIX5_NV\0"
-+   "GL_MATRIX6_ARB\0"
-+   "GL_MATRIX6_NV\0"
-+   "GL_MATRIX7_ARB\0"
-+   "GL_MATRIX7_NV\0"
-+   "GL_MATRIX8_ARB\0"
-+   "GL_MATRIX9_ARB\0"
-+   "GL_MATRIX_INDEX_ARRAY_ARB\0"
-+   "GL_MATRIX_INDEX_ARRAY_POINTER_ARB\0"
-+   "GL_MATRIX_INDEX_ARRAY_SIZE_ARB\0"
-+   "GL_MATRIX_INDEX_ARRAY_STRIDE_ARB\0"
-+   "GL_MATRIX_INDEX_ARRAY_TYPE_ARB\0"
-+   "GL_MATRIX_MODE\0"
-+   "GL_MATRIX_PALETTE_ARB\0"
-+   "GL_MAX\0"
-+   "GL_MAX_3D_TEXTURE_SIZE\0"
-+   "GL_MAX_ARRAY_TEXTURE_LAYERS_EXT\0"
-+   "GL_MAX_ATTRIB_STACK_DEPTH\0"
-+   "GL_MAX_CLIENT_ATTRIB_STACK_DEPTH\0"
-+   "GL_MAX_CLIPMAP_DEPTH_SGIX\0"
-+   "GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX\0"
-+   "GL_MAX_CLIP_PLANES\0"
-+   "GL_MAX_COLOR_ATTACHMENTS_EXT\0"
-+   "GL_MAX_COLOR_MATRIX_STACK_DEPTH\0"
-+   "GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI\0"
-+   "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS\0"
-+   "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB\0"
-+   "GL_MAX_CONVOLUTION_HEIGHT\0"
-+   "GL_MAX_CONVOLUTION_HEIGHT_EXT\0"
-+   "GL_MAX_CONVOLUTION_WIDTH\0"
-+   "GL_MAX_CONVOLUTION_WIDTH_EXT\0"
-+   "GL_MAX_CUBE_MAP_TEXTURE_SIZE\0"
-+   "GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB\0"
-+   "GL_MAX_DRAW_BUFFERS\0"
-+   "GL_MAX_DRAW_BUFFERS_ARB\0"
-+   "GL_MAX_DRAW_BUFFERS_ATI\0"
-+   "GL_MAX_ELEMENTS_INDICES\0"
-+   "GL_MAX_ELEMENTS_VERTICES\0"
-+   "GL_MAX_EVAL_ORDER\0"
-+   "GL_MAX_EXT\0"
-+   "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS\0"
-+   "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB\0"
-+   "GL_MAX_LIGHTS\0"
-+   "GL_MAX_LIST_NESTING\0"
-+   "GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB\0"
-+   "GL_MAX_MODELVIEW_STACK_DEPTH\0"
-+   "GL_MAX_NAME_STACK_DEPTH\0"
-+   "GL_MAX_PALETTE_MATRICES_ARB\0"
-+   "GL_MAX_PIXEL_MAP_TABLE\0"
-+   "GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB\0"
-+   "GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB\0"
-+   "GL_MAX_PROGRAM_ATTRIBS_ARB\0"
-+   "GL_MAX_PROGRAM_CALL_DEPTH_NV\0"
-+   "GL_MAX_PROGRAM_ENV_PARAMETERS_ARB\0"
-+   "GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV\0"
-+   "GL_MAX_PROGRAM_IF_DEPTH_NV\0"
-+   "GL_MAX_PROGRAM_INSTRUCTIONS_ARB\0"
-+   "GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB\0"
-+   "GL_MAX_PROGRAM_LOOP_COUNT_NV\0"
-+   "GL_MAX_PROGRAM_LOOP_DEPTH_NV\0"
-+   "GL_MAX_PROGRAM_MATRICES_ARB\0"
-+   "GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB\0"
-+   "GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB\0"
-+   "GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB\0"
-+   "GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB\0"
-+   "GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB\0"
-+   "GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB\0"
-+   "GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB\0"
-+   "GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB\0"
-+   "GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB\0"
-+   "GL_MAX_PROGRAM_PARAMETERS_ARB\0"
-+   "GL_MAX_PROGRAM_TEMPORARIES_ARB\0"
-+   "GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB\0"
-+   "GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB\0"
-+   "GL_MAX_PROJECTION_STACK_DEPTH\0"
-+   "GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB\0"
-+   "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV\0"
-+   "GL_MAX_RENDERBUFFER_SIZE_EXT\0"
-+   "GL_MAX_SHININESS_NV\0"
-+   "GL_MAX_SPOT_EXPONENT_NV\0"
-+   "GL_MAX_TEXTURE_COORDS\0"
-+   "GL_MAX_TEXTURE_COORDS_ARB\0"
-+   "GL_MAX_TEXTURE_IMAGE_UNITS\0"
-+   "GL_MAX_TEXTURE_IMAGE_UNITS_ARB\0"
-+   "GL_MAX_TEXTURE_LOD_BIAS\0"
-+   "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT\0"
-+   "GL_MAX_TEXTURE_SIZE\0"
-+   "GL_MAX_TEXTURE_STACK_DEPTH\0"
-+   "GL_MAX_TEXTURE_UNITS\0"
-+   "GL_MAX_TEXTURE_UNITS_ARB\0"
-+   "GL_MAX_TRACK_MATRICES_NV\0"
-+   "GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV\0"
-+   "GL_MAX_VARYING_FLOATS\0"
-+   "GL_MAX_VARYING_FLOATS_ARB\0"
-+   "GL_MAX_VERTEX_ATTRIBS\0"
-+   "GL_MAX_VERTEX_ATTRIBS_ARB\0"
-+   "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS\0"
-+   "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB\0"
-+   "GL_MAX_VERTEX_UNIFORM_COMPONENTS\0"
-+   "GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB\0"
-+   "GL_MAX_VERTEX_UNITS_ARB\0"
-+   "GL_MAX_VIEWPORT_DIMS\0"
-+   "GL_MIN\0"
-+   "GL_MINMAX\0"
-+   "GL_MINMAX_EXT\0"
-+   "GL_MINMAX_FORMAT\0"
-+   "GL_MINMAX_FORMAT_EXT\0"
-+   "GL_MINMAX_SINK\0"
-+   "GL_MINMAX_SINK_EXT\0"
-+   "GL_MIN_EXT\0"
-+   "GL_MIRRORED_REPEAT\0"
-+   "GL_MIRRORED_REPEAT_ARB\0"
-+   "GL_MIRRORED_REPEAT_IBM\0"
-+   "GL_MIRROR_CLAMP_ATI\0"
-+   "GL_MIRROR_CLAMP_EXT\0"
-+   "GL_MIRROR_CLAMP_TO_BORDER_EXT\0"
-+   "GL_MIRROR_CLAMP_TO_EDGE_ATI\0"
-+   "GL_MIRROR_CLAMP_TO_EDGE_EXT\0"
-+   "GL_MODELVIEW\0"
-+   "GL_MODELVIEW0_ARB\0"
-+   "GL_MODELVIEW10_ARB\0"
-+   "GL_MODELVIEW11_ARB\0"
-+   "GL_MODELVIEW12_ARB\0"
-+   "GL_MODELVIEW13_ARB\0"
-+   "GL_MODELVIEW14_ARB\0"
-+   "GL_MODELVIEW15_ARB\0"
-+   "GL_MODELVIEW16_ARB\0"
-+   "GL_MODELVIEW17_ARB\0"
-+   "GL_MODELVIEW18_ARB\0"
-+   "GL_MODELVIEW19_ARB\0"
-+   "GL_MODELVIEW1_ARB\0"
-+   "GL_MODELVIEW20_ARB\0"
-+   "GL_MODELVIEW21_ARB\0"
-+   "GL_MODELVIEW22_ARB\0"
-+   "GL_MODELVIEW23_ARB\0"
-+   "GL_MODELVIEW24_ARB\0"
-+   "GL_MODELVIEW25_ARB\0"
-+   "GL_MODELVIEW26_ARB\0"
-+   "GL_MODELVIEW27_ARB\0"
-+   "GL_MODELVIEW28_ARB\0"
-+   "GL_MODELVIEW29_ARB\0"
-+   "GL_MODELVIEW2_ARB\0"
-+   "GL_MODELVIEW30_ARB\0"
-+   "GL_MODELVIEW31_ARB\0"
-+   "GL_MODELVIEW3_ARB\0"
-+   "GL_MODELVIEW4_ARB\0"
-+   "GL_MODELVIEW5_ARB\0"
-+   "GL_MODELVIEW6_ARB\0"
-+   "GL_MODELVIEW7_ARB\0"
-+   "GL_MODELVIEW8_ARB\0"
-+   "GL_MODELVIEW9_ARB\0"
-+   "GL_MODELVIEW_MATRIX\0"
-+   "GL_MODELVIEW_PROJECTION_NV\0"
-+   "GL_MODELVIEW_STACK_DEPTH\0"
-+   "GL_MODULATE\0"
-+   "GL_MODULATE_ADD_ATI\0"
-+   "GL_MODULATE_SIGNED_ADD_ATI\0"
-+   "GL_MODULATE_SUBTRACT_ATI\0"
-+   "GL_MULT\0"
-+   "GL_MULTISAMPLE\0"
-+   "GL_MULTISAMPLE_3DFX\0"
-+   "GL_MULTISAMPLE_ARB\0"
-+   "GL_MULTISAMPLE_BIT\0"
-+   "GL_MULTISAMPLE_BIT_3DFX\0"
-+   "GL_MULTISAMPLE_BIT_ARB\0"
-+   "GL_MULTISAMPLE_FILTER_HINT_NV\0"
-+   "GL_N3F_V3F\0"
-+   "GL_NAME_STACK_DEPTH\0"
-+   "GL_NAND\0"
-+   "GL_NEAREST\0"
-+   "GL_NEAREST_CLIPMAP_LINEAR_SGIX\0"
-+   "GL_NEAREST_CLIPMAP_NEAREST_SGIX\0"
-+   "GL_NEAREST_MIPMAP_LINEAR\0"
-+   "GL_NEAREST_MIPMAP_NEAREST\0"
-+   "GL_NEVER\0"
-+   "GL_NICEST\0"
-+   "GL_NONE\0"
-+   "GL_NOOP\0"
-+   "GL_NOR\0"
-+   "GL_NORMALIZE\0"
-+   "GL_NORMAL_ARRAY\0"
-+   "GL_NORMAL_ARRAY_BUFFER_BINDING\0"
-+   "GL_NORMAL_ARRAY_BUFFER_BINDING_ARB\0"
-+   "GL_NORMAL_ARRAY_POINTER\0"
-+   "GL_NORMAL_ARRAY_STRIDE\0"
-+   "GL_NORMAL_ARRAY_TYPE\0"
-+   "GL_NORMAL_MAP\0"
-+   "GL_NORMAL_MAP_ARB\0"
-+   "GL_NORMAL_MAP_NV\0"
-+   "GL_NOTEQUAL\0"
-+   "GL_NO_ERROR\0"
-+   "GL_NUM_COMPRESSED_TEXTURE_FORMATS\0"
-+   "GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB\0"
-+   "GL_OBJECT_ACTIVE_ATTRIBUTES_ARB\0"
-+   "GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB\0"
-+   "GL_OBJECT_ACTIVE_UNIFORMS_ARB\0"
-+   "GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB\0"
-+   "GL_OBJECT_ATTACHED_OBJECTS_ARB\0"
-+   "GL_OBJECT_COMPILE_STATUS_ARB\0"
-+   "GL_OBJECT_DELETE_STATUS_ARB\0"
-+   "GL_OBJECT_INFO_LOG_LENGTH_ARB\0"
-+   "GL_OBJECT_LINEAR\0"
-+   "GL_OBJECT_LINK_STATUS_ARB\0"
-+   "GL_OBJECT_PLANE\0"
-+   "GL_OBJECT_SHADER_SOURCE_LENGTH_ARB\0"
-+   "GL_OBJECT_SUBTYPE_ARB\0"
-+   "GL_OBJECT_TYPE_ARB\0"
-+   "GL_OBJECT_VALIDATE_STATUS_ARB\0"
-+   "GL_OCCLUSION_TEST_HP\0"
-+   "GL_OCCLUSION_TEST_RESULT_HP\0"
-+   "GL_ONE\0"
-+   "GL_ONE_MINUS_CONSTANT_ALPHA\0"
-+   "GL_ONE_MINUS_CONSTANT_ALPHA_EXT\0"
-+   "GL_ONE_MINUS_CONSTANT_COLOR\0"
-+   "GL_ONE_MINUS_CONSTANT_COLOR_EXT\0"
-+   "GL_ONE_MINUS_DST_ALPHA\0"
-+   "GL_ONE_MINUS_DST_COLOR\0"
-+   "GL_ONE_MINUS_SRC_ALPHA\0"
-+   "GL_ONE_MINUS_SRC_COLOR\0"
-+   "GL_OPERAND0_ALPHA\0"
-+   "GL_OPERAND0_ALPHA_ARB\0"
-+   "GL_OPERAND0_ALPHA_EXT\0"
-+   "GL_OPERAND0_RGB\0"
-+   "GL_OPERAND0_RGB_ARB\0"
-+   "GL_OPERAND0_RGB_EXT\0"
-+   "GL_OPERAND1_ALPHA\0"
-+   "GL_OPERAND1_ALPHA_ARB\0"
-+   "GL_OPERAND1_ALPHA_EXT\0"
-+   "GL_OPERAND1_RGB\0"
-+   "GL_OPERAND1_RGB_ARB\0"
-+   "GL_OPERAND1_RGB_EXT\0"
-+   "GL_OPERAND2_ALPHA\0"
-+   "GL_OPERAND2_ALPHA_ARB\0"
-+   "GL_OPERAND2_ALPHA_EXT\0"
-+   "GL_OPERAND2_RGB\0"
-+   "GL_OPERAND2_RGB_ARB\0"
-+   "GL_OPERAND2_RGB_EXT\0"
-+   "GL_OPERAND3_ALPHA_NV\0"
-+   "GL_OPERAND3_RGB_NV\0"
-+   "GL_OR\0"
-+   "GL_ORDER\0"
-+   "GL_OR_INVERTED\0"
-+   "GL_OR_REVERSE\0"
-+   "GL_OUT_OF_MEMORY\0"
-+   "GL_PACK_ALIGNMENT\0"
-+   "GL_PACK_IMAGE_HEIGHT\0"
-+   "GL_PACK_INVERT_MESA\0"
-+   "GL_PACK_LSB_FIRST\0"
-+   "GL_PACK_ROW_LENGTH\0"
-+   "GL_PACK_SKIP_IMAGES\0"
-+   "GL_PACK_SKIP_PIXELS\0"
-+   "GL_PACK_SKIP_ROWS\0"
-+   "GL_PACK_SWAP_BYTES\0"
-+   "GL_PALETTE4_R5_G6_B5_OES\0"
-+   "GL_PALETTE4_RGB5_A1_OES\0"
-+   "GL_PALETTE4_RGB8_OES\0"
-+   "GL_PALETTE4_RGBA4_OES\0"
-+   "GL_PALETTE4_RGBA8_OES\0"
-+   "GL_PALETTE8_R5_G6_B5_OES\0"
-+   "GL_PALETTE8_RGB5_A1_OES\0"
-+   "GL_PALETTE8_RGB8_OES\0"
-+   "GL_PALETTE8_RGBA4_OES\0"
-+   "GL_PALETTE8_RGBA8_OES\0"
-+   "GL_PASS_THROUGH_TOKEN\0"
-+   "GL_PERSPECTIVE_CORRECTION_HINT\0"
-+   "GL_PIXEL_MAP_A_TO_A\0"
-+   "GL_PIXEL_MAP_A_TO_A_SIZE\0"
-+   "GL_PIXEL_MAP_B_TO_B\0"
-+   "GL_PIXEL_MAP_B_TO_B_SIZE\0"
-+   "GL_PIXEL_MAP_G_TO_G\0"
-+   "GL_PIXEL_MAP_G_TO_G_SIZE\0"
-+   "GL_PIXEL_MAP_I_TO_A\0"
-+   "GL_PIXEL_MAP_I_TO_A_SIZE\0"
-+   "GL_PIXEL_MAP_I_TO_B\0"
-+   "GL_PIXEL_MAP_I_TO_B_SIZE\0"
-+   "GL_PIXEL_MAP_I_TO_G\0"
-+   "GL_PIXEL_MAP_I_TO_G_SIZE\0"
-+   "GL_PIXEL_MAP_I_TO_I\0"
-+   "GL_PIXEL_MAP_I_TO_I_SIZE\0"
-+   "GL_PIXEL_MAP_I_TO_R\0"
-+   "GL_PIXEL_MAP_I_TO_R_SIZE\0"
-+   "GL_PIXEL_MAP_R_TO_R\0"
-+   "GL_PIXEL_MAP_R_TO_R_SIZE\0"
-+   "GL_PIXEL_MAP_S_TO_S\0"
-+   "GL_PIXEL_MAP_S_TO_S_SIZE\0"
-+   "GL_PIXEL_MODE_BIT\0"
-+   "GL_PIXEL_PACK_BUFFER_BINDING_EXT\0"
-+   "GL_PIXEL_PACK_BUFFER_EXT\0"
-+   "GL_PIXEL_UNPACK_BUFFER_BINDING_EXT\0"
-+   "GL_PIXEL_UNPACK_BUFFER_EXT\0"
-+   "GL_POINT\0"
-+   "GL_POINTS\0"
-+   "GL_POINT_BIT\0"
-+   "GL_POINT_DISTANCE_ATTENUATION\0"
-+   "GL_POINT_DISTANCE_ATTENUATION_ARB\0"
-+   "GL_POINT_DISTANCE_ATTENUATION_EXT\0"
-+   "GL_POINT_DISTANCE_ATTENUATION_SGIS\0"
-+   "GL_POINT_FADE_THRESHOLD_SIZE\0"
-+   "GL_POINT_FADE_THRESHOLD_SIZE_ARB\0"
-+   "GL_POINT_FADE_THRESHOLD_SIZE_EXT\0"
-+   "GL_POINT_FADE_THRESHOLD_SIZE_SGIS\0"
-+   "GL_POINT_SIZE\0"
-+   "GL_POINT_SIZE_GRANULARITY\0"
-+   "GL_POINT_SIZE_MAX\0"
-+   "GL_POINT_SIZE_MAX_ARB\0"
-+   "GL_POINT_SIZE_MAX_EXT\0"
-+   "GL_POINT_SIZE_MAX_SGIS\0"
-+   "GL_POINT_SIZE_MIN\0"
-+   "GL_POINT_SIZE_MIN_ARB\0"
-+   "GL_POINT_SIZE_MIN_EXT\0"
-+   "GL_POINT_SIZE_MIN_SGIS\0"
-+   "GL_POINT_SIZE_RANGE\0"
-+   "GL_POINT_SMOOTH\0"
-+   "GL_POINT_SMOOTH_HINT\0"
-+   "GL_POINT_SPRITE\0"
-+   "GL_POINT_SPRITE_ARB\0"
-+   "GL_POINT_SPRITE_COORD_ORIGIN\0"
-+   "GL_POINT_SPRITE_NV\0"
-+   "GL_POINT_SPRITE_R_MODE_NV\0"
-+   "GL_POINT_TOKEN\0"
-+   "GL_POLYGON\0"
-+   "GL_POLYGON_BIT\0"
-+   "GL_POLYGON_MODE\0"
-+   "GL_POLYGON_OFFSET_BIAS\0"
-+   "GL_POLYGON_OFFSET_FACTOR\0"
-+   "GL_POLYGON_OFFSET_FILL\0"
-+   "GL_POLYGON_OFFSET_LINE\0"
-+   "GL_POLYGON_OFFSET_POINT\0"
-+   "GL_POLYGON_OFFSET_UNITS\0"
-+   "GL_POLYGON_SMOOTH\0"
-+   "GL_POLYGON_SMOOTH_HINT\0"
-+   "GL_POLYGON_STIPPLE\0"
-+   "GL_POLYGON_STIPPLE_BIT\0"
-+   "GL_POLYGON_TOKEN\0"
-+   "GL_POSITION\0"
-+   "GL_POST_COLOR_MATRIX_ALPHA_BIAS\0"
-+   "GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI\0"
-+   "GL_POST_COLOR_MATRIX_ALPHA_SCALE\0"
-+   "GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI\0"
-+   "GL_POST_COLOR_MATRIX_BLUE_BIAS\0"
-+   "GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI\0"
-+   "GL_POST_COLOR_MATRIX_BLUE_SCALE\0"
-+   "GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI\0"
-+   "GL_POST_COLOR_MATRIX_COLOR_TABLE\0"
-+   "GL_POST_COLOR_MATRIX_GREEN_BIAS\0"
-+   "GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI\0"
-+   "GL_POST_COLOR_MATRIX_GREEN_SCALE\0"
-+   "GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI\0"
-+   "GL_POST_COLOR_MATRIX_RED_BIAS\0"
-+   "GL_POST_COLOR_MATRIX_RED_BIAS_SGI\0"
-+   "GL_POST_COLOR_MATRIX_RED_SCALE\0"
-+   "GL_POST_COLOR_MATRIX_RED_SCALE_SGI\0"
-+   "GL_POST_CONVOLUTION_ALPHA_BIAS\0"
-+   "GL_POST_CONVOLUTION_ALPHA_BIAS_EXT\0"
-+   "GL_POST_CONVOLUTION_ALPHA_SCALE\0"
-+   "GL_POST_CONVOLUTION_ALPHA_SCALE_EXT\0"
-+   "GL_POST_CONVOLUTION_BLUE_BIAS\0"
-+   "GL_POST_CONVOLUTION_BLUE_BIAS_EXT\0"
-+   "GL_POST_CONVOLUTION_BLUE_SCALE\0"
-+   "GL_POST_CONVOLUTION_BLUE_SCALE_EXT\0"
-+   "GL_POST_CONVOLUTION_COLOR_TABLE\0"
-+   "GL_POST_CONVOLUTION_GREEN_BIAS\0"
-+   "GL_POST_CONVOLUTION_GREEN_BIAS_EXT\0"
-+   "GL_POST_CONVOLUTION_GREEN_SCALE\0"
-+   "GL_POST_CONVOLUTION_GREEN_SCALE_EXT\0"
-+   "GL_POST_CONVOLUTION_RED_BIAS\0"
-+   "GL_POST_CONVOLUTION_RED_BIAS_EXT\0"
-+   "GL_POST_CONVOLUTION_RED_SCALE\0"
-+   "GL_POST_CONVOLUTION_RED_SCALE_EXT\0"
-+   "GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX\0"
-+   "GL_POST_TEXTURE_FILTER_BIAS_SGIX\0"
-+   "GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX\0"
-+   "GL_POST_TEXTURE_FILTER_SCALE_SGIX\0"
-+   "GL_PREVIOUS\0"
-+   "GL_PREVIOUS_ARB\0"
-+   "GL_PREVIOUS_EXT\0"
-+   "GL_PRIMARY_COLOR\0"
-+   "GL_PRIMARY_COLOR_ARB\0"
-+   "GL_PRIMARY_COLOR_EXT\0"
-+   "GL_PROGRAM_ADDRESS_REGISTERS_ARB\0"
-+   "GL_PROGRAM_ALU_INSTRUCTIONS_ARB\0"
-+   "GL_PROGRAM_ATTRIBS_ARB\0"
-+   "GL_PROGRAM_BINDING_ARB\0"
-+   "GL_PROGRAM_ERROR_POSITION_ARB\0"
-+   "GL_PROGRAM_ERROR_POSITION_NV\0"
-+   "GL_PROGRAM_ERROR_STRING_ARB\0"
-+   "GL_PROGRAM_FORMAT_ARB\0"
-+   "GL_PROGRAM_FORMAT_ASCII_ARB\0"
-+   "GL_PROGRAM_INSTRUCTIONS_ARB\0"
-+   "GL_PROGRAM_LENGTH_ARB\0"
-+   "GL_PROGRAM_LENGTH_NV\0"
-+   "GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB\0"
-+   "GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB\0"
-+   "GL_PROGRAM_NATIVE_ATTRIBS_ARB\0"
-+   "GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB\0"
-+   "GL_PROGRAM_NATIVE_PARAMETERS_ARB\0"
-+   "GL_PROGRAM_NATIVE_TEMPORARIES_ARB\0"
-+   "GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB\0"
-+   "GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB\0"
-+   "GL_PROGRAM_OBJECT_ARB\0"
-+   "GL_PROGRAM_PARAMETERS_ARB\0"
-+   "GL_PROGRAM_PARAMETER_NV\0"
-+   "GL_PROGRAM_RESIDENT_NV\0"
-+   "GL_PROGRAM_STRING_ARB\0"
-+   "GL_PROGRAM_STRING_NV\0"
-+   "GL_PROGRAM_TARGET_NV\0"
-+   "GL_PROGRAM_TEMPORARIES_ARB\0"
-+   "GL_PROGRAM_TEX_INDIRECTIONS_ARB\0"
-+   "GL_PROGRAM_TEX_INSTRUCTIONS_ARB\0"
-+   "GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB\0"
-+   "GL_PROJECTION\0"
-+   "GL_PROJECTION_MATRIX\0"
-+   "GL_PROJECTION_STACK_DEPTH\0"
-+   "GL_PROXY_COLOR_TABLE\0"
-+   "GL_PROXY_HISTOGRAM\0"
-+   "GL_PROXY_HISTOGRAM_EXT\0"
-+   "GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE\0"
-+   "GL_PROXY_POST_CONVOLUTION_COLOR_TABLE\0"
-+   "GL_PROXY_TEXTURE_1D\0"
-+   "GL_PROXY_TEXTURE_1D_ARRAY_EXT\0"
-+   "GL_PROXY_TEXTURE_1D_EXT\0"
-+   "GL_PROXY_TEXTURE_2D\0"
-+   "GL_PROXY_TEXTURE_2D_ARRAY_EXT\0"
-+   "GL_PROXY_TEXTURE_2D_EXT\0"
-+   "GL_PROXY_TEXTURE_3D\0"
-+   "GL_PROXY_TEXTURE_COLOR_TABLE_SGI\0"
-+   "GL_PROXY_TEXTURE_CUBE_MAP\0"
-+   "GL_PROXY_TEXTURE_CUBE_MAP_ARB\0"
-+   "GL_PROXY_TEXTURE_RECTANGLE_ARB\0"
-+   "GL_PROXY_TEXTURE_RECTANGLE_NV\0"
-+   "GL_Q\0"
-+   "GL_QUADRATIC_ATTENUATION\0"
-+   "GL_QUADS\0"
-+   "GL_QUAD_MESH_SUN\0"
-+   "GL_QUAD_STRIP\0"
-+   "GL_QUERY_COUNTER_BITS\0"
-+   "GL_QUERY_COUNTER_BITS_ARB\0"
-+   "GL_QUERY_RESULT\0"
-+   "GL_QUERY_RESULT_ARB\0"
-+   "GL_QUERY_RESULT_AVAILABLE\0"
-+   "GL_QUERY_RESULT_AVAILABLE_ARB\0"
-+   "GL_R\0"
-+   "GL_R3_G3_B2\0"
-+   "GL_RASTER_POSITION_UNCLIPPED_IBM\0"
-+   "GL_READ_BUFFER\0"
-+   "GL_READ_FRAMEBUFFER_BINDING_EXT\0"
-+   "GL_READ_FRAMEBUFFER_EXT\0"
-+   "GL_READ_ONLY\0"
-+   "GL_READ_ONLY_ARB\0"
-+   "GL_READ_WRITE\0"
-+   "GL_READ_WRITE_ARB\0"
-+   "GL_RED\0"
-+   "GL_REDUCE\0"
-+   "GL_REDUCE_EXT\0"
-+   "GL_RED_BIAS\0"
-+   "GL_RED_BITS\0"
-+   "GL_RED_SCALE\0"
-+   "GL_REFLECTION_MAP\0"
-+   "GL_REFLECTION_MAP_ARB\0"
-+   "GL_REFLECTION_MAP_NV\0"
-+   "GL_RENDER\0"
-+   "GL_RENDERBUFFER_BINDING_EXT\0"
-+   "GL_RENDERBUFFER_EXT\0"
-+   "GL_RENDERBUFFER_HEIGHT_EXT\0"
-+   "GL_RENDERBUFFER_INTERNAL_FORMAT_EXT\0"
-+   "GL_RENDERBUFFER_WIDTH_EXT\0"
-+   "GL_RENDERER\0"
-+   "GL_RENDER_MODE\0"
-+   "GL_REPEAT\0"
-+   "GL_REPLACE\0"
-+   "GL_REPLACE_EXT\0"
-+   "GL_REPLICATE_BORDER_HP\0"
-+   "GL_RESCALE_NORMAL\0"
-+   "GL_RESCALE_NORMAL_EXT\0"
-+   "GL_RETURN\0"
-+   "GL_RGB\0"
-+   "GL_RGB10\0"
-+   "GL_RGB10_A2\0"
-+   "GL_RGB10_A2_EXT\0"
-+   "GL_RGB10_EXT\0"
-+   "GL_RGB12\0"
-+   "GL_RGB12_EXT\0"
-+   "GL_RGB16\0"
-+   "GL_RGB16_EXT\0"
-+   "GL_RGB2_EXT\0"
-+   "GL_RGB4\0"
-+   "GL_RGB4_EXT\0"
-+   "GL_RGB4_S3TC\0"
-+   "GL_RGB5\0"
-+   "GL_RGB5_A1\0"
-+   "GL_RGB5_A1_EXT\0"
-+   "GL_RGB5_EXT\0"
-+   "GL_RGB8\0"
-+   "GL_RGB8_EXT\0"
-+   "GL_RGBA\0"
-+   "GL_RGBA12\0"
-+   "GL_RGBA12_EXT\0"
-+   "GL_RGBA16\0"
-+   "GL_RGBA16_EXT\0"
-+   "GL_RGBA2\0"
-+   "GL_RGBA2_EXT\0"
-+   "GL_RGBA4\0"
-+   "GL_RGBA4_DXT5_S3TC\0"
-+   "GL_RGBA4_EXT\0"
-+   "GL_RGBA4_S3TC\0"
-+   "GL_RGBA8\0"
-+   "GL_RGBA8_EXT\0"
-+   "GL_RGBA_DXT5_S3TC\0"
-+   "GL_RGBA_MODE\0"
-+   "GL_RGBA_S3TC\0"
-+   "GL_RGB_S3TC\0"
-+   "GL_RGB_SCALE\0"
-+   "GL_RGB_SCALE_ARB\0"
-+   "GL_RGB_SCALE_EXT\0"
-+   "GL_RIGHT\0"
-+   "GL_S\0"
-+   "GL_SAMPLER_1D\0"
-+   "GL_SAMPLER_1D_SHADOW\0"
-+   "GL_SAMPLER_2D\0"
-+   "GL_SAMPLER_2D_SHADOW\0"
-+   "GL_SAMPLER_3D\0"
-+   "GL_SAMPLER_CUBE\0"
-+   "GL_SAMPLES\0"
-+   "GL_SAMPLES_3DFX\0"
-+   "GL_SAMPLES_ARB\0"
-+   "GL_SAMPLES_PASSED\0"
-+   "GL_SAMPLES_PASSED_ARB\0"
-+   "GL_SAMPLE_ALPHA_TO_COVERAGE\0"
-+   "GL_SAMPLE_ALPHA_TO_COVERAGE_ARB\0"
-+   "GL_SAMPLE_ALPHA_TO_ONE\0"
-+   "GL_SAMPLE_ALPHA_TO_ONE_ARB\0"
-+   "GL_SAMPLE_BUFFERS\0"
-+   "GL_SAMPLE_BUFFERS_3DFX\0"
-+   "GL_SAMPLE_BUFFERS_ARB\0"
-+   "GL_SAMPLE_COVERAGE\0"
-+   "GL_SAMPLE_COVERAGE_ARB\0"
-+   "GL_SAMPLE_COVERAGE_INVERT\0"
-+   "GL_SAMPLE_COVERAGE_INVERT_ARB\0"
-+   "GL_SAMPLE_COVERAGE_VALUE\0"
-+   "GL_SAMPLE_COVERAGE_VALUE_ARB\0"
-+   "GL_SCISSOR_BIT\0"
-+   "GL_SCISSOR_BOX\0"
-+   "GL_SCISSOR_TEST\0"
-+   "GL_SECONDARY_COLOR_ARRAY\0"
-+   "GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING\0"
-+   "GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB\0"
-+   "GL_SECONDARY_COLOR_ARRAY_POINTER\0"
-+   "GL_SECONDARY_COLOR_ARRAY_SIZE\0"
-+   "GL_SECONDARY_COLOR_ARRAY_STRIDE\0"
-+   "GL_SECONDARY_COLOR_ARRAY_TYPE\0"
-+   "GL_SELECT\0"
-+   "GL_SELECTION_BUFFER_POINTER\0"
-+   "GL_SELECTION_BUFFER_SIZE\0"
-+   "GL_SEPARABLE_2D\0"
-+   "GL_SEPARATE_SPECULAR_COLOR\0"
-+   "GL_SEPARATE_SPECULAR_COLOR_EXT\0"
-+   "GL_SET\0"
-+   "GL_SHADER_OBJECT_ARB\0"
-+   "GL_SHADER_SOURCE_LENGTH\0"
-+   "GL_SHADER_TYPE\0"
-+   "GL_SHADE_MODEL\0"
-+   "GL_SHADING_LANGUAGE_VERSION\0"
-+   "GL_SHADOW_AMBIENT_SGIX\0"
-+   "GL_SHARED_TEXTURE_PALETTE_EXT\0"
-+   "GL_SHININESS\0"
-+   "GL_SHORT\0"
-+   "GL_SINGLE_COLOR\0"
-+   "GL_SINGLE_COLOR_EXT\0"
-+   "GL_SLICE_ACCUM_SUN\0"
-+   "GL_SMOOTH\0"
-+   "GL_SMOOTH_LINE_WIDTH_GRANULARITY\0"
-+   "GL_SMOOTH_LINE_WIDTH_RANGE\0"
-+   "GL_SMOOTH_POINT_SIZE_GRANULARITY\0"
-+   "GL_SMOOTH_POINT_SIZE_RANGE\0"
-+   "GL_SOURCE0_ALPHA\0"
-+   "GL_SOURCE0_ALPHA_ARB\0"
-+   "GL_SOURCE0_ALPHA_EXT\0"
-+   "GL_SOURCE0_RGB\0"
-+   "GL_SOURCE0_RGB_ARB\0"
-+   "GL_SOURCE0_RGB_EXT\0"
-+   "GL_SOURCE1_ALPHA\0"
-+   "GL_SOURCE1_ALPHA_ARB\0"
-+   "GL_SOURCE1_ALPHA_EXT\0"
-+   "GL_SOURCE1_RGB\0"
-+   "GL_SOURCE1_RGB_ARB\0"
-+   "GL_SOURCE1_RGB_EXT\0"
-+   "GL_SOURCE2_ALPHA\0"
-+   "GL_SOURCE2_ALPHA_ARB\0"
-+   "GL_SOURCE2_ALPHA_EXT\0"
-+   "GL_SOURCE2_RGB\0"
-+   "GL_SOURCE2_RGB_ARB\0"
-+   "GL_SOURCE2_RGB_EXT\0"
-+   "GL_SOURCE3_ALPHA_NV\0"
-+   "GL_SOURCE3_RGB_NV\0"
-+   "GL_SPECULAR\0"
-+   "GL_SPHERE_MAP\0"
-+   "GL_SPOT_CUTOFF\0"
-+   "GL_SPOT_DIRECTION\0"
-+   "GL_SPOT_EXPONENT\0"
-+   "GL_SRC0_ALPHA\0"
-+   "GL_SRC0_RGB\0"
-+   "GL_SRC1_ALPHA\0"
-+   "GL_SRC1_RGB\0"
-+   "GL_SRC2_ALPHA\0"
-+   "GL_SRC2_RGB\0"
-+   "GL_SRC_ALPHA\0"
-+   "GL_SRC_ALPHA_SATURATE\0"
-+   "GL_SRC_COLOR\0"
-+   "GL_STACK_OVERFLOW\0"
-+   "GL_STACK_UNDERFLOW\0"
-+   "GL_STATIC_COPY\0"
-+   "GL_STATIC_COPY_ARB\0"
-+   "GL_STATIC_DRAW\0"
-+   "GL_STATIC_DRAW_ARB\0"
-+   "GL_STATIC_READ\0"
-+   "GL_STATIC_READ_ARB\0"
-+   "GL_STENCIL\0"
-+   "GL_STENCIL_ATTACHMENT_EXT\0"
-+   "GL_STENCIL_BACK_FAIL\0"
-+   "GL_STENCIL_BACK_FUNC\0"
-+   "GL_STENCIL_BACK_PASS_DEPTH_FAIL\0"
-+   "GL_STENCIL_BACK_PASS_DEPTH_PASS\0"
-+   "GL_STENCIL_BACK_REF\0"
-+   "GL_STENCIL_BACK_VALUE_MASK\0"
-+   "GL_STENCIL_BACK_WRITEMASK\0"
-+   "GL_STENCIL_BITS\0"
-+   "GL_STENCIL_BUFFER_BIT\0"
-+   "GL_STENCIL_CLEAR_VALUE\0"
-+   "GL_STENCIL_FAIL\0"
-+   "GL_STENCIL_FUNC\0"
-+   "GL_STENCIL_INDEX\0"
-+   "GL_STENCIL_INDEX16_EXT\0"
-+   "GL_STENCIL_INDEX1_EXT\0"
-+   "GL_STENCIL_INDEX4_EXT\0"
-+   "GL_STENCIL_INDEX8_EXT\0"
-+   "GL_STENCIL_INDEX_EXT\0"
-+   "GL_STENCIL_PASS_DEPTH_FAIL\0"
-+   "GL_STENCIL_PASS_DEPTH_PASS\0"
-+   "GL_STENCIL_REF\0"
-+   "GL_STENCIL_TEST\0"
-+   "GL_STENCIL_TEST_TWO_SIDE_EXT\0"
-+   "GL_STENCIL_VALUE_MASK\0"
-+   "GL_STENCIL_WRITEMASK\0"
-+   "GL_STEREO\0"
-+   "GL_STREAM_COPY\0"
-+   "GL_STREAM_COPY_ARB\0"
-+   "GL_STREAM_DRAW\0"
-+   "GL_STREAM_DRAW_ARB\0"
-+   "GL_STREAM_READ\0"
-+   "GL_STREAM_READ_ARB\0"
-+   "GL_SUBPIXEL_BITS\0"
-+   "GL_SUBTRACT\0"
-+   "GL_SUBTRACT_ARB\0"
-+   "GL_T\0"
-+   "GL_T2F_C3F_V3F\0"
-+   "GL_T2F_C4F_N3F_V3F\0"
-+   "GL_T2F_C4UB_V3F\0"
-+   "GL_T2F_N3F_V3F\0"
-+   "GL_T2F_V3F\0"
-+   "GL_T4F_C4F_N3F_V4F\0"
-+   "GL_T4F_V4F\0"
-+   "GL_TABLE_TOO_LARGE_EXT\0"
-+   "GL_TEXTURE\0"
-+   "GL_TEXTURE0\0"
-+   "GL_TEXTURE0_ARB\0"
-+   "GL_TEXTURE1\0"
-+   "GL_TEXTURE10\0"
-+   "GL_TEXTURE10_ARB\0"
-+   "GL_TEXTURE11\0"
-+   "GL_TEXTURE11_ARB\0"
-+   "GL_TEXTURE12\0"
-+   "GL_TEXTURE12_ARB\0"
-+   "GL_TEXTURE13\0"
-+   "GL_TEXTURE13_ARB\0"
-+   "GL_TEXTURE14\0"
-+   "GL_TEXTURE14_ARB\0"
-+   "GL_TEXTURE15\0"
-+   "GL_TEXTURE15_ARB\0"
-+   "GL_TEXTURE16\0"
-+   "GL_TEXTURE16_ARB\0"
-+   "GL_TEXTURE17\0"
-+   "GL_TEXTURE17_ARB\0"
-+   "GL_TEXTURE18\0"
-+   "GL_TEXTURE18_ARB\0"
-+   "GL_TEXTURE19\0"
-+   "GL_TEXTURE19_ARB\0"
-+   "GL_TEXTURE1_ARB\0"
-+   "GL_TEXTURE2\0"
-+   "GL_TEXTURE20\0"
-+   "GL_TEXTURE20_ARB\0"
-+   "GL_TEXTURE21\0"
-+   "GL_TEXTURE21_ARB\0"
-+   "GL_TEXTURE22\0"
-+   "GL_TEXTURE22_ARB\0"
-+   "GL_TEXTURE23\0"
-+   "GL_TEXTURE23_ARB\0"
-+   "GL_TEXTURE24\0"
-+   "GL_TEXTURE24_ARB\0"
-+   "GL_TEXTURE25\0"
-+   "GL_TEXTURE25_ARB\0"
-+   "GL_TEXTURE26\0"
-+   "GL_TEXTURE26_ARB\0"
-+   "GL_TEXTURE27\0"
-+   "GL_TEXTURE27_ARB\0"
-+   "GL_TEXTURE28\0"
-+   "GL_TEXTURE28_ARB\0"
-+   "GL_TEXTURE29\0"
-+   "GL_TEXTURE29_ARB\0"
-+   "GL_TEXTURE2_ARB\0"
-+   "GL_TEXTURE3\0"
-+   "GL_TEXTURE30\0"
-+   "GL_TEXTURE30_ARB\0"
-+   "GL_TEXTURE31\0"
-+   "GL_TEXTURE31_ARB\0"
-+   "GL_TEXTURE3_ARB\0"
-+   "GL_TEXTURE4\0"
-+   "GL_TEXTURE4_ARB\0"
-+   "GL_TEXTURE5\0"
-+   "GL_TEXTURE5_ARB\0"
-+   "GL_TEXTURE6\0"
-+   "GL_TEXTURE6_ARB\0"
-+   "GL_TEXTURE7\0"
-+   "GL_TEXTURE7_ARB\0"
-+   "GL_TEXTURE8\0"
-+   "GL_TEXTURE8_ARB\0"
-+   "GL_TEXTURE9\0"
-+   "GL_TEXTURE9_ARB\0"
-+   "GL_TEXTURE_1D\0"
-+   "GL_TEXTURE_1D_ARRAY_EXT\0"
-+   "GL_TEXTURE_2D\0"
-+   "GL_TEXTURE_2D_ARRAY_EXT\0"
-+   "GL_TEXTURE_3D\0"
-+   "GL_TEXTURE_ALPHA_SIZE\0"
-+   "GL_TEXTURE_ALPHA_SIZE_EXT\0"
-+   "GL_TEXTURE_BASE_LEVEL\0"
-+   "GL_TEXTURE_BINDING_1D\0"
-+   "GL_TEXTURE_BINDING_1D_ARRAY_EXT\0"
-+   "GL_TEXTURE_BINDING_2D\0"
-+   "GL_TEXTURE_BINDING_2D_ARRAY_EXT\0"
-+   "GL_TEXTURE_BINDING_3D\0"
-+   "GL_TEXTURE_BINDING_CUBE_MAP\0"
-+   "GL_TEXTURE_BINDING_CUBE_MAP_ARB\0"
-+   "GL_TEXTURE_BINDING_RECTANGLE_ARB\0"
-+   "GL_TEXTURE_BINDING_RECTANGLE_NV\0"
-+   "GL_TEXTURE_BIT\0"
-+   "GL_TEXTURE_BLUE_SIZE\0"
-+   "GL_TEXTURE_BLUE_SIZE_EXT\0"
-+   "GL_TEXTURE_BORDER\0"
-+   "GL_TEXTURE_BORDER_COLOR\0"
-+   "GL_TEXTURE_CLIPMAP_CENTER_SGIX\0"
-+   "GL_TEXTURE_CLIPMAP_DEPTH_SGIX\0"
-+   "GL_TEXTURE_CLIPMAP_FRAME_SGIX\0"
-+   "GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX\0"
-+   "GL_TEXTURE_CLIPMAP_OFFSET_SGIX\0"
-+   "GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX\0"
-+   "GL_TEXTURE_COLOR_TABLE_SGI\0"
-+   "GL_TEXTURE_COLOR_WRITEMASK_SGIS\0"
-+   "GL_TEXTURE_COMPARE_FAIL_VALUE_ARB\0"
-+   "GL_TEXTURE_COMPARE_FUNC\0"
-+   "GL_TEXTURE_COMPARE_FUNC_ARB\0"
-+   "GL_TEXTURE_COMPARE_MODE\0"
-+   "GL_TEXTURE_COMPARE_MODE_ARB\0"
-+   "GL_TEXTURE_COMPARE_OPERATOR_SGIX\0"
-+   "GL_TEXTURE_COMPARE_SGIX\0"
-+   "GL_TEXTURE_COMPONENTS\0"
-+   "GL_TEXTURE_COMPRESSED\0"
-+   "GL_TEXTURE_COMPRESSED_ARB\0"
-+   "GL_TEXTURE_COMPRESSED_FORMATS_ARB\0"
-+   "GL_TEXTURE_COMPRESSED_IMAGE_SIZE\0"
-+   "GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB\0"
-+   "GL_TEXTURE_COMPRESSION_HINT\0"
-+   "GL_TEXTURE_COMPRESSION_HINT_ARB\0"
-+   "GL_TEXTURE_COORD_ARRAY\0"
-+   "GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING\0"
-+   "GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB\0"
-+   "GL_TEXTURE_COORD_ARRAY_POINTER\0"
-+   "GL_TEXTURE_COORD_ARRAY_SIZE\0"
-+   "GL_TEXTURE_COORD_ARRAY_STRIDE\0"
-+   "GL_TEXTURE_COORD_ARRAY_TYPE\0"
-+   "GL_TEXTURE_CUBE_MAP\0"
-+   "GL_TEXTURE_CUBE_MAP_ARB\0"
-+   "GL_TEXTURE_CUBE_MAP_NEGATIVE_X\0"
-+   "GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB\0"
-+   "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y\0"
-+   "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB\0"
-+   "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z\0"
-+   "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB\0"
-+   "GL_TEXTURE_CUBE_MAP_POSITIVE_X\0"
-+   "GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB\0"
-+   "GL_TEXTURE_CUBE_MAP_POSITIVE_Y\0"
-+   "GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB\0"
-+   "GL_TEXTURE_CUBE_MAP_POSITIVE_Z\0"
-+   "GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB\0"
-+   "GL_TEXTURE_DEPTH\0"
-+   "GL_TEXTURE_DEPTH_SIZE\0"
-+   "GL_TEXTURE_DEPTH_SIZE_ARB\0"
-+   "GL_TEXTURE_ENV\0"
-+   "GL_TEXTURE_ENV_COLOR\0"
-+   "GL_TEXTURE_ENV_MODE\0"
-+   "GL_TEXTURE_FILTER_CONTROL\0"
-+   "GL_TEXTURE_GEN_MODE\0"
-+   "GL_TEXTURE_GEN_Q\0"
-+   "GL_TEXTURE_GEN_R\0"
-+   "GL_TEXTURE_GEN_S\0"
-+   "GL_TEXTURE_GEN_T\0"
-+   "GL_TEXTURE_GEQUAL_R_SGIX\0"
-+   "GL_TEXTURE_GREEN_SIZE\0"
-+   "GL_TEXTURE_GREEN_SIZE_EXT\0"
-+   "GL_TEXTURE_HEIGHT\0"
-+   "GL_TEXTURE_INDEX_SIZE_EXT\0"
-+   "GL_TEXTURE_INTENSITY_SIZE\0"
-+   "GL_TEXTURE_INTENSITY_SIZE_EXT\0"
-+   "GL_TEXTURE_INTERNAL_FORMAT\0"
-+   "GL_TEXTURE_LEQUAL_R_SGIX\0"
-+   "GL_TEXTURE_LOD_BIAS\0"
-+   "GL_TEXTURE_LOD_BIAS_EXT\0"
-+   "GL_TEXTURE_LOD_BIAS_R_SGIX\0"
-+   "GL_TEXTURE_LOD_BIAS_S_SGIX\0"
-+   "GL_TEXTURE_LOD_BIAS_T_SGIX\0"
-+   "GL_TEXTURE_LUMINANCE_SIZE\0"
-+   "GL_TEXTURE_LUMINANCE_SIZE_EXT\0"
-+   "GL_TEXTURE_MAG_FILTER\0"
-+   "GL_TEXTURE_MATRIX\0"
-+   "GL_TEXTURE_MAX_ANISOTROPY_EXT\0"
-+   "GL_TEXTURE_MAX_CLAMP_R_SGIX\0"
-+   "GL_TEXTURE_MAX_CLAMP_S_SGIX\0"
-+   "GL_TEXTURE_MAX_CLAMP_T_SGIX\0"
-+   "GL_TEXTURE_MAX_LEVEL\0"
-+   "GL_TEXTURE_MAX_LOD\0"
-+   "GL_TEXTURE_MIN_FILTER\0"
-+   "GL_TEXTURE_MIN_LOD\0"
-+   "GL_TEXTURE_PRIORITY\0"
-+   "GL_TEXTURE_RECTANGLE_ARB\0"
-+   "GL_TEXTURE_RECTANGLE_NV\0"
-+   "GL_TEXTURE_RED_SIZE\0"
-+   "GL_TEXTURE_RED_SIZE_EXT\0"
-+   "GL_TEXTURE_RESIDENT\0"
-+   "GL_TEXTURE_STACK_DEPTH\0"
-+   "GL_TEXTURE_TOO_LARGE_EXT\0"
-+   "GL_TEXTURE_UNSIGNED_REMAP_MODE_NV\0"
-+   "GL_TEXTURE_WIDTH\0"
-+   "GL_TEXTURE_WRAP_R\0"
-+   "GL_TEXTURE_WRAP_S\0"
-+   "GL_TEXTURE_WRAP_T\0"
-+   "GL_TIME_ELAPSED_EXT\0"
-+   "GL_TRACK_MATRIX_NV\0"
-+   "GL_TRACK_MATRIX_TRANSFORM_NV\0"
-+   "GL_TRANSFORM_BIT\0"
-+   "GL_TRANSPOSE_COLOR_MATRIX\0"
-+   "GL_TRANSPOSE_COLOR_MATRIX_ARB\0"
-+   "GL_TRANSPOSE_CURRENT_MATRIX_ARB\0"
-+   "GL_TRANSPOSE_MODELVIEW_MATRIX\0"
-+   "GL_TRANSPOSE_MODELVIEW_MATRIX_ARB\0"
-+   "GL_TRANSPOSE_NV\0"
-+   "GL_TRANSPOSE_PROJECTION_MATRIX\0"
-+   "GL_TRANSPOSE_PROJECTION_MATRIX_ARB\0"
-+   "GL_TRANSPOSE_TEXTURE_MATRIX\0"
-+   "GL_TRANSPOSE_TEXTURE_MATRIX_ARB\0"
-+   "GL_TRIANGLES\0"
-+   "GL_TRIANGLE_FAN\0"
-+   "GL_TRIANGLE_MESH_SUN\0"
-+   "GL_TRIANGLE_STRIP\0"
-+   "GL_TRUE\0"
-+   "GL_UNPACK_ALIGNMENT\0"
-+   "GL_UNPACK_IMAGE_HEIGHT\0"
-+   "GL_UNPACK_LSB_FIRST\0"
-+   "GL_UNPACK_ROW_LENGTH\0"
-+   "GL_UNPACK_SKIP_IMAGES\0"
-+   "GL_UNPACK_SKIP_PIXELS\0"
-+   "GL_UNPACK_SKIP_ROWS\0"
-+   "GL_UNPACK_SWAP_BYTES\0"
-+   "GL_UNSIGNED_BYTE\0"
-+   "GL_UNSIGNED_BYTE_2_3_3_REV\0"
-+   "GL_UNSIGNED_BYTE_3_3_2\0"
-+   "GL_UNSIGNED_INT\0"
-+   "GL_UNSIGNED_INT_10_10_10_2\0"
-+   "GL_UNSIGNED_INT_24_8_NV\0"
-+   "GL_UNSIGNED_INT_2_10_10_10_REV\0"
-+   "GL_UNSIGNED_INT_8_8_8_8\0"
-+   "GL_UNSIGNED_INT_8_8_8_8_REV\0"
-+   "GL_UNSIGNED_SHORT\0"
-+   "GL_UNSIGNED_SHORT_1_5_5_5_REV\0"
-+   "GL_UNSIGNED_SHORT_4_4_4_4\0"
-+   "GL_UNSIGNED_SHORT_4_4_4_4_REV\0"
-+   "GL_UNSIGNED_SHORT_5_5_5_1\0"
-+   "GL_UNSIGNED_SHORT_5_6_5\0"
-+   "GL_UNSIGNED_SHORT_5_6_5_REV\0"
-+   "GL_UNSIGNED_SHORT_8_8_APPLE\0"
-+   "GL_UNSIGNED_SHORT_8_8_MESA\0"
-+   "GL_UNSIGNED_SHORT_8_8_REV_APPLE\0"
-+   "GL_UNSIGNED_SHORT_8_8_REV_MESA\0"
-+   "GL_UPPER_LEFT\0"
-+   "GL_V2F\0"
-+   "GL_V3F\0"
-+   "GL_VALIDATE_STATUS\0"
-+   "GL_VENDOR\0"
-+   "GL_VERSION\0"
-+   "GL_VERTEX_ARRAY\0"
-+   "GL_VERTEX_ARRAY_BINDING_APPLE\0"
-+   "GL_VERTEX_ARRAY_BUFFER_BINDING\0"
-+   "GL_VERTEX_ARRAY_BUFFER_BINDING_ARB\0"
-+   "GL_VERTEX_ARRAY_POINTER\0"
-+   "GL_VERTEX_ARRAY_SIZE\0"
-+   "GL_VERTEX_ARRAY_STRIDE\0"
-+   "GL_VERTEX_ARRAY_TYPE\0"
-+   "GL_VERTEX_ATTRIB_ARRAY0_NV\0"
-+   "GL_VERTEX_ATTRIB_ARRAY10_NV\0"
-+   "GL_VERTEX_ATTRIB_ARRAY11_NV\0"
-+   "GL_VERTEX_ATTRIB_ARRAY12_NV\0"
-+   "GL_VERTEX_ATTRIB_ARRAY13_NV\0"
-+   "GL_VERTEX_ATTRIB_ARRAY14_NV\0"
-+   "GL_VERTEX_ATTRIB_ARRAY15_NV\0"
-+   "GL_VERTEX_ATTRIB_ARRAY1_NV\0"
-+   "GL_VERTEX_ATTRIB_ARRAY2_NV\0"
-+   "GL_VERTEX_ATTRIB_ARRAY3_NV\0"
-+   "GL_VERTEX_ATTRIB_ARRAY4_NV\0"
-+   "GL_VERTEX_ATTRIB_ARRAY5_NV\0"
-+   "GL_VERTEX_ATTRIB_ARRAY6_NV\0"
-+   "GL_VERTEX_ATTRIB_ARRAY7_NV\0"
-+   "GL_VERTEX_ATTRIB_ARRAY8_NV\0"
-+   "GL_VERTEX_ATTRIB_ARRAY9_NV\0"
-+   "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING\0"
-+   "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB\0"
-+   "GL_VERTEX_ATTRIB_ARRAY_ENABLED\0"
-+   "GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB\0"
-+   "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED\0"
-+   "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB\0"
-+   "GL_VERTEX_ATTRIB_ARRAY_POINTER\0"
-+   "GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB\0"
-+   "GL_VERTEX_ATTRIB_ARRAY_SIZE\0"
-+   "GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB\0"
-+   "GL_VERTEX_ATTRIB_ARRAY_STRIDE\0"
-+   "GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB\0"
-+   "GL_VERTEX_ATTRIB_ARRAY_TYPE\0"
-+   "GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB\0"
-+   "GL_VERTEX_BLEND_ARB\0"
-+   "GL_VERTEX_PROGRAM_ARB\0"
-+   "GL_VERTEX_PROGRAM_BINDING_NV\0"
-+   "GL_VERTEX_PROGRAM_NV\0"
-+   "GL_VERTEX_PROGRAM_POINT_SIZE\0"
-+   "GL_VERTEX_PROGRAM_POINT_SIZE_ARB\0"
-+   "GL_VERTEX_PROGRAM_POINT_SIZE_NV\0"
-+   "GL_VERTEX_PROGRAM_TWO_SIDE\0"
-+   "GL_VERTEX_PROGRAM_TWO_SIDE_ARB\0"
-+   "GL_VERTEX_PROGRAM_TWO_SIDE_NV\0"
-+   "GL_VERTEX_SHADER\0"
-+   "GL_VERTEX_SHADER_ARB\0"
-+   "GL_VERTEX_STATE_PROGRAM_NV\0"
-+   "GL_VIEWPORT\0"
-+   "GL_VIEWPORT_BIT\0"
-+   "GL_WEIGHT_ARRAY_ARB\0"
-+   "GL_WEIGHT_ARRAY_BUFFER_BINDING\0"
-+   "GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB\0"
-+   "GL_WEIGHT_ARRAY_POINTER_ARB\0"
-+   "GL_WEIGHT_ARRAY_SIZE_ARB\0"
-+   "GL_WEIGHT_ARRAY_STRIDE_ARB\0"
-+   "GL_WEIGHT_ARRAY_TYPE_ARB\0"
-+   "GL_WEIGHT_SUM_UNITY_ARB\0"
-+   "GL_WRAP_BORDER_SUN\0"
-+   "GL_WRITE_ONLY\0"
-+   "GL_WRITE_ONLY_ARB\0"
-+   "GL_XOR\0"
-+   "GL_YCBCR_422_APPLE\0"
-+   "GL_YCBCR_MESA\0"
-+   "GL_ZERO\0"
-+   "GL_ZOOM_X\0"
-+   "GL_ZOOM_Y\0"
-+   ;
-+
-+static const enum_elt all_enums[1746] =
-+{
-+   {     0, 0x00000600 }, /* GL_2D */
-+   {     6, 0x00001407 }, /* GL_2_BYTES */
-+   {    17, 0x00000601 }, /* GL_3D */
-+   {    23, 0x00000602 }, /* GL_3D_COLOR */
-+   {    35, 0x00000603 }, /* GL_3D_COLOR_TEXTURE */
-+   {    55, 0x00001408 }, /* GL_3_BYTES */
-+   {    66, 0x00000604 }, /* GL_4D_COLOR_TEXTURE */
-+   {    86, 0x00001409 }, /* GL_4_BYTES */
-+   {    97, 0x00000100 }, /* GL_ACCUM */
-+   {   106, 0x00000D5B }, /* GL_ACCUM_ALPHA_BITS */
-+   {   126, 0x00000D5A }, /* GL_ACCUM_BLUE_BITS */
-+   {   145, 0x00000200 }, /* GL_ACCUM_BUFFER_BIT */
-+   {   165, 0x00000B80 }, /* GL_ACCUM_CLEAR_VALUE */
-+   {   186, 0x00000D59 }, /* GL_ACCUM_GREEN_BITS */
-+   {   206, 0x00000D58 }, /* GL_ACCUM_RED_BITS */
-+   {   224, 0x00008B89 }, /* GL_ACTIVE_ATTRIBUTES */
-+   {   245, 0x00008B8A }, /* GL_ACTIVE_ATTRIBUTE_MAX_LENGTH */
-+   {   276, 0x00008911 }, /* GL_ACTIVE_STENCIL_FACE_EXT */
-+   {   303, 0x000084E0 }, /* GL_ACTIVE_TEXTURE */
-+   {   321, 0x000084E0 }, /* GL_ACTIVE_TEXTURE_ARB */
-+   {   343, 0x00008B86 }, /* GL_ACTIVE_UNIFORMS */
-+   {   362, 0x00008B87 }, /* GL_ACTIVE_UNIFORM_MAX_LENGTH */
-+   {   391, 0x000086A5 }, /* GL_ACTIVE_VERTEX_UNITS_ARB */
-+   {   418, 0x00000104 }, /* GL_ADD */
-+   {   425, 0x00008574 }, /* GL_ADD_SIGNED */
-+   {   439, 0x00008574 }, /* GL_ADD_SIGNED_ARB */
-+   {   457, 0x00008574 }, /* GL_ADD_SIGNED_EXT */
-+   {   475, 0x0000846E }, /* GL_ALIASED_LINE_WIDTH_RANGE */
-+   {   503, 0x0000846D }, /* GL_ALIASED_POINT_SIZE_RANGE */
-+   {   531, 0x000FFFFF }, /* GL_ALL_ATTRIB_BITS */
-+   {   550, 0xFFFFFFFF }, /* GL_ALL_CLIENT_ATTRIB_BITS */
-+   {   576, 0x00001906 }, /* GL_ALPHA */
-+   {   585, 0x0000803D }, /* GL_ALPHA12 */
-+   {   596, 0x0000803D }, /* GL_ALPHA12_EXT */
-+   {   611, 0x0000803E }, /* GL_ALPHA16 */
-+   {   622, 0x0000803E }, /* GL_ALPHA16_EXT */
-+   {   637, 0x0000803B }, /* GL_ALPHA4 */
-+   {   647, 0x0000803B }, /* GL_ALPHA4_EXT */
-+   {   661, 0x0000803C }, /* GL_ALPHA8 */
-+   {   671, 0x0000803C }, /* GL_ALPHA8_EXT */
-+   {   685, 0x00000D1D }, /* GL_ALPHA_BIAS */
-+   {   699, 0x00000D55 }, /* GL_ALPHA_BITS */
-+   {   713, 0x00000D1C }, /* GL_ALPHA_SCALE */
-+   {   728, 0x00000BC0 }, /* GL_ALPHA_TEST */
-+   {   742, 0x00000BC1 }, /* GL_ALPHA_TEST_FUNC */
-+   {   761, 0x00000BC2 }, /* GL_ALPHA_TEST_REF */
-+   {   779, 0x00000207 }, /* GL_ALWAYS */
-+   {   789, 0x00001200 }, /* GL_AMBIENT */
-+   {   800, 0x00001602 }, /* GL_AMBIENT_AND_DIFFUSE */
-+   {   823, 0x00001501 }, /* GL_AND */
-+   {   830, 0x00001504 }, /* GL_AND_INVERTED */
-+   {   846, 0x00001502 }, /* GL_AND_REVERSE */
-+   {   861, 0x00008892 }, /* GL_ARRAY_BUFFER */
-+   {   877, 0x00008892 }, /* GL_ARRAY_BUFFER_ARB */
-+   {   897, 0x00008894 }, /* GL_ARRAY_BUFFER_BINDING */
-+   {   921, 0x00008894 }, /* GL_ARRAY_BUFFER_BINDING_ARB */
-+   {   949, 0x00008B85 }, /* GL_ATTACHED_SHADERS */
-+   {   969, 0x00008645 }, /* GL_ATTRIB_ARRAY_POINTER_NV */
-+   {   996, 0x00008623 }, /* GL_ATTRIB_ARRAY_SIZE_NV */
-+   {  1020, 0x00008624 }, /* GL_ATTRIB_ARRAY_STRIDE_NV */
-+   {  1046, 0x00008625 }, /* GL_ATTRIB_ARRAY_TYPE_NV */
-+   {  1070, 0x00000BB0 }, /* GL_ATTRIB_STACK_DEPTH */
-+   {  1092, 0x00000D80 }, /* GL_AUTO_NORMAL */
-+   {  1107, 0x00000409 }, /* GL_AUX0 */
-+   {  1115, 0x0000040A }, /* GL_AUX1 */
-+   {  1123, 0x0000040B }, /* GL_AUX2 */
-+   {  1131, 0x0000040C }, /* GL_AUX3 */
-+   {  1139, 0x00000C00 }, /* GL_AUX_BUFFERS */
-+   {  1154, 0x00000405 }, /* GL_BACK */
-+   {  1162, 0x00000402 }, /* GL_BACK_LEFT */
-+   {  1175, 0x00000403 }, /* GL_BACK_RIGHT */
-+   {  1189, 0x000080E0 }, /* GL_BGR */
-+   {  1196, 0x000080E1 }, /* GL_BGRA */
-+   {  1204, 0x00001A00 }, /* GL_BITMAP */
-+   {  1214, 0x00000704 }, /* GL_BITMAP_TOKEN */
-+   {  1230, 0x00000BE2 }, /* GL_BLEND */
-+   {  1239, 0x00008005 }, /* GL_BLEND_COLOR */
-+   {  1254, 0x00008005 }, /* GL_BLEND_COLOR_EXT */
-+   {  1273, 0x00000BE0 }, /* GL_BLEND_DST */
-+   {  1286, 0x000080CA }, /* GL_BLEND_DST_ALPHA */
-+   {  1305, 0x000080C8 }, /* GL_BLEND_DST_RGB */
-+   {  1322, 0x00008009 }, /* GL_BLEND_EQUATION */
-+   {  1340, 0x0000883D }, /* GL_BLEND_EQUATION_ALPHA */
-+   {  1364, 0x0000883D }, /* GL_BLEND_EQUATION_ALPHA_EXT */
-+   {  1392, 0x00008009 }, /* GL_BLEND_EQUATION_EXT */
-+   {  1414, 0x00008009 }, /* GL_BLEND_EQUATION_RGB_EXT */
-+   {  1440, 0x00000BE1 }, /* GL_BLEND_SRC */
-+   {  1453, 0x000080CB }, /* GL_BLEND_SRC_ALPHA */
-+   {  1472, 0x000080C9 }, /* GL_BLEND_SRC_RGB */
-+   {  1489, 0x00001905 }, /* GL_BLUE */
-+   {  1497, 0x00000D1B }, /* GL_BLUE_BIAS */
-+   {  1510, 0x00000D54 }, /* GL_BLUE_BITS */
-+   {  1523, 0x00000D1A }, /* GL_BLUE_SCALE */
-+   {  1537, 0x00008B56 }, /* GL_BOOL */
-+   {  1545, 0x00008B56 }, /* GL_BOOL_ARB */
-+   {  1557, 0x00008B57 }, /* GL_BOOL_VEC2 */
-+   {  1570, 0x00008B57 }, /* GL_BOOL_VEC2_ARB */
-+   {  1587, 0x00008B58 }, /* GL_BOOL_VEC3 */
-+   {  1600, 0x00008B58 }, /* GL_BOOL_VEC3_ARB */
-+   {  1617, 0x00008B59 }, /* GL_BOOL_VEC4 */
-+   {  1630, 0x00008B59 }, /* GL_BOOL_VEC4_ARB */
-+   {  1647, 0x000088BB }, /* GL_BUFFER_ACCESS */
-+   {  1664, 0x000088BB }, /* GL_BUFFER_ACCESS_ARB */
-+   {  1685, 0x000088BC }, /* GL_BUFFER_MAPPED */
-+   {  1702, 0x000088BC }, /* GL_BUFFER_MAPPED_ARB */
-+   {  1723, 0x000088BD }, /* GL_BUFFER_MAP_POINTER */
-+   {  1745, 0x000088BD }, /* GL_BUFFER_MAP_POINTER_ARB */
-+   {  1771, 0x00008764 }, /* GL_BUFFER_SIZE */
-+   {  1786, 0x00008764 }, /* GL_BUFFER_SIZE_ARB */
-+   {  1805, 0x00008765 }, /* GL_BUFFER_USAGE */
-+   {  1821, 0x00008765 }, /* GL_BUFFER_USAGE_ARB */
-+   {  1841, 0x00001400 }, /* GL_BYTE */
-+   {  1849, 0x00002A24 }, /* GL_C3F_V3F */
-+   {  1860, 0x00002A26 }, /* GL_C4F_N3F_V3F */
-+   {  1875, 0x00002A22 }, /* GL_C4UB_V2F */
-+   {  1887, 0x00002A23 }, /* GL_C4UB_V3F */
-+   {  1899, 0x00000901 }, /* GL_CCW */
-+   {  1906, 0x00002900 }, /* GL_CLAMP */
-+   {  1915, 0x0000812D }, /* GL_CLAMP_TO_BORDER */
-+   {  1934, 0x0000812D }, /* GL_CLAMP_TO_BORDER_ARB */
-+   {  1957, 0x0000812D }, /* GL_CLAMP_TO_BORDER_SGIS */
-+   {  1981, 0x0000812F }, /* GL_CLAMP_TO_EDGE */
-+   {  1998, 0x0000812F }, /* GL_CLAMP_TO_EDGE_SGIS */
-+   {  2020, 0x00001500 }, /* GL_CLEAR */
-+   {  2029, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE */
-+   {  2054, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE_ARB */
-+   {  2083, 0xFFFFFFFF }, /* GL_CLIENT_ALL_ATTRIB_BITS */
-+   {  2109, 0x00000BB1 }, /* GL_CLIENT_ATTRIB_STACK_DEPTH */
-+   {  2138, 0x00000001 }, /* GL_CLIENT_PIXEL_STORE_BIT */
-+   {  2164, 0x00000002 }, /* GL_CLIENT_VERTEX_ARRAY_BIT */
-+   {  2191, 0x00003000 }, /* GL_CLIP_PLANE0 */
-+   {  2206, 0x00003001 }, /* GL_CLIP_PLANE1 */
-+   {  2221, 0x00003002 }, /* GL_CLIP_PLANE2 */
-+   {  2236, 0x00003003 }, /* GL_CLIP_PLANE3 */
-+   {  2251, 0x00003004 }, /* GL_CLIP_PLANE4 */
-+   {  2266, 0x00003005 }, /* GL_CLIP_PLANE5 */
-+   {  2281, 0x000080F0 }, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */
-+   {  2314, 0x00000A00 }, /* GL_COEFF */
-+   {  2323, 0x00001800 }, /* GL_COLOR */
-+   {  2332, 0x00008076 }, /* GL_COLOR_ARRAY */
-+   {  2347, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING */
-+   {  2377, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING_ARB */
-+   {  2411, 0x00008090 }, /* GL_COLOR_ARRAY_POINTER */
-+   {  2434, 0x00008081 }, /* GL_COLOR_ARRAY_SIZE */
-+   {  2454, 0x00008083 }, /* GL_COLOR_ARRAY_STRIDE */
-+   {  2476, 0x00008082 }, /* GL_COLOR_ARRAY_TYPE */
-+   {  2496, 0x00008CE0 }, /* GL_COLOR_ATTACHMENT0_EXT */
-+   {  2521, 0x00008CEA }, /* GL_COLOR_ATTACHMENT10_EXT */
-+   {  2547, 0x00008CEB }, /* GL_COLOR_ATTACHMENT11_EXT */
-+   {  2573, 0x00008CEC }, /* GL_COLOR_ATTACHMENT12_EXT */
-+   {  2599, 0x00008CED }, /* GL_COLOR_ATTACHMENT13_EXT */
-+   {  2625, 0x00008CEE }, /* GL_COLOR_ATTACHMENT14_EXT */
-+   {  2651, 0x00008CEF }, /* GL_COLOR_ATTACHMENT15_EXT */
-+   {  2677, 0x00008CE1 }, /* GL_COLOR_ATTACHMENT1_EXT */
-+   {  2702, 0x00008CE2 }, /* GL_COLOR_ATTACHMENT2_EXT */
-+   {  2727, 0x00008CE3 }, /* GL_COLOR_ATTACHMENT3_EXT */
-+   {  2752, 0x00008CE4 }, /* GL_COLOR_ATTACHMENT4_EXT */
-+   {  2777, 0x00008CE5 }, /* GL_COLOR_ATTACHMENT5_EXT */
-+   {  2802, 0x00008CE6 }, /* GL_COLOR_ATTACHMENT6_EXT */
-+   {  2827, 0x00008CE7 }, /* GL_COLOR_ATTACHMENT7_EXT */
-+   {  2852, 0x00008CE8 }, /* GL_COLOR_ATTACHMENT8_EXT */
-+   {  2877, 0x00008CE9 }, /* GL_COLOR_ATTACHMENT9_EXT */
-+   {  2902, 0x00004000 }, /* GL_COLOR_BUFFER_BIT */
-+   {  2922, 0x00000C22 }, /* GL_COLOR_CLEAR_VALUE */
-+   {  2943, 0x00001900 }, /* GL_COLOR_INDEX */
-+   {  2958, 0x00001603 }, /* GL_COLOR_INDEXES */
-+   {  2975, 0x00000BF2 }, /* GL_COLOR_LOGIC_OP */
-+   {  2993, 0x00000B57 }, /* GL_COLOR_MATERIAL */
-+   {  3011, 0x00000B55 }, /* GL_COLOR_MATERIAL_FACE */
-+   {  3034, 0x00000B56 }, /* GL_COLOR_MATERIAL_PARAMETER */
-+   {  3062, 0x000080B1 }, /* GL_COLOR_MATRIX */
-+   {  3078, 0x000080B1 }, /* GL_COLOR_MATRIX_SGI */
-+   {  3098, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH */
-+   {  3126, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH_SGI */
-+   {  3158, 0x00008458 }, /* GL_COLOR_SUM */
-+   {  3171, 0x00008458 }, /* GL_COLOR_SUM_ARB */
-+   {  3188, 0x000080D0 }, /* GL_COLOR_TABLE */
-+   {  3203, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE */
-+   {  3229, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_EXT */
-+   {  3259, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_SGI */
-+   {  3289, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS */
-+   {  3309, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS_SGI */
-+   {  3333, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE */
-+   {  3358, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_EXT */
-+   {  3387, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_SGI */
-+   {  3416, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT */
-+   {  3438, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_EXT */
-+   {  3464, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_SGI */
-+   {  3490, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE */
-+   {  3516, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_EXT */
-+   {  3546, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_SGI */
-+   {  3576, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE */
-+   {  3606, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_EXT */
-+   {  3640, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_SGI */
-+   {  3674, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE */
-+   {  3704, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_EXT */
-+   {  3738, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_SGI */
-+   {  3772, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE */
-+   {  3796, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_EXT */
-+   {  3824, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_SGI */
-+   {  3852, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE */
-+   {  3873, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE_SGI */
-+   {  3898, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH */
-+   {  3919, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_EXT */
-+   {  3944, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_SGI */
-+   {  3969, 0x00000C23 }, /* GL_COLOR_WRITEMASK */
-+   {  3988, 0x00008570 }, /* GL_COMBINE */
-+   {  3999, 0x00008503 }, /* GL_COMBINE4 */
-+   {  4011, 0x00008572 }, /* GL_COMBINE_ALPHA */
-+   {  4028, 0x00008572 }, /* GL_COMBINE_ALPHA_ARB */
-+   {  4049, 0x00008572 }, /* GL_COMBINE_ALPHA_EXT */
-+   {  4070, 0x00008570 }, /* GL_COMBINE_ARB */
-+   {  4085, 0x00008570 }, /* GL_COMBINE_EXT */
-+   {  4100, 0x00008571 }, /* GL_COMBINE_RGB */
-+   {  4115, 0x00008571 }, /* GL_COMBINE_RGB_ARB */
-+   {  4134, 0x00008571 }, /* GL_COMBINE_RGB_EXT */
-+   {  4153, 0x0000884E }, /* GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT */
-+   {  4189, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE */
-+   {  4213, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE_ARB */
-+   {  4241, 0x00001300 }, /* GL_COMPILE */
-+   {  4252, 0x00001301 }, /* GL_COMPILE_AND_EXECUTE */
-+   {  4275, 0x00008B81 }, /* GL_COMPILE_STATUS */
-+   {  4293, 0x000084E9 }, /* GL_COMPRESSED_ALPHA */
-+   {  4313, 0x000084E9 }, /* GL_COMPRESSED_ALPHA_ARB */
-+   {  4337, 0x000084EC }, /* GL_COMPRESSED_INTENSITY */
-+   {  4361, 0x000084EC }, /* GL_COMPRESSED_INTENSITY_ARB */
-+   {  4389, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE */
-+   {  4413, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA */
-+   {  4443, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA_ARB */
-+   {  4477, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE_ARB */
-+   {  4505, 0x000084ED }, /* GL_COMPRESSED_RGB */
-+   {  4523, 0x000084EE }, /* GL_COMPRESSED_RGBA */
-+   {  4542, 0x000084EE }, /* GL_COMPRESSED_RGBA_ARB */
-+   {  4565, 0x000086B1 }, /* GL_COMPRESSED_RGBA_FXT1_3DFX */
-+   {  4594, 0x000083F1 }, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */
-+   {  4627, 0x000083F2 }, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */
-+   {  4660, 0x000083F3 }, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */
-+   {  4693, 0x000084ED }, /* GL_COMPRESSED_RGB_ARB */
-+   {  4715, 0x000086B0 }, /* GL_COMPRESSED_RGB_FXT1_3DFX */
-+   {  4743, 0x000083F0 }, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */
-+   {  4775, 0x000086A3 }, /* GL_COMPRESSED_TEXTURE_FORMATS */
-+   {  4805, 0x00008576 }, /* GL_CONSTANT */
-+   {  4817, 0x00008003 }, /* GL_CONSTANT_ALPHA */
-+   {  4835, 0x00008003 }, /* GL_CONSTANT_ALPHA_EXT */
-+   {  4857, 0x00008576 }, /* GL_CONSTANT_ARB */
-+   {  4873, 0x00001207 }, /* GL_CONSTANT_ATTENUATION */
-+   {  4897, 0x00008151 }, /* GL_CONSTANT_BORDER_HP */
-+   {  4919, 0x00008001 }, /* GL_CONSTANT_COLOR */
-+   {  4937, 0x00008001 }, /* GL_CONSTANT_COLOR_EXT */
-+   {  4959, 0x00008576 }, /* GL_CONSTANT_EXT */
-+   {  4975, 0x00008010 }, /* GL_CONVOLUTION_1D */
-+   {  4993, 0x00008011 }, /* GL_CONVOLUTION_2D */
-+   {  5011, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR */
-+   {  5039, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR_HP */
-+   {  5070, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE */
-+   {  5097, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE_EXT */
-+   {  5128, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS */
-+   {  5155, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS_EXT */
-+   {  5186, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE */
-+   {  5214, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE_EXT */
-+   {  5246, 0x00008017 }, /* GL_CONVOLUTION_FORMAT */
-+   {  5268, 0x00008017 }, /* GL_CONVOLUTION_FORMAT_EXT */
-+   {  5294, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT */
-+   {  5316, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT_EXT */
-+   {  5342, 0x00008018 }, /* GL_CONVOLUTION_WIDTH */
-+   {  5363, 0x00008018 }, /* GL_CONVOLUTION_WIDTH_EXT */
-+   {  5388, 0x00008862 }, /* GL_COORD_REPLACE */
-+   {  5405, 0x00008862 }, /* GL_COORD_REPLACE_ARB */
-+   {  5426, 0x00008862 }, /* GL_COORD_REPLACE_NV */
-+   {  5446, 0x00001503 }, /* GL_COPY */
-+   {  5454, 0x0000150C }, /* GL_COPY_INVERTED */
-+   {  5471, 0x00000706 }, /* GL_COPY_PIXEL_TOKEN */
-+   {  5491, 0x00000B44 }, /* GL_CULL_FACE */
-+   {  5504, 0x00000B45 }, /* GL_CULL_FACE_MODE */
-+   {  5522, 0x000081AA }, /* GL_CULL_VERTEX_EXT */
-+   {  5541, 0x000081AC }, /* GL_CULL_VERTEX_EYE_POSITION_EXT */
-+   {  5573, 0x000081AB }, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */
-+   {  5608, 0x00008626 }, /* GL_CURRENT_ATTRIB_NV */
-+   {  5629, 0x00000001 }, /* GL_CURRENT_BIT */
-+   {  5644, 0x00000B00 }, /* GL_CURRENT_COLOR */
-+   {  5661, 0x00008453 }, /* GL_CURRENT_FOG_COORD */
-+   {  5682, 0x00008453 }, /* GL_CURRENT_FOG_COORDINATE */
-+   {  5708, 0x00000B01 }, /* GL_CURRENT_INDEX */
-+   {  5725, 0x00008641 }, /* GL_CURRENT_MATRIX_ARB */
-+   {  5747, 0x00008845 }, /* GL_CURRENT_MATRIX_INDEX_ARB */
-+   {  5775, 0x00008641 }, /* GL_CURRENT_MATRIX_NV */
-+   {  5796, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */
-+   {  5830, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_NV */
-+   {  5863, 0x00000B02 }, /* GL_CURRENT_NORMAL */
-+   {  5881, 0x00008843 }, /* GL_CURRENT_PALETTE_MATRIX_ARB */
-+   {  5911, 0x00008B8D }, /* GL_CURRENT_PROGRAM */
-+   {  5930, 0x00008865 }, /* GL_CURRENT_QUERY */
-+   {  5947, 0x00008865 }, /* GL_CURRENT_QUERY_ARB */
-+   {  5968, 0x00000B04 }, /* GL_CURRENT_RASTER_COLOR */
-+   {  5992, 0x00000B09 }, /* GL_CURRENT_RASTER_DISTANCE */
-+   {  6019, 0x00000B05 }, /* GL_CURRENT_RASTER_INDEX */
-+   {  6043, 0x00000B07 }, /* GL_CURRENT_RASTER_POSITION */
-+   {  6070, 0x00000B08 }, /* GL_CURRENT_RASTER_POSITION_VALID */
-+   {  6103, 0x00000B06 }, /* GL_CURRENT_RASTER_TEXTURE_COORDS */
-+   {  6136, 0x00008459 }, /* GL_CURRENT_SECONDARY_COLOR */
-+   {  6163, 0x00000B03 }, /* GL_CURRENT_TEXTURE_COORDS */
-+   {  6189, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB */
-+   {  6214, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB_ARB */
-+   {  6243, 0x000086A8 }, /* GL_CURRENT_WEIGHT_ARB */
-+   {  6265, 0x00000900 }, /* GL_CW */
-+   {  6271, 0x0000875B }, /* GL_DEBUG_ASSERT_MESA */
-+   {  6292, 0x00008759 }, /* GL_DEBUG_OBJECT_MESA */
-+   {  6313, 0x0000875A }, /* GL_DEBUG_PRINT_MESA */
-+   {  6333, 0x00002101 }, /* GL_DECAL */
-+   {  6342, 0x00001E03 }, /* GL_DECR */
-+   {  6350, 0x00008508 }, /* GL_DECR_WRAP */
-+   {  6363, 0x00008508 }, /* GL_DECR_WRAP_EXT */
-+   {  6380, 0x00008B80 }, /* GL_DELETE_STATUS */
-+   {  6397, 0x00001801 }, /* GL_DEPTH */
-+   {  6406, 0x00008D00 }, /* GL_DEPTH_ATTACHMENT_EXT */
-+   {  6430, 0x00000D1F }, /* GL_DEPTH_BIAS */
-+   {  6444, 0x00000D56 }, /* GL_DEPTH_BITS */
-+   {  6458, 0x00008891 }, /* GL_DEPTH_BOUNDS_EXT */
-+   {  6478, 0x00008890 }, /* GL_DEPTH_BOUNDS_TEST_EXT */
-+   {  6503, 0x00000100 }, /* GL_DEPTH_BUFFER_BIT */
-+   {  6523, 0x0000864F }, /* GL_DEPTH_CLAMP_NV */
-+   {  6541, 0x00000B73 }, /* GL_DEPTH_CLEAR_VALUE */
-+   {  6562, 0x00001902 }, /* GL_DEPTH_COMPONENT */
-+   {  6581, 0x000081A5 }, /* GL_DEPTH_COMPONENT16 */
-+   {  6602, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_ARB */
-+   {  6627, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_SGIX */
-+   {  6653, 0x000081A6 }, /* GL_DEPTH_COMPONENT24 */
-+   {  6674, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_ARB */
-+   {  6699, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_SGIX */
-+   {  6725, 0x000081A7 }, /* GL_DEPTH_COMPONENT32 */
-+   {  6746, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_ARB */
-+   {  6771, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_SGIX */
-+   {  6797, 0x00000B74 }, /* GL_DEPTH_FUNC */
-+   {  6811, 0x00000B70 }, /* GL_DEPTH_RANGE */
-+   {  6826, 0x00000D1E }, /* GL_DEPTH_SCALE */
-+   {  6841, 0x000084F9 }, /* GL_DEPTH_STENCIL_NV */
-+   {  6861, 0x0000886F }, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
-+   {  6889, 0x0000886E }, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
-+   {  6917, 0x00000B71 }, /* GL_DEPTH_TEST */
-+   {  6931, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE */
-+   {  6953, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE_ARB */
-+   {  6979, 0x00000B72 }, /* GL_DEPTH_WRITEMASK */
-+   {  6998, 0x00001201 }, /* GL_DIFFUSE */
-+   {  7009, 0x00000BD0 }, /* GL_DITHER */
-+   {  7019, 0x00000A02 }, /* GL_DOMAIN */
-+   {  7029, 0x00001100 }, /* GL_DONT_CARE */
-+   {  7042, 0x000086AE }, /* GL_DOT3_RGB */
-+   {  7054, 0x000086AF }, /* GL_DOT3_RGBA */
-+   {  7067, 0x000086AF }, /* GL_DOT3_RGBA_ARB */
-+   {  7084, 0x00008741 }, /* GL_DOT3_RGBA_EXT */
-+   {  7101, 0x000086AE }, /* GL_DOT3_RGB_ARB */
-+   {  7117, 0x00008740 }, /* GL_DOT3_RGB_EXT */
-+   {  7133, 0x0000140A }, /* GL_DOUBLE */
-+   {  7143, 0x00000C32 }, /* GL_DOUBLEBUFFER */
-+   {  7159, 0x00000C01 }, /* GL_DRAW_BUFFER */
-+   {  7174, 0x00008825 }, /* GL_DRAW_BUFFER0 */
-+   {  7190, 0x00008825 }, /* GL_DRAW_BUFFER0_ARB */
-+   {  7210, 0x00008825 }, /* GL_DRAW_BUFFER0_ATI */
-+   {  7230, 0x00008826 }, /* GL_DRAW_BUFFER1 */
-+   {  7246, 0x0000882F }, /* GL_DRAW_BUFFER10 */
-+   {  7263, 0x0000882F }, /* GL_DRAW_BUFFER10_ARB */
-+   {  7284, 0x0000882F }, /* GL_DRAW_BUFFER10_ATI */
-+   {  7305, 0x00008830 }, /* GL_DRAW_BUFFER11 */
-+   {  7322, 0x00008830 }, /* GL_DRAW_BUFFER11_ARB */
-+   {  7343, 0x00008830 }, /* GL_DRAW_BUFFER11_ATI */
-+   {  7364, 0x00008831 }, /* GL_DRAW_BUFFER12 */
-+   {  7381, 0x00008831 }, /* GL_DRAW_BUFFER12_ARB */
-+   {  7402, 0x00008831 }, /* GL_DRAW_BUFFER12_ATI */
-+   {  7423, 0x00008832 }, /* GL_DRAW_BUFFER13 */
-+   {  7440, 0x00008832 }, /* GL_DRAW_BUFFER13_ARB */
-+   {  7461, 0x00008832 }, /* GL_DRAW_BUFFER13_ATI */
-+   {  7482, 0x00008833 }, /* GL_DRAW_BUFFER14 */
-+   {  7499, 0x00008833 }, /* GL_DRAW_BUFFER14_ARB */
-+   {  7520, 0x00008833 }, /* GL_DRAW_BUFFER14_ATI */
-+   {  7541, 0x00008834 }, /* GL_DRAW_BUFFER15 */
-+   {  7558, 0x00008834 }, /* GL_DRAW_BUFFER15_ARB */
-+   {  7579, 0x00008834 }, /* GL_DRAW_BUFFER15_ATI */
-+   {  7600, 0x00008826 }, /* GL_DRAW_BUFFER1_ARB */
-+   {  7620, 0x00008826 }, /* GL_DRAW_BUFFER1_ATI */
-+   {  7640, 0x00008827 }, /* GL_DRAW_BUFFER2 */
-+   {  7656, 0x00008827 }, /* GL_DRAW_BUFFER2_ARB */
-+   {  7676, 0x00008827 }, /* GL_DRAW_BUFFER2_ATI */
-+   {  7696, 0x00008828 }, /* GL_DRAW_BUFFER3 */
-+   {  7712, 0x00008828 }, /* GL_DRAW_BUFFER3_ARB */
-+   {  7732, 0x00008828 }, /* GL_DRAW_BUFFER3_ATI */
-+   {  7752, 0x00008829 }, /* GL_DRAW_BUFFER4 */
-+   {  7768, 0x00008829 }, /* GL_DRAW_BUFFER4_ARB */
-+   {  7788, 0x00008829 }, /* GL_DRAW_BUFFER4_ATI */
-+   {  7808, 0x0000882A }, /* GL_DRAW_BUFFER5 */
-+   {  7824, 0x0000882A }, /* GL_DRAW_BUFFER5_ARB */
-+   {  7844, 0x0000882A }, /* GL_DRAW_BUFFER5_ATI */
-+   {  7864, 0x0000882B }, /* GL_DRAW_BUFFER6 */
-+   {  7880, 0x0000882B }, /* GL_DRAW_BUFFER6_ARB */
-+   {  7900, 0x0000882B }, /* GL_DRAW_BUFFER6_ATI */
-+   {  7920, 0x0000882C }, /* GL_DRAW_BUFFER7 */
-+   {  7936, 0x0000882C }, /* GL_DRAW_BUFFER7_ARB */
-+   {  7956, 0x0000882C }, /* GL_DRAW_BUFFER7_ATI */
-+   {  7976, 0x0000882D }, /* GL_DRAW_BUFFER8 */
-+   {  7992, 0x0000882D }, /* GL_DRAW_BUFFER8_ARB */
-+   {  8012, 0x0000882D }, /* GL_DRAW_BUFFER8_ATI */
-+   {  8032, 0x0000882E }, /* GL_DRAW_BUFFER9 */
-+   {  8048, 0x0000882E }, /* GL_DRAW_BUFFER9_ARB */
-+   {  8068, 0x0000882E }, /* GL_DRAW_BUFFER9_ATI */
-+   {  8088, 0x00008CA6 }, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */
-+   {  8120, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER_EXT */
-+   {  8144, 0x00000705 }, /* GL_DRAW_PIXEL_TOKEN */
-+   {  8164, 0x00000304 }, /* GL_DST_ALPHA */
-+   {  8177, 0x00000306 }, /* GL_DST_COLOR */
-+   {  8190, 0x000088EA }, /* GL_DYNAMIC_COPY */
-+   {  8206, 0x000088EA }, /* GL_DYNAMIC_COPY_ARB */
-+   {  8226, 0x000088E8 }, /* GL_DYNAMIC_DRAW */
-+   {  8242, 0x000088E8 }, /* GL_DYNAMIC_DRAW_ARB */
-+   {  8262, 0x000088E9 }, /* GL_DYNAMIC_READ */
-+   {  8278, 0x000088E9 }, /* GL_DYNAMIC_READ_ARB */
-+   {  8298, 0x00000B43 }, /* GL_EDGE_FLAG */
-+   {  8311, 0x00008079 }, /* GL_EDGE_FLAG_ARRAY */
-+   {  8330, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
-+   {  8364, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB */
-+   {  8402, 0x00008093 }, /* GL_EDGE_FLAG_ARRAY_POINTER */
-+   {  8429, 0x0000808C }, /* GL_EDGE_FLAG_ARRAY_STRIDE */
-+   {  8455, 0x00008893 }, /* GL_ELEMENT_ARRAY_BUFFER */
-+   {  8479, 0x00008893 }, /* GL_ELEMENT_ARRAY_BUFFER_ARB */
-+   {  8507, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
-+   {  8539, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB */
-+   {  8575, 0x00001600 }, /* GL_EMISSION */
-+   {  8587, 0x00002000 }, /* GL_ENABLE_BIT */
-+   {  8601, 0x00000202 }, /* GL_EQUAL */
-+   {  8610, 0x00001509 }, /* GL_EQUIV */
-+   {  8619, 0x00010000 }, /* GL_EVAL_BIT */
-+   {  8631, 0x00000800 }, /* GL_EXP */
-+   {  8638, 0x00000801 }, /* GL_EXP2 */
-+   {  8646, 0x00001F03 }, /* GL_EXTENSIONS */
-+   {  8660, 0x00002400 }, /* GL_EYE_LINEAR */
-+   {  8674, 0x00002502 }, /* GL_EYE_PLANE */
-+   {  8687, 0x0000855C }, /* GL_EYE_PLANE_ABSOLUTE_NV */
-+   {  8712, 0x0000855B }, /* GL_EYE_RADIAL_NV */
-+   {  8729, 0x00000000 }, /* GL_FALSE */
-+   {  8738, 0x00001101 }, /* GL_FASTEST */
-+   {  8749, 0x00001C01 }, /* GL_FEEDBACK */
-+   {  8761, 0x00000DF0 }, /* GL_FEEDBACK_BUFFER_POINTER */
-+   {  8788, 0x00000DF1 }, /* GL_FEEDBACK_BUFFER_SIZE */
-+   {  8812, 0x00000DF2 }, /* GL_FEEDBACK_BUFFER_TYPE */
-+   {  8836, 0x00001B02 }, /* GL_FILL */
-+   {  8844, 0x00001D00 }, /* GL_FLAT */
-+   {  8852, 0x00001406 }, /* GL_FLOAT */
-+   {  8861, 0x00008B5A }, /* GL_FLOAT_MAT2 */
-+   {  8875, 0x00008B5A }, /* GL_FLOAT_MAT2_ARB */
-+   {  8893, 0x00008B5B }, /* GL_FLOAT_MAT3 */
-+   {  8907, 0x00008B5B }, /* GL_FLOAT_MAT3_ARB */
-+   {  8925, 0x00008B5C }, /* GL_FLOAT_MAT4 */
-+   {  8939, 0x00008B5C }, /* GL_FLOAT_MAT4_ARB */
-+   {  8957, 0x00008B50 }, /* GL_FLOAT_VEC2 */
-+   {  8971, 0x00008B50 }, /* GL_FLOAT_VEC2_ARB */
-+   {  8989, 0x00008B51 }, /* GL_FLOAT_VEC3 */
-+   {  9003, 0x00008B51 }, /* GL_FLOAT_VEC3_ARB */
-+   {  9021, 0x00008B52 }, /* GL_FLOAT_VEC4 */
-+   {  9035, 0x00008B52 }, /* GL_FLOAT_VEC4_ARB */
-+   {  9053, 0x00000B60 }, /* GL_FOG */
-+   {  9060, 0x00000080 }, /* GL_FOG_BIT */
-+   {  9071, 0x00000B66 }, /* GL_FOG_COLOR */
-+   {  9084, 0x00008451 }, /* GL_FOG_COORD */
-+   {  9097, 0x00008451 }, /* GL_FOG_COORDINATE */
-+   {  9115, 0x00008457 }, /* GL_FOG_COORDINATE_ARRAY */
-+   {  9139, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
-+   {  9178, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB */
-+   {  9221, 0x00008456 }, /* GL_FOG_COORDINATE_ARRAY_POINTER */
-+   {  9253, 0x00008455 }, /* GL_FOG_COORDINATE_ARRAY_STRIDE */
-+   {  9284, 0x00008454 }, /* GL_FOG_COORDINATE_ARRAY_TYPE */
-+   {  9313, 0x00008450 }, /* GL_FOG_COORDINATE_SOURCE */
-+   {  9338, 0x00008457 }, /* GL_FOG_COORD_ARRAY */
-+   {  9357, 0x0000889D }, /* GL_FOG_COORD_ARRAY_BUFFER_BINDING */
-+   {  9391, 0x00008456 }, /* GL_FOG_COORD_ARRAY_POINTER */
-+   {  9418, 0x00008455 }, /* GL_FOG_COORD_ARRAY_STRIDE */
-+   {  9444, 0x00008454 }, /* GL_FOG_COORD_ARRAY_TYPE */
-+   {  9468, 0x00008450 }, /* GL_FOG_COORD_SRC */
-+   {  9485, 0x00000B62 }, /* GL_FOG_DENSITY */
-+   {  9500, 0x0000855A }, /* GL_FOG_DISTANCE_MODE_NV */
-+   {  9524, 0x00000B64 }, /* GL_FOG_END */
-+   {  9535, 0x00000C54 }, /* GL_FOG_HINT */
-+   {  9547, 0x00000B61 }, /* GL_FOG_INDEX */
-+   {  9560, 0x00000B65 }, /* GL_FOG_MODE */
-+   {  9572, 0x00008198 }, /* GL_FOG_OFFSET_SGIX */
-+   {  9591, 0x00008199 }, /* GL_FOG_OFFSET_VALUE_SGIX */
-+   {  9616, 0x00000B63 }, /* GL_FOG_START */
-+   {  9629, 0x00008452 }, /* GL_FRAGMENT_DEPTH */
-+   {  9647, 0x00008804 }, /* GL_FRAGMENT_PROGRAM_ARB */
-+   {  9671, 0x00008B30 }, /* GL_FRAGMENT_SHADER */
-+   {  9690, 0x00008B30 }, /* GL_FRAGMENT_SHADER_ARB */
-+   {  9713, 0x00008B8B }, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */
-+   {  9748, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT */
-+   {  9790, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT */
-+   {  9832, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT */
-+   {  9881, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT */
-+   {  9933, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT */
-+   {  9977, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT */
-+   { 10021, 0x00008CA6 }, /* GL_FRAMEBUFFER_BINDING_EXT */
-+   { 10048, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE_EXT */
-+   { 10076, 0x00008D40 }, /* GL_FRAMEBUFFER_EXT */
-+   { 10095, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT */
-+   { 10136, 0x00008CD9 }, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */
-+   { 10177, 0x00008CDB }, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */
-+   { 10219, 0x00008CD8 }, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */
-+   { 10270, 0x00008CDA }, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */
-+   { 10308, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT */
-+   { 10357, 0x00008CDC }, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */
-+   { 10399, 0x00008CDE }, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */
-+   { 10431, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED_EXT */
-+   { 10462, 0x00000404 }, /* GL_FRONT */
-+   { 10471, 0x00000408 }, /* GL_FRONT_AND_BACK */
-+   { 10489, 0x00000B46 }, /* GL_FRONT_FACE */
-+   { 10503, 0x00000400 }, /* GL_FRONT_LEFT */
-+   { 10517, 0x00000401 }, /* GL_FRONT_RIGHT */
-+   { 10532, 0x00008006 }, /* GL_FUNC_ADD */
-+   { 10544, 0x00008006 }, /* GL_FUNC_ADD_EXT */
-+   { 10560, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT */
-+   { 10585, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT_EXT */
-+   { 10614, 0x0000800A }, /* GL_FUNC_SUBTRACT */
-+   { 10631, 0x0000800A }, /* GL_FUNC_SUBTRACT_EXT */
-+   { 10652, 0x00008191 }, /* GL_GENERATE_MIPMAP */
-+   { 10671, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT */
-+   { 10695, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT_SGIS */
-+   { 10724, 0x00008191 }, /* GL_GENERATE_MIPMAP_SGIS */
-+   { 10748, 0x00000206 }, /* GL_GEQUAL */
-+   { 10758, 0x00008009 }, /* GL_GL_BLEND_EQUATION_RGB */
-+   { 10783, 0x00008C4A }, /* GL_GL_COMPRESSED_SLUMINANCE */
-+   { 10811, 0x00008C4B }, /* GL_GL_COMPRESSED_SLUMINANCE_ALPHA */
-+   { 10845, 0x00008C48 }, /* GL_GL_COMPRESSED_SRGB */
-+   { 10867, 0x00008C49 }, /* GL_GL_COMPRESSED_SRGB_ALPHA */
-+   { 10895, 0x0000845F }, /* GL_GL_CURRENT_RASTER_SECONDARY_COLOR */
-+   { 10932, 0x00008B65 }, /* GL_GL_FLOAT_MAT2x3 */
-+   { 10951, 0x00008B66 }, /* GL_GL_FLOAT_MAT2x4 */
-+   { 10970, 0x00008B67 }, /* GL_GL_FLOAT_MAT3x2 */
-+   { 10989, 0x00008B68 }, /* GL_GL_FLOAT_MAT3x4 */
-+   { 11008, 0x00008B69 }, /* GL_GL_FLOAT_MAT4x2 */
-+   { 11027, 0x00008B6A }, /* GL_GL_FLOAT_MAT4x3 */
-+   { 11046, 0x000088EB }, /* GL_GL_PIXEL_PACK_BUFFER */
-+   { 11070, 0x000088ED }, /* GL_GL_PIXEL_PACK_BUFFER_BINDING */
-+   { 11102, 0x000088EC }, /* GL_GL_PIXEL_UNPACK_BUFFER */
-+   { 11128, 0x000088EF }, /* GL_GL_PIXEL_UNPACK_BUFFER_BINDING */
-+   { 11162, 0x00008C46 }, /* GL_GL_SLUMINANCE */
-+   { 11179, 0x00008C47 }, /* GL_GL_SLUMINANCE8 */
-+   { 11197, 0x00008C45 }, /* GL_GL_SLUMINANCE8_ALPHA8 */
-+   { 11222, 0x00008C44 }, /* GL_GL_SLUMINANCE_ALPHA */
-+   { 11245, 0x00008C40 }, /* GL_GL_SRGB */
-+   { 11256, 0x00008C41 }, /* GL_GL_SRGB8 */
-+   { 11268, 0x00008C43 }, /* GL_GL_SRGB8_ALPHA8 */
-+   { 11287, 0x00008C42 }, /* GL_GL_SRGB_ALPHA */
-+   { 11304, 0x00000204 }, /* GL_GREATER */
-+   { 11315, 0x00001904 }, /* GL_GREEN */
-+   { 11324, 0x00000D19 }, /* GL_GREEN_BIAS */
-+   { 11338, 0x00000D53 }, /* GL_GREEN_BITS */
-+   { 11352, 0x00000D18 }, /* GL_GREEN_SCALE */
-+   { 11367, 0x00008000 }, /* GL_HINT_BIT */
-+   { 11379, 0x00008024 }, /* GL_HISTOGRAM */
-+   { 11392, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE */
-+   { 11416, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE_EXT */
-+   { 11444, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE */
-+   { 11467, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE_EXT */
-+   { 11494, 0x00008024 }, /* GL_HISTOGRAM_EXT */
-+   { 11511, 0x00008027 }, /* GL_HISTOGRAM_FORMAT */
-+   { 11531, 0x00008027 }, /* GL_HISTOGRAM_FORMAT_EXT */
-+   { 11555, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE */
-+   { 11579, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE_EXT */
-+   { 11607, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE */
-+   { 11635, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE_EXT */
-+   { 11667, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE */
-+   { 11689, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE_EXT */
-+   { 11715, 0x0000802D }, /* GL_HISTOGRAM_SINK */
-+   { 11733, 0x0000802D }, /* GL_HISTOGRAM_SINK_EXT */
-+   { 11755, 0x00008026 }, /* GL_HISTOGRAM_WIDTH */
-+   { 11774, 0x00008026 }, /* GL_HISTOGRAM_WIDTH_EXT */
-+   { 11797, 0x0000862A }, /* GL_IDENTITY_NV */
-+   { 11812, 0x00008150 }, /* GL_IGNORE_BORDER_HP */
-+   { 11832, 0x00008B9B }, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
-+   { 11872, 0x00008B9A }, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
-+   { 11910, 0x00001E02 }, /* GL_INCR */
-+   { 11918, 0x00008507 }, /* GL_INCR_WRAP */
-+   { 11931, 0x00008507 }, /* GL_INCR_WRAP_EXT */
-+   { 11948, 0x00008077 }, /* GL_INDEX_ARRAY */
-+   { 11963, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING */
-+   { 11993, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING_ARB */
-+   { 12027, 0x00008091 }, /* GL_INDEX_ARRAY_POINTER */
-+   { 12050, 0x00008086 }, /* GL_INDEX_ARRAY_STRIDE */
-+   { 12072, 0x00008085 }, /* GL_INDEX_ARRAY_TYPE */
-+   { 12092, 0x00000D51 }, /* GL_INDEX_BITS */
-+   { 12106, 0x00000C20 }, /* GL_INDEX_CLEAR_VALUE */
-+   { 12127, 0x00000BF1 }, /* GL_INDEX_LOGIC_OP */
-+   { 12145, 0x00000C30 }, /* GL_INDEX_MODE */
-+   { 12159, 0x00000D13 }, /* GL_INDEX_OFFSET */
-+   { 12175, 0x00000D12 }, /* GL_INDEX_SHIFT */
-+   { 12190, 0x00000C21 }, /* GL_INDEX_WRITEMASK */
-+   { 12209, 0x00008B84 }, /* GL_INFO_LOG_LENGTH */
-+   { 12228, 0x00001404 }, /* GL_INT */
-+   { 12235, 0x00008049 }, /* GL_INTENSITY */
-+   { 12248, 0x0000804C }, /* GL_INTENSITY12 */
-+   { 12263, 0x0000804C }, /* GL_INTENSITY12_EXT */
-+   { 12282, 0x0000804D }, /* GL_INTENSITY16 */
-+   { 12297, 0x0000804D }, /* GL_INTENSITY16_EXT */
-+   { 12316, 0x0000804A }, /* GL_INTENSITY4 */
-+   { 12330, 0x0000804A }, /* GL_INTENSITY4_EXT */
-+   { 12348, 0x0000804B }, /* GL_INTENSITY8 */
-+   { 12362, 0x0000804B }, /* GL_INTENSITY8_EXT */
-+   { 12380, 0x00008049 }, /* GL_INTENSITY_EXT */
-+   { 12397, 0x00008575 }, /* GL_INTERPOLATE */
-+   { 12412, 0x00008575 }, /* GL_INTERPOLATE_ARB */
-+   { 12431, 0x00008575 }, /* GL_INTERPOLATE_EXT */
-+   { 12450, 0x00008B53 }, /* GL_INT_VEC2 */
-+   { 12462, 0x00008B53 }, /* GL_INT_VEC2_ARB */
-+   { 12478, 0x00008B54 }, /* GL_INT_VEC3 */
-+   { 12490, 0x00008B54 }, /* GL_INT_VEC3_ARB */
-+   { 12506, 0x00008B55 }, /* GL_INT_VEC4 */
-+   { 12518, 0x00008B55 }, /* GL_INT_VEC4_ARB */
-+   { 12534, 0x00000500 }, /* GL_INVALID_ENUM */
-+   { 12550, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */
-+   { 12587, 0x00000502 }, /* GL_INVALID_OPERATION */
-+   { 12608, 0x00000501 }, /* GL_INVALID_VALUE */
-+   { 12625, 0x0000862B }, /* GL_INVERSE_NV */
-+   { 12639, 0x0000862D }, /* GL_INVERSE_TRANSPOSE_NV */
-+   { 12663, 0x0000150A }, /* GL_INVERT */
-+   { 12673, 0x00001E00 }, /* GL_KEEP */
-+   { 12681, 0x00000406 }, /* GL_LEFT */
-+   { 12689, 0x00000203 }, /* GL_LEQUAL */
-+   { 12699, 0x00000201 }, /* GL_LESS */
-+   { 12707, 0x00004000 }, /* GL_LIGHT0 */
-+   { 12717, 0x00004001 }, /* GL_LIGHT1 */
-+   { 12727, 0x00004002 }, /* GL_LIGHT2 */
-+   { 12737, 0x00004003 }, /* GL_LIGHT3 */
-+   { 12747, 0x00004004 }, /* GL_LIGHT4 */
-+   { 12757, 0x00004005 }, /* GL_LIGHT5 */
-+   { 12767, 0x00004006 }, /* GL_LIGHT6 */
-+   { 12777, 0x00004007 }, /* GL_LIGHT7 */
-+   { 12787, 0x00000B50 }, /* GL_LIGHTING */
-+   { 12799, 0x00000040 }, /* GL_LIGHTING_BIT */
-+   { 12815, 0x00000B53 }, /* GL_LIGHT_MODEL_AMBIENT */
-+   { 12838, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL */
-+   { 12867, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL_EXT */
-+   { 12900, 0x00000B51 }, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
-+   { 12928, 0x00000B52 }, /* GL_LIGHT_MODEL_TWO_SIDE */
-+   { 12952, 0x00001B01 }, /* GL_LINE */
-+   { 12960, 0x00002601 }, /* GL_LINEAR */
-+   { 12970, 0x00001208 }, /* GL_LINEAR_ATTENUATION */
-+   { 12992, 0x00008170 }, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
-+   { 13022, 0x0000844F }, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
-+   { 13053, 0x00002703 }, /* GL_LINEAR_MIPMAP_LINEAR */
-+   { 13077, 0x00002701 }, /* GL_LINEAR_MIPMAP_NEAREST */
-+   { 13102, 0x00000001 }, /* GL_LINES */
-+   { 13111, 0x00000004 }, /* GL_LINE_BIT */
-+   { 13123, 0x00000002 }, /* GL_LINE_LOOP */
-+   { 13136, 0x00000707 }, /* GL_LINE_RESET_TOKEN */
-+   { 13156, 0x00000B20 }, /* GL_LINE_SMOOTH */
-+   { 13171, 0x00000C52 }, /* GL_LINE_SMOOTH_HINT */
-+   { 13191, 0x00000B24 }, /* GL_LINE_STIPPLE */
-+   { 13207, 0x00000B25 }, /* GL_LINE_STIPPLE_PATTERN */
-+   { 13231, 0x00000B26 }, /* GL_LINE_STIPPLE_REPEAT */
-+   { 13254, 0x00000003 }, /* GL_LINE_STRIP */
-+   { 13268, 0x00000702 }, /* GL_LINE_TOKEN */
-+   { 13282, 0x00000B21 }, /* GL_LINE_WIDTH */
-+   { 13296, 0x00000B23 }, /* GL_LINE_WIDTH_GRANULARITY */
-+   { 13322, 0x00000B22 }, /* GL_LINE_WIDTH_RANGE */
-+   { 13342, 0x00008B82 }, /* GL_LINK_STATUS */
-+   { 13357, 0x00000B32 }, /* GL_LIST_BASE */
-+   { 13370, 0x00020000 }, /* GL_LIST_BIT */
-+   { 13382, 0x00000B33 }, /* GL_LIST_INDEX */
-+   { 13396, 0x00000B30 }, /* GL_LIST_MODE */
-+   { 13409, 0x00000101 }, /* GL_LOAD */
-+   { 13417, 0x00000BF1 }, /* GL_LOGIC_OP */
-+   { 13429, 0x00000BF0 }, /* GL_LOGIC_OP_MODE */
-+   { 13446, 0x00008CA1 }, /* GL_LOWER_LEFT */
-+   { 13460, 0x00001909 }, /* GL_LUMINANCE */
-+   { 13473, 0x00008041 }, /* GL_LUMINANCE12 */
-+   { 13488, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12 */
-+   { 13511, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12_EXT */
-+   { 13538, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4 */
-+   { 13560, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4_EXT */
-+   { 13586, 0x00008041 }, /* GL_LUMINANCE12_EXT */
-+   { 13605, 0x00008042 }, /* GL_LUMINANCE16 */
-+   { 13620, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16 */
-+   { 13643, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16_EXT */
-+   { 13670, 0x00008042 }, /* GL_LUMINANCE16_EXT */
-+   { 13689, 0x0000803F }, /* GL_LUMINANCE4 */
-+   { 13703, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4 */
-+   { 13724, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4_EXT */
-+   { 13749, 0x0000803F }, /* GL_LUMINANCE4_EXT */
-+   { 13767, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2 */
-+   { 13788, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2_EXT */
-+   { 13813, 0x00008040 }, /* GL_LUMINANCE8 */
-+   { 13827, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8 */
-+   { 13848, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8_EXT */
-+   { 13873, 0x00008040 }, /* GL_LUMINANCE8_EXT */
-+   { 13891, 0x0000190A }, /* GL_LUMINANCE_ALPHA */
-+   { 13910, 0x00000D90 }, /* GL_MAP1_COLOR_4 */
-+   { 13926, 0x00000DD0 }, /* GL_MAP1_GRID_DOMAIN */
-+   { 13946, 0x00000DD1 }, /* GL_MAP1_GRID_SEGMENTS */
-+   { 13968, 0x00000D91 }, /* GL_MAP1_INDEX */
-+   { 13982, 0x00000D92 }, /* GL_MAP1_NORMAL */
-+   { 13997, 0x00000D93 }, /* GL_MAP1_TEXTURE_COORD_1 */
-+   { 14021, 0x00000D94 }, /* GL_MAP1_TEXTURE_COORD_2 */
-+   { 14045, 0x00000D95 }, /* GL_MAP1_TEXTURE_COORD_3 */
-+   { 14069, 0x00000D96 }, /* GL_MAP1_TEXTURE_COORD_4 */
-+   { 14093, 0x00000D97 }, /* GL_MAP1_VERTEX_3 */
-+   { 14110, 0x00000D98 }, /* GL_MAP1_VERTEX_4 */
-+   { 14127, 0x00008660 }, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
-+   { 14155, 0x0000866A }, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
-+   { 14184, 0x0000866B }, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
-+   { 14213, 0x0000866C }, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
-+   { 14242, 0x0000866D }, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
-+   { 14271, 0x0000866E }, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
-+   { 14300, 0x0000866F }, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
-+   { 14329, 0x00008661 }, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
-+   { 14357, 0x00008662 }, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
-+   { 14385, 0x00008663 }, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
-+   { 14413, 0x00008664 }, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
-+   { 14441, 0x00008665 }, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
-+   { 14469, 0x00008666 }, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
-+   { 14497, 0x00008667 }, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
-+   { 14525, 0x00008668 }, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
-+   { 14553, 0x00008669 }, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
-+   { 14581, 0x00000DB0 }, /* GL_MAP2_COLOR_4 */
-+   { 14597, 0x00000DD2 }, /* GL_MAP2_GRID_DOMAIN */
-+   { 14617, 0x00000DD3 }, /* GL_MAP2_GRID_SEGMENTS */
-+   { 14639, 0x00000DB1 }, /* GL_MAP2_INDEX */
-+   { 14653, 0x00000DB2 }, /* GL_MAP2_NORMAL */
-+   { 14668, 0x00000DB3 }, /* GL_MAP2_TEXTURE_COORD_1 */
-+   { 14692, 0x00000DB4 }, /* GL_MAP2_TEXTURE_COORD_2 */
-+   { 14716, 0x00000DB5 }, /* GL_MAP2_TEXTURE_COORD_3 */
-+   { 14740, 0x00000DB6 }, /* GL_MAP2_TEXTURE_COORD_4 */
-+   { 14764, 0x00000DB7 }, /* GL_MAP2_VERTEX_3 */
-+   { 14781, 0x00000DB8 }, /* GL_MAP2_VERTEX_4 */
-+   { 14798, 0x00008670 }, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
-+   { 14826, 0x0000867A }, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
-+   { 14855, 0x0000867B }, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
-+   { 14884, 0x0000867C }, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
-+   { 14913, 0x0000867D }, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
-+   { 14942, 0x0000867E }, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
-+   { 14971, 0x0000867F }, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
-+   { 15000, 0x00008671 }, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
-+   { 15028, 0x00008672 }, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
-+   { 15056, 0x00008673 }, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
-+   { 15084, 0x00008674 }, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
-+   { 15112, 0x00008675 }, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
-+   { 15140, 0x00008676 }, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
-+   { 15168, 0x00008677 }, /* GL_MAP2_VERTEX_ATTRIB7_4_NV */
-+   { 15196, 0x00008678 }, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
-+   { 15224, 0x00008679 }, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
-+   { 15252, 0x00000D10 }, /* GL_MAP_COLOR */
-+   { 15265, 0x00000D11 }, /* GL_MAP_STENCIL */
-+   { 15280, 0x000088C0 }, /* GL_MATRIX0_ARB */
-+   { 15295, 0x00008630 }, /* GL_MATRIX0_NV */
-+   { 15309, 0x000088CA }, /* GL_MATRIX10_ARB */
-+   { 15325, 0x000088CB }, /* GL_MATRIX11_ARB */
-+   { 15341, 0x000088CC }, /* GL_MATRIX12_ARB */
-+   { 15357, 0x000088CD }, /* GL_MATRIX13_ARB */
-+   { 15373, 0x000088CE }, /* GL_MATRIX14_ARB */
-+   { 15389, 0x000088CF }, /* GL_MATRIX15_ARB */
-+   { 15405, 0x000088D0 }, /* GL_MATRIX16_ARB */
-+   { 15421, 0x000088D1 }, /* GL_MATRIX17_ARB */
-+   { 15437, 0x000088D2 }, /* GL_MATRIX18_ARB */
-+   { 15453, 0x000088D3 }, /* GL_MATRIX19_ARB */
-+   { 15469, 0x000088C1 }, /* GL_MATRIX1_ARB */
-+   { 15484, 0x00008631 }, /* GL_MATRIX1_NV */
-+   { 15498, 0x000088D4 }, /* GL_MATRIX20_ARB */
-+   { 15514, 0x000088D5 }, /* GL_MATRIX21_ARB */
-+   { 15530, 0x000088D6 }, /* GL_MATRIX22_ARB */
-+   { 15546, 0x000088D7 }, /* GL_MATRIX23_ARB */
-+   { 15562, 0x000088D8 }, /* GL_MATRIX24_ARB */
-+   { 15578, 0x000088D9 }, /* GL_MATRIX25_ARB */
-+   { 15594, 0x000088DA }, /* GL_MATRIX26_ARB */
-+   { 15610, 0x000088DB }, /* GL_MATRIX27_ARB */
-+   { 15626, 0x000088DC }, /* GL_MATRIX28_ARB */
-+   { 15642, 0x000088DD }, /* GL_MATRIX29_ARB */
-+   { 15658, 0x000088C2 }, /* GL_MATRIX2_ARB */
-+   { 15673, 0x00008632 }, /* GL_MATRIX2_NV */
-+   { 15687, 0x000088DE }, /* GL_MATRIX30_ARB */
-+   { 15703, 0x000088DF }, /* GL_MATRIX31_ARB */
-+   { 15719, 0x000088C3 }, /* GL_MATRIX3_ARB */
-+   { 15734, 0x00008633 }, /* GL_MATRIX3_NV */
-+   { 15748, 0x000088C4 }, /* GL_MATRIX4_ARB */
-+   { 15763, 0x00008634 }, /* GL_MATRIX4_NV */
-+   { 15777, 0x000088C5 }, /* GL_MATRIX5_ARB */
-+   { 15792, 0x00008635 }, /* GL_MATRIX5_NV */
-+   { 15806, 0x000088C6 }, /* GL_MATRIX6_ARB */
-+   { 15821, 0x00008636 }, /* GL_MATRIX6_NV */
-+   { 15835, 0x000088C7 }, /* GL_MATRIX7_ARB */
-+   { 15850, 0x00008637 }, /* GL_MATRIX7_NV */
-+   { 15864, 0x000088C8 }, /* GL_MATRIX8_ARB */
-+   { 15879, 0x000088C9 }, /* GL_MATRIX9_ARB */
-+   { 15894, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_ARB */
-+   { 15920, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
-+   { 15954, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
-+   { 15985, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
-+   { 16018, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
-+   { 16049, 0x00000BA0 }, /* GL_MATRIX_MODE */
-+   { 16064, 0x00008840 }, /* GL_MATRIX_PALETTE_ARB */
-+   { 16086, 0x00008008 }, /* GL_MAX */
-+   { 16093, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE */
-+   { 16116, 0x000088FF }, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
-+   { 16148, 0x00000D35 }, /* GL_MAX_ATTRIB_STACK_DEPTH */
-+   { 16174, 0x00000D3B }, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
-+   { 16207, 0x00008177 }, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
-+   { 16233, 0x00008178 }, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-+   { 16267, 0x00000D32 }, /* GL_MAX_CLIP_PLANES */
-+   { 16286, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
-+   { 16315, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
-+   { 16347, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI */
-+   { 16383, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
-+   { 16419, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB */
-+   { 16459, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT */
-+   { 16485, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT_EXT */
-+   { 16515, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH */
-+   { 16540, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH_EXT */
-+   { 16569, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
-+   { 16598, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB */
-+   { 16631, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS */
-+   { 16651, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ARB */
-+   { 16675, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ATI */
-+   { 16699, 0x000080E9 }, /* GL_MAX_ELEMENTS_INDICES */
-+   { 16723, 0x000080E8 }, /* GL_MAX_ELEMENTS_VERTICES */
-+   { 16748, 0x00000D30 }, /* GL_MAX_EVAL_ORDER */
-+   { 16766, 0x00008008 }, /* GL_MAX_EXT */
-+   { 16777, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
-+   { 16812, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB */
-+   { 16851, 0x00000D31 }, /* GL_MAX_LIGHTS */
-+   { 16865, 0x00000B31 }, /* GL_MAX_LIST_NESTING */
-+   { 16885, 0x00008841 }, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
-+   { 16923, 0x00000D36 }, /* GL_MAX_MODELVIEW_STACK_DEPTH */
-+   { 16952, 0x00000D37 }, /* GL_MAX_NAME_STACK_DEPTH */
-+   { 16976, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_ARB */
-+   { 17004, 0x00000D34 }, /* GL_MAX_PIXEL_MAP_TABLE */
-+   { 17027, 0x000088B1 }, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
-+   { 17064, 0x0000880B }, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
-+   { 17100, 0x000088AD }, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
-+   { 17127, 0x000088F5 }, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
-+   { 17156, 0x000088B5 }, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
-+   { 17190, 0x000088F4 }, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */
-+   { 17226, 0x000088F6 }, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
-+   { 17253, 0x000088A1 }, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
-+   { 17285, 0x000088B4 }, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
-+   { 17321, 0x000088F8 }, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
-+   { 17350, 0x000088F7 }, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
-+   { 17379, 0x0000862F }, /* GL_MAX_PROGRAM_MATRICES_ARB */
-+   { 17407, 0x0000862E }, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
-+   { 17445, 0x000088B3 }, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-+   { 17489, 0x0000880E }, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-+   { 17532, 0x000088AF }, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
-+   { 17566, 0x000088A3 }, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-+   { 17605, 0x000088AB }, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
-+   { 17642, 0x000088A7 }, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
-+   { 17680, 0x00008810 }, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-+   { 17723, 0x0000880F }, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-+   { 17766, 0x000088A9 }, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
-+   { 17796, 0x000088A5 }, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
-+   { 17827, 0x0000880D }, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
-+   { 17863, 0x0000880C }, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
-+   { 17899, 0x00000D38 }, /* GL_MAX_PROJECTION_STACK_DEPTH */
-+   { 17929, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
-+   { 17963, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_NV */
-+   { 17996, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
-+   { 18025, 0x00008504 }, /* GL_MAX_SHININESS_NV */
-+   { 18045, 0x00008505 }, /* GL_MAX_SPOT_EXPONENT_NV */
-+   { 18069, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS */
-+   { 18091, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS_ARB */
-+   { 18117, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS */
-+   { 18144, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS_ARB */
-+   { 18175, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS */
-+   { 18199, 0x000084FF }, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
-+   { 18233, 0x00000D33 }, /* GL_MAX_TEXTURE_SIZE */
-+   { 18253, 0x00000D39 }, /* GL_MAX_TEXTURE_STACK_DEPTH */
-+   { 18280, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS */
-+   { 18301, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS_ARB */
-+   { 18326, 0x0000862F }, /* GL_MAX_TRACK_MATRICES_NV */
-+   { 18351, 0x0000862E }, /* GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */
-+   { 18386, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS */
-+   { 18408, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS_ARB */
-+   { 18434, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS */
-+   { 18456, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS_ARB */
-+   { 18482, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
-+   { 18516, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */
-+   { 18554, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
-+   { 18587, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB */
-+   { 18624, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_ARB */
-+   { 18648, 0x00000D3A }, /* GL_MAX_VIEWPORT_DIMS */
-+   { 18669, 0x00008007 }, /* GL_MIN */
-+   { 18676, 0x0000802E }, /* GL_MINMAX */
-+   { 18686, 0x0000802E }, /* GL_MINMAX_EXT */
-+   { 18700, 0x0000802F }, /* GL_MINMAX_FORMAT */
-+   { 18717, 0x0000802F }, /* GL_MINMAX_FORMAT_EXT */
-+   { 18738, 0x00008030 }, /* GL_MINMAX_SINK */
-+   { 18753, 0x00008030 }, /* GL_MINMAX_SINK_EXT */
-+   { 18772, 0x00008007 }, /* GL_MIN_EXT */
-+   { 18783, 0x00008370 }, /* GL_MIRRORED_REPEAT */
-+   { 18802, 0x00008370 }, /* GL_MIRRORED_REPEAT_ARB */
-+   { 18825, 0x00008370 }, /* GL_MIRRORED_REPEAT_IBM */
-+   { 18848, 0x00008742 }, /* GL_MIRROR_CLAMP_ATI */
-+   { 18868, 0x00008742 }, /* GL_MIRROR_CLAMP_EXT */
-+   { 18888, 0x00008912 }, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
-+   { 18918, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_ATI */
-+   { 18946, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
-+   { 18974, 0x00001700 }, /* GL_MODELVIEW */
-+   { 18987, 0x00001700 }, /* GL_MODELVIEW0_ARB */
-+   { 19005, 0x0000872A }, /* GL_MODELVIEW10_ARB */
-+   { 19024, 0x0000872B }, /* GL_MODELVIEW11_ARB */
-+   { 19043, 0x0000872C }, /* GL_MODELVIEW12_ARB */
-+   { 19062, 0x0000872D }, /* GL_MODELVIEW13_ARB */
-+   { 19081, 0x0000872E }, /* GL_MODELVIEW14_ARB */
-+   { 19100, 0x0000872F }, /* GL_MODELVIEW15_ARB */
-+   { 19119, 0x00008730 }, /* GL_MODELVIEW16_ARB */
-+   { 19138, 0x00008731 }, /* GL_MODELVIEW17_ARB */
-+   { 19157, 0x00008732 }, /* GL_MODELVIEW18_ARB */
-+   { 19176, 0x00008733 }, /* GL_MODELVIEW19_ARB */
-+   { 19195, 0x0000850A }, /* GL_MODELVIEW1_ARB */
-+   { 19213, 0x00008734 }, /* GL_MODELVIEW20_ARB */
-+   { 19232, 0x00008735 }, /* GL_MODELVIEW21_ARB */
-+   { 19251, 0x00008736 }, /* GL_MODELVIEW22_ARB */
-+   { 19270, 0x00008737 }, /* GL_MODELVIEW23_ARB */
-+   { 19289, 0x00008738 }, /* GL_MODELVIEW24_ARB */
-+   { 19308, 0x00008739 }, /* GL_MODELVIEW25_ARB */
-+   { 19327, 0x0000873A }, /* GL_MODELVIEW26_ARB */
-+   { 19346, 0x0000873B }, /* GL_MODELVIEW27_ARB */
-+   { 19365, 0x0000873C }, /* GL_MODELVIEW28_ARB */
-+   { 19384, 0x0000873D }, /* GL_MODELVIEW29_ARB */
-+   { 19403, 0x00008722 }, /* GL_MODELVIEW2_ARB */
-+   { 19421, 0x0000873E }, /* GL_MODELVIEW30_ARB */
-+   { 19440, 0x0000873F }, /* GL_MODELVIEW31_ARB */
-+   { 19459, 0x00008723 }, /* GL_MODELVIEW3_ARB */
-+   { 19477, 0x00008724 }, /* GL_MODELVIEW4_ARB */
-+   { 19495, 0x00008725 }, /* GL_MODELVIEW5_ARB */
-+   { 19513, 0x00008726 }, /* GL_MODELVIEW6_ARB */
-+   { 19531, 0x00008727 }, /* GL_MODELVIEW7_ARB */
-+   { 19549, 0x00008728 }, /* GL_MODELVIEW8_ARB */
-+   { 19567, 0x00008729 }, /* GL_MODELVIEW9_ARB */
-+   { 19585, 0x00000BA6 }, /* GL_MODELVIEW_MATRIX */
-+   { 19605, 0x00008629 }, /* GL_MODELVIEW_PROJECTION_NV */
-+   { 19632, 0x00000BA3 }, /* GL_MODELVIEW_STACK_DEPTH */
-+   { 19657, 0x00002100 }, /* GL_MODULATE */
-+   { 19669, 0x00008744 }, /* GL_MODULATE_ADD_ATI */
-+   { 19689, 0x00008745 }, /* GL_MODULATE_SIGNED_ADD_ATI */
-+   { 19716, 0x00008746 }, /* GL_MODULATE_SUBTRACT_ATI */
-+   { 19741, 0x00000103 }, /* GL_MULT */
-+   { 19749, 0x0000809D }, /* GL_MULTISAMPLE */
-+   { 19764, 0x000086B2 }, /* GL_MULTISAMPLE_3DFX */
-+   { 19784, 0x0000809D }, /* GL_MULTISAMPLE_ARB */
-+   { 19803, 0x20000000 }, /* GL_MULTISAMPLE_BIT */
-+   { 19822, 0x20000000 }, /* GL_MULTISAMPLE_BIT_3DFX */
-+   { 19846, 0x20000000 }, /* GL_MULTISAMPLE_BIT_ARB */
-+   { 19869, 0x00008534 }, /* GL_MULTISAMPLE_FILTER_HINT_NV */
-+   { 19899, 0x00002A25 }, /* GL_N3F_V3F */
-+   { 19910, 0x00000D70 }, /* GL_NAME_STACK_DEPTH */
-+   { 19930, 0x0000150E }, /* GL_NAND */
-+   { 19938, 0x00002600 }, /* GL_NEAREST */
-+   { 19949, 0x0000844E }, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
-+   { 19980, 0x0000844D }, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
-+   { 20012, 0x00002702 }, /* GL_NEAREST_MIPMAP_LINEAR */
-+   { 20037, 0x00002700 }, /* GL_NEAREST_MIPMAP_NEAREST */
-+   { 20063, 0x00000200 }, /* GL_NEVER */
-+   { 20072, 0x00001102 }, /* GL_NICEST */
-+   { 20082, 0x00000000 }, /* GL_NONE */
-+   { 20090, 0x00001505 }, /* GL_NOOP */
-+   { 20098, 0x00001508 }, /* GL_NOR */
-+   { 20105, 0x00000BA1 }, /* GL_NORMALIZE */
-+   { 20118, 0x00008075 }, /* GL_NORMAL_ARRAY */
-+   { 20134, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
-+   { 20165, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING_ARB */
-+   { 20200, 0x0000808F }, /* GL_NORMAL_ARRAY_POINTER */
-+   { 20224, 0x0000807F }, /* GL_NORMAL_ARRAY_STRIDE */
-+   { 20247, 0x0000807E }, /* GL_NORMAL_ARRAY_TYPE */
-+   { 20268, 0x00008511 }, /* GL_NORMAL_MAP */
-+   { 20282, 0x00008511 }, /* GL_NORMAL_MAP_ARB */
-+   { 20300, 0x00008511 }, /* GL_NORMAL_MAP_NV */
-+   { 20317, 0x00000205 }, /* GL_NOTEQUAL */
-+   { 20329, 0x00000000 }, /* GL_NO_ERROR */
-+   { 20341, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
-+   { 20375, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB */
-+   { 20413, 0x00008B89 }, /* GL_OBJECT_ACTIVE_ATTRIBUTES_ARB */
-+   { 20445, 0x00008B8A }, /* GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB */
-+   { 20487, 0x00008B86 }, /* GL_OBJECT_ACTIVE_UNIFORMS_ARB */
-+   { 20517, 0x00008B87 }, /* GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB */
-+   { 20557, 0x00008B85 }, /* GL_OBJECT_ATTACHED_OBJECTS_ARB */
-+   { 20588, 0x00008B81 }, /* GL_OBJECT_COMPILE_STATUS_ARB */
-+   { 20617, 0x00008B80 }, /* GL_OBJECT_DELETE_STATUS_ARB */
-+   { 20645, 0x00008B84 }, /* GL_OBJECT_INFO_LOG_LENGTH_ARB */
-+   { 20675, 0x00002401 }, /* GL_OBJECT_LINEAR */
-+   { 20692, 0x00008B82 }, /* GL_OBJECT_LINK_STATUS_ARB */
-+   { 20718, 0x00002501 }, /* GL_OBJECT_PLANE */
-+   { 20734, 0x00008B88 }, /* GL_OBJECT_SHADER_SOURCE_LENGTH_ARB */
-+   { 20769, 0x00008B4F }, /* GL_OBJECT_SUBTYPE_ARB */
-+   { 20791, 0x00008B4E }, /* GL_OBJECT_TYPE_ARB */
-+   { 20810, 0x00008B83 }, /* GL_OBJECT_VALIDATE_STATUS_ARB */
-+   { 20840, 0x00008165 }, /* GL_OCCLUSION_TEST_HP */
-+   { 20861, 0x00008166 }, /* GL_OCCLUSION_TEST_RESULT_HP */
-+   { 20889, 0x00000001 }, /* GL_ONE */
-+   { 20896, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA */
-+   { 20924, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA_EXT */
-+   { 20956, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR */
-+   { 20984, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR_EXT */
-+   { 21016, 0x00000305 }, /* GL_ONE_MINUS_DST_ALPHA */
-+   { 21039, 0x00000307 }, /* GL_ONE_MINUS_DST_COLOR */
-+   { 21062, 0x00000303 }, /* GL_ONE_MINUS_SRC_ALPHA */
-+   { 21085, 0x00000301 }, /* GL_ONE_MINUS_SRC_COLOR */
-+   { 21108, 0x00008598 }, /* GL_OPERAND0_ALPHA */
-+   { 21126, 0x00008598 }, /* GL_OPERAND0_ALPHA_ARB */
-+   { 21148, 0x00008598 }, /* GL_OPERAND0_ALPHA_EXT */
-+   { 21170, 0x00008590 }, /* GL_OPERAND0_RGB */
-+   { 21186, 0x00008590 }, /* GL_OPERAND0_RGB_ARB */
-+   { 21206, 0x00008590 }, /* GL_OPERAND0_RGB_EXT */
-+   { 21226, 0x00008599 }, /* GL_OPERAND1_ALPHA */
-+   { 21244, 0x00008599 }, /* GL_OPERAND1_ALPHA_ARB */
-+   { 21266, 0x00008599 }, /* GL_OPERAND1_ALPHA_EXT */
-+   { 21288, 0x00008591 }, /* GL_OPERAND1_RGB */
-+   { 21304, 0x00008591 }, /* GL_OPERAND1_RGB_ARB */
-+   { 21324, 0x00008591 }, /* GL_OPERAND1_RGB_EXT */
-+   { 21344, 0x0000859A }, /* GL_OPERAND2_ALPHA */
-+   { 21362, 0x0000859A }, /* GL_OPERAND2_ALPHA_ARB */
-+   { 21384, 0x0000859A }, /* GL_OPERAND2_ALPHA_EXT */
-+   { 21406, 0x00008592 }, /* GL_OPERAND2_RGB */
-+   { 21422, 0x00008592 }, /* GL_OPERAND2_RGB_ARB */
-+   { 21442, 0x00008592 }, /* GL_OPERAND2_RGB_EXT */
-+   { 21462, 0x0000859B }, /* GL_OPERAND3_ALPHA_NV */
-+   { 21483, 0x00008593 }, /* GL_OPERAND3_RGB_NV */
-+   { 21502, 0x00001507 }, /* GL_OR */
-+   { 21508, 0x00000A01 }, /* GL_ORDER */
-+   { 21517, 0x0000150D }, /* GL_OR_INVERTED */
-+   { 21532, 0x0000150B }, /* GL_OR_REVERSE */
-+   { 21546, 0x00000505 }, /* GL_OUT_OF_MEMORY */
-+   { 21563, 0x00000D05 }, /* GL_PACK_ALIGNMENT */
-+   { 21581, 0x0000806C }, /* GL_PACK_IMAGE_HEIGHT */
-+   { 21602, 0x00008758 }, /* GL_PACK_INVERT_MESA */
-+   { 21622, 0x00000D01 }, /* GL_PACK_LSB_FIRST */
-+   { 21640, 0x00000D02 }, /* GL_PACK_ROW_LENGTH */
-+   { 21659, 0x0000806B }, /* GL_PACK_SKIP_IMAGES */
-+   { 21679, 0x00000D04 }, /* GL_PACK_SKIP_PIXELS */
-+   { 21699, 0x00000D03 }, /* GL_PACK_SKIP_ROWS */
-+   { 21717, 0x00000D00 }, /* GL_PACK_SWAP_BYTES */
-+   { 21736, 0x00008B92 }, /* GL_PALETTE4_R5_G6_B5_OES */
-+   { 21761, 0x00008B94 }, /* GL_PALETTE4_RGB5_A1_OES */
-+   { 21785, 0x00008B90 }, /* GL_PALETTE4_RGB8_OES */
-+   { 21806, 0x00008B93 }, /* GL_PALETTE4_RGBA4_OES */
-+   { 21828, 0x00008B91 }, /* GL_PALETTE4_RGBA8_OES */
-+   { 21850, 0x00008B97 }, /* GL_PALETTE8_R5_G6_B5_OES */
-+   { 21875, 0x00008B99 }, /* GL_PALETTE8_RGB5_A1_OES */
-+   { 21899, 0x00008B95 }, /* GL_PALETTE8_RGB8_OES */
-+   { 21920, 0x00008B98 }, /* GL_PALETTE8_RGBA4_OES */
-+   { 21942, 0x00008B96 }, /* GL_PALETTE8_RGBA8_OES */
-+   { 21964, 0x00000700 }, /* GL_PASS_THROUGH_TOKEN */
-+   { 21986, 0x00000C50 }, /* GL_PERSPECTIVE_CORRECTION_HINT */
-+   { 22017, 0x00000C79 }, /* GL_PIXEL_MAP_A_TO_A */
-+   { 22037, 0x00000CB9 }, /* GL_PIXEL_MAP_A_TO_A_SIZE */
-+   { 22062, 0x00000C78 }, /* GL_PIXEL_MAP_B_TO_B */
-+   { 22082, 0x00000CB8 }, /* GL_PIXEL_MAP_B_TO_B_SIZE */
-+   { 22107, 0x00000C77 }, /* GL_PIXEL_MAP_G_TO_G */
-+   { 22127, 0x00000CB7 }, /* GL_PIXEL_MAP_G_TO_G_SIZE */
-+   { 22152, 0x00000C75 }, /* GL_PIXEL_MAP_I_TO_A */
-+   { 22172, 0x00000CB5 }, /* GL_PIXEL_MAP_I_TO_A_SIZE */
-+   { 22197, 0x00000C74 }, /* GL_PIXEL_MAP_I_TO_B */
-+   { 22217, 0x00000CB4 }, /* GL_PIXEL_MAP_I_TO_B_SIZE */
-+   { 22242, 0x00000C73 }, /* GL_PIXEL_MAP_I_TO_G */
-+   { 22262, 0x00000CB3 }, /* GL_PIXEL_MAP_I_TO_G_SIZE */
-+   { 22287, 0x00000C70 }, /* GL_PIXEL_MAP_I_TO_I */
-+   { 22307, 0x00000CB0 }, /* GL_PIXEL_MAP_I_TO_I_SIZE */
-+   { 22332, 0x00000C72 }, /* GL_PIXEL_MAP_I_TO_R */
-+   { 22352, 0x00000CB2 }, /* GL_PIXEL_MAP_I_TO_R_SIZE */
-+   { 22377, 0x00000C76 }, /* GL_PIXEL_MAP_R_TO_R */
-+   { 22397, 0x00000CB6 }, /* GL_PIXEL_MAP_R_TO_R_SIZE */
-+   { 22422, 0x00000C71 }, /* GL_PIXEL_MAP_S_TO_S */
-+   { 22442, 0x00000CB1 }, /* GL_PIXEL_MAP_S_TO_S_SIZE */
-+   { 22467, 0x00000020 }, /* GL_PIXEL_MODE_BIT */
-+   { 22485, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING_EXT */
-+   { 22518, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER_EXT */
-+   { 22543, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING_EXT */
-+   { 22578, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER_EXT */
-+   { 22605, 0x00001B00 }, /* GL_POINT */
-+   { 22614, 0x00000000 }, /* GL_POINTS */
-+   { 22624, 0x00000002 }, /* GL_POINT_BIT */
-+   { 22637, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION */
-+   { 22667, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_ARB */
-+   { 22701, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_EXT */
-+   { 22735, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_SGIS */
-+   { 22770, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE */
-+   { 22799, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_ARB */
-+   { 22832, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_EXT */
-+   { 22865, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_SGIS */
-+   { 22899, 0x00000B11 }, /* GL_POINT_SIZE */
-+   { 22913, 0x00000B13 }, /* GL_POINT_SIZE_GRANULARITY */
-+   { 22939, 0x00008127 }, /* GL_POINT_SIZE_MAX */
-+   { 22957, 0x00008127 }, /* GL_POINT_SIZE_MAX_ARB */
-+   { 22979, 0x00008127 }, /* GL_POINT_SIZE_MAX_EXT */
-+   { 23001, 0x00008127 }, /* GL_POINT_SIZE_MAX_SGIS */
-+   { 23024, 0x00008126 }, /* GL_POINT_SIZE_MIN */
-+   { 23042, 0x00008126 }, /* GL_POINT_SIZE_MIN_ARB */
-+   { 23064, 0x00008126 }, /* GL_POINT_SIZE_MIN_EXT */
-+   { 23086, 0x00008126 }, /* GL_POINT_SIZE_MIN_SGIS */
-+   { 23109, 0x00000B12 }, /* GL_POINT_SIZE_RANGE */
-+   { 23129, 0x00000B10 }, /* GL_POINT_SMOOTH */
-+   { 23145, 0x00000C51 }, /* GL_POINT_SMOOTH_HINT */
-+   { 23166, 0x00008861 }, /* GL_POINT_SPRITE */
-+   { 23182, 0x00008861 }, /* GL_POINT_SPRITE_ARB */
-+   { 23202, 0x00008CA0 }, /* GL_POINT_SPRITE_COORD_ORIGIN */
-+   { 23231, 0x00008861 }, /* GL_POINT_SPRITE_NV */
-+   { 23250, 0x00008863 }, /* GL_POINT_SPRITE_R_MODE_NV */
-+   { 23276, 0x00000701 }, /* GL_POINT_TOKEN */
-+   { 23291, 0x00000009 }, /* GL_POLYGON */
-+   { 23302, 0x00000008 }, /* GL_POLYGON_BIT */
-+   { 23317, 0x00000B40 }, /* GL_POLYGON_MODE */
-+   { 23333, 0x00008039 }, /* GL_POLYGON_OFFSET_BIAS */
-+   { 23356, 0x00008038 }, /* GL_POLYGON_OFFSET_FACTOR */
-+   { 23381, 0x00008037 }, /* GL_POLYGON_OFFSET_FILL */
-+   { 23404, 0x00002A02 }, /* GL_POLYGON_OFFSET_LINE */
-+   { 23427, 0x00002A01 }, /* GL_POLYGON_OFFSET_POINT */
-+   { 23451, 0x00002A00 }, /* GL_POLYGON_OFFSET_UNITS */
-+   { 23475, 0x00000B41 }, /* GL_POLYGON_SMOOTH */
-+   { 23493, 0x00000C53 }, /* GL_POLYGON_SMOOTH_HINT */
-+   { 23516, 0x00000B42 }, /* GL_POLYGON_STIPPLE */
-+   { 23535, 0x00000010 }, /* GL_POLYGON_STIPPLE_BIT */
-+   { 23558, 0x00000703 }, /* GL_POLYGON_TOKEN */
-+   { 23575, 0x00001203 }, /* GL_POSITION */
-+   { 23587, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
-+   { 23619, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI */
-+   { 23655, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
-+   { 23688, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI */
-+   { 23725, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
-+   { 23756, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI */
-+   { 23791, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
-+   { 23823, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI */
-+   { 23859, 0x000080D2 }, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
-+   { 23892, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
-+   { 23924, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI */
-+   { 23960, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
-+   { 23993, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI */
-+   { 24030, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS */
-+   { 24060, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS_SGI */
-+   { 24094, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE */
-+   { 24125, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE_SGI */
-+   { 24160, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
-+   { 24191, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS_EXT */
-+   { 24226, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
-+   { 24258, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE_EXT */
-+   { 24294, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS */
-+   { 24324, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS_EXT */
-+   { 24358, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE */
-+   { 24389, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE_EXT */
-+   { 24424, 0x000080D1 }, /* GL_POST_CONVOLUTION_COLOR_TABLE */
-+   { 24456, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS */
-+   { 24487, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS_EXT */
-+   { 24522, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE */
-+   { 24554, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE_EXT */
-+   { 24590, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS */
-+   { 24619, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS_EXT */
-+   { 24652, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE */
-+   { 24682, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE_EXT */
-+   { 24716, 0x0000817B }, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
-+   { 24755, 0x00008179 }, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
-+   { 24788, 0x0000817C }, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
-+   { 24828, 0x0000817A }, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
-+   { 24862, 0x00008578 }, /* GL_PREVIOUS */
-+   { 24874, 0x00008578 }, /* GL_PREVIOUS_ARB */
-+   { 24890, 0x00008578 }, /* GL_PREVIOUS_EXT */
-+   { 24906, 0x00008577 }, /* GL_PRIMARY_COLOR */
-+   { 24923, 0x00008577 }, /* GL_PRIMARY_COLOR_ARB */
-+   { 24944, 0x00008577 }, /* GL_PRIMARY_COLOR_EXT */
-+   { 24965, 0x000088B0 }, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
-+   { 24998, 0x00008805 }, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
-+   { 25030, 0x000088AC }, /* GL_PROGRAM_ATTRIBS_ARB */
-+   { 25053, 0x00008677 }, /* GL_PROGRAM_BINDING_ARB */
-+   { 25076, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_ARB */
-+   { 25106, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_NV */
-+   { 25135, 0x00008874 }, /* GL_PROGRAM_ERROR_STRING_ARB */
-+   { 25163, 0x00008876 }, /* GL_PROGRAM_FORMAT_ARB */
-+   { 25185, 0x00008875 }, /* GL_PROGRAM_FORMAT_ASCII_ARB */
-+   { 25213, 0x000088A0 }, /* GL_PROGRAM_INSTRUCTIONS_ARB */
-+   { 25241, 0x00008627 }, /* GL_PROGRAM_LENGTH_ARB */
-+   { 25263, 0x00008627 }, /* GL_PROGRAM_LENGTH_NV */
-+   { 25284, 0x000088B2 }, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-+   { 25324, 0x00008808 }, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-+   { 25363, 0x000088AE }, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
-+   { 25393, 0x000088A2 }, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-+   { 25428, 0x000088AA }, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
-+   { 25461, 0x000088A6 }, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
-+   { 25495, 0x0000880A }, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-+   { 25534, 0x00008809 }, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-+   { 25573, 0x00008B40 }, /* GL_PROGRAM_OBJECT_ARB */
-+   { 25595, 0x000088A8 }, /* GL_PROGRAM_PARAMETERS_ARB */
-+   { 25621, 0x00008644 }, /* GL_PROGRAM_PARAMETER_NV */
-+   { 25645, 0x00008647 }, /* GL_PROGRAM_RESIDENT_NV */
-+   { 25668, 0x00008628 }, /* GL_PROGRAM_STRING_ARB */
-+   { 25690, 0x00008628 }, /* GL_PROGRAM_STRING_NV */
-+   { 25711, 0x00008646 }, /* GL_PROGRAM_TARGET_NV */
-+   { 25732, 0x000088A4 }, /* GL_PROGRAM_TEMPORARIES_ARB */
-+   { 25759, 0x00008807 }, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
-+   { 25791, 0x00008806 }, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
-+   { 25823, 0x000088B6 }, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
-+   { 25858, 0x00001701 }, /* GL_PROJECTION */
-+   { 25872, 0x00000BA7 }, /* GL_PROJECTION_MATRIX */
-+   { 25893, 0x00000BA4 }, /* GL_PROJECTION_STACK_DEPTH */
-+   { 25919, 0x000080D3 }, /* GL_PROXY_COLOR_TABLE */
-+   { 25940, 0x00008025 }, /* GL_PROXY_HISTOGRAM */
-+   { 25959, 0x00008025 }, /* GL_PROXY_HISTOGRAM_EXT */
-+   { 25982, 0x000080D5 }, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
-+   { 26021, 0x000080D4 }, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
-+   { 26059, 0x00008063 }, /* GL_PROXY_TEXTURE_1D */
-+   { 26079, 0x00008C19 }, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
-+   { 26109, 0x00008063 }, /* GL_PROXY_TEXTURE_1D_EXT */
-+   { 26133, 0x00008064 }, /* GL_PROXY_TEXTURE_2D */
-+   { 26153, 0x00008C1B }, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
-+   { 26183, 0x00008064 }, /* GL_PROXY_TEXTURE_2D_EXT */
-+   { 26207, 0x00008070 }, /* GL_PROXY_TEXTURE_3D */
-+   { 26227, 0x000080BD }, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
-+   { 26260, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP */
-+   { 26286, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP_ARB */
-+   { 26316, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
-+   { 26347, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_NV */
-+   { 26377, 0x00002003 }, /* GL_Q */
-+   { 26382, 0x00001209 }, /* GL_QUADRATIC_ATTENUATION */
-+   { 26407, 0x00000007 }, /* GL_QUADS */
-+   { 26416, 0x00008614 }, /* GL_QUAD_MESH_SUN */
-+   { 26433, 0x00000008 }, /* GL_QUAD_STRIP */
-+   { 26447, 0x00008864 }, /* GL_QUERY_COUNTER_BITS */
-+   { 26469, 0x00008864 }, /* GL_QUERY_COUNTER_BITS_ARB */
-+   { 26495, 0x00008866 }, /* GL_QUERY_RESULT */
-+   { 26511, 0x00008866 }, /* GL_QUERY_RESULT_ARB */
-+   { 26531, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE */
-+   { 26557, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE_ARB */
-+   { 26587, 0x00002002 }, /* GL_R */
-+   { 26592, 0x00002A10 }, /* GL_R3_G3_B2 */
-+   { 26604, 0x00019262 }, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
-+   { 26637, 0x00000C02 }, /* GL_READ_BUFFER */
-+   { 26652, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING_EXT */
-+   { 26684, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER_EXT */
-+   { 26708, 0x000088B8 }, /* GL_READ_ONLY */
-+   { 26721, 0x000088B8 }, /* GL_READ_ONLY_ARB */
-+   { 26738, 0x000088BA }, /* GL_READ_WRITE */
-+   { 26752, 0x000088BA }, /* GL_READ_WRITE_ARB */
-+   { 26770, 0x00001903 }, /* GL_RED */
-+   { 26777, 0x00008016 }, /* GL_REDUCE */
-+   { 26787, 0x00008016 }, /* GL_REDUCE_EXT */
-+   { 26801, 0x00000D15 }, /* GL_RED_BIAS */
-+   { 26813, 0x00000D52 }, /* GL_RED_BITS */
-+   { 26825, 0x00000D14 }, /* GL_RED_SCALE */
-+   { 26838, 0x00008512 }, /* GL_REFLECTION_MAP */
-+   { 26856, 0x00008512 }, /* GL_REFLECTION_MAP_ARB */
-+   { 26878, 0x00008512 }, /* GL_REFLECTION_MAP_NV */
-+   { 26899, 0x00001C00 }, /* GL_RENDER */
-+   { 26909, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_EXT */
-+   { 26937, 0x00008D41 }, /* GL_RENDERBUFFER_EXT */
-+   { 26957, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_EXT */
-+   { 26984, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */
-+   { 27020, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_EXT */
-+   { 27046, 0x00001F01 }, /* GL_RENDERER */
-+   { 27058, 0x00000C40 }, /* GL_RENDER_MODE */
-+   { 27073, 0x00002901 }, /* GL_REPEAT */
-+   { 27083, 0x00001E01 }, /* GL_REPLACE */
-+   { 27094, 0x00008062 }, /* GL_REPLACE_EXT */
-+   { 27109, 0x00008153 }, /* GL_REPLICATE_BORDER_HP */
-+   { 27132, 0x0000803A }, /* GL_RESCALE_NORMAL */
-+   { 27150, 0x0000803A }, /* GL_RESCALE_NORMAL_EXT */
-+   { 27172, 0x00000102 }, /* GL_RETURN */
-+   { 27182, 0x00001907 }, /* GL_RGB */
-+   { 27189, 0x00008052 }, /* GL_RGB10 */
-+   { 27198, 0x00008059 }, /* GL_RGB10_A2 */
-+   { 27210, 0x00008059 }, /* GL_RGB10_A2_EXT */
-+   { 27226, 0x00008052 }, /* GL_RGB10_EXT */
-+   { 27239, 0x00008053 }, /* GL_RGB12 */
-+   { 27248, 0x00008053 }, /* GL_RGB12_EXT */
-+   { 27261, 0x00008054 }, /* GL_RGB16 */
-+   { 27270, 0x00008054 }, /* GL_RGB16_EXT */
-+   { 27283, 0x0000804E }, /* GL_RGB2_EXT */
-+   { 27295, 0x0000804F }, /* GL_RGB4 */
-+   { 27303, 0x0000804F }, /* GL_RGB4_EXT */
-+   { 27315, 0x000083A1 }, /* GL_RGB4_S3TC */
-+   { 27328, 0x00008050 }, /* GL_RGB5 */
-+   { 27336, 0x00008057 }, /* GL_RGB5_A1 */
-+   { 27347, 0x00008057 }, /* GL_RGB5_A1_EXT */
-+   { 27362, 0x00008050 }, /* GL_RGB5_EXT */
-+   { 27374, 0x00008051 }, /* GL_RGB8 */
-+   { 27382, 0x00008051 }, /* GL_RGB8_EXT */
-+   { 27394, 0x00001908 }, /* GL_RGBA */
-+   { 27402, 0x0000805A }, /* GL_RGBA12 */
-+   { 27412, 0x0000805A }, /* GL_RGBA12_EXT */
-+   { 27426, 0x0000805B }, /* GL_RGBA16 */
-+   { 27436, 0x0000805B }, /* GL_RGBA16_EXT */
-+   { 27450, 0x00008055 }, /* GL_RGBA2 */
-+   { 27459, 0x00008055 }, /* GL_RGBA2_EXT */
-+   { 27472, 0x00008056 }, /* GL_RGBA4 */
-+   { 27481, 0x000083A5 }, /* GL_RGBA4_DXT5_S3TC */
-+   { 27500, 0x00008056 }, /* GL_RGBA4_EXT */
-+   { 27513, 0x000083A3 }, /* GL_RGBA4_S3TC */
-+   { 27527, 0x00008058 }, /* GL_RGBA8 */
-+   { 27536, 0x00008058 }, /* GL_RGBA8_EXT */
-+   { 27549, 0x000083A4 }, /* GL_RGBA_DXT5_S3TC */
-+   { 27567, 0x00000C31 }, /* GL_RGBA_MODE */
-+   { 27580, 0x000083A2 }, /* GL_RGBA_S3TC */
-+   { 27593, 0x000083A0 }, /* GL_RGB_S3TC */
-+   { 27605, 0x00008573 }, /* GL_RGB_SCALE */
-+   { 27618, 0x00008573 }, /* GL_RGB_SCALE_ARB */
-+   { 27635, 0x00008573 }, /* GL_RGB_SCALE_EXT */
-+   { 27652, 0x00000407 }, /* GL_RIGHT */
-+   { 27661, 0x00002000 }, /* GL_S */
-+   { 27666, 0x00008B5D }, /* GL_SAMPLER_1D */
-+   { 27680, 0x00008B61 }, /* GL_SAMPLER_1D_SHADOW */
-+   { 27701, 0x00008B5E }, /* GL_SAMPLER_2D */
-+   { 27715, 0x00008B62 }, /* GL_SAMPLER_2D_SHADOW */
-+   { 27736, 0x00008B5F }, /* GL_SAMPLER_3D */
-+   { 27750, 0x00008B60 }, /* GL_SAMPLER_CUBE */
-+   { 27766, 0x000080A9 }, /* GL_SAMPLES */
-+   { 27777, 0x000086B4 }, /* GL_SAMPLES_3DFX */
-+   { 27793, 0x000080A9 }, /* GL_SAMPLES_ARB */
-+   { 27808, 0x00008914 }, /* GL_SAMPLES_PASSED */
-+   { 27826, 0x00008914 }, /* GL_SAMPLES_PASSED_ARB */
-+   { 27848, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
-+   { 27876, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE_ARB */
-+   { 27908, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE */
-+   { 27931, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE_ARB */
-+   { 27958, 0x000080A8 }, /* GL_SAMPLE_BUFFERS */
-+   { 27976, 0x000086B3 }, /* GL_SAMPLE_BUFFERS_3DFX */
-+   { 27999, 0x000080A8 }, /* GL_SAMPLE_BUFFERS_ARB */
-+   { 28021, 0x000080A0 }, /* GL_SAMPLE_COVERAGE */
-+   { 28040, 0x000080A0 }, /* GL_SAMPLE_COVERAGE_ARB */
-+   { 28063, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT */
-+   { 28089, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT_ARB */
-+   { 28119, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE */
-+   { 28144, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE_ARB */
-+   { 28173, 0x00080000 }, /* GL_SCISSOR_BIT */
-+   { 28188, 0x00000C10 }, /* GL_SCISSOR_BOX */
-+   { 28203, 0x00000C11 }, /* GL_SCISSOR_TEST */
-+   { 28219, 0x0000845E }, /* GL_SECONDARY_COLOR_ARRAY */
-+   { 28244, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
-+   { 28284, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB */
-+   { 28328, 0x0000845D }, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
-+   { 28361, 0x0000845A }, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
-+   { 28391, 0x0000845C }, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
-+   { 28423, 0x0000845B }, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
-+   { 28453, 0x00001C02 }, /* GL_SELECT */
-+   { 28463, 0x00000DF3 }, /* GL_SELECTION_BUFFER_POINTER */
-+   { 28491, 0x00000DF4 }, /* GL_SELECTION_BUFFER_SIZE */
-+   { 28516, 0x00008012 }, /* GL_SEPARABLE_2D */
-+   { 28532, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR */
-+   { 28559, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR_EXT */
-+   { 28590, 0x0000150F }, /* GL_SET */
-+   { 28597, 0x00008B48 }, /* GL_SHADER_OBJECT_ARB */
-+   { 28618, 0x00008B88 }, /* GL_SHADER_SOURCE_LENGTH */
-+   { 28642, 0x00008B4F }, /* GL_SHADER_TYPE */
-+   { 28657, 0x00000B54 }, /* GL_SHADE_MODEL */
-+   { 28672, 0x00008B8C }, /* GL_SHADING_LANGUAGE_VERSION */
-+   { 28700, 0x000080BF }, /* GL_SHADOW_AMBIENT_SGIX */
-+   { 28723, 0x000081FB }, /* GL_SHARED_TEXTURE_PALETTE_EXT */
-+   { 28753, 0x00001601 }, /* GL_SHININESS */
-+   { 28766, 0x00001402 }, /* GL_SHORT */
-+   { 28775, 0x000081F9 }, /* GL_SINGLE_COLOR */
-+   { 28791, 0x000081F9 }, /* GL_SINGLE_COLOR_EXT */
-+   { 28811, 0x000085CC }, /* GL_SLICE_ACCUM_SUN */
-+   { 28830, 0x00001D01 }, /* GL_SMOOTH */
-+   { 28840, 0x00000B23 }, /* GL_SMOOTH_LINE_WIDTH_GRANULARITY */
-+   { 28873, 0x00000B22 }, /* GL_SMOOTH_LINE_WIDTH_RANGE */
-+   { 28900, 0x00000B13 }, /* GL_SMOOTH_POINT_SIZE_GRANULARITY */
-+   { 28933, 0x00000B12 }, /* GL_SMOOTH_POINT_SIZE_RANGE */
-+   { 28960, 0x00008588 }, /* GL_SOURCE0_ALPHA */
-+   { 28977, 0x00008588 }, /* GL_SOURCE0_ALPHA_ARB */
-+   { 28998, 0x00008588 }, /* GL_SOURCE0_ALPHA_EXT */
-+   { 29019, 0x00008580 }, /* GL_SOURCE0_RGB */
-+   { 29034, 0x00008580 }, /* GL_SOURCE0_RGB_ARB */
-+   { 29053, 0x00008580 }, /* GL_SOURCE0_RGB_EXT */
-+   { 29072, 0x00008589 }, /* GL_SOURCE1_ALPHA */
-+   { 29089, 0x00008589 }, /* GL_SOURCE1_ALPHA_ARB */
-+   { 29110, 0x00008589 }, /* GL_SOURCE1_ALPHA_EXT */
-+   { 29131, 0x00008581 }, /* GL_SOURCE1_RGB */
-+   { 29146, 0x00008581 }, /* GL_SOURCE1_RGB_ARB */
-+   { 29165, 0x00008581 }, /* GL_SOURCE1_RGB_EXT */
-+   { 29184, 0x0000858A }, /* GL_SOURCE2_ALPHA */
-+   { 29201, 0x0000858A }, /* GL_SOURCE2_ALPHA_ARB */
-+   { 29222, 0x0000858A }, /* GL_SOURCE2_ALPHA_EXT */
-+   { 29243, 0x00008582 }, /* GL_SOURCE2_RGB */
-+   { 29258, 0x00008582 }, /* GL_SOURCE2_RGB_ARB */
-+   { 29277, 0x00008582 }, /* GL_SOURCE2_RGB_EXT */
-+   { 29296, 0x0000858B }, /* GL_SOURCE3_ALPHA_NV */
-+   { 29316, 0x00008583 }, /* GL_SOURCE3_RGB_NV */
-+   { 29334, 0x00001202 }, /* GL_SPECULAR */
-+   { 29346, 0x00002402 }, /* GL_SPHERE_MAP */
-+   { 29360, 0x00001206 }, /* GL_SPOT_CUTOFF */
-+   { 29375, 0x00001204 }, /* GL_SPOT_DIRECTION */
-+   { 29393, 0x00001205 }, /* GL_SPOT_EXPONENT */
-+   { 29410, 0x00008588 }, /* GL_SRC0_ALPHA */
-+   { 29424, 0x00008580 }, /* GL_SRC0_RGB */
-+   { 29436, 0x00008589 }, /* GL_SRC1_ALPHA */
-+   { 29450, 0x00008581 }, /* GL_SRC1_RGB */
-+   { 29462, 0x0000858A }, /* GL_SRC2_ALPHA */
-+   { 29476, 0x00008582 }, /* GL_SRC2_RGB */
-+   { 29488, 0x00000302 }, /* GL_SRC_ALPHA */
-+   { 29501, 0x00000308 }, /* GL_SRC_ALPHA_SATURATE */
-+   { 29523, 0x00000300 }, /* GL_SRC_COLOR */
-+   { 29536, 0x00000503 }, /* GL_STACK_OVERFLOW */
-+   { 29554, 0x00000504 }, /* GL_STACK_UNDERFLOW */
-+   { 29573, 0x000088E6 }, /* GL_STATIC_COPY */
-+   { 29588, 0x000088E6 }, /* GL_STATIC_COPY_ARB */
-+   { 29607, 0x000088E4 }, /* GL_STATIC_DRAW */
-+   { 29622, 0x000088E4 }, /* GL_STATIC_DRAW_ARB */
-+   { 29641, 0x000088E5 }, /* GL_STATIC_READ */
-+   { 29656, 0x000088E5 }, /* GL_STATIC_READ_ARB */
-+   { 29675, 0x00001802 }, /* GL_STENCIL */
-+   { 29686, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_EXT */
-+   { 29712, 0x00008801 }, /* GL_STENCIL_BACK_FAIL */
-+   { 29733, 0x00008800 }, /* GL_STENCIL_BACK_FUNC */
-+   { 29754, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
-+   { 29786, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
-+   { 29818, 0x00008CA3 }, /* GL_STENCIL_BACK_REF */
-+   { 29838, 0x00008CA4 }, /* GL_STENCIL_BACK_VALUE_MASK */
-+   { 29865, 0x00008CA5 }, /* GL_STENCIL_BACK_WRITEMASK */
-+   { 29891, 0x00000D57 }, /* GL_STENCIL_BITS */
-+   { 29907, 0x00000400 }, /* GL_STENCIL_BUFFER_BIT */
-+   { 29929, 0x00000B91 }, /* GL_STENCIL_CLEAR_VALUE */
-+   { 29952, 0x00000B94 }, /* GL_STENCIL_FAIL */
-+   { 29968, 0x00000B92 }, /* GL_STENCIL_FUNC */
-+   { 29984, 0x00001901 }, /* GL_STENCIL_INDEX */
-+   { 30001, 0x00008D49 }, /* GL_STENCIL_INDEX16_EXT */
-+   { 30024, 0x00008D46 }, /* GL_STENCIL_INDEX1_EXT */
-+   { 30046, 0x00008D47 }, /* GL_STENCIL_INDEX4_EXT */
-+   { 30068, 0x00008D48 }, /* GL_STENCIL_INDEX8_EXT */
-+   { 30090, 0x00008D45 }, /* GL_STENCIL_INDEX_EXT */
-+   { 30111, 0x00000B95 }, /* GL_STENCIL_PASS_DEPTH_FAIL */
-+   { 30138, 0x00000B96 }, /* GL_STENCIL_PASS_DEPTH_PASS */
-+   { 30165, 0x00000B97 }, /* GL_STENCIL_REF */
-+   { 30180, 0x00000B90 }, /* GL_STENCIL_TEST */
-+   { 30196, 0x00008910 }, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
-+   { 30225, 0x00000B93 }, /* GL_STENCIL_VALUE_MASK */
-+   { 30247, 0x00000B98 }, /* GL_STENCIL_WRITEMASK */
-+   { 30268, 0x00000C33 }, /* GL_STEREO */
-+   { 30278, 0x000088E2 }, /* GL_STREAM_COPY */
-+   { 30293, 0x000088E2 }, /* GL_STREAM_COPY_ARB */
-+   { 30312, 0x000088E0 }, /* GL_STREAM_DRAW */
-+   { 30327, 0x000088E0 }, /* GL_STREAM_DRAW_ARB */
-+   { 30346, 0x000088E1 }, /* GL_STREAM_READ */
-+   { 30361, 0x000088E1 }, /* GL_STREAM_READ_ARB */
-+   { 30380, 0x00000D50 }, /* GL_SUBPIXEL_BITS */
-+   { 30397, 0x000084E7 }, /* GL_SUBTRACT */
-+   { 30409, 0x000084E7 }, /* GL_SUBTRACT_ARB */
-+   { 30425, 0x00002001 }, /* GL_T */
-+   { 30430, 0x00002A2A }, /* GL_T2F_C3F_V3F */
-+   { 30445, 0x00002A2C }, /* GL_T2F_C4F_N3F_V3F */
-+   { 30464, 0x00002A29 }, /* GL_T2F_C4UB_V3F */
-+   { 30480, 0x00002A2B }, /* GL_T2F_N3F_V3F */
-+   { 30495, 0x00002A27 }, /* GL_T2F_V3F */
-+   { 30506, 0x00002A2D }, /* GL_T4F_C4F_N3F_V4F */
-+   { 30525, 0x00002A28 }, /* GL_T4F_V4F */
-+   { 30536, 0x00008031 }, /* GL_TABLE_TOO_LARGE_EXT */
-+   { 30559, 0x00001702 }, /* GL_TEXTURE */
-+   { 30570, 0x000084C0 }, /* GL_TEXTURE0 */
-+   { 30582, 0x000084C0 }, /* GL_TEXTURE0_ARB */
-+   { 30598, 0x000084C1 }, /* GL_TEXTURE1 */
-+   { 30610, 0x000084CA }, /* GL_TEXTURE10 */
-+   { 30623, 0x000084CA }, /* GL_TEXTURE10_ARB */
-+   { 30640, 0x000084CB }, /* GL_TEXTURE11 */
-+   { 30653, 0x000084CB }, /* GL_TEXTURE11_ARB */
-+   { 30670, 0x000084CC }, /* GL_TEXTURE12 */
-+   { 30683, 0x000084CC }, /* GL_TEXTURE12_ARB */
-+   { 30700, 0x000084CD }, /* GL_TEXTURE13 */
-+   { 30713, 0x000084CD }, /* GL_TEXTURE13_ARB */
-+   { 30730, 0x000084CE }, /* GL_TEXTURE14 */
-+   { 30743, 0x000084CE }, /* GL_TEXTURE14_ARB */
-+   { 30760, 0x000084CF }, /* GL_TEXTURE15 */
-+   { 30773, 0x000084CF }, /* GL_TEXTURE15_ARB */
-+   { 30790, 0x000084D0 }, /* GL_TEXTURE16 */
-+   { 30803, 0x000084D0 }, /* GL_TEXTURE16_ARB */
-+   { 30820, 0x000084D1 }, /* GL_TEXTURE17 */
-+   { 30833, 0x000084D1 }, /* GL_TEXTURE17_ARB */
-+   { 30850, 0x000084D2 }, /* GL_TEXTURE18 */
-+   { 30863, 0x000084D2 }, /* GL_TEXTURE18_ARB */
-+   { 30880, 0x000084D3 }, /* GL_TEXTURE19 */
-+   { 30893, 0x000084D3 }, /* GL_TEXTURE19_ARB */
-+   { 30910, 0x000084C1 }, /* GL_TEXTURE1_ARB */
-+   { 30926, 0x000084C2 }, /* GL_TEXTURE2 */
-+   { 30938, 0x000084D4 }, /* GL_TEXTURE20 */
-+   { 30951, 0x000084D4 }, /* GL_TEXTURE20_ARB */
-+   { 30968, 0x000084D5 }, /* GL_TEXTURE21 */
-+   { 30981, 0x000084D5 }, /* GL_TEXTURE21_ARB */
-+   { 30998, 0x000084D6 }, /* GL_TEXTURE22 */
-+   { 31011, 0x000084D6 }, /* GL_TEXTURE22_ARB */
-+   { 31028, 0x000084D7 }, /* GL_TEXTURE23 */
-+   { 31041, 0x000084D7 }, /* GL_TEXTURE23_ARB */
-+   { 31058, 0x000084D8 }, /* GL_TEXTURE24 */
-+   { 31071, 0x000084D8 }, /* GL_TEXTURE24_ARB */
-+   { 31088, 0x000084D9 }, /* GL_TEXTURE25 */
-+   { 31101, 0x000084D9 }, /* GL_TEXTURE25_ARB */
-+   { 31118, 0x000084DA }, /* GL_TEXTURE26 */
-+   { 31131, 0x000084DA }, /* GL_TEXTURE26_ARB */
-+   { 31148, 0x000084DB }, /* GL_TEXTURE27 */
-+   { 31161, 0x000084DB }, /* GL_TEXTURE27_ARB */
-+   { 31178, 0x000084DC }, /* GL_TEXTURE28 */
-+   { 31191, 0x000084DC }, /* GL_TEXTURE28_ARB */
-+   { 31208, 0x000084DD }, /* GL_TEXTURE29 */
-+   { 31221, 0x000084DD }, /* GL_TEXTURE29_ARB */
-+   { 31238, 0x000084C2 }, /* GL_TEXTURE2_ARB */
-+   { 31254, 0x000084C3 }, /* GL_TEXTURE3 */
-+   { 31266, 0x000084DE }, /* GL_TEXTURE30 */
-+   { 31279, 0x000084DE }, /* GL_TEXTURE30_ARB */
-+   { 31296, 0x000084DF }, /* GL_TEXTURE31 */
-+   { 31309, 0x000084DF }, /* GL_TEXTURE31_ARB */
-+   { 31326, 0x000084C3 }, /* GL_TEXTURE3_ARB */
-+   { 31342, 0x000084C4 }, /* GL_TEXTURE4 */
-+   { 31354, 0x000084C4 }, /* GL_TEXTURE4_ARB */
-+   { 31370, 0x000084C5 }, /* GL_TEXTURE5 */
-+   { 31382, 0x000084C5 }, /* GL_TEXTURE5_ARB */
-+   { 31398, 0x000084C6 }, /* GL_TEXTURE6 */
-+   { 31410, 0x000084C6 }, /* GL_TEXTURE6_ARB */
-+   { 31426, 0x000084C7 }, /* GL_TEXTURE7 */
-+   { 31438, 0x000084C7 }, /* GL_TEXTURE7_ARB */
-+   { 31454, 0x000084C8 }, /* GL_TEXTURE8 */
-+   { 31466, 0x000084C8 }, /* GL_TEXTURE8_ARB */
-+   { 31482, 0x000084C9 }, /* GL_TEXTURE9 */
-+   { 31494, 0x000084C9 }, /* GL_TEXTURE9_ARB */
-+   { 31510, 0x00000DE0 }, /* GL_TEXTURE_1D */
-+   { 31524, 0x00008C18 }, /* GL_TEXTURE_1D_ARRAY_EXT */
-+   { 31548, 0x00000DE1 }, /* GL_TEXTURE_2D */
-+   { 31562, 0x00008C1A }, /* GL_TEXTURE_2D_ARRAY_EXT */
-+   { 31586, 0x0000806F }, /* GL_TEXTURE_3D */
-+   { 31600, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE */
-+   { 31622, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE_EXT */
-+   { 31648, 0x0000813C }, /* GL_TEXTURE_BASE_LEVEL */
-+   { 31670, 0x00008068 }, /* GL_TEXTURE_BINDING_1D */
-+   { 31692, 0x00008C1C }, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
-+   { 31724, 0x00008069 }, /* GL_TEXTURE_BINDING_2D */
-+   { 31746, 0x00008C1D }, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
-+   { 31778, 0x0000806A }, /* GL_TEXTURE_BINDING_3D */
-+   { 31800, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP */
-+   { 31828, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_ARB */
-+   { 31860, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
-+   { 31893, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_NV */
-+   { 31925, 0x00040000 }, /* GL_TEXTURE_BIT */
-+   { 31940, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE */
-+   { 31961, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE_EXT */
-+   { 31986, 0x00001005 }, /* GL_TEXTURE_BORDER */
-+   { 32004, 0x00001004 }, /* GL_TEXTURE_BORDER_COLOR */
-+   { 32028, 0x00008171 }, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
-+   { 32059, 0x00008176 }, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
-+   { 32089, 0x00008172 }, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
-+   { 32119, 0x00008175 }, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
-+   { 32154, 0x00008173 }, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
-+   { 32185, 0x00008174 }, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-+   { 32223, 0x000080BC }, /* GL_TEXTURE_COLOR_TABLE_SGI */
-+   { 32250, 0x000081EF }, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
-+   { 32282, 0x000080BF }, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
-+   { 32316, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC */
-+   { 32340, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC_ARB */
-+   { 32368, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE */
-+   { 32392, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE_ARB */
-+   { 32420, 0x0000819B }, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
-+   { 32453, 0x0000819A }, /* GL_TEXTURE_COMPARE_SGIX */
-+   { 32477, 0x00001003 }, /* GL_TEXTURE_COMPONENTS */
-+   { 32499, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED */
-+   { 32521, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED_ARB */
-+   { 32547, 0x000086A3 }, /* GL_TEXTURE_COMPRESSED_FORMATS_ARB */
-+   { 32581, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
-+   { 32614, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB */
-+   { 32651, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT */
-+   { 32679, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT_ARB */
-+   { 32711, 0x00008078 }, /* GL_TEXTURE_COORD_ARRAY */
-+   { 32734, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
-+   { 32772, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB */
-+   { 32814, 0x00008092 }, /* GL_TEXTURE_COORD_ARRAY_POINTER */
-+   { 32845, 0x00008088 }, /* GL_TEXTURE_COORD_ARRAY_SIZE */
-+   { 32873, 0x0000808A }, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
-+   { 32903, 0x00008089 }, /* GL_TEXTURE_COORD_ARRAY_TYPE */
-+   { 32931, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP */
-+   { 32951, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_ARB */
-+   { 32975, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
-+   { 33006, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB */
-+   { 33041, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
-+   { 33072, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB */
-+   { 33107, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
-+   { 33138, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB */
-+   { 33173, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
-+   { 33204, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB */
-+   { 33239, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
-+   { 33270, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB */
-+   { 33305, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
-+   { 33336, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB */
-+   { 33371, 0x00008071 }, /* GL_TEXTURE_DEPTH */
-+   { 33388, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE */
-+   { 33410, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE_ARB */
-+   { 33436, 0x00002300 }, /* GL_TEXTURE_ENV */
-+   { 33451, 0x00002201 }, /* GL_TEXTURE_ENV_COLOR */
-+   { 33472, 0x00002200 }, /* GL_TEXTURE_ENV_MODE */
-+   { 33492, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL */
-+   { 33518, 0x00002500 }, /* GL_TEXTURE_GEN_MODE */
-+   { 33538, 0x00000C63 }, /* GL_TEXTURE_GEN_Q */
-+   { 33555, 0x00000C62 }, /* GL_TEXTURE_GEN_R */
-+   { 33572, 0x00000C60 }, /* GL_TEXTURE_GEN_S */
-+   { 33589, 0x00000C61 }, /* GL_TEXTURE_GEN_T */
-+   { 33606, 0x0000819D }, /* GL_TEXTURE_GEQUAL_R_SGIX */
-+   { 33631, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE */
-+   { 33653, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE_EXT */
-+   { 33679, 0x00001001 }, /* GL_TEXTURE_HEIGHT */
-+   { 33697, 0x000080ED }, /* GL_TEXTURE_INDEX_SIZE_EXT */
-+   { 33723, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE */
-+   { 33749, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE_EXT */
-+   { 33779, 0x00001003 }, /* GL_TEXTURE_INTERNAL_FORMAT */
-+   { 33806, 0x0000819C }, /* GL_TEXTURE_LEQUAL_R_SGIX */
-+   { 33831, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS */
-+   { 33851, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS_EXT */
-+   { 33875, 0x00008190 }, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
-+   { 33902, 0x0000818E }, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
-+   { 33929, 0x0000818F }, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
-+   { 33956, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE */
-+   { 33982, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE_EXT */
-+   { 34012, 0x00002800 }, /* GL_TEXTURE_MAG_FILTER */
-+   { 34034, 0x00000BA8 }, /* GL_TEXTURE_MATRIX */
-+   { 34052, 0x000084FE }, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
-+   { 34082, 0x0000836B }, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
-+   { 34110, 0x00008369 }, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
-+   { 34138, 0x0000836A }, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
-+   { 34166, 0x0000813D }, /* GL_TEXTURE_MAX_LEVEL */
-+   { 34187, 0x0000813B }, /* GL_TEXTURE_MAX_LOD */
-+   { 34206, 0x00002801 }, /* GL_TEXTURE_MIN_FILTER */
-+   { 34228, 0x0000813A }, /* GL_TEXTURE_MIN_LOD */
-+   { 34247, 0x00008066 }, /* GL_TEXTURE_PRIORITY */
-+   { 34267, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_ARB */
-+   { 34292, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_NV */
-+   { 34316, 0x0000805C }, /* GL_TEXTURE_RED_SIZE */
-+   { 34336, 0x0000805C }, /* GL_TEXTURE_RED_SIZE_EXT */
-+   { 34360, 0x00008067 }, /* GL_TEXTURE_RESIDENT */
-+   { 34380, 0x00000BA5 }, /* GL_TEXTURE_STACK_DEPTH */
-+   { 34403, 0x00008065 }, /* GL_TEXTURE_TOO_LARGE_EXT */
-+   { 34428, 0x0000888F }, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
-+   { 34462, 0x00001000 }, /* GL_TEXTURE_WIDTH */
-+   { 34479, 0x00008072 }, /* GL_TEXTURE_WRAP_R */
-+   { 34497, 0x00002802 }, /* GL_TEXTURE_WRAP_S */
-+   { 34515, 0x00002803 }, /* GL_TEXTURE_WRAP_T */
-+   { 34533, 0x000088BF }, /* GL_TIME_ELAPSED_EXT */
-+   { 34553, 0x00008648 }, /* GL_TRACK_MATRIX_NV */
-+   { 34572, 0x00008649 }, /* GL_TRACK_MATRIX_TRANSFORM_NV */
-+   { 34601, 0x00001000 }, /* GL_TRANSFORM_BIT */
-+   { 34618, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX */
-+   { 34644, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX_ARB */
-+   { 34674, 0x000088B7 }, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
-+   { 34706, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
-+   { 34736, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX_ARB */
-+   { 34770, 0x0000862C }, /* GL_TRANSPOSE_NV */
-+   { 34786, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX */
-+   { 34817, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX_ARB */
-+   { 34852, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX */
-+   { 34880, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX_ARB */
-+   { 34912, 0x00000004 }, /* GL_TRIANGLES */
-+   { 34925, 0x00000006 }, /* GL_TRIANGLE_FAN */
-+   { 34941, 0x00008615 }, /* GL_TRIANGLE_MESH_SUN */
-+   { 34962, 0x00000005 }, /* GL_TRIANGLE_STRIP */
-+   { 34980, 0x00000001 }, /* GL_TRUE */
-+   { 34988, 0x00000CF5 }, /* GL_UNPACK_ALIGNMENT */
-+   { 35008, 0x0000806E }, /* GL_UNPACK_IMAGE_HEIGHT */
-+   { 35031, 0x00000CF1 }, /* GL_UNPACK_LSB_FIRST */
-+   { 35051, 0x00000CF2 }, /* GL_UNPACK_ROW_LENGTH */
-+   { 35072, 0x0000806D }, /* GL_UNPACK_SKIP_IMAGES */
-+   { 35094, 0x00000CF4 }, /* GL_UNPACK_SKIP_PIXELS */
-+   { 35116, 0x00000CF3 }, /* GL_UNPACK_SKIP_ROWS */
-+   { 35136, 0x00000CF0 }, /* GL_UNPACK_SWAP_BYTES */
-+   { 35157, 0x00001401 }, /* GL_UNSIGNED_BYTE */
-+   { 35174, 0x00008362 }, /* GL_UNSIGNED_BYTE_2_3_3_REV */
-+   { 35201, 0x00008032 }, /* GL_UNSIGNED_BYTE_3_3_2 */
-+   { 35224, 0x00001405 }, /* GL_UNSIGNED_INT */
-+   { 35240, 0x00008036 }, /* GL_UNSIGNED_INT_10_10_10_2 */
-+   { 35267, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_NV */
-+   { 35291, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV */
-+   { 35322, 0x00008035 }, /* GL_UNSIGNED_INT_8_8_8_8 */
-+   { 35346, 0x00008367 }, /* GL_UNSIGNED_INT_8_8_8_8_REV */
-+   { 35374, 0x00001403 }, /* GL_UNSIGNED_SHORT */
-+   { 35392, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
-+   { 35422, 0x00008033 }, /* GL_UNSIGNED_SHORT_4_4_4_4 */
-+   { 35448, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
-+   { 35478, 0x00008034 }, /* GL_UNSIGNED_SHORT_5_5_5_1 */
-+   { 35504, 0x00008363 }, /* GL_UNSIGNED_SHORT_5_6_5 */
-+   { 35528, 0x00008364 }, /* GL_UNSIGNED_SHORT_5_6_5_REV */
-+   { 35556, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_APPLE */
-+   { 35584, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_MESA */
-+   { 35611, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
-+   { 35643, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_MESA */
-+   { 35674, 0x00008CA2 }, /* GL_UPPER_LEFT */
-+   { 35688, 0x00002A20 }, /* GL_V2F */
-+   { 35695, 0x00002A21 }, /* GL_V3F */
-+   { 35702, 0x00008B83 }, /* GL_VALIDATE_STATUS */
-+   { 35721, 0x00001F00 }, /* GL_VENDOR */
-+   { 35731, 0x00001F02 }, /* GL_VERSION */
-+   { 35742, 0x00008074 }, /* GL_VERTEX_ARRAY */
-+   { 35758, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING_APPLE */
-+   { 35788, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
-+   { 35819, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING_ARB */
-+   { 35854, 0x0000808E }, /* GL_VERTEX_ARRAY_POINTER */
-+   { 35878, 0x0000807A }, /* GL_VERTEX_ARRAY_SIZE */
-+   { 35899, 0x0000807C }, /* GL_VERTEX_ARRAY_STRIDE */
-+   { 35922, 0x0000807B }, /* GL_VERTEX_ARRAY_TYPE */
-+   { 35943, 0x00008650 }, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
-+   { 35970, 0x0000865A }, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
-+   { 35998, 0x0000865B }, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
-+   { 36026, 0x0000865C }, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
-+   { 36054, 0x0000865D }, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
-+   { 36082, 0x0000865E }, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
-+   { 36110, 0x0000865F }, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
-+   { 36138, 0x00008651 }, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
-+   { 36165, 0x00008652 }, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
-+   { 36192, 0x00008653 }, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
-+   { 36219, 0x00008654 }, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
-+   { 36246, 0x00008655 }, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
-+   { 36273, 0x00008656 }, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
-+   { 36300, 0x00008657 }, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
-+   { 36327, 0x00008658 }, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
-+   { 36354, 0x00008659 }, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
-+   { 36381, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
-+   { 36419, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB */
-+   { 36461, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
-+   { 36492, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */
-+   { 36527, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
-+   { 36561, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */
-+   { 36599, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
-+   { 36630, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */
-+   { 36665, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
-+   { 36693, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */
-+   { 36725, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
-+   { 36755, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */
-+   { 36789, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
-+   { 36817, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */
-+   { 36849, 0x000086A7 }, /* GL_VERTEX_BLEND_ARB */
-+   { 36869, 0x00008620 }, /* GL_VERTEX_PROGRAM_ARB */
-+   { 36891, 0x0000864A }, /* GL_VERTEX_PROGRAM_BINDING_NV */
-+   { 36920, 0x00008620 }, /* GL_VERTEX_PROGRAM_NV */
-+   { 36941, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE */
-+   { 36970, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */
-+   { 37003, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_NV */
-+   { 37035, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE */
-+   { 37062, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */
-+   { 37093, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_NV */
-+   { 37123, 0x00008B31 }, /* GL_VERTEX_SHADER */
-+   { 37140, 0x00008B31 }, /* GL_VERTEX_SHADER_ARB */
-+   { 37161, 0x00008621 }, /* GL_VERTEX_STATE_PROGRAM_NV */
-+   { 37188, 0x00000BA2 }, /* GL_VIEWPORT */
-+   { 37200, 0x00000800 }, /* GL_VIEWPORT_BIT */
-+   { 37216, 0x000086AD }, /* GL_WEIGHT_ARRAY_ARB */
-+   { 37236, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
-+   { 37267, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB */
-+   { 37302, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_ARB */
-+   { 37330, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_ARB */
-+   { 37355, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
-+   { 37382, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_ARB */
-+   { 37407, 0x000086A6 }, /* GL_WEIGHT_SUM_UNITY_ARB */
-+   { 37431, 0x000081D4 }, /* GL_WRAP_BORDER_SUN */
-+   { 37450, 0x000088B9 }, /* GL_WRITE_ONLY */
-+   { 37464, 0x000088B9 }, /* GL_WRITE_ONLY_ARB */
-+   { 37482, 0x00001506 }, /* GL_XOR */
-+   { 37489, 0x000085B9 }, /* GL_YCBCR_422_APPLE */
-+   { 37508, 0x00008757 }, /* GL_YCBCR_MESA */
-+   { 37522, 0x00000000 }, /* GL_ZERO */
-+   { 37530, 0x00000D16 }, /* GL_ZOOM_X */
-+   { 37540, 0x00000D17 }, /* GL_ZOOM_Y */
-+};
-+
-+static const unsigned reduced_enums[1284] =
-+{
-+       436, /* GL_FALSE */
-+       645, /* GL_LINES */
-+       647, /* GL_LINE_LOOP */
-+       654, /* GL_LINE_STRIP */
-+      1637, /* GL_TRIANGLES */
-+      1640, /* GL_TRIANGLE_STRIP */
-+      1638, /* GL_TRIANGLE_FAN */
-+      1211, /* GL_QUADS */
-+      1213, /* GL_QUAD_STRIP */
-+      1099, /* GL_POLYGON */
-+      1111, /* GL_POLYGON_STIPPLE_BIT */
-+      1064, /* GL_PIXEL_MODE_BIT */
-+       632, /* GL_LIGHTING_BIT */
-+       458, /* GL_FOG_BIT */
-+         8, /* GL_ACCUM */
-+       664, /* GL_LOAD */
-+      1253, /* GL_RETURN */
-+       937, /* GL_MULT */
-+        23, /* GL_ADD */
-+       953, /* GL_NEVER */
-+       622, /* GL_LESS */
-+       426, /* GL_EQUAL */
-+       621, /* GL_LEQUAL */
-+       547, /* GL_GREATER */
-+       968, /* GL_NOTEQUAL */
-+       522, /* GL_GEQUAL */
-+        46, /* GL_ALWAYS */
-+      1386, /* GL_SRC_COLOR */
-+       997, /* GL_ONE_MINUS_SRC_COLOR */
-+      1384, /* GL_SRC_ALPHA */
-+       996, /* GL_ONE_MINUS_SRC_ALPHA */
-+       406, /* GL_DST_ALPHA */
-+       994, /* GL_ONE_MINUS_DST_ALPHA */
-+       407, /* GL_DST_COLOR */
-+       995, /* GL_ONE_MINUS_DST_COLOR */
-+      1385, /* GL_SRC_ALPHA_SATURATE */
-+       510, /* GL_FRONT_LEFT */
-+       511, /* GL_FRONT_RIGHT */
-+        69, /* GL_BACK_LEFT */
-+        70, /* GL_BACK_RIGHT */
-+       507, /* GL_FRONT */
-+        68, /* GL_BACK */
-+       620, /* GL_LEFT */
-+      1293, /* GL_RIGHT */
-+       508, /* GL_FRONT_AND_BACK */
-+        63, /* GL_AUX0 */
-+        64, /* GL_AUX1 */
-+        65, /* GL_AUX2 */
-+        66, /* GL_AUX3 */
-+       612, /* GL_INVALID_ENUM */
-+       615, /* GL_INVALID_VALUE */
-+       614, /* GL_INVALID_OPERATION */
-+      1387, /* GL_STACK_OVERFLOW */
-+      1388, /* GL_STACK_UNDERFLOW */
-+      1022, /* GL_OUT_OF_MEMORY */
-+       613, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */
-+         0, /* GL_2D */
-+         2, /* GL_3D */
-+         3, /* GL_3D_COLOR */
-+         4, /* GL_3D_COLOR_TEXTURE */
-+         6, /* GL_4D_COLOR_TEXTURE */
-+      1042, /* GL_PASS_THROUGH_TOKEN */
-+      1098, /* GL_POINT_TOKEN */
-+       655, /* GL_LINE_TOKEN */
-+      1112, /* GL_POLYGON_TOKEN */
-+        74, /* GL_BITMAP_TOKEN */
-+       405, /* GL_DRAW_PIXEL_TOKEN */
-+       271, /* GL_COPY_PIXEL_TOKEN */
-+       648, /* GL_LINE_RESET_TOKEN */
-+       429, /* GL_EXP */
-+       430, /* GL_EXP2 */
-+       304, /* GL_CW */
-+       116, /* GL_CCW */
-+       137, /* GL_COEFF */
-+      1019, /* GL_ORDER */
-+       344, /* GL_DOMAIN */
-+       279, /* GL_CURRENT_COLOR */
-+       282, /* GL_CURRENT_INDEX */
-+       288, /* GL_CURRENT_NORMAL */
-+       300, /* GL_CURRENT_TEXTURE_COORDS */
-+       293, /* GL_CURRENT_RASTER_COLOR */
-+       295, /* GL_CURRENT_RASTER_INDEX */
-+       298, /* GL_CURRENT_RASTER_TEXTURE_COORDS */
-+       296, /* GL_CURRENT_RASTER_POSITION */
-+       297, /* GL_CURRENT_RASTER_POSITION_VALID */
-+       294, /* GL_CURRENT_RASTER_DISTANCE */
-+      1091, /* GL_POINT_SMOOTH */
-+      1080, /* GL_POINT_SIZE */
-+      1090, /* GL_POINT_SIZE_RANGE */
-+      1081, /* GL_POINT_SIZE_GRANULARITY */
-+       649, /* GL_LINE_SMOOTH */
-+       656, /* GL_LINE_WIDTH */
-+       658, /* GL_LINE_WIDTH_RANGE */
-+       657, /* GL_LINE_WIDTH_GRANULARITY */
-+       651, /* GL_LINE_STIPPLE */
-+       652, /* GL_LINE_STIPPLE_PATTERN */
-+       653, /* GL_LINE_STIPPLE_REPEAT */
-+       663, /* GL_LIST_MODE */
-+       822, /* GL_MAX_LIST_NESTING */
-+       660, /* GL_LIST_BASE */
-+       662, /* GL_LIST_INDEX */
-+      1101, /* GL_POLYGON_MODE */
-+      1108, /* GL_POLYGON_SMOOTH */
-+      1110, /* GL_POLYGON_STIPPLE */
-+       414, /* GL_EDGE_FLAG */
-+       272, /* GL_CULL_FACE */
-+       273, /* GL_CULL_FACE_MODE */
-+       509, /* GL_FRONT_FACE */
-+       631, /* GL_LIGHTING */
-+       636, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
-+       637, /* GL_LIGHT_MODEL_TWO_SIDE */
-+       633, /* GL_LIGHT_MODEL_AMBIENT */
-+      1339, /* GL_SHADE_MODEL */
-+       168, /* GL_COLOR_MATERIAL_FACE */
-+       169, /* GL_COLOR_MATERIAL_PARAMETER */
-+       167, /* GL_COLOR_MATERIAL */
-+       457, /* GL_FOG */
-+       479, /* GL_FOG_INDEX */
-+       475, /* GL_FOG_DENSITY */
-+       483, /* GL_FOG_START */
-+       477, /* GL_FOG_END */
-+       480, /* GL_FOG_MODE */
-+       459, /* GL_FOG_COLOR */
-+       333, /* GL_DEPTH_RANGE */
-+       338, /* GL_DEPTH_TEST */
-+       341, /* GL_DEPTH_WRITEMASK */
-+       321, /* GL_DEPTH_CLEAR_VALUE */
-+       332, /* GL_DEPTH_FUNC */
-+        12, /* GL_ACCUM_CLEAR_VALUE */
-+      1418, /* GL_STENCIL_TEST */
-+      1406, /* GL_STENCIL_CLEAR_VALUE */
-+      1408, /* GL_STENCIL_FUNC */
-+      1420, /* GL_STENCIL_VALUE_MASK */
-+      1407, /* GL_STENCIL_FAIL */
-+      1415, /* GL_STENCIL_PASS_DEPTH_FAIL */
-+      1416, /* GL_STENCIL_PASS_DEPTH_PASS */
-+      1417, /* GL_STENCIL_REF */
-+      1421, /* GL_STENCIL_WRITEMASK */
-+       791, /* GL_MATRIX_MODE */
-+       958, /* GL_NORMALIZE */
-+      1727, /* GL_VIEWPORT */
-+       932, /* GL_MODELVIEW_STACK_DEPTH */
-+      1191, /* GL_PROJECTION_STACK_DEPTH */
-+      1616, /* GL_TEXTURE_STACK_DEPTH */
-+       930, /* GL_MODELVIEW_MATRIX */
-+      1190, /* GL_PROJECTION_MATRIX */
-+      1601, /* GL_TEXTURE_MATRIX */
-+        61, /* GL_ATTRIB_STACK_DEPTH */
-+       127, /* GL_CLIENT_ATTRIB_STACK_DEPTH */
-+        43, /* GL_ALPHA_TEST */
-+        44, /* GL_ALPHA_TEST_FUNC */
-+        45, /* GL_ALPHA_TEST_REF */
-+       343, /* GL_DITHER */
-+        78, /* GL_BLEND_DST */
-+        86, /* GL_BLEND_SRC */
-+        75, /* GL_BLEND */
-+       666, /* GL_LOGIC_OP_MODE */
-+       586, /* GL_INDEX_LOGIC_OP */
-+       166, /* GL_COLOR_LOGIC_OP */
-+        67, /* GL_AUX_BUFFERS */
-+       354, /* GL_DRAW_BUFFER */
-+      1223, /* GL_READ_BUFFER */
-+      1320, /* GL_SCISSOR_BOX */
-+      1321, /* GL_SCISSOR_TEST */
-+       585, /* GL_INDEX_CLEAR_VALUE */
-+       590, /* GL_INDEX_WRITEMASK */
-+       163, /* GL_COLOR_CLEAR_VALUE */
-+       205, /* GL_COLOR_WRITEMASK */
-+       587, /* GL_INDEX_MODE */
-+      1287, /* GL_RGBA_MODE */
-+       353, /* GL_DOUBLEBUFFER */
-+      1422, /* GL_STEREO */
-+      1246, /* GL_RENDER_MODE */
-+      1043, /* GL_PERSPECTIVE_CORRECTION_HINT */
-+      1092, /* GL_POINT_SMOOTH_HINT */
-+       650, /* GL_LINE_SMOOTH_HINT */
-+      1109, /* GL_POLYGON_SMOOTH_HINT */
-+       478, /* GL_FOG_HINT */
-+      1582, /* GL_TEXTURE_GEN_S */
-+      1583, /* GL_TEXTURE_GEN_T */
-+      1581, /* GL_TEXTURE_GEN_R */
-+      1580, /* GL_TEXTURE_GEN_Q */
-+      1056, /* GL_PIXEL_MAP_I_TO_I */
-+      1062, /* GL_PIXEL_MAP_S_TO_S */
-+      1058, /* GL_PIXEL_MAP_I_TO_R */
-+      1054, /* GL_PIXEL_MAP_I_TO_G */
-+      1052, /* GL_PIXEL_MAP_I_TO_B */
-+      1050, /* GL_PIXEL_MAP_I_TO_A */
-+      1060, /* GL_PIXEL_MAP_R_TO_R */
-+      1048, /* GL_PIXEL_MAP_G_TO_G */
-+      1046, /* GL_PIXEL_MAP_B_TO_B */
-+      1044, /* GL_PIXEL_MAP_A_TO_A */
-+      1057, /* GL_PIXEL_MAP_I_TO_I_SIZE */
-+      1063, /* GL_PIXEL_MAP_S_TO_S_SIZE */
-+      1059, /* GL_PIXEL_MAP_I_TO_R_SIZE */
-+      1055, /* GL_PIXEL_MAP_I_TO_G_SIZE */
-+      1053, /* GL_PIXEL_MAP_I_TO_B_SIZE */
-+      1051, /* GL_PIXEL_MAP_I_TO_A_SIZE */
-+      1061, /* GL_PIXEL_MAP_R_TO_R_SIZE */
-+      1049, /* GL_PIXEL_MAP_G_TO_G_SIZE */
-+      1047, /* GL_PIXEL_MAP_B_TO_B_SIZE */
-+      1045, /* GL_PIXEL_MAP_A_TO_A_SIZE */
-+      1649, /* GL_UNPACK_SWAP_BYTES */
-+      1644, /* GL_UNPACK_LSB_FIRST */
-+      1645, /* GL_UNPACK_ROW_LENGTH */
-+      1648, /* GL_UNPACK_SKIP_ROWS */
-+      1647, /* GL_UNPACK_SKIP_PIXELS */
-+      1642, /* GL_UNPACK_ALIGNMENT */
-+      1031, /* GL_PACK_SWAP_BYTES */
-+      1026, /* GL_PACK_LSB_FIRST */
-+      1027, /* GL_PACK_ROW_LENGTH */
-+      1030, /* GL_PACK_SKIP_ROWS */
-+      1029, /* GL_PACK_SKIP_PIXELS */
-+      1023, /* GL_PACK_ALIGNMENT */
-+       744, /* GL_MAP_COLOR */
-+       745, /* GL_MAP_STENCIL */
-+       589, /* GL_INDEX_SHIFT */
-+       588, /* GL_INDEX_OFFSET */
-+      1235, /* GL_RED_SCALE */
-+      1233, /* GL_RED_BIAS */
-+      1744, /* GL_ZOOM_X */
-+      1745, /* GL_ZOOM_Y */
-+       551, /* GL_GREEN_SCALE */
-+       549, /* GL_GREEN_BIAS */
-+        92, /* GL_BLUE_SCALE */
-+        90, /* GL_BLUE_BIAS */
-+        42, /* GL_ALPHA_SCALE */
-+        40, /* GL_ALPHA_BIAS */
-+       334, /* GL_DEPTH_SCALE */
-+       315, /* GL_DEPTH_BIAS */
-+       817, /* GL_MAX_EVAL_ORDER */
-+       821, /* GL_MAX_LIGHTS */
-+       800, /* GL_MAX_CLIP_PLANES */
-+       865, /* GL_MAX_TEXTURE_SIZE */
-+       827, /* GL_MAX_PIXEL_MAP_TABLE */
-+       796, /* GL_MAX_ATTRIB_STACK_DEPTH */
-+       824, /* GL_MAX_MODELVIEW_STACK_DEPTH */
-+       825, /* GL_MAX_NAME_STACK_DEPTH */
-+       853, /* GL_MAX_PROJECTION_STACK_DEPTH */
-+       866, /* GL_MAX_TEXTURE_STACK_DEPTH */
-+       880, /* GL_MAX_VIEWPORT_DIMS */
-+       797, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
-+      1429, /* GL_SUBPIXEL_BITS */
-+       584, /* GL_INDEX_BITS */
-+      1234, /* GL_RED_BITS */
-+       550, /* GL_GREEN_BITS */
-+        91, /* GL_BLUE_BITS */
-+        41, /* GL_ALPHA_BITS */
-+       316, /* GL_DEPTH_BITS */
-+      1404, /* GL_STENCIL_BITS */
-+        14, /* GL_ACCUM_RED_BITS */
-+        13, /* GL_ACCUM_GREEN_BITS */
-+        10, /* GL_ACCUM_BLUE_BITS */
-+         9, /* GL_ACCUM_ALPHA_BITS */
-+       946, /* GL_NAME_STACK_DEPTH */
-+        62, /* GL_AUTO_NORMAL */
-+       690, /* GL_MAP1_COLOR_4 */
-+       693, /* GL_MAP1_INDEX */
-+       694, /* GL_MAP1_NORMAL */
-+       695, /* GL_MAP1_TEXTURE_COORD_1 */
-+       696, /* GL_MAP1_TEXTURE_COORD_2 */
-+       697, /* GL_MAP1_TEXTURE_COORD_3 */
-+       698, /* GL_MAP1_TEXTURE_COORD_4 */
-+       699, /* GL_MAP1_VERTEX_3 */
-+       700, /* GL_MAP1_VERTEX_4 */
-+       717, /* GL_MAP2_COLOR_4 */
-+       720, /* GL_MAP2_INDEX */
-+       721, /* GL_MAP2_NORMAL */
-+       722, /* GL_MAP2_TEXTURE_COORD_1 */
-+       723, /* GL_MAP2_TEXTURE_COORD_2 */
-+       724, /* GL_MAP2_TEXTURE_COORD_3 */
-+       725, /* GL_MAP2_TEXTURE_COORD_4 */
-+       726, /* GL_MAP2_VERTEX_3 */
-+       727, /* GL_MAP2_VERTEX_4 */
-+       691, /* GL_MAP1_GRID_DOMAIN */
-+       692, /* GL_MAP1_GRID_SEGMENTS */
-+       718, /* GL_MAP2_GRID_DOMAIN */
-+       719, /* GL_MAP2_GRID_SEGMENTS */
-+      1506, /* GL_TEXTURE_1D */
-+      1508, /* GL_TEXTURE_2D */
-+       439, /* GL_FEEDBACK_BUFFER_POINTER */
-+       440, /* GL_FEEDBACK_BUFFER_SIZE */
-+       441, /* GL_FEEDBACK_BUFFER_TYPE */
-+      1330, /* GL_SELECTION_BUFFER_POINTER */
-+      1331, /* GL_SELECTION_BUFFER_SIZE */
-+      1619, /* GL_TEXTURE_WIDTH */
-+      1587, /* GL_TEXTURE_HEIGHT */
-+      1543, /* GL_TEXTURE_COMPONENTS */
-+      1527, /* GL_TEXTURE_BORDER_COLOR */
-+      1526, /* GL_TEXTURE_BORDER */
-+       345, /* GL_DONT_CARE */
-+       437, /* GL_FASTEST */
-+       954, /* GL_NICEST */
-+        47, /* GL_AMBIENT */
-+       342, /* GL_DIFFUSE */
-+      1373, /* GL_SPECULAR */
-+      1113, /* GL_POSITION */
-+      1376, /* GL_SPOT_DIRECTION */
-+      1377, /* GL_SPOT_EXPONENT */
-+      1375, /* GL_SPOT_CUTOFF */
-+       245, /* GL_CONSTANT_ATTENUATION */
-+       640, /* GL_LINEAR_ATTENUATION */
-+      1210, /* GL_QUADRATIC_ATTENUATION */
-+       219, /* GL_COMPILE */
-+       220, /* GL_COMPILE_AND_EXECUTE */
-+       111, /* GL_BYTE */
-+      1650, /* GL_UNSIGNED_BYTE */
-+      1344, /* GL_SHORT */
-+      1659, /* GL_UNSIGNED_SHORT */
-+       592, /* GL_INT */
-+      1653, /* GL_UNSIGNED_INT */
-+       444, /* GL_FLOAT */
-+         1, /* GL_2_BYTES */
-+         5, /* GL_3_BYTES */
-+         7, /* GL_4_BYTES */
-+       352, /* GL_DOUBLE */
-+       123, /* GL_CLEAR */
-+        49, /* GL_AND */
-+        51, /* GL_AND_REVERSE */
-+       269, /* GL_COPY */
-+        50, /* GL_AND_INVERTED */
-+       956, /* GL_NOOP */
-+      1740, /* GL_XOR */
-+      1018, /* GL_OR */
-+       957, /* GL_NOR */
-+       427, /* GL_EQUIV */
-+       618, /* GL_INVERT */
-+      1021, /* GL_OR_REVERSE */
-+       270, /* GL_COPY_INVERTED */
-+      1020, /* GL_OR_INVERTED */
-+       947, /* GL_NAND */
-+      1335, /* GL_SET */
-+       424, /* GL_EMISSION */
-+      1343, /* GL_SHININESS */
-+        48, /* GL_AMBIENT_AND_DIFFUSE */
-+       165, /* GL_COLOR_INDEXES */
-+       897, /* GL_MODELVIEW */
-+      1189, /* GL_PROJECTION */
-+      1441, /* GL_TEXTURE */
-+       138, /* GL_COLOR */
-+       313, /* GL_DEPTH */
-+      1395, /* GL_STENCIL */
-+       164, /* GL_COLOR_INDEX */
-+      1409, /* GL_STENCIL_INDEX */
-+       322, /* GL_DEPTH_COMPONENT */
-+      1230, /* GL_RED */
-+       548, /* GL_GREEN */
-+        89, /* GL_BLUE */
-+        31, /* GL_ALPHA */
-+      1254, /* GL_RGB */
-+      1273, /* GL_RGBA */
-+       668, /* GL_LUMINANCE */
-+       689, /* GL_LUMINANCE_ALPHA */
-+        73, /* GL_BITMAP */
-+      1069, /* GL_POINT */
-+       638, /* GL_LINE */
-+       442, /* GL_FILL */
-+      1239, /* GL_RENDER */
-+       438, /* GL_FEEDBACK */
-+      1329, /* GL_SELECT */
-+       443, /* GL_FLAT */
-+      1348, /* GL_SMOOTH */
-+       619, /* GL_KEEP */
-+      1248, /* GL_REPLACE */
-+       575, /* GL_INCR */
-+       309, /* GL_DECR */
-+      1674, /* GL_VENDOR */
-+      1245, /* GL_RENDERER */
-+      1675, /* GL_VERSION */
-+       431, /* GL_EXTENSIONS */
-+      1294, /* GL_S */
-+      1432, /* GL_T */
-+      1220, /* GL_R */
-+      1209, /* GL_Q */
-+       933, /* GL_MODULATE */
-+       308, /* GL_DECAL */
-+      1577, /* GL_TEXTURE_ENV_MODE */
-+      1576, /* GL_TEXTURE_ENV_COLOR */
-+      1575, /* GL_TEXTURE_ENV */
-+       432, /* GL_EYE_LINEAR */
-+       980, /* GL_OBJECT_LINEAR */
-+      1374, /* GL_SPHERE_MAP */
-+      1579, /* GL_TEXTURE_GEN_MODE */
-+       982, /* GL_OBJECT_PLANE */
-+       433, /* GL_EYE_PLANE */
-+       948, /* GL_NEAREST */
-+       639, /* GL_LINEAR */
-+       952, /* GL_NEAREST_MIPMAP_NEAREST */
-+       644, /* GL_LINEAR_MIPMAP_NEAREST */
-+       951, /* GL_NEAREST_MIPMAP_LINEAR */
-+       643, /* GL_LINEAR_MIPMAP_LINEAR */
-+      1600, /* GL_TEXTURE_MAG_FILTER */
-+      1608, /* GL_TEXTURE_MIN_FILTER */
-+      1621, /* GL_TEXTURE_WRAP_S */
-+      1622, /* GL_TEXTURE_WRAP_T */
-+       117, /* GL_CLAMP */
-+      1247, /* GL_REPEAT */
-+      1107, /* GL_POLYGON_OFFSET_UNITS */
-+      1106, /* GL_POLYGON_OFFSET_POINT */
-+      1105, /* GL_POLYGON_OFFSET_LINE */
-+      1221, /* GL_R3_G3_B2 */
-+      1671, /* GL_V2F */
-+      1672, /* GL_V3F */
-+       114, /* GL_C4UB_V2F */
-+       115, /* GL_C4UB_V3F */
-+       112, /* GL_C3F_V3F */
-+       945, /* GL_N3F_V3F */
-+       113, /* GL_C4F_N3F_V3F */
-+      1437, /* GL_T2F_V3F */
-+      1439, /* GL_T4F_V4F */
-+      1435, /* GL_T2F_C4UB_V3F */
-+      1433, /* GL_T2F_C3F_V3F */
-+      1436, /* GL_T2F_N3F_V3F */
-+      1434, /* GL_T2F_C4F_N3F_V3F */
-+      1438, /* GL_T4F_C4F_N3F_V4F */
-+       130, /* GL_CLIP_PLANE0 */
-+       131, /* GL_CLIP_PLANE1 */
-+       132, /* GL_CLIP_PLANE2 */
-+       133, /* GL_CLIP_PLANE3 */
-+       134, /* GL_CLIP_PLANE4 */
-+       135, /* GL_CLIP_PLANE5 */
-+       623, /* GL_LIGHT0 */
-+       624, /* GL_LIGHT1 */
-+       625, /* GL_LIGHT2 */
-+       626, /* GL_LIGHT3 */
-+       627, /* GL_LIGHT4 */
-+       628, /* GL_LIGHT5 */
-+       629, /* GL_LIGHT6 */
-+       630, /* GL_LIGHT7 */
-+       552, /* GL_HINT_BIT */
-+       247, /* GL_CONSTANT_COLOR */
-+       992, /* GL_ONE_MINUS_CONSTANT_COLOR */
-+       242, /* GL_CONSTANT_ALPHA */
-+       990, /* GL_ONE_MINUS_CONSTANT_ALPHA */
-+        76, /* GL_BLEND_COLOR */
-+       512, /* GL_FUNC_ADD */
-+       881, /* GL_MIN */
-+       793, /* GL_MAX */
-+        81, /* GL_BLEND_EQUATION */
-+       516, /* GL_FUNC_SUBTRACT */
-+       514, /* GL_FUNC_REVERSE_SUBTRACT */
-+       250, /* GL_CONVOLUTION_1D */
-+       251, /* GL_CONVOLUTION_2D */
-+      1332, /* GL_SEPARABLE_2D */
-+       254, /* GL_CONVOLUTION_BORDER_MODE */
-+       258, /* GL_CONVOLUTION_FILTER_SCALE */
-+       256, /* GL_CONVOLUTION_FILTER_BIAS */
-+      1231, /* GL_REDUCE */
-+       260, /* GL_CONVOLUTION_FORMAT */
-+       264, /* GL_CONVOLUTION_WIDTH */
-+       262, /* GL_CONVOLUTION_HEIGHT */
-+       808, /* GL_MAX_CONVOLUTION_WIDTH */
-+       806, /* GL_MAX_CONVOLUTION_HEIGHT */
-+      1146, /* GL_POST_CONVOLUTION_RED_SCALE */
-+      1142, /* GL_POST_CONVOLUTION_GREEN_SCALE */
-+      1137, /* GL_POST_CONVOLUTION_BLUE_SCALE */
-+      1133, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
-+      1144, /* GL_POST_CONVOLUTION_RED_BIAS */
-+      1140, /* GL_POST_CONVOLUTION_GREEN_BIAS */
-+      1135, /* GL_POST_CONVOLUTION_BLUE_BIAS */
-+      1131, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
-+       553, /* GL_HISTOGRAM */
-+      1193, /* GL_PROXY_HISTOGRAM */
-+       569, /* GL_HISTOGRAM_WIDTH */
-+       559, /* GL_HISTOGRAM_FORMAT */
-+       565, /* GL_HISTOGRAM_RED_SIZE */
-+       561, /* GL_HISTOGRAM_GREEN_SIZE */
-+       556, /* GL_HISTOGRAM_BLUE_SIZE */
-+       554, /* GL_HISTOGRAM_ALPHA_SIZE */
-+       563, /* GL_HISTOGRAM_LUMINANCE_SIZE */
-+       567, /* GL_HISTOGRAM_SINK */
-+       882, /* GL_MINMAX */
-+       884, /* GL_MINMAX_FORMAT */
-+       886, /* GL_MINMAX_SINK */
-+      1440, /* GL_TABLE_TOO_LARGE_EXT */
-+      1652, /* GL_UNSIGNED_BYTE_3_3_2 */
-+      1661, /* GL_UNSIGNED_SHORT_4_4_4_4 */
-+      1663, /* GL_UNSIGNED_SHORT_5_5_5_1 */
-+      1657, /* GL_UNSIGNED_INT_8_8_8_8 */
-+      1654, /* GL_UNSIGNED_INT_10_10_10_2 */
-+      1104, /* GL_POLYGON_OFFSET_FILL */
-+      1103, /* GL_POLYGON_OFFSET_FACTOR */
-+      1102, /* GL_POLYGON_OFFSET_BIAS */
-+      1251, /* GL_RESCALE_NORMAL */
-+        36, /* GL_ALPHA4 */
-+        38, /* GL_ALPHA8 */
-+        32, /* GL_ALPHA12 */
-+        34, /* GL_ALPHA16 */
-+       679, /* GL_LUMINANCE4 */
-+       685, /* GL_LUMINANCE8 */
-+       669, /* GL_LUMINANCE12 */
-+       675, /* GL_LUMINANCE16 */
-+       680, /* GL_LUMINANCE4_ALPHA4 */
-+       683, /* GL_LUMINANCE6_ALPHA2 */
-+       686, /* GL_LUMINANCE8_ALPHA8 */
-+       672, /* GL_LUMINANCE12_ALPHA4 */
-+       670, /* GL_LUMINANCE12_ALPHA12 */
-+       676, /* GL_LUMINANCE16_ALPHA16 */
-+       593, /* GL_INTENSITY */
-+       598, /* GL_INTENSITY4 */
-+       600, /* GL_INTENSITY8 */
-+       594, /* GL_INTENSITY12 */
-+       596, /* GL_INTENSITY16 */
-+      1263, /* GL_RGB2_EXT */
-+      1264, /* GL_RGB4 */
-+      1267, /* GL_RGB5 */
-+      1271, /* GL_RGB8 */
-+      1255, /* GL_RGB10 */
-+      1259, /* GL_RGB12 */
-+      1261, /* GL_RGB16 */
-+      1278, /* GL_RGBA2 */
-+      1280, /* GL_RGBA4 */
-+      1268, /* GL_RGB5_A1 */
-+      1284, /* GL_RGBA8 */
-+      1256, /* GL_RGB10_A2 */
-+      1274, /* GL_RGBA12 */
-+      1276, /* GL_RGBA16 */
-+      1613, /* GL_TEXTURE_RED_SIZE */
-+      1585, /* GL_TEXTURE_GREEN_SIZE */
-+      1524, /* GL_TEXTURE_BLUE_SIZE */
-+      1511, /* GL_TEXTURE_ALPHA_SIZE */
-+      1598, /* GL_TEXTURE_LUMINANCE_SIZE */
-+      1589, /* GL_TEXTURE_INTENSITY_SIZE */
-+      1249, /* GL_REPLACE_EXT */
-+      1197, /* GL_PROXY_TEXTURE_1D */
-+      1200, /* GL_PROXY_TEXTURE_2D */
-+      1617, /* GL_TEXTURE_TOO_LARGE_EXT */
-+      1610, /* GL_TEXTURE_PRIORITY */
-+      1615, /* GL_TEXTURE_RESIDENT */
-+      1514, /* GL_TEXTURE_BINDING_1D */
-+      1516, /* GL_TEXTURE_BINDING_2D */
-+      1518, /* GL_TEXTURE_BINDING_3D */
-+      1028, /* GL_PACK_SKIP_IMAGES */
-+      1024, /* GL_PACK_IMAGE_HEIGHT */
-+      1646, /* GL_UNPACK_SKIP_IMAGES */
-+      1643, /* GL_UNPACK_IMAGE_HEIGHT */
-+      1510, /* GL_TEXTURE_3D */
-+      1203, /* GL_PROXY_TEXTURE_3D */
-+      1572, /* GL_TEXTURE_DEPTH */
-+      1620, /* GL_TEXTURE_WRAP_R */
-+       794, /* GL_MAX_3D_TEXTURE_SIZE */
-+      1676, /* GL_VERTEX_ARRAY */
-+       959, /* GL_NORMAL_ARRAY */
-+       139, /* GL_COLOR_ARRAY */
-+       578, /* GL_INDEX_ARRAY */
-+      1551, /* GL_TEXTURE_COORD_ARRAY */
-+       415, /* GL_EDGE_FLAG_ARRAY */
-+      1681, /* GL_VERTEX_ARRAY_SIZE */
-+      1683, /* GL_VERTEX_ARRAY_TYPE */
-+      1682, /* GL_VERTEX_ARRAY_STRIDE */
-+       964, /* GL_NORMAL_ARRAY_TYPE */
-+       963, /* GL_NORMAL_ARRAY_STRIDE */
-+       143, /* GL_COLOR_ARRAY_SIZE */
-+       145, /* GL_COLOR_ARRAY_TYPE */
-+       144, /* GL_COLOR_ARRAY_STRIDE */
-+       583, /* GL_INDEX_ARRAY_TYPE */
-+       582, /* GL_INDEX_ARRAY_STRIDE */
-+      1555, /* GL_TEXTURE_COORD_ARRAY_SIZE */
-+      1557, /* GL_TEXTURE_COORD_ARRAY_TYPE */
-+      1556, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
-+       419, /* GL_EDGE_FLAG_ARRAY_STRIDE */
-+      1680, /* GL_VERTEX_ARRAY_POINTER */
-+       962, /* GL_NORMAL_ARRAY_POINTER */
-+       142, /* GL_COLOR_ARRAY_POINTER */
-+       581, /* GL_INDEX_ARRAY_POINTER */
-+      1554, /* GL_TEXTURE_COORD_ARRAY_POINTER */
-+       418, /* GL_EDGE_FLAG_ARRAY_POINTER */
-+       938, /* GL_MULTISAMPLE */
-+      1306, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
-+      1308, /* GL_SAMPLE_ALPHA_TO_ONE */
-+      1313, /* GL_SAMPLE_COVERAGE */
-+      1310, /* GL_SAMPLE_BUFFERS */
-+      1301, /* GL_SAMPLES */
-+      1317, /* GL_SAMPLE_COVERAGE_VALUE */
-+      1315, /* GL_SAMPLE_COVERAGE_INVERT */
-+       170, /* GL_COLOR_MATRIX */
-+       172, /* GL_COLOR_MATRIX_STACK_DEPTH */
-+       802, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
-+      1129, /* GL_POST_COLOR_MATRIX_RED_SCALE */
-+      1125, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
-+      1120, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
-+      1116, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
-+      1127, /* GL_POST_COLOR_MATRIX_RED_BIAS */
-+      1123, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
-+      1118, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
-+      1114, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
-+      1534, /* GL_TEXTURE_COLOR_TABLE_SGI */
-+      1204, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
-+      1536, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
-+        80, /* GL_BLEND_DST_RGB */
-+        88, /* GL_BLEND_SRC_RGB */
-+        79, /* GL_BLEND_DST_ALPHA */
-+        87, /* GL_BLEND_SRC_ALPHA */
-+       176, /* GL_COLOR_TABLE */
-+      1139, /* GL_POST_CONVOLUTION_COLOR_TABLE */
-+      1122, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
-+      1192, /* GL_PROXY_COLOR_TABLE */
-+      1196, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
-+      1195, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
-+       200, /* GL_COLOR_TABLE_SCALE */
-+       180, /* GL_COLOR_TABLE_BIAS */
-+       185, /* GL_COLOR_TABLE_FORMAT */
-+       202, /* GL_COLOR_TABLE_WIDTH */
-+       197, /* GL_COLOR_TABLE_RED_SIZE */
-+       188, /* GL_COLOR_TABLE_GREEN_SIZE */
-+       182, /* GL_COLOR_TABLE_BLUE_SIZE */
-+       177, /* GL_COLOR_TABLE_ALPHA_SIZE */
-+       194, /* GL_COLOR_TABLE_LUMINANCE_SIZE */
-+       191, /* GL_COLOR_TABLE_INTENSITY_SIZE */
-+        71, /* GL_BGR */
-+        72, /* GL_BGRA */
-+       816, /* GL_MAX_ELEMENTS_VERTICES */
-+       815, /* GL_MAX_ELEMENTS_INDICES */
-+      1588, /* GL_TEXTURE_INDEX_SIZE_EXT */
-+       136, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */
-+      1086, /* GL_POINT_SIZE_MIN */
-+      1082, /* GL_POINT_SIZE_MAX */
-+      1076, /* GL_POINT_FADE_THRESHOLD_SIZE */
-+      1072, /* GL_POINT_DISTANCE_ATTENUATION */
-+       118, /* GL_CLAMP_TO_BORDER */
-+       121, /* GL_CLAMP_TO_EDGE */
-+      1609, /* GL_TEXTURE_MIN_LOD */
-+      1607, /* GL_TEXTURE_MAX_LOD */
-+      1513, /* GL_TEXTURE_BASE_LEVEL */
-+      1606, /* GL_TEXTURE_MAX_LEVEL */
-+       572, /* GL_IGNORE_BORDER_HP */
-+       246, /* GL_CONSTANT_BORDER_HP */
-+      1250, /* GL_REPLICATE_BORDER_HP */
-+       252, /* GL_CONVOLUTION_BORDER_COLOR */
-+       987, /* GL_OCCLUSION_TEST_HP */
-+       988, /* GL_OCCLUSION_TEST_RESULT_HP */
-+       641, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
-+      1528, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
-+      1530, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
-+      1532, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
-+      1533, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-+      1531, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
-+      1529, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
-+       798, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
-+       799, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-+      1149, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
-+      1151, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
-+      1148, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
-+      1150, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
-+      1596, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
-+      1597, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
-+      1595, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
-+       518, /* GL_GENERATE_MIPMAP */
-+       519, /* GL_GENERATE_MIPMAP_HINT */
-+       481, /* GL_FOG_OFFSET_SGIX */
-+       482, /* GL_FOG_OFFSET_VALUE_SGIX */
-+      1542, /* GL_TEXTURE_COMPARE_SGIX */
-+      1541, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
-+      1592, /* GL_TEXTURE_LEQUAL_R_SGIX */
-+      1584, /* GL_TEXTURE_GEQUAL_R_SGIX */
-+       323, /* GL_DEPTH_COMPONENT16 */
-+       326, /* GL_DEPTH_COMPONENT24 */
-+       329, /* GL_DEPTH_COMPONENT32 */
-+       274, /* GL_CULL_VERTEX_EXT */
-+       276, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */
-+       275, /* GL_CULL_VERTEX_EYE_POSITION_EXT */
-+      1737, /* GL_WRAP_BORDER_SUN */
-+      1535, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
-+       634, /* GL_LIGHT_MODEL_COLOR_CONTROL */
-+      1345, /* GL_SINGLE_COLOR */
-+      1333, /* GL_SEPARATE_SPECULAR_COLOR */
-+      1342, /* GL_SHARED_TEXTURE_PALETTE_EXT */
-+      1651, /* GL_UNSIGNED_BYTE_2_3_3_REV */
-+      1664, /* GL_UNSIGNED_SHORT_5_6_5 */
-+      1665, /* GL_UNSIGNED_SHORT_5_6_5_REV */
-+      1662, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
-+      1660, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
-+      1658, /* GL_UNSIGNED_INT_8_8_8_8_REV */
-+      1656, /* GL_UNSIGNED_INT_2_10_10_10_REV */
-+      1604, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
-+      1605, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
-+      1603, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
-+       889, /* GL_MIRRORED_REPEAT */
-+      1289, /* GL_RGB_S3TC */
-+      1266, /* GL_RGB4_S3TC */
-+      1288, /* GL_RGBA_S3TC */
-+      1283, /* GL_RGBA4_S3TC */
-+      1286, /* GL_RGBA_DXT5_S3TC */
-+      1281, /* GL_RGBA4_DXT5_S3TC */
-+       239, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */
-+       234, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */
-+       235, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */
-+       236, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */
-+       950, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
-+       949, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
-+       642, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
-+       468, /* GL_FOG_COORDINATE_SOURCE */
-+       460, /* GL_FOG_COORD */
-+       484, /* GL_FRAGMENT_DEPTH */
-+       280, /* GL_CURRENT_FOG_COORD */
-+       467, /* GL_FOG_COORDINATE_ARRAY_TYPE */
-+       466, /* GL_FOG_COORDINATE_ARRAY_STRIDE */
-+       465, /* GL_FOG_COORDINATE_ARRAY_POINTER */
-+       462, /* GL_FOG_COORDINATE_ARRAY */
-+       174, /* GL_COLOR_SUM */
-+       299, /* GL_CURRENT_SECONDARY_COLOR */
-+      1326, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
-+      1328, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
-+      1327, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
-+      1325, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
-+      1322, /* GL_SECONDARY_COLOR_ARRAY */
-+       528, /* GL_GL_CURRENT_RASTER_SECONDARY_COLOR */
-+        28, /* GL_ALIASED_POINT_SIZE_RANGE */
-+        27, /* GL_ALIASED_LINE_WIDTH_RANGE */
-+      1442, /* GL_TEXTURE0 */
-+      1444, /* GL_TEXTURE1 */
-+      1466, /* GL_TEXTURE2 */
-+      1488, /* GL_TEXTURE3 */
-+      1494, /* GL_TEXTURE4 */
-+      1496, /* GL_TEXTURE5 */
-+      1498, /* GL_TEXTURE6 */
-+      1500, /* GL_TEXTURE7 */
-+      1502, /* GL_TEXTURE8 */
-+      1504, /* GL_TEXTURE9 */
-+      1445, /* GL_TEXTURE10 */
-+      1447, /* GL_TEXTURE11 */
-+      1449, /* GL_TEXTURE12 */
-+      1451, /* GL_TEXTURE13 */
-+      1453, /* GL_TEXTURE14 */
-+      1455, /* GL_TEXTURE15 */
-+      1457, /* GL_TEXTURE16 */
-+      1459, /* GL_TEXTURE17 */
-+      1461, /* GL_TEXTURE18 */
-+      1463, /* GL_TEXTURE19 */
-+      1467, /* GL_TEXTURE20 */
-+      1469, /* GL_TEXTURE21 */
-+      1471, /* GL_TEXTURE22 */
-+      1473, /* GL_TEXTURE23 */
-+      1475, /* GL_TEXTURE24 */
-+      1477, /* GL_TEXTURE25 */
-+      1479, /* GL_TEXTURE26 */
-+      1481, /* GL_TEXTURE27 */
-+      1483, /* GL_TEXTURE28 */
-+      1485, /* GL_TEXTURE29 */
-+      1489, /* GL_TEXTURE30 */
-+      1491, /* GL_TEXTURE31 */
-+        18, /* GL_ACTIVE_TEXTURE */
-+       124, /* GL_CLIENT_ACTIVE_TEXTURE */
-+       867, /* GL_MAX_TEXTURE_UNITS */
-+      1630, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
-+      1633, /* GL_TRANSPOSE_PROJECTION_MATRIX */
-+      1635, /* GL_TRANSPOSE_TEXTURE_MATRIX */
-+      1627, /* GL_TRANSPOSE_COLOR_MATRIX */
-+      1430, /* GL_SUBTRACT */
-+       856, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
-+       222, /* GL_COMPRESSED_ALPHA */
-+       226, /* GL_COMPRESSED_LUMINANCE */
-+       227, /* GL_COMPRESSED_LUMINANCE_ALPHA */
-+       224, /* GL_COMPRESSED_INTENSITY */
-+       230, /* GL_COMPRESSED_RGB */
-+       231, /* GL_COMPRESSED_RGBA */
-+      1549, /* GL_TEXTURE_COMPRESSION_HINT */
-+      1611, /* GL_TEXTURE_RECTANGLE_ARB */
-+      1521, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
-+      1207, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
-+       854, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
-+       335, /* GL_DEPTH_STENCIL_NV */
-+      1655, /* GL_UNSIGNED_INT_24_8_NV */
-+       863, /* GL_MAX_TEXTURE_LOD_BIAS */
-+      1602, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
-+       864, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
-+      1578, /* GL_TEXTURE_FILTER_CONTROL */
-+      1593, /* GL_TEXTURE_LOD_BIAS */
-+       207, /* GL_COMBINE4 */
-+       857, /* GL_MAX_SHININESS_NV */
-+       858, /* GL_MAX_SPOT_EXPONENT_NV */
-+       576, /* GL_INCR_WRAP */
-+       310, /* GL_DECR_WRAP */
-+       909, /* GL_MODELVIEW1_ARB */
-+       965, /* GL_NORMAL_MAP */
-+      1236, /* GL_REFLECTION_MAP */
-+      1558, /* GL_TEXTURE_CUBE_MAP */
-+      1519, /* GL_TEXTURE_BINDING_CUBE_MAP */
-+      1566, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
-+      1560, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
-+      1568, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
-+      1562, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
-+      1570, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
-+      1564, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
-+      1205, /* GL_PROXY_TEXTURE_CUBE_MAP */
-+       810, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
-+       944, /* GL_MULTISAMPLE_FILTER_HINT_NV */
-+       476, /* GL_FOG_DISTANCE_MODE_NV */
-+       435, /* GL_EYE_RADIAL_NV */
-+       434, /* GL_EYE_PLANE_ABSOLUTE_NV */
-+       206, /* GL_COMBINE */
-+       213, /* GL_COMBINE_RGB */
-+       208, /* GL_COMBINE_ALPHA */
-+      1290, /* GL_RGB_SCALE */
-+        24, /* GL_ADD_SIGNED */
-+       603, /* GL_INTERPOLATE */
-+       241, /* GL_CONSTANT */
-+      1155, /* GL_PRIMARY_COLOR */
-+      1152, /* GL_PREVIOUS */
-+      1356, /* GL_SOURCE0_RGB */
-+      1362, /* GL_SOURCE1_RGB */
-+      1368, /* GL_SOURCE2_RGB */
-+      1372, /* GL_SOURCE3_RGB_NV */
-+      1353, /* GL_SOURCE0_ALPHA */
-+      1359, /* GL_SOURCE1_ALPHA */
-+      1365, /* GL_SOURCE2_ALPHA */
-+      1371, /* GL_SOURCE3_ALPHA_NV */
-+      1001, /* GL_OPERAND0_RGB */
-+      1007, /* GL_OPERAND1_RGB */
-+      1013, /* GL_OPERAND2_RGB */
-+      1017, /* GL_OPERAND3_RGB_NV */
-+       998, /* GL_OPERAND0_ALPHA */
-+      1004, /* GL_OPERAND1_ALPHA */
-+      1010, /* GL_OPERAND2_ALPHA */
-+      1016, /* GL_OPERAND3_ALPHA_NV */
-+      1677, /* GL_VERTEX_ARRAY_BINDING_APPLE */
-+      1741, /* GL_YCBCR_422_APPLE */
-+      1666, /* GL_UNSIGNED_SHORT_8_8_APPLE */
-+      1668, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
-+      1347, /* GL_SLICE_ACCUM_SUN */
-+      1212, /* GL_QUAD_MESH_SUN */
-+      1639, /* GL_TRIANGLE_MESH_SUN */
-+      1715, /* GL_VERTEX_PROGRAM_ARB */
-+      1726, /* GL_VERTEX_STATE_PROGRAM_NV */
-+      1702, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
-+      1708, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
-+      1710, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
-+      1712, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
-+       301, /* GL_CURRENT_VERTEX_ATTRIB */
-+      1168, /* GL_PROGRAM_LENGTH_ARB */
-+      1182, /* GL_PROGRAM_STRING_ARB */
-+       931, /* GL_MODELVIEW_PROJECTION_NV */
-+       571, /* GL_IDENTITY_NV */
-+       616, /* GL_INVERSE_NV */
-+      1632, /* GL_TRANSPOSE_NV */
-+       617, /* GL_INVERSE_TRANSPOSE_NV */
-+       840, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
-+       839, /* GL_MAX_PROGRAM_MATRICES_ARB */
-+       747, /* GL_MATRIX0_NV */
-+       759, /* GL_MATRIX1_NV */
-+       771, /* GL_MATRIX2_NV */
-+       775, /* GL_MATRIX3_NV */
-+       777, /* GL_MATRIX4_NV */
-+       779, /* GL_MATRIX5_NV */
-+       781, /* GL_MATRIX6_NV */
-+       783, /* GL_MATRIX7_NV */
-+       286, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */
-+       283, /* GL_CURRENT_MATRIX_ARB */
-+      1718, /* GL_VERTEX_PROGRAM_POINT_SIZE */
-+      1721, /* GL_VERTEX_PROGRAM_TWO_SIDE */
-+      1180, /* GL_PROGRAM_PARAMETER_NV */
-+      1706, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
-+      1184, /* GL_PROGRAM_TARGET_NV */
-+      1181, /* GL_PROGRAM_RESIDENT_NV */
-+      1624, /* GL_TRACK_MATRIX_NV */
-+      1625, /* GL_TRACK_MATRIX_TRANSFORM_NV */
-+      1716, /* GL_VERTEX_PROGRAM_BINDING_NV */
-+      1162, /* GL_PROGRAM_ERROR_POSITION_ARB */
-+       320, /* GL_DEPTH_CLAMP_NV */
-+      1684, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
-+      1691, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
-+      1692, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
-+      1693, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
-+      1694, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
-+      1695, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
-+      1696, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
-+      1697, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
-+      1698, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
-+      1699, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
-+      1685, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
-+      1686, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
-+      1687, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
-+      1688, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
-+      1689, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
-+      1690, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
-+       701, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
-+       708, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
-+       709, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
-+       710, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
-+       711, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
-+       712, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
-+       713, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
-+       714, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
-+       715, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
-+       716, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
-+       702, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
-+       703, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
-+       704, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
-+       705, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
-+       706, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
-+       707, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
-+       728, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
-+       735, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
-+       736, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
-+       737, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
-+       738, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
-+       739, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
-+       740, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
-+      1161, /* GL_PROGRAM_BINDING_ARB */
-+       742, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
-+       743, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
-+       729, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
-+       730, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
-+       731, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
-+       732, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
-+       733, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
-+       734, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
-+      1547, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
-+      1544, /* GL_TEXTURE_COMPRESSED */
-+       970, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
-+       240, /* GL_COMPRESSED_TEXTURE_FORMATS */
-+       879, /* GL_MAX_VERTEX_UNITS_ARB */
-+        22, /* GL_ACTIVE_VERTEX_UNITS_ARB */
-+      1736, /* GL_WEIGHT_SUM_UNITY_ARB */
-+      1714, /* GL_VERTEX_BLEND_ARB */
-+       303, /* GL_CURRENT_WEIGHT_ARB */
-+      1735, /* GL_WEIGHT_ARRAY_TYPE_ARB */
-+      1734, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
-+      1733, /* GL_WEIGHT_ARRAY_SIZE_ARB */
-+      1732, /* GL_WEIGHT_ARRAY_POINTER_ARB */
-+      1729, /* GL_WEIGHT_ARRAY_ARB */
-+       346, /* GL_DOT3_RGB */
-+       347, /* GL_DOT3_RGBA */
-+       238, /* GL_COMPRESSED_RGB_FXT1_3DFX */
-+       233, /* GL_COMPRESSED_RGBA_FXT1_3DFX */
-+       939, /* GL_MULTISAMPLE_3DFX */
-+      1311, /* GL_SAMPLE_BUFFERS_3DFX */
-+      1302, /* GL_SAMPLES_3DFX */
-+       920, /* GL_MODELVIEW2_ARB */
-+       923, /* GL_MODELVIEW3_ARB */
-+       924, /* GL_MODELVIEW4_ARB */
-+       925, /* GL_MODELVIEW5_ARB */
-+       926, /* GL_MODELVIEW6_ARB */
-+       927, /* GL_MODELVIEW7_ARB */
-+       928, /* GL_MODELVIEW8_ARB */
-+       929, /* GL_MODELVIEW9_ARB */
-+       899, /* GL_MODELVIEW10_ARB */
-+       900, /* GL_MODELVIEW11_ARB */
-+       901, /* GL_MODELVIEW12_ARB */
-+       902, /* GL_MODELVIEW13_ARB */
-+       903, /* GL_MODELVIEW14_ARB */
-+       904, /* GL_MODELVIEW15_ARB */
-+       905, /* GL_MODELVIEW16_ARB */
-+       906, /* GL_MODELVIEW17_ARB */
-+       907, /* GL_MODELVIEW18_ARB */
-+       908, /* GL_MODELVIEW19_ARB */
-+       910, /* GL_MODELVIEW20_ARB */
-+       911, /* GL_MODELVIEW21_ARB */
-+       912, /* GL_MODELVIEW22_ARB */
-+       913, /* GL_MODELVIEW23_ARB */
-+       914, /* GL_MODELVIEW24_ARB */
-+       915, /* GL_MODELVIEW25_ARB */
-+       916, /* GL_MODELVIEW26_ARB */
-+       917, /* GL_MODELVIEW27_ARB */
-+       918, /* GL_MODELVIEW28_ARB */
-+       919, /* GL_MODELVIEW29_ARB */
-+       921, /* GL_MODELVIEW30_ARB */
-+       922, /* GL_MODELVIEW31_ARB */
-+       351, /* GL_DOT3_RGB_EXT */
-+       349, /* GL_DOT3_RGBA_EXT */
-+       893, /* GL_MIRROR_CLAMP_EXT */
-+       896, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
-+       934, /* GL_MODULATE_ADD_ATI */
-+       935, /* GL_MODULATE_SIGNED_ADD_ATI */
-+       936, /* GL_MODULATE_SUBTRACT_ATI */
-+      1742, /* GL_YCBCR_MESA */
-+      1025, /* GL_PACK_INVERT_MESA */
-+       306, /* GL_DEBUG_OBJECT_MESA */
-+       307, /* GL_DEBUG_PRINT_MESA */
-+       305, /* GL_DEBUG_ASSERT_MESA */
-+       107, /* GL_BUFFER_SIZE */
-+       109, /* GL_BUFFER_USAGE */
-+      1398, /* GL_STENCIL_BACK_FUNC */
-+      1397, /* GL_STENCIL_BACK_FAIL */
-+      1399, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
-+      1400, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
-+       485, /* GL_FRAGMENT_PROGRAM_ARB */
-+      1159, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
-+      1187, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
-+      1186, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
-+      1171, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-+      1177, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-+      1176, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-+       829, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
-+       852, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
-+       851, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
-+       842, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-+       848, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-+       847, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-+       812, /* GL_MAX_DRAW_BUFFERS */
-+       355, /* GL_DRAW_BUFFER0 */
-+       358, /* GL_DRAW_BUFFER1 */
-+       379, /* GL_DRAW_BUFFER2 */
-+       382, /* GL_DRAW_BUFFER3 */
-+       385, /* GL_DRAW_BUFFER4 */
-+       388, /* GL_DRAW_BUFFER5 */
-+       391, /* GL_DRAW_BUFFER6 */
-+       394, /* GL_DRAW_BUFFER7 */
-+       397, /* GL_DRAW_BUFFER8 */
-+       400, /* GL_DRAW_BUFFER9 */
-+       359, /* GL_DRAW_BUFFER10 */
-+       362, /* GL_DRAW_BUFFER11 */
-+       365, /* GL_DRAW_BUFFER12 */
-+       368, /* GL_DRAW_BUFFER13 */
-+       371, /* GL_DRAW_BUFFER14 */
-+       374, /* GL_DRAW_BUFFER15 */
-+        82, /* GL_BLEND_EQUATION_ALPHA */
-+       792, /* GL_MATRIX_PALETTE_ARB */
-+       823, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
-+       826, /* GL_MAX_PALETTE_MATRICES_ARB */
-+       289, /* GL_CURRENT_PALETTE_MATRIX_ARB */
-+       786, /* GL_MATRIX_INDEX_ARRAY_ARB */
-+       284, /* GL_CURRENT_MATRIX_INDEX_ARB */
-+       788, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
-+       790, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
-+       789, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
-+       787, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
-+      1573, /* GL_TEXTURE_DEPTH_SIZE */
-+       339, /* GL_DEPTH_TEXTURE_MODE */
-+      1539, /* GL_TEXTURE_COMPARE_MODE */
-+      1537, /* GL_TEXTURE_COMPARE_FUNC */
-+       217, /* GL_COMPARE_R_TO_TEXTURE */
-+      1093, /* GL_POINT_SPRITE */
-+       266, /* GL_COORD_REPLACE */
-+      1097, /* GL_POINT_SPRITE_R_MODE_NV */
-+      1214, /* GL_QUERY_COUNTER_BITS */
-+       291, /* GL_CURRENT_QUERY */
-+      1216, /* GL_QUERY_RESULT */
-+      1218, /* GL_QUERY_RESULT_AVAILABLE */
-+       873, /* GL_MAX_VERTEX_ATTRIBS */
-+      1704, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
-+       337, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
-+       336, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
-+       859, /* GL_MAX_TEXTURE_COORDS */
-+       861, /* GL_MAX_TEXTURE_IMAGE_UNITS */
-+      1164, /* GL_PROGRAM_ERROR_STRING_ARB */
-+      1166, /* GL_PROGRAM_FORMAT_ASCII_ARB */
-+      1165, /* GL_PROGRAM_FORMAT_ARB */
-+      1618, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
-+       318, /* GL_DEPTH_BOUNDS_TEST_EXT */
-+       317, /* GL_DEPTH_BOUNDS_EXT */
-+        52, /* GL_ARRAY_BUFFER */
-+       420, /* GL_ELEMENT_ARRAY_BUFFER */
-+        54, /* GL_ARRAY_BUFFER_BINDING */
-+       422, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
-+      1678, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
-+       960, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
-+       140, /* GL_COLOR_ARRAY_BUFFER_BINDING */
-+       579, /* GL_INDEX_ARRAY_BUFFER_BINDING */
-+      1552, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
-+       416, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
-+      1323, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
-+       463, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
-+      1730, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
-+      1700, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
-+      1167, /* GL_PROGRAM_INSTRUCTIONS_ARB */
-+       835, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
-+      1173, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-+       844, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-+      1185, /* GL_PROGRAM_TEMPORARIES_ARB */
-+       850, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
-+      1175, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
-+       846, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
-+      1179, /* GL_PROGRAM_PARAMETERS_ARB */
-+       849, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
-+      1174, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
-+       845, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
-+      1160, /* GL_PROGRAM_ATTRIBS_ARB */
-+       830, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
-+      1172, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
-+       843, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
-+      1158, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
-+       828, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
-+      1170, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-+       841, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-+       836, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
-+       832, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
-+      1188, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
-+      1629, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
-+      1226, /* GL_READ_ONLY */
-+      1738, /* GL_WRITE_ONLY */
-+      1228, /* GL_READ_WRITE */
-+       101, /* GL_BUFFER_ACCESS */
-+       103, /* GL_BUFFER_MAPPED */
-+       105, /* GL_BUFFER_MAP_POINTER */
-+      1623, /* GL_TIME_ELAPSED_EXT */
-+       746, /* GL_MATRIX0_ARB */
-+       758, /* GL_MATRIX1_ARB */
-+       770, /* GL_MATRIX2_ARB */
-+       774, /* GL_MATRIX3_ARB */
-+       776, /* GL_MATRIX4_ARB */
-+       778, /* GL_MATRIX5_ARB */
-+       780, /* GL_MATRIX6_ARB */
-+       782, /* GL_MATRIX7_ARB */
-+       784, /* GL_MATRIX8_ARB */
-+       785, /* GL_MATRIX9_ARB */
-+       748, /* GL_MATRIX10_ARB */
-+       749, /* GL_MATRIX11_ARB */
-+       750, /* GL_MATRIX12_ARB */
-+       751, /* GL_MATRIX13_ARB */
-+       752, /* GL_MATRIX14_ARB */
-+       753, /* GL_MATRIX15_ARB */
-+       754, /* GL_MATRIX16_ARB */
-+       755, /* GL_MATRIX17_ARB */
-+       756, /* GL_MATRIX18_ARB */
-+       757, /* GL_MATRIX19_ARB */
-+       760, /* GL_MATRIX20_ARB */
-+       761, /* GL_MATRIX21_ARB */
-+       762, /* GL_MATRIX22_ARB */
-+       763, /* GL_MATRIX23_ARB */
-+       764, /* GL_MATRIX24_ARB */
-+       765, /* GL_MATRIX25_ARB */
-+       766, /* GL_MATRIX26_ARB */
-+       767, /* GL_MATRIX27_ARB */
-+       768, /* GL_MATRIX28_ARB */
-+       769, /* GL_MATRIX29_ARB */
-+       772, /* GL_MATRIX30_ARB */
-+       773, /* GL_MATRIX31_ARB */
-+      1425, /* GL_STREAM_DRAW */
-+      1427, /* GL_STREAM_READ */
-+      1423, /* GL_STREAM_COPY */
-+      1391, /* GL_STATIC_DRAW */
-+      1393, /* GL_STATIC_READ */
-+      1389, /* GL_STATIC_COPY */
-+       410, /* GL_DYNAMIC_DRAW */
-+       412, /* GL_DYNAMIC_READ */
-+       408, /* GL_DYNAMIC_COPY */
-+       535, /* GL_GL_PIXEL_PACK_BUFFER */
-+       537, /* GL_GL_PIXEL_UNPACK_BUFFER */
-+       536, /* GL_GL_PIXEL_PACK_BUFFER_BINDING */
-+       538, /* GL_GL_PIXEL_UNPACK_BUFFER_BINDING */
-+       833, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */
-+       831, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
-+       834, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
-+       838, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
-+       837, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
-+       795, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
-+      1419, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
-+        17, /* GL_ACTIVE_STENCIL_FACE_EXT */
-+       894, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
-+      1304, /* GL_SAMPLES_PASSED */
-+       486, /* GL_FRAGMENT_SHADER */
-+      1724, /* GL_VERTEX_SHADER */
-+      1178, /* GL_PROGRAM_OBJECT_ARB */
-+      1336, /* GL_SHADER_OBJECT_ARB */
-+       819, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
-+       877, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
-+       871, /* GL_MAX_VARYING_FLOATS */
-+       875, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
-+       804, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
-+       985, /* GL_OBJECT_TYPE_ARB */
-+      1338, /* GL_SHADER_TYPE */
-+       451, /* GL_FLOAT_VEC2 */
-+       453, /* GL_FLOAT_VEC3 */
-+       455, /* GL_FLOAT_VEC4 */
-+       606, /* GL_INT_VEC2 */
-+       608, /* GL_INT_VEC3 */
-+       610, /* GL_INT_VEC4 */
-+        93, /* GL_BOOL */
-+        95, /* GL_BOOL_VEC2 */
-+        97, /* GL_BOOL_VEC3 */
-+        99, /* GL_BOOL_VEC4 */
-+       445, /* GL_FLOAT_MAT2 */
-+       447, /* GL_FLOAT_MAT3 */
-+       449, /* GL_FLOAT_MAT4 */
-+      1295, /* GL_SAMPLER_1D */
-+      1297, /* GL_SAMPLER_2D */
-+      1299, /* GL_SAMPLER_3D */
-+      1300, /* GL_SAMPLER_CUBE */
-+      1296, /* GL_SAMPLER_1D_SHADOW */
-+      1298, /* GL_SAMPLER_2D_SHADOW */
-+       529, /* GL_GL_FLOAT_MAT2x3 */
-+       530, /* GL_GL_FLOAT_MAT2x4 */
-+       531, /* GL_GL_FLOAT_MAT3x2 */
-+       532, /* GL_GL_FLOAT_MAT3x4 */
-+       533, /* GL_GL_FLOAT_MAT4x2 */
-+       534, /* GL_GL_FLOAT_MAT4x3 */
-+       312, /* GL_DELETE_STATUS */
-+       221, /* GL_COMPILE_STATUS */
-+       659, /* GL_LINK_STATUS */
-+      1673, /* GL_VALIDATE_STATUS */
-+       591, /* GL_INFO_LOG_LENGTH */
-+        56, /* GL_ATTACHED_SHADERS */
-+        20, /* GL_ACTIVE_UNIFORMS */
-+        21, /* GL_ACTIVE_UNIFORM_MAX_LENGTH */
-+      1337, /* GL_SHADER_SOURCE_LENGTH */
-+        15, /* GL_ACTIVE_ATTRIBUTES */
-+        16, /* GL_ACTIVE_ATTRIBUTE_MAX_LENGTH */
-+       488, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */
-+      1340, /* GL_SHADING_LANGUAGE_VERSION */
-+       290, /* GL_CURRENT_PROGRAM */
-+      1034, /* GL_PALETTE4_RGB8_OES */
-+      1036, /* GL_PALETTE4_RGBA8_OES */
-+      1032, /* GL_PALETTE4_R5_G6_B5_OES */
-+      1035, /* GL_PALETTE4_RGBA4_OES */
-+      1033, /* GL_PALETTE4_RGB5_A1_OES */
-+      1039, /* GL_PALETTE8_RGB8_OES */
-+      1041, /* GL_PALETTE8_RGBA8_OES */
-+      1037, /* GL_PALETTE8_R5_G6_B5_OES */
-+      1040, /* GL_PALETTE8_RGBA4_OES */
-+      1038, /* GL_PALETTE8_RGB5_A1_OES */
-+       574, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
-+       573, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
-+      1507, /* GL_TEXTURE_1D_ARRAY_EXT */
-+      1198, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
-+      1509, /* GL_TEXTURE_2D_ARRAY_EXT */
-+      1201, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
-+      1515, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
-+      1517, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
-+       543, /* GL_GL_SRGB */
-+       544, /* GL_GL_SRGB8 */
-+       546, /* GL_GL_SRGB_ALPHA */
-+       545, /* GL_GL_SRGB8_ALPHA8 */
-+       542, /* GL_GL_SLUMINANCE_ALPHA */
-+       541, /* GL_GL_SLUMINANCE8_ALPHA8 */
-+       539, /* GL_GL_SLUMINANCE */
-+       540, /* GL_GL_SLUMINANCE8 */
-+       526, /* GL_GL_COMPRESSED_SRGB */
-+       527, /* GL_GL_COMPRESSED_SRGB_ALPHA */
-+       524, /* GL_GL_COMPRESSED_SLUMINANCE */
-+       525, /* GL_GL_COMPRESSED_SLUMINANCE_ALPHA */
-+      1095, /* GL_POINT_SPRITE_COORD_ORIGIN */
-+       667, /* GL_LOWER_LEFT */
-+      1670, /* GL_UPPER_LEFT */
-+      1401, /* GL_STENCIL_BACK_REF */
-+      1402, /* GL_STENCIL_BACK_VALUE_MASK */
-+      1403, /* GL_STENCIL_BACK_WRITEMASK */
-+       403, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */
-+      1240, /* GL_RENDERBUFFER_BINDING_EXT */
-+      1225, /* GL_READ_FRAMEBUFFER_EXT */
-+       404, /* GL_DRAW_FRAMEBUFFER_EXT */
-+      1224, /* GL_READ_FRAMEBUFFER_BINDING_EXT */
-+       490, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT */
-+       489, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT */
-+       494, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT */
-+       492, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT */
-+       491, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT */
-+       496, /* GL_FRAMEBUFFER_COMPLETE_EXT */
-+       498, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT */
-+       503, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT */
-+       501, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */
-+       499, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */
-+       502, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */
-+       500, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */
-+       504, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */
-+       506, /* GL_FRAMEBUFFER_UNSUPPORTED_EXT */
-+       505, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */
-+       801, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
-+       146, /* GL_COLOR_ATTACHMENT0_EXT */
-+       153, /* GL_COLOR_ATTACHMENT1_EXT */
-+       154, /* GL_COLOR_ATTACHMENT2_EXT */
-+       155, /* GL_COLOR_ATTACHMENT3_EXT */
-+       156, /* GL_COLOR_ATTACHMENT4_EXT */
-+       157, /* GL_COLOR_ATTACHMENT5_EXT */
-+       158, /* GL_COLOR_ATTACHMENT6_EXT */
-+       159, /* GL_COLOR_ATTACHMENT7_EXT */
-+       160, /* GL_COLOR_ATTACHMENT8_EXT */
-+       161, /* GL_COLOR_ATTACHMENT9_EXT */
-+       147, /* GL_COLOR_ATTACHMENT10_EXT */
-+       148, /* GL_COLOR_ATTACHMENT11_EXT */
-+       149, /* GL_COLOR_ATTACHMENT12_EXT */
-+       150, /* GL_COLOR_ATTACHMENT13_EXT */
-+       151, /* GL_COLOR_ATTACHMENT14_EXT */
-+       152, /* GL_COLOR_ATTACHMENT15_EXT */
-+       314, /* GL_DEPTH_ATTACHMENT_EXT */
-+      1396, /* GL_STENCIL_ATTACHMENT_EXT */
-+       497, /* GL_FRAMEBUFFER_EXT */
-+      1241, /* GL_RENDERBUFFER_EXT */
-+      1244, /* GL_RENDERBUFFER_WIDTH_EXT */
-+      1242, /* GL_RENDERBUFFER_HEIGHT_EXT */
-+      1243, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */
-+      1414, /* GL_STENCIL_INDEX_EXT */
-+      1411, /* GL_STENCIL_INDEX1_EXT */
-+      1412, /* GL_STENCIL_INDEX4_EXT */
-+      1413, /* GL_STENCIL_INDEX8_EXT */
-+      1410, /* GL_STENCIL_INDEX16_EXT */
-+       428, /* GL_EVAL_BIT */
-+      1222, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
-+       661, /* GL_LIST_BIT */
-+      1523, /* GL_TEXTURE_BIT */
-+      1319, /* GL_SCISSOR_BIT */
-+        29, /* GL_ALL_ATTRIB_BITS */
-+       941, /* GL_MULTISAMPLE_BIT */
-+        30, /* GL_ALL_CLIENT_ATTRIB_BITS */
-+};
-+
-+#define Elements(x) sizeof(x)/sizeof(*x)
-+
-+typedef int (*cfunc)(const void *, const void *);
-+
-+/**
-+ * Compare a key name to an element in the \c all_enums array.
-+ *
-+ * \c bsearch always passes the key as the first parameter and the pointer
-+ * to the array element as the second parameter.  We can elimiate some
-+ * extra work by taking advantage of that fact.
-+ *
-+ * \param a  Pointer to the desired enum name.
-+ * \param b  Pointer to an element of the \c all_enums array.
-+ */
-+static int compar_name( const char *a, const enum_elt *b )
-+{
-+   return _mesa_strcmp( a, & enum_string_table[ b->offset ] );
-+}
-+
-+/**
-+ * Compare a key enum value to an element in the \c all_enums array.
-+ *
-+ * \c bsearch always passes the key as the first parameter and the pointer
-+ * to the array element as the second parameter.  We can elimiate some
-+ * extra work by taking advantage of that fact.
-+ *
-+ * \param a  Pointer to the desired enum name.
-+ * \param b  Pointer to an index into the \c all_enums array.
-+ */
-+static int compar_nr( const int *a, const unsigned *b )
-+{
-+   return a[0] - all_enums[*b].n;
-+}
-+
-+
-+static char token_tmp[20];
-+
-+const char *_mesa_lookup_enum_by_nr( int nr )
-+{
-+   unsigned * i;
-+
-+   i = (unsigned *)bsearch( & nr, reduced_enums, Elements(reduced_enums),
-+                            sizeof(reduced_enums[0]), (cfunc) compar_nr );
-+
-+   if ( i != NULL ) {
-+      return & enum_string_table[ all_enums[ *i ].offset ];
-+   }
-+   else {
-+      /* this is not re-entrant safe, no big deal here */
-+      _mesa_sprintf(token_tmp, "0x%x", nr);
-+      return token_tmp;
-+   }
-+}
-+
-+int _mesa_lookup_enum_by_name( const char *symbol )
-+{
-+   enum_elt * f = NULL;
-+
-+   if ( symbol != NULL ) {
-+      f = (enum_elt *)bsearch( symbol, all_enums, Elements(all_enums),
-+			       sizeof( enum_elt ), (cfunc) compar_name );
-+   }
-+
-+   return (f != NULL) ? f->n : -1;
-+}
-+
-+
-Index: qemu-0.14.0/target-i386/mesa_get.c
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-i386/mesa_get.c
-@@ -0,0 +1,5563 @@
-+
-+/***
-+ ***  NOTE!!!  DO NOT EDIT THIS FILE!!!  IT IS GENERATED BY get_gen.py
-+ ***/
-+
-+#include "glheader.h"
-+#include "context.h"
-+#include "enable.h"
-+#include "extensions.h"
-+#include "fbobject.h"
-+#include "get.h"
-+#include "macros.h"
-+#include "mtypes.h"
-+#include "state.h"
-+#include "texcompress.h"
-+
-+
-+#define FLOAT_TO_BOOLEAN(X)   ( (X) ? GL_TRUE : GL_FALSE )
-+
-+#define INT_TO_BOOLEAN(I)     ( (I) ? GL_TRUE : GL_FALSE )
-+
-+#define ENUM_TO_BOOLEAN(E)    ( (E) ? GL_TRUE : GL_FALSE )
-+#define ENUM_TO_INT(E)        ( (GLint) (E) )
-+#define ENUM_TO_FLOAT(E)      ( (GLfloat) (E) )
-+
-+#define BOOLEAN_TO_INT(B)     ( (GLint) (B) )
-+#define BOOLEAN_TO_FLOAT(B)   ( (B) ? 1.0F : 0.0F )
-+
-+
-+/*
-+ * Check if named extension is enabled, if not generate error and return.
-+ */
-+#define CHECK_EXT1(EXT1, FUNC)                                         \
-+   if (!ctx->Extensions.EXT1) {                                        \
-+      _mesa_error(ctx, GL_INVALID_ENUM, FUNC "(0x%x)", (int) pname);  \
-+      return;                                                          \
-+   }
-+
-+/*
-+ * Check if either of two extensions is enabled.
-+ */
-+#define CHECK_EXT2(EXT1, EXT2, FUNC)                                   \
-+   if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2) {               \
-+      _mesa_error(ctx, GL_INVALID_ENUM, FUNC "(0x%x)", (int) pname);  \
-+      return;                                                          \
-+   }
-+
-+/*
-+ * Check if either of three extensions is enabled.
-+ */
-+#define CHECK_EXT3(EXT1, EXT2, EXT3, FUNC)                             \
-+   if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2 &&               \
-+       !ctx->Extensions.EXT3) {                                        \
-+      _mesa_error(ctx, GL_INVALID_ENUM, FUNC "(0x%x)", (int) pname);  \
-+      return;                                                          \
-+   }
-+
-+/*
-+ * Check if either of four extensions is enabled.
-+ */
-+#define CHECK_EXT4(EXT1, EXT2, EXT3, EXT4, FUNC)                       \
-+   if (!ctx->Extensions.EXT1 && !ctx->Extensions.EXT2 &&               \
-+       !ctx->Extensions.EXT3 && !ctx->Extensions.EXT4) {               \
-+      _mesa_error(ctx, GL_INVALID_ENUM, FUNC "(0x%x)", (int) pname);  \
-+      return;                                                          \
-+   }
-+
-+
-+void GLAPIENTRY
-+_mesa_GetBooleanv( GLenum pname, GLboolean *params )
-+{
-+   GET_CURRENT_CONTEXT(ctx);
-+   ASSERT_OUTSIDE_BEGIN_END(ctx);
-+
-+   if (!params)
-+      return;
-+
-+   if (ctx->NewState)
-+      _mesa_update_state(ctx);
-+
-+   if (ctx->Driver.GetBooleanv &&
-+       ctx->Driver.GetBooleanv(ctx, pname, params))
-+      return;
-+
-+   switch (pname) {
-+      case GL_ACCUM_RED_BITS:
-+         params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.accumRedBits);
-+         break;
-+      case GL_ACCUM_GREEN_BITS:
-+         params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.accumGreenBits);
-+         break;
-+      case GL_ACCUM_BLUE_BITS:
-+         params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.accumBlueBits);
-+         break;
-+      case GL_ACCUM_ALPHA_BITS:
-+         params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.accumAlphaBits);
-+         break;
-+      case GL_ACCUM_CLEAR_VALUE:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Accum.ClearColor[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Accum.ClearColor[1]);
-+         params[2] = FLOAT_TO_BOOLEAN(ctx->Accum.ClearColor[2]);
-+         params[3] = FLOAT_TO_BOOLEAN(ctx->Accum.ClearColor[3]);
-+         break;
-+      case GL_ALPHA_BIAS:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.AlphaBias);
-+         break;
-+      case GL_ALPHA_BITS:
-+         params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.alphaBits);
-+         break;
-+      case GL_ALPHA_SCALE:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.AlphaScale);
-+         break;
-+      case GL_ALPHA_TEST:
-+         params[0] = ctx->Color.AlphaEnabled;
-+         break;
-+      case GL_ALPHA_TEST_FUNC:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Color.AlphaFunc);
-+         break;
-+      case GL_ALPHA_TEST_REF:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Color.AlphaRef);
-+         break;
-+      case GL_ATTRIB_STACK_DEPTH:
-+         params[0] = INT_TO_BOOLEAN(ctx->AttribStackDepth);
-+         break;
-+      case GL_AUTO_NORMAL:
-+         params[0] = ctx->Eval.AutoNormal;
-+         break;
-+      case GL_AUX_BUFFERS:
-+         params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.numAuxBuffers);
-+         break;
-+      case GL_BLEND:
-+         params[0] = ctx->Color.BlendEnabled;
-+         break;
-+      case GL_BLEND_DST:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendDstRGB);
-+         break;
-+      case GL_BLEND_SRC:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendSrcRGB);
-+         break;
-+      case GL_BLEND_SRC_RGB_EXT:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendSrcRGB);
-+         break;
-+      case GL_BLEND_DST_RGB_EXT:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendDstRGB);
-+         break;
-+      case GL_BLEND_SRC_ALPHA_EXT:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendSrcA);
-+         break;
-+      case GL_BLEND_DST_ALPHA_EXT:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendDstA);
-+         break;
-+      case GL_BLEND_EQUATION:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendEquationRGB );
-+         break;
-+      case GL_BLEND_EQUATION_ALPHA_EXT:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Color.BlendEquationA );
-+         break;
-+      case GL_BLEND_COLOR_EXT:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Color.BlendColor[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Color.BlendColor[1]);
-+         params[2] = FLOAT_TO_BOOLEAN(ctx->Color.BlendColor[2]);
-+         params[3] = FLOAT_TO_BOOLEAN(ctx->Color.BlendColor[3]);
-+         break;
-+      case GL_BLUE_BIAS:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.BlueBias);
-+         break;
-+      case GL_BLUE_BITS:
-+         params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.blueBits);
-+         break;
-+      case GL_BLUE_SCALE:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.BlueScale);
-+         break;
-+      case GL_CLIENT_ATTRIB_STACK_DEPTH:
-+         params[0] = INT_TO_BOOLEAN(ctx->ClientAttribStackDepth);
-+         break;
-+      case GL_CLIP_PLANE0:
-+         params[0] = (ctx->Transform.ClipPlanesEnabled >> 0) & 1;
-+         break;
-+      case GL_CLIP_PLANE1:
-+         params[0] = (ctx->Transform.ClipPlanesEnabled >> 1) & 1;
-+         break;
-+      case GL_CLIP_PLANE2:
-+         params[0] = (ctx->Transform.ClipPlanesEnabled >> 2) & 1;
-+         break;
-+      case GL_CLIP_PLANE3:
-+         params[0] = (ctx->Transform.ClipPlanesEnabled >> 3) & 1;
-+         break;
-+      case GL_CLIP_PLANE4:
-+         params[0] = (ctx->Transform.ClipPlanesEnabled >> 4) & 1;
-+         break;
-+      case GL_CLIP_PLANE5:
-+         params[0] = (ctx->Transform.ClipPlanesEnabled >> 5) & 1;
-+         break;
-+      case GL_COLOR_CLEAR_VALUE:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Color.ClearColor[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Color.ClearColor[1]);
-+         params[2] = FLOAT_TO_BOOLEAN(ctx->Color.ClearColor[2]);
-+         params[3] = FLOAT_TO_BOOLEAN(ctx->Color.ClearColor[3]);
-+         break;
-+      case GL_COLOR_MATERIAL:
-+         params[0] = ctx->Light.ColorMaterialEnabled;
-+         break;
-+      case GL_COLOR_MATERIAL_FACE:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Light.ColorMaterialFace);
-+         break;
-+      case GL_COLOR_MATERIAL_PARAMETER:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Light.ColorMaterialMode);
-+         break;
-+      case GL_COLOR_WRITEMASK:
-+         params[0] = INT_TO_BOOLEAN(ctx->Color.ColorMask[RCOMP] ? 1 : 0);
-+         params[1] = INT_TO_BOOLEAN(ctx->Color.ColorMask[GCOMP] ? 1 : 0);
-+         params[2] = INT_TO_BOOLEAN(ctx->Color.ColorMask[BCOMP] ? 1 : 0);
-+         params[3] = INT_TO_BOOLEAN(ctx->Color.ColorMask[ACOMP] ? 1 : 0);
-+         break;
-+      case GL_CULL_FACE:
-+         params[0] = ctx->Polygon.CullFlag;
-+         break;
-+      case GL_CULL_FACE_MODE:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Polygon.CullFaceMode);
-+         break;
-+      case GL_CURRENT_COLOR:
-+         {
-+         FLUSH_CURRENT(ctx, 0);
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0]);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1]);
-+         params[2] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2]);
-+         params[3] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3]);
-+         }
-+         break;
-+      case GL_CURRENT_INDEX:
-+         {
-+         FLUSH_CURRENT(ctx, 0);
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX][0]);
-+         }
-+         break;
-+      case GL_CURRENT_NORMAL:
-+         {
-+         FLUSH_CURRENT(ctx, 0);
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0]);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1]);
-+         params[2] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2]);
-+         }
-+         break;
-+      case GL_CURRENT_RASTER_COLOR:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Current.RasterColor[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Current.RasterColor[1]);
-+         params[2] = FLOAT_TO_BOOLEAN(ctx->Current.RasterColor[2]);
-+         params[3] = FLOAT_TO_BOOLEAN(ctx->Current.RasterColor[3]);
-+         break;
-+      case GL_CURRENT_RASTER_DISTANCE:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Current.RasterDistance);
-+         break;
-+      case GL_CURRENT_RASTER_INDEX:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Current.RasterIndex);
-+         break;
-+      case GL_CURRENT_RASTER_POSITION:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Current.RasterPos[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Current.RasterPos[1]);
-+         params[2] = FLOAT_TO_BOOLEAN(ctx->Current.RasterPos[2]);
-+         params[3] = FLOAT_TO_BOOLEAN(ctx->Current.RasterPos[3]);
-+         break;
-+      case GL_CURRENT_RASTER_SECONDARY_COLOR:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Current.RasterSecondaryColor[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Current.RasterSecondaryColor[1]);
-+         params[2] = FLOAT_TO_BOOLEAN(ctx->Current.RasterSecondaryColor[2]);
-+         params[3] = FLOAT_TO_BOOLEAN(ctx->Current.RasterSecondaryColor[3]);
-+         break;
-+      case GL_CURRENT_RASTER_TEXTURE_COORDS:
-+         {
-+         const GLuint texUnit = ctx->Texture.CurrentUnit;
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Current.RasterTexCoords[texUnit][0]);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Current.RasterTexCoords[texUnit][1]);
-+         params[2] = FLOAT_TO_BOOLEAN(ctx->Current.RasterTexCoords[texUnit][2]);
-+         params[3] = FLOAT_TO_BOOLEAN(ctx->Current.RasterTexCoords[texUnit][3]);
-+         }
-+         break;
-+      case GL_CURRENT_RASTER_POSITION_VALID:
-+         params[0] = ctx->Current.RasterPosValid;
-+         break;
-+      case GL_CURRENT_TEXTURE_COORDS:
-+         {
-+         const GLuint texUnit = ctx->Texture.CurrentUnit;
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0]);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]);
-+         params[2] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]);
-+         params[3] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3]);
-+         }
-+         break;
-+      case GL_DEPTH_BIAS:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.DepthBias);
-+         break;
-+      case GL_DEPTH_BITS:
-+         params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.depthBits);
-+         break;
-+      case GL_DEPTH_CLEAR_VALUE:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Depth.Clear);
-+         break;
-+      case GL_DEPTH_FUNC:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Depth.Func);
-+         break;
-+      case GL_DEPTH_RANGE:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Viewport.Near);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Viewport.Far);
-+         break;
-+      case GL_DEPTH_SCALE:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.DepthScale);
-+         break;
-+      case GL_DEPTH_TEST:
-+         params[0] = ctx->Depth.Test;
-+         break;
-+      case GL_DEPTH_WRITEMASK:
-+         params[0] = ctx->Depth.Mask;
-+         break;
-+      case GL_DITHER:
-+         params[0] = ctx->Color.DitherFlag;
-+         break;
-+      case GL_DOUBLEBUFFER:
-+         params[0] = ctx->DrawBuffer->Visual.doubleBufferMode;
-+         break;
-+      case GL_DRAW_BUFFER:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->DrawBuffer->ColorDrawBuffer[0]);
-+         break;
-+      case GL_EDGE_FLAG:
-+         {
-+         FLUSH_CURRENT(ctx, 0);
-+         params[0] = ctx->Current.EdgeFlag;
-+         }
-+         break;
-+      case GL_FEEDBACK_BUFFER_SIZE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Feedback.BufferSize);
-+         break;
-+      case GL_FEEDBACK_BUFFER_TYPE:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Feedback.Type);
-+         break;
-+      case GL_FOG:
-+         params[0] = ctx->Fog.Enabled;
-+         break;
-+      case GL_FOG_COLOR:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Fog.Color[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Fog.Color[1]);
-+         params[2] = FLOAT_TO_BOOLEAN(ctx->Fog.Color[2]);
-+         params[3] = FLOAT_TO_BOOLEAN(ctx->Fog.Color[3]);
-+         break;
-+      case GL_FOG_DENSITY:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Fog.Density);
-+         break;
-+      case GL_FOG_END:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Fog.End);
-+         break;
-+      case GL_FOG_HINT:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Hint.Fog);
-+         break;
-+      case GL_FOG_INDEX:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Fog.Index);
-+         break;
-+      case GL_FOG_MODE:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Fog.Mode);
-+         break;
-+      case GL_FOG_START:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Fog.Start);
-+         break;
-+      case GL_FRONT_FACE:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Polygon.FrontFace);
-+         break;
-+      case GL_GREEN_BIAS:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.GreenBias);
-+         break;
-+      case GL_GREEN_BITS:
-+         params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.greenBits);
-+         break;
-+      case GL_GREEN_SCALE:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.GreenScale);
-+         break;
-+      case GL_INDEX_BITS:
-+         params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.indexBits);
-+         break;
-+      case GL_INDEX_CLEAR_VALUE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Color.ClearIndex);
-+         break;
-+      case GL_INDEX_MODE:
-+         params[0] = !ctx->DrawBuffer->Visual.rgbMode;
-+         break;
-+      case GL_INDEX_OFFSET:
-+         params[0] = INT_TO_BOOLEAN(ctx->Pixel.IndexOffset);
-+         break;
-+      case GL_INDEX_SHIFT:
-+         params[0] = INT_TO_BOOLEAN(ctx->Pixel.IndexShift);
-+         break;
-+      case GL_INDEX_WRITEMASK:
-+         params[0] = INT_TO_BOOLEAN(ctx->Color.IndexMask);
-+         break;
-+      case GL_LIGHT0:
-+         params[0] = ctx->Light.Light[0].Enabled;
-+         break;
-+      case GL_LIGHT1:
-+         params[0] = ctx->Light.Light[1].Enabled;
-+         break;
-+      case GL_LIGHT2:
-+         params[0] = ctx->Light.Light[2].Enabled;
-+         break;
-+      case GL_LIGHT3:
-+         params[0] = ctx->Light.Light[3].Enabled;
-+         break;
-+      case GL_LIGHT4:
-+         params[0] = ctx->Light.Light[4].Enabled;
-+         break;
-+      case GL_LIGHT5:
-+         params[0] = ctx->Light.Light[5].Enabled;
-+         break;
-+      case GL_LIGHT6:
-+         params[0] = ctx->Light.Light[6].Enabled;
-+         break;
-+      case GL_LIGHT7:
-+         params[0] = ctx->Light.Light[7].Enabled;
-+         break;
-+      case GL_LIGHTING:
-+         params[0] = ctx->Light.Enabled;
-+         break;
-+      case GL_LIGHT_MODEL_AMBIENT:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Light.Model.Ambient[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Light.Model.Ambient[1]);
-+         params[2] = FLOAT_TO_BOOLEAN(ctx->Light.Model.Ambient[2]);
-+         params[3] = FLOAT_TO_BOOLEAN(ctx->Light.Model.Ambient[3]);
-+         break;
-+      case GL_LIGHT_MODEL_COLOR_CONTROL:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Light.Model.ColorControl);
-+         break;
-+      case GL_LIGHT_MODEL_LOCAL_VIEWER:
-+         params[0] = ctx->Light.Model.LocalViewer;
-+         break;
-+      case GL_LIGHT_MODEL_TWO_SIDE:
-+         params[0] = ctx->Light.Model.TwoSide;
-+         break;
-+      case GL_LINE_SMOOTH:
-+         params[0] = ctx->Line.SmoothFlag;
-+         break;
-+      case GL_LINE_SMOOTH_HINT:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Hint.LineSmooth);
-+         break;
-+      case GL_LINE_STIPPLE:
-+         params[0] = ctx->Line.StippleFlag;
-+         break;
-+      case GL_LINE_STIPPLE_PATTERN:
-+         params[0] = INT_TO_BOOLEAN(ctx->Line.StipplePattern);
-+         break;
-+      case GL_LINE_STIPPLE_REPEAT:
-+         params[0] = INT_TO_BOOLEAN(ctx->Line.StippleFactor);
-+         break;
-+      case GL_LINE_WIDTH:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Line.Width);
-+         break;
-+      case GL_LINE_WIDTH_GRANULARITY:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Const.LineWidthGranularity);
-+         break;
-+      case GL_LINE_WIDTH_RANGE:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MinLineWidthAA);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Const.MaxLineWidthAA);
-+         break;
-+      case GL_ALIASED_LINE_WIDTH_RANGE:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MinLineWidth);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Const.MaxLineWidth);
-+         break;
-+      case GL_LIST_BASE:
-+         params[0] = INT_TO_BOOLEAN(ctx->List.ListBase);
-+         break;
-+      case GL_LIST_INDEX:
-+         params[0] = INT_TO_BOOLEAN(ctx->ListState.CurrentListNum);
-+         break;
-+      case GL_LIST_MODE:
-+         {
-+         GLenum mode;
-+         if (!ctx->CompileFlag)
-+            mode = 0;
-+         else if (ctx->ExecuteFlag)
-+            mode = GL_COMPILE_AND_EXECUTE;
-+         else
-+            mode = GL_COMPILE;
-+         params[0] = ENUM_TO_BOOLEAN(mode);
-+         }
-+         break;
-+      case GL_INDEX_LOGIC_OP:
-+         params[0] = ctx->Color.IndexLogicOpEnabled;
-+         break;
-+      case GL_COLOR_LOGIC_OP:
-+         params[0] = ctx->Color.ColorLogicOpEnabled;
-+         break;
-+      case GL_LOGIC_OP_MODE:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Color.LogicOp);
-+         break;
-+      case GL_MAP1_COLOR_4:
-+         params[0] = ctx->Eval.Map1Color4;
-+         break;
-+      case GL_MAP1_GRID_DOMAIN:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Eval.MapGrid1u1);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Eval.MapGrid1u2);
-+         break;
-+      case GL_MAP1_GRID_SEGMENTS:
-+         params[0] = INT_TO_BOOLEAN(ctx->Eval.MapGrid1un);
-+         break;
-+      case GL_MAP1_INDEX:
-+         params[0] = ctx->Eval.Map1Index;
-+         break;
-+      case GL_MAP1_NORMAL:
-+         params[0] = ctx->Eval.Map1Normal;
-+         break;
-+      case GL_MAP1_TEXTURE_COORD_1:
-+         params[0] = ctx->Eval.Map1TextureCoord1;
-+         break;
-+      case GL_MAP1_TEXTURE_COORD_2:
-+         params[0] = ctx->Eval.Map1TextureCoord2;
-+         break;
-+      case GL_MAP1_TEXTURE_COORD_3:
-+         params[0] = ctx->Eval.Map1TextureCoord3;
-+         break;
-+      case GL_MAP1_TEXTURE_COORD_4:
-+         params[0] = ctx->Eval.Map1TextureCoord4;
-+         break;
-+      case GL_MAP1_VERTEX_3:
-+         params[0] = ctx->Eval.Map1Vertex3;
-+         break;
-+      case GL_MAP1_VERTEX_4:
-+         params[0] = ctx->Eval.Map1Vertex4;
-+         break;
-+      case GL_MAP2_COLOR_4:
-+         params[0] = ctx->Eval.Map2Color4;
-+         break;
-+      case GL_MAP2_GRID_DOMAIN:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Eval.MapGrid2u1);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Eval.MapGrid2u2);
-+         params[2] = FLOAT_TO_BOOLEAN(ctx->Eval.MapGrid2v1);
-+         params[3] = FLOAT_TO_BOOLEAN(ctx->Eval.MapGrid2v2);
-+         break;
-+      case GL_MAP2_GRID_SEGMENTS:
-+         params[0] = INT_TO_BOOLEAN(ctx->Eval.MapGrid2un);
-+         params[1] = INT_TO_BOOLEAN(ctx->Eval.MapGrid2vn);
-+         break;
-+      case GL_MAP2_INDEX:
-+         params[0] = ctx->Eval.Map2Index;
-+         break;
-+      case GL_MAP2_NORMAL:
-+         params[0] = ctx->Eval.Map2Normal;
-+         break;
-+      case GL_MAP2_TEXTURE_COORD_1:
-+         params[0] = ctx->Eval.Map2TextureCoord1;
-+         break;
-+      case GL_MAP2_TEXTURE_COORD_2:
-+         params[0] = ctx->Eval.Map2TextureCoord2;
-+         break;
-+      case GL_MAP2_TEXTURE_COORD_3:
-+         params[0] = ctx->Eval.Map2TextureCoord3;
-+         break;
-+      case GL_MAP2_TEXTURE_COORD_4:
-+         params[0] = ctx->Eval.Map2TextureCoord4;
-+         break;
-+      case GL_MAP2_VERTEX_3:
-+         params[0] = ctx->Eval.Map2Vertex3;
-+         break;
-+      case GL_MAP2_VERTEX_4:
-+         params[0] = ctx->Eval.Map2Vertex4;
-+         break;
-+      case GL_MAP_COLOR:
-+         params[0] = ctx->Pixel.MapColorFlag;
-+         break;
-+      case GL_MAP_STENCIL:
-+         params[0] = ctx->Pixel.MapStencilFlag;
-+         break;
-+      case GL_MATRIX_MODE:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Transform.MatrixMode);
-+         break;
-+      case GL_MAX_ATTRIB_STACK_DEPTH:
-+         params[0] = INT_TO_BOOLEAN(MAX_ATTRIB_STACK_DEPTH);
-+         break;
-+      case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
-+         params[0] = INT_TO_BOOLEAN(MAX_CLIENT_ATTRIB_STACK_DEPTH);
-+         break;
-+      case GL_MAX_CLIP_PLANES:
-+         params[0] = INT_TO_BOOLEAN(ctx->Const.MaxClipPlanes);
-+         break;
-+      case GL_MAX_ELEMENTS_VERTICES:
-+         params[0] = INT_TO_BOOLEAN(ctx->Const.MaxArrayLockSize);
-+         break;
-+      case GL_MAX_ELEMENTS_INDICES:
-+         params[0] = INT_TO_BOOLEAN(ctx->Const.MaxArrayLockSize);
-+         break;
-+      case GL_MAX_EVAL_ORDER:
-+         params[0] = INT_TO_BOOLEAN(MAX_EVAL_ORDER);
-+         break;
-+      case GL_MAX_LIGHTS:
-+         params[0] = INT_TO_BOOLEAN(ctx->Const.MaxLights);
-+         break;
-+      case GL_MAX_LIST_NESTING:
-+         params[0] = INT_TO_BOOLEAN(MAX_LIST_NESTING);
-+         break;
-+      case GL_MAX_MODELVIEW_STACK_DEPTH:
-+         params[0] = INT_TO_BOOLEAN(MAX_MODELVIEW_STACK_DEPTH);
-+         break;
-+      case GL_MAX_NAME_STACK_DEPTH:
-+         params[0] = INT_TO_BOOLEAN(MAX_NAME_STACK_DEPTH);
-+         break;
-+      case GL_MAX_PIXEL_MAP_TABLE:
-+         params[0] = INT_TO_BOOLEAN(MAX_PIXEL_MAP_TABLE);
-+         break;
-+      case GL_MAX_PROJECTION_STACK_DEPTH:
-+         params[0] = INT_TO_BOOLEAN(MAX_PROJECTION_STACK_DEPTH);
-+         break;
-+      case GL_MAX_TEXTURE_SIZE:
-+         params[0] = INT_TO_BOOLEAN(1 << (ctx->Const.MaxTextureLevels - 1));
-+         break;
-+      case GL_MAX_3D_TEXTURE_SIZE:
-+         params[0] = INT_TO_BOOLEAN(1 << (ctx->Const.Max3DTextureLevels - 1));
-+         break;
-+      case GL_MAX_TEXTURE_STACK_DEPTH:
-+         params[0] = INT_TO_BOOLEAN(MAX_TEXTURE_STACK_DEPTH);
-+         break;
-+      case GL_MAX_VIEWPORT_DIMS:
-+         params[0] = INT_TO_BOOLEAN(ctx->Const.MaxViewportWidth);
-+         params[1] = INT_TO_BOOLEAN(ctx->Const.MaxViewportHeight);
-+         break;
-+      case GL_MODELVIEW_MATRIX:
-+         {
-+         const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
-+         params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(matrix[1]);
-+         params[2] = FLOAT_TO_BOOLEAN(matrix[2]);
-+         params[3] = FLOAT_TO_BOOLEAN(matrix[3]);
-+         params[4] = FLOAT_TO_BOOLEAN(matrix[4]);
-+         params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+         params[6] = FLOAT_TO_BOOLEAN(matrix[6]);
-+         params[7] = FLOAT_TO_BOOLEAN(matrix[7]);
-+         params[8] = FLOAT_TO_BOOLEAN(matrix[8]);
-+         params[9] = FLOAT_TO_BOOLEAN(matrix[9]);
-+         params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+         params[11] = FLOAT_TO_BOOLEAN(matrix[11]);
-+         params[12] = FLOAT_TO_BOOLEAN(matrix[12]);
-+         params[13] = FLOAT_TO_BOOLEAN(matrix[13]);
-+         params[14] = FLOAT_TO_BOOLEAN(matrix[14]);
-+         params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+         }
-+         break;
-+      case GL_MODELVIEW_STACK_DEPTH:
-+         params[0] = INT_TO_BOOLEAN(ctx->ModelviewMatrixStack.Depth + 1);
-+         break;
-+      case GL_NAME_STACK_DEPTH:
-+         params[0] = INT_TO_BOOLEAN(ctx->Select.NameStackDepth);
-+         break;
-+      case GL_NORMALIZE:
-+         params[0] = ctx->Transform.Normalize;
-+         break;
-+      case GL_PACK_ALIGNMENT:
-+         params[0] = INT_TO_BOOLEAN(ctx->Pack.Alignment);
-+         break;
-+      case GL_PACK_LSB_FIRST:
-+         params[0] = ctx->Pack.LsbFirst;
-+         break;
-+      case GL_PACK_ROW_LENGTH:
-+         params[0] = INT_TO_BOOLEAN(ctx->Pack.RowLength);
-+         break;
-+      case GL_PACK_SKIP_PIXELS:
-+         params[0] = INT_TO_BOOLEAN(ctx->Pack.SkipPixels);
-+         break;
-+      case GL_PACK_SKIP_ROWS:
-+         params[0] = INT_TO_BOOLEAN(ctx->Pack.SkipRows);
-+         break;
-+      case GL_PACK_SWAP_BYTES:
-+         params[0] = ctx->Pack.SwapBytes;
-+         break;
-+      case GL_PACK_SKIP_IMAGES_EXT:
-+         params[0] = INT_TO_BOOLEAN(ctx->Pack.SkipImages);
-+         break;
-+      case GL_PACK_IMAGE_HEIGHT_EXT:
-+         params[0] = INT_TO_BOOLEAN(ctx->Pack.ImageHeight);
-+         break;
-+      case GL_PACK_INVERT_MESA:
-+         params[0] = ctx->Pack.Invert;
-+         break;
-+      case GL_PERSPECTIVE_CORRECTION_HINT:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Hint.PerspectiveCorrection);
-+         break;
-+      case GL_PIXEL_MAP_A_TO_A_SIZE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapAtoAsize);
-+         break;
-+      case GL_PIXEL_MAP_B_TO_B_SIZE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapBtoBsize);
-+         break;
-+      case GL_PIXEL_MAP_G_TO_G_SIZE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapGtoGsize);
-+         break;
-+      case GL_PIXEL_MAP_I_TO_A_SIZE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapItoAsize);
-+         break;
-+      case GL_PIXEL_MAP_I_TO_B_SIZE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapItoBsize);
-+         break;
-+      case GL_PIXEL_MAP_I_TO_G_SIZE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapItoGsize);
-+         break;
-+      case GL_PIXEL_MAP_I_TO_I_SIZE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapItoIsize);
-+         break;
-+      case GL_PIXEL_MAP_I_TO_R_SIZE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapItoRsize);
-+         break;
-+      case GL_PIXEL_MAP_R_TO_R_SIZE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapRtoRsize);
-+         break;
-+      case GL_PIXEL_MAP_S_TO_S_SIZE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Pixel.MapStoSsize);
-+         break;
-+      case GL_POINT_SIZE:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Point.Size);
-+         break;
-+      case GL_POINT_SIZE_GRANULARITY:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Const.PointSizeGranularity);
-+         break;
-+      case GL_POINT_SIZE_RANGE:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MinPointSizeAA);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Const.MaxPointSizeAA);
-+         break;
-+      case GL_ALIASED_POINT_SIZE_RANGE:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MinPointSize);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Const.MaxPointSize);
-+         break;
-+      case GL_POINT_SMOOTH:
-+         params[0] = ctx->Point.SmoothFlag;
-+         break;
-+      case GL_POINT_SMOOTH_HINT:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Hint.PointSmooth);
-+         break;
-+      case GL_POINT_SIZE_MIN_EXT:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Point.MinSize);
-+         break;
-+      case GL_POINT_SIZE_MAX_EXT:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Point.MaxSize);
-+         break;
-+      case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Point.Threshold);
-+         break;
-+      case GL_DISTANCE_ATTENUATION_EXT:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Point.Params[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Point.Params[1]);
-+         params[2] = FLOAT_TO_BOOLEAN(ctx->Point.Params[2]);
-+         break;
-+      case GL_POLYGON_MODE:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Polygon.FrontMode);
-+         params[1] = ENUM_TO_BOOLEAN(ctx->Polygon.BackMode);
-+         break;
-+      case GL_POLYGON_OFFSET_BIAS_EXT:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Polygon.OffsetUnits);
-+         break;
-+      case GL_POLYGON_OFFSET_FACTOR:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Polygon.OffsetFactor );
-+         break;
-+      case GL_POLYGON_OFFSET_UNITS:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Polygon.OffsetUnits );
-+         break;
-+      case GL_POLYGON_SMOOTH:
-+         params[0] = ctx->Polygon.SmoothFlag;
-+         break;
-+      case GL_POLYGON_SMOOTH_HINT:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Hint.PolygonSmooth);
-+         break;
-+      case GL_POLYGON_STIPPLE:
-+         params[0] = ctx->Polygon.StippleFlag;
-+         break;
-+      case GL_PROJECTION_MATRIX:
-+         {
-+         const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
-+         params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(matrix[1]);
-+         params[2] = FLOAT_TO_BOOLEAN(matrix[2]);
-+         params[3] = FLOAT_TO_BOOLEAN(matrix[3]);
-+         params[4] = FLOAT_TO_BOOLEAN(matrix[4]);
-+         params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+         params[6] = FLOAT_TO_BOOLEAN(matrix[6]);
-+         params[7] = FLOAT_TO_BOOLEAN(matrix[7]);
-+         params[8] = FLOAT_TO_BOOLEAN(matrix[8]);
-+         params[9] = FLOAT_TO_BOOLEAN(matrix[9]);
-+         params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+         params[11] = FLOAT_TO_BOOLEAN(matrix[11]);
-+         params[12] = FLOAT_TO_BOOLEAN(matrix[12]);
-+         params[13] = FLOAT_TO_BOOLEAN(matrix[13]);
-+         params[14] = FLOAT_TO_BOOLEAN(matrix[14]);
-+         params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+         }
-+         break;
-+      case GL_PROJECTION_STACK_DEPTH:
-+         params[0] = INT_TO_BOOLEAN(ctx->ProjectionMatrixStack.Depth + 1);
-+         break;
-+      case GL_READ_BUFFER:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->ReadBuffer->ColorReadBuffer);
-+         break;
-+      case GL_RED_BIAS:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.RedBias);
-+         break;
-+      case GL_RED_BITS:
-+         params[0] = INT_TO_BOOLEAN( ctx->DrawBuffer->Visual.redBits );
-+         break;
-+      case GL_RED_SCALE:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.RedScale);
-+         break;
-+      case GL_RENDER_MODE:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->RenderMode);
-+         break;
-+      case GL_RESCALE_NORMAL:
-+         params[0] = ctx->Transform.RescaleNormals;
-+         break;
-+      case GL_RGBA_MODE:
-+         params[0] = ctx->DrawBuffer->Visual.rgbMode;
-+         break;
-+      case GL_SCISSOR_BOX:
-+         params[0] = INT_TO_BOOLEAN(ctx->Scissor.X);
-+         params[1] = INT_TO_BOOLEAN(ctx->Scissor.Y);
-+         params[2] = INT_TO_BOOLEAN(ctx->Scissor.Width);
-+         params[3] = INT_TO_BOOLEAN(ctx->Scissor.Height);
-+         break;
-+      case GL_SCISSOR_TEST:
-+         params[0] = ctx->Scissor.Enabled;
-+         break;
-+      case GL_SELECTION_BUFFER_SIZE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Select.BufferSize);
-+         break;
-+      case GL_SHADE_MODEL:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Light.ShadeModel);
-+         break;
-+      case GL_SHARED_TEXTURE_PALETTE_EXT:
-+         params[0] = ctx->Texture.SharedPalette;
-+         break;
-+      case GL_STENCIL_BITS:
-+         params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.stencilBits);
-+         break;
-+      case GL_STENCIL_CLEAR_VALUE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Stencil.Clear);
-+         break;
-+      case GL_STENCIL_FAIL:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace]);
-+         break;
-+      case GL_STENCIL_FUNC:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.Function[ctx->Stencil.ActiveFace]);
-+         break;
-+      case GL_STENCIL_PASS_DEPTH_FAIL:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace]);
-+         break;
-+      case GL_STENCIL_PASS_DEPTH_PASS:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace]);
-+         break;
-+      case GL_STENCIL_REF:
-+         params[0] = INT_TO_BOOLEAN(ctx->Stencil.Ref[ctx->Stencil.ActiveFace]);
-+         break;
-+      case GL_STENCIL_TEST:
-+         params[0] = ctx->Stencil.Enabled;
-+         break;
-+      case GL_STENCIL_VALUE_MASK:
-+         params[0] = INT_TO_BOOLEAN(ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace]);
-+         break;
-+      case GL_STENCIL_WRITEMASK:
-+         params[0] = INT_TO_BOOLEAN(ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace]);
-+         break;
-+      case GL_STEREO:
-+         params[0] = ctx->DrawBuffer->Visual.stereoMode;
-+         break;
-+      case GL_SUBPIXEL_BITS:
-+         params[0] = INT_TO_BOOLEAN(ctx->Const.SubPixelBits);
-+         break;
-+      case GL_TEXTURE_1D:
-+         params[0] = _mesa_IsEnabled(GL_TEXTURE_1D);
-+         break;
-+      case GL_TEXTURE_2D:
-+         params[0] = _mesa_IsEnabled(GL_TEXTURE_2D);
-+         break;
-+      case GL_TEXTURE_3D:
-+         params[0] = _mesa_IsEnabled(GL_TEXTURE_3D);
-+         break;
-+      case GL_TEXTURE_BINDING_1D:
-+         params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1D->Name);
-+         break;
-+      case GL_TEXTURE_BINDING_2D:
-+         params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2D->Name);
-+         break;
-+      case GL_TEXTURE_BINDING_3D:
-+         params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current3D->Name);
-+         break;
-+      case GL_TEXTURE_ENV_COLOR:
-+         {
-+         const GLfloat *color = ctx->Texture.Unit[ctx->Texture.CurrentUnit].EnvColor;
-+         params[0] = FLOAT_TO_BOOLEAN(color[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(color[1]);
-+         params[2] = FLOAT_TO_BOOLEAN(color[2]);
-+         params[3] = FLOAT_TO_BOOLEAN(color[3]);
-+         }
-+         break;
-+      case GL_TEXTURE_ENV_MODE:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].EnvMode);
-+         break;
-+      case GL_TEXTURE_GEN_S:
-+         params[0] = ((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0);
-+         break;
-+      case GL_TEXTURE_GEN_T:
-+         params[0] = ((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & T_BIT) ? 1 : 0);
-+         break;
-+      case GL_TEXTURE_GEN_R:
-+         params[0] = ((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & R_BIT) ? 1 : 0);
-+         break;
-+      case GL_TEXTURE_GEN_Q:
-+         params[0] = ((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & Q_BIT) ? 1 : 0);
-+         break;
-+      case GL_TEXTURE_MATRIX:
-+         {
-+         const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
-+         params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(matrix[1]);
-+         params[2] = FLOAT_TO_BOOLEAN(matrix[2]);
-+         params[3] = FLOAT_TO_BOOLEAN(matrix[3]);
-+         params[4] = FLOAT_TO_BOOLEAN(matrix[4]);
-+         params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+         params[6] = FLOAT_TO_BOOLEAN(matrix[6]);
-+         params[7] = FLOAT_TO_BOOLEAN(matrix[7]);
-+         params[8] = FLOAT_TO_BOOLEAN(matrix[8]);
-+         params[9] = FLOAT_TO_BOOLEAN(matrix[9]);
-+         params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+         params[11] = FLOAT_TO_BOOLEAN(matrix[11]);
-+         params[12] = FLOAT_TO_BOOLEAN(matrix[12]);
-+         params[13] = FLOAT_TO_BOOLEAN(matrix[13]);
-+         params[14] = FLOAT_TO_BOOLEAN(matrix[14]);
-+         params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+         }
-+         break;
-+      case GL_TEXTURE_STACK_DEPTH:
-+         params[0] = INT_TO_BOOLEAN(ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Depth + 1);
-+         break;
-+      case GL_UNPACK_ALIGNMENT:
-+         params[0] = INT_TO_BOOLEAN(ctx->Unpack.Alignment);
-+         break;
-+      case GL_UNPACK_LSB_FIRST:
-+         params[0] = ctx->Unpack.LsbFirst;
-+         break;
-+      case GL_UNPACK_ROW_LENGTH:
-+         params[0] = INT_TO_BOOLEAN(ctx->Unpack.RowLength);
-+         break;
-+      case GL_UNPACK_SKIP_PIXELS:
-+         params[0] = INT_TO_BOOLEAN(ctx->Unpack.SkipPixels);
-+         break;
-+      case GL_UNPACK_SKIP_ROWS:
-+         params[0] = INT_TO_BOOLEAN(ctx->Unpack.SkipRows);
-+         break;
-+      case GL_UNPACK_SWAP_BYTES:
-+         params[0] = ctx->Unpack.SwapBytes;
-+         break;
-+      case GL_UNPACK_SKIP_IMAGES_EXT:
-+         params[0] = INT_TO_BOOLEAN(ctx->Unpack.SkipImages);
-+         break;
-+      case GL_UNPACK_IMAGE_HEIGHT_EXT:
-+         params[0] = INT_TO_BOOLEAN(ctx->Unpack.ImageHeight);
-+         break;
-+      case GL_UNPACK_CLIENT_STORAGE_APPLE:
-+         params[0] = ctx->Unpack.ClientStorage;
-+         break;
-+      case GL_VIEWPORT:
-+         params[0] = INT_TO_BOOLEAN(ctx->Viewport.X);
-+         params[1] = INT_TO_BOOLEAN(ctx->Viewport.Y);
-+         params[2] = INT_TO_BOOLEAN(ctx->Viewport.Width);
-+         params[3] = INT_TO_BOOLEAN(ctx->Viewport.Height);
-+         break;
-+      case GL_ZOOM_X:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.ZoomX);
-+         break;
-+      case GL_ZOOM_Y:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.ZoomY);
-+         break;
-+      case GL_VERTEX_ARRAY:
-+         params[0] = ctx->Array.ArrayObj->Vertex.Enabled;
-+         break;
-+      case GL_VERTEX_ARRAY_SIZE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Vertex.Size);
-+         break;
-+      case GL_VERTEX_ARRAY_TYPE:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Array.ArrayObj->Vertex.Type);
-+         break;
-+      case GL_VERTEX_ARRAY_STRIDE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Vertex.Stride);
-+         break;
-+      case GL_VERTEX_ARRAY_COUNT_EXT:
-+         params[0] = INT_TO_BOOLEAN(0);
-+         break;
-+      case GL_NORMAL_ARRAY:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Array.ArrayObj->Normal.Enabled);
-+         break;
-+      case GL_NORMAL_ARRAY_TYPE:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Array.ArrayObj->Normal.Type);
-+         break;
-+      case GL_NORMAL_ARRAY_STRIDE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Normal.Stride);
-+         break;
-+      case GL_NORMAL_ARRAY_COUNT_EXT:
-+         params[0] = INT_TO_BOOLEAN(0);
-+         break;
-+      case GL_COLOR_ARRAY:
-+         params[0] = ctx->Array.ArrayObj->Color.Enabled;
-+         break;
-+      case GL_COLOR_ARRAY_SIZE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Color.Size);
-+         break;
-+      case GL_COLOR_ARRAY_TYPE:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Array.ArrayObj->Color.Type);
-+         break;
-+      case GL_COLOR_ARRAY_STRIDE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Color.Stride);
-+         break;
-+      case GL_COLOR_ARRAY_COUNT_EXT:
-+         params[0] = INT_TO_BOOLEAN(0);
-+         break;
-+      case GL_INDEX_ARRAY:
-+         params[0] = ctx->Array.ArrayObj->Index.Enabled;
-+         break;
-+      case GL_INDEX_ARRAY_TYPE:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Array.ArrayObj->Index.Type);
-+         break;
-+      case GL_INDEX_ARRAY_STRIDE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Index.Stride);
-+         break;
-+      case GL_INDEX_ARRAY_COUNT_EXT:
-+         params[0] = INT_TO_BOOLEAN(0);
-+         break;
-+      case GL_TEXTURE_COORD_ARRAY:
-+         params[0] = ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled;
-+         break;
-+      case GL_TEXTURE_COORD_ARRAY_SIZE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Size);
-+         break;
-+      case GL_TEXTURE_COORD_ARRAY_TYPE:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Type);
-+         break;
-+      case GL_TEXTURE_COORD_ARRAY_STRIDE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Stride);
-+         break;
-+      case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
-+         params[0] = INT_TO_BOOLEAN(0);
-+         break;
-+      case GL_EDGE_FLAG_ARRAY:
-+         params[0] = ctx->Array.ArrayObj->EdgeFlag.Enabled;
-+         break;
-+      case GL_EDGE_FLAG_ARRAY_STRIDE:
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->EdgeFlag.Stride);
-+         break;
-+      case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
-+         params[0] = INT_TO_BOOLEAN(0);
-+         break;
-+      case GL_MAX_TEXTURE_UNITS_ARB:
-+         CHECK_EXT1(ARB_multitexture, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Const.MaxTextureUnits);
-+         break;
-+      case GL_ACTIVE_TEXTURE_ARB:
-+         CHECK_EXT1(ARB_multitexture, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit);
-+         break;
-+      case GL_CLIENT_ACTIVE_TEXTURE_ARB:
-+         CHECK_EXT1(ARB_multitexture, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(GL_TEXTURE0_ARB + ctx->Array.ActiveTexture);
-+         break;
-+      case GL_TEXTURE_CUBE_MAP_ARB:
-+         CHECK_EXT1(ARB_texture_cube_map, "GetBooleanv");
-+         params[0] = _mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB);
-+         break;
-+      case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-+         CHECK_EXT1(ARB_texture_cube_map, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap->Name);
-+         break;
-+      case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-+         CHECK_EXT1(ARB_texture_cube_map, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN((1 << (ctx->Const.MaxCubeTextureLevels - 1)));
-+         break;
-+      case GL_TEXTURE_COMPRESSION_HINT_ARB:
-+         CHECK_EXT1(ARB_texture_compression, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Hint.TextureCompression);
-+         break;
-+      case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-+         CHECK_EXT1(ARB_texture_compression, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(_mesa_get_compressed_formats(ctx, NULL, GL_FALSE));
-+         break;
-+      case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-+         CHECK_EXT1(ARB_texture_compression, "GetBooleanv");
-+         {
-+         GLint formats[100];
-+         GLuint i, n = _mesa_get_compressed_formats(ctx, formats, GL_FALSE);
-+         ASSERT(n <= 100);
-+         for (i = 0; i < n; i++)
-+            params[i] = ENUM_TO_INT(formats[i]);
-+         }
-+         break;
-+      case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
-+         CHECK_EXT1(EXT_compiled_vertex_array, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.LockFirst);
-+         break;
-+      case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
-+         CHECK_EXT1(EXT_compiled_vertex_array, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.LockCount);
-+         break;
-+      case GL_TRANSPOSE_COLOR_MATRIX_ARB:
-+         {
-+         const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
-+         params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(matrix[4]);
-+         params[2] = FLOAT_TO_BOOLEAN(matrix[8]);
-+         params[3] = FLOAT_TO_BOOLEAN(matrix[12]);
-+         params[4] = FLOAT_TO_BOOLEAN(matrix[1]);
-+         params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+         params[6] = FLOAT_TO_BOOLEAN(matrix[9]);
-+         params[7] = FLOAT_TO_BOOLEAN(matrix[13]);
-+         params[8] = FLOAT_TO_BOOLEAN(matrix[2]);
-+         params[9] = FLOAT_TO_BOOLEAN(matrix[6]);
-+         params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+         params[11] = FLOAT_TO_BOOLEAN(matrix[14]);
-+         params[12] = FLOAT_TO_BOOLEAN(matrix[3]);
-+         params[13] = FLOAT_TO_BOOLEAN(matrix[7]);
-+         params[14] = FLOAT_TO_BOOLEAN(matrix[11]);
-+         params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+         }
-+         break;
-+      case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
-+         {
-+         const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
-+         params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(matrix[4]);
-+         params[2] = FLOAT_TO_BOOLEAN(matrix[8]);
-+         params[3] = FLOAT_TO_BOOLEAN(matrix[12]);
-+         params[4] = FLOAT_TO_BOOLEAN(matrix[1]);
-+         params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+         params[6] = FLOAT_TO_BOOLEAN(matrix[9]);
-+         params[7] = FLOAT_TO_BOOLEAN(matrix[13]);
-+         params[8] = FLOAT_TO_BOOLEAN(matrix[2]);
-+         params[9] = FLOAT_TO_BOOLEAN(matrix[6]);
-+         params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+         params[11] = FLOAT_TO_BOOLEAN(matrix[14]);
-+         params[12] = FLOAT_TO_BOOLEAN(matrix[3]);
-+         params[13] = FLOAT_TO_BOOLEAN(matrix[7]);
-+         params[14] = FLOAT_TO_BOOLEAN(matrix[11]);
-+         params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+         }
-+         break;
-+      case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
-+         {
-+         const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
-+         params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(matrix[4]);
-+         params[2] = FLOAT_TO_BOOLEAN(matrix[8]);
-+         params[3] = FLOAT_TO_BOOLEAN(matrix[12]);
-+         params[4] = FLOAT_TO_BOOLEAN(matrix[1]);
-+         params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+         params[6] = FLOAT_TO_BOOLEAN(matrix[9]);
-+         params[7] = FLOAT_TO_BOOLEAN(matrix[13]);
-+         params[8] = FLOAT_TO_BOOLEAN(matrix[2]);
-+         params[9] = FLOAT_TO_BOOLEAN(matrix[6]);
-+         params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+         params[11] = FLOAT_TO_BOOLEAN(matrix[14]);
-+         params[12] = FLOAT_TO_BOOLEAN(matrix[3]);
-+         params[13] = FLOAT_TO_BOOLEAN(matrix[7]);
-+         params[14] = FLOAT_TO_BOOLEAN(matrix[11]);
-+         params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+         }
-+         break;
-+      case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
-+         {
-+         const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
-+         params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(matrix[4]);
-+         params[2] = FLOAT_TO_BOOLEAN(matrix[8]);
-+         params[3] = FLOAT_TO_BOOLEAN(matrix[12]);
-+         params[4] = FLOAT_TO_BOOLEAN(matrix[1]);
-+         params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+         params[6] = FLOAT_TO_BOOLEAN(matrix[9]);
-+         params[7] = FLOAT_TO_BOOLEAN(matrix[13]);
-+         params[8] = FLOAT_TO_BOOLEAN(matrix[2]);
-+         params[9] = FLOAT_TO_BOOLEAN(matrix[6]);
-+         params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+         params[11] = FLOAT_TO_BOOLEAN(matrix[14]);
-+         params[12] = FLOAT_TO_BOOLEAN(matrix[3]);
-+         params[13] = FLOAT_TO_BOOLEAN(matrix[7]);
-+         params[14] = FLOAT_TO_BOOLEAN(matrix[11]);
-+         params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+         }
-+         break;
-+      case GL_COLOR_MATRIX_SGI:
-+         {
-+         const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
-+         params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(matrix[1]);
-+         params[2] = FLOAT_TO_BOOLEAN(matrix[2]);
-+         params[3] = FLOAT_TO_BOOLEAN(matrix[3]);
-+         params[4] = FLOAT_TO_BOOLEAN(matrix[4]);
-+         params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+         params[6] = FLOAT_TO_BOOLEAN(matrix[6]);
-+         params[7] = FLOAT_TO_BOOLEAN(matrix[7]);
-+         params[8] = FLOAT_TO_BOOLEAN(matrix[8]);
-+         params[9] = FLOAT_TO_BOOLEAN(matrix[9]);
-+         params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+         params[11] = FLOAT_TO_BOOLEAN(matrix[11]);
-+         params[12] = FLOAT_TO_BOOLEAN(matrix[12]);
-+         params[13] = FLOAT_TO_BOOLEAN(matrix[13]);
-+         params[14] = FLOAT_TO_BOOLEAN(matrix[14]);
-+         params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+         }
-+         break;
-+      case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
-+         params[0] = INT_TO_BOOLEAN(ctx->ColorMatrixStack.Depth + 1);
-+         break;
-+      case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
-+         params[0] = INT_TO_BOOLEAN(MAX_COLOR_STACK_DEPTH);
-+         break;
-+      case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixScale[0]);
-+         break;
-+      case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixScale[1]);
-+         break;
-+      case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixScale[2]);
-+         break;
-+      case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixScale[3]);
-+         break;
-+      case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixBias[0]);
-+         break;
-+      case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixBias[1]);
-+         break;
-+      case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixBias[2]);
-+         break;
-+      case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostColorMatrixBias[3]);
-+         break;
-+      case GL_CONVOLUTION_1D_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+         params[0] = ctx->Pixel.Convolution1DEnabled;
-+         break;
-+      case GL_CONVOLUTION_2D_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+         params[0] = ctx->Pixel.Convolution2DEnabled;
-+         break;
-+      case GL_SEPARABLE_2D_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+         params[0] = ctx->Pixel.Separable2DEnabled;
-+         break;
-+      case GL_POST_CONVOLUTION_RED_SCALE_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionScale[0]);
-+         break;
-+      case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionScale[1]);
-+         break;
-+      case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionScale[2]);
-+         break;
-+      case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionScale[3]);
-+         break;
-+      case GL_POST_CONVOLUTION_RED_BIAS_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionBias[0]);
-+         break;
-+      case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionBias[1]);
-+         break;
-+      case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionBias[2]);
-+         break;
-+      case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetBooleanv");
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Pixel.PostConvolutionBias[3]);
-+         break;
-+      case GL_HISTOGRAM:
-+         CHECK_EXT1(EXT_histogram, "GetBooleanv");
-+         params[0] = ctx->Pixel.HistogramEnabled;
-+         break;
-+      case GL_MINMAX:
-+         CHECK_EXT1(EXT_histogram, "GetBooleanv");
-+         params[0] = ctx->Pixel.MinMaxEnabled;
-+         break;
-+      case GL_COLOR_TABLE_SGI:
-+         CHECK_EXT1(SGI_color_table, "GetBooleanv");
-+         params[0] = ctx->Pixel.ColorTableEnabled;
-+         break;
-+      case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
-+         CHECK_EXT1(SGI_color_table, "GetBooleanv");
-+         params[0] = ctx->Pixel.PostConvolutionColorTableEnabled;
-+         break;
-+      case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
-+         CHECK_EXT1(SGI_color_table, "GetBooleanv");
-+         params[0] = ctx->Pixel.PostColorMatrixColorTableEnabled;
-+         break;
-+      case GL_TEXTURE_COLOR_TABLE_SGI:
-+         CHECK_EXT1(SGI_texture_color_table, "GetBooleanv");
-+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled;
-+         break;
-+      case GL_COLOR_SUM_EXT:
-+         CHECK_EXT2(EXT_secondary_color, ARB_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Fog.ColorSumEnabled;
-+         break;
-+      case GL_CURRENT_SECONDARY_COLOR_EXT:
-+         CHECK_EXT1(EXT_secondary_color, "GetBooleanv");
-+         {
-+         FLUSH_CURRENT(ctx, 0);
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0]);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1]);
-+         params[2] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2]);
-+         params[3] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][3]);
-+         }
-+         break;
-+      case GL_SECONDARY_COLOR_ARRAY_EXT:
-+         CHECK_EXT1(EXT_secondary_color, "GetBooleanv");
-+         params[0] = ctx->Array.ArrayObj->SecondaryColor.Enabled;
-+         break;
-+      case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
-+         CHECK_EXT1(EXT_secondary_color, "GetBooleanv");
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Array.ArrayObj->SecondaryColor.Type);
-+         break;
-+      case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
-+         CHECK_EXT1(EXT_secondary_color, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->SecondaryColor.Stride);
-+         break;
-+      case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
-+         CHECK_EXT1(EXT_secondary_color, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->SecondaryColor.Size);
-+         break;
-+      case GL_CURRENT_FOG_COORDINATE_EXT:
-+         CHECK_EXT1(EXT_fog_coord, "GetBooleanv");
-+         {
-+         FLUSH_CURRENT(ctx, 0);
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Current.Attrib[VERT_ATTRIB_FOG][0]);
-+         }
-+         break;
-+      case GL_FOG_COORDINATE_ARRAY_EXT:
-+         CHECK_EXT1(EXT_fog_coord, "GetBooleanv");
-+         params[0] = ctx->Array.ArrayObj->FogCoord.Enabled;
-+         break;
-+      case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
-+         CHECK_EXT1(EXT_fog_coord, "GetBooleanv");
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Array.ArrayObj->FogCoord.Type);
-+         break;
-+      case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
-+         CHECK_EXT1(EXT_fog_coord, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->FogCoord.Stride);
-+         break;
-+      case GL_FOG_COORDINATE_SOURCE_EXT:
-+         CHECK_EXT1(EXT_fog_coord, "GetBooleanv");
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Fog.FogCoordinateSource);
-+         break;
-+      case GL_MAX_TEXTURE_LOD_BIAS_EXT:
-+         CHECK_EXT1(EXT_texture_lod_bias, "GetBooleanv");
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MaxTextureLodBias);
-+         break;
-+      case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
-+         CHECK_EXT1(EXT_texture_filter_anisotropic, "GetBooleanv");
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MaxTextureMaxAnisotropy);
-+         break;
-+      case GL_MULTISAMPLE_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetBooleanv");
-+         params[0] = ctx->Multisample.Enabled;
-+         break;
-+      case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetBooleanv");
-+         params[0] = ctx->Multisample.SampleAlphaToCoverage;
-+         break;
-+      case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetBooleanv");
-+         params[0] = ctx->Multisample.SampleAlphaToOne;
-+         break;
-+      case GL_SAMPLE_COVERAGE_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetBooleanv");
-+         params[0] = ctx->Multisample.SampleCoverage;
-+         break;
-+      case GL_SAMPLE_COVERAGE_VALUE_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetBooleanv");
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Multisample.SampleCoverageValue);
-+         break;
-+      case GL_SAMPLE_COVERAGE_INVERT_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetBooleanv");
-+         params[0] = ctx->Multisample.SampleCoverageInvert;
-+         break;
-+      case GL_SAMPLE_BUFFERS_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.sampleBuffers);
-+         break;
-+      case GL_SAMPLES_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Visual.samples);
-+         break;
-+      case GL_RASTER_POSITION_UNCLIPPED_IBM:
-+         CHECK_EXT1(IBM_rasterpos_clip, "GetBooleanv");
-+         params[0] = ctx->Transform.RasterPositionUnclipped;
-+         break;
-+      case GL_POINT_SPRITE_NV:
-+         CHECK_EXT2(NV_point_sprite, ARB_point_sprite, "GetBooleanv");
-+         params[0] = ctx->Point.PointSprite;
-+         break;
-+      case GL_POINT_SPRITE_R_MODE_NV:
-+         CHECK_EXT1(NV_point_sprite, "GetBooleanv");
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Point.SpriteRMode);
-+         break;
-+      case GL_POINT_SPRITE_COORD_ORIGIN:
-+         CHECK_EXT2(NV_point_sprite, ARB_point_sprite, "GetBooleanv");
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Point.SpriteOrigin);
-+         break;
-+      case GL_GENERATE_MIPMAP_HINT_SGIS:
-+         CHECK_EXT1(SGIS_generate_mipmap, "GetBooleanv");
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Hint.GenerateMipmap);
-+         break;
-+      case GL_VERTEX_PROGRAM_BINDING_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN((ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0));
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY0_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Array.ArrayObj->VertexAttrib[0].Enabled;
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY1_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Array.ArrayObj->VertexAttrib[1].Enabled;
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY2_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Array.ArrayObj->VertexAttrib[2].Enabled;
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY3_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Array.ArrayObj->VertexAttrib[3].Enabled;
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Array.ArrayObj->VertexAttrib[4].Enabled;
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY5_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Array.ArrayObj->VertexAttrib[5].Enabled;
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY6_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Array.ArrayObj->VertexAttrib[6].Enabled;
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY7_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Array.ArrayObj->VertexAttrib[7].Enabled;
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY8_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Array.ArrayObj->VertexAttrib[8].Enabled;
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY9_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Array.ArrayObj->VertexAttrib[9].Enabled;
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY10_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Array.ArrayObj->VertexAttrib[10].Enabled;
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY11_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Array.ArrayObj->VertexAttrib[11].Enabled;
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY12_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Array.ArrayObj->VertexAttrib[12].Enabled;
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY13_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Array.ArrayObj->VertexAttrib[13].Enabled;
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY14_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Array.ArrayObj->VertexAttrib[14].Enabled;
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY15_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Array.ArrayObj->VertexAttrib[15].Enabled;
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB0_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Eval.Map1Attrib[0];
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB1_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Eval.Map1Attrib[1];
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB2_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Eval.Map1Attrib[2];
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB3_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Eval.Map1Attrib[3];
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB4_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Eval.Map1Attrib[4];
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB5_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Eval.Map1Attrib[5];
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB6_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Eval.Map1Attrib[6];
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB7_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Eval.Map1Attrib[7];
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB8_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Eval.Map1Attrib[8];
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB9_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Eval.Map1Attrib[9];
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB10_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Eval.Map1Attrib[10];
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB11_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Eval.Map1Attrib[11];
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB12_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Eval.Map1Attrib[12];
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB13_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Eval.Map1Attrib[13];
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB14_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Eval.Map1Attrib[14];
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB15_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->Eval.Map1Attrib[15];
-+         break;
-+      case GL_FRAGMENT_PROGRAM_NV:
-+         CHECK_EXT1(NV_fragment_program, "GetBooleanv");
-+         params[0] = ctx->FragmentProgram.Enabled;
-+         break;
-+      case GL_FRAGMENT_PROGRAM_BINDING_NV:
-+         CHECK_EXT1(NV_fragment_program, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->FragmentProgram.Current ? ctx->FragmentProgram.Current->Base.Id : 0);
-+         break;
-+      case GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV:
-+         CHECK_EXT1(NV_fragment_program, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(MAX_NV_FRAGMENT_PROGRAM_PARAMS);
-+         break;
-+      case GL_TEXTURE_RECTANGLE_NV:
-+         CHECK_EXT1(NV_texture_rectangle, "GetBooleanv");
-+         params[0] = _mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV);
-+         break;
-+      case GL_TEXTURE_BINDING_RECTANGLE_NV:
-+         CHECK_EXT1(NV_texture_rectangle, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentRect->Name);
-+         break;
-+      case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
-+         CHECK_EXT1(NV_texture_rectangle, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Const.MaxTextureRectSize);
-+         break;
-+      case GL_STENCIL_TEST_TWO_SIDE_EXT:
-+         CHECK_EXT1(EXT_stencil_two_side, "GetBooleanv");
-+         params[0] = ctx->Stencil.TestTwoSide;
-+         break;
-+      case GL_ACTIVE_STENCIL_FACE_EXT:
-+         CHECK_EXT1(EXT_stencil_two_side, "GetBooleanv");
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT);
-+         break;
-+      case GL_MAX_SHININESS_NV:
-+         CHECK_EXT1(NV_light_max_exponent, "GetBooleanv");
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MaxShininess);
-+         break;
-+      case GL_MAX_SPOT_EXPONENT_NV:
-+         CHECK_EXT1(NV_light_max_exponent, "GetBooleanv");
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Const.MaxSpotExponent);
-+         break;
-+      case GL_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayBufferObj->Name);
-+         break;
-+      case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Vertex.BufferObj->Name);
-+         break;
-+      case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Normal.BufferObj->Name);
-+         break;
-+      case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Color.BufferObj->Name);
-+         break;
-+      case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->Index.BufferObj->Name);
-+         break;
-+      case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].BufferObj->Name);
-+         break;
-+      case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->EdgeFlag.BufferObj->Name);
-+         break;
-+      case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->SecondaryColor.BufferObj->Name);
-+         break;
-+      case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ArrayObj->FogCoord.BufferObj->Name);
-+         break;
-+      case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Array.ElementArrayBufferObj->Name);
-+         break;
-+      case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
-+         CHECK_EXT1(EXT_pixel_buffer_object, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Pack.BufferObj->Name);
-+         break;
-+      case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:
-+         CHECK_EXT1(EXT_pixel_buffer_object, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Unpack.BufferObj->Name);
-+         break;
-+      case GL_VERTEX_PROGRAM_ARB:
-+         CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->VertexProgram.Enabled;
-+         break;
-+      case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
-+         CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->VertexProgram.PointSizeEnabled;
-+         break;
-+      case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
-+         CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->VertexProgram.TwoSideEnabled;
-+         break;
-+      case GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB:
-+         CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Const.MaxProgramMatrixStackDepth);
-+         break;
-+      case GL_MAX_PROGRAM_MATRICES_ARB:
-+         CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Const.MaxProgramMatrices);
-+         break;
-+      case GL_CURRENT_MATRIX_STACK_DEPTH_ARB:
-+         CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetBooleanv");
-+         params[0] = ctx->CurrentStack->Depth + 1;
-+         break;
-+      case GL_CURRENT_MATRIX_ARB:
-+         CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_fragment_program, "GetBooleanv");
-+         {
-+         const GLfloat *matrix = ctx->CurrentStack->Top->m;
-+         params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(matrix[1]);
-+         params[2] = FLOAT_TO_BOOLEAN(matrix[2]);
-+         params[3] = FLOAT_TO_BOOLEAN(matrix[3]);
-+         params[4] = FLOAT_TO_BOOLEAN(matrix[4]);
-+         params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+         params[6] = FLOAT_TO_BOOLEAN(matrix[6]);
-+         params[7] = FLOAT_TO_BOOLEAN(matrix[7]);
-+         params[8] = FLOAT_TO_BOOLEAN(matrix[8]);
-+         params[9] = FLOAT_TO_BOOLEAN(matrix[9]);
-+         params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+         params[11] = FLOAT_TO_BOOLEAN(matrix[11]);
-+         params[12] = FLOAT_TO_BOOLEAN(matrix[12]);
-+         params[13] = FLOAT_TO_BOOLEAN(matrix[13]);
-+         params[14] = FLOAT_TO_BOOLEAN(matrix[14]);
-+         params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+         }
-+         break;
-+      case GL_TRANSPOSE_CURRENT_MATRIX_ARB:
-+         CHECK_EXT2(ARB_vertex_program, ARB_fragment_program, "GetBooleanv");
-+         {
-+         const GLfloat *matrix = ctx->CurrentStack->Top->m;
-+         params[0] = FLOAT_TO_BOOLEAN(matrix[0]);
-+         params[1] = FLOAT_TO_BOOLEAN(matrix[4]);
-+         params[2] = FLOAT_TO_BOOLEAN(matrix[8]);
-+         params[3] = FLOAT_TO_BOOLEAN(matrix[12]);
-+         params[4] = FLOAT_TO_BOOLEAN(matrix[1]);
-+         params[5] = FLOAT_TO_BOOLEAN(matrix[5]);
-+         params[6] = FLOAT_TO_BOOLEAN(matrix[9]);
-+         params[7] = FLOAT_TO_BOOLEAN(matrix[13]);
-+         params[8] = FLOAT_TO_BOOLEAN(matrix[2]);
-+         params[9] = FLOAT_TO_BOOLEAN(matrix[6]);
-+         params[10] = FLOAT_TO_BOOLEAN(matrix[10]);
-+         params[11] = FLOAT_TO_BOOLEAN(matrix[14]);
-+         params[12] = FLOAT_TO_BOOLEAN(matrix[3]);
-+         params[13] = FLOAT_TO_BOOLEAN(matrix[7]);
-+         params[14] = FLOAT_TO_BOOLEAN(matrix[11]);
-+         params[15] = FLOAT_TO_BOOLEAN(matrix[15]);
-+         }
-+         break;
-+      case GL_MAX_VERTEX_ATTRIBS_ARB:
-+         CHECK_EXT1(ARB_vertex_program, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Const.VertexProgram.MaxAttribs);
-+         break;
-+      case GL_PROGRAM_ERROR_POSITION_ARB:
-+         CHECK_EXT4(NV_vertex_program, ARB_vertex_program, NV_fragment_program, ARB_fragment_program, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Program.ErrorPos);
-+         break;
-+      case GL_FRAGMENT_PROGRAM_ARB:
-+         CHECK_EXT1(ARB_fragment_program, "GetBooleanv");
-+         params[0] = ctx->FragmentProgram.Enabled;
-+         break;
-+      case GL_MAX_TEXTURE_COORDS_ARB:
-+         CHECK_EXT2(ARB_fragment_program, NV_fragment_program, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Const.MaxTextureCoordUnits);
-+         break;
-+      case GL_MAX_TEXTURE_IMAGE_UNITS_ARB:
-+         CHECK_EXT2(ARB_fragment_program, NV_fragment_program, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Const.MaxTextureImageUnits);
-+         break;
-+      case GL_DEPTH_BOUNDS_TEST_EXT:
-+         CHECK_EXT1(EXT_depth_bounds_test, "GetBooleanv");
-+         params[0] = ctx->Depth.BoundsTest;
-+         break;
-+      case GL_DEPTH_BOUNDS_EXT:
-+         CHECK_EXT1(EXT_depth_bounds_test, "GetBooleanv");
-+         params[0] = FLOAT_TO_BOOLEAN(ctx->Depth.BoundsMin);
-+         params[1] = FLOAT_TO_BOOLEAN(ctx->Depth.BoundsMax);
-+         break;
-+      case GL_FRAGMENT_PROGRAM_CALLBACK_MESA:
-+         CHECK_EXT1(MESA_program_debug, "GetBooleanv");
-+         params[0] = ctx->FragmentProgram.CallbackEnabled;
-+         break;
-+      case GL_VERTEX_PROGRAM_CALLBACK_MESA:
-+         CHECK_EXT1(MESA_program_debug, "GetBooleanv");
-+         params[0] = ctx->VertexProgram.CallbackEnabled;
-+         break;
-+      case GL_FRAGMENT_PROGRAM_POSITION_MESA:
-+         CHECK_EXT1(MESA_program_debug, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->FragmentProgram.CurrentPosition);
-+         break;
-+      case GL_VERTEX_PROGRAM_POSITION_MESA:
-+         CHECK_EXT1(MESA_program_debug, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->VertexProgram.CurrentPosition);
-+         break;
-+      case GL_MAX_DRAW_BUFFERS_ARB:
-+         CHECK_EXT1(ARB_draw_buffers, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Const.MaxDrawBuffers);
-+         break;
-+      case GL_DRAW_BUFFER0_ARB:
-+         CHECK_EXT1(ARB_draw_buffers, "GetBooleanv");
-+         params[0] = ENUM_TO_BOOLEAN(ctx->DrawBuffer->ColorDrawBuffer[0]);
-+         break;
-+      case GL_DRAW_BUFFER1_ARB:
-+         CHECK_EXT1(ARB_draw_buffers, "GetBooleanv");
-+         {
-+         GLenum buffer;
-+         if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-+            _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
-+            return;
-+         }
-+         buffer = ctx->DrawBuffer->ColorDrawBuffer[1];
-+         params[0] = ENUM_TO_BOOLEAN(buffer);
-+         }
-+         break;
-+      case GL_DRAW_BUFFER2_ARB:
-+         CHECK_EXT1(ARB_draw_buffers, "GetBooleanv");
-+         {
-+         GLenum buffer;
-+         if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-+            _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
-+            return;
-+         }
-+         buffer = ctx->DrawBuffer->ColorDrawBuffer[2];
-+         params[0] = ENUM_TO_BOOLEAN(buffer);
-+         }
-+         break;
-+      case GL_DRAW_BUFFER3_ARB:
-+         CHECK_EXT1(ARB_draw_buffers, "GetBooleanv");
-+         {
-+         GLenum buffer;
-+         if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-+            _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
-+            return;
-+         }
-+         buffer = ctx->DrawBuffer->ColorDrawBuffer[3];
-+         params[0] = ENUM_TO_BOOLEAN(buffer);
-+         }
-+         break;
-+      case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
-+         CHECK_EXT1(OES_read_format, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Const.ColorReadType);
-+         break;
-+      case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
-+         CHECK_EXT1(OES_read_format, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Const.ColorReadFormat);
-+         break;
-+      case GL_NUM_FRAGMENT_REGISTERS_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(6);
-+         break;
-+      case GL_NUM_FRAGMENT_CONSTANTS_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(8);
-+         break;
-+      case GL_NUM_PASSES_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(2);
-+         break;
-+      case GL_NUM_INSTRUCTIONS_PER_PASS_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(8);
-+         break;
-+      case GL_NUM_INSTRUCTIONS_TOTAL_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(16);
-+         break;
-+      case GL_COLOR_ALPHA_PAIRING_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetBooleanv");
-+         params[0] = GL_TRUE;
-+         break;
-+      case GL_NUM_LOOPBACK_COMPONENTS_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(3);
-+         break;
-+      case GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(3);
-+         break;
-+      case GL_STENCIL_BACK_FUNC:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.Function[1]);
-+         break;
-+      case GL_STENCIL_BACK_VALUE_MASK:
-+         params[0] = INT_TO_BOOLEAN(ctx->Stencil.ValueMask[1]);
-+         break;
-+      case GL_STENCIL_BACK_REF:
-+         params[0] = INT_TO_BOOLEAN(ctx->Stencil.Ref[1]);
-+         break;
-+      case GL_STENCIL_BACK_FAIL:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.FailFunc[1]);
-+         break;
-+      case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.ZFailFunc[1]);
-+         break;
-+      case GL_STENCIL_BACK_PASS_DEPTH_PASS:
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Stencil.ZPassFunc[1]);
-+         break;
-+      case GL_FRAMEBUFFER_BINDING_EXT:
-+         CHECK_EXT1(EXT_framebuffer_object, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->DrawBuffer->Name);
-+         break;
-+      case GL_RENDERBUFFER_BINDING_EXT:
-+         CHECK_EXT1(EXT_framebuffer_object, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0);
-+         break;
-+      case GL_MAX_COLOR_ATTACHMENTS_EXT:
-+         CHECK_EXT1(EXT_framebuffer_object, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Const.MaxColorAttachments);
-+         break;
-+      case GL_MAX_RENDERBUFFER_SIZE_EXT:
-+         CHECK_EXT1(EXT_framebuffer_object, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(ctx->Const.MaxRenderbufferSize);
-+         break;
-+      case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB:
-+         CHECK_EXT1(ARB_fragment_shader, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(MAX_FRAGMENT_UNIFORM_COMPONENTS);
-+         break;
-+      case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB:
-+         CHECK_EXT1(ARB_fragment_shader, "GetBooleanv");
-+         params[0] = ENUM_TO_BOOLEAN(ctx->Hint.FragmentShaderDerivative);
-+         break;
-+      case GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB:
-+         CHECK_EXT1(ARB_vertex_shader, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(MAX_VERTEX_UNIFORM_COMPONENTS);
-+         break;
-+      case GL_MAX_VARYING_FLOATS_ARB:
-+         CHECK_EXT1(ARB_vertex_shader, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(MAX_VARYING_FLOATS);
-+         break;
-+      case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB:
-+         CHECK_EXT1(ARB_vertex_shader, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(MAX_VERTEX_TEXTURE_IMAGE_UNITS);
-+         break;
-+      case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB:
-+         CHECK_EXT1(ARB_vertex_shader, "GetBooleanv");
-+         params[0] = INT_TO_BOOLEAN(MAX_COMBINED_TEXTURE_IMAGE_UNITS);
-+         break;
-+      default:
-+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetBooleanv(pname=0x%x)", pname);
-+   }
-+}
-+
-+void GLAPIENTRY
-+_mesa_GetFloatv( GLenum pname, GLfloat *params )
-+{
-+   GET_CURRENT_CONTEXT(ctx);
-+   ASSERT_OUTSIDE_BEGIN_END(ctx);
-+
-+   if (!params)
-+      return;
-+
-+   if (ctx->NewState)
-+      _mesa_update_state(ctx);
-+
-+   if (ctx->Driver.GetFloatv &&
-+       ctx->Driver.GetFloatv(ctx, pname, params))
-+      return;
-+
-+   switch (pname) {
-+      case GL_ACCUM_RED_BITS:
-+         params[0] = (GLfloat)(ctx->DrawBuffer->Visual.accumRedBits);
-+         break;
-+      case GL_ACCUM_GREEN_BITS:
-+         params[0] = (GLfloat)(ctx->DrawBuffer->Visual.accumGreenBits);
-+         break;
-+      case GL_ACCUM_BLUE_BITS:
-+         params[0] = (GLfloat)(ctx->DrawBuffer->Visual.accumBlueBits);
-+         break;
-+      case GL_ACCUM_ALPHA_BITS:
-+         params[0] = (GLfloat)(ctx->DrawBuffer->Visual.accumAlphaBits);
-+         break;
-+      case GL_ACCUM_CLEAR_VALUE:
-+         params[0] = ctx->Accum.ClearColor[0];
-+         params[1] = ctx->Accum.ClearColor[1];
-+         params[2] = ctx->Accum.ClearColor[2];
-+         params[3] = ctx->Accum.ClearColor[3];
-+         break;
-+      case GL_ALPHA_BIAS:
-+         params[0] = ctx->Pixel.AlphaBias;
-+         break;
-+      case GL_ALPHA_BITS:
-+         params[0] = (GLfloat)(ctx->DrawBuffer->Visual.alphaBits);
-+         break;
-+      case GL_ALPHA_SCALE:
-+         params[0] = ctx->Pixel.AlphaScale;
-+         break;
-+      case GL_ALPHA_TEST:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Color.AlphaEnabled);
-+         break;
-+      case GL_ALPHA_TEST_FUNC:
-+         params[0] = ENUM_TO_FLOAT(ctx->Color.AlphaFunc);
-+         break;
-+      case GL_ALPHA_TEST_REF:
-+         params[0] = ctx->Color.AlphaRef;
-+         break;
-+      case GL_ATTRIB_STACK_DEPTH:
-+         params[0] = (GLfloat)(ctx->AttribStackDepth);
-+         break;
-+      case GL_AUTO_NORMAL:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.AutoNormal);
-+         break;
-+      case GL_AUX_BUFFERS:
-+         params[0] = (GLfloat)(ctx->DrawBuffer->Visual.numAuxBuffers);
-+         break;
-+      case GL_BLEND:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Color.BlendEnabled);
-+         break;
-+      case GL_BLEND_DST:
-+         params[0] = ENUM_TO_FLOAT(ctx->Color.BlendDstRGB);
-+         break;
-+      case GL_BLEND_SRC:
-+         params[0] = ENUM_TO_FLOAT(ctx->Color.BlendSrcRGB);
-+         break;
-+      case GL_BLEND_SRC_RGB_EXT:
-+         params[0] = ENUM_TO_FLOAT(ctx->Color.BlendSrcRGB);
-+         break;
-+      case GL_BLEND_DST_RGB_EXT:
-+         params[0] = ENUM_TO_FLOAT(ctx->Color.BlendDstRGB);
-+         break;
-+      case GL_BLEND_SRC_ALPHA_EXT:
-+         params[0] = ENUM_TO_FLOAT(ctx->Color.BlendSrcA);
-+         break;
-+      case GL_BLEND_DST_ALPHA_EXT:
-+         params[0] = ENUM_TO_FLOAT(ctx->Color.BlendDstA);
-+         break;
-+      case GL_BLEND_EQUATION:
-+         params[0] = ENUM_TO_FLOAT(ctx->Color.BlendEquationRGB );
-+         break;
-+      case GL_BLEND_EQUATION_ALPHA_EXT:
-+         params[0] = ENUM_TO_FLOAT(ctx->Color.BlendEquationA );
-+         break;
-+      case GL_BLEND_COLOR_EXT:
-+         params[0] = ctx->Color.BlendColor[0];
-+         params[1] = ctx->Color.BlendColor[1];
-+         params[2] = ctx->Color.BlendColor[2];
-+         params[3] = ctx->Color.BlendColor[3];
-+         break;
-+      case GL_BLUE_BIAS:
-+         params[0] = ctx->Pixel.BlueBias;
-+         break;
-+      case GL_BLUE_BITS:
-+         params[0] = (GLfloat)(ctx->DrawBuffer->Visual.blueBits);
-+         break;
-+      case GL_BLUE_SCALE:
-+         params[0] = ctx->Pixel.BlueScale;
-+         break;
-+      case GL_CLIENT_ATTRIB_STACK_DEPTH:
-+         params[0] = (GLfloat)(ctx->ClientAttribStackDepth);
-+         break;
-+      case GL_CLIP_PLANE0:
-+         params[0] = BOOLEAN_TO_FLOAT((ctx->Transform.ClipPlanesEnabled >> 0) & 1);
-+         break;
-+      case GL_CLIP_PLANE1:
-+         params[0] = BOOLEAN_TO_FLOAT((ctx->Transform.ClipPlanesEnabled >> 1) & 1);
-+         break;
-+      case GL_CLIP_PLANE2:
-+         params[0] = BOOLEAN_TO_FLOAT((ctx->Transform.ClipPlanesEnabled >> 2) & 1);
-+         break;
-+      case GL_CLIP_PLANE3:
-+         params[0] = BOOLEAN_TO_FLOAT((ctx->Transform.ClipPlanesEnabled >> 3) & 1);
-+         break;
-+      case GL_CLIP_PLANE4:
-+         params[0] = BOOLEAN_TO_FLOAT((ctx->Transform.ClipPlanesEnabled >> 4) & 1);
-+         break;
-+      case GL_CLIP_PLANE5:
-+         params[0] = BOOLEAN_TO_FLOAT((ctx->Transform.ClipPlanesEnabled >> 5) & 1);
-+         break;
-+      case GL_COLOR_CLEAR_VALUE:
-+         params[0] = ctx->Color.ClearColor[0];
-+         params[1] = ctx->Color.ClearColor[1];
-+         params[2] = ctx->Color.ClearColor[2];
-+         params[3] = ctx->Color.ClearColor[3];
-+         break;
-+      case GL_COLOR_MATERIAL:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Light.ColorMaterialEnabled);
-+         break;
-+      case GL_COLOR_MATERIAL_FACE:
-+         params[0] = ENUM_TO_FLOAT(ctx->Light.ColorMaterialFace);
-+         break;
-+      case GL_COLOR_MATERIAL_PARAMETER:
-+         params[0] = ENUM_TO_FLOAT(ctx->Light.ColorMaterialMode);
-+         break;
-+      case GL_COLOR_WRITEMASK:
-+         params[0] = (GLfloat)(ctx->Color.ColorMask[RCOMP] ? 1 : 0);
-+         params[1] = (GLfloat)(ctx->Color.ColorMask[GCOMP] ? 1 : 0);
-+         params[2] = (GLfloat)(ctx->Color.ColorMask[BCOMP] ? 1 : 0);
-+         params[3] = (GLfloat)(ctx->Color.ColorMask[ACOMP] ? 1 : 0);
-+         break;
-+      case GL_CULL_FACE:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Polygon.CullFlag);
-+         break;
-+      case GL_CULL_FACE_MODE:
-+         params[0] = ENUM_TO_FLOAT(ctx->Polygon.CullFaceMode);
-+         break;
-+      case GL_CURRENT_COLOR:
-+         {
-+         FLUSH_CURRENT(ctx, 0);
-+         params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0];
-+         params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1];
-+         params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2];
-+         params[3] = ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3];
-+         }
-+         break;
-+      case GL_CURRENT_INDEX:
-+         {
-+         FLUSH_CURRENT(ctx, 0);
-+         params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX][0];
-+         }
-+         break;
-+      case GL_CURRENT_NORMAL:
-+         {
-+         FLUSH_CURRENT(ctx, 0);
-+         params[0] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0];
-+         params[1] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1];
-+         params[2] = ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2];
-+         }
-+         break;
-+      case GL_CURRENT_RASTER_COLOR:
-+         params[0] = ctx->Current.RasterColor[0];
-+         params[1] = ctx->Current.RasterColor[1];
-+         params[2] = ctx->Current.RasterColor[2];
-+         params[3] = ctx->Current.RasterColor[3];
-+         break;
-+      case GL_CURRENT_RASTER_DISTANCE:
-+         params[0] = ctx->Current.RasterDistance;
-+         break;
-+      case GL_CURRENT_RASTER_INDEX:
-+         params[0] = ctx->Current.RasterIndex;
-+         break;
-+      case GL_CURRENT_RASTER_POSITION:
-+         params[0] = ctx->Current.RasterPos[0];
-+         params[1] = ctx->Current.RasterPos[1];
-+         params[2] = ctx->Current.RasterPos[2];
-+         params[3] = ctx->Current.RasterPos[3];
-+         break;
-+      case GL_CURRENT_RASTER_SECONDARY_COLOR:
-+         params[0] = ctx->Current.RasterSecondaryColor[0];
-+         params[1] = ctx->Current.RasterSecondaryColor[1];
-+         params[2] = ctx->Current.RasterSecondaryColor[2];
-+         params[3] = ctx->Current.RasterSecondaryColor[3];
-+         break;
-+      case GL_CURRENT_RASTER_TEXTURE_COORDS:
-+         {
-+         const GLuint texUnit = ctx->Texture.CurrentUnit;
-+         params[0] = ctx->Current.RasterTexCoords[texUnit][0];
-+         params[1] = ctx->Current.RasterTexCoords[texUnit][1];
-+         params[2] = ctx->Current.RasterTexCoords[texUnit][2];
-+         params[3] = ctx->Current.RasterTexCoords[texUnit][3];
-+         }
-+         break;
-+      case GL_CURRENT_RASTER_POSITION_VALID:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Current.RasterPosValid);
-+         break;
-+      case GL_CURRENT_TEXTURE_COORDS:
-+         {
-+         const GLuint texUnit = ctx->Texture.CurrentUnit;
-+         params[0] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0];
-+         params[1] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1];
-+         params[2] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2];
-+         params[3] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3];
-+         }
-+         break;
-+      case GL_DEPTH_BIAS:
-+         params[0] = ctx->Pixel.DepthBias;
-+         break;
-+      case GL_DEPTH_BITS:
-+         params[0] = (GLfloat)(ctx->DrawBuffer->Visual.depthBits);
-+         break;
-+      case GL_DEPTH_CLEAR_VALUE:
-+         params[0] = ctx->Depth.Clear;
-+         break;
-+      case GL_DEPTH_FUNC:
-+         params[0] = ENUM_TO_FLOAT(ctx->Depth.Func);
-+         break;
-+      case GL_DEPTH_RANGE:
-+         params[0] = ctx->Viewport.Near;
-+         params[1] = ctx->Viewport.Far;
-+         break;
-+      case GL_DEPTH_SCALE:
-+         params[0] = ctx->Pixel.DepthScale;
-+         break;
-+      case GL_DEPTH_TEST:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Depth.Test);
-+         break;
-+      case GL_DEPTH_WRITEMASK:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Depth.Mask);
-+         break;
-+      case GL_DITHER:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Color.DitherFlag);
-+         break;
-+      case GL_DOUBLEBUFFER:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->DrawBuffer->Visual.doubleBufferMode);
-+         break;
-+      case GL_DRAW_BUFFER:
-+         params[0] = ENUM_TO_FLOAT(ctx->DrawBuffer->ColorDrawBuffer[0]);
-+         break;
-+      case GL_EDGE_FLAG:
-+         {
-+         FLUSH_CURRENT(ctx, 0);
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Current.EdgeFlag);
-+         }
-+         break;
-+      case GL_FEEDBACK_BUFFER_SIZE:
-+         params[0] = (GLfloat)(ctx->Feedback.BufferSize);
-+         break;
-+      case GL_FEEDBACK_BUFFER_TYPE:
-+         params[0] = ENUM_TO_FLOAT(ctx->Feedback.Type);
-+         break;
-+      case GL_FOG:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Fog.Enabled);
-+         break;
-+      case GL_FOG_COLOR:
-+         params[0] = ctx->Fog.Color[0];
-+         params[1] = ctx->Fog.Color[1];
-+         params[2] = ctx->Fog.Color[2];
-+         params[3] = ctx->Fog.Color[3];
-+         break;
-+      case GL_FOG_DENSITY:
-+         params[0] = ctx->Fog.Density;
-+         break;
-+      case GL_FOG_END:
-+         params[0] = ctx->Fog.End;
-+         break;
-+      case GL_FOG_HINT:
-+         params[0] = ENUM_TO_FLOAT(ctx->Hint.Fog);
-+         break;
-+      case GL_FOG_INDEX:
-+         params[0] = ctx->Fog.Index;
-+         break;
-+      case GL_FOG_MODE:
-+         params[0] = ENUM_TO_FLOAT(ctx->Fog.Mode);
-+         break;
-+      case GL_FOG_START:
-+         params[0] = ctx->Fog.Start;
-+         break;
-+      case GL_FRONT_FACE:
-+         params[0] = ENUM_TO_FLOAT(ctx->Polygon.FrontFace);
-+         break;
-+      case GL_GREEN_BIAS:
-+         params[0] = ctx->Pixel.GreenBias;
-+         break;
-+      case GL_GREEN_BITS:
-+         params[0] = (GLfloat)(ctx->DrawBuffer->Visual.greenBits);
-+         break;
-+      case GL_GREEN_SCALE:
-+         params[0] = ctx->Pixel.GreenScale;
-+         break;
-+      case GL_INDEX_BITS:
-+         params[0] = (GLfloat)(ctx->DrawBuffer->Visual.indexBits);
-+         break;
-+      case GL_INDEX_CLEAR_VALUE:
-+         params[0] = (GLfloat)(ctx->Color.ClearIndex);
-+         break;
-+      case GL_INDEX_MODE:
-+         params[0] = BOOLEAN_TO_FLOAT(!ctx->DrawBuffer->Visual.rgbMode);
-+         break;
-+      case GL_INDEX_OFFSET:
-+         params[0] = (GLfloat)(ctx->Pixel.IndexOffset);
-+         break;
-+      case GL_INDEX_SHIFT:
-+         params[0] = (GLfloat)(ctx->Pixel.IndexShift);
-+         break;
-+      case GL_INDEX_WRITEMASK:
-+         params[0] = (GLfloat)(ctx->Color.IndexMask);
-+         break;
-+      case GL_LIGHT0:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[0].Enabled);
-+         break;
-+      case GL_LIGHT1:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[1].Enabled);
-+         break;
-+      case GL_LIGHT2:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[2].Enabled);
-+         break;
-+      case GL_LIGHT3:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[3].Enabled);
-+         break;
-+      case GL_LIGHT4:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[4].Enabled);
-+         break;
-+      case GL_LIGHT5:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[5].Enabled);
-+         break;
-+      case GL_LIGHT6:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[6].Enabled);
-+         break;
-+      case GL_LIGHT7:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Light[7].Enabled);
-+         break;
-+      case GL_LIGHTING:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Enabled);
-+         break;
-+      case GL_LIGHT_MODEL_AMBIENT:
-+         params[0] = ctx->Light.Model.Ambient[0];
-+         params[1] = ctx->Light.Model.Ambient[1];
-+         params[2] = ctx->Light.Model.Ambient[2];
-+         params[3] = ctx->Light.Model.Ambient[3];
-+         break;
-+      case GL_LIGHT_MODEL_COLOR_CONTROL:
-+         params[0] = ENUM_TO_FLOAT(ctx->Light.Model.ColorControl);
-+         break;
-+      case GL_LIGHT_MODEL_LOCAL_VIEWER:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Model.LocalViewer);
-+         break;
-+      case GL_LIGHT_MODEL_TWO_SIDE:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Light.Model.TwoSide);
-+         break;
-+      case GL_LINE_SMOOTH:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Line.SmoothFlag);
-+         break;
-+      case GL_LINE_SMOOTH_HINT:
-+         params[0] = ENUM_TO_FLOAT(ctx->Hint.LineSmooth);
-+         break;
-+      case GL_LINE_STIPPLE:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Line.StippleFlag);
-+         break;
-+      case GL_LINE_STIPPLE_PATTERN:
-+         params[0] = (GLfloat)(ctx->Line.StipplePattern);
-+         break;
-+      case GL_LINE_STIPPLE_REPEAT:
-+         params[0] = (GLfloat)(ctx->Line.StippleFactor);
-+         break;
-+      case GL_LINE_WIDTH:
-+         params[0] = ctx->Line.Width;
-+         break;
-+      case GL_LINE_WIDTH_GRANULARITY:
-+         params[0] = ctx->Const.LineWidthGranularity;
-+         break;
-+      case GL_LINE_WIDTH_RANGE:
-+         params[0] = ctx->Const.MinLineWidthAA;
-+         params[1] = ctx->Const.MaxLineWidthAA;
-+         break;
-+      case GL_ALIASED_LINE_WIDTH_RANGE:
-+         params[0] = ctx->Const.MinLineWidth;
-+         params[1] = ctx->Const.MaxLineWidth;
-+         break;
-+      case GL_LIST_BASE:
-+         params[0] = (GLfloat)(ctx->List.ListBase);
-+         break;
-+      case GL_LIST_INDEX:
-+         params[0] = (GLfloat)(ctx->ListState.CurrentListNum);
-+         break;
-+      case GL_LIST_MODE:
-+         {
-+         GLenum mode;
-+         if (!ctx->CompileFlag)
-+            mode = 0;
-+         else if (ctx->ExecuteFlag)
-+            mode = GL_COMPILE_AND_EXECUTE;
-+         else
-+            mode = GL_COMPILE;
-+         params[0] = ENUM_TO_FLOAT(mode);
-+         }
-+         break;
-+      case GL_INDEX_LOGIC_OP:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Color.IndexLogicOpEnabled);
-+         break;
-+      case GL_COLOR_LOGIC_OP:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Color.ColorLogicOpEnabled);
-+         break;
-+      case GL_LOGIC_OP_MODE:
-+         params[0] = ENUM_TO_FLOAT(ctx->Color.LogicOp);
-+         break;
-+      case GL_MAP1_COLOR_4:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Color4);
-+         break;
-+      case GL_MAP1_GRID_DOMAIN:
-+         params[0] = ctx->Eval.MapGrid1u1;
-+         params[1] = ctx->Eval.MapGrid1u2;
-+         break;
-+      case GL_MAP1_GRID_SEGMENTS:
-+         params[0] = (GLfloat)(ctx->Eval.MapGrid1un);
-+         break;
-+      case GL_MAP1_INDEX:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Index);
-+         break;
-+      case GL_MAP1_NORMAL:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Normal);
-+         break;
-+      case GL_MAP1_TEXTURE_COORD_1:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1TextureCoord1);
-+         break;
-+      case GL_MAP1_TEXTURE_COORD_2:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1TextureCoord2);
-+         break;
-+      case GL_MAP1_TEXTURE_COORD_3:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1TextureCoord3);
-+         break;
-+      case GL_MAP1_TEXTURE_COORD_4:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1TextureCoord4);
-+         break;
-+      case GL_MAP1_VERTEX_3:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Vertex3);
-+         break;
-+      case GL_MAP1_VERTEX_4:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Vertex4);
-+         break;
-+      case GL_MAP2_COLOR_4:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2Color4);
-+         break;
-+      case GL_MAP2_GRID_DOMAIN:
-+         params[0] = ctx->Eval.MapGrid2u1;
-+         params[1] = ctx->Eval.MapGrid2u2;
-+         params[2] = ctx->Eval.MapGrid2v1;
-+         params[3] = ctx->Eval.MapGrid2v2;
-+         break;
-+      case GL_MAP2_GRID_SEGMENTS:
-+         params[0] = (GLfloat)(ctx->Eval.MapGrid2un);
-+         params[1] = (GLfloat)(ctx->Eval.MapGrid2vn);
-+         break;
-+      case GL_MAP2_INDEX:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2Index);
-+         break;
-+      case GL_MAP2_NORMAL:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2Normal);
-+         break;
-+      case GL_MAP2_TEXTURE_COORD_1:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2TextureCoord1);
-+         break;
-+      case GL_MAP2_TEXTURE_COORD_2:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2TextureCoord2);
-+         break;
-+      case GL_MAP2_TEXTURE_COORD_3:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2TextureCoord3);
-+         break;
-+      case GL_MAP2_TEXTURE_COORD_4:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2TextureCoord4);
-+         break;
-+      case GL_MAP2_VERTEX_3:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2Vertex3);
-+         break;
-+      case GL_MAP2_VERTEX_4:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map2Vertex4);
-+         break;
-+      case GL_MAP_COLOR:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.MapColorFlag);
-+         break;
-+      case GL_MAP_STENCIL:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.MapStencilFlag);
-+         break;
-+      case GL_MATRIX_MODE:
-+         params[0] = ENUM_TO_FLOAT(ctx->Transform.MatrixMode);
-+         break;
-+      case GL_MAX_ATTRIB_STACK_DEPTH:
-+         params[0] = (GLfloat)(MAX_ATTRIB_STACK_DEPTH);
-+         break;
-+      case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
-+         params[0] = (GLfloat)(MAX_CLIENT_ATTRIB_STACK_DEPTH);
-+         break;
-+      case GL_MAX_CLIP_PLANES:
-+         params[0] = (GLfloat)(ctx->Const.MaxClipPlanes);
-+         break;
-+      case GL_MAX_ELEMENTS_VERTICES:
-+         params[0] = (GLfloat)(ctx->Const.MaxArrayLockSize);
-+         break;
-+      case GL_MAX_ELEMENTS_INDICES:
-+         params[0] = (GLfloat)(ctx->Const.MaxArrayLockSize);
-+         break;
-+      case GL_MAX_EVAL_ORDER:
-+         params[0] = (GLfloat)(MAX_EVAL_ORDER);
-+         break;
-+      case GL_MAX_LIGHTS:
-+         params[0] = (GLfloat)(ctx->Const.MaxLights);
-+         break;
-+      case GL_MAX_LIST_NESTING:
-+         params[0] = (GLfloat)(MAX_LIST_NESTING);
-+         break;
-+      case GL_MAX_MODELVIEW_STACK_DEPTH:
-+         params[0] = (GLfloat)(MAX_MODELVIEW_STACK_DEPTH);
-+         break;
-+      case GL_MAX_NAME_STACK_DEPTH:
-+         params[0] = (GLfloat)(MAX_NAME_STACK_DEPTH);
-+         break;
-+      case GL_MAX_PIXEL_MAP_TABLE:
-+         params[0] = (GLfloat)(MAX_PIXEL_MAP_TABLE);
-+         break;
-+      case GL_MAX_PROJECTION_STACK_DEPTH:
-+         params[0] = (GLfloat)(MAX_PROJECTION_STACK_DEPTH);
-+         break;
-+      case GL_MAX_TEXTURE_SIZE:
-+         params[0] = (GLfloat)(1 << (ctx->Const.MaxTextureLevels - 1));
-+         break;
-+      case GL_MAX_3D_TEXTURE_SIZE:
-+         params[0] = (GLfloat)(1 << (ctx->Const.Max3DTextureLevels - 1));
-+         break;
-+      case GL_MAX_TEXTURE_STACK_DEPTH:
-+         params[0] = (GLfloat)(MAX_TEXTURE_STACK_DEPTH);
-+         break;
-+      case GL_MAX_VIEWPORT_DIMS:
-+         params[0] = (GLfloat)(ctx->Const.MaxViewportWidth);
-+         params[1] = (GLfloat)(ctx->Const.MaxViewportHeight);
-+         break;
-+      case GL_MODELVIEW_MATRIX:
-+         {
-+         const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
-+         params[0] = matrix[0];
-+         params[1] = matrix[1];
-+         params[2] = matrix[2];
-+         params[3] = matrix[3];
-+         params[4] = matrix[4];
-+         params[5] = matrix[5];
-+         params[6] = matrix[6];
-+         params[7] = matrix[7];
-+         params[8] = matrix[8];
-+         params[9] = matrix[9];
-+         params[10] = matrix[10];
-+         params[11] = matrix[11];
-+         params[12] = matrix[12];
-+         params[13] = matrix[13];
-+         params[14] = matrix[14];
-+         params[15] = matrix[15];
-+         }
-+         break;
-+      case GL_MODELVIEW_STACK_DEPTH:
-+         params[0] = (GLfloat)(ctx->ModelviewMatrixStack.Depth + 1);
-+         break;
-+      case GL_NAME_STACK_DEPTH:
-+         params[0] = (GLfloat)(ctx->Select.NameStackDepth);
-+         break;
-+      case GL_NORMALIZE:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Transform.Normalize);
-+         break;
-+      case GL_PACK_ALIGNMENT:
-+         params[0] = (GLfloat)(ctx->Pack.Alignment);
-+         break;
-+      case GL_PACK_LSB_FIRST:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Pack.LsbFirst);
-+         break;
-+      case GL_PACK_ROW_LENGTH:
-+         params[0] = (GLfloat)(ctx->Pack.RowLength);
-+         break;
-+      case GL_PACK_SKIP_PIXELS:
-+         params[0] = (GLfloat)(ctx->Pack.SkipPixels);
-+         break;
-+      case GL_PACK_SKIP_ROWS:
-+         params[0] = (GLfloat)(ctx->Pack.SkipRows);
-+         break;
-+      case GL_PACK_SWAP_BYTES:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Pack.SwapBytes);
-+         break;
-+      case GL_PACK_SKIP_IMAGES_EXT:
-+         params[0] = (GLfloat)(ctx->Pack.SkipImages);
-+         break;
-+      case GL_PACK_IMAGE_HEIGHT_EXT:
-+         params[0] = (GLfloat)(ctx->Pack.ImageHeight);
-+         break;
-+      case GL_PACK_INVERT_MESA:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Pack.Invert);
-+         break;
-+      case GL_PERSPECTIVE_CORRECTION_HINT:
-+         params[0] = ENUM_TO_FLOAT(ctx->Hint.PerspectiveCorrection);
-+         break;
-+      case GL_PIXEL_MAP_A_TO_A_SIZE:
-+         params[0] = (GLfloat)(ctx->Pixel.MapAtoAsize);
-+         break;
-+      case GL_PIXEL_MAP_B_TO_B_SIZE:
-+         params[0] = (GLfloat)(ctx->Pixel.MapBtoBsize);
-+         break;
-+      case GL_PIXEL_MAP_G_TO_G_SIZE:
-+         params[0] = (GLfloat)(ctx->Pixel.MapGtoGsize);
-+         break;
-+      case GL_PIXEL_MAP_I_TO_A_SIZE:
-+         params[0] = (GLfloat)(ctx->Pixel.MapItoAsize);
-+         break;
-+      case GL_PIXEL_MAP_I_TO_B_SIZE:
-+         params[0] = (GLfloat)(ctx->Pixel.MapItoBsize);
-+         break;
-+      case GL_PIXEL_MAP_I_TO_G_SIZE:
-+         params[0] = (GLfloat)(ctx->Pixel.MapItoGsize);
-+         break;
-+      case GL_PIXEL_MAP_I_TO_I_SIZE:
-+         params[0] = (GLfloat)(ctx->Pixel.MapItoIsize);
-+         break;
-+      case GL_PIXEL_MAP_I_TO_R_SIZE:
-+         params[0] = (GLfloat)(ctx->Pixel.MapItoRsize);
-+         break;
-+      case GL_PIXEL_MAP_R_TO_R_SIZE:
-+         params[0] = (GLfloat)(ctx->Pixel.MapRtoRsize);
-+         break;
-+      case GL_PIXEL_MAP_S_TO_S_SIZE:
-+         params[0] = (GLfloat)(ctx->Pixel.MapStoSsize);
-+         break;
-+      case GL_POINT_SIZE:
-+         params[0] = ctx->Point.Size;
-+         break;
-+      case GL_POINT_SIZE_GRANULARITY:
-+         params[0] = ctx->Const.PointSizeGranularity;
-+         break;
-+      case GL_POINT_SIZE_RANGE:
-+         params[0] = ctx->Const.MinPointSizeAA;
-+         params[1] = ctx->Const.MaxPointSizeAA;
-+         break;
-+      case GL_ALIASED_POINT_SIZE_RANGE:
-+         params[0] = ctx->Const.MinPointSize;
-+         params[1] = ctx->Const.MaxPointSize;
-+         break;
-+      case GL_POINT_SMOOTH:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Point.SmoothFlag);
-+         break;
-+      case GL_POINT_SMOOTH_HINT:
-+         params[0] = ENUM_TO_FLOAT(ctx->Hint.PointSmooth);
-+         break;
-+      case GL_POINT_SIZE_MIN_EXT:
-+         params[0] = ctx->Point.MinSize;
-+         break;
-+      case GL_POINT_SIZE_MAX_EXT:
-+         params[0] = ctx->Point.MaxSize;
-+         break;
-+      case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
-+         params[0] = ctx->Point.Threshold;
-+         break;
-+      case GL_DISTANCE_ATTENUATION_EXT:
-+         params[0] = ctx->Point.Params[0];
-+         params[1] = ctx->Point.Params[1];
-+         params[2] = ctx->Point.Params[2];
-+         break;
-+      case GL_POLYGON_MODE:
-+         params[0] = ENUM_TO_FLOAT(ctx->Polygon.FrontMode);
-+         params[1] = ENUM_TO_FLOAT(ctx->Polygon.BackMode);
-+         break;
-+      case GL_POLYGON_OFFSET_BIAS_EXT:
-+         params[0] = ctx->Polygon.OffsetUnits;
-+         break;
-+      case GL_POLYGON_OFFSET_FACTOR:
-+         params[0] = ctx->Polygon.OffsetFactor ;
-+         break;
-+      case GL_POLYGON_OFFSET_UNITS:
-+         params[0] = ctx->Polygon.OffsetUnits ;
-+         break;
-+      case GL_POLYGON_SMOOTH:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Polygon.SmoothFlag);
-+         break;
-+      case GL_POLYGON_SMOOTH_HINT:
-+         params[0] = ENUM_TO_FLOAT(ctx->Hint.PolygonSmooth);
-+         break;
-+      case GL_POLYGON_STIPPLE:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Polygon.StippleFlag);
-+         break;
-+      case GL_PROJECTION_MATRIX:
-+         {
-+         const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
-+         params[0] = matrix[0];
-+         params[1] = matrix[1];
-+         params[2] = matrix[2];
-+         params[3] = matrix[3];
-+         params[4] = matrix[4];
-+         params[5] = matrix[5];
-+         params[6] = matrix[6];
-+         params[7] = matrix[7];
-+         params[8] = matrix[8];
-+         params[9] = matrix[9];
-+         params[10] = matrix[10];
-+         params[11] = matrix[11];
-+         params[12] = matrix[12];
-+         params[13] = matrix[13];
-+         params[14] = matrix[14];
-+         params[15] = matrix[15];
-+         }
-+         break;
-+      case GL_PROJECTION_STACK_DEPTH:
-+         params[0] = (GLfloat)(ctx->ProjectionMatrixStack.Depth + 1);
-+         break;
-+      case GL_READ_BUFFER:
-+         params[0] = ENUM_TO_FLOAT(ctx->ReadBuffer->ColorReadBuffer);
-+         break;
-+      case GL_RED_BIAS:
-+         params[0] = ctx->Pixel.RedBias;
-+         break;
-+      case GL_RED_BITS:
-+         params[0] = (GLfloat)( ctx->DrawBuffer->Visual.redBits );
-+         break;
-+      case GL_RED_SCALE:
-+         params[0] = ctx->Pixel.RedScale;
-+         break;
-+      case GL_RENDER_MODE:
-+         params[0] = ENUM_TO_FLOAT(ctx->RenderMode);
-+         break;
-+      case GL_RESCALE_NORMAL:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Transform.RescaleNormals);
-+         break;
-+      case GL_RGBA_MODE:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->DrawBuffer->Visual.rgbMode);
-+         break;
-+      case GL_SCISSOR_BOX:
-+         params[0] = (GLfloat)(ctx->Scissor.X);
-+         params[1] = (GLfloat)(ctx->Scissor.Y);
-+         params[2] = (GLfloat)(ctx->Scissor.Width);
-+         params[3] = (GLfloat)(ctx->Scissor.Height);
-+         break;
-+      case GL_SCISSOR_TEST:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Scissor.Enabled);
-+         break;
-+      case GL_SELECTION_BUFFER_SIZE:
-+         params[0] = (GLfloat)(ctx->Select.BufferSize);
-+         break;
-+      case GL_SHADE_MODEL:
-+         params[0] = ENUM_TO_FLOAT(ctx->Light.ShadeModel);
-+         break;
-+      case GL_SHARED_TEXTURE_PALETTE_EXT:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Texture.SharedPalette);
-+         break;
-+      case GL_STENCIL_BITS:
-+         params[0] = (GLfloat)(ctx->DrawBuffer->Visual.stencilBits);
-+         break;
-+      case GL_STENCIL_CLEAR_VALUE:
-+         params[0] = (GLfloat)(ctx->Stencil.Clear);
-+         break;
-+      case GL_STENCIL_FAIL:
-+         params[0] = ENUM_TO_FLOAT(ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace]);
-+         break;
-+      case GL_STENCIL_FUNC:
-+         params[0] = ENUM_TO_FLOAT(ctx->Stencil.Function[ctx->Stencil.ActiveFace]);
-+         break;
-+      case GL_STENCIL_PASS_DEPTH_FAIL:
-+         params[0] = ENUM_TO_FLOAT(ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace]);
-+         break;
-+      case GL_STENCIL_PASS_DEPTH_PASS:
-+         params[0] = ENUM_TO_FLOAT(ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace]);
-+         break;
-+      case GL_STENCIL_REF:
-+         params[0] = (GLfloat)(ctx->Stencil.Ref[ctx->Stencil.ActiveFace]);
-+         break;
-+      case GL_STENCIL_TEST:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Stencil.Enabled);
-+         break;
-+      case GL_STENCIL_VALUE_MASK:
-+         params[0] = (GLfloat)(ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace]);
-+         break;
-+      case GL_STENCIL_WRITEMASK:
-+         params[0] = (GLfloat)(ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace]);
-+         break;
-+      case GL_STEREO:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->DrawBuffer->Visual.stereoMode);
-+         break;
-+      case GL_SUBPIXEL_BITS:
-+         params[0] = (GLfloat)(ctx->Const.SubPixelBits);
-+         break;
-+      case GL_TEXTURE_1D:
-+         params[0] = BOOLEAN_TO_FLOAT(_mesa_IsEnabled(GL_TEXTURE_1D));
-+         break;
-+      case GL_TEXTURE_2D:
-+         params[0] = BOOLEAN_TO_FLOAT(_mesa_IsEnabled(GL_TEXTURE_2D));
-+         break;
-+      case GL_TEXTURE_3D:
-+         params[0] = BOOLEAN_TO_FLOAT(_mesa_IsEnabled(GL_TEXTURE_3D));
-+         break;
-+      case GL_TEXTURE_BINDING_1D:
-+         params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1D->Name);
-+         break;
-+      case GL_TEXTURE_BINDING_2D:
-+         params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2D->Name);
-+         break;
-+      case GL_TEXTURE_BINDING_3D:
-+         params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current3D->Name);
-+         break;
-+      case GL_TEXTURE_ENV_COLOR:
-+         {
-+         const GLfloat *color = ctx->Texture.Unit[ctx->Texture.CurrentUnit].EnvColor;
-+         params[0] = color[0];
-+         params[1] = color[1];
-+         params[2] = color[2];
-+         params[3] = color[3];
-+         }
-+         break;
-+      case GL_TEXTURE_ENV_MODE:
-+         params[0] = ENUM_TO_FLOAT(ctx->Texture.Unit[ctx->Texture.CurrentUnit].EnvMode);
-+         break;
-+      case GL_TEXTURE_GEN_S:
-+         params[0] = BOOLEAN_TO_FLOAT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0));
-+         break;
-+      case GL_TEXTURE_GEN_T:
-+         params[0] = BOOLEAN_TO_FLOAT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & T_BIT) ? 1 : 0));
-+         break;
-+      case GL_TEXTURE_GEN_R:
-+         params[0] = BOOLEAN_TO_FLOAT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & R_BIT) ? 1 : 0));
-+         break;
-+      case GL_TEXTURE_GEN_Q:
-+         params[0] = BOOLEAN_TO_FLOAT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & Q_BIT) ? 1 : 0));
-+         break;
-+      case GL_TEXTURE_MATRIX:
-+         {
-+         const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
-+         params[0] = matrix[0];
-+         params[1] = matrix[1];
-+         params[2] = matrix[2];
-+         params[3] = matrix[3];
-+         params[4] = matrix[4];
-+         params[5] = matrix[5];
-+         params[6] = matrix[6];
-+         params[7] = matrix[7];
-+         params[8] = matrix[8];
-+         params[9] = matrix[9];
-+         params[10] = matrix[10];
-+         params[11] = matrix[11];
-+         params[12] = matrix[12];
-+         params[13] = matrix[13];
-+         params[14] = matrix[14];
-+         params[15] = matrix[15];
-+         }
-+         break;
-+      case GL_TEXTURE_STACK_DEPTH:
-+         params[0] = (GLfloat)(ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Depth + 1);
-+         break;
-+      case GL_UNPACK_ALIGNMENT:
-+         params[0] = (GLfloat)(ctx->Unpack.Alignment);
-+         break;
-+      case GL_UNPACK_LSB_FIRST:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Unpack.LsbFirst);
-+         break;
-+      case GL_UNPACK_ROW_LENGTH:
-+         params[0] = (GLfloat)(ctx->Unpack.RowLength);
-+         break;
-+      case GL_UNPACK_SKIP_PIXELS:
-+         params[0] = (GLfloat)(ctx->Unpack.SkipPixels);
-+         break;
-+      case GL_UNPACK_SKIP_ROWS:
-+         params[0] = (GLfloat)(ctx->Unpack.SkipRows);
-+         break;
-+      case GL_UNPACK_SWAP_BYTES:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Unpack.SwapBytes);
-+         break;
-+      case GL_UNPACK_SKIP_IMAGES_EXT:
-+         params[0] = (GLfloat)(ctx->Unpack.SkipImages);
-+         break;
-+      case GL_UNPACK_IMAGE_HEIGHT_EXT:
-+         params[0] = (GLfloat)(ctx->Unpack.ImageHeight);
-+         break;
-+      case GL_UNPACK_CLIENT_STORAGE_APPLE:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Unpack.ClientStorage);
-+         break;
-+      case GL_VIEWPORT:
-+         params[0] = (GLfloat)(ctx->Viewport.X);
-+         params[1] = (GLfloat)(ctx->Viewport.Y);
-+         params[2] = (GLfloat)(ctx->Viewport.Width);
-+         params[3] = (GLfloat)(ctx->Viewport.Height);
-+         break;
-+      case GL_ZOOM_X:
-+         params[0] = ctx->Pixel.ZoomX;
-+         break;
-+      case GL_ZOOM_Y:
-+         params[0] = ctx->Pixel.ZoomY;
-+         break;
-+      case GL_VERTEX_ARRAY:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->Vertex.Enabled);
-+         break;
-+      case GL_VERTEX_ARRAY_SIZE:
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->Vertex.Size);
-+         break;
-+      case GL_VERTEX_ARRAY_TYPE:
-+         params[0] = ENUM_TO_FLOAT(ctx->Array.ArrayObj->Vertex.Type);
-+         break;
-+      case GL_VERTEX_ARRAY_STRIDE:
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->Vertex.Stride);
-+         break;
-+      case GL_VERTEX_ARRAY_COUNT_EXT:
-+         params[0] = (GLfloat)(0);
-+         break;
-+      case GL_NORMAL_ARRAY:
-+         params[0] = ENUM_TO_FLOAT(ctx->Array.ArrayObj->Normal.Enabled);
-+         break;
-+      case GL_NORMAL_ARRAY_TYPE:
-+         params[0] = ENUM_TO_FLOAT(ctx->Array.ArrayObj->Normal.Type);
-+         break;
-+      case GL_NORMAL_ARRAY_STRIDE:
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->Normal.Stride);
-+         break;
-+      case GL_NORMAL_ARRAY_COUNT_EXT:
-+         params[0] = (GLfloat)(0);
-+         break;
-+      case GL_COLOR_ARRAY:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->Color.Enabled);
-+         break;
-+      case GL_COLOR_ARRAY_SIZE:
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->Color.Size);
-+         break;
-+      case GL_COLOR_ARRAY_TYPE:
-+         params[0] = ENUM_TO_FLOAT(ctx->Array.ArrayObj->Color.Type);
-+         break;
-+      case GL_COLOR_ARRAY_STRIDE:
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->Color.Stride);
-+         break;
-+      case GL_COLOR_ARRAY_COUNT_EXT:
-+         params[0] = (GLfloat)(0);
-+         break;
-+      case GL_INDEX_ARRAY:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->Index.Enabled);
-+         break;
-+      case GL_INDEX_ARRAY_TYPE:
-+         params[0] = ENUM_TO_FLOAT(ctx->Array.ArrayObj->Index.Type);
-+         break;
-+      case GL_INDEX_ARRAY_STRIDE:
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->Index.Stride);
-+         break;
-+      case GL_INDEX_ARRAY_COUNT_EXT:
-+         params[0] = (GLfloat)(0);
-+         break;
-+      case GL_TEXTURE_COORD_ARRAY:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled);
-+         break;
-+      case GL_TEXTURE_COORD_ARRAY_SIZE:
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Size);
-+         break;
-+      case GL_TEXTURE_COORD_ARRAY_TYPE:
-+         params[0] = ENUM_TO_FLOAT(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Type);
-+         break;
-+      case GL_TEXTURE_COORD_ARRAY_STRIDE:
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Stride);
-+         break;
-+      case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
-+         params[0] = (GLfloat)(0);
-+         break;
-+      case GL_EDGE_FLAG_ARRAY:
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->EdgeFlag.Enabled);
-+         break;
-+      case GL_EDGE_FLAG_ARRAY_STRIDE:
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->EdgeFlag.Stride);
-+         break;
-+      case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
-+         params[0] = (GLfloat)(0);
-+         break;
-+      case GL_MAX_TEXTURE_UNITS_ARB:
-+         CHECK_EXT1(ARB_multitexture, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Const.MaxTextureUnits);
-+         break;
-+      case GL_ACTIVE_TEXTURE_ARB:
-+         CHECK_EXT1(ARB_multitexture, "GetFloatv");
-+         params[0] = (GLfloat)(GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit);
-+         break;
-+      case GL_CLIENT_ACTIVE_TEXTURE_ARB:
-+         CHECK_EXT1(ARB_multitexture, "GetFloatv");
-+         params[0] = (GLfloat)(GL_TEXTURE0_ARB + ctx->Array.ActiveTexture);
-+         break;
-+      case GL_TEXTURE_CUBE_MAP_ARB:
-+         CHECK_EXT1(ARB_texture_cube_map, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(_mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB));
-+         break;
-+      case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-+         CHECK_EXT1(ARB_texture_cube_map, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap->Name);
-+         break;
-+      case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-+         CHECK_EXT1(ARB_texture_cube_map, "GetFloatv");
-+         params[0] = (GLfloat)((1 << (ctx->Const.MaxCubeTextureLevels - 1)));
-+         break;
-+      case GL_TEXTURE_COMPRESSION_HINT_ARB:
-+         CHECK_EXT1(ARB_texture_compression, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Hint.TextureCompression);
-+         break;
-+      case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-+         CHECK_EXT1(ARB_texture_compression, "GetFloatv");
-+         params[0] = (GLfloat)(_mesa_get_compressed_formats(ctx, NULL, GL_FALSE));
-+         break;
-+      case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-+         CHECK_EXT1(ARB_texture_compression, "GetFloatv");
-+         {
-+         GLint formats[100];
-+         GLuint i, n = _mesa_get_compressed_formats(ctx, formats, GL_FALSE);
-+         ASSERT(n <= 100);
-+         for (i = 0; i < n; i++)
-+            params[i] = ENUM_TO_INT(formats[i]);
-+         }
-+         break;
-+      case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
-+         CHECK_EXT1(EXT_compiled_vertex_array, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Array.LockFirst);
-+         break;
-+      case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
-+         CHECK_EXT1(EXT_compiled_vertex_array, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Array.LockCount);
-+         break;
-+      case GL_TRANSPOSE_COLOR_MATRIX_ARB:
-+         {
-+         const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
-+         params[0] = matrix[0];
-+         params[1] = matrix[4];
-+         params[2] = matrix[8];
-+         params[3] = matrix[12];
-+         params[4] = matrix[1];
-+         params[5] = matrix[5];
-+         params[6] = matrix[9];
-+         params[7] = matrix[13];
-+         params[8] = matrix[2];
-+         params[9] = matrix[6];
-+         params[10] = matrix[10];
-+         params[11] = matrix[14];
-+         params[12] = matrix[3];
-+         params[13] = matrix[7];
-+         params[14] = matrix[11];
-+         params[15] = matrix[15];
-+         }
-+         break;
-+      case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
-+         {
-+         const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
-+         params[0] = matrix[0];
-+         params[1] = matrix[4];
-+         params[2] = matrix[8];
-+         params[3] = matrix[12];
-+         params[4] = matrix[1];
-+         params[5] = matrix[5];
-+         params[6] = matrix[9];
-+         params[7] = matrix[13];
-+         params[8] = matrix[2];
-+         params[9] = matrix[6];
-+         params[10] = matrix[10];
-+         params[11] = matrix[14];
-+         params[12] = matrix[3];
-+         params[13] = matrix[7];
-+         params[14] = matrix[11];
-+         params[15] = matrix[15];
-+         }
-+         break;
-+      case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
-+         {
-+         const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
-+         params[0] = matrix[0];
-+         params[1] = matrix[4];
-+         params[2] = matrix[8];
-+         params[3] = matrix[12];
-+         params[4] = matrix[1];
-+         params[5] = matrix[5];
-+         params[6] = matrix[9];
-+         params[7] = matrix[13];
-+         params[8] = matrix[2];
-+         params[9] = matrix[6];
-+         params[10] = matrix[10];
-+         params[11] = matrix[14];
-+         params[12] = matrix[3];
-+         params[13] = matrix[7];
-+         params[14] = matrix[11];
-+         params[15] = matrix[15];
-+         }
-+         break;
-+      case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
-+         {
-+         const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
-+         params[0] = matrix[0];
-+         params[1] = matrix[4];
-+         params[2] = matrix[8];
-+         params[3] = matrix[12];
-+         params[4] = matrix[1];
-+         params[5] = matrix[5];
-+         params[6] = matrix[9];
-+         params[7] = matrix[13];
-+         params[8] = matrix[2];
-+         params[9] = matrix[6];
-+         params[10] = matrix[10];
-+         params[11] = matrix[14];
-+         params[12] = matrix[3];
-+         params[13] = matrix[7];
-+         params[14] = matrix[11];
-+         params[15] = matrix[15];
-+         }
-+         break;
-+      case GL_COLOR_MATRIX_SGI:
-+         {
-+         const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
-+         params[0] = matrix[0];
-+         params[1] = matrix[1];
-+         params[2] = matrix[2];
-+         params[3] = matrix[3];
-+         params[4] = matrix[4];
-+         params[5] = matrix[5];
-+         params[6] = matrix[6];
-+         params[7] = matrix[7];
-+         params[8] = matrix[8];
-+         params[9] = matrix[9];
-+         params[10] = matrix[10];
-+         params[11] = matrix[11];
-+         params[12] = matrix[12];
-+         params[13] = matrix[13];
-+         params[14] = matrix[14];
-+         params[15] = matrix[15];
-+         }
-+         break;
-+      case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
-+         params[0] = (GLfloat)(ctx->ColorMatrixStack.Depth + 1);
-+         break;
-+      case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
-+         params[0] = (GLfloat)(MAX_COLOR_STACK_DEPTH);
-+         break;
-+      case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
-+         params[0] = ctx->Pixel.PostColorMatrixScale[0];
-+         break;
-+      case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
-+         params[0] = ctx->Pixel.PostColorMatrixScale[1];
-+         break;
-+      case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
-+         params[0] = ctx->Pixel.PostColorMatrixScale[2];
-+         break;
-+      case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
-+         params[0] = ctx->Pixel.PostColorMatrixScale[3];
-+         break;
-+      case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
-+         params[0] = ctx->Pixel.PostColorMatrixBias[0];
-+         break;
-+      case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
-+         params[0] = ctx->Pixel.PostColorMatrixBias[1];
-+         break;
-+      case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
-+         params[0] = ctx->Pixel.PostColorMatrixBias[2];
-+         break;
-+      case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
-+         params[0] = ctx->Pixel.PostColorMatrixBias[3];
-+         break;
-+      case GL_CONVOLUTION_1D_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.Convolution1DEnabled);
-+         break;
-+      case GL_CONVOLUTION_2D_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.Convolution2DEnabled);
-+         break;
-+      case GL_SEPARABLE_2D_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.Separable2DEnabled);
-+         break;
-+      case GL_POST_CONVOLUTION_RED_SCALE_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetFloatv");
-+         params[0] = ctx->Pixel.PostConvolutionScale[0];
-+         break;
-+      case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetFloatv");
-+         params[0] = ctx->Pixel.PostConvolutionScale[1];
-+         break;
-+      case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetFloatv");
-+         params[0] = ctx->Pixel.PostConvolutionScale[2];
-+         break;
-+      case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetFloatv");
-+         params[0] = ctx->Pixel.PostConvolutionScale[3];
-+         break;
-+      case GL_POST_CONVOLUTION_RED_BIAS_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetFloatv");
-+         params[0] = ctx->Pixel.PostConvolutionBias[0];
-+         break;
-+      case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetFloatv");
-+         params[0] = ctx->Pixel.PostConvolutionBias[1];
-+         break;
-+      case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetFloatv");
-+         params[0] = ctx->Pixel.PostConvolutionBias[2];
-+         break;
-+      case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetFloatv");
-+         params[0] = ctx->Pixel.PostConvolutionBias[3];
-+         break;
-+      case GL_HISTOGRAM:
-+         CHECK_EXT1(EXT_histogram, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.HistogramEnabled);
-+         break;
-+      case GL_MINMAX:
-+         CHECK_EXT1(EXT_histogram, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.MinMaxEnabled);
-+         break;
-+      case GL_COLOR_TABLE_SGI:
-+         CHECK_EXT1(SGI_color_table, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.ColorTableEnabled);
-+         break;
-+      case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
-+         CHECK_EXT1(SGI_color_table, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.PostConvolutionColorTableEnabled);
-+         break;
-+      case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
-+         CHECK_EXT1(SGI_color_table, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Pixel.PostColorMatrixColorTableEnabled);
-+         break;
-+      case GL_TEXTURE_COLOR_TABLE_SGI:
-+         CHECK_EXT1(SGI_texture_color_table, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled);
-+         break;
-+      case GL_COLOR_SUM_EXT:
-+         CHECK_EXT2(EXT_secondary_color, ARB_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Fog.ColorSumEnabled);
-+         break;
-+      case GL_CURRENT_SECONDARY_COLOR_EXT:
-+         CHECK_EXT1(EXT_secondary_color, "GetFloatv");
-+         {
-+         FLUSH_CURRENT(ctx, 0);
-+         params[0] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0];
-+         params[1] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1];
-+         params[2] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2];
-+         params[3] = ctx->Current.Attrib[VERT_ATTRIB_COLOR1][3];
-+         }
-+         break;
-+      case GL_SECONDARY_COLOR_ARRAY_EXT:
-+         CHECK_EXT1(EXT_secondary_color, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->SecondaryColor.Enabled);
-+         break;
-+      case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
-+         CHECK_EXT1(EXT_secondary_color, "GetFloatv");
-+         params[0] = ENUM_TO_FLOAT(ctx->Array.ArrayObj->SecondaryColor.Type);
-+         break;
-+      case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
-+         CHECK_EXT1(EXT_secondary_color, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->SecondaryColor.Stride);
-+         break;
-+      case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
-+         CHECK_EXT1(EXT_secondary_color, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->SecondaryColor.Size);
-+         break;
-+      case GL_CURRENT_FOG_COORDINATE_EXT:
-+         CHECK_EXT1(EXT_fog_coord, "GetFloatv");
-+         {
-+         FLUSH_CURRENT(ctx, 0);
-+         params[0] = ctx->Current.Attrib[VERT_ATTRIB_FOG][0];
-+         }
-+         break;
-+      case GL_FOG_COORDINATE_ARRAY_EXT:
-+         CHECK_EXT1(EXT_fog_coord, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->FogCoord.Enabled);
-+         break;
-+      case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
-+         CHECK_EXT1(EXT_fog_coord, "GetFloatv");
-+         params[0] = ENUM_TO_FLOAT(ctx->Array.ArrayObj->FogCoord.Type);
-+         break;
-+      case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
-+         CHECK_EXT1(EXT_fog_coord, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->FogCoord.Stride);
-+         break;
-+      case GL_FOG_COORDINATE_SOURCE_EXT:
-+         CHECK_EXT1(EXT_fog_coord, "GetFloatv");
-+         params[0] = ENUM_TO_FLOAT(ctx->Fog.FogCoordinateSource);
-+         break;
-+      case GL_MAX_TEXTURE_LOD_BIAS_EXT:
-+         CHECK_EXT1(EXT_texture_lod_bias, "GetFloatv");
-+         params[0] = ctx->Const.MaxTextureLodBias;
-+         break;
-+      case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
-+         CHECK_EXT1(EXT_texture_filter_anisotropic, "GetFloatv");
-+         params[0] = ctx->Const.MaxTextureMaxAnisotropy;
-+         break;
-+      case GL_MULTISAMPLE_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.Enabled);
-+         break;
-+      case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.SampleAlphaToCoverage);
-+         break;
-+      case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.SampleAlphaToOne);
-+         break;
-+      case GL_SAMPLE_COVERAGE_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.SampleCoverage);
-+         break;
-+      case GL_SAMPLE_COVERAGE_VALUE_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetFloatv");
-+         params[0] = ctx->Multisample.SampleCoverageValue;
-+         break;
-+      case GL_SAMPLE_COVERAGE_INVERT_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Multisample.SampleCoverageInvert);
-+         break;
-+      case GL_SAMPLE_BUFFERS_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->DrawBuffer->Visual.sampleBuffers);
-+         break;
-+      case GL_SAMPLES_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->DrawBuffer->Visual.samples);
-+         break;
-+      case GL_RASTER_POSITION_UNCLIPPED_IBM:
-+         CHECK_EXT1(IBM_rasterpos_clip, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Transform.RasterPositionUnclipped);
-+         break;
-+      case GL_POINT_SPRITE_NV:
-+         CHECK_EXT2(NV_point_sprite, ARB_point_sprite, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Point.PointSprite);
-+         break;
-+      case GL_POINT_SPRITE_R_MODE_NV:
-+         CHECK_EXT1(NV_point_sprite, "GetFloatv");
-+         params[0] = ENUM_TO_FLOAT(ctx->Point.SpriteRMode);
-+         break;
-+      case GL_POINT_SPRITE_COORD_ORIGIN:
-+         CHECK_EXT2(NV_point_sprite, ARB_point_sprite, "GetFloatv");
-+         params[0] = ENUM_TO_FLOAT(ctx->Point.SpriteOrigin);
-+         break;
-+      case GL_GENERATE_MIPMAP_HINT_SGIS:
-+         CHECK_EXT1(SGIS_generate_mipmap, "GetFloatv");
-+         params[0] = ENUM_TO_FLOAT(ctx->Hint.GenerateMipmap);
-+         break;
-+      case GL_VERTEX_PROGRAM_BINDING_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = (GLfloat)((ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0));
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY0_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[0].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY1_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[1].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY2_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[2].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY3_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[3].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[4].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY5_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[5].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY6_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[6].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY7_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[7].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY8_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[8].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY9_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[9].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY10_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[10].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY11_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[11].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY12_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[12].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY13_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[13].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY14_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[14].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY15_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Array.ArrayObj->VertexAttrib[15].Enabled);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB0_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[0]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB1_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[1]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB2_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[2]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB3_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[3]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB4_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[4]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB5_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[5]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB6_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[6]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB7_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[7]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB8_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[8]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB9_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[9]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB10_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[10]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB11_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[11]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB12_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[12]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB13_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[13]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB14_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[14]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB15_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Eval.Map1Attrib[15]);
-+         break;
-+      case GL_FRAGMENT_PROGRAM_NV:
-+         CHECK_EXT1(NV_fragment_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->FragmentProgram.Enabled);
-+         break;
-+      case GL_FRAGMENT_PROGRAM_BINDING_NV:
-+         CHECK_EXT1(NV_fragment_program, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->FragmentProgram.Current ? ctx->FragmentProgram.Current->Base.Id : 0);
-+         break;
-+      case GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV:
-+         CHECK_EXT1(NV_fragment_program, "GetFloatv");
-+         params[0] = (GLfloat)(MAX_NV_FRAGMENT_PROGRAM_PARAMS);
-+         break;
-+      case GL_TEXTURE_RECTANGLE_NV:
-+         CHECK_EXT1(NV_texture_rectangle, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(_mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV));
-+         break;
-+      case GL_TEXTURE_BINDING_RECTANGLE_NV:
-+         CHECK_EXT1(NV_texture_rectangle, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentRect->Name);
-+         break;
-+      case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
-+         CHECK_EXT1(NV_texture_rectangle, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Const.MaxTextureRectSize);
-+         break;
-+      case GL_STENCIL_TEST_TWO_SIDE_EXT:
-+         CHECK_EXT1(EXT_stencil_two_side, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Stencil.TestTwoSide);
-+         break;
-+      case GL_ACTIVE_STENCIL_FACE_EXT:
-+         CHECK_EXT1(EXT_stencil_two_side, "GetFloatv");
-+         params[0] = ENUM_TO_FLOAT(ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT);
-+         break;
-+      case GL_MAX_SHININESS_NV:
-+         CHECK_EXT1(NV_light_max_exponent, "GetFloatv");
-+         params[0] = ctx->Const.MaxShininess;
-+         break;
-+      case GL_MAX_SPOT_EXPONENT_NV:
-+         CHECK_EXT1(NV_light_max_exponent, "GetFloatv");
-+         params[0] = ctx->Const.MaxSpotExponent;
-+         break;
-+      case GL_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Array.ArrayBufferObj->Name);
-+         break;
-+      case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->Vertex.BufferObj->Name);
-+         break;
-+      case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->Normal.BufferObj->Name);
-+         break;
-+      case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->Color.BufferObj->Name);
-+         break;
-+      case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->Index.BufferObj->Name);
-+         break;
-+      case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].BufferObj->Name);
-+         break;
-+      case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->EdgeFlag.BufferObj->Name);
-+         break;
-+      case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->SecondaryColor.BufferObj->Name);
-+         break;
-+      case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Array.ArrayObj->FogCoord.BufferObj->Name);
-+         break;
-+      case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Array.ElementArrayBufferObj->Name);
-+         break;
-+      case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
-+         CHECK_EXT1(EXT_pixel_buffer_object, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Pack.BufferObj->Name);
-+         break;
-+      case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:
-+         CHECK_EXT1(EXT_pixel_buffer_object, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Unpack.BufferObj->Name);
-+         break;
-+      case GL_VERTEX_PROGRAM_ARB:
-+         CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->VertexProgram.Enabled);
-+         break;
-+      case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
-+         CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->VertexProgram.PointSizeEnabled);
-+         break;
-+      case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
-+         CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->VertexProgram.TwoSideEnabled);
-+         break;
-+      case GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB:
-+         CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Const.MaxProgramMatrixStackDepth);
-+         break;
-+      case GL_MAX_PROGRAM_MATRICES_ARB:
-+         CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Const.MaxProgramMatrices);
-+         break;
-+      case GL_CURRENT_MATRIX_STACK_DEPTH_ARB:
-+         CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->CurrentStack->Depth + 1);
-+         break;
-+      case GL_CURRENT_MATRIX_ARB:
-+         CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_fragment_program, "GetFloatv");
-+         {
-+         const GLfloat *matrix = ctx->CurrentStack->Top->m;
-+         params[0] = matrix[0];
-+         params[1] = matrix[1];
-+         params[2] = matrix[2];
-+         params[3] = matrix[3];
-+         params[4] = matrix[4];
-+         params[5] = matrix[5];
-+         params[6] = matrix[6];
-+         params[7] = matrix[7];
-+         params[8] = matrix[8];
-+         params[9] = matrix[9];
-+         params[10] = matrix[10];
-+         params[11] = matrix[11];
-+         params[12] = matrix[12];
-+         params[13] = matrix[13];
-+         params[14] = matrix[14];
-+         params[15] = matrix[15];
-+         }
-+         break;
-+      case GL_TRANSPOSE_CURRENT_MATRIX_ARB:
-+         CHECK_EXT2(ARB_vertex_program, ARB_fragment_program, "GetFloatv");
-+         {
-+         const GLfloat *matrix = ctx->CurrentStack->Top->m;
-+         params[0] = matrix[0];
-+         params[1] = matrix[4];
-+         params[2] = matrix[8];
-+         params[3] = matrix[12];
-+         params[4] = matrix[1];
-+         params[5] = matrix[5];
-+         params[6] = matrix[9];
-+         params[7] = matrix[13];
-+         params[8] = matrix[2];
-+         params[9] = matrix[6];
-+         params[10] = matrix[10];
-+         params[11] = matrix[14];
-+         params[12] = matrix[3];
-+         params[13] = matrix[7];
-+         params[14] = matrix[11];
-+         params[15] = matrix[15];
-+         }
-+         break;
-+      case GL_MAX_VERTEX_ATTRIBS_ARB:
-+         CHECK_EXT1(ARB_vertex_program, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Const.VertexProgram.MaxAttribs);
-+         break;
-+      case GL_PROGRAM_ERROR_POSITION_ARB:
-+         CHECK_EXT4(NV_vertex_program, ARB_vertex_program, NV_fragment_program, ARB_fragment_program, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Program.ErrorPos);
-+         break;
-+      case GL_FRAGMENT_PROGRAM_ARB:
-+         CHECK_EXT1(ARB_fragment_program, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->FragmentProgram.Enabled);
-+         break;
-+      case GL_MAX_TEXTURE_COORDS_ARB:
-+         CHECK_EXT2(ARB_fragment_program, NV_fragment_program, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Const.MaxTextureCoordUnits);
-+         break;
-+      case GL_MAX_TEXTURE_IMAGE_UNITS_ARB:
-+         CHECK_EXT2(ARB_fragment_program, NV_fragment_program, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Const.MaxTextureImageUnits);
-+         break;
-+      case GL_DEPTH_BOUNDS_TEST_EXT:
-+         CHECK_EXT1(EXT_depth_bounds_test, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->Depth.BoundsTest);
-+         break;
-+      case GL_DEPTH_BOUNDS_EXT:
-+         CHECK_EXT1(EXT_depth_bounds_test, "GetFloatv");
-+         params[0] = ctx->Depth.BoundsMin;
-+         params[1] = ctx->Depth.BoundsMax;
-+         break;
-+      case GL_FRAGMENT_PROGRAM_CALLBACK_MESA:
-+         CHECK_EXT1(MESA_program_debug, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->FragmentProgram.CallbackEnabled);
-+         break;
-+      case GL_VERTEX_PROGRAM_CALLBACK_MESA:
-+         CHECK_EXT1(MESA_program_debug, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(ctx->VertexProgram.CallbackEnabled);
-+         break;
-+      case GL_FRAGMENT_PROGRAM_POSITION_MESA:
-+         CHECK_EXT1(MESA_program_debug, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->FragmentProgram.CurrentPosition);
-+         break;
-+      case GL_VERTEX_PROGRAM_POSITION_MESA:
-+         CHECK_EXT1(MESA_program_debug, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->VertexProgram.CurrentPosition);
-+         break;
-+      case GL_MAX_DRAW_BUFFERS_ARB:
-+         CHECK_EXT1(ARB_draw_buffers, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Const.MaxDrawBuffers);
-+         break;
-+      case GL_DRAW_BUFFER0_ARB:
-+         CHECK_EXT1(ARB_draw_buffers, "GetFloatv");
-+         params[0] = ENUM_TO_FLOAT(ctx->DrawBuffer->ColorDrawBuffer[0]);
-+         break;
-+      case GL_DRAW_BUFFER1_ARB:
-+         CHECK_EXT1(ARB_draw_buffers, "GetFloatv");
-+         {
-+         GLenum buffer;
-+         if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-+            _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
-+            return;
-+         }
-+         buffer = ctx->DrawBuffer->ColorDrawBuffer[1];
-+         params[0] = ENUM_TO_FLOAT(buffer);
-+         }
-+         break;
-+      case GL_DRAW_BUFFER2_ARB:
-+         CHECK_EXT1(ARB_draw_buffers, "GetFloatv");
-+         {
-+         GLenum buffer;
-+         if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-+            _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
-+            return;
-+         }
-+         buffer = ctx->DrawBuffer->ColorDrawBuffer[2];
-+         params[0] = ENUM_TO_FLOAT(buffer);
-+         }
-+         break;
-+      case GL_DRAW_BUFFER3_ARB:
-+         CHECK_EXT1(ARB_draw_buffers, "GetFloatv");
-+         {
-+         GLenum buffer;
-+         if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-+            _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
-+            return;
-+         }
-+         buffer = ctx->DrawBuffer->ColorDrawBuffer[3];
-+         params[0] = ENUM_TO_FLOAT(buffer);
-+         }
-+         break;
-+      case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
-+         CHECK_EXT1(OES_read_format, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Const.ColorReadType);
-+         break;
-+      case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
-+         CHECK_EXT1(OES_read_format, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Const.ColorReadFormat);
-+         break;
-+      case GL_NUM_FRAGMENT_REGISTERS_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetFloatv");
-+         params[0] = (GLfloat)(6);
-+         break;
-+      case GL_NUM_FRAGMENT_CONSTANTS_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetFloatv");
-+         params[0] = (GLfloat)(8);
-+         break;
-+      case GL_NUM_PASSES_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetFloatv");
-+         params[0] = (GLfloat)(2);
-+         break;
-+      case GL_NUM_INSTRUCTIONS_PER_PASS_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetFloatv");
-+         params[0] = (GLfloat)(8);
-+         break;
-+      case GL_NUM_INSTRUCTIONS_TOTAL_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetFloatv");
-+         params[0] = (GLfloat)(16);
-+         break;
-+      case GL_COLOR_ALPHA_PAIRING_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetFloatv");
-+         params[0] = BOOLEAN_TO_FLOAT(GL_TRUE);
-+         break;
-+      case GL_NUM_LOOPBACK_COMPONENTS_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetFloatv");
-+         params[0] = (GLfloat)(3);
-+         break;
-+      case GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetFloatv");
-+         params[0] = (GLfloat)(3);
-+         break;
-+      case GL_STENCIL_BACK_FUNC:
-+         params[0] = ENUM_TO_FLOAT(ctx->Stencil.Function[1]);
-+         break;
-+      case GL_STENCIL_BACK_VALUE_MASK:
-+         params[0] = (GLfloat)(ctx->Stencil.ValueMask[1]);
-+         break;
-+      case GL_STENCIL_BACK_REF:
-+         params[0] = (GLfloat)(ctx->Stencil.Ref[1]);
-+         break;
-+      case GL_STENCIL_BACK_FAIL:
-+         params[0] = ENUM_TO_FLOAT(ctx->Stencil.FailFunc[1]);
-+         break;
-+      case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
-+         params[0] = ENUM_TO_FLOAT(ctx->Stencil.ZFailFunc[1]);
-+         break;
-+      case GL_STENCIL_BACK_PASS_DEPTH_PASS:
-+         params[0] = ENUM_TO_FLOAT(ctx->Stencil.ZPassFunc[1]);
-+         break;
-+      case GL_FRAMEBUFFER_BINDING_EXT:
-+         CHECK_EXT1(EXT_framebuffer_object, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->DrawBuffer->Name);
-+         break;
-+      case GL_RENDERBUFFER_BINDING_EXT:
-+         CHECK_EXT1(EXT_framebuffer_object, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0);
-+         break;
-+      case GL_MAX_COLOR_ATTACHMENTS_EXT:
-+         CHECK_EXT1(EXT_framebuffer_object, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Const.MaxColorAttachments);
-+         break;
-+      case GL_MAX_RENDERBUFFER_SIZE_EXT:
-+         CHECK_EXT1(EXT_framebuffer_object, "GetFloatv");
-+         params[0] = (GLfloat)(ctx->Const.MaxRenderbufferSize);
-+         break;
-+      case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB:
-+         CHECK_EXT1(ARB_fragment_shader, "GetFloatv");
-+         params[0] = (GLfloat)(MAX_FRAGMENT_UNIFORM_COMPONENTS);
-+         break;
-+      case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB:
-+         CHECK_EXT1(ARB_fragment_shader, "GetFloatv");
-+         params[0] = ENUM_TO_FLOAT(ctx->Hint.FragmentShaderDerivative);
-+         break;
-+      case GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB:
-+         CHECK_EXT1(ARB_vertex_shader, "GetFloatv");
-+         params[0] = (GLfloat)(MAX_VERTEX_UNIFORM_COMPONENTS);
-+         break;
-+      case GL_MAX_VARYING_FLOATS_ARB:
-+         CHECK_EXT1(ARB_vertex_shader, "GetFloatv");
-+         params[0] = (GLfloat)(MAX_VARYING_FLOATS);
-+         break;
-+      case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB:
-+         CHECK_EXT1(ARB_vertex_shader, "GetFloatv");
-+         params[0] = (GLfloat)(MAX_VERTEX_TEXTURE_IMAGE_UNITS);
-+         break;
-+      case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB:
-+         CHECK_EXT1(ARB_vertex_shader, "GetFloatv");
-+         params[0] = (GLfloat)(MAX_COMBINED_TEXTURE_IMAGE_UNITS);
-+         break;
-+      default:
-+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetFloatv(pname=0x%x)", pname);
-+   }
-+}
-+
-+void GLAPIENTRY
-+_mesa_GetIntegerv( GLenum pname, GLint *params )
-+{
-+   GET_CURRENT_CONTEXT(ctx);
-+   ASSERT_OUTSIDE_BEGIN_END(ctx);
-+
-+   if (!params)
-+      return;
-+
-+   if (ctx->NewState)
-+      _mesa_update_state(ctx);
-+
-+   if (ctx->Driver.GetIntegerv &&
-+       ctx->Driver.GetIntegerv(ctx, pname, params))
-+      return;
-+
-+   switch (pname) {
-+      case GL_ACCUM_RED_BITS:
-+         params[0] = ctx->DrawBuffer->Visual.accumRedBits;
-+         break;
-+      case GL_ACCUM_GREEN_BITS:
-+         params[0] = ctx->DrawBuffer->Visual.accumGreenBits;
-+         break;
-+      case GL_ACCUM_BLUE_BITS:
-+         params[0] = ctx->DrawBuffer->Visual.accumBlueBits;
-+         break;
-+      case GL_ACCUM_ALPHA_BITS:
-+         params[0] = ctx->DrawBuffer->Visual.accumAlphaBits;
-+         break;
-+      case GL_ACCUM_CLEAR_VALUE:
-+         params[0] = FLOAT_TO_INT(ctx->Accum.ClearColor[0]);
-+         params[1] = FLOAT_TO_INT(ctx->Accum.ClearColor[1]);
-+         params[2] = FLOAT_TO_INT(ctx->Accum.ClearColor[2]);
-+         params[3] = FLOAT_TO_INT(ctx->Accum.ClearColor[3]);
-+         break;
-+      case GL_ALPHA_BIAS:
-+         params[0] = IROUND(ctx->Pixel.AlphaBias);
-+         break;
-+      case GL_ALPHA_BITS:
-+         params[0] = ctx->DrawBuffer->Visual.alphaBits;
-+         break;
-+      case GL_ALPHA_SCALE:
-+         params[0] = IROUND(ctx->Pixel.AlphaScale);
-+         break;
-+      case GL_ALPHA_TEST:
-+         params[0] = BOOLEAN_TO_INT(ctx->Color.AlphaEnabled);
-+         break;
-+      case GL_ALPHA_TEST_FUNC:
-+         params[0] = ENUM_TO_INT(ctx->Color.AlphaFunc);
-+         break;
-+      case GL_ALPHA_TEST_REF:
-+         params[0] = FLOAT_TO_INT(ctx->Color.AlphaRef);
-+         break;
-+      case GL_ATTRIB_STACK_DEPTH:
-+         params[0] = ctx->AttribStackDepth;
-+         break;
-+      case GL_AUTO_NORMAL:
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.AutoNormal);
-+         break;
-+      case GL_AUX_BUFFERS:
-+         params[0] = ctx->DrawBuffer->Visual.numAuxBuffers;
-+         break;
-+      case GL_BLEND:
-+         params[0] = BOOLEAN_TO_INT(ctx->Color.BlendEnabled);
-+         break;
-+      case GL_BLEND_DST:
-+         params[0] = ENUM_TO_INT(ctx->Color.BlendDstRGB);
-+         break;
-+      case GL_BLEND_SRC:
-+         params[0] = ENUM_TO_INT(ctx->Color.BlendSrcRGB);
-+         break;
-+      case GL_BLEND_SRC_RGB_EXT:
-+         params[0] = ENUM_TO_INT(ctx->Color.BlendSrcRGB);
-+         break;
-+      case GL_BLEND_DST_RGB_EXT:
-+         params[0] = ENUM_TO_INT(ctx->Color.BlendDstRGB);
-+         break;
-+      case GL_BLEND_SRC_ALPHA_EXT:
-+         params[0] = ENUM_TO_INT(ctx->Color.BlendSrcA);
-+         break;
-+      case GL_BLEND_DST_ALPHA_EXT:
-+         params[0] = ENUM_TO_INT(ctx->Color.BlendDstA);
-+         break;
-+      case GL_BLEND_EQUATION:
-+         params[0] = ENUM_TO_INT(ctx->Color.BlendEquationRGB );
-+         break;
-+      case GL_BLEND_EQUATION_ALPHA_EXT:
-+         params[0] = ENUM_TO_INT(ctx->Color.BlendEquationA );
-+         break;
-+      case GL_BLEND_COLOR_EXT:
-+         params[0] = FLOAT_TO_INT(ctx->Color.BlendColor[0]);
-+         params[1] = FLOAT_TO_INT(ctx->Color.BlendColor[1]);
-+         params[2] = FLOAT_TO_INT(ctx->Color.BlendColor[2]);
-+         params[3] = FLOAT_TO_INT(ctx->Color.BlendColor[3]);
-+         break;
-+      case GL_BLUE_BIAS:
-+         params[0] = IROUND(ctx->Pixel.BlueBias);
-+         break;
-+      case GL_BLUE_BITS:
-+         params[0] = ctx->DrawBuffer->Visual.blueBits;
-+         break;
-+      case GL_BLUE_SCALE:
-+         params[0] = IROUND(ctx->Pixel.BlueScale);
-+         break;
-+      case GL_CLIENT_ATTRIB_STACK_DEPTH:
-+         params[0] = ctx->ClientAttribStackDepth;
-+         break;
-+      case GL_CLIP_PLANE0:
-+         params[0] = BOOLEAN_TO_INT((ctx->Transform.ClipPlanesEnabled >> 0) & 1);
-+         break;
-+      case GL_CLIP_PLANE1:
-+         params[0] = BOOLEAN_TO_INT((ctx->Transform.ClipPlanesEnabled >> 1) & 1);
-+         break;
-+      case GL_CLIP_PLANE2:
-+         params[0] = BOOLEAN_TO_INT((ctx->Transform.ClipPlanesEnabled >> 2) & 1);
-+         break;
-+      case GL_CLIP_PLANE3:
-+         params[0] = BOOLEAN_TO_INT((ctx->Transform.ClipPlanesEnabled >> 3) & 1);
-+         break;
-+      case GL_CLIP_PLANE4:
-+         params[0] = BOOLEAN_TO_INT((ctx->Transform.ClipPlanesEnabled >> 4) & 1);
-+         break;
-+      case GL_CLIP_PLANE5:
-+         params[0] = BOOLEAN_TO_INT((ctx->Transform.ClipPlanesEnabled >> 5) & 1);
-+         break;
-+      case GL_COLOR_CLEAR_VALUE:
-+         params[0] = FLOAT_TO_INT(ctx->Color.ClearColor[0]);
-+         params[1] = FLOAT_TO_INT(ctx->Color.ClearColor[1]);
-+         params[2] = FLOAT_TO_INT(ctx->Color.ClearColor[2]);
-+         params[3] = FLOAT_TO_INT(ctx->Color.ClearColor[3]);
-+         break;
-+      case GL_COLOR_MATERIAL:
-+         params[0] = BOOLEAN_TO_INT(ctx->Light.ColorMaterialEnabled);
-+         break;
-+      case GL_COLOR_MATERIAL_FACE:
-+         params[0] = ENUM_TO_INT(ctx->Light.ColorMaterialFace);
-+         break;
-+      case GL_COLOR_MATERIAL_PARAMETER:
-+         params[0] = ENUM_TO_INT(ctx->Light.ColorMaterialMode);
-+         break;
-+      case GL_COLOR_WRITEMASK:
-+         params[0] = ctx->Color.ColorMask[RCOMP] ? 1 : 0;
-+         params[1] = ctx->Color.ColorMask[GCOMP] ? 1 : 0;
-+         params[2] = ctx->Color.ColorMask[BCOMP] ? 1 : 0;
-+         params[3] = ctx->Color.ColorMask[ACOMP] ? 1 : 0;
-+         break;
-+      case GL_CULL_FACE:
-+         params[0] = BOOLEAN_TO_INT(ctx->Polygon.CullFlag);
-+         break;
-+      case GL_CULL_FACE_MODE:
-+         params[0] = ENUM_TO_INT(ctx->Polygon.CullFaceMode);
-+         break;
-+      case GL_CURRENT_COLOR:
-+         {
-+         FLUSH_CURRENT(ctx, 0);
-+         params[0] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][0]);
-+         params[1] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][1]);
-+         params[2] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][2]);
-+         params[3] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR0][3]);
-+         }
-+         break;
-+      case GL_CURRENT_INDEX:
-+         {
-+         FLUSH_CURRENT(ctx, 0);
-+         params[0] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX][0]);
-+         }
-+         break;
-+      case GL_CURRENT_NORMAL:
-+         {
-+         FLUSH_CURRENT(ctx, 0);
-+         params[0] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][0]);
-+         params[1] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][1]);
-+         params[2] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_NORMAL][2]);
-+         }
-+         break;
-+      case GL_CURRENT_RASTER_COLOR:
-+         params[0] = FLOAT_TO_INT(ctx->Current.RasterColor[0]);
-+         params[1] = FLOAT_TO_INT(ctx->Current.RasterColor[1]);
-+         params[2] = FLOAT_TO_INT(ctx->Current.RasterColor[2]);
-+         params[3] = FLOAT_TO_INT(ctx->Current.RasterColor[3]);
-+         break;
-+      case GL_CURRENT_RASTER_DISTANCE:
-+         params[0] = IROUND(ctx->Current.RasterDistance);
-+         break;
-+      case GL_CURRENT_RASTER_INDEX:
-+         params[0] = IROUND(ctx->Current.RasterIndex);
-+         break;
-+      case GL_CURRENT_RASTER_POSITION:
-+         params[0] = IROUND(ctx->Current.RasterPos[0]);
-+         params[1] = IROUND(ctx->Current.RasterPos[1]);
-+         params[2] = IROUND(ctx->Current.RasterPos[2]);
-+         params[3] = IROUND(ctx->Current.RasterPos[3]);
-+         break;
-+      case GL_CURRENT_RASTER_SECONDARY_COLOR:
-+         params[0] = FLOAT_TO_INT(ctx->Current.RasterSecondaryColor[0]);
-+         params[1] = FLOAT_TO_INT(ctx->Current.RasterSecondaryColor[1]);
-+         params[2] = FLOAT_TO_INT(ctx->Current.RasterSecondaryColor[2]);
-+         params[3] = FLOAT_TO_INT(ctx->Current.RasterSecondaryColor[3]);
-+         break;
-+      case GL_CURRENT_RASTER_TEXTURE_COORDS:
-+         {
-+         const GLuint texUnit = ctx->Texture.CurrentUnit;
-+         params[0] = IROUND(ctx->Current.RasterTexCoords[texUnit][0]);
-+         params[1] = IROUND(ctx->Current.RasterTexCoords[texUnit][1]);
-+         params[2] = IROUND(ctx->Current.RasterTexCoords[texUnit][2]);
-+         params[3] = IROUND(ctx->Current.RasterTexCoords[texUnit][3]);
-+         }
-+         break;
-+      case GL_CURRENT_RASTER_POSITION_VALID:
-+         params[0] = BOOLEAN_TO_INT(ctx->Current.RasterPosValid);
-+         break;
-+      case GL_CURRENT_TEXTURE_COORDS:
-+         {
-+         const GLuint texUnit = ctx->Texture.CurrentUnit;
-+         params[0] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][0]);
-+         params[1] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][1]);
-+         params[2] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][2]);
-+         params[3] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_TEX0 + texUnit][3]);
-+         }
-+         break;
-+      case GL_DEPTH_BIAS:
-+         params[0] = IROUND(ctx->Pixel.DepthBias);
-+         break;
-+      case GL_DEPTH_BITS:
-+         params[0] = ctx->DrawBuffer->Visual.depthBits;
-+         break;
-+      case GL_DEPTH_CLEAR_VALUE:
-+         params[0] = IROUND(ctx->Depth.Clear);
-+         break;
-+      case GL_DEPTH_FUNC:
-+         params[0] = ENUM_TO_INT(ctx->Depth.Func);
-+         break;
-+      case GL_DEPTH_RANGE:
-+         params[0] = FLOAT_TO_INT(ctx->Viewport.Near);
-+         params[1] = FLOAT_TO_INT(ctx->Viewport.Far);
-+         break;
-+      case GL_DEPTH_SCALE:
-+         params[0] = IROUND(ctx->Pixel.DepthScale);
-+         break;
-+      case GL_DEPTH_TEST:
-+         params[0] = BOOLEAN_TO_INT(ctx->Depth.Test);
-+         break;
-+      case GL_DEPTH_WRITEMASK:
-+         params[0] = BOOLEAN_TO_INT(ctx->Depth.Mask);
-+         break;
-+      case GL_DITHER:
-+         params[0] = BOOLEAN_TO_INT(ctx->Color.DitherFlag);
-+         break;
-+      case GL_DOUBLEBUFFER:
-+         params[0] = BOOLEAN_TO_INT(ctx->DrawBuffer->Visual.doubleBufferMode);
-+         break;
-+      case GL_DRAW_BUFFER:
-+         params[0] = ENUM_TO_INT(ctx->DrawBuffer->ColorDrawBuffer[0]);
-+         break;
-+      case GL_EDGE_FLAG:
-+         {
-+         FLUSH_CURRENT(ctx, 0);
-+         params[0] = BOOLEAN_TO_INT(ctx->Current.EdgeFlag);
-+         }
-+         break;
-+      case GL_FEEDBACK_BUFFER_SIZE:
-+         params[0] = ctx->Feedback.BufferSize;
-+         break;
-+      case GL_FEEDBACK_BUFFER_TYPE:
-+         params[0] = ENUM_TO_INT(ctx->Feedback.Type);
-+         break;
-+      case GL_FOG:
-+         params[0] = BOOLEAN_TO_INT(ctx->Fog.Enabled);
-+         break;
-+      case GL_FOG_COLOR:
-+         params[0] = FLOAT_TO_INT(ctx->Fog.Color[0]);
-+         params[1] = FLOAT_TO_INT(ctx->Fog.Color[1]);
-+         params[2] = FLOAT_TO_INT(ctx->Fog.Color[2]);
-+         params[3] = FLOAT_TO_INT(ctx->Fog.Color[3]);
-+         break;
-+      case GL_FOG_DENSITY:
-+         params[0] = IROUND(ctx->Fog.Density);
-+         break;
-+      case GL_FOG_END:
-+         params[0] = IROUND(ctx->Fog.End);
-+         break;
-+      case GL_FOG_HINT:
-+         params[0] = ENUM_TO_INT(ctx->Hint.Fog);
-+         break;
-+      case GL_FOG_INDEX:
-+         params[0] = IROUND(ctx->Fog.Index);
-+         break;
-+      case GL_FOG_MODE:
-+         params[0] = ENUM_TO_INT(ctx->Fog.Mode);
-+         break;
-+      case GL_FOG_START:
-+         params[0] = IROUND(ctx->Fog.Start);
-+         break;
-+      case GL_FRONT_FACE:
-+         params[0] = ENUM_TO_INT(ctx->Polygon.FrontFace);
-+         break;
-+      case GL_GREEN_BIAS:
-+         params[0] = IROUND(ctx->Pixel.GreenBias);
-+         break;
-+      case GL_GREEN_BITS:
-+         params[0] = ctx->DrawBuffer->Visual.greenBits;
-+         break;
-+      case GL_GREEN_SCALE:
-+         params[0] = IROUND(ctx->Pixel.GreenScale);
-+         break;
-+      case GL_INDEX_BITS:
-+         params[0] = ctx->DrawBuffer->Visual.indexBits;
-+         break;
-+      case GL_INDEX_CLEAR_VALUE:
-+         params[0] = ctx->Color.ClearIndex;
-+         break;
-+      case GL_INDEX_MODE:
-+         params[0] = BOOLEAN_TO_INT(!ctx->DrawBuffer->Visual.rgbMode);
-+         break;
-+      case GL_INDEX_OFFSET:
-+         params[0] = ctx->Pixel.IndexOffset;
-+         break;
-+      case GL_INDEX_SHIFT:
-+         params[0] = ctx->Pixel.IndexShift;
-+         break;
-+      case GL_INDEX_WRITEMASK:
-+         params[0] = ctx->Color.IndexMask;
-+         break;
-+      case GL_LIGHT0:
-+         params[0] = BOOLEAN_TO_INT(ctx->Light.Light[0].Enabled);
-+         break;
-+      case GL_LIGHT1:
-+         params[0] = BOOLEAN_TO_INT(ctx->Light.Light[1].Enabled);
-+         break;
-+      case GL_LIGHT2:
-+         params[0] = BOOLEAN_TO_INT(ctx->Light.Light[2].Enabled);
-+         break;
-+      case GL_LIGHT3:
-+         params[0] = BOOLEAN_TO_INT(ctx->Light.Light[3].Enabled);
-+         break;
-+      case GL_LIGHT4:
-+         params[0] = BOOLEAN_TO_INT(ctx->Light.Light[4].Enabled);
-+         break;
-+      case GL_LIGHT5:
-+         params[0] = BOOLEAN_TO_INT(ctx->Light.Light[5].Enabled);
-+         break;
-+      case GL_LIGHT6:
-+         params[0] = BOOLEAN_TO_INT(ctx->Light.Light[6].Enabled);
-+         break;
-+      case GL_LIGHT7:
-+         params[0] = BOOLEAN_TO_INT(ctx->Light.Light[7].Enabled);
-+         break;
-+      case GL_LIGHTING:
-+         params[0] = BOOLEAN_TO_INT(ctx->Light.Enabled);
-+         break;
-+      case GL_LIGHT_MODEL_AMBIENT:
-+         params[0] = FLOAT_TO_INT(ctx->Light.Model.Ambient[0]);
-+         params[1] = FLOAT_TO_INT(ctx->Light.Model.Ambient[1]);
-+         params[2] = FLOAT_TO_INT(ctx->Light.Model.Ambient[2]);
-+         params[3] = FLOAT_TO_INT(ctx->Light.Model.Ambient[3]);
-+         break;
-+      case GL_LIGHT_MODEL_COLOR_CONTROL:
-+         params[0] = ENUM_TO_INT(ctx->Light.Model.ColorControl);
-+         break;
-+      case GL_LIGHT_MODEL_LOCAL_VIEWER:
-+         params[0] = BOOLEAN_TO_INT(ctx->Light.Model.LocalViewer);
-+         break;
-+      case GL_LIGHT_MODEL_TWO_SIDE:
-+         params[0] = BOOLEAN_TO_INT(ctx->Light.Model.TwoSide);
-+         break;
-+      case GL_LINE_SMOOTH:
-+         params[0] = BOOLEAN_TO_INT(ctx->Line.SmoothFlag);
-+         break;
-+      case GL_LINE_SMOOTH_HINT:
-+         params[0] = ENUM_TO_INT(ctx->Hint.LineSmooth);
-+         break;
-+      case GL_LINE_STIPPLE:
-+         params[0] = BOOLEAN_TO_INT(ctx->Line.StippleFlag);
-+         break;
-+      case GL_LINE_STIPPLE_PATTERN:
-+         params[0] = ctx->Line.StipplePattern;
-+         break;
-+      case GL_LINE_STIPPLE_REPEAT:
-+         params[0] = ctx->Line.StippleFactor;
-+         break;
-+      case GL_LINE_WIDTH:
-+         params[0] = IROUND(ctx->Line.Width);
-+         break;
-+      case GL_LINE_WIDTH_GRANULARITY:
-+         params[0] = IROUND(ctx->Const.LineWidthGranularity);
-+         break;
-+      case GL_LINE_WIDTH_RANGE:
-+         params[0] = IROUND(ctx->Const.MinLineWidthAA);
-+         params[1] = IROUND(ctx->Const.MaxLineWidthAA);
-+         break;
-+      case GL_ALIASED_LINE_WIDTH_RANGE:
-+         params[0] = IROUND(ctx->Const.MinLineWidth);
-+         params[1] = IROUND(ctx->Const.MaxLineWidth);
-+         break;
-+      case GL_LIST_BASE:
-+         params[0] = ctx->List.ListBase;
-+         break;
-+      case GL_LIST_INDEX:
-+         params[0] = ctx->ListState.CurrentListNum;
-+         break;
-+      case GL_LIST_MODE:
-+         {
-+         GLenum mode;
-+         if (!ctx->CompileFlag)
-+            mode = 0;
-+         else if (ctx->ExecuteFlag)
-+            mode = GL_COMPILE_AND_EXECUTE;
-+         else
-+            mode = GL_COMPILE;
-+         params[0] = ENUM_TO_INT(mode);
-+         }
-+         break;
-+      case GL_INDEX_LOGIC_OP:
-+         params[0] = BOOLEAN_TO_INT(ctx->Color.IndexLogicOpEnabled);
-+         break;
-+      case GL_COLOR_LOGIC_OP:
-+         params[0] = BOOLEAN_TO_INT(ctx->Color.ColorLogicOpEnabled);
-+         break;
-+      case GL_LOGIC_OP_MODE:
-+         params[0] = ENUM_TO_INT(ctx->Color.LogicOp);
-+         break;
-+      case GL_MAP1_COLOR_4:
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Color4);
-+         break;
-+      case GL_MAP1_GRID_DOMAIN:
-+         params[0] = IROUND(ctx->Eval.MapGrid1u1);
-+         params[1] = IROUND(ctx->Eval.MapGrid1u2);
-+         break;
-+      case GL_MAP1_GRID_SEGMENTS:
-+         params[0] = ctx->Eval.MapGrid1un;
-+         break;
-+      case GL_MAP1_INDEX:
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Index);
-+         break;
-+      case GL_MAP1_NORMAL:
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Normal);
-+         break;
-+      case GL_MAP1_TEXTURE_COORD_1:
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1TextureCoord1);
-+         break;
-+      case GL_MAP1_TEXTURE_COORD_2:
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1TextureCoord2);
-+         break;
-+      case GL_MAP1_TEXTURE_COORD_3:
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1TextureCoord3);
-+         break;
-+      case GL_MAP1_TEXTURE_COORD_4:
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1TextureCoord4);
-+         break;
-+      case GL_MAP1_VERTEX_3:
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Vertex3);
-+         break;
-+      case GL_MAP1_VERTEX_4:
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Vertex4);
-+         break;
-+      case GL_MAP2_COLOR_4:
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2Color4);
-+         break;
-+      case GL_MAP2_GRID_DOMAIN:
-+         params[0] = IROUND(ctx->Eval.MapGrid2u1);
-+         params[1] = IROUND(ctx->Eval.MapGrid2u2);
-+         params[2] = IROUND(ctx->Eval.MapGrid2v1);
-+         params[3] = IROUND(ctx->Eval.MapGrid2v2);
-+         break;
-+      case GL_MAP2_GRID_SEGMENTS:
-+         params[0] = ctx->Eval.MapGrid2un;
-+         params[1] = ctx->Eval.MapGrid2vn;
-+         break;
-+      case GL_MAP2_INDEX:
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2Index);
-+         break;
-+      case GL_MAP2_NORMAL:
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2Normal);
-+         break;
-+      case GL_MAP2_TEXTURE_COORD_1:
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2TextureCoord1);
-+         break;
-+      case GL_MAP2_TEXTURE_COORD_2:
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2TextureCoord2);
-+         break;
-+      case GL_MAP2_TEXTURE_COORD_3:
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2TextureCoord3);
-+         break;
-+      case GL_MAP2_TEXTURE_COORD_4:
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2TextureCoord4);
-+         break;
-+      case GL_MAP2_VERTEX_3:
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2Vertex3);
-+         break;
-+      case GL_MAP2_VERTEX_4:
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map2Vertex4);
-+         break;
-+      case GL_MAP_COLOR:
-+         params[0] = BOOLEAN_TO_INT(ctx->Pixel.MapColorFlag);
-+         break;
-+      case GL_MAP_STENCIL:
-+         params[0] = BOOLEAN_TO_INT(ctx->Pixel.MapStencilFlag);
-+         break;
-+      case GL_MATRIX_MODE:
-+         params[0] = ENUM_TO_INT(ctx->Transform.MatrixMode);
-+         break;
-+      case GL_MAX_ATTRIB_STACK_DEPTH:
-+         params[0] = MAX_ATTRIB_STACK_DEPTH;
-+         break;
-+      case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
-+         params[0] = MAX_CLIENT_ATTRIB_STACK_DEPTH;
-+         break;
-+      case GL_MAX_CLIP_PLANES:
-+         params[0] = ctx->Const.MaxClipPlanes;
-+         break;
-+      case GL_MAX_ELEMENTS_VERTICES:
-+         params[0] = ctx->Const.MaxArrayLockSize;
-+         break;
-+      case GL_MAX_ELEMENTS_INDICES:
-+         params[0] = ctx->Const.MaxArrayLockSize;
-+         break;
-+      case GL_MAX_EVAL_ORDER:
-+         params[0] = MAX_EVAL_ORDER;
-+         break;
-+      case GL_MAX_LIGHTS:
-+         params[0] = ctx->Const.MaxLights;
-+         break;
-+      case GL_MAX_LIST_NESTING:
-+         params[0] = MAX_LIST_NESTING;
-+         break;
-+      case GL_MAX_MODELVIEW_STACK_DEPTH:
-+         params[0] = MAX_MODELVIEW_STACK_DEPTH;
-+         break;
-+      case GL_MAX_NAME_STACK_DEPTH:
-+         params[0] = MAX_NAME_STACK_DEPTH;
-+         break;
-+      case GL_MAX_PIXEL_MAP_TABLE:
-+         params[0] = MAX_PIXEL_MAP_TABLE;
-+         break;
-+      case GL_MAX_PROJECTION_STACK_DEPTH:
-+         params[0] = MAX_PROJECTION_STACK_DEPTH;
-+         break;
-+      case GL_MAX_TEXTURE_SIZE:
-+         params[0] = 1 << (ctx->Const.MaxTextureLevels - 1);
-+         break;
-+      case GL_MAX_3D_TEXTURE_SIZE:
-+         params[0] = 1 << (ctx->Const.Max3DTextureLevels - 1);
-+         break;
-+      case GL_MAX_TEXTURE_STACK_DEPTH:
-+         params[0] = MAX_TEXTURE_STACK_DEPTH;
-+         break;
-+      case GL_MAX_VIEWPORT_DIMS:
-+         params[0] = ctx->Const.MaxViewportWidth;
-+         params[1] = ctx->Const.MaxViewportHeight;
-+         break;
-+      case GL_MODELVIEW_MATRIX:
-+         {
-+         const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
-+         params[0] = IROUND(matrix[0]);
-+         params[1] = IROUND(matrix[1]);
-+         params[2] = IROUND(matrix[2]);
-+         params[3] = IROUND(matrix[3]);
-+         params[4] = IROUND(matrix[4]);
-+         params[5] = IROUND(matrix[5]);
-+         params[6] = IROUND(matrix[6]);
-+         params[7] = IROUND(matrix[7]);
-+         params[8] = IROUND(matrix[8]);
-+         params[9] = IROUND(matrix[9]);
-+         params[10] = IROUND(matrix[10]);
-+         params[11] = IROUND(matrix[11]);
-+         params[12] = IROUND(matrix[12]);
-+         params[13] = IROUND(matrix[13]);
-+         params[14] = IROUND(matrix[14]);
-+         params[15] = IROUND(matrix[15]);
-+         }
-+         break;
-+      case GL_MODELVIEW_STACK_DEPTH:
-+         params[0] = ctx->ModelviewMatrixStack.Depth + 1;
-+         break;
-+      case GL_NAME_STACK_DEPTH:
-+         params[0] = ctx->Select.NameStackDepth;
-+         break;
-+      case GL_NORMALIZE:
-+         params[0] = BOOLEAN_TO_INT(ctx->Transform.Normalize);
-+         break;
-+      case GL_PACK_ALIGNMENT:
-+         params[0] = ctx->Pack.Alignment;
-+         break;
-+      case GL_PACK_LSB_FIRST:
-+         params[0] = BOOLEAN_TO_INT(ctx->Pack.LsbFirst);
-+         break;
-+      case GL_PACK_ROW_LENGTH:
-+         params[0] = ctx->Pack.RowLength;
-+         break;
-+      case GL_PACK_SKIP_PIXELS:
-+         params[0] = ctx->Pack.SkipPixels;
-+         break;
-+      case GL_PACK_SKIP_ROWS:
-+         params[0] = ctx->Pack.SkipRows;
-+         break;
-+      case GL_PACK_SWAP_BYTES:
-+         params[0] = BOOLEAN_TO_INT(ctx->Pack.SwapBytes);
-+         break;
-+      case GL_PACK_SKIP_IMAGES_EXT:
-+         params[0] = ctx->Pack.SkipImages;
-+         break;
-+      case GL_PACK_IMAGE_HEIGHT_EXT:
-+         params[0] = ctx->Pack.ImageHeight;
-+         break;
-+      case GL_PACK_INVERT_MESA:
-+         params[0] = BOOLEAN_TO_INT(ctx->Pack.Invert);
-+         break;
-+      case GL_PERSPECTIVE_CORRECTION_HINT:
-+         params[0] = ENUM_TO_INT(ctx->Hint.PerspectiveCorrection);
-+         break;
-+      case GL_PIXEL_MAP_A_TO_A_SIZE:
-+         params[0] = ctx->Pixel.MapAtoAsize;
-+         break;
-+      case GL_PIXEL_MAP_B_TO_B_SIZE:
-+         params[0] = ctx->Pixel.MapBtoBsize;
-+         break;
-+      case GL_PIXEL_MAP_G_TO_G_SIZE:
-+         params[0] = ctx->Pixel.MapGtoGsize;
-+         break;
-+      case GL_PIXEL_MAP_I_TO_A_SIZE:
-+         params[0] = ctx->Pixel.MapItoAsize;
-+         break;
-+      case GL_PIXEL_MAP_I_TO_B_SIZE:
-+         params[0] = ctx->Pixel.MapItoBsize;
-+         break;
-+      case GL_PIXEL_MAP_I_TO_G_SIZE:
-+         params[0] = ctx->Pixel.MapItoGsize;
-+         break;
-+      case GL_PIXEL_MAP_I_TO_I_SIZE:
-+         params[0] = ctx->Pixel.MapItoIsize;
-+         break;
-+      case GL_PIXEL_MAP_I_TO_R_SIZE:
-+         params[0] = ctx->Pixel.MapItoRsize;
-+         break;
-+      case GL_PIXEL_MAP_R_TO_R_SIZE:
-+         params[0] = ctx->Pixel.MapRtoRsize;
-+         break;
-+      case GL_PIXEL_MAP_S_TO_S_SIZE:
-+         params[0] = ctx->Pixel.MapStoSsize;
-+         break;
-+      case GL_POINT_SIZE:
-+         params[0] = IROUND(ctx->Point.Size);
-+         break;
-+      case GL_POINT_SIZE_GRANULARITY:
-+         params[0] = IROUND(ctx->Const.PointSizeGranularity);
-+         break;
-+      case GL_POINT_SIZE_RANGE:
-+         params[0] = IROUND(ctx->Const.MinPointSizeAA);
-+         params[1] = IROUND(ctx->Const.MaxPointSizeAA);
-+         break;
-+      case GL_ALIASED_POINT_SIZE_RANGE:
-+         params[0] = IROUND(ctx->Const.MinPointSize);
-+         params[1] = IROUND(ctx->Const.MaxPointSize);
-+         break;
-+      case GL_POINT_SMOOTH:
-+         params[0] = BOOLEAN_TO_INT(ctx->Point.SmoothFlag);
-+         break;
-+      case GL_POINT_SMOOTH_HINT:
-+         params[0] = ENUM_TO_INT(ctx->Hint.PointSmooth);
-+         break;
-+      case GL_POINT_SIZE_MIN_EXT:
-+         params[0] = IROUND(ctx->Point.MinSize);
-+         break;
-+      case GL_POINT_SIZE_MAX_EXT:
-+         params[0] = IROUND(ctx->Point.MaxSize);
-+         break;
-+      case GL_POINT_FADE_THRESHOLD_SIZE_EXT:
-+         params[0] = IROUND(ctx->Point.Threshold);
-+         break;
-+      case GL_DISTANCE_ATTENUATION_EXT:
-+         params[0] = IROUND(ctx->Point.Params[0]);
-+         params[1] = IROUND(ctx->Point.Params[1]);
-+         params[2] = IROUND(ctx->Point.Params[2]);
-+         break;
-+      case GL_POLYGON_MODE:
-+         params[0] = ENUM_TO_INT(ctx->Polygon.FrontMode);
-+         params[1] = ENUM_TO_INT(ctx->Polygon.BackMode);
-+         break;
-+      case GL_POLYGON_OFFSET_BIAS_EXT:
-+         params[0] = IROUND(ctx->Polygon.OffsetUnits);
-+         break;
-+      case GL_POLYGON_OFFSET_FACTOR:
-+         params[0] = IROUND(ctx->Polygon.OffsetFactor );
-+         break;
-+      case GL_POLYGON_OFFSET_UNITS:
-+         params[0] = IROUND(ctx->Polygon.OffsetUnits );
-+         break;
-+      case GL_POLYGON_SMOOTH:
-+         params[0] = BOOLEAN_TO_INT(ctx->Polygon.SmoothFlag);
-+         break;
-+      case GL_POLYGON_SMOOTH_HINT:
-+         params[0] = ENUM_TO_INT(ctx->Hint.PolygonSmooth);
-+         break;
-+      case GL_POLYGON_STIPPLE:
-+         params[0] = BOOLEAN_TO_INT(ctx->Polygon.StippleFlag);
-+         break;
-+      case GL_PROJECTION_MATRIX:
-+         {
-+         const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
-+         params[0] = IROUND(matrix[0]);
-+         params[1] = IROUND(matrix[1]);
-+         params[2] = IROUND(matrix[2]);
-+         params[3] = IROUND(matrix[3]);
-+         params[4] = IROUND(matrix[4]);
-+         params[5] = IROUND(matrix[5]);
-+         params[6] = IROUND(matrix[6]);
-+         params[7] = IROUND(matrix[7]);
-+         params[8] = IROUND(matrix[8]);
-+         params[9] = IROUND(matrix[9]);
-+         params[10] = IROUND(matrix[10]);
-+         params[11] = IROUND(matrix[11]);
-+         params[12] = IROUND(matrix[12]);
-+         params[13] = IROUND(matrix[13]);
-+         params[14] = IROUND(matrix[14]);
-+         params[15] = IROUND(matrix[15]);
-+         }
-+         break;
-+      case GL_PROJECTION_STACK_DEPTH:
-+         params[0] = ctx->ProjectionMatrixStack.Depth + 1;
-+         break;
-+      case GL_READ_BUFFER:
-+         params[0] = ENUM_TO_INT(ctx->ReadBuffer->ColorReadBuffer);
-+         break;
-+      case GL_RED_BIAS:
-+         params[0] = IROUND(ctx->Pixel.RedBias);
-+         break;
-+      case GL_RED_BITS:
-+         params[0] =  ctx->DrawBuffer->Visual.redBits ;
-+         break;
-+      case GL_RED_SCALE:
-+         params[0] = IROUND(ctx->Pixel.RedScale);
-+         break;
-+      case GL_RENDER_MODE:
-+         params[0] = ENUM_TO_INT(ctx->RenderMode);
-+         break;
-+      case GL_RESCALE_NORMAL:
-+         params[0] = BOOLEAN_TO_INT(ctx->Transform.RescaleNormals);
-+         break;
-+      case GL_RGBA_MODE:
-+         params[0] = BOOLEAN_TO_INT(ctx->DrawBuffer->Visual.rgbMode);
-+         break;
-+      case GL_SCISSOR_BOX:
-+         params[0] = ctx->Scissor.X;
-+         params[1] = ctx->Scissor.Y;
-+         params[2] = ctx->Scissor.Width;
-+         params[3] = ctx->Scissor.Height;
-+         break;
-+      case GL_SCISSOR_TEST:
-+         params[0] = BOOLEAN_TO_INT(ctx->Scissor.Enabled);
-+         break;
-+      case GL_SELECTION_BUFFER_SIZE:
-+         params[0] = ctx->Select.BufferSize;
-+         break;
-+      case GL_SHADE_MODEL:
-+         params[0] = ENUM_TO_INT(ctx->Light.ShadeModel);
-+         break;
-+      case GL_SHARED_TEXTURE_PALETTE_EXT:
-+         params[0] = BOOLEAN_TO_INT(ctx->Texture.SharedPalette);
-+         break;
-+      case GL_STENCIL_BITS:
-+         params[0] = ctx->DrawBuffer->Visual.stencilBits;
-+         break;
-+      case GL_STENCIL_CLEAR_VALUE:
-+         params[0] = ctx->Stencil.Clear;
-+         break;
-+      case GL_STENCIL_FAIL:
-+         params[0] = ENUM_TO_INT(ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace]);
-+         break;
-+      case GL_STENCIL_FUNC:
-+         params[0] = ENUM_TO_INT(ctx->Stencil.Function[ctx->Stencil.ActiveFace]);
-+         break;
-+      case GL_STENCIL_PASS_DEPTH_FAIL:
-+         params[0] = ENUM_TO_INT(ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace]);
-+         break;
-+      case GL_STENCIL_PASS_DEPTH_PASS:
-+         params[0] = ENUM_TO_INT(ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace]);
-+         break;
-+      case GL_STENCIL_REF:
-+         params[0] = ctx->Stencil.Ref[ctx->Stencil.ActiveFace];
-+         break;
-+      case GL_STENCIL_TEST:
-+         params[0] = BOOLEAN_TO_INT(ctx->Stencil.Enabled);
-+         break;
-+      case GL_STENCIL_VALUE_MASK:
-+         params[0] = ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace];
-+         break;
-+      case GL_STENCIL_WRITEMASK:
-+         params[0] = ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace];
-+         break;
-+      case GL_STEREO:
-+         params[0] = BOOLEAN_TO_INT(ctx->DrawBuffer->Visual.stereoMode);
-+         break;
-+      case GL_SUBPIXEL_BITS:
-+         params[0] = ctx->Const.SubPixelBits;
-+         break;
-+      case GL_TEXTURE_1D:
-+         params[0] = BOOLEAN_TO_INT(_mesa_IsEnabled(GL_TEXTURE_1D));
-+         break;
-+      case GL_TEXTURE_2D:
-+         params[0] = BOOLEAN_TO_INT(_mesa_IsEnabled(GL_TEXTURE_2D));
-+         break;
-+      case GL_TEXTURE_3D:
-+         params[0] = BOOLEAN_TO_INT(_mesa_IsEnabled(GL_TEXTURE_3D));
-+         break;
-+      case GL_TEXTURE_BINDING_1D:
-+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current1D->Name;
-+         break;
-+      case GL_TEXTURE_BINDING_2D:
-+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current2D->Name;
-+         break;
-+      case GL_TEXTURE_BINDING_3D:
-+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Current3D->Name;
-+         break;
-+      case GL_TEXTURE_ENV_COLOR:
-+         {
-+         const GLfloat *color = ctx->Texture.Unit[ctx->Texture.CurrentUnit].EnvColor;
-+         params[0] = FLOAT_TO_INT(color[0]);
-+         params[1] = FLOAT_TO_INT(color[1]);
-+         params[2] = FLOAT_TO_INT(color[2]);
-+         params[3] = FLOAT_TO_INT(color[3]);
-+         }
-+         break;
-+      case GL_TEXTURE_ENV_MODE:
-+         params[0] = ENUM_TO_INT(ctx->Texture.Unit[ctx->Texture.CurrentUnit].EnvMode);
-+         break;
-+      case GL_TEXTURE_GEN_S:
-+         params[0] = BOOLEAN_TO_INT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & S_BIT) ? 1 : 0));
-+         break;
-+      case GL_TEXTURE_GEN_T:
-+         params[0] = BOOLEAN_TO_INT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & T_BIT) ? 1 : 0));
-+         break;
-+      case GL_TEXTURE_GEN_R:
-+         params[0] = BOOLEAN_TO_INT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & R_BIT) ? 1 : 0));
-+         break;
-+      case GL_TEXTURE_GEN_Q:
-+         params[0] = BOOLEAN_TO_INT(((ctx->Texture.Unit[ctx->Texture.CurrentUnit].TexGenEnabled & Q_BIT) ? 1 : 0));
-+         break;
-+      case GL_TEXTURE_MATRIX:
-+         {
-+         const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
-+         params[0] = IROUND(matrix[0]);
-+         params[1] = IROUND(matrix[1]);
-+         params[2] = IROUND(matrix[2]);
-+         params[3] = IROUND(matrix[3]);
-+         params[4] = IROUND(matrix[4]);
-+         params[5] = IROUND(matrix[5]);
-+         params[6] = IROUND(matrix[6]);
-+         params[7] = IROUND(matrix[7]);
-+         params[8] = IROUND(matrix[8]);
-+         params[9] = IROUND(matrix[9]);
-+         params[10] = IROUND(matrix[10]);
-+         params[11] = IROUND(matrix[11]);
-+         params[12] = IROUND(matrix[12]);
-+         params[13] = IROUND(matrix[13]);
-+         params[14] = IROUND(matrix[14]);
-+         params[15] = IROUND(matrix[15]);
-+         }
-+         break;
-+      case GL_TEXTURE_STACK_DEPTH:
-+         params[0] = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Depth + 1;
-+         break;
-+      case GL_UNPACK_ALIGNMENT:
-+         params[0] = ctx->Unpack.Alignment;
-+         break;
-+      case GL_UNPACK_LSB_FIRST:
-+         params[0] = BOOLEAN_TO_INT(ctx->Unpack.LsbFirst);
-+         break;
-+      case GL_UNPACK_ROW_LENGTH:
-+         params[0] = ctx->Unpack.RowLength;
-+         break;
-+      case GL_UNPACK_SKIP_PIXELS:
-+         params[0] = ctx->Unpack.SkipPixels;
-+         break;
-+      case GL_UNPACK_SKIP_ROWS:
-+         params[0] = ctx->Unpack.SkipRows;
-+         break;
-+      case GL_UNPACK_SWAP_BYTES:
-+         params[0] = BOOLEAN_TO_INT(ctx->Unpack.SwapBytes);
-+         break;
-+      case GL_UNPACK_SKIP_IMAGES_EXT:
-+         params[0] = ctx->Unpack.SkipImages;
-+         break;
-+      case GL_UNPACK_IMAGE_HEIGHT_EXT:
-+         params[0] = ctx->Unpack.ImageHeight;
-+         break;
-+      case GL_UNPACK_CLIENT_STORAGE_APPLE:
-+         params[0] = BOOLEAN_TO_INT(ctx->Unpack.ClientStorage);
-+         break;
-+      case GL_VIEWPORT:
-+         params[0] = ctx->Viewport.X;
-+         params[1] = ctx->Viewport.Y;
-+         params[2] = ctx->Viewport.Width;
-+         params[3] = ctx->Viewport.Height;
-+         break;
-+      case GL_ZOOM_X:
-+         params[0] = IROUND(ctx->Pixel.ZoomX);
-+         break;
-+      case GL_ZOOM_Y:
-+         params[0] = IROUND(ctx->Pixel.ZoomY);
-+         break;
-+      case GL_VERTEX_ARRAY:
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->Vertex.Enabled);
-+         break;
-+      case GL_VERTEX_ARRAY_SIZE:
-+         params[0] = ctx->Array.ArrayObj->Vertex.Size;
-+         break;
-+      case GL_VERTEX_ARRAY_TYPE:
-+         params[0] = ENUM_TO_INT(ctx->Array.ArrayObj->Vertex.Type);
-+         break;
-+      case GL_VERTEX_ARRAY_STRIDE:
-+         params[0] = ctx->Array.ArrayObj->Vertex.Stride;
-+         break;
-+      case GL_VERTEX_ARRAY_COUNT_EXT:
-+         params[0] = 0;
-+         break;
-+      case GL_NORMAL_ARRAY:
-+         params[0] = ENUM_TO_INT(ctx->Array.ArrayObj->Normal.Enabled);
-+         break;
-+      case GL_NORMAL_ARRAY_TYPE:
-+         params[0] = ENUM_TO_INT(ctx->Array.ArrayObj->Normal.Type);
-+         break;
-+      case GL_NORMAL_ARRAY_STRIDE:
-+         params[0] = ctx->Array.ArrayObj->Normal.Stride;
-+         break;
-+      case GL_NORMAL_ARRAY_COUNT_EXT:
-+         params[0] = 0;
-+         break;
-+      case GL_COLOR_ARRAY:
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->Color.Enabled);
-+         break;
-+      case GL_COLOR_ARRAY_SIZE:
-+         params[0] = ctx->Array.ArrayObj->Color.Size;
-+         break;
-+      case GL_COLOR_ARRAY_TYPE:
-+         params[0] = ENUM_TO_INT(ctx->Array.ArrayObj->Color.Type);
-+         break;
-+      case GL_COLOR_ARRAY_STRIDE:
-+         params[0] = ctx->Array.ArrayObj->Color.Stride;
-+         break;
-+      case GL_COLOR_ARRAY_COUNT_EXT:
-+         params[0] = 0;
-+         break;
-+      case GL_INDEX_ARRAY:
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->Index.Enabled);
-+         break;
-+      case GL_INDEX_ARRAY_TYPE:
-+         params[0] = ENUM_TO_INT(ctx->Array.ArrayObj->Index.Type);
-+         break;
-+      case GL_INDEX_ARRAY_STRIDE:
-+         params[0] = ctx->Array.ArrayObj->Index.Stride;
-+         break;
-+      case GL_INDEX_ARRAY_COUNT_EXT:
-+         params[0] = 0;
-+         break;
-+      case GL_TEXTURE_COORD_ARRAY:
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Enabled);
-+         break;
-+      case GL_TEXTURE_COORD_ARRAY_SIZE:
-+         params[0] = ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Size;
-+         break;
-+      case GL_TEXTURE_COORD_ARRAY_TYPE:
-+         params[0] = ENUM_TO_INT(ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Type);
-+         break;
-+      case GL_TEXTURE_COORD_ARRAY_STRIDE:
-+         params[0] = ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].Stride;
-+         break;
-+      case GL_TEXTURE_COORD_ARRAY_COUNT_EXT:
-+         params[0] = 0;
-+         break;
-+      case GL_EDGE_FLAG_ARRAY:
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->EdgeFlag.Enabled);
-+         break;
-+      case GL_EDGE_FLAG_ARRAY_STRIDE:
-+         params[0] = ctx->Array.ArrayObj->EdgeFlag.Stride;
-+         break;
-+      case GL_EDGE_FLAG_ARRAY_COUNT_EXT:
-+         params[0] = 0;
-+         break;
-+      case GL_MAX_TEXTURE_UNITS_ARB:
-+         CHECK_EXT1(ARB_multitexture, "GetIntegerv");
-+         params[0] = ctx->Const.MaxTextureUnits;
-+         break;
-+      case GL_ACTIVE_TEXTURE_ARB:
-+         CHECK_EXT1(ARB_multitexture, "GetIntegerv");
-+         params[0] = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit;
-+         break;
-+      case GL_CLIENT_ACTIVE_TEXTURE_ARB:
-+         CHECK_EXT1(ARB_multitexture, "GetIntegerv");
-+         params[0] = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture;
-+         break;
-+      case GL_TEXTURE_CUBE_MAP_ARB:
-+         CHECK_EXT1(ARB_texture_cube_map, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(_mesa_IsEnabled(GL_TEXTURE_CUBE_MAP_ARB));
-+         break;
-+      case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-+         CHECK_EXT1(ARB_texture_cube_map, "GetIntegerv");
-+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentCubeMap->Name;
-+         break;
-+      case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-+         CHECK_EXT1(ARB_texture_cube_map, "GetIntegerv");
-+         params[0] = (1 << (ctx->Const.MaxCubeTextureLevels - 1));
-+         break;
-+      case GL_TEXTURE_COMPRESSION_HINT_ARB:
-+         CHECK_EXT1(ARB_texture_compression, "GetIntegerv");
-+         params[0] = ctx->Hint.TextureCompression;
-+         break;
-+      case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-+         CHECK_EXT1(ARB_texture_compression, "GetIntegerv");
-+         params[0] = _mesa_get_compressed_formats(ctx, NULL, GL_FALSE);
-+         break;
-+      case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-+         CHECK_EXT1(ARB_texture_compression, "GetIntegerv");
-+         {
-+         GLint formats[100];
-+         GLuint i, n = _mesa_get_compressed_formats(ctx, formats, GL_FALSE);
-+         ASSERT(n <= 100);
-+         for (i = 0; i < n; i++)
-+            params[i] = ENUM_TO_INT(formats[i]);
-+         }
-+         break;
-+      case GL_ARRAY_ELEMENT_LOCK_FIRST_EXT:
-+         CHECK_EXT1(EXT_compiled_vertex_array, "GetIntegerv");
-+         params[0] = ctx->Array.LockFirst;
-+         break;
-+      case GL_ARRAY_ELEMENT_LOCK_COUNT_EXT:
-+         CHECK_EXT1(EXT_compiled_vertex_array, "GetIntegerv");
-+         params[0] = ctx->Array.LockCount;
-+         break;
-+      case GL_TRANSPOSE_COLOR_MATRIX_ARB:
-+         {
-+         const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
-+         params[0] = IROUND(matrix[0]);
-+         params[1] = IROUND(matrix[4]);
-+         params[2] = IROUND(matrix[8]);
-+         params[3] = IROUND(matrix[12]);
-+         params[4] = IROUND(matrix[1]);
-+         params[5] = IROUND(matrix[5]);
-+         params[6] = IROUND(matrix[9]);
-+         params[7] = IROUND(matrix[13]);
-+         params[8] = IROUND(matrix[2]);
-+         params[9] = IROUND(matrix[6]);
-+         params[10] = IROUND(matrix[10]);
-+         params[11] = IROUND(matrix[14]);
-+         params[12] = IROUND(matrix[3]);
-+         params[13] = IROUND(matrix[7]);
-+         params[14] = IROUND(matrix[11]);
-+         params[15] = IROUND(matrix[15]);
-+         }
-+         break;
-+      case GL_TRANSPOSE_MODELVIEW_MATRIX_ARB:
-+         {
-+         const GLfloat *matrix = ctx->ModelviewMatrixStack.Top->m;
-+         params[0] = IROUND(matrix[0]);
-+         params[1] = IROUND(matrix[4]);
-+         params[2] = IROUND(matrix[8]);
-+         params[3] = IROUND(matrix[12]);
-+         params[4] = IROUND(matrix[1]);
-+         params[5] = IROUND(matrix[5]);
-+         params[6] = IROUND(matrix[9]);
-+         params[7] = IROUND(matrix[13]);
-+         params[8] = IROUND(matrix[2]);
-+         params[9] = IROUND(matrix[6]);
-+         params[10] = IROUND(matrix[10]);
-+         params[11] = IROUND(matrix[14]);
-+         params[12] = IROUND(matrix[3]);
-+         params[13] = IROUND(matrix[7]);
-+         params[14] = IROUND(matrix[11]);
-+         params[15] = IROUND(matrix[15]);
-+         }
-+         break;
-+      case GL_TRANSPOSE_PROJECTION_MATRIX_ARB:
-+         {
-+         const GLfloat *matrix = ctx->ProjectionMatrixStack.Top->m;
-+         params[0] = IROUND(matrix[0]);
-+         params[1] = IROUND(matrix[4]);
-+         params[2] = IROUND(matrix[8]);
-+         params[3] = IROUND(matrix[12]);
-+         params[4] = IROUND(matrix[1]);
-+         params[5] = IROUND(matrix[5]);
-+         params[6] = IROUND(matrix[9]);
-+         params[7] = IROUND(matrix[13]);
-+         params[8] = IROUND(matrix[2]);
-+         params[9] = IROUND(matrix[6]);
-+         params[10] = IROUND(matrix[10]);
-+         params[11] = IROUND(matrix[14]);
-+         params[12] = IROUND(matrix[3]);
-+         params[13] = IROUND(matrix[7]);
-+         params[14] = IROUND(matrix[11]);
-+         params[15] = IROUND(matrix[15]);
-+         }
-+         break;
-+      case GL_TRANSPOSE_TEXTURE_MATRIX_ARB:
-+         {
-+         const GLfloat *matrix = ctx->TextureMatrixStack[ctx->Texture.CurrentUnit].Top->m;
-+         params[0] = IROUND(matrix[0]);
-+         params[1] = IROUND(matrix[4]);
-+         params[2] = IROUND(matrix[8]);
-+         params[3] = IROUND(matrix[12]);
-+         params[4] = IROUND(matrix[1]);
-+         params[5] = IROUND(matrix[5]);
-+         params[6] = IROUND(matrix[9]);
-+         params[7] = IROUND(matrix[13]);
-+         params[8] = IROUND(matrix[2]);
-+         params[9] = IROUND(matrix[6]);
-+         params[10] = IROUND(matrix[10]);
-+         params[11] = IROUND(matrix[14]);
-+         params[12] = IROUND(matrix[3]);
-+         params[13] = IROUND(matrix[7]);
-+         params[14] = IROUND(matrix[11]);
-+         params[15] = IROUND(matrix[15]);
-+         }
-+         break;
-+      case GL_COLOR_MATRIX_SGI:
-+         {
-+         const GLfloat *matrix = ctx->ColorMatrixStack.Top->m;
-+         params[0] = IROUND(matrix[0]);
-+         params[1] = IROUND(matrix[1]);
-+         params[2] = IROUND(matrix[2]);
-+         params[3] = IROUND(matrix[3]);
-+         params[4] = IROUND(matrix[4]);
-+         params[5] = IROUND(matrix[5]);
-+         params[6] = IROUND(matrix[6]);
-+         params[7] = IROUND(matrix[7]);
-+         params[8] = IROUND(matrix[8]);
-+         params[9] = IROUND(matrix[9]);
-+         params[10] = IROUND(matrix[10]);
-+         params[11] = IROUND(matrix[11]);
-+         params[12] = IROUND(matrix[12]);
-+         params[13] = IROUND(matrix[13]);
-+         params[14] = IROUND(matrix[14]);
-+         params[15] = IROUND(matrix[15]);
-+         }
-+         break;
-+      case GL_COLOR_MATRIX_STACK_DEPTH_SGI:
-+         params[0] = ctx->ColorMatrixStack.Depth + 1;
-+         break;
-+      case GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI:
-+         params[0] = MAX_COLOR_STACK_DEPTH;
-+         break;
-+      case GL_POST_COLOR_MATRIX_RED_SCALE_SGI:
-+         params[0] = IROUND(ctx->Pixel.PostColorMatrixScale[0]);
-+         break;
-+      case GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI:
-+         params[0] = IROUND(ctx->Pixel.PostColorMatrixScale[1]);
-+         break;
-+      case GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI:
-+         params[0] = IROUND(ctx->Pixel.PostColorMatrixScale[2]);
-+         break;
-+      case GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI:
-+         params[0] = IROUND(ctx->Pixel.PostColorMatrixScale[3]);
-+         break;
-+      case GL_POST_COLOR_MATRIX_RED_BIAS_SGI:
-+         params[0] = IROUND(ctx->Pixel.PostColorMatrixBias[0]);
-+         break;
-+      case GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI:
-+         params[0] = IROUND(ctx->Pixel.PostColorMatrixBias[1]);
-+         break;
-+      case GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI:
-+         params[0] = IROUND(ctx->Pixel.PostColorMatrixBias[2]);
-+         break;
-+      case GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI:
-+         params[0] = IROUND(ctx->Pixel.PostColorMatrixBias[3]);
-+         break;
-+      case GL_CONVOLUTION_1D_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Pixel.Convolution1DEnabled);
-+         break;
-+      case GL_CONVOLUTION_2D_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Pixel.Convolution2DEnabled);
-+         break;
-+      case GL_SEPARABLE_2D_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Pixel.Separable2DEnabled);
-+         break;
-+      case GL_POST_CONVOLUTION_RED_SCALE_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+         params[0] = IROUND(ctx->Pixel.PostConvolutionScale[0]);
-+         break;
-+      case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+         params[0] = IROUND(ctx->Pixel.PostConvolutionScale[1]);
-+         break;
-+      case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+         params[0] = IROUND(ctx->Pixel.PostConvolutionScale[2]);
-+         break;
-+      case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+         params[0] = IROUND(ctx->Pixel.PostConvolutionScale[3]);
-+         break;
-+      case GL_POST_CONVOLUTION_RED_BIAS_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+         params[0] = IROUND(ctx->Pixel.PostConvolutionBias[0]);
-+         break;
-+      case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+         params[0] = IROUND(ctx->Pixel.PostConvolutionBias[1]);
-+         break;
-+      case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+         params[0] = IROUND(ctx->Pixel.PostConvolutionBias[2]);
-+         break;
-+      case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:
-+         CHECK_EXT1(EXT_convolution, "GetIntegerv");
-+         params[0] = IROUND(ctx->Pixel.PostConvolutionBias[3]);
-+         break;
-+      case GL_HISTOGRAM:
-+         CHECK_EXT1(EXT_histogram, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Pixel.HistogramEnabled);
-+         break;
-+      case GL_MINMAX:
-+         CHECK_EXT1(EXT_histogram, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Pixel.MinMaxEnabled);
-+         break;
-+      case GL_COLOR_TABLE_SGI:
-+         CHECK_EXT1(SGI_color_table, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Pixel.ColorTableEnabled);
-+         break;
-+      case GL_POST_CONVOLUTION_COLOR_TABLE_SGI:
-+         CHECK_EXT1(SGI_color_table, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Pixel.PostConvolutionColorTableEnabled);
-+         break;
-+      case GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI:
-+         CHECK_EXT1(SGI_color_table, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Pixel.PostColorMatrixColorTableEnabled);
-+         break;
-+      case GL_TEXTURE_COLOR_TABLE_SGI:
-+         CHECK_EXT1(SGI_texture_color_table, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Texture.Unit[ctx->Texture.CurrentUnit].ColorTableEnabled);
-+         break;
-+      case GL_COLOR_SUM_EXT:
-+         CHECK_EXT2(EXT_secondary_color, ARB_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Fog.ColorSumEnabled);
-+         break;
-+      case GL_CURRENT_SECONDARY_COLOR_EXT:
-+         CHECK_EXT1(EXT_secondary_color, "GetIntegerv");
-+         {
-+         FLUSH_CURRENT(ctx, 0);
-+         params[0] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][0]);
-+         params[1] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][1]);
-+         params[2] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][2]);
-+         params[3] = FLOAT_TO_INT(ctx->Current.Attrib[VERT_ATTRIB_COLOR1][3]);
-+         }
-+         break;
-+      case GL_SECONDARY_COLOR_ARRAY_EXT:
-+         CHECK_EXT1(EXT_secondary_color, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->SecondaryColor.Enabled);
-+         break;
-+      case GL_SECONDARY_COLOR_ARRAY_TYPE_EXT:
-+         CHECK_EXT1(EXT_secondary_color, "GetIntegerv");
-+         params[0] = ENUM_TO_INT(ctx->Array.ArrayObj->SecondaryColor.Type);
-+         break;
-+      case GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT:
-+         CHECK_EXT1(EXT_secondary_color, "GetIntegerv");
-+         params[0] = ctx->Array.ArrayObj->SecondaryColor.Stride;
-+         break;
-+      case GL_SECONDARY_COLOR_ARRAY_SIZE_EXT:
-+         CHECK_EXT1(EXT_secondary_color, "GetIntegerv");
-+         params[0] = ctx->Array.ArrayObj->SecondaryColor.Size;
-+         break;
-+      case GL_CURRENT_FOG_COORDINATE_EXT:
-+         CHECK_EXT1(EXT_fog_coord, "GetIntegerv");
-+         {
-+         FLUSH_CURRENT(ctx, 0);
-+         params[0] = IROUND(ctx->Current.Attrib[VERT_ATTRIB_FOG][0]);
-+         }
-+         break;
-+      case GL_FOG_COORDINATE_ARRAY_EXT:
-+         CHECK_EXT1(EXT_fog_coord, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->FogCoord.Enabled);
-+         break;
-+      case GL_FOG_COORDINATE_ARRAY_TYPE_EXT:
-+         CHECK_EXT1(EXT_fog_coord, "GetIntegerv");
-+         params[0] = ENUM_TO_INT(ctx->Array.ArrayObj->FogCoord.Type);
-+         break;
-+      case GL_FOG_COORDINATE_ARRAY_STRIDE_EXT:
-+         CHECK_EXT1(EXT_fog_coord, "GetIntegerv");
-+         params[0] = ctx->Array.ArrayObj->FogCoord.Stride;
-+         break;
-+      case GL_FOG_COORDINATE_SOURCE_EXT:
-+         CHECK_EXT1(EXT_fog_coord, "GetIntegerv");
-+         params[0] = ENUM_TO_INT(ctx->Fog.FogCoordinateSource);
-+         break;
-+      case GL_MAX_TEXTURE_LOD_BIAS_EXT:
-+         CHECK_EXT1(EXT_texture_lod_bias, "GetIntegerv");
-+         params[0] = IROUND(ctx->Const.MaxTextureLodBias);
-+         break;
-+      case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
-+         CHECK_EXT1(EXT_texture_filter_anisotropic, "GetIntegerv");
-+         params[0] = IROUND(ctx->Const.MaxTextureMaxAnisotropy);
-+         break;
-+      case GL_MULTISAMPLE_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Multisample.Enabled);
-+         break;
-+      case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Multisample.SampleAlphaToCoverage);
-+         break;
-+      case GL_SAMPLE_ALPHA_TO_ONE_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Multisample.SampleAlphaToOne);
-+         break;
-+      case GL_SAMPLE_COVERAGE_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Multisample.SampleCoverage);
-+         break;
-+      case GL_SAMPLE_COVERAGE_VALUE_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetIntegerv");
-+         params[0] = IROUND(ctx->Multisample.SampleCoverageValue);
-+         break;
-+      case GL_SAMPLE_COVERAGE_INVERT_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Multisample.SampleCoverageInvert);
-+         break;
-+      case GL_SAMPLE_BUFFERS_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetIntegerv");
-+         params[0] = ctx->DrawBuffer->Visual.sampleBuffers;
-+         break;
-+      case GL_SAMPLES_ARB:
-+         CHECK_EXT1(ARB_multisample, "GetIntegerv");
-+         params[0] = ctx->DrawBuffer->Visual.samples;
-+         break;
-+      case GL_RASTER_POSITION_UNCLIPPED_IBM:
-+         CHECK_EXT1(IBM_rasterpos_clip, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Transform.RasterPositionUnclipped);
-+         break;
-+      case GL_POINT_SPRITE_NV:
-+         CHECK_EXT2(NV_point_sprite, ARB_point_sprite, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Point.PointSprite);
-+         break;
-+      case GL_POINT_SPRITE_R_MODE_NV:
-+         CHECK_EXT1(NV_point_sprite, "GetIntegerv");
-+         params[0] = ENUM_TO_INT(ctx->Point.SpriteRMode);
-+         break;
-+      case GL_POINT_SPRITE_COORD_ORIGIN:
-+         CHECK_EXT2(NV_point_sprite, ARB_point_sprite, "GetIntegerv");
-+         params[0] = ENUM_TO_INT(ctx->Point.SpriteOrigin);
-+         break;
-+      case GL_GENERATE_MIPMAP_HINT_SGIS:
-+         CHECK_EXT1(SGIS_generate_mipmap, "GetIntegerv");
-+         params[0] = ENUM_TO_INT(ctx->Hint.GenerateMipmap);
-+         break;
-+      case GL_VERTEX_PROGRAM_BINDING_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = (ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY0_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[0].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY1_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[1].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY2_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[2].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY3_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[3].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[4].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY5_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[5].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY6_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[6].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY7_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[7].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY8_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[8].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY9_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[9].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY10_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[10].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY11_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[11].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY12_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[12].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY13_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[13].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY14_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[14].Enabled);
-+         break;
-+      case GL_VERTEX_ATTRIB_ARRAY15_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Array.ArrayObj->VertexAttrib[15].Enabled);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB0_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[0]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB1_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[1]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB2_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[2]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB3_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[3]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB4_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[4]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB5_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[5]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB6_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[6]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB7_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[7]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB8_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[8]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB9_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[9]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB10_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[10]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB11_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[11]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB12_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[12]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB13_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[13]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB14_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[14]);
-+         break;
-+      case GL_MAP1_VERTEX_ATTRIB15_4_NV:
-+         CHECK_EXT1(NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Eval.Map1Attrib[15]);
-+         break;
-+      case GL_FRAGMENT_PROGRAM_NV:
-+         CHECK_EXT1(NV_fragment_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->FragmentProgram.Enabled);
-+         break;
-+      case GL_FRAGMENT_PROGRAM_BINDING_NV:
-+         CHECK_EXT1(NV_fragment_program, "GetIntegerv");
-+         params[0] = ctx->FragmentProgram.Current ? ctx->FragmentProgram.Current->Base.Id : 0;
-+         break;
-+      case GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV:
-+         CHECK_EXT1(NV_fragment_program, "GetIntegerv");
-+         params[0] = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
-+         break;
-+      case GL_TEXTURE_RECTANGLE_NV:
-+         CHECK_EXT1(NV_texture_rectangle, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(_mesa_IsEnabled(GL_TEXTURE_RECTANGLE_NV));
-+         break;
-+      case GL_TEXTURE_BINDING_RECTANGLE_NV:
-+         CHECK_EXT1(NV_texture_rectangle, "GetIntegerv");
-+         params[0] = ctx->Texture.Unit[ctx->Texture.CurrentUnit].CurrentRect->Name;
-+         break;
-+      case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
-+         CHECK_EXT1(NV_texture_rectangle, "GetIntegerv");
-+         params[0] = ctx->Const.MaxTextureRectSize;
-+         break;
-+      case GL_STENCIL_TEST_TWO_SIDE_EXT:
-+         CHECK_EXT1(EXT_stencil_two_side, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Stencil.TestTwoSide);
-+         break;
-+      case GL_ACTIVE_STENCIL_FACE_EXT:
-+         CHECK_EXT1(EXT_stencil_two_side, "GetIntegerv");
-+         params[0] = ENUM_TO_INT(ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT);
-+         break;
-+      case GL_MAX_SHININESS_NV:
-+         CHECK_EXT1(NV_light_max_exponent, "GetIntegerv");
-+         params[0] = IROUND(ctx->Const.MaxShininess);
-+         break;
-+      case GL_MAX_SPOT_EXPONENT_NV:
-+         CHECK_EXT1(NV_light_max_exponent, "GetIntegerv");
-+         params[0] = IROUND(ctx->Const.MaxSpotExponent);
-+         break;
-+      case GL_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+         params[0] = ctx->Array.ArrayBufferObj->Name;
-+         break;
-+      case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+         params[0] = ctx->Array.ArrayObj->Vertex.BufferObj->Name;
-+         break;
-+      case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+         params[0] = ctx->Array.ArrayObj->Normal.BufferObj->Name;
-+         break;
-+      case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+         params[0] = ctx->Array.ArrayObj->Color.BufferObj->Name;
-+         break;
-+      case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+         params[0] = ctx->Array.ArrayObj->Index.BufferObj->Name;
-+         break;
-+      case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+         params[0] = ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].BufferObj->Name;
-+         break;
-+      case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+         params[0] = ctx->Array.ArrayObj->EdgeFlag.BufferObj->Name;
-+         break;
-+      case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+         params[0] = ctx->Array.ArrayObj->SecondaryColor.BufferObj->Name;
-+         break;
-+      case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+         params[0] = ctx->Array.ArrayObj->FogCoord.BufferObj->Name;
-+         break;
-+      case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
-+         CHECK_EXT1(ARB_vertex_buffer_object, "GetIntegerv");
-+         params[0] = ctx->Array.ElementArrayBufferObj->Name;
-+         break;
-+      case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
-+         CHECK_EXT1(EXT_pixel_buffer_object, "GetIntegerv");
-+         params[0] = ctx->Pack.BufferObj->Name;
-+         break;
-+      case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:
-+         CHECK_EXT1(EXT_pixel_buffer_object, "GetIntegerv");
-+         params[0] = ctx->Unpack.BufferObj->Name;
-+         break;
-+      case GL_VERTEX_PROGRAM_ARB:
-+         CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->VertexProgram.Enabled);
-+         break;
-+      case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
-+         CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->VertexProgram.PointSizeEnabled);
-+         break;
-+      case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
-+         CHECK_EXT2(ARB_vertex_program, NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->VertexProgram.TwoSideEnabled);
-+         break;
-+      case GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB:
-+         CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetIntegerv");
-+         params[0] = ctx->Const.MaxProgramMatrixStackDepth;
-+         break;
-+      case GL_MAX_PROGRAM_MATRICES_ARB:
-+         CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetIntegerv");
-+         params[0] = ctx->Const.MaxProgramMatrices;
-+         break;
-+      case GL_CURRENT_MATRIX_STACK_DEPTH_ARB:
-+         CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_vertex_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->CurrentStack->Depth + 1);
-+         break;
-+      case GL_CURRENT_MATRIX_ARB:
-+         CHECK_EXT3(ARB_vertex_program, ARB_fragment_program, NV_fragment_program, "GetIntegerv");
-+         {
-+         const GLfloat *matrix = ctx->CurrentStack->Top->m;
-+         params[0] = IROUND(matrix[0]);
-+         params[1] = IROUND(matrix[1]);
-+         params[2] = IROUND(matrix[2]);
-+         params[3] = IROUND(matrix[3]);
-+         params[4] = IROUND(matrix[4]);
-+         params[5] = IROUND(matrix[5]);
-+         params[6] = IROUND(matrix[6]);
-+         params[7] = IROUND(matrix[7]);
-+         params[8] = IROUND(matrix[8]);
-+         params[9] = IROUND(matrix[9]);
-+         params[10] = IROUND(matrix[10]);
-+         params[11] = IROUND(matrix[11]);
-+         params[12] = IROUND(matrix[12]);
-+         params[13] = IROUND(matrix[13]);
-+         params[14] = IROUND(matrix[14]);
-+         params[15] = IROUND(matrix[15]);
-+         }
-+         break;
-+      case GL_TRANSPOSE_CURRENT_MATRIX_ARB:
-+         CHECK_EXT2(ARB_vertex_program, ARB_fragment_program, "GetIntegerv");
-+         {
-+         const GLfloat *matrix = ctx->CurrentStack->Top->m;
-+         params[0] = IROUND(matrix[0]);
-+         params[1] = IROUND(matrix[4]);
-+         params[2] = IROUND(matrix[8]);
-+         params[3] = IROUND(matrix[12]);
-+         params[4] = IROUND(matrix[1]);
-+         params[5] = IROUND(matrix[5]);
-+         params[6] = IROUND(matrix[9]);
-+         params[7] = IROUND(matrix[13]);
-+         params[8] = IROUND(matrix[2]);
-+         params[9] = IROUND(matrix[6]);
-+         params[10] = IROUND(matrix[10]);
-+         params[11] = IROUND(matrix[14]);
-+         params[12] = IROUND(matrix[3]);
-+         params[13] = IROUND(matrix[7]);
-+         params[14] = IROUND(matrix[11]);
-+         params[15] = IROUND(matrix[15]);
-+         }
-+         break;
-+      case GL_MAX_VERTEX_ATTRIBS_ARB:
-+         CHECK_EXT1(ARB_vertex_program, "GetIntegerv");
-+         params[0] = ctx->Const.VertexProgram.MaxAttribs;
-+         break;
-+      case GL_PROGRAM_ERROR_POSITION_ARB:
-+         CHECK_EXT4(NV_vertex_program, ARB_vertex_program, NV_fragment_program, ARB_fragment_program, "GetIntegerv");
-+         params[0] = ctx->Program.ErrorPos;
-+         break;
-+      case GL_FRAGMENT_PROGRAM_ARB:
-+         CHECK_EXT1(ARB_fragment_program, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->FragmentProgram.Enabled);
-+         break;
-+      case GL_MAX_TEXTURE_COORDS_ARB:
-+         CHECK_EXT2(ARB_fragment_program, NV_fragment_program, "GetIntegerv");
-+         params[0] = ctx->Const.MaxTextureCoordUnits;
-+         break;
-+      case GL_MAX_TEXTURE_IMAGE_UNITS_ARB:
-+         CHECK_EXT2(ARB_fragment_program, NV_fragment_program, "GetIntegerv");
-+         params[0] = ctx->Const.MaxTextureImageUnits;
-+         break;
-+      case GL_DEPTH_BOUNDS_TEST_EXT:
-+         CHECK_EXT1(EXT_depth_bounds_test, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->Depth.BoundsTest);
-+         break;
-+      case GL_DEPTH_BOUNDS_EXT:
-+         CHECK_EXT1(EXT_depth_bounds_test, "GetIntegerv");
-+         params[0] = IROUND(ctx->Depth.BoundsMin);
-+         params[1] = IROUND(ctx->Depth.BoundsMax);
-+         break;
-+      case GL_FRAGMENT_PROGRAM_CALLBACK_MESA:
-+         CHECK_EXT1(MESA_program_debug, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->FragmentProgram.CallbackEnabled);
-+         break;
-+      case GL_VERTEX_PROGRAM_CALLBACK_MESA:
-+         CHECK_EXT1(MESA_program_debug, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(ctx->VertexProgram.CallbackEnabled);
-+         break;
-+      case GL_FRAGMENT_PROGRAM_POSITION_MESA:
-+         CHECK_EXT1(MESA_program_debug, "GetIntegerv");
-+         params[0] = ctx->FragmentProgram.CurrentPosition;
-+         break;
-+      case GL_VERTEX_PROGRAM_POSITION_MESA:
-+         CHECK_EXT1(MESA_program_debug, "GetIntegerv");
-+         params[0] = ctx->VertexProgram.CurrentPosition;
-+         break;
-+      case GL_MAX_DRAW_BUFFERS_ARB:
-+         CHECK_EXT1(ARB_draw_buffers, "GetIntegerv");
-+         params[0] = ctx->Const.MaxDrawBuffers;
-+         break;
-+      case GL_DRAW_BUFFER0_ARB:
-+         CHECK_EXT1(ARB_draw_buffers, "GetIntegerv");
-+         params[0] = ENUM_TO_INT(ctx->DrawBuffer->ColorDrawBuffer[0]);
-+         break;
-+      case GL_DRAW_BUFFER1_ARB:
-+         CHECK_EXT1(ARB_draw_buffers, "GetIntegerv");
-+         {
-+         GLenum buffer;
-+         if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-+            _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
-+            return;
-+         }
-+         buffer = ctx->DrawBuffer->ColorDrawBuffer[1];
-+         params[0] = ENUM_TO_INT(buffer);
-+         }
-+         break;
-+      case GL_DRAW_BUFFER2_ARB:
-+         CHECK_EXT1(ARB_draw_buffers, "GetIntegerv");
-+         {
-+         GLenum buffer;
-+         if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-+            _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
-+            return;
-+         }
-+         buffer = ctx->DrawBuffer->ColorDrawBuffer[2];
-+         params[0] = ENUM_TO_INT(buffer);
-+         }
-+         break;
-+      case GL_DRAW_BUFFER3_ARB:
-+         CHECK_EXT1(ARB_draw_buffers, "GetIntegerv");
-+         {
-+         GLenum buffer;
-+         if (pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-+            _mesa_error(ctx, GL_INVALID_ENUM, "glGet(GL_DRAW_BUFFERx_ARB)");
-+            return;
-+         }
-+         buffer = ctx->DrawBuffer->ColorDrawBuffer[3];
-+         params[0] = ENUM_TO_INT(buffer);
-+         }
-+         break;
-+      case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
-+         CHECK_EXT1(OES_read_format, "GetIntegerv");
-+         params[0] = ctx->Const.ColorReadType;
-+         break;
-+      case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
-+         CHECK_EXT1(OES_read_format, "GetIntegerv");
-+         params[0] = ctx->Const.ColorReadFormat;
-+         break;
-+      case GL_NUM_FRAGMENT_REGISTERS_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetIntegerv");
-+         params[0] = 6;
-+         break;
-+      case GL_NUM_FRAGMENT_CONSTANTS_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetIntegerv");
-+         params[0] = 8;
-+         break;
-+      case GL_NUM_PASSES_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetIntegerv");
-+         params[0] = 2;
-+         break;
-+      case GL_NUM_INSTRUCTIONS_PER_PASS_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetIntegerv");
-+         params[0] = 8;
-+         break;
-+      case GL_NUM_INSTRUCTIONS_TOTAL_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetIntegerv");
-+         params[0] = 16;
-+         break;
-+      case GL_COLOR_ALPHA_PAIRING_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetIntegerv");
-+         params[0] = BOOLEAN_TO_INT(GL_TRUE);
-+         break;
-+      case GL_NUM_LOOPBACK_COMPONENTS_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetIntegerv");
-+         params[0] = 3;
-+         break;
-+      case GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI:
-+         CHECK_EXT1(ATI_fragment_shader, "GetIntegerv");
-+         params[0] = 3;
-+         break;
-+      case GL_STENCIL_BACK_FUNC:
-+         params[0] = ENUM_TO_INT(ctx->Stencil.Function[1]);
-+         break;
-+      case GL_STENCIL_BACK_VALUE_MASK:
-+         params[0] = ctx->Stencil.ValueMask[1];
-+         break;
-+      case GL_STENCIL_BACK_REF:
-+         params[0] = ctx->Stencil.Ref[1];
-+         break;
-+      case GL_STENCIL_BACK_FAIL:
-+         params[0] = ENUM_TO_INT(ctx->Stencil.FailFunc[1]);
-+         break;
-+      case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
-+         params[0] = ENUM_TO_INT(ctx->Stencil.ZFailFunc[1]);
-+         break;
-+      case GL_STENCIL_BACK_PASS_DEPTH_PASS:
-+         params[0] = ENUM_TO_INT(ctx->Stencil.ZPassFunc[1]);
-+         break;
-+      case GL_FRAMEBUFFER_BINDING_EXT:
-+         CHECK_EXT1(EXT_framebuffer_object, "GetIntegerv");
-+         params[0] = ctx->DrawBuffer->Name;
-+         break;
-+      case GL_RENDERBUFFER_BINDING_EXT:
-+         CHECK_EXT1(EXT_framebuffer_object, "GetIntegerv");
-+         params[0] = ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0;
-+         break;
-+      case GL_MAX_COLOR_ATTACHMENTS_EXT:
-+         CHECK_EXT1(EXT_framebuffer_object, "GetIntegerv");
-+         params[0] = ctx->Const.MaxColorAttachments;
-+         break;
-+      case GL_MAX_RENDERBUFFER_SIZE_EXT:
-+         CHECK_EXT1(EXT_framebuffer_object, "GetIntegerv");
-+         params[0] = ctx->Const.MaxRenderbufferSize;
-+         break;
-+      case GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB:
-+         CHECK_EXT1(ARB_fragment_shader, "GetIntegerv");
-+         params[0] = MAX_FRAGMENT_UNIFORM_COMPONENTS;
-+         break;
-+      case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB:
-+         CHECK_EXT1(ARB_fragment_shader, "GetIntegerv");
-+         params[0] = ENUM_TO_INT(ctx->Hint.FragmentShaderDerivative);
-+         break;
-+      case GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB:
-+         CHECK_EXT1(ARB_vertex_shader, "GetIntegerv");
-+         params[0] = MAX_VERTEX_UNIFORM_COMPONENTS;
-+         break;
-+      case GL_MAX_VARYING_FLOATS_ARB:
-+         CHECK_EXT1(ARB_vertex_shader, "GetIntegerv");
-+         params[0] = MAX_VARYING_FLOATS;
-+         break;
-+      case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB:
-+         CHECK_EXT1(ARB_vertex_shader, "GetIntegerv");
-+         params[0] = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
-+         break;
-+      case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB:
-+         CHECK_EXT1(ARB_vertex_shader, "GetIntegerv");
-+         params[0] = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
-+         break;
-+      default:
-+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetIntegerv(pname=0x%x)", pname);
-+   }
-+}
-+
-+
-+void GLAPIENTRY
-+_mesa_GetDoublev( GLenum pname, GLdouble *params )
-+{
-+   const GLfloat magic = -1234.5F;
-+   GLfloat values[16];
-+   GLuint i;
-+
-+   if (!params)
-+      return;
-+
-+   /* Init temp array to magic numbers so we can figure out how many values
-+    * are returned by the GetFloatv() call.
-+    */
-+   for (i = 0; i < 16; i++)
-+      values[i] = magic;
-+
-+   _mesa_GetFloatv(pname, values);
-+
-+   for (i = 0; i < 16 && values[i] != magic; i++)
-+      params[i] = (GLdouble) values[i];
-+}
-+
-Index: qemu-0.14.0/target-i386/mesa_gl.h
-===================================================================
---- /dev/null
-+++ qemu-0.14.0/target-i386/mesa_gl.h
-@@ -0,0 +1,2251 @@
-+/*
-+ * Mesa 3-D graphics library
-+ * Version:  6.5.1
-+ *
-+ * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
-+ *
-+ * Permission is hereby granted, free of charge, to any person obtaining a
-+ * copy of this software and associated documentation files (the "Software"),
-+ * to deal in the Software without restriction, including without limitation
-+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
-+ * and/or sell copies of the Software, and to permit persons to whom the
-+ * Software is furnished to do so, subject to the following conditions:
-+ *
-+ * The above copyright notice and this permission notice shall be included
-+ * in all copies or substantial portions of the Software.
-+ *
-+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
-+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
-+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-+ */
-+
-+
-+#ifndef __gl_h_
-+#define __gl_h_
-+
-+#if defined(USE_MGL_NAMESPACE)
-+#include "gl_mangle.h"
-+#endif
-+
-+
-+/**********************************************************************
-+ * Begin system-specific stuff. Do not do any of this when building
-+ * for SciTech SNAP, as this is all done before this header file is
-+ * included.
-+ */
-+#if !defined(__SCITECH_SNAP__)
-+
-+#if defined(__BEOS__)
-+#include <stdlib.h>     /* to get some BeOS-isms */
-+#endif
-+
-+#if !defined(OPENSTEP) && (defined(NeXT) || defined(NeXT_PDO))
-+#define OPENSTEP
-+#endif
-+
-+#if defined(_WIN32) && !defined(__WIN32__) && !defined(__CYGWIN__)
-+#define __WIN32__
-+#endif
-+
-+#if !defined(OPENSTEP) && (defined(__WIN32__) && !defined(__CYGWIN__))
-+#  if (defined(_MSC_VER) || defined(__MINGW32__)) && defined(BUILD_GL32) /* tag specify we're building mesa as a DLL */
-+#    define GLAPI __declspec(dllexport)
-+#  elif (defined(_MSC_VER) || defined(__MINGW32__)) && defined(_DLL) /* tag specifying we're building for DLL runtime support */
-+#    define GLAPI __declspec(dllimport)
-+#  else /* for use with static link lib build of Win32 edition only */
-+#    define GLAPI extern
-+#  endif /* _STATIC_MESA support */
-+#  define GLAPIENTRY __stdcall
-+#elif defined(__CYGWIN__) && defined(USE_OPENGL32) /* use native windows opengl32 */
-+#  define GLAPI extern
-+#  define GLAPIENTRY __stdcall
-+#elif defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 303
-+#  define GLAPI __attribute__((visibility("default")))
-+#  define GLAPIENTRY
-+#endif /* WIN32 && !CYGWIN */
-+
-+#if (defined(__BEOS__) && defined(__POWERPC__)) || defined(__QUICKDRAW__)
-+#  define PRAGMA_EXPORT_SUPPORTED		1
-+#endif
-+
-+/*
-+ * WINDOWS: Include windows.h here to define APIENTRY.
-+ * It is also useful when applications include this file by
-+ * including only glut.h, since glut.h depends on windows.h.
-+ * Applications needing to include windows.h with parms other
-+ * than "WIN32_LEAN_AND_MEAN" may include windows.h before
-+ * glut.h or gl.h.
-+ */
-+#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
-+#define WIN32_LEAN_AND_MEAN 1
-+#include <windows.h>
-+#endif
-+
-+#if defined(_WIN32) && !defined(_WINGDI_) && !defined(_GNU_H_WINDOWS32_DEFINES) && !defined(OPENSTEP) && !defined(__CYGWIN__)
-+#include <GL/mesa_wgl.h>
-+#endif
-+
-+#if defined(macintosh) && PRAGMA_IMPORT_SUPPORTED
-+#pragma import on
-+#endif
-+
-+#ifndef GLAPI
-+#define GLAPI extern
-+#endif
-+
-+#ifndef GLAPIENTRY
-+#define GLAPIENTRY
-+#endif
-+
-+#ifndef APIENTRY
-+#define APIENTRY GLAPIENTRY
-+#endif
-+
-+/* "P" suffix to be used for a pointer to a function */
-+#ifndef APIENTRYP
-+#define APIENTRYP APIENTRY *
-+#endif
-+
-+#ifndef GLAPIENTRYP
-+#define GLAPIENTRYP GLAPIENTRY *
-+#endif
-+
-+#ifdef CENTERLINE_CLPP
-+#define signed
-+#endif
-+
-+#if defined(PRAGMA_EXPORT_SUPPORTED)
-+#pragma export on
-+#endif
-+
-+#endif /* !__SCITECH_SNAP__ */
-+/*
-+ * End system-specific stuff.
-+ **********************************************************************/
-+
-+
-+
-+#ifdef __cplusplus
-+extern "C" {
-+#endif
-+
-+
-+
-+#define GL_VERSION_1_1   1
-+#define GL_VERSION_1_2   1
-+#define GL_VERSION_1_3   1
-+#define GL_ARB_imaging   1
-+
-+
-+/*
-+ * Datatypes
-+ */
-+typedef unsigned int	GLenum;
-+typedef unsigned char	GLboolean;
-+typedef unsigned int	GLbitfield;
-+typedef void		GLvoid;
-+typedef signed char	GLbyte;		/* 1-byte signed */
-+typedef short		GLshort;	/* 2-byte signed */
-+typedef int		GLint;		/* 4-byte signed */
-+typedef unsigned char	GLubyte;	/* 1-byte unsigned */
-+typedef unsigned short	GLushort;	/* 2-byte unsigned */
-+typedef unsigned int	GLuint;		/* 4-byte unsigned */
-+typedef int		GLsizei;	/* 4-byte signed */
-+typedef float		GLfloat;	/* single precision float */
-+typedef float		GLclampf;	/* single precision float in [0,1] */
-+typedef double		GLdouble;	/* double precision float */
-+typedef double		GLclampd;	/* double precision float in [0,1] */
-+
-+
-+
-+/*
-+ * Constants
-+ */
-+
-+/* Boolean values */
-+#define GL_FALSE				0x0
-+#define GL_TRUE					0x1
-+
-+/* Data types */
-+#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
-+
-+/* Primitives */
-+#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
-+
-+/* Vertex Arrays */
-+#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
-+
-+/* Matrix Mode */
-+#define GL_MATRIX_MODE				0x0BA0
-+#define GL_MODELVIEW				0x1700
-+#define GL_PROJECTION				0x1701
-+#define GL_TEXTURE				0x1702
-+
-+/* Points */
-+#define GL_POINT_SMOOTH				0x0B10
-+#define GL_POINT_SIZE				0x0B11
-+#define GL_POINT_SIZE_GRANULARITY 		0x0B13
-+#define GL_POINT_SIZE_RANGE			0x0B12
-+
-+/* Lines */
-+#define GL_LINE_SMOOTH				0x0B20
-+#define GL_LINE_STIPPLE				0x0B24
-+#define GL_LINE_STIPPLE_PATTERN			0x0B25
-+#define GL_LINE_STIPPLE_REPEAT			0x0B26
-+#define GL_LINE_WIDTH				0x0B21
-+#define GL_LINE_WIDTH_GRANULARITY		0x0B23
-+#define GL_LINE_WIDTH_RANGE			0x0B22
-+
-+/* Polygons */
-+#define GL_POINT				0x1B00
-+#define GL_LINE					0x1B01
-+#define GL_FILL					0x1B02
-+#define GL_CW					0x0900
-+#define GL_CCW					0x0901
-+#define GL_FRONT				0x0404
-+#define GL_BACK					0x0405
-+#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_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
-+
-+/* Display Lists */
-+#define GL_COMPILE				0x1300
-+#define GL_COMPILE_AND_EXECUTE			0x1301
-+#define GL_LIST_BASE				0x0B32
-+#define GL_LIST_INDEX				0x0B33
-+#define GL_LIST_MODE				0x0B30
-+
-+/* Depth buffer */
-+#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_DEPTH_TEST				0x0B71
-+#define GL_DEPTH_BITS				0x0D56
-+#define GL_DEPTH_CLEAR_VALUE			0x0B73
-+#define GL_DEPTH_FUNC				0x0B74
-+#define GL_DEPTH_RANGE				0x0B70
-+#define GL_DEPTH_WRITEMASK			0x0B72
-+#define GL_DEPTH_COMPONENT			0x1902
-+
-+/* Lighting */
-+#define GL_LIGHTING				0x0B50
-+#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_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_AMBIENT				0x1200
-+#define GL_DIFFUSE				0x1201
-+#define GL_SPECULAR				0x1202
-+#define GL_SHININESS				0x1601
-+#define GL_EMISSION				0x1600
-+#define GL_POSITION				0x1203
-+#define GL_SPOT_DIRECTION			0x1204
-+#define GL_AMBIENT_AND_DIFFUSE			0x1602
-+#define GL_COLOR_INDEXES			0x1603
-+#define GL_LIGHT_MODEL_TWO_SIDE			0x0B52
-+#define GL_LIGHT_MODEL_LOCAL_VIEWER		0x0B51
-+#define GL_LIGHT_MODEL_AMBIENT			0x0B53
-+#define GL_FRONT_AND_BACK			0x0408
-+#define GL_SHADE_MODEL				0x0B54
-+#define GL_FLAT					0x1D00
-+#define GL_SMOOTH				0x1D01
-+#define GL_COLOR_MATERIAL			0x0B57
-+#define GL_COLOR_MATERIAL_FACE			0x0B55
-+#define GL_COLOR_MATERIAL_PARAMETER		0x0B56
-+#define GL_NORMALIZE				0x0BA1
-+
-+/* User clipping planes */
-+#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
-+
-+/* Accumulation buffer */
-+#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_ACCUM_CLEAR_VALUE			0x0B80
-+#define GL_ACCUM				0x0100
-+#define GL_ADD					0x0104
-+#define GL_LOAD					0x0101
-+#define GL_MULT					0x0103
-+#define GL_RETURN				0x0102
-+
-+/* Alpha testing */
-+#define GL_ALPHA_TEST				0x0BC0
-+#define GL_ALPHA_TEST_REF			0x0BC2
-+#define GL_ALPHA_TEST_FUNC			0x0BC1
-+
-+/* Blending */
-+#define GL_BLEND				0x0BE2
-+#define GL_BLEND_SRC				0x0BE1
-+#define GL_BLEND_DST				0x0BE0
-+#define GL_ZERO					0x0
-+#define GL_ONE					0x1
-+#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
-+
-+/* Render Mode */
-+#define GL_FEEDBACK				0x1C01
-+#define GL_RENDER				0x1C00
-+#define GL_SELECT				0x1C02
-+
-+/* Feedback */
-+#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_POINT_TOKEN				0x0701
-+#define GL_LINE_TOKEN				0x0702
-+#define GL_LINE_RESET_TOKEN			0x0707
-+#define GL_POLYGON_TOKEN			0x0703
-+#define GL_BITMAP_TOKEN				0x0704
-+#define GL_DRAW_PIXEL_TOKEN			0x0705
-+#define GL_COPY_PIXEL_TOKEN			0x0706
-+#define GL_PASS_THROUGH_TOKEN			0x0700
-+#define GL_FEEDBACK_BUFFER_POINTER		0x0DF0
-+#define GL_FEEDBACK_BUFFER_SIZE			0x0DF1
-+#define GL_FEEDBACK_BUFFER_TYPE			0x0DF2
-+
-+/* Selection */
-+#define GL_SELECTION_BUFFER_POINTER		0x0DF3
-+#define GL_SELECTION_BUFFER_SIZE		0x0DF4
-+
-+/* Fog */
-+#define GL_FOG					0x0B60
-+#define GL_FOG_MODE				0x0B65
-+#define GL_FOG_DENSITY				0x0B62
-+#define GL_FOG_COLOR				0x0B66
-+#define GL_FOG_INDEX				0x0B61
-+#define GL_FOG_START				0x0B63
-+#define GL_FOG_END				0x0B64
-+#define GL_LINEAR				0x2601
-+#define GL_EXP					0x0800
-+#define GL_EXP2					0x0801
-+
-+/* Logic Ops */
-+#define GL_LOGIC_OP				0x0BF1
-+#define GL_INDEX_LOGIC_OP			0x0BF1
-+#define GL_COLOR_LOGIC_OP			0x0BF2
-+#define GL_LOGIC_OP_MODE			0x0BF0
-+#define GL_CLEAR				0x1500
-+#define GL_SET					0x150F
-+#define GL_COPY					0x1503
-+#define GL_COPY_INVERTED			0x150C
-+#define GL_NOOP					0x1505
-+#define GL_INVERT				0x150A
-+#define GL_AND					0x1501
-+#define GL_NAND					0x150E
-+#define GL_OR					0x1507
-+#define GL_NOR					0x1508
-+#define GL_XOR					0x1506
-+#define GL_EQUIV				0x1509
-+#define GL_AND_REVERSE				0x1502
-+#define GL_AND_INVERTED				0x1504
-+#define GL_OR_REVERSE				0x150B
-+#define GL_OR_INVERTED				0x150D
-+
-+/* Stencil */
-+#define GL_STENCIL_BITS				0x0D57
-+#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_STENCIL_INDEX			0x1901
-+#define GL_KEEP					0x1E00
-+#define GL_REPLACE				0x1E01
-+#define GL_INCR					0x1E02
-+#define GL_DECR					0x1E03
-+
-+/* Buffers, Pixel Drawing/Reading */
-+#define GL_NONE					0x0
-+#define GL_LEFT					0x0406
-+#define GL_RIGHT				0x0407
-+/*GL_FRONT					0x0404 */
-+/*GL_BACK					0x0405 */
-+/*GL_FRONT_AND_BACK				0x0408 */
-+#define GL_FRONT_LEFT				0x0400
-+#define GL_FRONT_RIGHT				0x0401
-+#define GL_BACK_LEFT				0x0402
-+#define GL_BACK_RIGHT				0x0403
-+#define GL_AUX0					0x0409
-+#define GL_AUX1					0x040A
-+#define GL_AUX2					0x040B
-+#define GL_AUX3					0x040C
-+#define GL_COLOR_INDEX				0x1900
-+#define GL_RED					0x1903
-+#define GL_GREEN				0x1904
-+#define GL_BLUE					0x1905
-+#define GL_ALPHA				0x1906
-+#define GL_LUMINANCE				0x1909
-+#define GL_LUMINANCE_ALPHA			0x190A
-+#define GL_ALPHA_BITS				0x0D55
-+#define GL_RED_BITS				0x0D52
-+#define GL_GREEN_BITS				0x0D53
-+#define GL_BLUE_BITS				0x0D54
-+#define GL_INDEX_BITS				0x0D51
-+#define GL_SUBPIXEL_BITS			0x0D50
-+#define GL_AUX_BUFFERS				0x0C00
-+#define GL_READ_BUFFER				0x0C02
-+#define GL_DRAW_BUFFER				0x0C01
-+#define GL_DOUBLEBUFFER				0x0C32
-+#define GL_STEREO				0x0C33
-+#define GL_BITMAP				0x1A00
-+#define GL_COLOR				0x1800
-+#define GL_DEPTH				0x1801
-+#define GL_STENCIL				0x1802
-+#define GL_DITHER				0x0BD0
-+#define GL_RGB					0x1907
-+#define GL_RGBA					0x1908
-+
-+/* Implementation limits */
-+#define GL_MAX_LIST_NESTING			0x0B31
-+#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
-+
-+/* Gets */
-+#define GL_ATTRIB_STACK_DEPTH			0x0BB0
-+#define GL_CLIENT_ATTRIB_STACK_DEPTH		0x0BB1
-+#define GL_COLOR_CLEAR_VALUE			0x0C22
-+#define GL_COLOR_WRITEMASK			0x0C23
-+#define GL_CURRENT_INDEX			0x0B01
-+#define GL_CURRENT_COLOR			0x0B00
-+#define GL_CURRENT_NORMAL			0x0B02
-+#define GL_CURRENT_RASTER_COLOR			0x0B04
-+#define GL_CURRENT_RASTER_DISTANCE		0x0B09
-+#define GL_CURRENT_RASTER_INDEX			0x0B05
-+#define GL_CURRENT_RASTER_POSITION		0x0B07
-+#define GL_CURRENT_RASTER_TEXTURE_COORDS	0x0B06
-+#define GL_CURRENT_RASTER_POSITION_VALID	0x0B08
-+#define GL_CURRENT_TEXTURE_COORDS		0x0B03
-+#define GL_INDEX_CLEAR_VALUE			0x0C20
-+#define GL_INDEX_MODE				0x0C30
-+#define GL_INDEX_WRITEMASK			0x0C21
-+#define GL_MODELVIEW_MATRIX			0x0BA6
-+#define GL_MODELVIEW_STACK_DEPTH		0x0BA3
-+#define GL_NAME_STACK_DEPTH			0x0D70
-+#define GL_PROJECTION_MATRIX			0x0BA7
-+#define GL_PROJECTION_STACK_DEPTH		0x0BA4
-+#define GL_RENDER_MODE				0x0C40
-+#define GL_RGBA_MODE				0x0C31
-+#define GL_TEXTURE_MATRIX			0x0BA8
-+#define GL_TEXTURE_STACK_DEPTH			0x0BA5
-+#define GL_VIEWPORT				0x0BA2
-+
-+/* Evaluators */
-+#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_COEFF				0x0A00
-+#define GL_ORDER				0x0A01
-+#define GL_DOMAIN				0x0A02
-+
-+/* Hints */
-+#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_DONT_CARE				0x1100
-+#define GL_FASTEST				0x1101
-+#define GL_NICEST				0x1102
-+
-+/* Scissor box */
-+#define GL_SCISSOR_BOX				0x0C10
-+#define GL_SCISSOR_TEST				0x0C11
-+
-+/* Pixel Mode / Transfer */
-+#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_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_PIXEL_MAP_S_TO_S_SIZE		0x0CB1
-+#define GL_PIXEL_MAP_I_TO_I_SIZE		0x0CB0
-+#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_PIXEL_MAP_S_TO_S			0x0C71
-+#define GL_PIXEL_MAP_I_TO_I			0x0C70
-+#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_PACK_ALIGNMENT			0x0D05
-+#define GL_PACK_LSB_FIRST			0x0D01
-+#define GL_PACK_ROW_LENGTH			0x0D02
-+#define GL_PACK_SKIP_PIXELS			0x0D04
-+#define GL_PACK_SKIP_ROWS			0x0D03
-+#define GL_PACK_SWAP_BYTES			0x0D00
-+#define GL_UNPACK_ALIGNMENT			0x0CF5
-+#define GL_UNPACK_LSB_FIRST			0x0CF1
-+#define GL_UNPACK_ROW_LENGTH			0x0CF2
-+#define GL_UNPACK_SKIP_PIXELS			0x0CF4
-+#define GL_UNPACK_SKIP_ROWS			0x0CF3
-+#define GL_UNPACK_SWAP_BYTES			0x0CF0
-+#define GL_ZOOM_X				0x0D16
-+#define GL_ZOOM_Y				0x0D17
-+
-+/* Texture mapping */
-+#define GL_TEXTURE_ENV				0x2300
-+#define GL_TEXTURE_ENV_MODE			0x2200
-+#define GL_TEXTURE_1D				0x0DE0
-+#define GL_TEXTURE_2D				0x0DE1
-+#define GL_TEXTURE_WRAP_S			0x2802
-+#define GL_TEXTURE_WRAP_T			0x2803
-+#define GL_TEXTURE_MAG_FILTER			0x2800
-+#define GL_TEXTURE_MIN_FILTER			0x2801
-+#define GL_TEXTURE_ENV_COLOR			0x2201
-+#define GL_TEXTURE_GEN_S			0x0C60
-+#define GL_TEXTURE_GEN_T			0x0C61
-+#define GL_TEXTURE_GEN_MODE			0x2500
-+#define GL_TEXTURE_BORDER_COLOR			0x1004
-+#define GL_TEXTURE_WIDTH			0x1000
-+#define GL_TEXTURE_HEIGHT			0x1001
-+#define GL_TEXTURE_BORDER			0x1005
-+#define GL_TEXTURE_COMPONENTS			0x1003
-+#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_NEAREST_MIPMAP_NEAREST		0x2700
-+#define GL_NEAREST_MIPMAP_LINEAR		0x2702
-+#define GL_LINEAR_MIPMAP_NEAREST		0x2701
-+#define GL_LINEAR_MIPMAP_LINEAR			0x2703
-+#define GL_OBJECT_LINEAR			0x2401
-+#define GL_OBJECT_PLANE				0x2501
-+#define GL_EYE_LINEAR				0x2400
-+#define GL_EYE_PLANE				0x2502
-+#define GL_SPHERE_MAP				0x2402
-+#define GL_DECAL				0x2101
-+#define GL_MODULATE				0x2100
-+#define GL_NEAREST				0x2600
-+#define GL_REPEAT				0x2901
-+#define GL_CLAMP				0x2900
-+#define GL_S					0x2000
-+#define GL_T					0x2001
-+#define GL_R					0x2002
-+#define GL_Q					0x2003
-+#define GL_TEXTURE_GEN_R			0x0C62
-+#define GL_TEXTURE_GEN_Q			0x0C63
-+
-+/* Utility */
-+#define GL_VENDOR				0x1F00
-+#define GL_RENDERER				0x1F01
-+#define GL_VERSION				0x1F02
-+#define GL_EXTENSIONS				0x1F03
-+
-+/* Errors */
-+#define GL_NO_ERROR 				0x0
-+#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
-+
-+/* glPush/PopAttrib bits */
-+#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
-+
-+
-+/* OpenGL 1.1 */
-+#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_TEXTURE_INTERNAL_FORMAT		0x1003
-+#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_CLIENT_PIXEL_STORE_BIT		0x00000001
-+#define GL_CLIENT_VERTEX_ARRAY_BIT		0x00000002
-+#define GL_ALL_CLIENT_ATTRIB_BITS 		0xFFFFFFFF
-+#define GL_CLIENT_ALL_ATTRIB_BITS 		0xFFFFFFFF
-+
-+
-+
-+/*
-+ * Miscellaneous
-+ */
-+
-+GLAPI void GLAPIENTRY glClearIndex( GLfloat c );
-+
-+GLAPI void GLAPIENTRY glClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha );
-+
-+GLAPI void GLAPIENTRY glClear( GLbitfield mask );
-+
-+GLAPI void GLAPIENTRY glIndexMask( GLuint mask );
-+
-+GLAPI void GLAPIENTRY glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha );
-+
-+GLAPI void GLAPIENTRY glAlphaFunc( GLenum func, GLclampf ref );
-+
-+GLAPI void GLAPIENTRY glBlendFunc( GLenum sfactor, GLenum dfactor );
-+
-+GLAPI void GLAPIENTRY glLogicOp( GLenum opcode );
-+
-+GLAPI void GLAPIENTRY glCullFace( GLenum mode );
-+
-+GLAPI void GLAPIENTRY glFrontFace( GLenum mode );
-+
-+GLAPI void GLAPIENTRY glPointSize( GLfloat size );
-+
-+GLAPI void GLAPIENTRY glLineWidth( GLfloat width );
-+
-+GLAPI void GLAPIENTRY glLineStipple( GLint factor, GLushort pattern );
-+
-+GLAPI void GLAPIENTRY glPolygonMode( GLenum face, GLenum mode );
-+
-+GLAPI void GLAPIENTRY glPolygonOffset( GLfloat factor, GLfloat units );
-+
-+GLAPI void GLAPIENTRY glPolygonStipple( const GLubyte *mask );
-+
-+GLAPI void GLAPIENTRY glGetPolygonStipple( GLubyte *mask );
-+
-+GLAPI void GLAPIENTRY glEdgeFlag( GLboolean flag );
-+
-+GLAPI void GLAPIENTRY glEdgeFlagv( const GLboolean *flag );
-+
-+GLAPI void GLAPIENTRY glScissor( GLint x, GLint y, GLsizei width, GLsizei height);
-+
-+GLAPI void GLAPIENTRY glClipPlane( GLenum plane, const GLdouble *equation );
-+
-+GLAPI void GLAPIENTRY glGetClipPlane( GLenum plane, GLdouble *equation );
-+
-+GLAPI void GLAPIENTRY glDrawBuffer( GLenum mode );
-+
-+GLAPI void GLAPIENTRY glReadBuffer( GLenum mode );
-+
-+GLAPI void GLAPIENTRY glEnable( GLenum cap );
-+
-+GLAPI void GLAPIENTRY glDisable( GLenum cap );
-+
-+GLAPI GLboolean GLAPIENTRY glIsEnabled( GLenum cap );
-+
-+
-+GLAPI void GLAPIENTRY glEnableClientState( GLenum cap );  /* 1.1 */
-+
-+GLAPI void GLAPIENTRY glDisableClientState( GLenum cap );  /* 1.1 */
-+
-+
-+GLAPI void GLAPIENTRY glGetBooleanv( GLenum pname, GLboolean *params );
-+
-+GLAPI void GLAPIENTRY glGetDoublev( GLenum pname, GLdouble *params );
-+
-+GLAPI void GLAPIENTRY glGetFloatv( GLenum pname, GLfloat *params );
-+
-+GLAPI void GLAPIENTRY glGetIntegerv( GLenum pname, GLint *params );
-+
-+
-+GLAPI void GLAPIENTRY glPushAttrib( GLbitfield mask );
-+
-+GLAPI void GLAPIENTRY glPopAttrib( void );
-+
-+
-+GLAPI void GLAPIENTRY glPushClientAttrib( GLbitfield mask );  /* 1.1 */
-+
-+GLAPI void GLAPIENTRY glPopClientAttrib( void );  /* 1.1 */
-+
-+
-+GLAPI GLint GLAPIENTRY glRenderMode( GLenum mode );
-+
-+GLAPI GLenum GLAPIENTRY glGetError( void );
-+
-+GLAPI const GLubyte * GLAPIENTRY glGetString( GLenum name );
-+
-+GLAPI void GLAPIENTRY glFinish( void );
-+
-+GLAPI void GLAPIENTRY glFlush( void );
-+
-+GLAPI void GLAPIENTRY glHint( GLenum target, GLenum mode );
-+
-+
-+/*
-+ * Depth Buffer
-+ */
-+
-+GLAPI void GLAPIENTRY glClearDepth( GLclampd depth );
-+
-+GLAPI void GLAPIENTRY glDepthFunc( GLenum func );
-+
-+GLAPI void GLAPIENTRY glDepthMask( GLboolean flag );
-+
-+GLAPI void GLAPIENTRY glDepthRange( GLclampd near_val, GLclampd far_val );
-+
-+
-+/*
-+ * Accumulation Buffer
-+ */
-+
-+GLAPI void GLAPIENTRY glClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha );
-+
-+GLAPI void GLAPIENTRY glAccum( GLenum op, GLfloat value );
-+
-+
-+/*
-+ * Transformation
-+ */
-+
-+GLAPI void GLAPIENTRY glMatrixMode( GLenum mode );
-+
-+GLAPI void GLAPIENTRY glOrtho( GLdouble left, GLdouble right,
-+                                 GLdouble bottom, GLdouble top,
-+                                 GLdouble near_val, GLdouble far_val );
-+
-+GLAPI void GLAPIENTRY glFrustum( GLdouble left, GLdouble right,
-+                                   GLdouble bottom, GLdouble top,
-+                                   GLdouble near_val, GLdouble far_val );
-+
-+GLAPI void GLAPIENTRY glViewport( GLint x, GLint y,
-+                                    GLsizei width, GLsizei height );
-+
-+GLAPI void GLAPIENTRY glPushMatrix( void );
-+
-+GLAPI void GLAPIENTRY glPopMatrix( void );
-+
-+GLAPI void GLAPIENTRY glLoadIdentity( void );
-+
-+GLAPI void GLAPIENTRY glLoadMatrixd( const GLdouble *m );
-+GLAPI void GLAPIENTRY glLoadMatrixf( const GLfloat *m );
-+
-+GLAPI void GLAPIENTRY glMultMatrixd( const GLdouble *m );
-+GLAPI void GLAPIENTRY glMultMatrixf( const GLfloat *m );
-+
-+GLAPI void GLAPIENTRY glRotated( GLdouble angle,
-+                                   GLdouble x, GLdouble y, GLdouble z );
-+GLAPI void GLAPIENTRY glRotatef( GLfloat angle,
-+                                   GLfloat x, GLfloat y, GLfloat z );
-+
-+GLAPI void GLAPIENTRY glScaled( GLdouble x, GLdouble y, GLdouble z );
-+GLAPI void GLAPIENTRY glScalef( GLfloat x, GLfloat y, GLfloat z );
-+
-+GLAPI void GLAPIENTRY glTranslated( GLdouble x, GLdouble y, GLdouble z );
-+GLAPI void GLAPIENTRY glTranslatef( GLfloat x, GLfloat y, GLfloat z );
-+
-+
-+/*
-+ * Display Lists
-+ */
-+
-+GLAPI GLboolean GLAPIENTRY glIsList( GLuint list );
-+
-+GLAPI void GLAPIENTRY glDeleteLists( GLuint list, GLsizei range );
-+
-+GLAPI GLuint GLAPIENTRY glGenLists( GLsizei range );
-+
-+GLAPI void GLAPIENTRY glNewList( GLuint list, GLenum mode );
-+
-+GLAPI void GLAPIENTRY glEndList( void );
-+
-+GLAPI void GLAPIENTRY glCallList( GLuint list );
-+
-+GLAPI void GLAPIENTRY glCallLists( GLsizei n, GLenum type,
-+                                     const GLvoid *lists );
-+
-+GLAPI void GLAPIENTRY glListBase( GLuint base );
-+
-+
-+/*
-+ * Drawing Functions
-+ */
-+
-+GLAPI void GLAPIENTRY glBegin( GLenum mode );
-+
-+GLAPI void GLAPIENTRY glEnd( void );
-+
-+
-+GLAPI void GLAPIENTRY glVertex2d( GLdouble x, GLdouble y );
-+GLAPI void GLAPIENTRY glVertex2f( GLfloat x, GLfloat y );
-+GLAPI void GLAPIENTRY glVertex2i( GLint x, GLint y );
-+GLAPI void GLAPIENTRY glVertex2s( GLshort x, GLshort y );
-+
-+GLAPI void GLAPIENTRY glVertex3d( GLdouble x, GLdouble y, GLdouble z );
-+GLAPI void GLAPIENTRY glVertex3f( GLfloat x, GLfloat y, GLfloat z );
-+GLAPI void GLAPIENTRY glVertex3i( GLint x, GLint y, GLint z );
-+GLAPI void GLAPIENTRY glVertex3s( GLshort x, GLshort y, GLshort z );
-+
-+GLAPI void GLAPIENTRY glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w );
-+GLAPI void GLAPIENTRY glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w );
-+GLAPI void GLAPIENTRY glVertex4i( GLint x, GLint y, GLint z, GLint w );
-+GLAPI void GLAPIENTRY glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w );
-+
-+GLAPI void GLAPIENTRY glVertex2dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glVertex2fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glVertex2iv( const GLint *v );
-+GLAPI void GLAPIENTRY glVertex2sv( const GLshort *v );
-+
-+GLAPI void GLAPIENTRY glVertex3dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glVertex3fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glVertex3iv( const GLint *v );
-+GLAPI void GLAPIENTRY glVertex3sv( const GLshort *v );
-+
-+GLAPI void GLAPIENTRY glVertex4dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glVertex4fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glVertex4iv( const GLint *v );
-+GLAPI void GLAPIENTRY glVertex4sv( const GLshort *v );
-+
-+
-+GLAPI void GLAPIENTRY glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz );
-+GLAPI void GLAPIENTRY glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz );
-+GLAPI void GLAPIENTRY glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz );
-+GLAPI void GLAPIENTRY glNormal3i( GLint nx, GLint ny, GLint nz );
-+GLAPI void GLAPIENTRY glNormal3s( GLshort nx, GLshort ny, GLshort nz );
-+
-+GLAPI void GLAPIENTRY glNormal3bv( const GLbyte *v );
-+GLAPI void GLAPIENTRY glNormal3dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glNormal3fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glNormal3iv( const GLint *v );
-+GLAPI void GLAPIENTRY glNormal3sv( const GLshort *v );
-+
-+
-+GLAPI void GLAPIENTRY glIndexd( GLdouble c );
-+GLAPI void GLAPIENTRY glIndexf( GLfloat c );
-+GLAPI void GLAPIENTRY glIndexi( GLint c );
-+GLAPI void GLAPIENTRY glIndexs( GLshort c );
-+GLAPI void GLAPIENTRY glIndexub( GLubyte c );  /* 1.1 */
-+
-+GLAPI void GLAPIENTRY glIndexdv( const GLdouble *c );
-+GLAPI void GLAPIENTRY glIndexfv( const GLfloat *c );
-+GLAPI void GLAPIENTRY glIndexiv( const GLint *c );
-+GLAPI void GLAPIENTRY glIndexsv( const GLshort *c );
-+GLAPI void GLAPIENTRY glIndexubv( const GLubyte *c );  /* 1.1 */
-+
-+GLAPI void GLAPIENTRY glColor3b( GLbyte red, GLbyte green, GLbyte blue );
-+GLAPI void GLAPIENTRY glColor3d( GLdouble red, GLdouble green, GLdouble blue );
-+GLAPI void GLAPIENTRY glColor3f( GLfloat red, GLfloat green, GLfloat blue );
-+GLAPI void GLAPIENTRY glColor3i( GLint red, GLint green, GLint blue );
-+GLAPI void GLAPIENTRY glColor3s( GLshort red, GLshort green, GLshort blue );
-+GLAPI void GLAPIENTRY glColor3ub( GLubyte red, GLubyte green, GLubyte blue );
-+GLAPI void GLAPIENTRY glColor3ui( GLuint red, GLuint green, GLuint blue );
-+GLAPI void GLAPIENTRY glColor3us( GLushort red, GLushort green, GLushort blue );
-+
-+GLAPI void GLAPIENTRY glColor4b( GLbyte red, GLbyte green,
-+                                   GLbyte blue, GLbyte alpha );
-+GLAPI void GLAPIENTRY glColor4d( GLdouble red, GLdouble green,
-+                                   GLdouble blue, GLdouble alpha );
-+GLAPI void GLAPIENTRY glColor4f( GLfloat red, GLfloat green,
-+                                   GLfloat blue, GLfloat alpha );
-+GLAPI void GLAPIENTRY glColor4i( GLint red, GLint green,
-+                                   GLint blue, GLint alpha );
-+GLAPI void GLAPIENTRY glColor4s( GLshort red, GLshort green,
-+                                   GLshort blue, GLshort alpha );
-+GLAPI void GLAPIENTRY glColor4ub( GLubyte red, GLubyte green,
-+                                    GLubyte blue, GLubyte alpha );
-+GLAPI void GLAPIENTRY glColor4ui( GLuint red, GLuint green,
-+                                    GLuint blue, GLuint alpha );
-+GLAPI void GLAPIENTRY glColor4us( GLushort red, GLushort green,
-+                                    GLushort blue, GLushort alpha );
-+
-+
-+GLAPI void GLAPIENTRY glColor3bv( const GLbyte *v );
-+GLAPI void GLAPIENTRY glColor3dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glColor3fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glColor3iv( const GLint *v );
-+GLAPI void GLAPIENTRY glColor3sv( const GLshort *v );
-+GLAPI void GLAPIENTRY glColor3ubv( const GLubyte *v );
-+GLAPI void GLAPIENTRY glColor3uiv( const GLuint *v );
-+GLAPI void GLAPIENTRY glColor3usv( const GLushort *v );
-+
-+GLAPI void GLAPIENTRY glColor4bv( const GLbyte *v );
-+GLAPI void GLAPIENTRY glColor4dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glColor4fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glColor4iv( const GLint *v );
-+GLAPI void GLAPIENTRY glColor4sv( const GLshort *v );
-+GLAPI void GLAPIENTRY glColor4ubv( const GLubyte *v );
-+GLAPI void GLAPIENTRY glColor4uiv( const GLuint *v );
-+GLAPI void GLAPIENTRY glColor4usv( const GLushort *v );
-+
-+
-+GLAPI void GLAPIENTRY glTexCoord1d( GLdouble s );
-+GLAPI void GLAPIENTRY glTexCoord1f( GLfloat s );
-+GLAPI void GLAPIENTRY glTexCoord1i( GLint s );
-+GLAPI void GLAPIENTRY glTexCoord1s( GLshort s );
-+
-+GLAPI void GLAPIENTRY glTexCoord2d( GLdouble s, GLdouble t );
-+GLAPI void GLAPIENTRY glTexCoord2f( GLfloat s, GLfloat t );
-+GLAPI void GLAPIENTRY glTexCoord2i( GLint s, GLint t );
-+GLAPI void GLAPIENTRY glTexCoord2s( GLshort s, GLshort t );
-+
-+GLAPI void GLAPIENTRY glTexCoord3d( GLdouble s, GLdouble t, GLdouble r );
-+GLAPI void GLAPIENTRY glTexCoord3f( GLfloat s, GLfloat t, GLfloat r );
-+GLAPI void GLAPIENTRY glTexCoord3i( GLint s, GLint t, GLint r );
-+GLAPI void GLAPIENTRY glTexCoord3s( GLshort s, GLshort t, GLshort r );
-+
-+GLAPI void GLAPIENTRY glTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q );
-+GLAPI void GLAPIENTRY glTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q );
-+GLAPI void GLAPIENTRY glTexCoord4i( GLint s, GLint t, GLint r, GLint q );
-+GLAPI void GLAPIENTRY glTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q );
-+
-+GLAPI void GLAPIENTRY glTexCoord1dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glTexCoord1fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glTexCoord1iv( const GLint *v );
-+GLAPI void GLAPIENTRY glTexCoord1sv( const GLshort *v );
-+
-+GLAPI void GLAPIENTRY glTexCoord2dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glTexCoord2fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glTexCoord2iv( const GLint *v );
-+GLAPI void GLAPIENTRY glTexCoord2sv( const GLshort *v );
-+
-+GLAPI void GLAPIENTRY glTexCoord3dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glTexCoord3fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glTexCoord3iv( const GLint *v );
-+GLAPI void GLAPIENTRY glTexCoord3sv( const GLshort *v );
-+
-+GLAPI void GLAPIENTRY glTexCoord4dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glTexCoord4fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glTexCoord4iv( const GLint *v );
-+GLAPI void GLAPIENTRY glTexCoord4sv( const GLshort *v );
-+
-+
-+GLAPI void GLAPIENTRY glRasterPos2d( GLdouble x, GLdouble y );
-+GLAPI void GLAPIENTRY glRasterPos2f( GLfloat x, GLfloat y );
-+GLAPI void GLAPIENTRY glRasterPos2i( GLint x, GLint y );
-+GLAPI void GLAPIENTRY glRasterPos2s( GLshort x, GLshort y );
-+
-+GLAPI void GLAPIENTRY glRasterPos3d( GLdouble x, GLdouble y, GLdouble z );
-+GLAPI void GLAPIENTRY glRasterPos3f( GLfloat x, GLfloat y, GLfloat z );
-+GLAPI void GLAPIENTRY glRasterPos3i( GLint x, GLint y, GLint z );
-+GLAPI void GLAPIENTRY glRasterPos3s( GLshort x, GLshort y, GLshort z );
-+
-+GLAPI void GLAPIENTRY glRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w );
-+GLAPI void GLAPIENTRY glRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w );
-+GLAPI void GLAPIENTRY glRasterPos4i( GLint x, GLint y, GLint z, GLint w );
-+GLAPI void GLAPIENTRY glRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w );
-+
-+GLAPI void GLAPIENTRY glRasterPos2dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glRasterPos2fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glRasterPos2iv( const GLint *v );
-+GLAPI void GLAPIENTRY glRasterPos2sv( const GLshort *v );
-+
-+GLAPI void GLAPIENTRY glRasterPos3dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glRasterPos3fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glRasterPos3iv( const GLint *v );
-+GLAPI void GLAPIENTRY glRasterPos3sv( const GLshort *v );
-+
-+GLAPI void GLAPIENTRY glRasterPos4dv( const GLdouble *v );
-+GLAPI void GLAPIENTRY glRasterPos4fv( const GLfloat *v );
-+GLAPI void GLAPIENTRY glRasterPos4iv( const GLint *v );
-+GLAPI void GLAPIENTRY glRasterPos4sv( const GLshort *v );
-+
-+
-+GLAPI void GLAPIENTRY glRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 );
-+GLAPI void GLAPIENTRY glRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 );
-+GLAPI void GLAPIENTRY glRecti( GLint x1, GLint y1, GLint x2, GLint y2 );
-+GLAPI void GLAPIENTRY glRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 );
-+
-+
-+GLAPI void GLAPIENTRY glRectdv( const GLdouble *v1, const GLdouble *v2 );
-+GLAPI void GLAPIENTRY glRectfv( const GLfloat *v1, const GLfloat *v2 );
-+GLAPI void GLAPIENTRY glRectiv( const GLint *v1, const GLint *v2 );
-+GLAPI void GLAPIENTRY glRectsv( const GLshort *v1, const GLshort *v2 );
-+
-+
-+/*
-+ * Vertex Arrays  (1.1)
-+ */
-+
-+GLAPI void GLAPIENTRY glVertexPointer( GLint size, GLenum type,
-+                                       GLsizei stride, const GLvoid *ptr );
-+
-+GLAPI void GLAPIENTRY glNormalPointer( GLenum type, GLsizei stride,
-+                                       const GLvoid *ptr );
-+
-+GLAPI void GLAPIENTRY glColorPointer( GLint size, GLenum type,
-+                                      GLsizei stride, const GLvoid *ptr );
-+
-+GLAPI void GLAPIENTRY glIndexPointer( GLenum type, GLsizei stride,
-+                                      const GLvoid *ptr );
-+
-+GLAPI void GLAPIENTRY glTexCoordPointer( GLint size, GLenum type,
-+                                         GLsizei stride, const GLvoid *ptr );
-+
-+GLAPI void GLAPIENTRY glEdgeFlagPointer( GLsizei stride, const GLvoid *ptr );
-+
-+GLAPI void GLAPIENTRY glGetPointerv( GLenum pname, GLvoid **params );
-+
-+GLAPI void GLAPIENTRY glArrayElement( GLint i );
-+
-+GLAPI void GLAPIENTRY glDrawArrays( GLenum mode, GLint first, GLsizei count );
-+
-+GLAPI void GLAPIENTRY glDrawElements( GLenum mode, GLsizei count,
-+                                      GLenum type, const GLvoid *indices );
-+
-+GLAPI void GLAPIENTRY glInterleavedArrays( GLenum format, GLsizei stride,
-+                                           const GLvoid *pointer );
-+
-+/*
-+ * Lighting
-+ */
-+
-+GLAPI void GLAPIENTRY glShadeModel( GLenum mode );
-+
-+GLAPI void GLAPIENTRY glLightf( GLenum light, GLenum pname, GLfloat param );
-+GLAPI void GLAPIENTRY glLighti( GLenum light, GLenum pname, GLint param );
-+GLAPI void GLAPIENTRY glLightfv( GLenum light, GLenum pname,
-+                                 const GLfloat *params );
-+GLAPI void GLAPIENTRY glLightiv( GLenum light, GLenum pname,
-+                                 const GLint *params );
-+
-+GLAPI void GLAPIENTRY glGetLightfv( GLenum light, GLenum pname,
-+                                    GLfloat *params );
-+GLAPI void GLAPIENTRY glGetLightiv( GLenum light, GLenum pname,
-+                                    GLint *params );
-+
-+GLAPI void GLAPIENTRY glLightModelf( GLenum pname, GLfloat param );
-+GLAPI void GLAPIENTRY glLightModeli( GLenum pname, GLint param );
-+GLAPI void GLAPIENTRY glLightModelfv( GLenum pname, const GLfloat *params );
-+GLAPI void GLAPIENTRY glLightModeliv( GLenum pname, const GLint *params );
-+
-+GLAPI void GLAPIENTRY glMaterialf( GLenum face, GLenum pname, GLfloat param );
-+GLAPI void GLAPIENTRY glMateriali( GLenum face, GLenum pname, GLint param );
-+GLAPI void GLAPIENTRY glMaterialfv( GLenum face, GLenum pname, const GLfloat *params );
-+GLAPI void GLAPIENTRY glMaterialiv( GLenum face, GLenum pname, const GLint *params );
-+
-+GLAPI void GLAPIENTRY glGetMaterialfv( GLenum face, GLenum pname, GLfloat *params );
-+GLAPI void GLAPIENTRY glGetMaterialiv( GLenum face, GLenum pname, GLint *params );
-+
-+GLAPI void GLAPIENTRY glColorMaterial( GLenum face, GLenum mode );
-+
-+
-+/*
-+ * Raster functions
-+ */
-+
-+GLAPI void GLAPIENTRY glPixelZoom( GLfloat xfactor, GLfloat yfactor );
-+
-+GLAPI void GLAPIENTRY glPixelStoref( GLenum pname, GLfloat param );
-+GLAPI void GLAPIENTRY glPixelStorei( GLenum pname, GLint param );
-+
-+GLAPI void GLAPIENTRY glPixelTransferf( GLenum pname, GLfloat param );
-+GLAPI void GLAPIENTRY glPixelTransferi( GLenum pname, GLint param );
-+
-+GLAPI void GLAPIENTRY glPixelMapfv( GLenum map, GLsizei mapsize,
-+                                    const GLfloat *values );
-+GLAPI void GLAPIENTRY glPixelMapuiv( GLenum map, GLsizei mapsize,
-+                                     const GLuint *values );
-+GLAPI void GLAPIENTRY glPixelMapusv( GLenum map, GLsizei mapsize,
-+                                     const GLushort *values );
-+
-+GLAPI void GLAPIENTRY glGetPixelMapfv( GLenum map, GLfloat *values );
-+GLAPI void GLAPIENTRY glGetPixelMapuiv( GLenum map, GLuint *values );
-+GLAPI void GLAPIENTRY glGetPixelMapusv( GLenum map, GLushort *values );
-+
-+GLAPI void GLAPIENTRY glBitmap( GLsizei width, GLsizei height,
-+                                GLfloat xorig, GLfloat yorig,
-+                                GLfloat xmove, GLfloat ymove,
-+                                const GLubyte *bitmap );
-+
-+GLAPI void GLAPIENTRY glReadPixels( GLint x, GLint y,
-+                                    GLsizei width, GLsizei height,
-+                                    GLenum format, GLenum type,
-+                                    GLvoid *pixels );
-+
-+GLAPI void GLAPIENTRY glDrawPixels( GLsizei width, GLsizei height,
-+                                    GLenum format, GLenum type,
-+                                    const GLvoid *pixels );
-+
-+GLAPI void GLAPIENTRY glCopyPixels( GLint x, GLint y,
-+                                    GLsizei width, GLsizei height,
-+                                    GLenum type );
-+
-+/*
-+ * Stenciling
-+ */
-+
-+GLAPI void GLAPIENTRY glStencilFunc( GLenum func, GLint ref, GLuint mask );
-+
-+GLAPI void GLAPIENTRY glStencilMask( GLuint mask );
-+
-+GLAPI void GLAPIENTRY glStencilOp( GLenum fail, GLenum zfail, GLenum zpass );
-+
-+GLAPI void GLAPIENTRY glClearStencil( GLint s );
-+
-+
-+
-+/*
-+ * Texture mapping
-+ */
-+
-+GLAPI void GLAPIENTRY glTexGend( GLenum coord, GLenum pname, GLdouble param );
-+GLAPI void GLAPIENTRY glTexGenf( GLenum coord, GLenum pname, GLfloat param );
-+GLAPI void GLAPIENTRY glTexGeni( GLenum coord, GLenum pname, GLint param );
-+
-+GLAPI void GLAPIENTRY glTexGendv( GLenum coord, GLenum pname, const GLdouble *params );
-+GLAPI void GLAPIENTRY glTexGenfv( GLenum coord, GLenum pname, const GLfloat *params );
-+GLAPI void GLAPIENTRY glTexGeniv( GLenum coord, GLenum pname, const GLint *params );
-+
-+GLAPI void GLAPIENTRY glGetTexGendv( GLenum coord, GLenum pname, GLdouble *params );
-+GLAPI void GLAPIENTRY glGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params );
-+GLAPI void GLAPIENTRY glGetTexGeniv( GLenum coord, GLenum pname, GLint *params );
-+
-+
-+GLAPI void GLAPIENTRY glTexEnvf( GLenum target, GLenum pname, GLfloat param );
-+GLAPI void GLAPIENTRY glTexEnvi( GLenum target, GLenum pname, GLint param );
-+
-+GLAPI void GLAPIENTRY glTexEnvfv( GLenum target, GLenum pname, const GLfloat *params );
-+GLAPI void GLAPIENTRY glTexEnviv( GLenum target, GLenum pname, const GLint *params );
-+
-+GLAPI void GLAPIENTRY glGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params );
-+GLAPI void GLAPIENTRY glGetTexEnviv( GLenum target, GLenum pname, GLint *params );
-+
-+
-+GLAPI void GLAPIENTRY glTexParameterf( GLenum target, GLenum pname, GLfloat param );
-+GLAPI void GLAPIENTRY glTexParameteri( GLenum target, GLenum pname, GLint param );
-+
-+GLAPI void GLAPIENTRY glTexParameterfv( GLenum target, GLenum pname,
-+                                          const GLfloat *params );
-+GLAPI void GLAPIENTRY glTexParameteriv( GLenum target, GLenum pname,
-+                                          const GLint *params );
-+
-+GLAPI void GLAPIENTRY glGetTexParameterfv( GLenum target,
-+                                           GLenum pname, GLfloat *params);
-+GLAPI void GLAPIENTRY glGetTexParameteriv( GLenum target,
-+                                           GLenum pname, GLint *params );
-+
-+GLAPI void GLAPIENTRY glGetTexLevelParameterfv( GLenum target, GLint level,
-+                                                GLenum pname, GLfloat *params );
-+GLAPI void GLAPIENTRY glGetTexLevelParameteriv( GLenum target, GLint level,
-+                                                GLenum pname, GLint *params );
-+
-+
-+GLAPI void GLAPIENTRY glTexImage1D( GLenum target, GLint level,
-+                                    GLint internalFormat,
-+                                    GLsizei width, GLint border,
-+                                    GLenum format, GLenum type,
-+                                    const GLvoid *pixels );
-+
-+GLAPI void GLAPIENTRY glTexImage2D( GLenum target, GLint level,
-+                                    GLint internalFormat,
-+                                    GLsizei width, GLsizei height,
-+                                    GLint border, GLenum format, GLenum type,
-+                                    const GLvoid *pixels );
-+
-+GLAPI void GLAPIENTRY glGetTexImage( GLenum target, GLint level,
-+                                     GLenum format, GLenum type,
-+                                     GLvoid *pixels );
-+
-+
-+/* 1.1 functions */
-+
-+GLAPI void GLAPIENTRY glGenTextures( GLsizei n, GLuint *textures );
-+
-+GLAPI void GLAPIENTRY glDeleteTextures( GLsizei n, const GLuint *textures);
-+
-+GLAPI void GLAPIENTRY glBindTexture( GLenum target, GLuint texture );
-+
-+GLAPI void GLAPIENTRY glPrioritizeTextures( GLsizei n,
-+                                            const GLuint *textures,
-+                                            const GLclampf *priorities );
-+
-+GLAPI GLboolean GLAPIENTRY glAreTexturesResident( GLsizei n,
-+                                                  const GLuint *textures,
-+                                                  GLboolean *residences );
-+
-+GLAPI GLboolean GLAPIENTRY glIsTexture( GLuint texture );
-+
-+
-+GLAPI void GLAPIENTRY glTexSubImage1D( GLenum target, GLint level,
-+                                       GLint xoffset,
-+                                       GLsizei width, GLenum format,
-+                                       GLenum type, const GLvoid *pixels );
-+
-+
-+GLAPI void GLAPIENTRY glTexSubImage2D( GLenum target, GLint level,
-+                                       GLint xoffset, GLint yoffset,
-+                                       GLsizei width, GLsizei height,
-+                                       GLenum format, GLenum type,
-+                                       const GLvoid *pixels );
-+
-+
-+GLAPI void GLAPIENTRY glCopyTexImage1D( GLenum target, GLint level,
-+                                        GLenum internalformat,
-+                                        GLint x, GLint y,
-+                                        GLsizei width, GLint border );
-+
-+
-+GLAPI void GLAPIENTRY glCopyTexImage2D( GLenum target, GLint level,
-+                                        GLenum internalformat,
-+                                        GLint x, GLint y,
-+                                        GLsizei width, GLsizei height,
-+                                        GLint border );
-+
-+
-+GLAPI void GLAPIENTRY glCopyTexSubImage1D( GLenum target, GLint level,
-+                                           GLint xoffset, GLint x, GLint y,
-+                                           GLsizei width );
-+
-+
-+GLAPI void GLAPIENTRY glCopyTexSubImage2D( GLenum target, GLint level,
-+                                           GLint xoffset, GLint yoffset,
-+                                           GLint x, GLint y,
-+                                           GLsizei width, GLsizei height );
-+
-+
-+/*
-+ * Evaluators
-+ */
-+
-+GLAPI void GLAPIENTRY glMap1d( GLenum target, GLdouble u1, GLdouble u2,
-+                               GLint stride,
-+                               GLint order, const GLdouble *points );
-+GLAPI void GLAPIENTRY glMap1f( GLenum target, GLfloat u1, GLfloat u2,
-+                               GLint stride,
-+                               GLint order, const GLfloat *points );
-+
-+GLAPI void GLAPIENTRY glMap2d( GLenum target,
-+		     GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
-+		     GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
-+		     const GLdouble *points );
-+GLAPI void GLAPIENTRY glMap2f( GLenum target,
-+		     GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
-+		     GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
-+		     const GLfloat *points );
-+
-+GLAPI void GLAPIENTRY glGetMapdv( GLenum target, GLenum query, GLdouble *v );
-+GLAPI void GLAPIENTRY glGetMapfv( GLenum target, GLenum query, GLfloat *v );
-+GLAPI void GLAPIENTRY glGetMapiv( GLenum target, GLenum query, GLint *v );
-+
-+GLAPI void GLAPIENTRY glEvalCoord1d( GLdouble u );
-+GLAPI void GLAPIENTRY glEvalCoord1f( GLfloat u );
-+
-+GLAPI void GLAPIENTRY glEvalCoord1dv( const GLdouble *u );
-+GLAPI void GLAPIENTRY glEvalCoord1fv( const GLfloat *u );
-+
-+GLAPI void GLAPIENTRY glEvalCoord2d( GLdouble u, GLdouble v );
-+GLAPI void GLAPIENTRY glEvalCoord2f( GLfloat u, GLfloat v );
-+
-+GLAPI void GLAPIENTRY glEvalCoord2dv( const GLdouble *u );
-+GLAPI void GLAPIENTRY glEvalCoord2fv( const GLfloat *u );
-+
-+GLAPI void GLAPIENTRY glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 );
-+GLAPI void GLAPIENTRY glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 );
-+
-+GLAPI void GLAPIENTRY glMapGrid2d( GLint un, GLdouble u1, GLdouble u2,
-+                                   GLint vn, GLdouble v1, GLdouble v2 );
-+GLAPI void GLAPIENTRY glMapGrid2f( GLint un, GLfloat u1, GLfloat u2,
-+                                   GLint vn, GLfloat v1, GLfloat v2 );
-+
-+GLAPI void GLAPIENTRY glEvalPoint1( GLint i );
-+
-+GLAPI void GLAPIENTRY glEvalPoint2( GLint i, GLint j );
-+
-+GLAPI void GLAPIENTRY glEvalMesh1( GLenum mode, GLint i1, GLint i2 );
-+
-+GLAPI void GLAPIENTRY glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 );
-+
-+
-+/*
-+ * Fog
-+ */
-+
-+GLAPI void GLAPIENTRY glFogf( GLenum pname, GLfloat param );
-+
-+GLAPI void GLAPIENTRY glFogi( GLenum pname, GLint param );
-+
-+GLAPI void GLAPIENTRY glFogfv( GLenum pname, const GLfloat *params );
-+
-+GLAPI void GLAPIENTRY glFogiv( GLenum pname, const GLint *params );
-+
-+
-+/*
-+ * Selection and Feedback
-+ */
-+
-+GLAPI void GLAPIENTRY glFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer );
-+
-+GLAPI void GLAPIENTRY glPassThrough( GLfloat token );
-+
-+GLAPI void GLAPIENTRY glSelectBuffer( GLsizei size, GLuint *buffer );
-+
-+GLAPI void GLAPIENTRY glInitNames( void );
-+
-+GLAPI void GLAPIENTRY glLoadName( GLuint name );
-+
-+GLAPI void GLAPIENTRY glPushName( GLuint name );
-+
-+GLAPI void GLAPIENTRY glPopName( void );
-+
-+
-+
-+/*
-+ * OpenGL 1.2
-+ */
-+
-+#define GL_RESCALE_NORMAL			0x803A
-+#define GL_CLAMP_TO_EDGE			0x812F
-+#define GL_MAX_ELEMENTS_VERTICES		0x80E8
-+#define GL_MAX_ELEMENTS_INDICES			0x80E9
-+#define GL_BGR					0x80E0
-+#define GL_BGRA					0x80E1
-+#define GL_UNSIGNED_BYTE_3_3_2			0x8032
-+#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		0x8033
-+#define GL_UNSIGNED_SHORT_4_4_4_4_REV		0x8365
-+#define GL_UNSIGNED_SHORT_5_5_5_1		0x8034
-+#define GL_UNSIGNED_SHORT_1_5_5_5_REV		0x8366
-+#define GL_UNSIGNED_INT_8_8_8_8			0x8035
-+#define GL_UNSIGNED_INT_8_8_8_8_REV		0x8367
-+#define GL_UNSIGNED_INT_10_10_10_2		0x8036
-+#define GL_UNSIGNED_INT_2_10_10_10_REV		0x8368
-+#define GL_LIGHT_MODEL_COLOR_CONTROL		0x81F8
-+#define GL_SINGLE_COLOR				0x81F9
-+#define GL_SEPARATE_SPECULAR_COLOR		0x81FA
-+#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_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
-+
-+GLAPI void GLAPIENTRY glDrawRangeElements( GLenum mode, GLuint start,
-+	GLuint end, GLsizei count, GLenum type, const GLvoid *indices );
-+
-+GLAPI void GLAPIENTRY glTexImage3D( GLenum target, GLint level,
-+                                      GLint internalFormat,
-+                                      GLsizei width, GLsizei height,
-+                                      GLsizei depth, GLint border,
-+                                      GLenum format, GLenum type,
-+                                      const GLvoid *pixels );
-+
-+GLAPI void GLAPIENTRY glTexSubImage3D( GLenum target, GLint level,
-+                                         GLint xoffset, GLint yoffset,
-+                                         GLint zoffset, GLsizei width,
-+                                         GLsizei height, GLsizei depth,
-+                                         GLenum format,
-+                                         GLenum type, const GLvoid *pixels);
-+
-+GLAPI void GLAPIENTRY glCopyTexSubImage3D( GLenum target, GLint level,
-+                                             GLint xoffset, GLint yoffset,
-+                                             GLint zoffset, GLint x,
-+                                             GLint y, GLsizei width,
-+                                             GLsizei height );
-+
-+typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-+typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-+typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC) (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 (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-+
-+
-+/*
-+ * 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_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_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_CONSTANT_BORDER			0x8151
-+#define GL_REPLICATE_BORDER			0x8153
-+#define GL_CONVOLUTION_BORDER_COLOR		0x8154
-+#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_MATRIX_ALPHA_BIAS		0x80BB
-+#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_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
-+
-+
-+GLAPI void GLAPIENTRY glColorTable( GLenum target, GLenum internalformat,
-+                                    GLsizei width, GLenum format,
-+                                    GLenum type, const GLvoid *table );
-+
-+GLAPI void GLAPIENTRY glColorSubTable( GLenum target,
-+                                       GLsizei start, GLsizei count,
-+                                       GLenum format, GLenum type,
-+                                       const GLvoid *data );
-+
-+GLAPI void GLAPIENTRY glColorTableParameteriv(GLenum target, GLenum pname,
-+                                              const GLint *params);
-+
-+GLAPI void GLAPIENTRY glColorTableParameterfv(GLenum target, GLenum pname,
-+                                              const GLfloat *params);
-+
-+GLAPI void GLAPIENTRY glCopyColorSubTable( GLenum target, GLsizei start,
-+                                           GLint x, GLint y, GLsizei width );
-+
-+GLAPI void GLAPIENTRY glCopyColorTable( GLenum target, GLenum internalformat,
-+                                        GLint x, GLint y, GLsizei width );
-+
-+GLAPI void GLAPIENTRY glGetColorTable( GLenum target, GLenum format,
-+                                       GLenum type, GLvoid *table );
-+
-+GLAPI void GLAPIENTRY glGetColorTableParameterfv( GLenum target, GLenum pname,
-+                                                  GLfloat *params );
-+
-+GLAPI void GLAPIENTRY glGetColorTableParameteriv( GLenum target, GLenum pname,
-+                                                  GLint *params );
-+
-+GLAPI void GLAPIENTRY glBlendEquation( GLenum mode );
-+
-+GLAPI void GLAPIENTRY glBlendColor( GLclampf red, GLclampf green,
-+                                    GLclampf blue, GLclampf alpha );
-+
-+GLAPI void GLAPIENTRY glHistogram( GLenum target, GLsizei width,
-+				   GLenum internalformat, GLboolean sink );
-+
-+GLAPI void GLAPIENTRY glResetHistogram( GLenum target );
-+
-+GLAPI void GLAPIENTRY glGetHistogram( GLenum target, GLboolean reset,
-+				      GLenum format, GLenum type,
-+				      GLvoid *values );
-+
-+GLAPI void GLAPIENTRY glGetHistogramParameterfv( GLenum target, GLenum pname,
-+						 GLfloat *params );
-+
-+GLAPI void GLAPIENTRY glGetHistogramParameteriv( GLenum target, GLenum pname,
-+						 GLint *params );
-+
-+GLAPI void GLAPIENTRY glMinmax( GLenum target, GLenum internalformat,
-+				GLboolean sink );
-+
-+GLAPI void GLAPIENTRY glResetMinmax( GLenum target );
-+
-+GLAPI void GLAPIENTRY glGetMinmax( GLenum target, GLboolean reset,
-+                                   GLenum format, GLenum types,
-+                                   GLvoid *values );
-+
-+GLAPI void GLAPIENTRY glGetMinmaxParameterfv( GLenum target, GLenum pname,
-+					      GLfloat *params );
-+
-+GLAPI void GLAPIENTRY glGetMinmaxParameteriv( GLenum target, GLenum pname,
-+					      GLint *params );
-+
-+GLAPI void GLAPIENTRY glConvolutionFilter1D( GLenum target,
-+	GLenum internalformat, GLsizei width, GLenum format, GLenum type,
-+	const GLvoid *image );
-+
-+GLAPI void GLAPIENTRY glConvolutionFilter2D( GLenum target,
-+	GLenum internalformat, GLsizei width, GLsizei height, GLenum format,
-+	GLenum type, const GLvoid *image );
-+
-+GLAPI void GLAPIENTRY glConvolutionParameterf( GLenum target, GLenum pname,
-+	GLfloat params );
-+
-+GLAPI void GLAPIENTRY glConvolutionParameterfv( GLenum target, GLenum pname,
-+	const GLfloat *params );
-+
-+GLAPI void GLAPIENTRY glConvolutionParameteri( GLenum target, GLenum pname,
-+	GLint params );
-+
-+GLAPI void GLAPIENTRY glConvolutionParameteriv( GLenum target, GLenum pname,
-+	const GLint *params );
-+
-+GLAPI void GLAPIENTRY glCopyConvolutionFilter1D( GLenum target,
-+	GLenum internalformat, GLint x, GLint y, GLsizei width );
-+
-+GLAPI void GLAPIENTRY glCopyConvolutionFilter2D( GLenum target,
-+	GLenum internalformat, GLint x, GLint y, GLsizei width,
-+	GLsizei height);
-+
-+GLAPI void GLAPIENTRY glGetConvolutionFilter( GLenum target, GLenum format,
-+	GLenum type, GLvoid *image );
-+
-+GLAPI void GLAPIENTRY glGetConvolutionParameterfv( GLenum target, GLenum pname,
-+	GLfloat *params );
-+
-+GLAPI void GLAPIENTRY glGetConvolutionParameteriv( GLenum target, GLenum pname,
-+	GLint *params );
-+
-+GLAPI void GLAPIENTRY glSeparableFilter2D( GLenum target,
-+	GLenum internalformat, GLsizei width, GLsizei height, GLenum format,
-+	GLenum type, const GLvoid *row, const GLvoid *column );
-+
-+GLAPI void GLAPIENTRY glGetSeparableFilter( GLenum target, GLenum format,
-+	GLenum type, GLvoid *row, GLvoid *column, GLvoid *span );
-+
-+typedef void (APIENTRYP PFNGLBLENDCOLORPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
-+typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC) (GLenum mode);
-+typedef void (APIENTRYP PFNGLCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
-+typedef void (APIENTRYP PFNGLCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params);
-+typedef void (APIENTRYP PFNGLCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params);
-+typedef void (APIENTRYP PFNGLCOPYCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-+typedef void (APIENTRYP PFNGLGETCOLORTABLEPROC) (GLenum target, GLenum format, GLenum type, GLvoid *table);
-+typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
-+typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
-+typedef void (APIENTRYP PFNGLCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
-+typedef void (APIENTRYP PFNGLCOPYCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
-+typedef void (APIENTRYP PFNGLCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
-+typedef void (APIENTRYP PFNGLCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
-+typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERFPROC) (GLenum target, GLenum pname, GLfloat params);
-+typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params);
-+typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERIPROC) (GLenum target, GLenum pname, GLint params);
-+typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params);
-+typedef void (APIENTRYP PFNGLCOPYCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-+typedef void (APIENTRYP PFNGLCOPYCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-+typedef void (APIENTRYP PFNGLGETCONVOLUTIONFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *image);
-+typedef void (APIENTRYP PFNGLGETCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
-+typedef void (APIENTRYP PFNGLGETCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
-+typedef void (APIENTRYP PFNGLGETSEPARABLEFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
-+typedef void (APIENTRYP PFNGLSEPARABLEFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
-+typedef void (APIENTRYP PFNGLGETHISTOGRAMPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-+typedef void (APIENTRYP PFNGLGETHISTOGRAMPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
-+typedef void (APIENTRYP PFNGLGETHISTOGRAMPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
-+typedef void (APIENTRYP PFNGLGETMINMAXPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-+typedef void (APIENTRYP PFNGLGETMINMAXPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
-+typedef void (APIENTRYP PFNGLGETMINMAXPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
-+typedef void (APIENTRYP PFNGLHISTOGRAMPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
-+typedef void (APIENTRYP PFNGLMINMAXPROC) (GLenum target, GLenum internalformat, GLboolean sink);
-+typedef void (APIENTRYP PFNGLRESETHISTOGRAMPROC) (GLenum target);
-+typedef void (APIENTRYP PFNGLRESETMINMAXPROC) (GLenum target);
-+
-+
-+
-+/*
-+ * OpenGL 1.3
-+ */
-+
-+/* multitexture */
-+#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_TEXTURE2