mesa git update 30 Mar 2011

30 files changed, 32120 insertions, 31575 deletions

diff --git a/mesalib/src/mesa/main/api_exec.c b/mesalib/src/mesa/main/api_exec.c
index 4101ac424..f7603705b 100644
--- a/mesalib/src/mesa/main/api_exec.c
+++ b/mesalib/src/mesa/main/api_exec.c
@@ -1,730 +1,732 @@
-/*

- * Mesa 3-D graphics library

- * Version:  7.1

- *

- * Copyright (C) 1999-2008  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.

- */

-

-

-/**

- * \file api_exec.c

- * Initialize dispatch table with the immidiate mode functions.

- */

-

-

-#include "mfeatures.h"

-#include "accum.h"

-#include "api_loopback.h"

-#include "api_exec.h"

-#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program

-#include "arbprogram.h"

-#endif

-#include "atifragshader.h"

-#include "attrib.h"

-#include "blend.h"

-#if FEATURE_ARB_vertex_buffer_object

-#include "bufferobj.h"

-#endif

-#include "arrayobj.h"

-#if FEATURE_draw_read_buffer

-#include "buffers.h"

-#endif

-#include "clear.h"

-#include "clip.h"

-#include "colortab.h"

-#include "condrender.h"

-#include "context.h"

-#include "convolve.h"

-#include "depth.h"

-#include "dlist.h"

-#include "drawpix.h"

-#include "rastpos.h"

-#include "enable.h"

-#include "eval.h"

-#include "get.h"

-#include "feedback.h"

-#include "fog.h"

-#if FEATURE_EXT_framebuffer_object

-#include "fbobject.h"

-#endif

-#include "framebuffer.h"

-#include "hint.h"

-#include "histogram.h"

-#include "imports.h"

-#include "light.h"

-#include "lines.h"

-#include "matrix.h"

-#include "multisample.h"

-#include "pixel.h"

-#include "pixelstore.h"

-#include "points.h"

-#include "polygon.h"

-#include "queryobj.h"

-#include "readpix.h"

-#include "scissor.h"

-#include "stencil.h"

-#include "texenv.h"

-#include "texgetimage.h"

-#include "teximage.h"

-#include "texgen.h"

-#include "texobj.h"

-#include "texparam.h"

-#include "texstate.h"

-#include "texturebarrier.h"

-#include "transformfeedback.h"

-#include "mtypes.h"

-#include "varray.h"

-#include "viewport.h"

-#if FEATURE_NV_vertex_program || FEATURE_NV_fragment_program

-#include "nvprogram.h"

-#endif

-#if FEATURE_ARB_shader_objects

-#include "shaderapi.h"

-#include "uniforms.h"

-#endif

-#include "syncobj.h"

-#include "main/dispatch.h"

-

-

-#if FEATURE_GL

-

-

-/**

- * Initialize a dispatch table with pointers to Mesa's immediate-mode

- * commands.

- *

- * Pointers to glBegin()/glEnd() object commands and a few others

- * are provided via the GLvertexformat interface.

- *

- * \param ctx  GL context to which \c exec belongs.

- * \param exec dispatch table.

- */

-struct _glapi_table *

-_mesa_create_exec_table(void)

-{

-   struct _glapi_table *exec;

-

-   exec = _mesa_alloc_dispatch_table(_gloffset_COUNT);

-   if (exec == NULL)

-      return NULL;

-

-#if _HAVE_FULL_GL

-   _mesa_loopback_init_api_table( exec );

-#endif

-

-   /* load the dispatch slots we understand */

-   SET_AlphaFunc(exec, _mesa_AlphaFunc);

-   SET_BlendFunc(exec, _mesa_BlendFunc);

-   SET_Clear(exec, _mesa_Clear);

-   SET_ClearColor(exec, _mesa_ClearColor);

-   SET_ClearStencil(exec, _mesa_ClearStencil);

-   SET_ColorMask(exec, _mesa_ColorMask);

-   SET_CullFace(exec, _mesa_CullFace);

-   SET_Disable(exec, _mesa_Disable);

-#if FEATURE_draw_read_buffer

-   SET_DrawBuffer(exec, _mesa_DrawBuffer);

-   SET_ReadBuffer(exec, _mesa_ReadBuffer);

-#endif

-   SET_Enable(exec, _mesa_Enable);

-   SET_Finish(exec, _mesa_Finish);

-   SET_Flush(exec, _mesa_Flush);

-   SET_FrontFace(exec, _mesa_FrontFace);

-   SET_Frustum(exec, _mesa_Frustum);

-   SET_GetError(exec, _mesa_GetError);

-   SET_GetFloatv(exec, _mesa_GetFloatv);

-   SET_GetString(exec, _mesa_GetString);

-   SET_LineStipple(exec, _mesa_LineStipple);

-   SET_LineWidth(exec, _mesa_LineWidth);

-   SET_LoadIdentity(exec, _mesa_LoadIdentity);

-   SET_LoadMatrixf(exec, _mesa_LoadMatrixf);

-   SET_LogicOp(exec, _mesa_LogicOp);

-   SET_MatrixMode(exec, _mesa_MatrixMode);

-   SET_MultMatrixf(exec, _mesa_MultMatrixf);

-   SET_Ortho(exec, _mesa_Ortho);

-   SET_PixelStorei(exec, _mesa_PixelStorei);

-   SET_PopMatrix(exec, _mesa_PopMatrix);

-   SET_PushMatrix(exec, _mesa_PushMatrix);

-   SET_Rotatef(exec, _mesa_Rotatef);

-   SET_Scalef(exec, _mesa_Scalef);

-   SET_Scissor(exec, _mesa_Scissor);

-   SET_ShadeModel(exec, _mesa_ShadeModel);

-   SET_StencilFunc(exec, _mesa_StencilFunc);

-   SET_StencilMask(exec, _mesa_StencilMask);

-   SET_StencilOp(exec, _mesa_StencilOp);

-   SET_TexEnvfv(exec, _mesa_TexEnvfv);

-   SET_TexEnvi(exec, _mesa_TexEnvi);

-   SET_TexImage2D(exec, _mesa_TexImage2D);

-   SET_TexParameteri(exec, _mesa_TexParameteri);

-   SET_Translatef(exec, _mesa_Translatef);

-   SET_Viewport(exec, _mesa_Viewport);

-

-   _mesa_init_accum_dispatch(exec);

-   _mesa_init_dlist_dispatch(exec);

-

-   SET_ClearDepth(exec, _mesa_ClearDepth);

-   SET_ClearIndex(exec, _mesa_ClearIndex);

-   SET_ClipPlane(exec, _mesa_ClipPlane);

-   SET_ColorMaterial(exec, _mesa_ColorMaterial);

-   SET_DepthFunc(exec, _mesa_DepthFunc);

-   SET_DepthMask(exec, _mesa_DepthMask);

-   SET_DepthRange(exec, _mesa_DepthRange);

-

-   _mesa_init_drawpix_dispatch(exec);

-   _mesa_init_feedback_dispatch(exec);

-

-   SET_FogCoordPointerEXT(exec, _mesa_FogCoordPointerEXT);

-   SET_Fogf(exec, _mesa_Fogf);

-   SET_Fogfv(exec, _mesa_Fogfv);

-   SET_Fogi(exec, _mesa_Fogi);

-   SET_Fogiv(exec, _mesa_Fogiv);

-   SET_GetClipPlane(exec, _mesa_GetClipPlane);

-   SET_GetBooleanv(exec, _mesa_GetBooleanv);

-   SET_GetDoublev(exec, _mesa_GetDoublev);

-   SET_GetIntegerv(exec, _mesa_GetIntegerv);

-   SET_GetLightfv(exec, _mesa_GetLightfv);

-   SET_GetLightiv(exec, _mesa_GetLightiv);

-   SET_GetMaterialfv(exec, _mesa_GetMaterialfv);

-   SET_GetMaterialiv(exec, _mesa_GetMaterialiv);

-   SET_GetPolygonStipple(exec, _mesa_GetPolygonStipple);

-   SET_GetTexEnvfv(exec, _mesa_GetTexEnvfv);

-   SET_GetTexEnviv(exec, _mesa_GetTexEnviv);

-   SET_GetTexLevelParameterfv(exec, _mesa_GetTexLevelParameterfv);

-   SET_GetTexLevelParameteriv(exec, _mesa_GetTexLevelParameteriv);

-   SET_GetTexParameterfv(exec, _mesa_GetTexParameterfv);

-   SET_GetTexParameteriv(exec, _mesa_GetTexParameteriv);

-   SET_GetTexImage(exec, _mesa_GetTexImage);

-   SET_Hint(exec, _mesa_Hint);

-   SET_IndexMask(exec, _mesa_IndexMask);

-   SET_IsEnabled(exec, _mesa_IsEnabled);

-   SET_LightModelf(exec, _mesa_LightModelf);

-   SET_LightModelfv(exec, _mesa_LightModelfv);

-   SET_LightModeli(exec, _mesa_LightModeli);

-   SET_LightModeliv(exec, _mesa_LightModeliv);

-   SET_Lightf(exec, _mesa_Lightf);

-   SET_Lightfv(exec, _mesa_Lightfv);

-   SET_Lighti(exec, _mesa_Lighti);

-   SET_Lightiv(exec, _mesa_Lightiv);

-   SET_LoadMatrixd(exec, _mesa_LoadMatrixd);

-

-   _mesa_init_eval_dispatch(exec);

-

-   SET_MultMatrixd(exec, _mesa_MultMatrixd);

-

-   _mesa_init_pixel_dispatch(exec);

-

-   SET_PixelStoref(exec, _mesa_PixelStoref);

-   SET_PointSize(exec, _mesa_PointSize);

-   SET_PolygonMode(exec, _mesa_PolygonMode);

-   SET_PolygonOffset(exec, _mesa_PolygonOffset);

-   SET_PolygonStipple(exec, _mesa_PolygonStipple);

-

-   _mesa_init_attrib_dispatch(exec);

-   _mesa_init_rastpos_dispatch(exec);

-

-   SET_ReadPixels(exec, _mesa_ReadPixels);

-   SET_Rotated(exec, _mesa_Rotated);

-   SET_Scaled(exec, _mesa_Scaled);

-   SET_SecondaryColorPointerEXT(exec, _mesa_SecondaryColorPointerEXT);

-   SET_TexEnvf(exec, _mesa_TexEnvf);

-   SET_TexEnviv(exec, _mesa_TexEnviv);

-

-   _mesa_init_texgen_dispatch(exec);

-

-   SET_TexImage1D(exec, _mesa_TexImage1D);

-   SET_TexParameterf(exec, _mesa_TexParameterf);

-   SET_TexParameterfv(exec, _mesa_TexParameterfv);

-   SET_TexParameteriv(exec, _mesa_TexParameteriv);

-   SET_Translated(exec, _mesa_Translated);

-

-   /* 1.1 */

-   SET_BindTexture(exec, _mesa_BindTexture);

-   SET_DeleteTextures(exec, _mesa_DeleteTextures);

-   SET_GenTextures(exec, _mesa_GenTextures);

-#if _HAVE_FULL_GL

-   SET_AreTexturesResident(exec, _mesa_AreTexturesResident);

-   SET_ColorPointer(exec, _mesa_ColorPointer);

-   SET_CopyTexImage1D(exec, _mesa_CopyTexImage1D);

-   SET_CopyTexImage2D(exec, _mesa_CopyTexImage2D);

-   SET_CopyTexSubImage1D(exec, _mesa_CopyTexSubImage1D);

-   SET_CopyTexSubImage2D(exec, _mesa_CopyTexSubImage2D);

-   SET_DisableClientState(exec, _mesa_DisableClientState);

-   SET_EdgeFlagPointer(exec, _mesa_EdgeFlagPointer);

-   SET_EnableClientState(exec, _mesa_EnableClientState);

-   SET_GetPointerv(exec, _mesa_GetPointerv);

-   SET_IndexPointer(exec, _mesa_IndexPointer);

-   SET_InterleavedArrays(exec, _mesa_InterleavedArrays);

-   SET_IsTexture(exec, _mesa_IsTexture);

-   SET_NormalPointer(exec, _mesa_NormalPointer);

-   SET_PrioritizeTextures(exec, _mesa_PrioritizeTextures);

-   SET_TexCoordPointer(exec, _mesa_TexCoordPointer);

-   SET_TexSubImage1D(exec, _mesa_TexSubImage1D);

-   SET_TexSubImage2D(exec, _mesa_TexSubImage2D);

-   SET_VertexPointer(exec, _mesa_VertexPointer);

-#endif

-

-   /* 1.2 */

-#if _HAVE_FULL_GL

-   SET_CopyTexSubImage3D(exec, _mesa_CopyTexSubImage3D);

-   SET_TexImage3D(exec, _mesa_TexImage3D);

-   SET_TexSubImage3D(exec, _mesa_TexSubImage3D);

-#endif

-

-   /* OpenGL 1.2  GL_ARB_imaging */

-   SET_BlendColor(exec, _mesa_BlendColor);

-   SET_BlendEquation(exec, _mesa_BlendEquation);

-   SET_BlendEquationSeparateEXT(exec, _mesa_BlendEquationSeparateEXT);

-

-   _mesa_init_colortable_dispatch(exec);

-   _mesa_init_convolve_dispatch(exec);

-   _mesa_init_histogram_dispatch(exec);

-

-   /* OpenGL 2.0 */

-   SET_StencilFuncSeparate(exec, _mesa_StencilFuncSeparate);

-   SET_StencilMaskSeparate(exec, _mesa_StencilMaskSeparate);

-   SET_StencilOpSeparate(exec, _mesa_StencilOpSeparate);

-

-#if FEATURE_ARB_shader_objects

-   _mesa_init_shader_dispatch(exec);

-   _mesa_init_shader_uniform_dispatch(exec);

-#endif

-

-   /* 2. GL_EXT_blend_color */

-#if 0

-/*    SET_BlendColorEXT(exec, _mesa_BlendColorEXT); */

-#endif

-

-   /* 3. GL_EXT_polygon_offset */

-#if _HAVE_FULL_GL

-   SET_PolygonOffsetEXT(exec, _mesa_PolygonOffsetEXT);

-#endif

-

-   /* 6. GL_EXT_texture3d */

-#if 0

-/*    SET_CopyTexSubImage3DEXT(exec, _mesa_CopyTexSubImage3D); */

-/*    SET_TexImage3DEXT(exec, _mesa_TexImage3DEXT); */

-/*    SET_TexSubImage3DEXT(exec, _mesa_TexSubImage3D); */

-#endif

-

-   /* 11. GL_EXT_histogram */

-#if 0

-   SET_GetHistogramEXT(exec, _mesa_GetHistogram);

-   SET_GetHistogramParameterfvEXT(exec, _mesa_GetHistogramParameterfv);

-   SET_GetHistogramParameterivEXT(exec, _mesa_GetHistogramParameteriv);

-   SET_GetMinmaxEXT(exec, _mesa_GetMinmax);

-   SET_GetMinmaxParameterfvEXT(exec, _mesa_GetMinmaxParameterfv);

-   SET_GetMinmaxParameterivEXT(exec, _mesa_GetMinmaxParameteriv);

-#endif

-

-   /* 14. SGI_color_table */

-#if 0

-   SET_ColorTableSGI(exec, _mesa_ColorTable);

-   SET_ColorSubTableSGI(exec, _mesa_ColorSubTable);

-   SET_GetColorTableSGI(exec, _mesa_GetColorTable);

-   SET_GetColorTableParameterfvSGI(exec, _mesa_GetColorTableParameterfv);

-   SET_GetColorTableParameterivSGI(exec, _mesa_GetColorTableParameteriv);

-#endif

-

-   /* 30. GL_EXT_vertex_array */

-#if _HAVE_FULL_GL

-   SET_ColorPointerEXT(exec, _mesa_ColorPointerEXT);

-   SET_EdgeFlagPointerEXT(exec, _mesa_EdgeFlagPointerEXT);

-   SET_IndexPointerEXT(exec, _mesa_IndexPointerEXT);

-   SET_NormalPointerEXT(exec, _mesa_NormalPointerEXT);

-   SET_TexCoordPointerEXT(exec, _mesa_TexCoordPointerEXT);

-   SET_VertexPointerEXT(exec, _mesa_VertexPointerEXT);

-#endif

-

-   /* 37. GL_EXT_blend_minmax */

-#if 0

-   SET_BlendEquationEXT(exec, _mesa_BlendEquationEXT);

-#endif

-

-   /* 54. GL_EXT_point_parameters */

-#if _HAVE_FULL_GL

-   SET_PointParameterfEXT(exec, _mesa_PointParameterf);

-   SET_PointParameterfvEXT(exec, _mesa_PointParameterfv);

-#endif

-

-   /* 95. GL_ARB_ES2_compatibility */

-   SET_ClearDepthf(exec, _mesa_ClearDepthf);

-   SET_DepthRangef(exec, _mesa_DepthRangef);

-

-   /* 97. GL_EXT_compiled_vertex_array */

-#if _HAVE_FULL_GL

-   SET_LockArraysEXT(exec, _mesa_LockArraysEXT);

-   SET_UnlockArraysEXT(exec, _mesa_UnlockArraysEXT);

-#endif

-

-   /* 148. GL_EXT_multi_draw_arrays */

-#if _HAVE_FULL_GL

-   SET_MultiDrawArraysEXT(exec, _mesa_MultiDrawArraysEXT);

-#endif

-

-   /* 173. GL_INGR_blend_func_separate */

-#if _HAVE_FULL_GL

-   SET_BlendFuncSeparateEXT(exec, _mesa_BlendFuncSeparateEXT);

-#endif

-

-   /* 196. GL_MESA_resize_buffers */

-#if _HAVE_FULL_GL

-   SET_ResizeBuffersMESA(exec, _mesa_ResizeBuffersMESA);

-#endif

-

-   /* 197. GL_MESA_window_pos */

-   /* part of _mesa_init_rastpos_dispatch(exec); */

-

-   /* 200. GL_IBM_multimode_draw_arrays */

-#if _HAVE_FULL_GL

-   SET_MultiModeDrawArraysIBM(exec, _mesa_MultiModeDrawArraysIBM);

-   SET_MultiModeDrawElementsIBM(exec, _mesa_MultiModeDrawElementsIBM);

-#endif

-

-   /* 233. GL_NV_vertex_program */

-#if FEATURE_NV_vertex_program

-   SET_BindProgramNV(exec, _mesa_BindProgram);

-   SET_DeleteProgramsNV(exec, _mesa_DeletePrograms);

-   SET_ExecuteProgramNV(exec, _mesa_ExecuteProgramNV);

-   SET_GenProgramsNV(exec, _mesa_GenPrograms);

-   SET_AreProgramsResidentNV(exec, _mesa_AreProgramsResidentNV);

-   SET_RequestResidentProgramsNV(exec, _mesa_RequestResidentProgramsNV);

-   SET_GetProgramParameterfvNV(exec, _mesa_GetProgramParameterfvNV);

-   SET_GetProgramParameterdvNV(exec, _mesa_GetProgramParameterdvNV);

-   SET_GetProgramivNV(exec, _mesa_GetProgramivNV);

-   SET_GetProgramStringNV(exec, _mesa_GetProgramStringNV);

-   SET_GetTrackMatrixivNV(exec, _mesa_GetTrackMatrixivNV);

-   SET_GetVertexAttribdvNV(exec, _mesa_GetVertexAttribdvNV);

-   SET_GetVertexAttribfvNV(exec, _mesa_GetVertexAttribfvNV);

-   SET_GetVertexAttribivNV(exec, _mesa_GetVertexAttribivNV);

-   SET_GetVertexAttribPointervNV(exec, _mesa_GetVertexAttribPointervNV);

-   SET_IsProgramNV(exec, _mesa_IsProgramARB);

-   SET_LoadProgramNV(exec, _mesa_LoadProgramNV);

-   SET_ProgramEnvParameter4dARB(exec, _mesa_ProgramEnvParameter4dARB); /* alias to ProgramParameter4dNV */

-   SET_ProgramEnvParameter4dvARB(exec, _mesa_ProgramEnvParameter4dvARB);  /* alias to ProgramParameter4dvNV */

-   SET_ProgramEnvParameter4fARB(exec, _mesa_ProgramEnvParameter4fARB);  /* alias to ProgramParameter4fNV */

-   SET_ProgramEnvParameter4fvARB(exec, _mesa_ProgramEnvParameter4fvARB);  /* alias to ProgramParameter4fvNV */

-   SET_ProgramParameters4dvNV(exec, _mesa_ProgramParameters4dvNV);

-   SET_ProgramParameters4fvNV(exec, _mesa_ProgramParameters4fvNV);

-   SET_TrackMatrixNV(exec, _mesa_TrackMatrixNV);

-   SET_VertexAttribPointerNV(exec, _mesa_VertexAttribPointerNV);

-   /* glVertexAttrib*NV functions handled in api_loopback.c */

-#endif

-

-   /* 273. GL_APPLE_vertex_array_object */

-   SET_BindVertexArrayAPPLE(exec, _mesa_BindVertexArrayAPPLE);

-   SET_DeleteVertexArraysAPPLE(exec, _mesa_DeleteVertexArraysAPPLE);

-   SET_GenVertexArraysAPPLE(exec, _mesa_GenVertexArraysAPPLE);

-   SET_IsVertexArrayAPPLE(exec, _mesa_IsVertexArrayAPPLE);

-

-   /* 282. GL_NV_fragment_program */

-#if FEATURE_NV_fragment_program

-   SET_ProgramNamedParameter4fNV(exec, _mesa_ProgramNamedParameter4fNV);

-   SET_ProgramNamedParameter4dNV(exec, _mesa_ProgramNamedParameter4dNV);

-   SET_ProgramNamedParameter4fvNV(exec, _mesa_ProgramNamedParameter4fvNV);

-   SET_ProgramNamedParameter4dvNV(exec, _mesa_ProgramNamedParameter4dvNV);

-   SET_GetProgramNamedParameterfvNV(exec, _mesa_GetProgramNamedParameterfvNV);

-   SET_GetProgramNamedParameterdvNV(exec, _mesa_GetProgramNamedParameterdvNV);

-   SET_ProgramLocalParameter4dARB(exec, _mesa_ProgramLocalParameter4dARB);

-   SET_ProgramLocalParameter4dvARB(exec, _mesa_ProgramLocalParameter4dvARB);

-   SET_ProgramLocalParameter4fARB(exec, _mesa_ProgramLocalParameter4fARB);

-   SET_ProgramLocalParameter4fvARB(exec, _mesa_ProgramLocalParameter4fvARB);

-   SET_GetProgramLocalParameterdvARB(exec, _mesa_GetProgramLocalParameterdvARB);

-   SET_GetProgramLocalParameterfvARB(exec, _mesa_GetProgramLocalParameterfvARB);

-#endif

-

-   /* 262. GL_NV_point_sprite */

-#if _HAVE_FULL_GL

-   SET_PointParameteriNV(exec, _mesa_PointParameteri);

-   SET_PointParameterivNV(exec, _mesa_PointParameteriv);

-#endif

-

-   /* 268. GL_EXT_stencil_two_side */

-#if _HAVE_FULL_GL

-   SET_ActiveStencilFaceEXT(exec, _mesa_ActiveStencilFaceEXT);

-#endif

-

-   /* 285. GL_NV_primitive_restart */

-   SET_PrimitiveRestartIndexNV(exec, _mesa_PrimitiveRestartIndex);

-

-   /* ???. GL_EXT_depth_bounds_test */

-   SET_DepthBoundsEXT(exec, _mesa_DepthBoundsEXT);

-

-   /* 352. GL_EXT_transform_feedback */

-   _mesa_init_transform_feedback_dispatch(exec);

-

-   /* 364. GL_EXT_provoking_vertex */

-   SET_ProvokingVertexEXT(exec, _mesa_ProvokingVertexEXT);

-

-   /* ARB 1. GL_ARB_multitexture */

-#if _HAVE_FULL_GL

-   SET_ActiveTextureARB(exec, _mesa_ActiveTextureARB);

-   SET_ClientActiveTextureARB(exec, _mesa_ClientActiveTextureARB);

-#endif

-

-   /* ARB 3. GL_ARB_transpose_matrix */

-#if _HAVE_FULL_GL

-   SET_LoadTransposeMatrixdARB(exec, _mesa_LoadTransposeMatrixdARB);

-   SET_LoadTransposeMatrixfARB(exec, _mesa_LoadTransposeMatrixfARB);

-   SET_MultTransposeMatrixdARB(exec, _mesa_MultTransposeMatrixdARB);

-   SET_MultTransposeMatrixfARB(exec, _mesa_MultTransposeMatrixfARB);

-#endif

-

-   /* ARB 5. GL_ARB_multisample */

-#if _HAVE_FULL_GL

-   SET_SampleCoverageARB(exec, _mesa_SampleCoverageARB);

-#endif

-

-   /* ARB 12. GL_ARB_texture_compression */

-#if _HAVE_FULL_GL

-   SET_CompressedTexImage3DARB(exec, _mesa_CompressedTexImage3DARB);

-   SET_CompressedTexImage2DARB(exec, _mesa_CompressedTexImage2DARB);

-   SET_CompressedTexImage1DARB(exec, _mesa_CompressedTexImage1DARB);

-   SET_CompressedTexSubImage3DARB(exec, _mesa_CompressedTexSubImage3DARB);

-   SET_CompressedTexSubImage2DARB(exec, _mesa_CompressedTexSubImage2DARB);

-   SET_CompressedTexSubImage1DARB(exec, _mesa_CompressedTexSubImage1DARB);

-   SET_GetCompressedTexImageARB(exec, _mesa_GetCompressedTexImageARB);

-#endif

-

-   /* ARB 14. GL_ARB_point_parameters */

-   /* reuse EXT_point_parameters functions */

-

-   /* ARB 26. GL_ARB_vertex_program */

-   /* ARB 27. GL_ARB_fragment_program */

-#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program

-   /* glVertexAttrib1sARB aliases glVertexAttrib1sNV */

-   /* glVertexAttrib1fARB aliases glVertexAttrib1fNV */

-   /* glVertexAttrib1dARB aliases glVertexAttrib1dNV */

-   /* glVertexAttrib2sARB aliases glVertexAttrib2sNV */

-   /* glVertexAttrib2fARB aliases glVertexAttrib2fNV */

-   /* glVertexAttrib2dARB aliases glVertexAttrib2dNV */

-   /* glVertexAttrib3sARB aliases glVertexAttrib3sNV */

-   /* glVertexAttrib3fARB aliases glVertexAttrib3fNV */

-   /* glVertexAttrib3dARB aliases glVertexAttrib3dNV */

-   /* glVertexAttrib4sARB aliases glVertexAttrib4sNV */

-   /* glVertexAttrib4fARB aliases glVertexAttrib4fNV */

-   /* glVertexAttrib4dARB aliases glVertexAttrib4dNV */

-   /* glVertexAttrib4NubARB aliases glVertexAttrib4NubNV */

-   /* glVertexAttrib1svARB aliases glVertexAttrib1svNV */

-   /* glVertexAttrib1fvARB aliases glVertexAttrib1fvNV */

-   /* glVertexAttrib1dvARB aliases glVertexAttrib1dvNV */

-   /* glVertexAttrib2svARB aliases glVertexAttrib2svNV */

-   /* glVertexAttrib2fvARB aliases glVertexAttrib2fvNV */

-   /* glVertexAttrib2dvARB aliases glVertexAttrib2dvNV */

-   /* glVertexAttrib3svARB aliases glVertexAttrib3svNV */

-   /* glVertexAttrib3fvARB aliases glVertexAttrib3fvNV */

-   /* glVertexAttrib3dvARB aliases glVertexAttrib3dvNV */

-   /* glVertexAttrib4svARB aliases glVertexAttrib4svNV */

-   /* glVertexAttrib4fvARB aliases glVertexAttrib4fvNV */

-   /* glVertexAttrib4dvARB aliases glVertexAttrib4dvNV */

-   /* glVertexAttrib4NubvARB aliases glVertexAttrib4NubvNV */

-   /* glVertexAttrib4bvARB handled in api_loopback.c */

-   /* glVertexAttrib4ivARB handled in api_loopback.c */

-   /* glVertexAttrib4ubvARB handled in api_loopback.c */

-   /* glVertexAttrib4usvARB handled in api_loopback.c */

-   /* glVertexAttrib4uivARB handled in api_loopback.c */

-   /* glVertexAttrib4NbvARB handled in api_loopback.c */

-   /* glVertexAttrib4NsvARB handled in api_loopback.c */

-   /* glVertexAttrib4NivARB handled in api_loopback.c */

-   /* glVertexAttrib4NusvARB handled in api_loopback.c */

-   /* glVertexAttrib4NuivARB handled in api_loopback.c */

-   SET_VertexAttribPointerARB(exec, _mesa_VertexAttribPointerARB);

-   SET_EnableVertexAttribArrayARB(exec, _mesa_EnableVertexAttribArrayARB);

-   SET_DisableVertexAttribArrayARB(exec, _mesa_DisableVertexAttribArrayARB);

-   SET_ProgramStringARB(exec, _mesa_ProgramStringARB);

-   /* glBindProgramARB aliases glBindProgramNV */

-   /* glDeleteProgramsARB aliases glDeleteProgramsNV */

-   /* glGenProgramsARB aliases glGenProgramsNV */

-   /* glIsProgramARB aliases glIsProgramNV */

-   SET_GetVertexAttribdvARB(exec, _mesa_GetVertexAttribdvARB);

-   SET_GetVertexAttribfvARB(exec, _mesa_GetVertexAttribfvARB);

-   SET_GetVertexAttribivARB(exec, _mesa_GetVertexAttribivARB);

-   /* glGetVertexAttribPointervARB aliases glGetVertexAttribPointervNV */

-   SET_ProgramEnvParameter4dARB(exec, _mesa_ProgramEnvParameter4dARB);

-   SET_ProgramEnvParameter4dvARB(exec, _mesa_ProgramEnvParameter4dvARB);

-   SET_ProgramEnvParameter4fARB(exec, _mesa_ProgramEnvParameter4fARB);

-   SET_ProgramEnvParameter4fvARB(exec, _mesa_ProgramEnvParameter4fvARB);

-   SET_ProgramLocalParameter4dARB(exec, _mesa_ProgramLocalParameter4dARB);

-   SET_ProgramLocalParameter4dvARB(exec, _mesa_ProgramLocalParameter4dvARB);

-   SET_ProgramLocalParameter4fARB(exec, _mesa_ProgramLocalParameter4fARB);

-   SET_ProgramLocalParameter4fvARB(exec, _mesa_ProgramLocalParameter4fvARB);

-   SET_GetProgramEnvParameterdvARB(exec, _mesa_GetProgramEnvParameterdvARB);

-   SET_GetProgramEnvParameterfvARB(exec, _mesa_GetProgramEnvParameterfvARB);

-   SET_GetProgramLocalParameterdvARB(exec, _mesa_GetProgramLocalParameterdvARB);

-   SET_GetProgramLocalParameterfvARB(exec, _mesa_GetProgramLocalParameterfvARB);

-   SET_GetProgramivARB(exec, _mesa_GetProgramivARB);

-   SET_GetProgramStringARB(exec, _mesa_GetProgramStringARB);

-#endif

-

-   /* ARB 28. GL_ARB_vertex_buffer_object */

-#if FEATURE_ARB_vertex_buffer_object

-   SET_BindBufferARB(exec, _mesa_BindBufferARB);

-   SET_BufferDataARB(exec, _mesa_BufferDataARB);

-   SET_BufferSubDataARB(exec, _mesa_BufferSubDataARB);

-   SET_DeleteBuffersARB(exec, _mesa_DeleteBuffersARB);

-   SET_GenBuffersARB(exec, _mesa_GenBuffersARB);

-   SET_GetBufferParameterivARB(exec, _mesa_GetBufferParameterivARB);

-   SET_GetBufferPointervARB(exec, _mesa_GetBufferPointervARB);

-   SET_GetBufferSubDataARB(exec, _mesa_GetBufferSubDataARB);

-   SET_IsBufferARB(exec, _mesa_IsBufferARB);

-   SET_MapBufferARB(exec, _mesa_MapBufferARB);

-   SET_UnmapBufferARB(exec, _mesa_UnmapBufferARB);

-#endif

-

-   /* ARB 29. GL_ARB_occlusion_query */

-   _mesa_init_queryobj_dispatch(exec);

-

-   /* ARB 37. GL_ARB_draw_buffers */

-#if FEATURE_draw_read_buffer

-   SET_DrawBuffersARB(exec, _mesa_DrawBuffersARB);

-#endif

-

-   /* GL_ARB_sync */

-   _mesa_init_sync_dispatch(exec);

-

-  /* GL_ATI_fragment_shader */

-   _mesa_init_ati_fragment_shader_dispatch(exec);

-

-  /* GL_ATI_envmap_bumpmap */

-   SET_GetTexBumpParameterivATI(exec, _mesa_GetTexBumpParameterivATI);

-   SET_GetTexBumpParameterfvATI(exec, _mesa_GetTexBumpParameterfvATI);

-   SET_TexBumpParameterivATI(exec, _mesa_TexBumpParameterivATI);

-   SET_TexBumpParameterfvATI(exec, _mesa_TexBumpParameterfvATI);

-

-#if FEATURE_EXT_framebuffer_object

-   SET_IsRenderbufferEXT(exec, _mesa_IsRenderbufferEXT);

-   SET_BindRenderbufferEXT(exec, _mesa_BindRenderbufferEXT);

-   SET_DeleteRenderbuffersEXT(exec, _mesa_DeleteRenderbuffersEXT);

-   SET_GenRenderbuffersEXT(exec, _mesa_GenRenderbuffersEXT);

-   SET_RenderbufferStorageEXT(exec, _mesa_RenderbufferStorageEXT);

-   SET_GetRenderbufferParameterivEXT(exec, _mesa_GetRenderbufferParameterivEXT);

-   SET_IsFramebufferEXT(exec, _mesa_IsFramebufferEXT);

-   SET_BindFramebufferEXT(exec, _mesa_BindFramebufferEXT);

-   SET_DeleteFramebuffersEXT(exec, _mesa_DeleteFramebuffersEXT);

-   SET_GenFramebuffersEXT(exec, _mesa_GenFramebuffersEXT);

-   SET_CheckFramebufferStatusEXT(exec, _mesa_CheckFramebufferStatusEXT);

-   SET_FramebufferTexture1DEXT(exec, _mesa_FramebufferTexture1DEXT);

-   SET_FramebufferTexture2DEXT(exec, _mesa_FramebufferTexture2DEXT);

-   SET_FramebufferTexture3DEXT(exec, _mesa_FramebufferTexture3DEXT);

-   SET_FramebufferRenderbufferEXT(exec, _mesa_FramebufferRenderbufferEXT);

-   SET_GetFramebufferAttachmentParameterivEXT(exec, _mesa_GetFramebufferAttachmentParameterivEXT);

-   SET_GenerateMipmapEXT(exec, _mesa_GenerateMipmapEXT);

-#endif

-

-#if FEATURE_EXT_framebuffer_blit

-   SET_BlitFramebufferEXT(exec, _mesa_BlitFramebufferEXT);

-#endif

-

-   /* GL_EXT_gpu_program_parameters */

-#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program

-   SET_ProgramEnvParameters4fvEXT(exec, _mesa_ProgramEnvParameters4fvEXT);

-   SET_ProgramLocalParameters4fvEXT(exec, _mesa_ProgramLocalParameters4fvEXT);

-#endif

-

-   /* GL_MESA_texture_array / GL_EXT_texture_array */

-#if FEATURE_EXT_framebuffer_object

-   SET_FramebufferTextureLayerEXT(exec, _mesa_FramebufferTextureLayerEXT);

-#endif

-

-   /* GL_ATI_separate_stencil */

-   SET_StencilFuncSeparateATI(exec, _mesa_StencilFuncSeparateATI);

-

-#if FEATURE_ARB_framebuffer_object

-   /* The ARB_fbo functions are the union of

-    * GL_EXT_fbo, GL_EXT_framebuffer_blit, GL_EXT_texture_array

-    */

-   SET_RenderbufferStorageMultisample(exec, _mesa_RenderbufferStorageMultisample);

-#endif

-

-#if FEATURE_ARB_map_buffer_range

-   SET_MapBufferRange(exec, _mesa_MapBufferRange);

-   SET_FlushMappedBufferRange(exec, _mesa_FlushMappedBufferRange);

-#endif

-

-   /* GL_ARB_copy_buffer */

-   SET_CopyBufferSubData(exec, _mesa_CopyBufferSubData);

-

-   /* GL_ARB_vertex_array_object */

-   SET_BindVertexArray(exec, _mesa_BindVertexArray);

-   SET_GenVertexArrays(exec, _mesa_GenVertexArrays);

-

-   /* GL_EXT_draw_buffers2 */

-   SET_ColorMaskIndexedEXT(exec, _mesa_ColorMaskIndexed);

-   SET_GetBooleanIndexedvEXT(exec, _mesa_GetBooleanIndexedv);

-   SET_GetIntegerIndexedvEXT(exec, _mesa_GetIntegerIndexedv);

-   SET_EnableIndexedEXT(exec, _mesa_EnableIndexed);

-   SET_DisableIndexedEXT(exec, _mesa_DisableIndexed);

-   SET_IsEnabledIndexedEXT(exec, _mesa_IsEnabledIndexed);

-

-   /* GL_NV_conditional_render */

-   SET_BeginConditionalRenderNV(exec, _mesa_BeginConditionalRender);

-   SET_EndConditionalRenderNV(exec, _mesa_EndConditionalRender);

-

-#if FEATURE_OES_EGL_image

-   SET_EGLImageTargetTexture2DOES(exec, _mesa_EGLImageTargetTexture2DOES);

-   SET_EGLImageTargetRenderbufferStorageOES(exec, _mesa_EGLImageTargetRenderbufferStorageOES);

-#endif

-

-#if FEATURE_APPLE_object_purgeable

-   SET_ObjectPurgeableAPPLE(exec, _mesa_ObjectPurgeableAPPLE);

-   SET_ObjectUnpurgeableAPPLE(exec, _mesa_ObjectUnpurgeableAPPLE);

-   SET_GetObjectParameterivAPPLE(exec, _mesa_GetObjectParameterivAPPLE);

-#endif

-

-#if FEATURE_ARB_geometry_shader4

-   SET_FramebufferTextureARB(exec, _mesa_FramebufferTextureARB);

-   SET_FramebufferTextureFaceARB(exec, _mesa_FramebufferTextureFaceARB);

-#endif

-

-   /* GL_EXT_texture_integer */

-   SET_ClearColorIiEXT(exec, _mesa_ClearColorIiEXT);

-   SET_ClearColorIuiEXT(exec, _mesa_ClearColorIuiEXT);

-   SET_GetTexParameterIivEXT(exec, _mesa_GetTexParameterIiv);

-   SET_GetTexParameterIuivEXT(exec, _mesa_GetTexParameterIuiv);

-   SET_TexParameterIivEXT(exec, _mesa_TexParameterIiv);

-   SET_TexParameterIuivEXT(exec, _mesa_TexParameterIuiv);

-

-   /* GL_EXT_gpu_shader4 / OpenGL 3.0 */

-   SET_GetVertexAttribIivEXT(exec, _mesa_GetVertexAttribIiv);

-   SET_GetVertexAttribIuivEXT(exec, _mesa_GetVertexAttribIuiv);

-   SET_VertexAttribIPointerEXT(exec, _mesa_VertexAttribIPointer);

-

-   /* GL 3.0 (functions not covered by other extensions) */

-   SET_ClearBufferiv(exec, _mesa_ClearBufferiv);

-   SET_ClearBufferuiv(exec, _mesa_ClearBufferuiv);

-   SET_ClearBufferfv(exec, _mesa_ClearBufferfv);

-   SET_ClearBufferfi(exec, _mesa_ClearBufferfi);

-   SET_GetStringi(exec, _mesa_GetStringi);

-   SET_ClampColor(exec, _mesa_ClampColorARB);

-

-   /* GL_ARB_instanced_arrays */

-   SET_VertexAttribDivisorARB(exec, _mesa_VertexAttribDivisor);

-

-   /* GL_ARB_draw_buffer_blend */

-   SET_BlendFunciARB(exec, _mesa_BlendFunci);

-   SET_BlendFuncSeparateiARB(exec, _mesa_BlendFuncSeparatei);

-   SET_BlendEquationiARB(exec, _mesa_BlendEquationi);

-   SET_BlendEquationSeparateiARB(exec, _mesa_BlendEquationSeparatei);

-

-   /* GL_NV_texture_barrier */

-   SET_TextureBarrierNV(exec, _mesa_TextureBarrierNV);

- 

-   return exec;

-}

-

-#endif /* FEATURE_GL */

+/*
+ * Mesa 3-D graphics library
+ * Version:  7.1
+ *
+ * Copyright (C) 1999-2008  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.
+ */
+
+
+/**
+ * \file api_exec.c
+ * Initialize dispatch table with the immidiate mode functions.
+ */
+
+
+#include "mfeatures.h"
+#include "accum.h"
+#include "api_loopback.h"
+#include "api_exec.h"
+#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
+#include "arbprogram.h"
+#endif
+#include "atifragshader.h"
+#include "attrib.h"
+#include "blend.h"
+#if FEATURE_ARB_vertex_buffer_object
+#include "bufferobj.h"
+#endif
+#include "arrayobj.h"
+#if FEATURE_draw_read_buffer
+#include "buffers.h"
+#endif
+#include "clear.h"
+#include "clip.h"
+#include "colortab.h"
+#include "condrender.h"
+#include "context.h"
+#include "convolve.h"
+#include "depth.h"
+#include "dlist.h"
+#include "drawpix.h"
+#include "rastpos.h"
+#include "enable.h"
+#include "eval.h"
+#include "get.h"
+#include "feedback.h"
+#include "fog.h"
+#if FEATURE_EXT_framebuffer_object
+#include "fbobject.h"
+#endif
+#include "framebuffer.h"
+#include "hint.h"
+#include "histogram.h"
+#include "imports.h"
+#include "light.h"
+#include "lines.h"
+#include "matrix.h"
+#include "multisample.h"
+#include "pixel.h"
+#include "pixelstore.h"
+#include "points.h"
+#include "polygon.h"
+#include "queryobj.h"
+#include "readpix.h"
+#include "scissor.h"
+#include "stencil.h"
+#include "texenv.h"
+#include "texgetimage.h"
+#include "teximage.h"
+#include "texgen.h"
+#include "texobj.h"
+#include "texparam.h"
+#include "texstate.h"
+#include "texturebarrier.h"
+#include "transformfeedback.h"
+#include "mtypes.h"
+#include "varray.h"
+#include "viewport.h"
+#if FEATURE_NV_vertex_program || FEATURE_NV_fragment_program
+#include "nvprogram.h"
+#endif
+#if FEATURE_ARB_shader_objects
+#include "shaderapi.h"
+#include "uniforms.h"
+#endif
+#include "syncobj.h"
+#include "main/dispatch.h"
+
+
+#if FEATURE_GL
+
+
+/**
+ * Initialize a dispatch table with pointers to Mesa's immediate-mode
+ * commands.
+ *
+ * Pointers to glBegin()/glEnd() object commands and a few others
+ * are provided via the GLvertexformat interface.
+ *
+ * \param ctx  GL context to which \c exec belongs.
+ * \param exec dispatch table.
+ */
+struct _glapi_table *
+_mesa_create_exec_table(void)
+{
+   struct _glapi_table *exec;
+
+   exec = _mesa_alloc_dispatch_table(_gloffset_COUNT);
+   if (exec == NULL)
+      return NULL;
+
+#if _HAVE_FULL_GL
+   _mesa_loopback_init_api_table( exec );
+#endif
+
+   /* load the dispatch slots we understand */
+   SET_AlphaFunc(exec, _mesa_AlphaFunc);
+   SET_BlendFunc(exec, _mesa_BlendFunc);
+   SET_Clear(exec, _mesa_Clear);
+   SET_ClearColor(exec, _mesa_ClearColor);
+   SET_ClearStencil(exec, _mesa_ClearStencil);
+   SET_ColorMask(exec, _mesa_ColorMask);
+   SET_CullFace(exec, _mesa_CullFace);
+   SET_Disable(exec, _mesa_Disable);
+#if FEATURE_draw_read_buffer
+   SET_DrawBuffer(exec, _mesa_DrawBuffer);
+   SET_ReadBuffer(exec, _mesa_ReadBuffer);
+#endif
+   SET_Enable(exec, _mesa_Enable);
+   SET_Finish(exec, _mesa_Finish);
+   SET_Flush(exec, _mesa_Flush);
+   SET_FrontFace(exec, _mesa_FrontFace);
+   SET_Frustum(exec, _mesa_Frustum);
+   SET_GetError(exec, _mesa_GetError);
+   SET_GetFloatv(exec, _mesa_GetFloatv);
+   SET_GetString(exec, _mesa_GetString);
+   SET_LineStipple(exec, _mesa_LineStipple);
+   SET_LineWidth(exec, _mesa_LineWidth);
+   SET_LoadIdentity(exec, _mesa_LoadIdentity);
+   SET_LoadMatrixf(exec, _mesa_LoadMatrixf);
+   SET_LogicOp(exec, _mesa_LogicOp);
+   SET_MatrixMode(exec, _mesa_MatrixMode);
+   SET_MultMatrixf(exec, _mesa_MultMatrixf);
+   SET_Ortho(exec, _mesa_Ortho);
+   SET_PixelStorei(exec, _mesa_PixelStorei);
+   SET_PopMatrix(exec, _mesa_PopMatrix);
+   SET_PushMatrix(exec, _mesa_PushMatrix);
+   SET_Rotatef(exec, _mesa_Rotatef);
+   SET_Scalef(exec, _mesa_Scalef);
+   SET_Scissor(exec, _mesa_Scissor);
+   SET_ShadeModel(exec, _mesa_ShadeModel);
+   SET_StencilFunc(exec, _mesa_StencilFunc);
+   SET_StencilMask(exec, _mesa_StencilMask);
+   SET_StencilOp(exec, _mesa_StencilOp);
+   SET_TexEnvfv(exec, _mesa_TexEnvfv);
+   SET_TexEnvi(exec, _mesa_TexEnvi);
+   SET_TexImage2D(exec, _mesa_TexImage2D);
+   SET_TexParameteri(exec, _mesa_TexParameteri);
+   SET_Translatef(exec, _mesa_Translatef);
+   SET_Viewport(exec, _mesa_Viewport);
+
+   _mesa_init_accum_dispatch(exec);
+   _mesa_init_dlist_dispatch(exec);
+
+   SET_ClearDepth(exec, _mesa_ClearDepth);
+   SET_ClearIndex(exec, _mesa_ClearIndex);
+   SET_ClipPlane(exec, _mesa_ClipPlane);
+   SET_ColorMaterial(exec, _mesa_ColorMaterial);
+   SET_DepthFunc(exec, _mesa_DepthFunc);
+   SET_DepthMask(exec, _mesa_DepthMask);
+   SET_DepthRange(exec, _mesa_DepthRange);
+
+   _mesa_init_drawpix_dispatch(exec);
+   _mesa_init_feedback_dispatch(exec);
+
+   SET_FogCoordPointerEXT(exec, _mesa_FogCoordPointerEXT);
+   SET_Fogf(exec, _mesa_Fogf);
+   SET_Fogfv(exec, _mesa_Fogfv);
+   SET_Fogi(exec, _mesa_Fogi);
+   SET_Fogiv(exec, _mesa_Fogiv);
+   SET_GetClipPlane(exec, _mesa_GetClipPlane);
+   SET_GetBooleanv(exec, _mesa_GetBooleanv);
+   SET_GetDoublev(exec, _mesa_GetDoublev);
+   SET_GetIntegerv(exec, _mesa_GetIntegerv);
+   SET_GetLightfv(exec, _mesa_GetLightfv);
+   SET_GetLightiv(exec, _mesa_GetLightiv);
+   SET_GetMaterialfv(exec, _mesa_GetMaterialfv);
+   SET_GetMaterialiv(exec, _mesa_GetMaterialiv);
+   SET_GetPolygonStipple(exec, _mesa_GetPolygonStipple);
+   SET_GetTexEnvfv(exec, _mesa_GetTexEnvfv);
+   SET_GetTexEnviv(exec, _mesa_GetTexEnviv);
+   SET_GetTexLevelParameterfv(exec, _mesa_GetTexLevelParameterfv);
+   SET_GetTexLevelParameteriv(exec, _mesa_GetTexLevelParameteriv);
+   SET_GetTexParameterfv(exec, _mesa_GetTexParameterfv);
+   SET_GetTexParameteriv(exec, _mesa_GetTexParameteriv);
+   SET_GetTexImage(exec, _mesa_GetTexImage);
+   SET_Hint(exec, _mesa_Hint);
+   SET_IndexMask(exec, _mesa_IndexMask);
+   SET_IsEnabled(exec, _mesa_IsEnabled);
+   SET_LightModelf(exec, _mesa_LightModelf);
+   SET_LightModelfv(exec, _mesa_LightModelfv);
+   SET_LightModeli(exec, _mesa_LightModeli);
+   SET_LightModeliv(exec, _mesa_LightModeliv);
+   SET_Lightf(exec, _mesa_Lightf);
+   SET_Lightfv(exec, _mesa_Lightfv);
+   SET_Lighti(exec, _mesa_Lighti);
+   SET_Lightiv(exec, _mesa_Lightiv);
+   SET_LoadMatrixd(exec, _mesa_LoadMatrixd);
+
+   _mesa_init_eval_dispatch(exec);
+
+   SET_MultMatrixd(exec, _mesa_MultMatrixd);
+
+   _mesa_init_pixel_dispatch(exec);
+
+   SET_PixelStoref(exec, _mesa_PixelStoref);
+   SET_PointSize(exec, _mesa_PointSize);
+   SET_PolygonMode(exec, _mesa_PolygonMode);
+   SET_PolygonOffset(exec, _mesa_PolygonOffset);
+   SET_PolygonStipple(exec, _mesa_PolygonStipple);
+
+   _mesa_init_attrib_dispatch(exec);
+   _mesa_init_rastpos_dispatch(exec);
+
+   SET_ReadPixels(exec, _mesa_ReadPixels);
+   SET_Rotated(exec, _mesa_Rotated);
+   SET_Scaled(exec, _mesa_Scaled);
+   SET_SecondaryColorPointerEXT(exec, _mesa_SecondaryColorPointerEXT);
+   SET_TexEnvf(exec, _mesa_TexEnvf);
+   SET_TexEnviv(exec, _mesa_TexEnviv);
+
+   _mesa_init_texgen_dispatch(exec);
+
+   SET_TexImage1D(exec, _mesa_TexImage1D);
+   SET_TexParameterf(exec, _mesa_TexParameterf);
+   SET_TexParameterfv(exec, _mesa_TexParameterfv);
+   SET_TexParameteriv(exec, _mesa_TexParameteriv);
+   SET_Translated(exec, _mesa_Translated);
+
+   /* 1.1 */
+   SET_BindTexture(exec, _mesa_BindTexture);
+   SET_DeleteTextures(exec, _mesa_DeleteTextures);
+   SET_GenTextures(exec, _mesa_GenTextures);
+#if _HAVE_FULL_GL
+   SET_AreTexturesResident(exec, _mesa_AreTexturesResident);
+   SET_ColorPointer(exec, _mesa_ColorPointer);
+   SET_CopyTexImage1D(exec, _mesa_CopyTexImage1D);
+   SET_CopyTexImage2D(exec, _mesa_CopyTexImage2D);
+   SET_CopyTexSubImage1D(exec, _mesa_CopyTexSubImage1D);
+   SET_CopyTexSubImage2D(exec, _mesa_CopyTexSubImage2D);
+   SET_DisableClientState(exec, _mesa_DisableClientState);
+   SET_EdgeFlagPointer(exec, _mesa_EdgeFlagPointer);
+   SET_EnableClientState(exec, _mesa_EnableClientState);
+   SET_GetPointerv(exec, _mesa_GetPointerv);
+   SET_IndexPointer(exec, _mesa_IndexPointer);
+   SET_InterleavedArrays(exec, _mesa_InterleavedArrays);
+   SET_IsTexture(exec, _mesa_IsTexture);
+   SET_NormalPointer(exec, _mesa_NormalPointer);
+   SET_PrioritizeTextures(exec, _mesa_PrioritizeTextures);
+   SET_TexCoordPointer(exec, _mesa_TexCoordPointer);
+   SET_TexSubImage1D(exec, _mesa_TexSubImage1D);
+   SET_TexSubImage2D(exec, _mesa_TexSubImage2D);
+   SET_VertexPointer(exec, _mesa_VertexPointer);
+#endif
+
+   /* 1.2 */
+#if _HAVE_FULL_GL
+   SET_CopyTexSubImage3D(exec, _mesa_CopyTexSubImage3D);
+   SET_TexImage3D(exec, _mesa_TexImage3D);
+   SET_TexSubImage3D(exec, _mesa_TexSubImage3D);
+#endif
+
+   /* OpenGL 1.2  GL_ARB_imaging */
+   SET_BlendColor(exec, _mesa_BlendColor);
+   SET_BlendEquation(exec, _mesa_BlendEquation);
+   SET_BlendEquationSeparateEXT(exec, _mesa_BlendEquationSeparateEXT);
+
+   _mesa_init_colortable_dispatch(exec);
+   _mesa_init_convolve_dispatch(exec);
+   _mesa_init_histogram_dispatch(exec);
+
+   /* OpenGL 2.0 */
+   SET_StencilFuncSeparate(exec, _mesa_StencilFuncSeparate);
+   SET_StencilMaskSeparate(exec, _mesa_StencilMaskSeparate);
+   SET_StencilOpSeparate(exec, _mesa_StencilOpSeparate);
+
+#if FEATURE_ARB_shader_objects
+   _mesa_init_shader_dispatch(exec);
+   _mesa_init_shader_uniform_dispatch(exec);
+#endif
+
+   /* 2. GL_EXT_blend_color */
+#if 0
+/*    SET_BlendColorEXT(exec, _mesa_BlendColorEXT); */
+#endif
+
+   /* 3. GL_EXT_polygon_offset */
+#if _HAVE_FULL_GL
+   SET_PolygonOffsetEXT(exec, _mesa_PolygonOffsetEXT);
+#endif
+
+   /* 6. GL_EXT_texture3d */
+#if 0
+/*    SET_CopyTexSubImage3DEXT(exec, _mesa_CopyTexSubImage3D); */
+/*    SET_TexImage3DEXT(exec, _mesa_TexImage3DEXT); */
+/*    SET_TexSubImage3DEXT(exec, _mesa_TexSubImage3D); */
+#endif
+
+   /* 11. GL_EXT_histogram */
+#if 0
+   SET_GetHistogramEXT(exec, _mesa_GetHistogram);
+   SET_GetHistogramParameterfvEXT(exec, _mesa_GetHistogramParameterfv);
+   SET_GetHistogramParameterivEXT(exec, _mesa_GetHistogramParameteriv);
+   SET_GetMinmaxEXT(exec, _mesa_GetMinmax);
+   SET_GetMinmaxParameterfvEXT(exec, _mesa_GetMinmaxParameterfv);
+   SET_GetMinmaxParameterivEXT(exec, _mesa_GetMinmaxParameteriv);
+#endif
+
+   /* 14. SGI_color_table */
+#if 0
+   SET_ColorTableSGI(exec, _mesa_ColorTable);
+   SET_ColorSubTableSGI(exec, _mesa_ColorSubTable);
+   SET_GetColorTableSGI(exec, _mesa_GetColorTable);
+   SET_GetColorTableParameterfvSGI(exec, _mesa_GetColorTableParameterfv);
+   SET_GetColorTableParameterivSGI(exec, _mesa_GetColorTableParameteriv);
+#endif
+
+   /* 30. GL_EXT_vertex_array */
+#if _HAVE_FULL_GL
+   SET_ColorPointerEXT(exec, _mesa_ColorPointerEXT);
+   SET_EdgeFlagPointerEXT(exec, _mesa_EdgeFlagPointerEXT);
+   SET_IndexPointerEXT(exec, _mesa_IndexPointerEXT);
+   SET_NormalPointerEXT(exec, _mesa_NormalPointerEXT);
+   SET_TexCoordPointerEXT(exec, _mesa_TexCoordPointerEXT);
+   SET_VertexPointerEXT(exec, _mesa_VertexPointerEXT);
+#endif
+
+   /* 37. GL_EXT_blend_minmax */
+#if 0
+   SET_BlendEquationEXT(exec, _mesa_BlendEquationEXT);
+#endif
+
+   /* 54. GL_EXT_point_parameters */
+#if _HAVE_FULL_GL
+   SET_PointParameterfEXT(exec, _mesa_PointParameterf);
+   SET_PointParameterfvEXT(exec, _mesa_PointParameterfv);
+#endif
+
+   /* 95. GL_ARB_ES2_compatibility */
+   SET_ClearDepthf(exec, _mesa_ClearDepthf);
+   SET_DepthRangef(exec, _mesa_DepthRangef);
+
+   /* 97. GL_EXT_compiled_vertex_array */
+#if _HAVE_FULL_GL
+   SET_LockArraysEXT(exec, _mesa_LockArraysEXT);
+   SET_UnlockArraysEXT(exec, _mesa_UnlockArraysEXT);
+#endif
+
+   /* 148. GL_EXT_multi_draw_arrays */
+#if _HAVE_FULL_GL
+   SET_MultiDrawArraysEXT(exec, _mesa_MultiDrawArraysEXT);
+#endif
+
+   /* 173. GL_INGR_blend_func_separate */
+#if _HAVE_FULL_GL
+   SET_BlendFuncSeparateEXT(exec, _mesa_BlendFuncSeparateEXT);
+#endif
+
+   /* 196. GL_MESA_resize_buffers */
+#if _HAVE_FULL_GL
+   SET_ResizeBuffersMESA(exec, _mesa_ResizeBuffersMESA);
+#endif
+
+   /* 197. GL_MESA_window_pos */
+   /* part of _mesa_init_rastpos_dispatch(exec); */
+
+   /* 200. GL_IBM_multimode_draw_arrays */
+#if _HAVE_FULL_GL
+   SET_MultiModeDrawArraysIBM(exec, _mesa_MultiModeDrawArraysIBM);
+   SET_MultiModeDrawElementsIBM(exec, _mesa_MultiModeDrawElementsIBM);
+#endif
+
+   /* 233. GL_NV_vertex_program */
+#if FEATURE_NV_vertex_program
+   SET_BindProgramNV(exec, _mesa_BindProgram);
+   SET_DeleteProgramsNV(exec, _mesa_DeletePrograms);
+   SET_ExecuteProgramNV(exec, _mesa_ExecuteProgramNV);
+   SET_GenProgramsNV(exec, _mesa_GenPrograms);
+   SET_AreProgramsResidentNV(exec, _mesa_AreProgramsResidentNV);
+   SET_RequestResidentProgramsNV(exec, _mesa_RequestResidentProgramsNV);
+   SET_GetProgramParameterfvNV(exec, _mesa_GetProgramParameterfvNV);
+   SET_GetProgramParameterdvNV(exec, _mesa_GetProgramParameterdvNV);
+   SET_GetProgramivNV(exec, _mesa_GetProgramivNV);
+   SET_GetProgramStringNV(exec, _mesa_GetProgramStringNV);
+   SET_GetTrackMatrixivNV(exec, _mesa_GetTrackMatrixivNV);
+   SET_GetVertexAttribdvNV(exec, _mesa_GetVertexAttribdvNV);
+   SET_GetVertexAttribfvNV(exec, _mesa_GetVertexAttribfvNV);
+   SET_GetVertexAttribivNV(exec, _mesa_GetVertexAttribivNV);
+   SET_GetVertexAttribPointervNV(exec, _mesa_GetVertexAttribPointervNV);
+   SET_IsProgramNV(exec, _mesa_IsProgramARB);
+   SET_LoadProgramNV(exec, _mesa_LoadProgramNV);
+   SET_ProgramEnvParameter4dARB(exec, _mesa_ProgramEnvParameter4dARB); /* alias to ProgramParameter4dNV */
+   SET_ProgramEnvParameter4dvARB(exec, _mesa_ProgramEnvParameter4dvARB);  /* alias to ProgramParameter4dvNV */
+   SET_ProgramEnvParameter4fARB(exec, _mesa_ProgramEnvParameter4fARB);  /* alias to ProgramParameter4fNV */
+   SET_ProgramEnvParameter4fvARB(exec, _mesa_ProgramEnvParameter4fvARB);  /* alias to ProgramParameter4fvNV */
+   SET_ProgramParameters4dvNV(exec, _mesa_ProgramParameters4dvNV);
+   SET_ProgramParameters4fvNV(exec, _mesa_ProgramParameters4fvNV);
+   SET_TrackMatrixNV(exec, _mesa_TrackMatrixNV);
+   SET_VertexAttribPointerNV(exec, _mesa_VertexAttribPointerNV);
+   /* glVertexAttrib*NV functions handled in api_loopback.c */
+#endif
+
+   /* 273. GL_APPLE_vertex_array_object */
+   SET_BindVertexArrayAPPLE(exec, _mesa_BindVertexArrayAPPLE);
+   SET_DeleteVertexArraysAPPLE(exec, _mesa_DeleteVertexArraysAPPLE);
+   SET_GenVertexArraysAPPLE(exec, _mesa_GenVertexArraysAPPLE);
+   SET_IsVertexArrayAPPLE(exec, _mesa_IsVertexArrayAPPLE);
+
+   /* 282. GL_NV_fragment_program */
+#if FEATURE_NV_fragment_program
+   SET_ProgramNamedParameter4fNV(exec, _mesa_ProgramNamedParameter4fNV);
+   SET_ProgramNamedParameter4dNV(exec, _mesa_ProgramNamedParameter4dNV);
+   SET_ProgramNamedParameter4fvNV(exec, _mesa_ProgramNamedParameter4fvNV);
+   SET_ProgramNamedParameter4dvNV(exec, _mesa_ProgramNamedParameter4dvNV);
+   SET_GetProgramNamedParameterfvNV(exec, _mesa_GetProgramNamedParameterfvNV);
+   SET_GetProgramNamedParameterdvNV(exec, _mesa_GetProgramNamedParameterdvNV);
+   SET_ProgramLocalParameter4dARB(exec, _mesa_ProgramLocalParameter4dARB);
+   SET_ProgramLocalParameter4dvARB(exec, _mesa_ProgramLocalParameter4dvARB);
+   SET_ProgramLocalParameter4fARB(exec, _mesa_ProgramLocalParameter4fARB);
+   SET_ProgramLocalParameter4fvARB(exec, _mesa_ProgramLocalParameter4fvARB);
+   SET_GetProgramLocalParameterdvARB(exec, _mesa_GetProgramLocalParameterdvARB);
+   SET_GetProgramLocalParameterfvARB(exec, _mesa_GetProgramLocalParameterfvARB);
+#endif
+
+   /* 262. GL_NV_point_sprite */
+#if _HAVE_FULL_GL
+   SET_PointParameteriNV(exec, _mesa_PointParameteri);
+   SET_PointParameterivNV(exec, _mesa_PointParameteriv);
+#endif
+
+   /* 268. GL_EXT_stencil_two_side */
+#if _HAVE_FULL_GL
+   SET_ActiveStencilFaceEXT(exec, _mesa_ActiveStencilFaceEXT);
+#endif
+
+   /* 285. GL_NV_primitive_restart */
+   SET_PrimitiveRestartIndexNV(exec, _mesa_PrimitiveRestartIndex);
+
+   /* ???. GL_EXT_depth_bounds_test */
+   SET_DepthBoundsEXT(exec, _mesa_DepthBoundsEXT);
+
+   /* 352. GL_EXT_transform_feedback */
+   _mesa_init_transform_feedback_dispatch(exec);
+
+   /* 364. GL_EXT_provoking_vertex */
+   SET_ProvokingVertexEXT(exec, _mesa_ProvokingVertexEXT);
+
+   /* ARB 1. GL_ARB_multitexture */
+#if _HAVE_FULL_GL
+   SET_ActiveTextureARB(exec, _mesa_ActiveTextureARB);
+   SET_ClientActiveTextureARB(exec, _mesa_ClientActiveTextureARB);
+#endif
+
+   /* ARB 3. GL_ARB_transpose_matrix */
+#if _HAVE_FULL_GL
+   SET_LoadTransposeMatrixdARB(exec, _mesa_LoadTransposeMatrixdARB);
+   SET_LoadTransposeMatrixfARB(exec, _mesa_LoadTransposeMatrixfARB);
+   SET_MultTransposeMatrixdARB(exec, _mesa_MultTransposeMatrixdARB);
+   SET_MultTransposeMatrixfARB(exec, _mesa_MultTransposeMatrixfARB);
+#endif
+
+   /* ARB 5. GL_ARB_multisample */
+#if _HAVE_FULL_GL
+   SET_SampleCoverageARB(exec, _mesa_SampleCoverageARB);
+#endif
+
+   /* ARB 12. GL_ARB_texture_compression */
+#if _HAVE_FULL_GL
+   SET_CompressedTexImage3DARB(exec, _mesa_CompressedTexImage3DARB);
+   SET_CompressedTexImage2DARB(exec, _mesa_CompressedTexImage2DARB);
+   SET_CompressedTexImage1DARB(exec, _mesa_CompressedTexImage1DARB);
+   SET_CompressedTexSubImage3DARB(exec, _mesa_CompressedTexSubImage3DARB);
+   SET_CompressedTexSubImage2DARB(exec, _mesa_CompressedTexSubImage2DARB);
+   SET_CompressedTexSubImage1DARB(exec, _mesa_CompressedTexSubImage1DARB);
+   SET_GetCompressedTexImageARB(exec, _mesa_GetCompressedTexImageARB);
+#endif
+
+   /* ARB 14. GL_ARB_point_parameters */
+   /* reuse EXT_point_parameters functions */
+
+   /* ARB 26. GL_ARB_vertex_program */
+   /* ARB 27. GL_ARB_fragment_program */
+#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
+   /* glVertexAttrib1sARB aliases glVertexAttrib1sNV */
+   /* glVertexAttrib1fARB aliases glVertexAttrib1fNV */
+   /* glVertexAttrib1dARB aliases glVertexAttrib1dNV */
+   /* glVertexAttrib2sARB aliases glVertexAttrib2sNV */
+   /* glVertexAttrib2fARB aliases glVertexAttrib2fNV */
+   /* glVertexAttrib2dARB aliases glVertexAttrib2dNV */
+   /* glVertexAttrib3sARB aliases glVertexAttrib3sNV */
+   /* glVertexAttrib3fARB aliases glVertexAttrib3fNV */
+   /* glVertexAttrib3dARB aliases glVertexAttrib3dNV */
+   /* glVertexAttrib4sARB aliases glVertexAttrib4sNV */
+   /* glVertexAttrib4fARB aliases glVertexAttrib4fNV */
+   /* glVertexAttrib4dARB aliases glVertexAttrib4dNV */
+   /* glVertexAttrib4NubARB aliases glVertexAttrib4NubNV */
+   /* glVertexAttrib1svARB aliases glVertexAttrib1svNV */
+   /* glVertexAttrib1fvARB aliases glVertexAttrib1fvNV */
+   /* glVertexAttrib1dvARB aliases glVertexAttrib1dvNV */
+   /* glVertexAttrib2svARB aliases glVertexAttrib2svNV */
+   /* glVertexAttrib2fvARB aliases glVertexAttrib2fvNV */
+   /* glVertexAttrib2dvARB aliases glVertexAttrib2dvNV */
+   /* glVertexAttrib3svARB aliases glVertexAttrib3svNV */
+   /* glVertexAttrib3fvARB aliases glVertexAttrib3fvNV */
+   /* glVertexAttrib3dvARB aliases glVertexAttrib3dvNV */
+   /* glVertexAttrib4svARB aliases glVertexAttrib4svNV */
+   /* glVertexAttrib4fvARB aliases glVertexAttrib4fvNV */
+   /* glVertexAttrib4dvARB aliases glVertexAttrib4dvNV */
+   /* glVertexAttrib4NubvARB aliases glVertexAttrib4NubvNV */
+   /* glVertexAttrib4bvARB handled in api_loopback.c */
+   /* glVertexAttrib4ivARB handled in api_loopback.c */
+   /* glVertexAttrib4ubvARB handled in api_loopback.c */
+   /* glVertexAttrib4usvARB handled in api_loopback.c */
+   /* glVertexAttrib4uivARB handled in api_loopback.c */
+   /* glVertexAttrib4NbvARB handled in api_loopback.c */
+   /* glVertexAttrib4NsvARB handled in api_loopback.c */
+   /* glVertexAttrib4NivARB handled in api_loopback.c */
+   /* glVertexAttrib4NusvARB handled in api_loopback.c */
+   /* glVertexAttrib4NuivARB handled in api_loopback.c */
+   SET_VertexAttribPointerARB(exec, _mesa_VertexAttribPointerARB);
+   SET_EnableVertexAttribArrayARB(exec, _mesa_EnableVertexAttribArrayARB);
+   SET_DisableVertexAttribArrayARB(exec, _mesa_DisableVertexAttribArrayARB);
+   SET_ProgramStringARB(exec, _mesa_ProgramStringARB);
+   /* glBindProgramARB aliases glBindProgramNV */
+   /* glDeleteProgramsARB aliases glDeleteProgramsNV */
+   /* glGenProgramsARB aliases glGenProgramsNV */
+   /* glIsProgramARB aliases glIsProgramNV */
+   SET_GetVertexAttribdvARB(exec, _mesa_GetVertexAttribdvARB);
+   SET_GetVertexAttribfvARB(exec, _mesa_GetVertexAttribfvARB);
+   SET_GetVertexAttribivARB(exec, _mesa_GetVertexAttribivARB);
+   /* glGetVertexAttribPointervARB aliases glGetVertexAttribPointervNV */
+   SET_ProgramEnvParameter4dARB(exec, _mesa_ProgramEnvParameter4dARB);
+   SET_ProgramEnvParameter4dvARB(exec, _mesa_ProgramEnvParameter4dvARB);
+   SET_ProgramEnvParameter4fARB(exec, _mesa_ProgramEnvParameter4fARB);
+   SET_ProgramEnvParameter4fvARB(exec, _mesa_ProgramEnvParameter4fvARB);
+   SET_ProgramLocalParameter4dARB(exec, _mesa_ProgramLocalParameter4dARB);
+   SET_ProgramLocalParameter4dvARB(exec, _mesa_ProgramLocalParameter4dvARB);
+   SET_ProgramLocalParameter4fARB(exec, _mesa_ProgramLocalParameter4fARB);
+   SET_ProgramLocalParameter4fvARB(exec, _mesa_ProgramLocalParameter4fvARB);
+   SET_GetProgramEnvParameterdvARB(exec, _mesa_GetProgramEnvParameterdvARB);
+   SET_GetProgramEnvParameterfvARB(exec, _mesa_GetProgramEnvParameterfvARB);
+   SET_GetProgramLocalParameterdvARB(exec, _mesa_GetProgramLocalParameterdvARB);
+   SET_GetProgramLocalParameterfvARB(exec, _mesa_GetProgramLocalParameterfvARB);
+   SET_GetProgramivARB(exec, _mesa_GetProgramivARB);
+   SET_GetProgramStringARB(exec, _mesa_GetProgramStringARB);
+#endif
+
+   /* ARB 28. GL_ARB_vertex_buffer_object */
+#if FEATURE_ARB_vertex_buffer_object
+   SET_BindBufferARB(exec, _mesa_BindBufferARB);
+   SET_BufferDataARB(exec, _mesa_BufferDataARB);
+   SET_BufferSubDataARB(exec, _mesa_BufferSubDataARB);
+   SET_DeleteBuffersARB(exec, _mesa_DeleteBuffersARB);
+   SET_GenBuffersARB(exec, _mesa_GenBuffersARB);
+   SET_GetBufferParameterivARB(exec, _mesa_GetBufferParameterivARB);
+   SET_GetBufferPointervARB(exec, _mesa_GetBufferPointervARB);
+   SET_GetBufferSubDataARB(exec, _mesa_GetBufferSubDataARB);
+   SET_IsBufferARB(exec, _mesa_IsBufferARB);
+   SET_MapBufferARB(exec, _mesa_MapBufferARB);
+   SET_UnmapBufferARB(exec, _mesa_UnmapBufferARB);
+#endif
+
+   /* ARB 29. GL_ARB_occlusion_query */
+   _mesa_init_queryobj_dispatch(exec);
+
+   /* ARB 37. GL_ARB_draw_buffers */
+#if FEATURE_draw_read_buffer
+   SET_DrawBuffersARB(exec, _mesa_DrawBuffersARB);
+#endif
+
+   /* GL_ARB_sync */
+   _mesa_init_sync_dispatch(exec);
+
+  /* GL_ATI_fragment_shader */
+   _mesa_init_ati_fragment_shader_dispatch(exec);
+
+  /* GL_ATI_envmap_bumpmap */
+   SET_GetTexBumpParameterivATI(exec, _mesa_GetTexBumpParameterivATI);
+   SET_GetTexBumpParameterfvATI(exec, _mesa_GetTexBumpParameterfvATI);
+   SET_TexBumpParameterivATI(exec, _mesa_TexBumpParameterivATI);
+   SET_TexBumpParameterfvATI(exec, _mesa_TexBumpParameterfvATI);
+
+#if FEATURE_EXT_framebuffer_object
+   SET_IsRenderbufferEXT(exec, _mesa_IsRenderbufferEXT);
+   SET_BindRenderbufferEXT(exec, _mesa_BindRenderbufferEXT);
+   SET_DeleteRenderbuffersEXT(exec, _mesa_DeleteRenderbuffersEXT);
+   SET_GenRenderbuffersEXT(exec, _mesa_GenRenderbuffersEXT);
+   SET_RenderbufferStorageEXT(exec, _mesa_RenderbufferStorageEXT);
+   SET_GetRenderbufferParameterivEXT(exec, _mesa_GetRenderbufferParameterivEXT);
+   SET_IsFramebufferEXT(exec, _mesa_IsFramebufferEXT);
+   SET_BindFramebufferEXT(exec, _mesa_BindFramebufferEXT);
+   SET_DeleteFramebuffersEXT(exec, _mesa_DeleteFramebuffersEXT);
+   SET_GenFramebuffersEXT(exec, _mesa_GenFramebuffersEXT);
+   SET_CheckFramebufferStatusEXT(exec, _mesa_CheckFramebufferStatusEXT);
+   SET_FramebufferTexture1DEXT(exec, _mesa_FramebufferTexture1DEXT);
+   SET_FramebufferTexture2DEXT(exec, _mesa_FramebufferTexture2DEXT);
+   SET_FramebufferTexture3DEXT(exec, _mesa_FramebufferTexture3DEXT);
+   SET_FramebufferRenderbufferEXT(exec, _mesa_FramebufferRenderbufferEXT);
+   SET_GetFramebufferAttachmentParameterivEXT(exec, _mesa_GetFramebufferAttachmentParameterivEXT);
+   SET_GenerateMipmapEXT(exec, _mesa_GenerateMipmapEXT);
+#endif
+
+#if FEATURE_EXT_framebuffer_blit
+   SET_BlitFramebufferEXT(exec, _mesa_BlitFramebufferEXT);
+#endif
+
+   /* GL_EXT_gpu_program_parameters */
+#if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
+   SET_ProgramEnvParameters4fvEXT(exec, _mesa_ProgramEnvParameters4fvEXT);
+   SET_ProgramLocalParameters4fvEXT(exec, _mesa_ProgramLocalParameters4fvEXT);
+#endif
+
+   /* GL_MESA_texture_array / GL_EXT_texture_array */
+#if FEATURE_EXT_framebuffer_object
+   SET_FramebufferTextureLayerEXT(exec, _mesa_FramebufferTextureLayerEXT);
+#endif
+
+   /* GL_ATI_separate_stencil */
+   SET_StencilFuncSeparateATI(exec, _mesa_StencilFuncSeparateATI);
+
+#if FEATURE_ARB_framebuffer_object
+   /* The ARB_fbo functions are the union of
+    * GL_EXT_fbo, GL_EXT_framebuffer_blit, GL_EXT_texture_array
+    */
+   SET_RenderbufferStorageMultisample(exec, _mesa_RenderbufferStorageMultisample);
+#endif
+
+#if FEATURE_ARB_map_buffer_range
+   SET_MapBufferRange(exec, _mesa_MapBufferRange);
+   SET_FlushMappedBufferRange(exec, _mesa_FlushMappedBufferRange);
+#endif
+
+   /* GL_ARB_copy_buffer */
+   SET_CopyBufferSubData(exec, _mesa_CopyBufferSubData);
+
+   /* GL_ARB_vertex_array_object */
+   SET_BindVertexArray(exec, _mesa_BindVertexArray);
+   SET_GenVertexArrays(exec, _mesa_GenVertexArrays);
+
+   /* GL_EXT_draw_buffers2 */
+   SET_ColorMaskIndexedEXT(exec, _mesa_ColorMaskIndexed);
+   SET_GetBooleanIndexedvEXT(exec, _mesa_GetBooleanIndexedv);
+   SET_GetIntegerIndexedvEXT(exec, _mesa_GetIntegerIndexedv);
+   SET_EnableIndexedEXT(exec, _mesa_EnableIndexed);
+   SET_DisableIndexedEXT(exec, _mesa_DisableIndexed);
+   SET_IsEnabledIndexedEXT(exec, _mesa_IsEnabledIndexed);
+
+   /* GL_NV_conditional_render */
+   SET_BeginConditionalRenderNV(exec, _mesa_BeginConditionalRender);
+   SET_EndConditionalRenderNV(exec, _mesa_EndConditionalRender);
+
+#if FEATURE_OES_EGL_image
+   SET_EGLImageTargetTexture2DOES(exec, _mesa_EGLImageTargetTexture2DOES);
+   SET_EGLImageTargetRenderbufferStorageOES(exec, _mesa_EGLImageTargetRenderbufferStorageOES);
+#endif
+
+#if FEATURE_APPLE_object_purgeable
+   SET_ObjectPurgeableAPPLE(exec, _mesa_ObjectPurgeableAPPLE);
+   SET_ObjectUnpurgeableAPPLE(exec, _mesa_ObjectUnpurgeableAPPLE);
+   SET_GetObjectParameterivAPPLE(exec, _mesa_GetObjectParameterivAPPLE);
+#endif
+
+#if FEATURE_ARB_geometry_shader4
+   SET_FramebufferTextureARB(exec, _mesa_FramebufferTextureARB);
+   SET_FramebufferTextureFaceARB(exec, _mesa_FramebufferTextureFaceARB);
+#endif
+
+   SET_ClampColorARB(exec, _mesa_ClampColorARB);
+
+   /* GL_EXT_texture_integer */
+   SET_ClearColorIiEXT(exec, _mesa_ClearColorIiEXT);
+   SET_ClearColorIuiEXT(exec, _mesa_ClearColorIuiEXT);
+   SET_GetTexParameterIivEXT(exec, _mesa_GetTexParameterIiv);
+   SET_GetTexParameterIuivEXT(exec, _mesa_GetTexParameterIuiv);
+   SET_TexParameterIivEXT(exec, _mesa_TexParameterIiv);
+   SET_TexParameterIuivEXT(exec, _mesa_TexParameterIuiv);
+
+   /* GL_EXT_gpu_shader4 / OpenGL 3.0 */
+   SET_GetVertexAttribIivEXT(exec, _mesa_GetVertexAttribIiv);
+   SET_GetVertexAttribIuivEXT(exec, _mesa_GetVertexAttribIuiv);
+   SET_VertexAttribIPointerEXT(exec, _mesa_VertexAttribIPointer);
+
+   /* GL 3.0 (functions not covered by other extensions) */
+   SET_ClearBufferiv(exec, _mesa_ClearBufferiv);
+   SET_ClearBufferuiv(exec, _mesa_ClearBufferuiv);
+   SET_ClearBufferfv(exec, _mesa_ClearBufferfv);
+   SET_ClearBufferfi(exec, _mesa_ClearBufferfi);
+   SET_GetStringi(exec, _mesa_GetStringi);
+   SET_ClampColor(exec, _mesa_ClampColorARB);
+
+   /* GL_ARB_instanced_arrays */
+   SET_VertexAttribDivisorARB(exec, _mesa_VertexAttribDivisor);
+
+   /* GL_ARB_draw_buffer_blend */
+   SET_BlendFunciARB(exec, _mesa_BlendFunci);
+   SET_BlendFuncSeparateiARB(exec, _mesa_BlendFuncSeparatei);
+   SET_BlendEquationiARB(exec, _mesa_BlendEquationi);
+   SET_BlendEquationSeparateiARB(exec, _mesa_BlendEquationSeparatei);
+
+   /* GL_NV_texture_barrier */
+   SET_TextureBarrierNV(exec, _mesa_TextureBarrierNV);
+ 
+   return exec;
+}
+
+#endif /* FEATURE_GL */
diff --git a/mesalib/src/mesa/main/attrib.c b/mesalib/src/mesa/main/attrib.c
index ae7f633b8..340c06c97 100644
--- a/mesalib/src/mesa/main/attrib.c
+++ b/mesalib/src/mesa/main/attrib.c
@@ -879,10 +879,10 @@ _mesa_PopAttrib(void)
 
                color = (const struct gl_colorbuffer_attrib *) attr->data;
                _mesa_ClearIndex((GLfloat) color->ClearIndex);
-               _mesa_ClearColor(color->ClearColor[0],
-                                color->ClearColor[1],
-                                color->ClearColor[2],
-                                color->ClearColor[3]);
+               _mesa_ClearColor(color->ClearColorUnclamped[0],
+                                color->ClearColorUnclamped[1],
+                                color->ClearColorUnclamped[2],
+                                color->ClearColorUnclamped[3]);
                _mesa_IndexMask(color->IndexMask);
                if (!ctx->Extensions.EXT_draw_buffers2) {
                   _mesa_ColorMask((GLboolean) (color->ColorMask[0][0] != 0),
@@ -930,7 +930,7 @@ _mesa_PopAttrib(void)
                      _mesa_DrawBuffer(color->DrawBuffer[0]);
                }
                _mesa_set_enable(ctx, GL_ALPHA_TEST, color->AlphaEnabled);
-               _mesa_AlphaFunc(color->AlphaFunc, color->AlphaRef);
+               _mesa_AlphaFunc(color->AlphaFunc, color->AlphaRefUnclamped);
                if (ctx->Color.BlendEnabled != color->BlendEnabled) {
                   if (ctx->Extensions.EXT_draw_buffers2) {
                      GLuint i;
@@ -976,16 +976,18 @@ _mesa_PopAttrib(void)
                                                  color->Blend[0].EquationA);
                   }
                }
-               _mesa_BlendColor(color->BlendColor[0],
-                                color->BlendColor[1],
-                                color->BlendColor[2],
-                                color->BlendColor[3]);
+               _mesa_BlendColor(color->BlendColorUnclamped[0],
+                                color->BlendColorUnclamped[1],
+                                color->BlendColorUnclamped[2],
+                                color->BlendColorUnclamped[3]);
                _mesa_LogicOp(color->LogicOp);
                _mesa_set_enable(ctx, GL_COLOR_LOGIC_OP,
                                 color->ColorLogicOpEnabled);
                _mesa_set_enable(ctx, GL_INDEX_LOGIC_OP,
                                 color->IndexLogicOpEnabled);
                _mesa_set_enable(ctx, GL_DITHER, color->DitherFlag);
+               _mesa_ClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, color->ClampFragmentColor);
+               _mesa_ClampColorARB(GL_CLAMP_READ_COLOR_ARB, color->ClampReadColor);
             }
             break;
          case GL_CURRENT_BIT:
@@ -1108,6 +1110,7 @@ _mesa_PopAttrib(void)
                /* materials */
                memcpy(&ctx->Light.Material, &light->Material,
                       sizeof(struct gl_material));
+               _mesa_ClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, light->ClampVertexColor);
             }
             break;
          case GL_LINE_BIT:
diff --git a/mesalib/src/mesa/main/blend.c b/mesalib/src/mesa/main/blend.c
index c74a16803..95c101c34 100644
--- a/mesalib/src/mesa/main/blend.c
+++ b/mesalib/src/mesa/main/blend.c
@@ -513,19 +513,24 @@ _mesa_BlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
    GET_CURRENT_CONTEXT(ctx);
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   tmp[0] = CLAMP( red,   0.0F, 1.0F );
-   tmp[1] = CLAMP( green, 0.0F, 1.0F );
-   tmp[2] = CLAMP( blue,  0.0F, 1.0F );
-   tmp[3] = CLAMP( alpha, 0.0F, 1.0F );
+   tmp[0] = red;
+   tmp[1] = green;
+   tmp[2] = blue;
+   tmp[3] = alpha;
 
-   if (TEST_EQ_4V(tmp, ctx->Color.BlendColor))
+   if (TEST_EQ_4V(tmp, ctx->Color.BlendColorUnclamped))
       return;
 
    FLUSH_VERTICES(ctx, _NEW_COLOR);
-   COPY_4FV( ctx->Color.BlendColor, tmp );
+   COPY_4FV( ctx->Color.BlendColorUnclamped, tmp );
+
+   ctx->Color.BlendColor[0] = CLAMP(tmp[0], 0.0F, 1.0F);
+   ctx->Color.BlendColor[1] = CLAMP(tmp[1], 0.0F, 1.0F);
+   ctx->Color.BlendColor[2] = CLAMP(tmp[2], 0.0F, 1.0F);
+   ctx->Color.BlendColor[3] = CLAMP(tmp[3], 0.0F, 1.0F);
 
    if (ctx->Driver.BlendColor)
-      (*ctx->Driver.BlendColor)(ctx, tmp);
+      (*ctx->Driver.BlendColor)(ctx, ctx->Color.BlendColor);
 }
 
 
@@ -558,17 +563,16 @@ _mesa_AlphaFunc( GLenum func, GLclampf ref )
    case GL_NOTEQUAL:
    case GL_GEQUAL:
    case GL_ALWAYS:
-      ref = CLAMP(ref, 0.0F, 1.0F);
-
-      if (ctx->Color.AlphaFunc == func && ctx->Color.AlphaRef == ref)
+      if (ctx->Color.AlphaFunc == func && ctx->Color.AlphaRefUnclamped == ref)
          return; /* no change */
 
       FLUSH_VERTICES(ctx, _NEW_COLOR);
       ctx->Color.AlphaFunc = func;
-      ctx->Color.AlphaRef = ref;
+      ctx->Color.AlphaRefUnclamped = ref;
+      ctx->Color.AlphaRef = CLAMP(ref, 0.0F, 1.0F);
 
       if (ctx->Driver.AlphaFunc)
-         ctx->Driver.AlphaFunc(ctx, func, ref);
+         ctx->Driver.AlphaFunc(ctx, func, ctx->Color.AlphaRef);
       return;
 
    default:
@@ -737,7 +741,7 @@ _mesa_ColorMaskIndexed( GLuint buf, GLboolean red, GLboolean green,
 }
 
 
-extern void GLAPIENTRY
+void GLAPIENTRY
 _mesa_ClampColorARB(GLenum target, GLenum clamp)
 {
    GET_CURRENT_CONTEXT(ctx);
@@ -751,12 +755,15 @@ _mesa_ClampColorARB(GLenum target, GLenum clamp)
 
    switch (target) {
    case GL_CLAMP_VERTEX_COLOR_ARB:
+      FLUSH_VERTICES(ctx, _NEW_LIGHT);
       ctx->Light.ClampVertexColor = clamp;
       break;
    case GL_CLAMP_FRAGMENT_COLOR_ARB:
+      FLUSH_VERTICES(ctx, _NEW_FRAG_CLAMP);
       ctx->Color.ClampFragmentColor = clamp;
       break;
    case GL_CLAMP_READ_COLOR_ARB:
+      FLUSH_VERTICES(ctx, _NEW_COLOR);
       ctx->Color.ClampReadColor = clamp;
       break;
    default:
@@ -789,6 +796,7 @@ void _mesa_init_color( struct gl_context * ctx )
    memset(ctx->Color.ColorMask, 0xff, sizeof(ctx->Color.ColorMask));
    ctx->Color.ClearIndex = 0;
    ASSIGN_4V( ctx->Color.ClearColor, 0, 0, 0, 0 );
+   ASSIGN_4V( ctx->Color.ClearColorUnclamped, 0, 0, 0, 0 );
    ctx->Color.AlphaEnabled = GL_FALSE;
    ctx->Color.AlphaFunc = GL_ALWAYS;
    ctx->Color.AlphaRef = 0;
@@ -802,6 +810,7 @@ void _mesa_init_color( struct gl_context * ctx )
       ctx->Color.Blend[i].EquationA = GL_FUNC_ADD;
    }
    ASSIGN_4V( ctx->Color.BlendColor, 0.0, 0.0, 0.0, 0.0 );
+   ASSIGN_4V( ctx->Color.BlendColorUnclamped, 0.0, 0.0, 0.0, 0.0 );
    ctx->Color.IndexLogicOpEnabled = GL_FALSE;
    ctx->Color.ColorLogicOpEnabled = GL_FALSE;
    ctx->Color._LogicOpEnabled = GL_FALSE;
@@ -816,7 +825,9 @@ void _mesa_init_color( struct gl_context * ctx )
    }
 
    ctx->Color.ClampFragmentColor = GL_FIXED_ONLY_ARB;
+   ctx->Color._ClampFragmentColor = GL_TRUE;
    ctx->Color.ClampReadColor = GL_FIXED_ONLY_ARB;
+   ctx->Color._ClampReadColor = GL_TRUE;
 }
 
 /*@}*/
diff --git a/mesalib/src/mesa/main/clear.c b/mesalib/src/mesa/main/clear.c
index ca831476b..fa95e4522 100644
--- a/mesalib/src/mesa/main/clear.c
+++ b/mesalib/src/mesa/main/clear.c
@@ -1,567 +1,575 @@
-/*

- * Mesa 3-D graphics library

- * Version:  7.1

- *

- * Copyright (C) 1999-2007  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.

- */

-

-

-/**

- * \file clear.c

- * glClearColor, glClearIndex, glClear() functions.

- */

-

-

-

-#include "glheader.h"

-#include "clear.h"

-#include "context.h"

-#include "colormac.h"

-#include "enums.h"

-#include "macros.h"

-#include "mtypes.h"

-#include "state.h"

-

-

-

-#if _HAVE_FULL_GL

-void GLAPIENTRY

-_mesa_ClearIndex( GLfloat c )

-{

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   if (ctx->Color.ClearIndex == (GLuint) c)

-      return;

-

-   FLUSH_VERTICES(ctx, _NEW_COLOR);

-   ctx->Color.ClearIndex = (GLuint) c;

-}

-#endif

-

-

-/**

- * Specify the clear values for the color buffers.

- *

- * \param red red color component.

- * \param green green color component.

- * \param blue blue color component.

- * \param alpha alpha component.

- *

- * \sa glClearColor().

- *

- * Clamps the parameters and updates gl_colorbuffer_attrib::ClearColor.  On a

- * change, flushes the vertices and notifies the driver via the

- * dd_function_table::ClearColor callback.

- */

-void GLAPIENTRY

-_mesa_ClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )

-{

-   GLfloat tmp[4];

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   tmp[0] = CLAMP(red,   0.0F, 1.0F);

-   tmp[1] = CLAMP(green, 0.0F, 1.0F);

-   tmp[2] = CLAMP(blue,  0.0F, 1.0F);

-   tmp[3] = CLAMP(alpha, 0.0F, 1.0F);

-

-   if (TEST_EQ_4V(tmp, ctx->Color.ClearColor))

-      return; /* no change */

-

-   FLUSH_VERTICES(ctx, _NEW_COLOR);

-   COPY_4V(ctx->Color.ClearColor, tmp);

-

-   if (ctx->Driver.ClearColor) {

-      /* it's OK to call glClearColor in CI mode but it should be a NOP */

-      (*ctx->Driver.ClearColor)(ctx, ctx->Color.ClearColor);

-   }

-}

-

-

-/**

- * GL_EXT_texture_integer

- */

-void GLAPIENTRY

-_mesa_ClearColorIiEXT(GLint r, GLint g, GLint b, GLint a)

-{

-   GLfloat tmp[4];

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   tmp[0] = (GLfloat) r;

-   tmp[1] = (GLfloat) g;

-   tmp[2] = (GLfloat) b;

-   tmp[3] = (GLfloat) a;

-

-   if (TEST_EQ_4V(tmp, ctx->Color.ClearColor))

-      return; /* no change */

-

-   FLUSH_VERTICES(ctx, _NEW_COLOR);

-

-   /* XXX we should eventually have a float/int/uint union for

-    * the ctx->Color.ClearColor state.

-    */

-   COPY_4V(ctx->Color.ClearColor, tmp);

-

-   if (ctx->Driver.ClearColor) {

-      ctx->Driver.ClearColor(ctx, ctx->Color.ClearColor);

-   }

-}

-

-

-/**

- * GL_EXT_texture_integer

- */

-void GLAPIENTRY

-_mesa_ClearColorIuiEXT(GLuint r, GLuint g, GLuint b, GLuint a)

-{

-   GLfloat tmp[4];

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   tmp[0] = (GLfloat) r;

-   tmp[1] = (GLfloat) g;

-   tmp[2] = (GLfloat) b;

-   tmp[3] = (GLfloat) a;

-

-   if (TEST_EQ_4V(tmp, ctx->Color.ClearColor))

-      return; /* no change */

-

-   FLUSH_VERTICES(ctx, _NEW_COLOR);

-

-   /* XXX we should eventually have a float/int/uint union for

-    * the ctx->Color.ClearColor state.

-    */

-   COPY_4V(ctx->Color.ClearColor, tmp);

-

-   if (ctx->Driver.ClearColor) {

-      ctx->Driver.ClearColor(ctx, ctx->Color.ClearColor);

-   }

-}

-

-

-/**

- * Clear buffers.

- * 

- * \param mask bit-mask indicating the buffers to be cleared.

- *

- * Flushes the vertices and verifies the parameter. If __struct gl_contextRec::NewState

- * is set then calls _mesa_update_state() to update gl_frame_buffer::_Xmin,

- * etc. If the rasterization mode is set to GL_RENDER then requests the driver

- * to clear the buffers, via the dd_function_table::Clear callback.

- */ 

-void GLAPIENTRY

-_mesa_Clear( GLbitfield mask )

-{

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

-

-   FLUSH_CURRENT(ctx, 0);

-

-   if (MESA_VERBOSE & VERBOSE_API)

-      _mesa_debug(ctx, "glClear 0x%x\n", mask);

-

-   if (mask & ~(GL_COLOR_BUFFER_BIT |

-                GL_DEPTH_BUFFER_BIT |

-                GL_STENCIL_BUFFER_BIT |

-                GL_ACCUM_BUFFER_BIT)) {

-      /* invalid bit set */

-      _mesa_error( ctx, GL_INVALID_VALUE, "glClear(0x%x)", mask);

-      return;

-   }

-

-   if (ctx->NewState) {

-      _mesa_update_state( ctx );	/* update _Xmin, etc */

-   }

-

-   if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {

-      _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,

-                  "glClear(incomplete framebuffer)");

-      return;

-   }

-

-   if (ctx->DrawBuffer->Width == 0 || ctx->DrawBuffer->Height == 0 ||

-       ctx->DrawBuffer->_Xmin >= ctx->DrawBuffer->_Xmax ||

-       ctx->DrawBuffer->_Ymin >= ctx->DrawBuffer->_Ymax)

-      return;

-

-   if (ctx->RenderMode == GL_RENDER) {

-      GLbitfield bufferMask;

-

-      /* don't clear depth buffer if depth writing disabled */

-      if (!ctx->Depth.Mask)

-         mask &= ~GL_DEPTH_BUFFER_BIT;

-

-      /* Build the bitmask to send to device driver's Clear function.

-       * Note that the GL_COLOR_BUFFER_BIT flag will expand to 0, 1, 2 or 4

-       * of the BUFFER_BIT_FRONT/BACK_LEFT/RIGHT flags, or one of the

-       * BUFFER_BIT_COLORn flags.

-       */

-      bufferMask = 0;

-      if (mask & GL_COLOR_BUFFER_BIT) {

-         GLuint i;

-         for (i = 0; i < ctx->DrawBuffer->_NumColorDrawBuffers; i++) {

-            bufferMask |= (1 << ctx->DrawBuffer->_ColorDrawBufferIndexes[i]);

-         }

-      }

-

-      if ((mask & GL_DEPTH_BUFFER_BIT)

-          && ctx->DrawBuffer->Visual.haveDepthBuffer) {

-         bufferMask |= BUFFER_BIT_DEPTH;

-      }

-

-      if ((mask & GL_STENCIL_BUFFER_BIT)

-          && ctx->DrawBuffer->Visual.haveStencilBuffer) {

-         bufferMask |= BUFFER_BIT_STENCIL;

-      }

-

-      if ((mask & GL_ACCUM_BUFFER_BIT)

-          && ctx->DrawBuffer->Visual.haveAccumBuffer) {

-         bufferMask |= BUFFER_BIT_ACCUM;

-      }

-

-      ASSERT(ctx->Driver.Clear);

-      ctx->Driver.Clear(ctx, bufferMask);

-   }

-}

-

-

-/** Returned by make_color_buffer_mask() for errors */

-#define INVALID_MASK ~0x0

-

-

-/**

- * Convert the glClearBuffer 'drawbuffer' parameter into a bitmask of

- * BUFFER_BIT_x values.

- * Return INVALID_MASK if the drawbuffer value is invalid.

- */

-static GLbitfield

-make_color_buffer_mask(struct gl_context *ctx, GLint drawbuffer)

-{

-   const struct gl_renderbuffer_attachment *att = ctx->DrawBuffer->Attachment;

-   GLbitfield mask = 0x0;

-

-   switch (drawbuffer) {

-   case GL_FRONT:

-      if (att[BUFFER_FRONT_LEFT].Renderbuffer)

-         mask |= BUFFER_BIT_FRONT_LEFT;

-      if (att[BUFFER_FRONT_RIGHT].Renderbuffer)

-         mask |= BUFFER_BIT_FRONT_RIGHT;

-      break;

-   case GL_BACK:

-      if (att[BUFFER_BACK_LEFT].Renderbuffer)

-         mask |= BUFFER_BIT_BACK_LEFT;

-      if (att[BUFFER_BACK_RIGHT].Renderbuffer)

-         mask |= BUFFER_BIT_BACK_RIGHT;

-      break;

-   case GL_LEFT:

-      if (att[BUFFER_FRONT_LEFT].Renderbuffer)

-         mask |= BUFFER_BIT_FRONT_LEFT;

-      if (att[BUFFER_BACK_LEFT].Renderbuffer)

-         mask |= BUFFER_BIT_BACK_LEFT;

-      break;

-   case GL_RIGHT:

-      if (att[BUFFER_FRONT_RIGHT].Renderbuffer)

-         mask |= BUFFER_BIT_FRONT_RIGHT;

-      if (att[BUFFER_BACK_RIGHT].Renderbuffer)

-         mask |= BUFFER_BIT_BACK_RIGHT;

-      break;

-   case GL_FRONT_AND_BACK:

-      if (att[BUFFER_FRONT_LEFT].Renderbuffer)

-         mask |= BUFFER_BIT_FRONT_LEFT;

-      if (att[BUFFER_BACK_LEFT].Renderbuffer)

-         mask |= BUFFER_BIT_BACK_LEFT;

-      if (att[BUFFER_FRONT_RIGHT].Renderbuffer)

-         mask |= BUFFER_BIT_FRONT_RIGHT;

-      if (att[BUFFER_BACK_RIGHT].Renderbuffer)

-         mask |= BUFFER_BIT_BACK_RIGHT;

-      break;

-   default:

-      if (drawbuffer < 0 || drawbuffer >= (GLint)ctx->Const.MaxDrawBuffers) {

-         mask = INVALID_MASK;

-      }

-      else if (att[BUFFER_COLOR0 + drawbuffer].Renderbuffer) {

-         mask |= (BUFFER_BIT_COLOR0 << drawbuffer);

-      }

-   }

-

-   return mask;

-}

-

-

-

-/**

- * New in GL 3.0

- * Clear signed integer color buffer or stencil buffer (not depth).

- */

-void GLAPIENTRY

-_mesa_ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

-

-   FLUSH_CURRENT(ctx, 0);

-

-   if (ctx->NewState) {

-      _mesa_update_state( ctx );

-   }

-

-   switch (buffer) {

-   case GL_STENCIL:

-      if (drawbuffer != 0) {

-         _mesa_error(ctx, GL_INVALID_VALUE, "glClearBufferiv(drawbuffer=%d)",

-                     drawbuffer);

-         return;

-      }

-      else {

-         /* Save current stencil clear value, set to 'value', do the

-          * stencil clear and restore the clear value.

-          * XXX in the future we may have a new ctx->Driver.ClearBuffer()

-          * hook instead.

-          */

-         const GLuint clearSave = ctx->Stencil.Clear;

-         ctx->Stencil.Clear = *value;

-         if (ctx->Driver.ClearStencil)

-            ctx->Driver.ClearStencil(ctx, *value);

-         ctx->Driver.Clear(ctx, BUFFER_BIT_STENCIL);

-         ctx->Stencil.Clear = clearSave;

-         if (ctx->Driver.ClearStencil)

-            ctx->Driver.ClearStencil(ctx, clearSave);

-      }

-      break;

-   case GL_COLOR:

-      {

-         const GLbitfield mask = make_color_buffer_mask(ctx, drawbuffer);

-         if (mask == INVALID_MASK) {

-            _mesa_error(ctx, GL_INVALID_VALUE, "glClearBufferiv(drawbuffer=%d)",

-                        drawbuffer);

-            return;

-         }

-         else if (mask) {

-            /* XXX note: we're putting the integer clear values into the

-             * floating point state var.  This will not always work.  We'll

-             * need a new ctx->Driver.ClearBuffer() hook....

-             */

-            GLclampf clearSave[4];

-            /* save color */

-            COPY_4V(clearSave, ctx->Color.ClearColor);

-            /* set color */

-            COPY_4V_CAST(ctx->Color.ClearColor, value, GLclampf);

-            if (ctx->Driver.ClearColor)

-               ctx->Driver.ClearColor(ctx, ctx->Color.ClearColor);

-            /* clear buffer(s) */

-            ctx->Driver.Clear(ctx, mask);

-            /* restore color */

-            COPY_4V(ctx->Color.ClearColor, clearSave);

-            if (ctx->Driver.ClearColor)

-               ctx->Driver.ClearColor(ctx, clearSave);

-         }

-      }

-      break;

-   default:

-      _mesa_error(ctx, GL_INVALID_ENUM, "glClearBufferiv(buffer=%s)",

-                  _mesa_lookup_enum_by_nr(buffer));

-      return;

-   }

-}

-

-

-/**

- * New in GL 3.0

- * Clear unsigned integer color buffer (not depth, not stencil).

- */

-void GLAPIENTRY

-_mesa_ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

-

-   FLUSH_CURRENT(ctx, 0);

-

-   if (ctx->NewState) {

-      _mesa_update_state( ctx );

-   }

-

-   switch (buffer) {

-   case GL_COLOR:

-      {

-         const GLbitfield mask = make_color_buffer_mask(ctx, drawbuffer);

-         if (mask == INVALID_MASK) {

-            _mesa_error(ctx, GL_INVALID_VALUE, "glClearBufferuiv(drawbuffer=%d)",

-                        drawbuffer);

-            return;

-         }

-         else if (mask) {

-            /* XXX note: we're putting the uint clear values into the

-             * floating point state var.  This will not always work.  We'll

-             * need a new ctx->Driver.ClearBuffer() hook....

-             */

-            GLclampf clearSave[4];

-            /* save color */

-            COPY_4V(clearSave, ctx->Color.ClearColor);

-            /* set color */

-            COPY_4V_CAST(ctx->Color.ClearColor, value, GLclampf);

-            if (ctx->Driver.ClearColor)

-               ctx->Driver.ClearColor(ctx, ctx->Color.ClearColor);

-            /* clear buffer(s) */

-            ctx->Driver.Clear(ctx, mask);

-            /* restore color */

-            COPY_4V(ctx->Color.ClearColor, clearSave);

-            if (ctx->Driver.ClearColor)

-               ctx->Driver.ClearColor(ctx, clearSave);

-         }

-      }

-      break;

-   default:

-      _mesa_error(ctx, GL_INVALID_ENUM, "glClearBufferuiv(buffer=%s)",

-                  _mesa_lookup_enum_by_nr(buffer));

-      return;

-   }

-}

-

-

-/**

- * New in GL 3.0

- * Clear fixed-pt or float color buffer or depth buffer (not stencil).

- */

-void GLAPIENTRY

-_mesa_ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

-

-   FLUSH_CURRENT(ctx, 0);

-

-   if (ctx->NewState) {

-      _mesa_update_state( ctx );

-   }

-

-   switch (buffer) {

-   case GL_DEPTH:

-      if (drawbuffer != 0) {

-         _mesa_error(ctx, GL_INVALID_VALUE, "glClearBufferfv(drawbuffer=%d)",

-                     drawbuffer);

-         return;

-      }

-      else {

-         /* Save current depth clear value, set to 'value', do the

-          * depth clear and restore the clear value.

-          * XXX in the future we may have a new ctx->Driver.ClearBuffer()

-          * hook instead.

-          */

-         const GLclampd clearSave = ctx->Depth.Clear;

-         ctx->Depth.Clear = *value;

-         if (ctx->Driver.ClearDepth)

-            ctx->Driver.ClearDepth(ctx, *value);

-         ctx->Driver.Clear(ctx, BUFFER_BIT_DEPTH);

-         ctx->Depth.Clear = clearSave;

-         if (ctx->Driver.ClearDepth)

-            ctx->Driver.ClearDepth(ctx, clearSave);

-      }

-      /* clear depth buffer to value */

-      break;

-   case GL_COLOR:

-      {

-         const GLbitfield mask = make_color_buffer_mask(ctx, drawbuffer);

-         if (mask == INVALID_MASK) {

-            _mesa_error(ctx, GL_INVALID_VALUE, "glClearBufferfv(drawbuffer=%d)",

-                        drawbuffer);

-            return;

-         }

-         else if (mask) {

-            GLclampf clearSave[4];

-            /* save color */

-            COPY_4V(clearSave, ctx->Color.ClearColor);

-            /* set color */

-            COPY_4V_CAST(ctx->Color.ClearColor, value, GLclampf);

-            if (ctx->Driver.ClearColor)

-               ctx->Driver.ClearColor(ctx, ctx->Color.ClearColor);

-            /* clear buffer(s) */

-            ctx->Driver.Clear(ctx, mask);

-            /* restore color */

-            COPY_4V(ctx->Color.ClearColor, clearSave);

-            if (ctx->Driver.ClearColor)

-               ctx->Driver.ClearColor(ctx, clearSave);

-         }

-      }

-      break;

-   default:

-      _mesa_error(ctx, GL_INVALID_ENUM, "glClearBufferfv(buffer=%s)",

-                  _mesa_lookup_enum_by_nr(buffer));

-      return;

-   }

-}

-

-

-/**

- * New in GL 3.0

- * Clear depth/stencil buffer only.

- */

-void GLAPIENTRY

-_mesa_ClearBufferfi(GLenum buffer, GLint drawbuffer,

-                    GLfloat depth, GLint stencil)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

-

-   FLUSH_CURRENT(ctx, 0);

-

-   if (buffer != GL_DEPTH_STENCIL) {

-      _mesa_error(ctx, GL_INVALID_ENUM, "glClearBufferfi(buffer=%s)",

-                  _mesa_lookup_enum_by_nr(buffer));

-      return;

-   }

-

-   if (drawbuffer != 0) {

-      _mesa_error(ctx, GL_INVALID_VALUE, "glClearBufferfi(drawbuffer=%d)",

-                  drawbuffer);

-      return;

-   }

-

-   if (ctx->NewState) {

-      _mesa_update_state( ctx );

-   }

-

-   {

-      /* save current clear values */

-      const GLclampd clearDepthSave = ctx->Depth.Clear;

-      const GLuint clearStencilSave = ctx->Stencil.Clear;

-

-      /* set new clear values */

-      ctx->Depth.Clear = depth;

-      ctx->Stencil.Clear = stencil;

-      if (ctx->Driver.ClearDepth)

-         ctx->Driver.ClearDepth(ctx, depth);

-      if (ctx->Driver.ClearStencil)

-         ctx->Driver.ClearStencil(ctx, stencil);

-

-      /* clear buffers */

-      ctx->Driver.Clear(ctx, BUFFER_BIT_DEPTH | BUFFER_BIT_STENCIL);

-

-      /* restore */

-      ctx->Depth.Clear = clearDepthSave;

-      ctx->Stencil.Clear = clearStencilSave;

-      if (ctx->Driver.ClearDepth)

-         ctx->Driver.ClearDepth(ctx, clearDepthSave);

-      if (ctx->Driver.ClearStencil)

-         ctx->Driver.ClearStencil(ctx, clearStencilSave);

-   }

-}

+/*
+ * Mesa 3-D graphics library
+ * Version:  7.1
+ *
+ * Copyright (C) 1999-2007  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.
+ */
+
+
+/**
+ * \file clear.c
+ * glClearColor, glClearIndex, glClear() functions.
+ */
+
+
+
+#include "glheader.h"
+#include "clear.h"
+#include "context.h"
+#include "colormac.h"
+#include "enums.h"
+#include "macros.h"
+#include "mtypes.h"
+#include "state.h"
+
+
+
+#if _HAVE_FULL_GL
+void GLAPIENTRY
+_mesa_ClearIndex( GLfloat c )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (ctx->Color.ClearIndex == (GLuint) c)
+      return;
+
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+   ctx->Color.ClearIndex = (GLuint) c;
+}
+#endif
+
+
+/**
+ * Specify the clear values for the color buffers.
+ *
+ * \param red red color component.
+ * \param green green color component.
+ * \param blue blue color component.
+ * \param alpha alpha component.
+ *
+ * \sa glClearColor().
+ *
+ * Clamps the parameters and updates gl_colorbuffer_attrib::ClearColor.  On a
+ * change, flushes the vertices and notifies the driver via the
+ * dd_function_table::ClearColor callback.
+ */
+void GLAPIENTRY
+_mesa_ClearColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
+{
+   GLfloat tmp[4];
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   tmp[0] = red;
+   tmp[1] = green;
+   tmp[2] = blue;
+   tmp[3] = alpha;
+
+   if (TEST_EQ_4V(tmp, ctx->Color.ClearColorUnclamped))
+      return; /* no change */
+
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+   COPY_4V(ctx->Color.ClearColorUnclamped, tmp);
+
+   ctx->Color.ClearColor[0] = CLAMP(tmp[0], 0.0F, 1.0F);
+   ctx->Color.ClearColor[1] = CLAMP(tmp[1], 0.0F, 1.0F);
+   ctx->Color.ClearColor[2] = CLAMP(tmp[2], 0.0F, 1.0F);
+   ctx->Color.ClearColor[3] = CLAMP(tmp[3], 0.0F, 1.0F);
+
+   if (ctx->Driver.ClearColor) {
+      /* it's OK to call glClearColor in CI mode but it should be a NOP */
+      /* we pass the clamped color, since all drivers that need this don't
+       * support GL_ARB_color_buffer_float
+       */
+      (*ctx->Driver.ClearColor)(ctx, ctx->Color.ClearColor);
+   }
+}
+
+
+/**
+ * GL_EXT_texture_integer
+ */
+void GLAPIENTRY
+_mesa_ClearColorIiEXT(GLint r, GLint g, GLint b, GLint a)
+{
+   GLfloat tmp[4];
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   tmp[0] = (GLfloat) r;
+   tmp[1] = (GLfloat) g;
+   tmp[2] = (GLfloat) b;
+   tmp[3] = (GLfloat) a;
+
+   if (TEST_EQ_4V(tmp, ctx->Color.ClearColor))
+      return; /* no change */
+
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+
+   /* XXX we should eventually have a float/int/uint union for
+    * the ctx->Color.ClearColor state.
+    */
+   COPY_4V(ctx->Color.ClearColor, tmp);
+
+   if (ctx->Driver.ClearColor) {
+      ctx->Driver.ClearColor(ctx, ctx->Color.ClearColor);
+   }
+}
+
+
+/**
+ * GL_EXT_texture_integer
+ */
+void GLAPIENTRY
+_mesa_ClearColorIuiEXT(GLuint r, GLuint g, GLuint b, GLuint a)
+{
+   GLfloat tmp[4];
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   tmp[0] = (GLfloat) r;
+   tmp[1] = (GLfloat) g;
+   tmp[2] = (GLfloat) b;
+   tmp[3] = (GLfloat) a;
+
+   if (TEST_EQ_4V(tmp, ctx->Color.ClearColor))
+      return; /* no change */
+
+   FLUSH_VERTICES(ctx, _NEW_COLOR);
+
+   /* XXX we should eventually have a float/int/uint union for
+    * the ctx->Color.ClearColor state.
+    */
+   COPY_4V(ctx->Color.ClearColor, tmp);
+
+   if (ctx->Driver.ClearColor) {
+      ctx->Driver.ClearColor(ctx, ctx->Color.ClearColor);
+   }
+}
+
+
+/**
+ * Clear buffers.
+ * 
+ * \param mask bit-mask indicating the buffers to be cleared.
+ *
+ * Flushes the vertices and verifies the parameter. If __struct gl_contextRec::NewState
+ * is set then calls _mesa_update_state() to update gl_frame_buffer::_Xmin,
+ * etc. If the rasterization mode is set to GL_RENDER then requests the driver
+ * to clear the buffers, via the dd_function_table::Clear callback.
+ */ 
+void GLAPIENTRY
+_mesa_Clear( GLbitfield mask )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   FLUSH_CURRENT(ctx, 0);
+
+   if (MESA_VERBOSE & VERBOSE_API)
+      _mesa_debug(ctx, "glClear 0x%x\n", mask);
+
+   if (mask & ~(GL_COLOR_BUFFER_BIT |
+                GL_DEPTH_BUFFER_BIT |
+                GL_STENCIL_BUFFER_BIT |
+                GL_ACCUM_BUFFER_BIT)) {
+      /* invalid bit set */
+      _mesa_error( ctx, GL_INVALID_VALUE, "glClear(0x%x)", mask);
+      return;
+   }
+
+   if (ctx->NewState) {
+      _mesa_update_state( ctx );	/* update _Xmin, etc */
+   }
+
+   if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
+      _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
+                  "glClear(incomplete framebuffer)");
+      return;
+   }
+
+   if (ctx->DrawBuffer->Width == 0 || ctx->DrawBuffer->Height == 0 ||
+       ctx->DrawBuffer->_Xmin >= ctx->DrawBuffer->_Xmax ||
+       ctx->DrawBuffer->_Ymin >= ctx->DrawBuffer->_Ymax)
+      return;
+
+   if (ctx->RenderMode == GL_RENDER) {
+      GLbitfield bufferMask;
+
+      /* don't clear depth buffer if depth writing disabled */
+      if (!ctx->Depth.Mask)
+         mask &= ~GL_DEPTH_BUFFER_BIT;
+
+      /* Build the bitmask to send to device driver's Clear function.
+       * Note that the GL_COLOR_BUFFER_BIT flag will expand to 0, 1, 2 or 4
+       * of the BUFFER_BIT_FRONT/BACK_LEFT/RIGHT flags, or one of the
+       * BUFFER_BIT_COLORn flags.
+       */
+      bufferMask = 0;
+      if (mask & GL_COLOR_BUFFER_BIT) {
+         GLuint i;
+         for (i = 0; i < ctx->DrawBuffer->_NumColorDrawBuffers; i++) {
+            bufferMask |= (1 << ctx->DrawBuffer->_ColorDrawBufferIndexes[i]);
+         }
+      }
+
+      if ((mask & GL_DEPTH_BUFFER_BIT)
+          && ctx->DrawBuffer->Visual.haveDepthBuffer) {
+         bufferMask |= BUFFER_BIT_DEPTH;
+      }
+
+      if ((mask & GL_STENCIL_BUFFER_BIT)
+          && ctx->DrawBuffer->Visual.haveStencilBuffer) {
+         bufferMask |= BUFFER_BIT_STENCIL;
+      }
+
+      if ((mask & GL_ACCUM_BUFFER_BIT)
+          && ctx->DrawBuffer->Visual.haveAccumBuffer) {
+         bufferMask |= BUFFER_BIT_ACCUM;
+      }
+
+      ASSERT(ctx->Driver.Clear);
+      ctx->Driver.Clear(ctx, bufferMask);
+   }
+}
+
+
+/** Returned by make_color_buffer_mask() for errors */
+#define INVALID_MASK ~0x0
+
+
+/**
+ * Convert the glClearBuffer 'drawbuffer' parameter into a bitmask of
+ * BUFFER_BIT_x values.
+ * Return INVALID_MASK if the drawbuffer value is invalid.
+ */
+static GLbitfield
+make_color_buffer_mask(struct gl_context *ctx, GLint drawbuffer)
+{
+   const struct gl_renderbuffer_attachment *att = ctx->DrawBuffer->Attachment;
+   GLbitfield mask = 0x0;
+
+   switch (drawbuffer) {
+   case GL_FRONT:
+      if (att[BUFFER_FRONT_LEFT].Renderbuffer)
+         mask |= BUFFER_BIT_FRONT_LEFT;
+      if (att[BUFFER_FRONT_RIGHT].Renderbuffer)
+         mask |= BUFFER_BIT_FRONT_RIGHT;
+      break;
+   case GL_BACK:
+      if (att[BUFFER_BACK_LEFT].Renderbuffer)
+         mask |= BUFFER_BIT_BACK_LEFT;
+      if (att[BUFFER_BACK_RIGHT].Renderbuffer)
+         mask |= BUFFER_BIT_BACK_RIGHT;
+      break;
+   case GL_LEFT:
+      if (att[BUFFER_FRONT_LEFT].Renderbuffer)
+         mask |= BUFFER_BIT_FRONT_LEFT;
+      if (att[BUFFER_BACK_LEFT].Renderbuffer)
+         mask |= BUFFER_BIT_BACK_LEFT;
+      break;
+   case GL_RIGHT:
+      if (att[BUFFER_FRONT_RIGHT].Renderbuffer)
+         mask |= BUFFER_BIT_FRONT_RIGHT;
+      if (att[BUFFER_BACK_RIGHT].Renderbuffer)
+         mask |= BUFFER_BIT_BACK_RIGHT;
+      break;
+   case GL_FRONT_AND_BACK:
+      if (att[BUFFER_FRONT_LEFT].Renderbuffer)
+         mask |= BUFFER_BIT_FRONT_LEFT;
+      if (att[BUFFER_BACK_LEFT].Renderbuffer)
+         mask |= BUFFER_BIT_BACK_LEFT;
+      if (att[BUFFER_FRONT_RIGHT].Renderbuffer)
+         mask |= BUFFER_BIT_FRONT_RIGHT;
+      if (att[BUFFER_BACK_RIGHT].Renderbuffer)
+         mask |= BUFFER_BIT_BACK_RIGHT;
+      break;
+   default:
+      if (drawbuffer < 0 || drawbuffer >= (GLint)ctx->Const.MaxDrawBuffers) {
+         mask = INVALID_MASK;
+      }
+      else if (att[BUFFER_COLOR0 + drawbuffer].Renderbuffer) {
+         mask |= (BUFFER_BIT_COLOR0 << drawbuffer);
+      }
+   }
+
+   return mask;
+}
+
+
+
+/**
+ * New in GL 3.0
+ * Clear signed integer color buffer or stencil buffer (not depth).
+ */
+void GLAPIENTRY
+_mesa_ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   FLUSH_CURRENT(ctx, 0);
+
+   if (ctx->NewState) {
+      _mesa_update_state( ctx );
+   }
+
+   switch (buffer) {
+   case GL_STENCIL:
+      if (drawbuffer != 0) {
+         _mesa_error(ctx, GL_INVALID_VALUE, "glClearBufferiv(drawbuffer=%d)",
+                     drawbuffer);
+         return;
+      }
+      else {
+         /* Save current stencil clear value, set to 'value', do the
+          * stencil clear and restore the clear value.
+          * XXX in the future we may have a new ctx->Driver.ClearBuffer()
+          * hook instead.
+          */
+         const GLuint clearSave = ctx->Stencil.Clear;
+         ctx->Stencil.Clear = *value;
+         if (ctx->Driver.ClearStencil)
+            ctx->Driver.ClearStencil(ctx, *value);
+         ctx->Driver.Clear(ctx, BUFFER_BIT_STENCIL);
+         ctx->Stencil.Clear = clearSave;
+         if (ctx->Driver.ClearStencil)
+            ctx->Driver.ClearStencil(ctx, clearSave);
+      }
+      break;
+   case GL_COLOR:
+      {
+         const GLbitfield mask = make_color_buffer_mask(ctx, drawbuffer);
+         if (mask == INVALID_MASK) {
+            _mesa_error(ctx, GL_INVALID_VALUE, "glClearBufferiv(drawbuffer=%d)",
+                        drawbuffer);
+            return;
+         }
+         else if (mask) {
+            /* XXX note: we're putting the integer clear values into the
+             * floating point state var.  This will not always work.  We'll
+             * need a new ctx->Driver.ClearBuffer() hook....
+             */
+            GLclampf clearSave[4];
+            /* save color */
+            COPY_4V(clearSave, ctx->Color.ClearColor);
+            /* set color */
+            COPY_4V_CAST(ctx->Color.ClearColor, value, GLclampf);
+            if (ctx->Driver.ClearColor)
+               ctx->Driver.ClearColor(ctx, ctx->Color.ClearColor);
+            /* clear buffer(s) */
+            ctx->Driver.Clear(ctx, mask);
+            /* restore color */
+            COPY_4V(ctx->Color.ClearColor, clearSave);
+            if (ctx->Driver.ClearColor)
+               ctx->Driver.ClearColor(ctx, clearSave);
+         }
+      }
+      break;
+   default:
+      _mesa_error(ctx, GL_INVALID_ENUM, "glClearBufferiv(buffer=%s)",
+                  _mesa_lookup_enum_by_nr(buffer));
+      return;
+   }
+}
+
+
+/**
+ * New in GL 3.0
+ * Clear unsigned integer color buffer (not depth, not stencil).
+ */
+void GLAPIENTRY
+_mesa_ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   FLUSH_CURRENT(ctx, 0);
+
+   if (ctx->NewState) {
+      _mesa_update_state( ctx );
+   }
+
+   switch (buffer) {
+   case GL_COLOR:
+      {
+         const GLbitfield mask = make_color_buffer_mask(ctx, drawbuffer);
+         if (mask == INVALID_MASK) {
+            _mesa_error(ctx, GL_INVALID_VALUE, "glClearBufferuiv(drawbuffer=%d)",
+                        drawbuffer);
+            return;
+         }
+         else if (mask) {
+            /* XXX note: we're putting the uint clear values into the
+             * floating point state var.  This will not always work.  We'll
+             * need a new ctx->Driver.ClearBuffer() hook....
+             */
+            GLclampf clearSave[4];
+            /* save color */
+            COPY_4V(clearSave, ctx->Color.ClearColor);
+            /* set color */
+            COPY_4V_CAST(ctx->Color.ClearColor, value, GLclampf);
+            if (ctx->Driver.ClearColor)
+               ctx->Driver.ClearColor(ctx, ctx->Color.ClearColor);
+            /* clear buffer(s) */
+            ctx->Driver.Clear(ctx, mask);
+            /* restore color */
+            COPY_4V(ctx->Color.ClearColor, clearSave);
+            if (ctx->Driver.ClearColor)
+               ctx->Driver.ClearColor(ctx, clearSave);
+         }
+      }
+      break;
+   default:
+      _mesa_error(ctx, GL_INVALID_ENUM, "glClearBufferuiv(buffer=%s)",
+                  _mesa_lookup_enum_by_nr(buffer));
+      return;
+   }
+}
+
+
+/**
+ * New in GL 3.0
+ * Clear fixed-pt or float color buffer or depth buffer (not stencil).
+ */
+void GLAPIENTRY
+_mesa_ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   FLUSH_CURRENT(ctx, 0);
+
+   if (ctx->NewState) {
+      _mesa_update_state( ctx );
+   }
+
+   switch (buffer) {
+   case GL_DEPTH:
+      if (drawbuffer != 0) {
+         _mesa_error(ctx, GL_INVALID_VALUE, "glClearBufferfv(drawbuffer=%d)",
+                     drawbuffer);
+         return;
+      }
+      else {
+         /* Save current depth clear value, set to 'value', do the
+          * depth clear and restore the clear value.
+          * XXX in the future we may have a new ctx->Driver.ClearBuffer()
+          * hook instead.
+          */
+         const GLclampd clearSave = ctx->Depth.Clear;
+         ctx->Depth.Clear = *value;
+         if (ctx->Driver.ClearDepth)
+            ctx->Driver.ClearDepth(ctx, *value);
+         ctx->Driver.Clear(ctx, BUFFER_BIT_DEPTH);
+         ctx->Depth.Clear = clearSave;
+         if (ctx->Driver.ClearDepth)
+            ctx->Driver.ClearDepth(ctx, clearSave);
+      }
+      /* clear depth buffer to value */
+      break;
+   case GL_COLOR:
+      {
+         const GLbitfield mask = make_color_buffer_mask(ctx, drawbuffer);
+         if (mask == INVALID_MASK) {
+            _mesa_error(ctx, GL_INVALID_VALUE, "glClearBufferfv(drawbuffer=%d)",
+                        drawbuffer);
+            return;
+         }
+         else if (mask) {
+            GLclampf clearSave[4];
+            /* save color */
+            COPY_4V(clearSave, ctx->Color.ClearColor);
+            /* set color */
+            COPY_4V_CAST(ctx->Color.ClearColor, value, GLclampf);
+            if (ctx->Driver.ClearColor)
+               ctx->Driver.ClearColor(ctx, ctx->Color.ClearColor);
+            /* clear buffer(s) */
+            ctx->Driver.Clear(ctx, mask);
+            /* restore color */
+            COPY_4V(ctx->Color.ClearColor, clearSave);
+            if (ctx->Driver.ClearColor)
+               ctx->Driver.ClearColor(ctx, clearSave);
+         }
+      }
+      break;
+   default:
+      _mesa_error(ctx, GL_INVALID_ENUM, "glClearBufferfv(buffer=%s)",
+                  _mesa_lookup_enum_by_nr(buffer));
+      return;
+   }
+}
+
+
+/**
+ * New in GL 3.0
+ * Clear depth/stencil buffer only.
+ */
+void GLAPIENTRY
+_mesa_ClearBufferfi(GLenum buffer, GLint drawbuffer,
+                    GLfloat depth, GLint stencil)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
+
+   FLUSH_CURRENT(ctx, 0);
+
+   if (buffer != GL_DEPTH_STENCIL) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glClearBufferfi(buffer=%s)",
+                  _mesa_lookup_enum_by_nr(buffer));
+      return;
+   }
+
+   if (drawbuffer != 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glClearBufferfi(drawbuffer=%d)",
+                  drawbuffer);
+      return;
+   }
+
+   if (ctx->NewState) {
+      _mesa_update_state( ctx );
+   }
+
+   {
+      /* save current clear values */
+      const GLclampd clearDepthSave = ctx->Depth.Clear;
+      const GLuint clearStencilSave = ctx->Stencil.Clear;
+
+      /* set new clear values */
+      ctx->Depth.Clear = depth;
+      ctx->Stencil.Clear = stencil;
+      if (ctx->Driver.ClearDepth)
+         ctx->Driver.ClearDepth(ctx, depth);
+      if (ctx->Driver.ClearStencil)
+         ctx->Driver.ClearStencil(ctx, stencil);
+
+      /* clear buffers */
+      ctx->Driver.Clear(ctx, BUFFER_BIT_DEPTH | BUFFER_BIT_STENCIL);
+
+      /* restore */
+      ctx->Depth.Clear = clearDepthSave;
+      ctx->Stencil.Clear = clearStencilSave;
+      if (ctx->Driver.ClearDepth)
+         ctx->Driver.ClearDepth(ctx, clearDepthSave);
+      if (ctx->Driver.ClearStencil)
+         ctx->Driver.ClearStencil(ctx, clearStencilSave);
+   }
+}
diff --git a/mesalib/src/mesa/main/colortab.c b/mesalib/src/mesa/main/colortab.c
index d0c865735..35b3096f6 100644
--- a/mesalib/src/mesa/main/colortab.c
+++ b/mesalib/src/mesa/main/colortab.c
@@ -516,6 +516,7 @@ _mesa_GetColorTable( GLenum target, GLenum format,
    struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
    struct gl_color_table *table = NULL;
    GLfloat rgba[MAX_COLOR_TABLE_SIZE][4];
+   GLbitfield transferOps = 0;
    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 
    if (ctx->NewState) {
@@ -618,8 +619,12 @@ _mesa_GetColorTable( GLenum target, GLenum format,
    if (!data)
       return;
 
+   /* TODO: is this correct? */
+   if(ctx->Color._ClampReadColor)
+      transferOps |= IMAGE_CLAMP_BIT;
+
    _mesa_pack_rgba_span_float(ctx, table->Size, rgba,
-                              format, type, data, &ctx->Pack, 0x0);
+                              format, type, data, &ctx->Pack, transferOps);
 
    _mesa_unmap_pbo_dest(ctx, &ctx->Pack);
 }
diff --git a/mesalib/src/mesa/main/dlist.c b/mesalib/src/mesa/main/dlist.c
index 3de6832d3..7e86f1d0e 100644
--- a/mesalib/src/mesa/main/dlist.c
+++ b/mesalib/src/mesa/main/dlist.c
@@ -388,6 +388,9 @@ typedef enum
    OPCODE_UNIFORM_3UIV,
    OPCODE_UNIFORM_4UIV,
 
+   /* GL_ARB_color_buffer_float */
+   OPCODE_CLAMP_COLOR,
+
    /* GL_EXT_framebuffer_blit */
    OPCODE_BLIT_FRAMEBUFFER,
 
@@ -6887,6 +6890,22 @@ save_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,
 }
 
 static void GLAPIENTRY
+save_ClampColorARB(GLenum target, GLenum clamp)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   Node *n;
+   ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
+   n = alloc_instruction(ctx, OPCODE_CLAMP_COLOR, 2);
+   if (n) {
+      n[1].e = target;
+      n[2].e = clamp;
+   }
+   if (ctx->ExecuteFlag) {
+      CALL_ClampColorARB(ctx->Exec, (target, clamp));
+   }
+}
+
+static void GLAPIENTRY
 save_UseShaderProgramEXT(GLenum type, GLuint program)
 {
    GET_CURRENT_CONTEXT(ctx);
@@ -8071,6 +8090,10 @@ execute_list(struct gl_context *ctx, GLuint list)
                                     (n[1].i, n[2].i, n[3].b, n[4].data));
 	    break;
 
+         case OPCODE_CLAMP_COLOR:
+            CALL_ClampColorARB(ctx->Exec, (n[1].e, n[2].e));
+            break;
+
          case OPCODE_TEX_BUMP_PARAMETER_ATI:
             {
                GLfloat values[4];
@@ -9868,6 +9891,10 @@ _mesa_create_save_table(void)
    SET_UseShaderProgramEXT(table, save_UseShaderProgramEXT);
    SET_ActiveProgramEXT(table, save_ActiveProgramEXT);
 
+   /* GL_ARB_color_buffer_float */
+   SET_ClampColorARB(table, save_ClampColorARB);
+   SET_ClampColor(table, save_ClampColorARB);
+
    /* GL 3.0 */
 #if 0
    SET_ClearBufferiv(table, save_ClearBufferiv);
diff --git a/mesalib/src/mesa/main/enums.c b/mesalib/src/mesa/main/enums.c
index ebfb37227..14be3ff44 100644
--- a/mesalib/src/mesa/main/enums.c
+++ b/mesalib/src/mesa/main/enums.c
@@ -1,6294 +1,6307 @@
-/* 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 "main/glheader.h"

-#include "main/mfeatures.h"

-#include "main/enums.h"

-#include "main/imports.h"

-#include "main/mtypes.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_PROGRAM_EXT\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_ALPHA16I_EXT\0"

-   "GL_ALPHA16UI_EXT\0"

-   "GL_ALPHA16_EXT\0"

-   "GL_ALPHA32I_EXT\0"

-   "GL_ALPHA32UI_EXT\0"

-   "GL_ALPHA4\0"

-   "GL_ALPHA4_EXT\0"

-   "GL_ALPHA8\0"

-   "GL_ALPHA8I_EXT\0"

-   "GL_ALPHA8UI_EXT\0"

-   "GL_ALPHA8_EXT\0"

-   "GL_ALPHA_BIAS\0"

-   "GL_ALPHA_BITS\0"

-   "GL_ALPHA_INTEGER_EXT\0"

-   "GL_ALPHA_SCALE\0"

-   "GL_ALPHA_TEST\0"

-   "GL_ALPHA_TEST_FUNC\0"

-   "GL_ALPHA_TEST_REF\0"

-   "GL_ALREADY_SIGNALED\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_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_BGRA_EXT\0"

-   "GL_BGRA_INTEGER\0"

-   "GL_BGRA_INTEGER_EXT\0"

-   "GL_BGR_INTEGER\0"

-   "GL_BGR_INTEGER_EXT\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_ALPHA_OES\0"

-   "GL_BLEND_DST_RGB\0"

-   "GL_BLEND_DST_RGB_OES\0"

-   "GL_BLEND_EQUATION\0"

-   "GL_BLEND_EQUATION_ALPHA\0"

-   "GL_BLEND_EQUATION_ALPHA_EXT\0"

-   "GL_BLEND_EQUATION_ALPHA_OES\0"

-   "GL_BLEND_EQUATION_EXT\0"

-   "GL_BLEND_EQUATION_OES\0"

-   "GL_BLEND_EQUATION_RGB\0"

-   "GL_BLEND_EQUATION_RGB_EXT\0"

-   "GL_BLEND_EQUATION_RGB_OES\0"

-   "GL_BLEND_SRC\0"

-   "GL_BLEND_SRC_ALPHA\0"

-   "GL_BLEND_SRC_ALPHA_OES\0"

-   "GL_BLEND_SRC_RGB\0"

-   "GL_BLEND_SRC_RGB_OES\0"

-   "GL_BLUE\0"

-   "GL_BLUE_BIAS\0"

-   "GL_BLUE_BITS\0"

-   "GL_BLUE_INTEGER\0"

-   "GL_BLUE_INTEGER_EXT\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_ACCESS_FLAGS\0"

-   "GL_BUFFER_ACCESS_OES\0"

-   "GL_BUFFER_FLUSHING_UNMAP_APPLE\0"

-   "GL_BUFFER_MAPPED\0"

-   "GL_BUFFER_MAPPED_ARB\0"

-   "GL_BUFFER_MAPPED_OES\0"

-   "GL_BUFFER_MAP_LENGTH\0"

-   "GL_BUFFER_MAP_OFFSET\0"

-   "GL_BUFFER_MAP_POINTER\0"

-   "GL_BUFFER_MAP_POINTER_ARB\0"

-   "GL_BUFFER_MAP_POINTER_OES\0"

-   "GL_BUFFER_OBJECT_APPLE\0"

-   "GL_BUFFER_SERIALIZED_MODIFY_APPLE\0"

-   "GL_BUFFER_SIZE\0"

-   "GL_BUFFER_SIZE_ARB\0"

-   "GL_BUFFER_USAGE\0"

-   "GL_BUFFER_USAGE_ARB\0"

-   "GL_BUMP_ENVMAP_ATI\0"

-   "GL_BUMP_NUM_TEX_UNITS_ATI\0"

-   "GL_BUMP_ROT_MATRIX_ATI\0"

-   "GL_BUMP_ROT_MATRIX_SIZE_ATI\0"

-   "GL_BUMP_TARGET_ATI\0"

-   "GL_BUMP_TEX_UNITS_ATI\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_READ_COLOR\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_DISTANCE0\0"

-   "GL_CLIP_DISTANCE1\0"

-   "GL_CLIP_DISTANCE2\0"

-   "GL_CLIP_DISTANCE3\0"

-   "GL_CLIP_DISTANCE4\0"

-   "GL_CLIP_DISTANCE5\0"

-   "GL_CLIP_DISTANCE6\0"

-   "GL_CLIP_DISTANCE7\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\0"

-   "GL_COLOR_ATTACHMENT0_EXT\0"

-   "GL_COLOR_ATTACHMENT0_OES\0"

-   "GL_COLOR_ATTACHMENT1\0"

-   "GL_COLOR_ATTACHMENT10\0"

-   "GL_COLOR_ATTACHMENT10_EXT\0"

-   "GL_COLOR_ATTACHMENT11\0"

-   "GL_COLOR_ATTACHMENT11_EXT\0"

-   "GL_COLOR_ATTACHMENT12\0"

-   "GL_COLOR_ATTACHMENT12_EXT\0"

-   "GL_COLOR_ATTACHMENT13\0"

-   "GL_COLOR_ATTACHMENT13_EXT\0"

-   "GL_COLOR_ATTACHMENT14\0"

-   "GL_COLOR_ATTACHMENT14_EXT\0"

-   "GL_COLOR_ATTACHMENT15\0"

-   "GL_COLOR_ATTACHMENT15_EXT\0"

-   "GL_COLOR_ATTACHMENT1_EXT\0"

-   "GL_COLOR_ATTACHMENT2\0"

-   "GL_COLOR_ATTACHMENT2_EXT\0"

-   "GL_COLOR_ATTACHMENT3\0"

-   "GL_COLOR_ATTACHMENT3_EXT\0"

-   "GL_COLOR_ATTACHMENT4\0"

-   "GL_COLOR_ATTACHMENT4_EXT\0"

-   "GL_COLOR_ATTACHMENT5\0"

-   "GL_COLOR_ATTACHMENT5_EXT\0"

-   "GL_COLOR_ATTACHMENT6\0"

-   "GL_COLOR_ATTACHMENT6_EXT\0"

-   "GL_COLOR_ATTACHMENT7\0"

-   "GL_COLOR_ATTACHMENT7_EXT\0"

-   "GL_COLOR_ATTACHMENT8\0"

-   "GL_COLOR_ATTACHMENT8_EXT\0"

-   "GL_COLOR_ATTACHMENT9\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_REF_TO_TEXTURE\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_RED\0"

-   "GL_COMPRESSED_RG\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_SLUMINANCE\0"

-   "GL_COMPRESSED_SLUMINANCE_ALPHA\0"

-   "GL_COMPRESSED_SRGB\0"

-   "GL_COMPRESSED_SRGB_ALPHA\0"

-   "GL_COMPRESSED_TEXTURE_FORMATS\0"

-   "GL_CONDITION_SATISFIED\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_CONTEXT_COMPATIBILITY_PROFILE_BIT\0"

-   "GL_CONTEXT_CORE_PROFILE_BIT\0"

-   "GL_CONTEXT_FLAGS\0"

-   "GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT\0"

-   "GL_CONTEXT_PROFILE_MASK\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_COORD_REPLACE_OES\0"

-   "GL_COPY\0"

-   "GL_COPY_INVERTED\0"

-   "GL_COPY_PIXEL_TOKEN\0"

-   "GL_COPY_READ_BUFFER\0"

-   "GL_COPY_WRITE_BUFFER\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_PALETTE_MATRIX_OES\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_SECONDARY_COLOR\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_DEPTH24_STENCIL8\0"

-   "GL_DEPTH24_STENCIL8_EXT\0"

-   "GL_DEPTH24_STENCIL8_OES\0"

-   "GL_DEPTH_ATTACHMENT\0"

-   "GL_DEPTH_ATTACHMENT_EXT\0"

-   "GL_DEPTH_ATTACHMENT_OES\0"

-   "GL_DEPTH_BIAS\0"

-   "GL_DEPTH_BITS\0"

-   "GL_DEPTH_BOUNDS_EXT\0"

-   "GL_DEPTH_BOUNDS_TEST_EXT\0"

-   "GL_DEPTH_BUFFER\0"

-   "GL_DEPTH_BUFFER_BIT\0"

-   "GL_DEPTH_CLAMP\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_OES\0"

-   "GL_DEPTH_COMPONENT16_SGIX\0"

-   "GL_DEPTH_COMPONENT24\0"

-   "GL_DEPTH_COMPONENT24_ARB\0"

-   "GL_DEPTH_COMPONENT24_OES\0"

-   "GL_DEPTH_COMPONENT24_SGIX\0"

-   "GL_DEPTH_COMPONENT32\0"

-   "GL_DEPTH_COMPONENT32_ARB\0"

-   "GL_DEPTH_COMPONENT32_OES\0"

-   "GL_DEPTH_COMPONENT32_SGIX\0"

-   "GL_DEPTH_FUNC\0"

-   "GL_DEPTH_RANGE\0"

-   "GL_DEPTH_SCALE\0"

-   "GL_DEPTH_STENCIL\0"

-   "GL_DEPTH_STENCIL_ATTACHMENT\0"

-   "GL_DEPTH_STENCIL_EXT\0"

-   "GL_DEPTH_STENCIL_NV\0"

-   "GL_DEPTH_STENCIL_OES\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\0"

-   "GL_DRAW_FRAMEBUFFER_BINDING\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_DU8DV8_ATI\0"

-   "GL_DUDV_ATI\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_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_FIRST_VERTEX_CONVENTION\0"

-   "GL_FIRST_VERTEX_CONVENTION_EXT\0"

-   "GL_FIXED\0"

-   "GL_FIXED_OES\0"

-   "GL_FIXED_ONLY\0"

-   "GL_FLAT\0"

-   "GL_FLOAT\0"

-   "GL_FLOAT_MAT2\0"

-   "GL_FLOAT_MAT2_ARB\0"

-   "GL_FLOAT_MAT2x3\0"

-   "GL_FLOAT_MAT2x4\0"

-   "GL_FLOAT_MAT3\0"

-   "GL_FLOAT_MAT3_ARB\0"

-   "GL_FLOAT_MAT3x2\0"

-   "GL_FLOAT_MAT3x4\0"

-   "GL_FLOAT_MAT4\0"

-   "GL_FLOAT_MAT4_ARB\0"

-   "GL_FLOAT_MAT4x2\0"

-   "GL_FLOAT_MAT4x3\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_FRAGMENT_SHADER_DERIVATIVE_HINT_OES\0"

-   "GL_FRAMEBUFFER\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_LAYERED\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT\0"

-   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES\0"

-   "GL_FRAMEBUFFER_BINDING\0"

-   "GL_FRAMEBUFFER_BINDING_EXT\0"

-   "GL_FRAMEBUFFER_BINDING_OES\0"

-   "GL_FRAMEBUFFER_COMPLETE\0"

-   "GL_FRAMEBUFFER_COMPLETE_EXT\0"

-   "GL_FRAMEBUFFER_COMPLETE_OES\0"

-   "GL_FRAMEBUFFER_DEFAULT\0"

-   "GL_FRAMEBUFFER_EXT\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_OES\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT\0"

-   "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_OES\0"

-   "GL_FRAMEBUFFER_OES\0"

-   "GL_FRAMEBUFFER_STATUS_ERROR_EXT\0"

-   "GL_FRAMEBUFFER_UNDEFINED\0"

-   "GL_FRAMEBUFFER_UNSUPPORTED\0"

-   "GL_FRAMEBUFFER_UNSUPPORTED_EXT\0"

-   "GL_FRAMEBUFFER_UNSUPPORTED_OES\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_ADD_OES\0"

-   "GL_FUNC_REVERSE_SUBTRACT\0"

-   "GL_FUNC_REVERSE_SUBTRACT_EXT\0"

-   "GL_FUNC_REVERSE_SUBTRACT_OES\0"

-   "GL_FUNC_SUBTRACT\0"

-   "GL_FUNC_SUBTRACT_EXT\0"

-   "GL_FUNC_SUBTRACT_OES\0"

-   "GL_GENERATE_MIPMAP\0"

-   "GL_GENERATE_MIPMAP_HINT\0"

-   "GL_GENERATE_MIPMAP_HINT_SGIS\0"

-   "GL_GENERATE_MIPMAP_SGIS\0"

-   "GL_GEOMETRY_INPUT_TYPE\0"

-   "GL_GEOMETRY_INPUT_TYPE_ARB\0"

-   "GL_GEOMETRY_OUTPUT_TYPE\0"

-   "GL_GEOMETRY_OUTPUT_TYPE_ARB\0"

-   "GL_GEOMETRY_SHADER\0"

-   "GL_GEOMETRY_SHADER_ARB\0"

-   "GL_GEOMETRY_VERTICES_OUT\0"

-   "GL_GEOMETRY_VERTICES_OUT_ARB\0"

-   "GL_GEQUAL\0"

-   "GL_GREATER\0"

-   "GL_GREEN\0"

-   "GL_GREEN_BIAS\0"

-   "GL_GREEN_BITS\0"

-   "GL_GREEN_INTEGER\0"

-   "GL_GREEN_INTEGER_EXT\0"

-   "GL_GREEN_SCALE\0"

-   "GL_HALF_FLOAT\0"

-   "GL_HALF_FLOAT_OES\0"

-   "GL_HIGH_FLOAT\0"

-   "GL_HIGH_INT\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\0"

-   "GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES\0"

-   "GL_IMPLEMENTATION_COLOR_READ_TYPE\0"

-   "GL_IMPLEMENTATION_COLOR_READ_TYPE_OES\0"

-   "GL_INCR\0"

-   "GL_INCR_WRAP\0"

-   "GL_INCR_WRAP_EXT\0"

-   "GL_INDEX\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_INTENSITY16I_EXT\0"

-   "GL_INTENSITY16UI_EXT\0"

-   "GL_INTENSITY16_EXT\0"

-   "GL_INTENSITY32I_EXT\0"

-   "GL_INTENSITY32UI_EXT\0"

-   "GL_INTENSITY4\0"

-   "GL_INTENSITY4_EXT\0"

-   "GL_INTENSITY8\0"

-   "GL_INTENSITY8I_EXT\0"

-   "GL_INTENSITY8UI_EXT\0"

-   "GL_INTENSITY8_EXT\0"

-   "GL_INTENSITY_EXT\0"

-   "GL_INTERLEAVED_ATTRIBS\0"

-   "GL_INTERLEAVED_ATTRIBS_EXT\0"

-   "GL_INTERPOLATE\0"

-   "GL_INTERPOLATE_ARB\0"

-   "GL_INTERPOLATE_EXT\0"

-   "GL_INT_10_10_10_2_OES\0"

-   "GL_INT_SAMPLER_1D\0"

-   "GL_INT_SAMPLER_1D_ARRAY\0"

-   "GL_INT_SAMPLER_1D_ARRAY_EXT\0"

-   "GL_INT_SAMPLER_1D_EXT\0"

-   "GL_INT_SAMPLER_2D\0"

-   "GL_INT_SAMPLER_2D_ARRAY\0"

-   "GL_INT_SAMPLER_2D_ARRAY_EXT\0"

-   "GL_INT_SAMPLER_2D_EXT\0"

-   "GL_INT_SAMPLER_2D_RECT\0"

-   "GL_INT_SAMPLER_2D_RECT_EXT\0"

-   "GL_INT_SAMPLER_3D\0"

-   "GL_INT_SAMPLER_3D_EXT\0"

-   "GL_INT_SAMPLER_BUFFER\0"

-   "GL_INT_SAMPLER_BUFFER_EXT\0"

-   "GL_INT_SAMPLER_CUBE\0"

-   "GL_INT_SAMPLER_CUBE_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\0"

-   "GL_INVALID_FRAMEBUFFER_OPERATION_EXT\0"

-   "GL_INVALID_FRAMEBUFFER_OPERATION_OES\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_LAST_VERTEX_CONVENTION\0"

-   "GL_LAST_VERTEX_CONVENTION_EXT\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_LINES_ADJACENCY\0"

-   "GL_LINES_ADJACENCY_ARB\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_STRIP_ADJACENCY\0"

-   "GL_LINE_STRIP_ADJACENCY_ARB\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_LOW_FLOAT\0"

-   "GL_LOW_INT\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_LUMINANCE16I_EXT\0"

-   "GL_LUMINANCE16UI_EXT\0"

-   "GL_LUMINANCE16_ALPHA16\0"

-   "GL_LUMINANCE16_ALPHA16_EXT\0"

-   "GL_LUMINANCE16_EXT\0"

-   "GL_LUMINANCE32I_EXT\0"

-   "GL_LUMINANCE32UI_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_LUMINANCE8I_EXT\0"

-   "GL_LUMINANCE8UI_EXT\0"

-   "GL_LUMINANCE8_ALPHA8\0"

-   "GL_LUMINANCE8_ALPHA8_EXT\0"

-   "GL_LUMINANCE8_EXT\0"

-   "GL_LUMINANCE_ALPHA\0"

-   "GL_LUMINANCE_ALPHA16I_EXT\0"

-   "GL_LUMINANCE_ALPHA16UI_EXT\0"

-   "GL_LUMINANCE_ALPHA32I_EXT\0"

-   "GL_LUMINANCE_ALPHA32UI_EXT\0"

-   "GL_LUMINANCE_ALPHA8I_EXT\0"

-   "GL_LUMINANCE_ALPHA8UI_EXT\0"

-   "GL_LUMINANCE_ALPHA_INTEGER_EXT\0"

-   "GL_LUMINANCE_INTEGER_EXT\0"

-   "GL_MAJOR_VERSION\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_FLUSH_EXPLICIT_BIT\0"

-   "GL_MAP_INVALIDATE_BUFFER_BIT\0"

-   "GL_MAP_INVALIDATE_RANGE_BIT\0"

-   "GL_MAP_READ_BIT\0"

-   "GL_MAP_STENCIL\0"

-   "GL_MAP_UNSYNCHRONIZED_BIT\0"

-   "GL_MAP_WRITE_BIT\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_BUFFER_BINDING_OES\0"

-   "GL_MATRIX_INDEX_ARRAY_OES\0"

-   "GL_MATRIX_INDEX_ARRAY_POINTER_ARB\0"

-   "GL_MATRIX_INDEX_ARRAY_POINTER_OES\0"

-   "GL_MATRIX_INDEX_ARRAY_SIZE_ARB\0"

-   "GL_MATRIX_INDEX_ARRAY_SIZE_OES\0"

-   "GL_MATRIX_INDEX_ARRAY_STRIDE_ARB\0"

-   "GL_MATRIX_INDEX_ARRAY_STRIDE_OES\0"

-   "GL_MATRIX_INDEX_ARRAY_TYPE_ARB\0"

-   "GL_MATRIX_INDEX_ARRAY_TYPE_OES\0"

-   "GL_MATRIX_MODE\0"

-   "GL_MATRIX_PALETTE_ARB\0"

-   "GL_MATRIX_PALETTE_OES\0"

-   "GL_MAX\0"

-   "GL_MAX_3D_TEXTURE_SIZE\0"

-   "GL_MAX_3D_TEXTURE_SIZE_OES\0"

-   "GL_MAX_ARRAY_TEXTURE_LAYERS\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_DISTANCES\0"

-   "GL_MAX_CLIP_PLANES\0"

-   "GL_MAX_COLOR_ATTACHMENTS\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_CUBE_MAP_TEXTURE_SIZE_OES\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_INPUT_COMPONENTS\0"

-   "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS\0"

-   "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB\0"

-   "GL_MAX_FRAGMENT_UNIFORM_VECTORS\0"

-   "GL_MAX_GEOMETRY_INPUT_COMPONENTS\0"

-   "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS\0"

-   "GL_MAX_GEOMETRY_OUTPUT_VERTICES\0"

-   "GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB\0"

-   "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS\0"

-   "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB\0"

-   "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS\0"

-   "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB\0"

-   "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS\0"

-   "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB\0"

-   "GL_MAX_GEOMETRY_VARYING_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_PALETTE_MATRICES_OES\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_TEXEL_OFFSET\0"

-   "GL_MAX_PROGRAM_TEXEL_OFFSET_EXT\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\0"

-   "GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB\0"

-   "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV\0"

-   "GL_MAX_RENDERBUFFER_SIZE\0"

-   "GL_MAX_RENDERBUFFER_SIZE_EXT\0"

-   "GL_MAX_RENDERBUFFER_SIZE_OES\0"

-   "GL_MAX_SAMPLES\0"

-   "GL_MAX_SAMPLES_EXT\0"

-   "GL_MAX_SERVER_WAIT_TIMEOUT\0"

-   "GL_MAX_SHININESS_NV\0"

-   "GL_MAX_SPOT_EXPONENT_NV\0"

-   "GL_MAX_TEXTURE_BUFFER_SIZE\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_LOD_BIAS_EXT\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_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS\0"

-   "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT\0"

-   "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS\0"

-   "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT\0"

-   "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS\0"

-   "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT\0"

-   "GL_MAX_VARYING_COMPONENTS\0"

-   "GL_MAX_VARYING_FLOATS\0"

-   "GL_MAX_VARYING_FLOATS_ARB\0"

-   "GL_MAX_VARYING_VECTORS\0"

-   "GL_MAX_VERTEX_ATTRIBS\0"

-   "GL_MAX_VERTEX_ATTRIBS_ARB\0"

-   "GL_MAX_VERTEX_OUTPUT_COMPONENTS\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_UNIFORM_VECTORS\0"

-   "GL_MAX_VERTEX_UNITS_ARB\0"

-   "GL_MAX_VERTEX_UNITS_OES\0"

-   "GL_MAX_VERTEX_VARYING_COMPONENTS_ARB\0"

-   "GL_MAX_VIEWPORT_DIMS\0"

-   "GL_MEDIUM_FLOAT\0"

-   "GL_MEDIUM_INT\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_MINOR_VERSION\0"

-   "GL_MIN_EXT\0"

-   "GL_MIN_PROGRAM_TEXEL_OFFSET\0"

-   "GL_MIN_PROGRAM_TEXEL_OFFSET_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_MATRIX_FLOAT_AS_INT_BITS_OES\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_NONE_OES\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_NORMAL_MAP_OES\0"

-   "GL_NOTEQUAL\0"

-   "GL_NO_ERROR\0"

-   "GL_NUM_COMPRESSED_TEXTURE_FORMATS\0"

-   "GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB\0"

-   "GL_NUM_EXTENSIONS\0"

-   "GL_NUM_PROGRAM_BINARY_FORMATS_OES\0"

-   "GL_NUM_SHADER_BINARY_FORMATS\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\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\0"

-   "GL_PIXEL_PACK_BUFFER_BINDING\0"

-   "GL_PIXEL_PACK_BUFFER_BINDING_EXT\0"

-   "GL_PIXEL_PACK_BUFFER_EXT\0"

-   "GL_PIXEL_UNPACK_BUFFER\0"

-   "GL_PIXEL_UNPACK_BUFFER_BINDING\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_ARRAY_BUFFER_BINDING_OES\0"

-   "GL_POINT_SIZE_ARRAY_OES\0"

-   "GL_POINT_SIZE_ARRAY_POINTER_OES\0"

-   "GL_POINT_SIZE_ARRAY_STRIDE_OES\0"

-   "GL_POINT_SIZE_ARRAY_TYPE_OES\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_OES\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_PRIMITIVES_GENERATED\0"

-   "GL_PRIMITIVES_GENERATED_EXT\0"

-   "GL_PRIMITIVE_RESTART\0"

-   "GL_PRIMITIVE_RESTART_INDEX\0"

-   "GL_PRIMITIVE_RESTART_INDEX_NV\0"

-   "GL_PRIMITIVE_RESTART_NV\0"

-   "GL_PROGRAM_ADDRESS_REGISTERS_ARB\0"

-   "GL_PROGRAM_ALU_INSTRUCTIONS_ARB\0"

-   "GL_PROGRAM_ATTRIBS_ARB\0"

-   "GL_PROGRAM_BINARY_FORMATS_OES\0"

-   "GL_PROGRAM_BINARY_LENGTH_OES\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_POINT_SIZE\0"

-   "GL_PROGRAM_POINT_SIZE_ARB\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_MATRIX_FLOAT_AS_INT_BITS_OES\0"

-   "GL_PROJECTION_STACK_DEPTH\0"

-   "GL_PROVOKING_VERTEX\0"

-   "GL_PROVOKING_VERTEX_EXT\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\0"

-   "GL_PROXY_TEXTURE_1D_ARRAY_EXT\0"

-   "GL_PROXY_TEXTURE_1D_EXT\0"

-   "GL_PROXY_TEXTURE_2D\0"

-   "GL_PROXY_TEXTURE_2D_ARRAY\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\0"

-   "GL_PROXY_TEXTURE_RECTANGLE_ARB\0"

-   "GL_PROXY_TEXTURE_RECTANGLE_NV\0"

-   "GL_PURGEABLE_APPLE\0"

-   "GL_Q\0"

-   "GL_QUADRATIC_ATTENUATION\0"

-   "GL_QUADS\0"

-   "GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION\0"

-   "GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT\0"

-   "GL_QUAD_MESH_SUN\0"

-   "GL_QUAD_STRIP\0"

-   "GL_QUERY_BY_REGION_NO_WAIT\0"

-   "GL_QUERY_BY_REGION_NO_WAIT_NV\0"

-   "GL_QUERY_BY_REGION_WAIT\0"

-   "GL_QUERY_BY_REGION_WAIT_NV\0"

-   "GL_QUERY_COUNTER_BITS\0"

-   "GL_QUERY_COUNTER_BITS_ARB\0"

-   "GL_QUERY_NO_WAIT\0"

-   "GL_QUERY_NO_WAIT_NV\0"

-   "GL_QUERY_RESULT\0"

-   "GL_QUERY_RESULT_ARB\0"

-   "GL_QUERY_RESULT_AVAILABLE\0"

-   "GL_QUERY_RESULT_AVAILABLE_ARB\0"

-   "GL_QUERY_WAIT\0"

-   "GL_QUERY_WAIT_NV\0"

-   "GL_R\0"

-   "GL_R11F_G11F_B10F\0"

-   "GL_R16_SNORM\0"

-   "GL_R3_G3_B2\0"

-   "GL_R8_SNORM\0"

-   "GL_RASTERIZER_DISCARD\0"

-   "GL_RASTERIZER_DISCARD_EXT\0"

-   "GL_RASTER_POSITION_UNCLIPPED_IBM\0"

-   "GL_READ_BUFFER\0"

-   "GL_READ_FRAMEBUFFER\0"

-   "GL_READ_FRAMEBUFFER_BINDING\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_INTEGER\0"

-   "GL_RED_INTEGER_EXT\0"

-   "GL_RED_SCALE\0"

-   "GL_RED_SNORM\0"

-   "GL_REFLECTION_MAP\0"

-   "GL_REFLECTION_MAP_ARB\0"

-   "GL_REFLECTION_MAP_NV\0"

-   "GL_REFLECTION_MAP_OES\0"

-   "GL_RELEASED_APPLE\0"

-   "GL_RENDER\0"

-   "GL_RENDERBUFFER\0"

-   "GL_RENDERBUFFER_ALPHA_SIZE\0"

-   "GL_RENDERBUFFER_ALPHA_SIZE_OES\0"

-   "GL_RENDERBUFFER_BINDING\0"

-   "GL_RENDERBUFFER_BINDING_EXT\0"

-   "GL_RENDERBUFFER_BINDING_OES\0"

-   "GL_RENDERBUFFER_BLUE_SIZE\0"

-   "GL_RENDERBUFFER_BLUE_SIZE_OES\0"

-   "GL_RENDERBUFFER_DEPTH_SIZE\0"

-   "GL_RENDERBUFFER_DEPTH_SIZE_OES\0"

-   "GL_RENDERBUFFER_EXT\0"

-   "GL_RENDERBUFFER_GREEN_SIZE\0"

-   "GL_RENDERBUFFER_GREEN_SIZE_OES\0"

-   "GL_RENDERBUFFER_HEIGHT\0"

-   "GL_RENDERBUFFER_HEIGHT_EXT\0"

-   "GL_RENDERBUFFER_HEIGHT_OES\0"

-   "GL_RENDERBUFFER_INTERNAL_FORMAT\0"

-   "GL_RENDERBUFFER_INTERNAL_FORMAT_EXT\0"

-   "GL_RENDERBUFFER_INTERNAL_FORMAT_OES\0"

-   "GL_RENDERBUFFER_OES\0"

-   "GL_RENDERBUFFER_RED_SIZE\0"

-   "GL_RENDERBUFFER_RED_SIZE_OES\0"

-   "GL_RENDERBUFFER_SAMPLES\0"

-   "GL_RENDERBUFFER_SAMPLES_EXT\0"

-   "GL_RENDERBUFFER_STENCIL_SIZE\0"

-   "GL_RENDERBUFFER_STENCIL_SIZE_OES\0"

-   "GL_RENDERBUFFER_WIDTH\0"

-   "GL_RENDERBUFFER_WIDTH_EXT\0"

-   "GL_RENDERBUFFER_WIDTH_OES\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_RETAINED_APPLE\0"

-   "GL_RETURN\0"

-   "GL_RG16_SNORM\0"

-   "GL_RG8_SNORM\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_RGB16F\0"

-   "GL_RGB16I\0"

-   "GL_RGB16I_EXT\0"

-   "GL_RGB16UI\0"

-   "GL_RGB16UI_EXT\0"

-   "GL_RGB16_EXT\0"

-   "GL_RGB16_SNORM\0"

-   "GL_RGB2_EXT\0"

-   "GL_RGB32F\0"

-   "GL_RGB32I\0"

-   "GL_RGB32I_EXT\0"

-   "GL_RGB32UI\0"

-   "GL_RGB32UI_EXT\0"

-   "GL_RGB4\0"

-   "GL_RGB4_EXT\0"

-   "GL_RGB4_S3TC\0"

-   "GL_RGB5\0"

-   "GL_RGB565\0"

-   "GL_RGB565_OES\0"

-   "GL_RGB5_A1\0"

-   "GL_RGB5_A1_EXT\0"

-   "GL_RGB5_A1_OES\0"

-   "GL_RGB5_EXT\0"

-   "GL_RGB8\0"

-   "GL_RGB8I\0"

-   "GL_RGB8I_EXT\0"

-   "GL_RGB8UI\0"

-   "GL_RGB8UI_EXT\0"

-   "GL_RGB8_EXT\0"

-   "GL_RGB8_OES\0"

-   "GL_RGB8_SNORM\0"

-   "GL_RGB9_E5\0"

-   "GL_RGBA\0"

-   "GL_RGBA12\0"

-   "GL_RGBA12_EXT\0"

-   "GL_RGBA16\0"

-   "GL_RGBA16F\0"

-   "GL_RGBA16I\0"

-   "GL_RGBA16I_EXT\0"

-   "GL_RGBA16UI\0"

-   "GL_RGBA16UI_EXT\0"

-   "GL_RGBA16_EXT\0"

-   "GL_RGBA16_SNORM\0"

-   "GL_RGBA2\0"

-   "GL_RGBA2_EXT\0"

-   "GL_RGBA32F\0"

-   "GL_RGBA32I\0"

-   "GL_RGBA32I_EXT\0"

-   "GL_RGBA32UI\0"

-   "GL_RGBA32UI_EXT\0"

-   "GL_RGBA4\0"

-   "GL_RGBA4_DXT5_S3TC\0"

-   "GL_RGBA4_EXT\0"

-   "GL_RGBA4_OES\0"

-   "GL_RGBA4_S3TC\0"

-   "GL_RGBA8\0"

-   "GL_RGBA8I\0"

-   "GL_RGBA8I_EXT\0"

-   "GL_RGBA8UI\0"

-   "GL_RGBA8UI_EXT\0"

-   "GL_RGBA8_EXT\0"

-   "GL_RGBA8_OES\0"

-   "GL_RGBA8_SNORM\0"

-   "GL_RGBA_DXT5_S3TC\0"

-   "GL_RGBA_INTEGER\0"

-   "GL_RGBA_INTEGER_EXT\0"

-   "GL_RGBA_INTEGER_MODE_EXT\0"

-   "GL_RGBA_MODE\0"

-   "GL_RGBA_S3TC\0"

-   "GL_RGBA_SNORM\0"

-   "GL_RGB_INTEGER\0"

-   "GL_RGB_INTEGER_EXT\0"

-   "GL_RGB_S3TC\0"

-   "GL_RGB_SCALE\0"

-   "GL_RGB_SCALE_ARB\0"

-   "GL_RGB_SCALE_EXT\0"

-   "GL_RGB_SNORM\0"

-   "GL_RG_SNORM\0"

-   "GL_RIGHT\0"

-   "GL_S\0"

-   "GL_SAMPLER_1D\0"

-   "GL_SAMPLER_1D_ARRAY\0"

-   "GL_SAMPLER_1D_ARRAY_EXT\0"

-   "GL_SAMPLER_1D_ARRAY_SHADOW\0"

-   "GL_SAMPLER_1D_ARRAY_SHADOW_EXT\0"

-   "GL_SAMPLER_1D_SHADOW\0"

-   "GL_SAMPLER_2D\0"

-   "GL_SAMPLER_2D_ARRAY\0"

-   "GL_SAMPLER_2D_ARRAY_EXT\0"

-   "GL_SAMPLER_2D_ARRAY_SHADOW\0"

-   "GL_SAMPLER_2D_ARRAY_SHADOW_EXT\0"

-   "GL_SAMPLER_2D_RECT\0"

-   "GL_SAMPLER_2D_RECT_SHADOW\0"

-   "GL_SAMPLER_2D_SHADOW\0"

-   "GL_SAMPLER_3D\0"

-   "GL_SAMPLER_3D_OES\0"

-   "GL_SAMPLER_BUFFER\0"

-   "GL_SAMPLER_BUFFER_EXT\0"

-   "GL_SAMPLER_CUBE\0"

-   "GL_SAMPLER_CUBE_SHADOW\0"

-   "GL_SAMPLER_CUBE_SHADOW_EXT\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_ATTRIBS\0"

-   "GL_SEPARATE_ATTRIBS_EXT\0"

-   "GL_SEPARATE_SPECULAR_COLOR\0"

-   "GL_SEPARATE_SPECULAR_COLOR_EXT\0"

-   "GL_SET\0"

-   "GL_SHADER_BINARY_FORMATS\0"

-   "GL_SHADER_COMPILER\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_SIGNALED\0"

-   "GL_SIGNED_NORMALIZED\0"

-   "GL_SINGLE_COLOR\0"

-   "GL_SINGLE_COLOR_EXT\0"

-   "GL_SLICE_ACCUM_SUN\0"

-   "GL_SLUMINANCE\0"

-   "GL_SLUMINANCE8\0"

-   "GL_SLUMINANCE8_ALPHA8\0"

-   "GL_SLUMINANCE_ALPHA\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_SRGB\0"

-   "GL_SRGB8\0"

-   "GL_SRGB8_ALPHA8\0"

-   "GL_SRGB_ALPHA\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\0"

-   "GL_STENCIL_ATTACHMENT_EXT\0"

-   "GL_STENCIL_ATTACHMENT_OES\0"

-   "GL_STENCIL_BACK_FAIL\0"

-   "GL_STENCIL_BACK_FAIL_ATI\0"

-   "GL_STENCIL_BACK_FUNC\0"

-   "GL_STENCIL_BACK_FUNC_ATI\0"

-   "GL_STENCIL_BACK_PASS_DEPTH_FAIL\0"

-   "GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI\0"

-   "GL_STENCIL_BACK_PASS_DEPTH_PASS\0"

-   "GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI\0"

-   "GL_STENCIL_BACK_REF\0"

-   "GL_STENCIL_BACK_VALUE_MASK\0"

-   "GL_STENCIL_BACK_WRITEMASK\0"

-   "GL_STENCIL_BITS\0"

-   "GL_STENCIL_BUFFER\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_INDEX1\0"

-   "GL_STENCIL_INDEX16\0"

-   "GL_STENCIL_INDEX16_EXT\0"

-   "GL_STENCIL_INDEX1_EXT\0"

-   "GL_STENCIL_INDEX1_OES\0"

-   "GL_STENCIL_INDEX4\0"

-   "GL_STENCIL_INDEX4_EXT\0"

-   "GL_STENCIL_INDEX4_OES\0"

-   "GL_STENCIL_INDEX8\0"

-   "GL_STENCIL_INDEX8_EXT\0"

-   "GL_STENCIL_INDEX8_OES\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_STORAGE_CACHED_APPLE\0"

-   "GL_STORAGE_PRIVATE_APPLE\0"

-   "GL_STORAGE_SHARED_APPLE\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_SYNC_CONDITION\0"

-   "GL_SYNC_FENCE\0"

-   "GL_SYNC_FLAGS\0"

-   "GL_SYNC_FLUSH_COMMANDS_BIT\0"

-   "GL_SYNC_GPU_COMMANDS_COMPLETE\0"

-   "GL_SYNC_STATUS\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\0"

-   "GL_TEXTURE_1D_ARRAY_EXT\0"

-   "GL_TEXTURE_2D\0"

-   "GL_TEXTURE_2D_ARRAY\0"

-   "GL_TEXTURE_2D_ARRAY_EXT\0"

-   "GL_TEXTURE_3D\0"

-   "GL_TEXTURE_3D_OES\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\0"

-   "GL_TEXTURE_BINDING_1D_ARRAY_EXT\0"

-   "GL_TEXTURE_BINDING_2D\0"

-   "GL_TEXTURE_BINDING_2D_ARRAY\0"

-   "GL_TEXTURE_BINDING_2D_ARRAY_EXT\0"

-   "GL_TEXTURE_BINDING_3D\0"

-   "GL_TEXTURE_BINDING_3D_OES\0"

-   "GL_TEXTURE_BINDING_BUFFER\0"

-   "GL_TEXTURE_BINDING_CUBE_MAP\0"

-   "GL_TEXTURE_BINDING_CUBE_MAP_ARB\0"

-   "GL_TEXTURE_BINDING_CUBE_MAP_OES\0"

-   "GL_TEXTURE_BINDING_RECTANGLE\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_BUFFER\0"

-   "GL_TEXTURE_BUFFER_DATA_STORE_BINDING\0"

-   "GL_TEXTURE_BUFFER_FORMAT\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_CROP_RECT_OES\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_X_OES\0"

-   "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y\0"

-   "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB\0"

-   "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES\0"

-   "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z\0"

-   "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB\0"

-   "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES\0"

-   "GL_TEXTURE_CUBE_MAP_OES\0"

-   "GL_TEXTURE_CUBE_MAP_POSITIVE_X\0"

-   "GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB\0"

-   "GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES\0"

-   "GL_TEXTURE_CUBE_MAP_POSITIVE_Y\0"

-   "GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB\0"

-   "GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES\0"

-   "GL_TEXTURE_CUBE_MAP_POSITIVE_Z\0"

-   "GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB\0"

-   "GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES\0"

-   "GL_TEXTURE_CUBE_MAP_SEAMLESS\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_FILTER_CONTROL_EXT\0"

-   "GL_TEXTURE_GEN_MODE\0"

-   "GL_TEXTURE_GEN_MODE_OES\0"

-   "GL_TEXTURE_GEN_Q\0"

-   "GL_TEXTURE_GEN_R\0"

-   "GL_TEXTURE_GEN_S\0"

-   "GL_TEXTURE_GEN_STR_OES\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_MATRIX_FLOAT_AS_INT_BITS_OES\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_RANGE_LENGTH_APPLE\0"

-   "GL_TEXTURE_RANGE_POINTER_APPLE\0"

-   "GL_TEXTURE_RECTANGLE\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_SHARED_SIZE\0"

-   "GL_TEXTURE_STACK_DEPTH\0"

-   "GL_TEXTURE_STENCIL_SIZE\0"

-   "GL_TEXTURE_STENCIL_SIZE_EXT\0"

-   "GL_TEXTURE_STORAGE_HINT_APPLE\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_R_OES\0"

-   "GL_TEXTURE_WRAP_S\0"

-   "GL_TEXTURE_WRAP_T\0"

-   "GL_TIMEOUT_EXPIRED\0"

-   "GL_TIME_ELAPSED_EXT\0"

-   "GL_TRACK_MATRIX_NV\0"

-   "GL_TRACK_MATRIX_TRANSFORM_NV\0"

-   "GL_TRANSFORM_BIT\0"

-   "GL_TRANSFORM_FEEDBACK\0"

-   "GL_TRANSFORM_FEEDBACK_BINDING\0"

-   "GL_TRANSFORM_FEEDBACK_BUFFER\0"

-   "GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE\0"

-   "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING\0"

-   "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT\0"

-   "GL_TRANSFORM_FEEDBACK_BUFFER_EXT\0"

-   "GL_TRANSFORM_FEEDBACK_BUFFER_MODE\0"

-   "GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT\0"

-   "GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED\0"

-   "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE\0"

-   "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT\0"

-   "GL_TRANSFORM_FEEDBACK_BUFFER_START\0"

-   "GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT\0"

-   "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN\0"

-   "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT\0"

-   "GL_TRANSFORM_FEEDBACK_VARYINGS\0"

-   "GL_TRANSFORM_FEEDBACK_VARYINGS_EXT\0"

-   "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH\0"

-   "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT\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_TRIANGLES_ADJACENCY\0"

-   "GL_TRIANGLES_ADJACENCY_ARB\0"

-   "GL_TRIANGLE_FAN\0"

-   "GL_TRIANGLE_MESH_SUN\0"

-   "GL_TRIANGLE_STRIP\0"

-   "GL_TRIANGLE_STRIP_ADJACENCY\0"

-   "GL_TRIANGLE_STRIP_ADJACENCY_ARB\0"

-   "GL_TRUE\0"

-   "GL_UNDEFINED_APPLE\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_UNSIGNALED\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_10F_11F_11F_REV\0"

-   "GL_UNSIGNED_INT_10_10_10_2\0"

-   "GL_UNSIGNED_INT_10_10_10_2_OES\0"

-   "GL_UNSIGNED_INT_24_8\0"

-   "GL_UNSIGNED_INT_24_8_EXT\0"

-   "GL_UNSIGNED_INT_24_8_NV\0"

-   "GL_UNSIGNED_INT_24_8_OES\0"

-   "GL_UNSIGNED_INT_2_10_10_10_REV\0"

-   "GL_UNSIGNED_INT_2_10_10_10_REV_EXT\0"

-   "GL_UNSIGNED_INT_5_9_9_9_REV\0"

-   "GL_UNSIGNED_INT_8_8_8_8\0"

-   "GL_UNSIGNED_INT_8_8_8_8_REV\0"

-   "GL_UNSIGNED_INT_SAMPLER_1D\0"

-   "GL_UNSIGNED_INT_SAMPLER_1D_ARRAY\0"

-   "GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT\0"

-   "GL_UNSIGNED_INT_SAMPLER_1D_EXT\0"

-   "GL_UNSIGNED_INT_SAMPLER_2D\0"

-   "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY\0"

-   "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT\0"

-   "GL_UNSIGNED_INT_SAMPLER_2D_EXT\0"

-   "GL_UNSIGNED_INT_SAMPLER_2D_RECT\0"

-   "GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT\0"

-   "GL_UNSIGNED_INT_SAMPLER_3D\0"

-   "GL_UNSIGNED_INT_SAMPLER_3D_EXT\0"

-   "GL_UNSIGNED_INT_SAMPLER_BUFFER\0"

-   "GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT\0"

-   "GL_UNSIGNED_INT_SAMPLER_CUBE\0"

-   "GL_UNSIGNED_INT_SAMPLER_CUBE_EXT\0"

-   "GL_UNSIGNED_INT_VEC2\0"

-   "GL_UNSIGNED_INT_VEC2_EXT\0"

-   "GL_UNSIGNED_INT_VEC3\0"

-   "GL_UNSIGNED_INT_VEC3_EXT\0"

-   "GL_UNSIGNED_INT_VEC4\0"

-   "GL_UNSIGNED_INT_VEC4_EXT\0"

-   "GL_UNSIGNED_NORMALIZED\0"

-   "GL_UNSIGNED_SHORT\0"

-   "GL_UNSIGNED_SHORT_1_5_5_5_REV\0"

-   "GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT\0"

-   "GL_UNSIGNED_SHORT_4_4_4_4\0"

-   "GL_UNSIGNED_SHORT_4_4_4_4_REV\0"

-   "GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT\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\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_DIVISOR_ARB\0"

-   "GL_VERTEX_ATTRIB_ARRAY_ENABLED\0"

-   "GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB\0"

-   "GL_VERTEX_ATTRIB_ARRAY_INTEGER\0"

-   "GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT\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_VOLATILE_APPLE\0"

-   "GL_WAIT_FAILED\0"

-   "GL_WEIGHT_ARRAY_ARB\0"

-   "GL_WEIGHT_ARRAY_BUFFER_BINDING\0"

-   "GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB\0"

-   "GL_WEIGHT_ARRAY_BUFFER_BINDING_OES\0"

-   "GL_WEIGHT_ARRAY_OES\0"

-   "GL_WEIGHT_ARRAY_POINTER_ARB\0"

-   "GL_WEIGHT_ARRAY_POINTER_OES\0"

-   "GL_WEIGHT_ARRAY_SIZE_ARB\0"

-   "GL_WEIGHT_ARRAY_SIZE_OES\0"

-   "GL_WEIGHT_ARRAY_STRIDE_ARB\0"

-   "GL_WEIGHT_ARRAY_STRIDE_OES\0"

-   "GL_WEIGHT_ARRAY_TYPE_ARB\0"

-   "GL_WEIGHT_ARRAY_TYPE_OES\0"

-   "GL_WEIGHT_SUM_UNITY_ARB\0"

-   "GL_WRAP_BORDER_SUN\0"

-   "GL_WRITE_ONLY\0"

-   "GL_WRITE_ONLY_ARB\0"

-   "GL_WRITE_ONLY_OES\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[2295] =

-{

-   {     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, 0x00008B8D }, /* GL_ACTIVE_PROGRAM_EXT */

-   {   298, 0x00008911 }, /* GL_ACTIVE_STENCIL_FACE_EXT */

-   {   325, 0x000084E0 }, /* GL_ACTIVE_TEXTURE */

-   {   343, 0x000084E0 }, /* GL_ACTIVE_TEXTURE_ARB */

-   {   365, 0x00008B86 }, /* GL_ACTIVE_UNIFORMS */

-   {   384, 0x00008B87 }, /* GL_ACTIVE_UNIFORM_MAX_LENGTH */

-   {   413, 0x000086A5 }, /* GL_ACTIVE_VERTEX_UNITS_ARB */

-   {   440, 0x00000104 }, /* GL_ADD */

-   {   447, 0x00008574 }, /* GL_ADD_SIGNED */

-   {   461, 0x00008574 }, /* GL_ADD_SIGNED_ARB */

-   {   479, 0x00008574 }, /* GL_ADD_SIGNED_EXT */

-   {   497, 0x0000846E }, /* GL_ALIASED_LINE_WIDTH_RANGE */

-   {   525, 0x0000846D }, /* GL_ALIASED_POINT_SIZE_RANGE */

-   {   553, 0x000FFFFF }, /* GL_ALL_ATTRIB_BITS */

-   {   572, 0xFFFFFFFF }, /* GL_ALL_CLIENT_ATTRIB_BITS */

-   {   598, 0x00001906 }, /* GL_ALPHA */

-   {   607, 0x0000803D }, /* GL_ALPHA12 */

-   {   618, 0x0000803D }, /* GL_ALPHA12_EXT */

-   {   633, 0x0000803E }, /* GL_ALPHA16 */

-   {   644, 0x00008D8A }, /* GL_ALPHA16I_EXT */

-   {   660, 0x00008D78 }, /* GL_ALPHA16UI_EXT */

-   {   677, 0x0000803E }, /* GL_ALPHA16_EXT */

-   {   692, 0x00008D84 }, /* GL_ALPHA32I_EXT */

-   {   708, 0x00008D72 }, /* GL_ALPHA32UI_EXT */

-   {   725, 0x0000803B }, /* GL_ALPHA4 */

-   {   735, 0x0000803B }, /* GL_ALPHA4_EXT */

-   {   749, 0x0000803C }, /* GL_ALPHA8 */

-   {   759, 0x00008D90 }, /* GL_ALPHA8I_EXT */

-   {   774, 0x00008D7E }, /* GL_ALPHA8UI_EXT */

-   {   790, 0x0000803C }, /* GL_ALPHA8_EXT */

-   {   804, 0x00000D1D }, /* GL_ALPHA_BIAS */

-   {   818, 0x00000D55 }, /* GL_ALPHA_BITS */

-   {   832, 0x00008D97 }, /* GL_ALPHA_INTEGER_EXT */

-   {   853, 0x00000D1C }, /* GL_ALPHA_SCALE */

-   {   868, 0x00000BC0 }, /* GL_ALPHA_TEST */

-   {   882, 0x00000BC1 }, /* GL_ALPHA_TEST_FUNC */

-   {   901, 0x00000BC2 }, /* GL_ALPHA_TEST_REF */

-   {   919, 0x0000911A }, /* GL_ALREADY_SIGNALED */

-   {   939, 0x00000207 }, /* GL_ALWAYS */

-   {   949, 0x00001200 }, /* GL_AMBIENT */

-   {   960, 0x00001602 }, /* GL_AMBIENT_AND_DIFFUSE */

-   {   983, 0x00001501 }, /* GL_AND */

-   {   990, 0x00001504 }, /* GL_AND_INVERTED */

-   {  1006, 0x00001502 }, /* GL_AND_REVERSE */

-   {  1021, 0x00008892 }, /* GL_ARRAY_BUFFER */

-   {  1037, 0x00008894 }, /* GL_ARRAY_BUFFER_BINDING */

-   {  1061, 0x00008894 }, /* GL_ARRAY_BUFFER_BINDING_ARB */

-   {  1089, 0x00008B85 }, /* GL_ATTACHED_SHADERS */

-   {  1109, 0x00008645 }, /* GL_ATTRIB_ARRAY_POINTER_NV */

-   {  1136, 0x00008623 }, /* GL_ATTRIB_ARRAY_SIZE_NV */

-   {  1160, 0x00008624 }, /* GL_ATTRIB_ARRAY_STRIDE_NV */

-   {  1186, 0x00008625 }, /* GL_ATTRIB_ARRAY_TYPE_NV */

-   {  1210, 0x00000BB0 }, /* GL_ATTRIB_STACK_DEPTH */

-   {  1232, 0x00000D80 }, /* GL_AUTO_NORMAL */

-   {  1247, 0x00000409 }, /* GL_AUX0 */

-   {  1255, 0x0000040A }, /* GL_AUX1 */

-   {  1263, 0x0000040B }, /* GL_AUX2 */

-   {  1271, 0x0000040C }, /* GL_AUX3 */

-   {  1279, 0x00000C00 }, /* GL_AUX_BUFFERS */

-   {  1294, 0x00000405 }, /* GL_BACK */

-   {  1302, 0x00000402 }, /* GL_BACK_LEFT */

-   {  1315, 0x00000403 }, /* GL_BACK_RIGHT */

-   {  1329, 0x000080E0 }, /* GL_BGR */

-   {  1336, 0x000080E1 }, /* GL_BGRA */

-   {  1344, 0x000080E1 }, /* GL_BGRA_EXT */

-   {  1356, 0x00008D9B }, /* GL_BGRA_INTEGER */

-   {  1372, 0x00008D9B }, /* GL_BGRA_INTEGER_EXT */

-   {  1392, 0x00008D9A }, /* GL_BGR_INTEGER */

-   {  1407, 0x00008D9A }, /* GL_BGR_INTEGER_EXT */

-   {  1426, 0x00001A00 }, /* GL_BITMAP */

-   {  1436, 0x00000704 }, /* GL_BITMAP_TOKEN */

-   {  1452, 0x00000BE2 }, /* GL_BLEND */

-   {  1461, 0x00008005 }, /* GL_BLEND_COLOR */

-   {  1476, 0x00008005 }, /* GL_BLEND_COLOR_EXT */

-   {  1495, 0x00000BE0 }, /* GL_BLEND_DST */

-   {  1508, 0x000080CA }, /* GL_BLEND_DST_ALPHA */

-   {  1527, 0x000080CA }, /* GL_BLEND_DST_ALPHA_OES */

-   {  1550, 0x000080C8 }, /* GL_BLEND_DST_RGB */

-   {  1567, 0x000080C8 }, /* GL_BLEND_DST_RGB_OES */

-   {  1588, 0x00008009 }, /* GL_BLEND_EQUATION */

-   {  1606, 0x0000883D }, /* GL_BLEND_EQUATION_ALPHA */

-   {  1630, 0x0000883D }, /* GL_BLEND_EQUATION_ALPHA_EXT */

-   {  1658, 0x0000883D }, /* GL_BLEND_EQUATION_ALPHA_OES */

-   {  1686, 0x00008009 }, /* GL_BLEND_EQUATION_EXT */

-   {  1708, 0x00008009 }, /* GL_BLEND_EQUATION_OES */

-   {  1730, 0x00008009 }, /* GL_BLEND_EQUATION_RGB */

-   {  1752, 0x00008009 }, /* GL_BLEND_EQUATION_RGB_EXT */

-   {  1778, 0x00008009 }, /* GL_BLEND_EQUATION_RGB_OES */

-   {  1804, 0x00000BE1 }, /* GL_BLEND_SRC */

-   {  1817, 0x000080CB }, /* GL_BLEND_SRC_ALPHA */

-   {  1836, 0x000080CB }, /* GL_BLEND_SRC_ALPHA_OES */

-   {  1859, 0x000080C9 }, /* GL_BLEND_SRC_RGB */

-   {  1876, 0x000080C9 }, /* GL_BLEND_SRC_RGB_OES */

-   {  1897, 0x00001905 }, /* GL_BLUE */

-   {  1905, 0x00000D1B }, /* GL_BLUE_BIAS */

-   {  1918, 0x00000D54 }, /* GL_BLUE_BITS */

-   {  1931, 0x00008D96 }, /* GL_BLUE_INTEGER */

-   {  1947, 0x00008D96 }, /* GL_BLUE_INTEGER_EXT */

-   {  1967, 0x00000D1A }, /* GL_BLUE_SCALE */

-   {  1981, 0x00008B56 }, /* GL_BOOL */

-   {  1989, 0x00008B56 }, /* GL_BOOL_ARB */

-   {  2001, 0x00008B57 }, /* GL_BOOL_VEC2 */

-   {  2014, 0x00008B57 }, /* GL_BOOL_VEC2_ARB */

-   {  2031, 0x00008B58 }, /* GL_BOOL_VEC3 */

-   {  2044, 0x00008B58 }, /* GL_BOOL_VEC3_ARB */

-   {  2061, 0x00008B59 }, /* GL_BOOL_VEC4 */

-   {  2074, 0x00008B59 }, /* GL_BOOL_VEC4_ARB */

-   {  2091, 0x000088BB }, /* GL_BUFFER_ACCESS */

-   {  2108, 0x000088BB }, /* GL_BUFFER_ACCESS_ARB */

-   {  2129, 0x0000911F }, /* GL_BUFFER_ACCESS_FLAGS */

-   {  2152, 0x000088BB }, /* GL_BUFFER_ACCESS_OES */

-   {  2173, 0x00008A13 }, /* GL_BUFFER_FLUSHING_UNMAP_APPLE */

-   {  2204, 0x000088BC }, /* GL_BUFFER_MAPPED */

-   {  2221, 0x000088BC }, /* GL_BUFFER_MAPPED_ARB */

-   {  2242, 0x000088BC }, /* GL_BUFFER_MAPPED_OES */

-   {  2263, 0x00009120 }, /* GL_BUFFER_MAP_LENGTH */

-   {  2284, 0x00009121 }, /* GL_BUFFER_MAP_OFFSET */

-   {  2305, 0x000088BD }, /* GL_BUFFER_MAP_POINTER */

-   {  2327, 0x000088BD }, /* GL_BUFFER_MAP_POINTER_ARB */

-   {  2353, 0x000088BD }, /* GL_BUFFER_MAP_POINTER_OES */

-   {  2379, 0x000085B3 }, /* GL_BUFFER_OBJECT_APPLE */

-   {  2402, 0x00008A12 }, /* GL_BUFFER_SERIALIZED_MODIFY_APPLE */

-   {  2436, 0x00008764 }, /* GL_BUFFER_SIZE */

-   {  2451, 0x00008764 }, /* GL_BUFFER_SIZE_ARB */

-   {  2470, 0x00008765 }, /* GL_BUFFER_USAGE */

-   {  2486, 0x00008765 }, /* GL_BUFFER_USAGE_ARB */

-   {  2506, 0x0000877B }, /* GL_BUMP_ENVMAP_ATI */

-   {  2525, 0x00008777 }, /* GL_BUMP_NUM_TEX_UNITS_ATI */

-   {  2551, 0x00008775 }, /* GL_BUMP_ROT_MATRIX_ATI */

-   {  2574, 0x00008776 }, /* GL_BUMP_ROT_MATRIX_SIZE_ATI */

-   {  2602, 0x0000877C }, /* GL_BUMP_TARGET_ATI */

-   {  2621, 0x00008778 }, /* GL_BUMP_TEX_UNITS_ATI */

-   {  2643, 0x00001400 }, /* GL_BYTE */

-   {  2651, 0x00002A24 }, /* GL_C3F_V3F */

-   {  2662, 0x00002A26 }, /* GL_C4F_N3F_V3F */

-   {  2677, 0x00002A22 }, /* GL_C4UB_V2F */

-   {  2689, 0x00002A23 }, /* GL_C4UB_V3F */

-   {  2701, 0x00000901 }, /* GL_CCW */

-   {  2708, 0x00002900 }, /* GL_CLAMP */

-   {  2717, 0x0000891C }, /* GL_CLAMP_READ_COLOR */

-   {  2737, 0x0000812D }, /* GL_CLAMP_TO_BORDER */

-   {  2756, 0x0000812D }, /* GL_CLAMP_TO_BORDER_ARB */

-   {  2779, 0x0000812D }, /* GL_CLAMP_TO_BORDER_SGIS */

-   {  2803, 0x0000812F }, /* GL_CLAMP_TO_EDGE */

-   {  2820, 0x0000812F }, /* GL_CLAMP_TO_EDGE_SGIS */

-   {  2842, 0x00001500 }, /* GL_CLEAR */

-   {  2851, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE */

-   {  2876, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE_ARB */

-   {  2905, 0xFFFFFFFF }, /* GL_CLIENT_ALL_ATTRIB_BITS */

-   {  2931, 0x00000BB1 }, /* GL_CLIENT_ATTRIB_STACK_DEPTH */

-   {  2960, 0x00000001 }, /* GL_CLIENT_PIXEL_STORE_BIT */

-   {  2986, 0x00000002 }, /* GL_CLIENT_VERTEX_ARRAY_BIT */

-   {  3013, 0x00003000 }, /* GL_CLIP_DISTANCE0 */

-   {  3031, 0x00003001 }, /* GL_CLIP_DISTANCE1 */

-   {  3049, 0x00003002 }, /* GL_CLIP_DISTANCE2 */

-   {  3067, 0x00003003 }, /* GL_CLIP_DISTANCE3 */

-   {  3085, 0x00003004 }, /* GL_CLIP_DISTANCE4 */

-   {  3103, 0x00003005 }, /* GL_CLIP_DISTANCE5 */

-   {  3121, 0x00003006 }, /* GL_CLIP_DISTANCE6 */

-   {  3139, 0x00003007 }, /* GL_CLIP_DISTANCE7 */

-   {  3157, 0x00003000 }, /* GL_CLIP_PLANE0 */

-   {  3172, 0x00003001 }, /* GL_CLIP_PLANE1 */

-   {  3187, 0x00003002 }, /* GL_CLIP_PLANE2 */

-   {  3202, 0x00003003 }, /* GL_CLIP_PLANE3 */

-   {  3217, 0x00003004 }, /* GL_CLIP_PLANE4 */

-   {  3232, 0x00003005 }, /* GL_CLIP_PLANE5 */

-   {  3247, 0x000080F0 }, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */

-   {  3280, 0x00000A00 }, /* GL_COEFF */

-   {  3289, 0x00001800 }, /* GL_COLOR */

-   {  3298, 0x00008076 }, /* GL_COLOR_ARRAY */

-   {  3313, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING */

-   {  3343, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING_ARB */

-   {  3377, 0x00008090 }, /* GL_COLOR_ARRAY_POINTER */

-   {  3400, 0x00008081 }, /* GL_COLOR_ARRAY_SIZE */

-   {  3420, 0x00008083 }, /* GL_COLOR_ARRAY_STRIDE */

-   {  3442, 0x00008082 }, /* GL_COLOR_ARRAY_TYPE */

-   {  3462, 0x00008CE0 }, /* GL_COLOR_ATTACHMENT0 */

-   {  3483, 0x00008CE0 }, /* GL_COLOR_ATTACHMENT0_EXT */

-   {  3508, 0x00008CE0 }, /* GL_COLOR_ATTACHMENT0_OES */

-   {  3533, 0x00008CE1 }, /* GL_COLOR_ATTACHMENT1 */

-   {  3554, 0x00008CEA }, /* GL_COLOR_ATTACHMENT10 */

-   {  3576, 0x00008CEA }, /* GL_COLOR_ATTACHMENT10_EXT */

-   {  3602, 0x00008CEB }, /* GL_COLOR_ATTACHMENT11 */

-   {  3624, 0x00008CEB }, /* GL_COLOR_ATTACHMENT11_EXT */

-   {  3650, 0x00008CEC }, /* GL_COLOR_ATTACHMENT12 */

-   {  3672, 0x00008CEC }, /* GL_COLOR_ATTACHMENT12_EXT */

-   {  3698, 0x00008CED }, /* GL_COLOR_ATTACHMENT13 */

-   {  3720, 0x00008CED }, /* GL_COLOR_ATTACHMENT13_EXT */

-   {  3746, 0x00008CEE }, /* GL_COLOR_ATTACHMENT14 */

-   {  3768, 0x00008CEE }, /* GL_COLOR_ATTACHMENT14_EXT */

-   {  3794, 0x00008CEF }, /* GL_COLOR_ATTACHMENT15 */

-   {  3816, 0x00008CEF }, /* GL_COLOR_ATTACHMENT15_EXT */

-   {  3842, 0x00008CE1 }, /* GL_COLOR_ATTACHMENT1_EXT */

-   {  3867, 0x00008CE2 }, /* GL_COLOR_ATTACHMENT2 */

-   {  3888, 0x00008CE2 }, /* GL_COLOR_ATTACHMENT2_EXT */

-   {  3913, 0x00008CE3 }, /* GL_COLOR_ATTACHMENT3 */

-   {  3934, 0x00008CE3 }, /* GL_COLOR_ATTACHMENT3_EXT */

-   {  3959, 0x00008CE4 }, /* GL_COLOR_ATTACHMENT4 */

-   {  3980, 0x00008CE4 }, /* GL_COLOR_ATTACHMENT4_EXT */

-   {  4005, 0x00008CE5 }, /* GL_COLOR_ATTACHMENT5 */

-   {  4026, 0x00008CE5 }, /* GL_COLOR_ATTACHMENT5_EXT */

-   {  4051, 0x00008CE6 }, /* GL_COLOR_ATTACHMENT6 */

-   {  4072, 0x00008CE6 }, /* GL_COLOR_ATTACHMENT6_EXT */

-   {  4097, 0x00008CE7 }, /* GL_COLOR_ATTACHMENT7 */

-   {  4118, 0x00008CE7 }, /* GL_COLOR_ATTACHMENT7_EXT */

-   {  4143, 0x00008CE8 }, /* GL_COLOR_ATTACHMENT8 */

-   {  4164, 0x00008CE8 }, /* GL_COLOR_ATTACHMENT8_EXT */

-   {  4189, 0x00008CE9 }, /* GL_COLOR_ATTACHMENT9 */

-   {  4210, 0x00008CE9 }, /* GL_COLOR_ATTACHMENT9_EXT */

-   {  4235, 0x00004000 }, /* GL_COLOR_BUFFER_BIT */

-   {  4255, 0x00000C22 }, /* GL_COLOR_CLEAR_VALUE */

-   {  4276, 0x00001900 }, /* GL_COLOR_INDEX */

-   {  4291, 0x00001603 }, /* GL_COLOR_INDEXES */

-   {  4308, 0x00000BF2 }, /* GL_COLOR_LOGIC_OP */

-   {  4326, 0x00000B57 }, /* GL_COLOR_MATERIAL */

-   {  4344, 0x00000B55 }, /* GL_COLOR_MATERIAL_FACE */

-   {  4367, 0x00000B56 }, /* GL_COLOR_MATERIAL_PARAMETER */

-   {  4395, 0x000080B1 }, /* GL_COLOR_MATRIX */

-   {  4411, 0x000080B1 }, /* GL_COLOR_MATRIX_SGI */

-   {  4431, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH */

-   {  4459, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH_SGI */

-   {  4491, 0x00008458 }, /* GL_COLOR_SUM */

-   {  4504, 0x00008458 }, /* GL_COLOR_SUM_ARB */

-   {  4521, 0x000080D0 }, /* GL_COLOR_TABLE */

-   {  4536, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE */

-   {  4562, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_EXT */

-   {  4592, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_SGI */

-   {  4622, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS */

-   {  4642, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS_SGI */

-   {  4666, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE */

-   {  4691, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_EXT */

-   {  4720, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_SGI */

-   {  4749, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT */

-   {  4771, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_EXT */

-   {  4797, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_SGI */

-   {  4823, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE */

-   {  4849, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_EXT */

-   {  4879, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_SGI */

-   {  4909, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE */

-   {  4939, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_EXT */

-   {  4973, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_SGI */

-   {  5007, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE */

-   {  5037, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_EXT */

-   {  5071, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_SGI */

-   {  5105, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE */

-   {  5129, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_EXT */

-   {  5157, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_SGI */

-   {  5185, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE */

-   {  5206, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE_SGI */

-   {  5231, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH */

-   {  5252, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_EXT */

-   {  5277, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_SGI */

-   {  5302, 0x00000C23 }, /* GL_COLOR_WRITEMASK */

-   {  5321, 0x00008570 }, /* GL_COMBINE */

-   {  5332, 0x00008503 }, /* GL_COMBINE4 */

-   {  5344, 0x00008572 }, /* GL_COMBINE_ALPHA */

-   {  5361, 0x00008572 }, /* GL_COMBINE_ALPHA_ARB */

-   {  5382, 0x00008572 }, /* GL_COMBINE_ALPHA_EXT */

-   {  5403, 0x00008570 }, /* GL_COMBINE_ARB */

-   {  5418, 0x00008570 }, /* GL_COMBINE_EXT */

-   {  5433, 0x00008571 }, /* GL_COMBINE_RGB */

-   {  5448, 0x00008571 }, /* GL_COMBINE_RGB_ARB */

-   {  5467, 0x00008571 }, /* GL_COMBINE_RGB_EXT */

-   {  5486, 0x0000884E }, /* GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT */

-   {  5522, 0x0000884E }, /* GL_COMPARE_REF_TO_TEXTURE */

-   {  5548, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE */

-   {  5572, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE_ARB */

-   {  5600, 0x00001300 }, /* GL_COMPILE */

-   {  5611, 0x00001301 }, /* GL_COMPILE_AND_EXECUTE */

-   {  5634, 0x00008B81 }, /* GL_COMPILE_STATUS */

-   {  5652, 0x000084E9 }, /* GL_COMPRESSED_ALPHA */

-   {  5672, 0x000084E9 }, /* GL_COMPRESSED_ALPHA_ARB */

-   {  5696, 0x000084EC }, /* GL_COMPRESSED_INTENSITY */

-   {  5720, 0x000084EC }, /* GL_COMPRESSED_INTENSITY_ARB */

-   {  5748, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE */

-   {  5772, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA */

-   {  5802, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA_ARB */

-   {  5836, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE_ARB */

-   {  5864, 0x00008225 }, /* GL_COMPRESSED_RED */

-   {  5882, 0x00008226 }, /* GL_COMPRESSED_RG */

-   {  5899, 0x000084ED }, /* GL_COMPRESSED_RGB */

-   {  5917, 0x000084EE }, /* GL_COMPRESSED_RGBA */

-   {  5936, 0x000084EE }, /* GL_COMPRESSED_RGBA_ARB */

-   {  5959, 0x000086B1 }, /* GL_COMPRESSED_RGBA_FXT1_3DFX */

-   {  5988, 0x000083F1 }, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */

-   {  6021, 0x000083F2 }, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */

-   {  6054, 0x000083F3 }, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */

-   {  6087, 0x000084ED }, /* GL_COMPRESSED_RGB_ARB */

-   {  6109, 0x000086B0 }, /* GL_COMPRESSED_RGB_FXT1_3DFX */

-   {  6137, 0x000083F0 }, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */

-   {  6169, 0x00008C4A }, /* GL_COMPRESSED_SLUMINANCE */

-   {  6194, 0x00008C4B }, /* GL_COMPRESSED_SLUMINANCE_ALPHA */

-   {  6225, 0x00008C48 }, /* GL_COMPRESSED_SRGB */

-   {  6244, 0x00008C49 }, /* GL_COMPRESSED_SRGB_ALPHA */

-   {  6269, 0x000086A3 }, /* GL_COMPRESSED_TEXTURE_FORMATS */

-   {  6299, 0x0000911C }, /* GL_CONDITION_SATISFIED */

-   {  6322, 0x00008576 }, /* GL_CONSTANT */

-   {  6334, 0x00008003 }, /* GL_CONSTANT_ALPHA */

-   {  6352, 0x00008003 }, /* GL_CONSTANT_ALPHA_EXT */

-   {  6374, 0x00008576 }, /* GL_CONSTANT_ARB */

-   {  6390, 0x00001207 }, /* GL_CONSTANT_ATTENUATION */

-   {  6414, 0x00008151 }, /* GL_CONSTANT_BORDER_HP */

-   {  6436, 0x00008001 }, /* GL_CONSTANT_COLOR */

-   {  6454, 0x00008001 }, /* GL_CONSTANT_COLOR_EXT */

-   {  6476, 0x00008576 }, /* GL_CONSTANT_EXT */

-   {  6492, 0x00000002 }, /* GL_CONTEXT_COMPATIBILITY_PROFILE_BIT */

-   {  6529, 0x00000001 }, /* GL_CONTEXT_CORE_PROFILE_BIT */

-   {  6557, 0x0000821E }, /* GL_CONTEXT_FLAGS */

-   {  6574, 0x00000001 }, /* GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT */

-   {  6613, 0x00009126 }, /* GL_CONTEXT_PROFILE_MASK */

-   {  6637, 0x00008010 }, /* GL_CONVOLUTION_1D */

-   {  6655, 0x00008011 }, /* GL_CONVOLUTION_2D */

-   {  6673, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR */

-   {  6701, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR_HP */

-   {  6732, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE */

-   {  6759, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE_EXT */

-   {  6790, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS */

-   {  6817, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS_EXT */

-   {  6848, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE */

-   {  6876, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE_EXT */

-   {  6908, 0x00008017 }, /* GL_CONVOLUTION_FORMAT */

-   {  6930, 0x00008017 }, /* GL_CONVOLUTION_FORMAT_EXT */

-   {  6956, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT */

-   {  6978, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT_EXT */

-   {  7004, 0x00008018 }, /* GL_CONVOLUTION_WIDTH */

-   {  7025, 0x00008018 }, /* GL_CONVOLUTION_WIDTH_EXT */

-   {  7050, 0x00008862 }, /* GL_COORD_REPLACE */

-   {  7067, 0x00008862 }, /* GL_COORD_REPLACE_ARB */

-   {  7088, 0x00008862 }, /* GL_COORD_REPLACE_NV */

-   {  7108, 0x00008862 }, /* GL_COORD_REPLACE_OES */

-   {  7129, 0x00001503 }, /* GL_COPY */

-   {  7137, 0x0000150C }, /* GL_COPY_INVERTED */

-   {  7154, 0x00000706 }, /* GL_COPY_PIXEL_TOKEN */

-   {  7174, 0x00008F36 }, /* GL_COPY_READ_BUFFER */

-   {  7194, 0x00008F37 }, /* GL_COPY_WRITE_BUFFER */

-   {  7215, 0x00000B44 }, /* GL_CULL_FACE */

-   {  7228, 0x00000B45 }, /* GL_CULL_FACE_MODE */

-   {  7246, 0x000081AA }, /* GL_CULL_VERTEX_EXT */

-   {  7265, 0x000081AC }, /* GL_CULL_VERTEX_EYE_POSITION_EXT */

-   {  7297, 0x000081AB }, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */

-   {  7332, 0x00008626 }, /* GL_CURRENT_ATTRIB_NV */

-   {  7353, 0x00000001 }, /* GL_CURRENT_BIT */

-   {  7368, 0x00000B00 }, /* GL_CURRENT_COLOR */

-   {  7385, 0x00008453 }, /* GL_CURRENT_FOG_COORD */

-   {  7406, 0x00008453 }, /* GL_CURRENT_FOG_COORDINATE */

-   {  7432, 0x00000B01 }, /* GL_CURRENT_INDEX */

-   {  7449, 0x00008641 }, /* GL_CURRENT_MATRIX_ARB */

-   {  7471, 0x00008845 }, /* GL_CURRENT_MATRIX_INDEX_ARB */

-   {  7499, 0x00008641 }, /* GL_CURRENT_MATRIX_NV */

-   {  7520, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */

-   {  7554, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_NV */

-   {  7587, 0x00000B02 }, /* GL_CURRENT_NORMAL */

-   {  7605, 0x00008843 }, /* GL_CURRENT_PALETTE_MATRIX_ARB */

-   {  7635, 0x00008843 }, /* GL_CURRENT_PALETTE_MATRIX_OES */

-   {  7665, 0x00008B8D }, /* GL_CURRENT_PROGRAM */

-   {  7684, 0x00008865 }, /* GL_CURRENT_QUERY */

-   {  7701, 0x00008865 }, /* GL_CURRENT_QUERY_ARB */

-   {  7722, 0x00000B04 }, /* GL_CURRENT_RASTER_COLOR */

-   {  7746, 0x00000B09 }, /* GL_CURRENT_RASTER_DISTANCE */

-   {  7773, 0x00000B05 }, /* GL_CURRENT_RASTER_INDEX */

-   {  7797, 0x00000B07 }, /* GL_CURRENT_RASTER_POSITION */

-   {  7824, 0x00000B08 }, /* GL_CURRENT_RASTER_POSITION_VALID */

-   {  7857, 0x0000845F }, /* GL_CURRENT_RASTER_SECONDARY_COLOR */

-   {  7891, 0x00000B06 }, /* GL_CURRENT_RASTER_TEXTURE_COORDS */

-   {  7924, 0x00008459 }, /* GL_CURRENT_SECONDARY_COLOR */

-   {  7951, 0x00000B03 }, /* GL_CURRENT_TEXTURE_COORDS */

-   {  7977, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB */

-   {  8002, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB_ARB */

-   {  8031, 0x000086A8 }, /* GL_CURRENT_WEIGHT_ARB */

-   {  8053, 0x00000900 }, /* GL_CW */

-   {  8059, 0x0000875B }, /* GL_DEBUG_ASSERT_MESA */

-   {  8080, 0x00008759 }, /* GL_DEBUG_OBJECT_MESA */

-   {  8101, 0x0000875A }, /* GL_DEBUG_PRINT_MESA */

-   {  8121, 0x00002101 }, /* GL_DECAL */

-   {  8130, 0x00001E03 }, /* GL_DECR */

-   {  8138, 0x00008508 }, /* GL_DECR_WRAP */

-   {  8151, 0x00008508 }, /* GL_DECR_WRAP_EXT */

-   {  8168, 0x00008B80 }, /* GL_DELETE_STATUS */

-   {  8185, 0x00001801 }, /* GL_DEPTH */

-   {  8194, 0x000088F0 }, /* GL_DEPTH24_STENCIL8 */

-   {  8214, 0x000088F0 }, /* GL_DEPTH24_STENCIL8_EXT */

-   {  8238, 0x000088F0 }, /* GL_DEPTH24_STENCIL8_OES */

-   {  8262, 0x00008D00 }, /* GL_DEPTH_ATTACHMENT */

-   {  8282, 0x00008D00 }, /* GL_DEPTH_ATTACHMENT_EXT */

-   {  8306, 0x00008D00 }, /* GL_DEPTH_ATTACHMENT_OES */

-   {  8330, 0x00000D1F }, /* GL_DEPTH_BIAS */

-   {  8344, 0x00000D56 }, /* GL_DEPTH_BITS */

-   {  8358, 0x00008891 }, /* GL_DEPTH_BOUNDS_EXT */

-   {  8378, 0x00008890 }, /* GL_DEPTH_BOUNDS_TEST_EXT */

-   {  8403, 0x00008223 }, /* GL_DEPTH_BUFFER */

-   {  8419, 0x00000100 }, /* GL_DEPTH_BUFFER_BIT */

-   {  8439, 0x0000864F }, /* GL_DEPTH_CLAMP */

-   {  8454, 0x0000864F }, /* GL_DEPTH_CLAMP_NV */

-   {  8472, 0x00000B73 }, /* GL_DEPTH_CLEAR_VALUE */

-   {  8493, 0x00001902 }, /* GL_DEPTH_COMPONENT */

-   {  8512, 0x000081A5 }, /* GL_DEPTH_COMPONENT16 */

-   {  8533, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_ARB */

-   {  8558, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_OES */

-   {  8583, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_SGIX */

-   {  8609, 0x000081A6 }, /* GL_DEPTH_COMPONENT24 */

-   {  8630, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_ARB */

-   {  8655, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_OES */

-   {  8680, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_SGIX */

-   {  8706, 0x000081A7 }, /* GL_DEPTH_COMPONENT32 */

-   {  8727, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_ARB */

-   {  8752, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_OES */

-   {  8777, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_SGIX */

-   {  8803, 0x00000B74 }, /* GL_DEPTH_FUNC */

-   {  8817, 0x00000B70 }, /* GL_DEPTH_RANGE */

-   {  8832, 0x00000D1E }, /* GL_DEPTH_SCALE */

-   {  8847, 0x000084F9 }, /* GL_DEPTH_STENCIL */

-   {  8864, 0x0000821A }, /* GL_DEPTH_STENCIL_ATTACHMENT */

-   {  8892, 0x000084F9 }, /* GL_DEPTH_STENCIL_EXT */

-   {  8913, 0x000084F9 }, /* GL_DEPTH_STENCIL_NV */

-   {  8933, 0x000084F9 }, /* GL_DEPTH_STENCIL_OES */

-   {  8954, 0x0000886F }, /* GL_DEPTH_STENCIL_TO_BGRA_NV */

-   {  8982, 0x0000886E }, /* GL_DEPTH_STENCIL_TO_RGBA_NV */

-   {  9010, 0x00000B71 }, /* GL_DEPTH_TEST */

-   {  9024, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE */

-   {  9046, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE_ARB */

-   {  9072, 0x00000B72 }, /* GL_DEPTH_WRITEMASK */

-   {  9091, 0x00001201 }, /* GL_DIFFUSE */

-   {  9102, 0x00000BD0 }, /* GL_DITHER */

-   {  9112, 0x00000A02 }, /* GL_DOMAIN */

-   {  9122, 0x00001100 }, /* GL_DONT_CARE */

-   {  9135, 0x000086AE }, /* GL_DOT3_RGB */

-   {  9147, 0x000086AF }, /* GL_DOT3_RGBA */

-   {  9160, 0x000086AF }, /* GL_DOT3_RGBA_ARB */

-   {  9177, 0x00008741 }, /* GL_DOT3_RGBA_EXT */

-   {  9194, 0x000086AE }, /* GL_DOT3_RGB_ARB */

-   {  9210, 0x00008740 }, /* GL_DOT3_RGB_EXT */

-   {  9226, 0x0000140A }, /* GL_DOUBLE */

-   {  9236, 0x00000C32 }, /* GL_DOUBLEBUFFER */

-   {  9252, 0x00000C01 }, /* GL_DRAW_BUFFER */

-   {  9267, 0x00008825 }, /* GL_DRAW_BUFFER0 */

-   {  9283, 0x00008825 }, /* GL_DRAW_BUFFER0_ARB */

-   {  9303, 0x00008825 }, /* GL_DRAW_BUFFER0_ATI */

-   {  9323, 0x00008826 }, /* GL_DRAW_BUFFER1 */

-   {  9339, 0x0000882F }, /* GL_DRAW_BUFFER10 */

-   {  9356, 0x0000882F }, /* GL_DRAW_BUFFER10_ARB */

-   {  9377, 0x0000882F }, /* GL_DRAW_BUFFER10_ATI */

-   {  9398, 0x00008830 }, /* GL_DRAW_BUFFER11 */

-   {  9415, 0x00008830 }, /* GL_DRAW_BUFFER11_ARB */

-   {  9436, 0x00008830 }, /* GL_DRAW_BUFFER11_ATI */

-   {  9457, 0x00008831 }, /* GL_DRAW_BUFFER12 */

-   {  9474, 0x00008831 }, /* GL_DRAW_BUFFER12_ARB */

-   {  9495, 0x00008831 }, /* GL_DRAW_BUFFER12_ATI */

-   {  9516, 0x00008832 }, /* GL_DRAW_BUFFER13 */

-   {  9533, 0x00008832 }, /* GL_DRAW_BUFFER13_ARB */

-   {  9554, 0x00008832 }, /* GL_DRAW_BUFFER13_ATI */

-   {  9575, 0x00008833 }, /* GL_DRAW_BUFFER14 */

-   {  9592, 0x00008833 }, /* GL_DRAW_BUFFER14_ARB */

-   {  9613, 0x00008833 }, /* GL_DRAW_BUFFER14_ATI */

-   {  9634, 0x00008834 }, /* GL_DRAW_BUFFER15 */

-   {  9651, 0x00008834 }, /* GL_DRAW_BUFFER15_ARB */

-   {  9672, 0x00008834 }, /* GL_DRAW_BUFFER15_ATI */

-   {  9693, 0x00008826 }, /* GL_DRAW_BUFFER1_ARB */

-   {  9713, 0x00008826 }, /* GL_DRAW_BUFFER1_ATI */

-   {  9733, 0x00008827 }, /* GL_DRAW_BUFFER2 */

-   {  9749, 0x00008827 }, /* GL_DRAW_BUFFER2_ARB */

-   {  9769, 0x00008827 }, /* GL_DRAW_BUFFER2_ATI */

-   {  9789, 0x00008828 }, /* GL_DRAW_BUFFER3 */

-   {  9805, 0x00008828 }, /* GL_DRAW_BUFFER3_ARB */

-   {  9825, 0x00008828 }, /* GL_DRAW_BUFFER3_ATI */

-   {  9845, 0x00008829 }, /* GL_DRAW_BUFFER4 */

-   {  9861, 0x00008829 }, /* GL_DRAW_BUFFER4_ARB */

-   {  9881, 0x00008829 }, /* GL_DRAW_BUFFER4_ATI */

-   {  9901, 0x0000882A }, /* GL_DRAW_BUFFER5 */

-   {  9917, 0x0000882A }, /* GL_DRAW_BUFFER5_ARB */

-   {  9937, 0x0000882A }, /* GL_DRAW_BUFFER5_ATI */

-   {  9957, 0x0000882B }, /* GL_DRAW_BUFFER6 */

-   {  9973, 0x0000882B }, /* GL_DRAW_BUFFER6_ARB */

-   {  9993, 0x0000882B }, /* GL_DRAW_BUFFER6_ATI */

-   { 10013, 0x0000882C }, /* GL_DRAW_BUFFER7 */

-   { 10029, 0x0000882C }, /* GL_DRAW_BUFFER7_ARB */

-   { 10049, 0x0000882C }, /* GL_DRAW_BUFFER7_ATI */

-   { 10069, 0x0000882D }, /* GL_DRAW_BUFFER8 */

-   { 10085, 0x0000882D }, /* GL_DRAW_BUFFER8_ARB */

-   { 10105, 0x0000882D }, /* GL_DRAW_BUFFER8_ATI */

-   { 10125, 0x0000882E }, /* GL_DRAW_BUFFER9 */

-   { 10141, 0x0000882E }, /* GL_DRAW_BUFFER9_ARB */

-   { 10161, 0x0000882E }, /* GL_DRAW_BUFFER9_ATI */

-   { 10181, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER */

-   { 10201, 0x00008CA6 }, /* GL_DRAW_FRAMEBUFFER_BINDING */

-   { 10229, 0x00008CA6 }, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */

-   { 10261, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER_EXT */

-   { 10285, 0x00000705 }, /* GL_DRAW_PIXEL_TOKEN */

-   { 10305, 0x00000304 }, /* GL_DST_ALPHA */

-   { 10318, 0x00000306 }, /* GL_DST_COLOR */

-   { 10331, 0x0000877A }, /* GL_DU8DV8_ATI */

-   { 10345, 0x00008779 }, /* GL_DUDV_ATI */

-   { 10357, 0x000088EA }, /* GL_DYNAMIC_COPY */

-   { 10373, 0x000088EA }, /* GL_DYNAMIC_COPY_ARB */

-   { 10393, 0x000088E8 }, /* GL_DYNAMIC_DRAW */

-   { 10409, 0x000088E8 }, /* GL_DYNAMIC_DRAW_ARB */

-   { 10429, 0x000088E9 }, /* GL_DYNAMIC_READ */

-   { 10445, 0x000088E9 }, /* GL_DYNAMIC_READ_ARB */

-   { 10465, 0x00000B43 }, /* GL_EDGE_FLAG */

-   { 10478, 0x00008079 }, /* GL_EDGE_FLAG_ARRAY */

-   { 10497, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */

-   { 10531, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB */

-   { 10569, 0x00008093 }, /* GL_EDGE_FLAG_ARRAY_POINTER */

-   { 10596, 0x0000808C }, /* GL_EDGE_FLAG_ARRAY_STRIDE */

-   { 10622, 0x00008893 }, /* GL_ELEMENT_ARRAY_BUFFER */

-   { 10646, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */

-   { 10678, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB */

-   { 10714, 0x00001600 }, /* GL_EMISSION */

-   { 10726, 0x00002000 }, /* GL_ENABLE_BIT */

-   { 10740, 0x00000202 }, /* GL_EQUAL */

-   { 10749, 0x00001509 }, /* GL_EQUIV */

-   { 10758, 0x00010000 }, /* GL_EVAL_BIT */

-   { 10770, 0x00000800 }, /* GL_EXP */

-   { 10777, 0x00000801 }, /* GL_EXP2 */

-   { 10785, 0x00001F03 }, /* GL_EXTENSIONS */

-   { 10799, 0x00002400 }, /* GL_EYE_LINEAR */

-   { 10813, 0x00002502 }, /* GL_EYE_PLANE */

-   { 10826, 0x0000855C }, /* GL_EYE_PLANE_ABSOLUTE_NV */

-   { 10851, 0x0000855B }, /* GL_EYE_RADIAL_NV */

-   { 10868, 0x00000000 }, /* GL_FALSE */

-   { 10877, 0x00001101 }, /* GL_FASTEST */

-   { 10888, 0x00001C01 }, /* GL_FEEDBACK */

-   { 10900, 0x00000DF0 }, /* GL_FEEDBACK_BUFFER_POINTER */

-   { 10927, 0x00000DF1 }, /* GL_FEEDBACK_BUFFER_SIZE */

-   { 10951, 0x00000DF2 }, /* GL_FEEDBACK_BUFFER_TYPE */

-   { 10975, 0x00001B02 }, /* GL_FILL */

-   { 10983, 0x00008E4D }, /* GL_FIRST_VERTEX_CONVENTION */

-   { 11010, 0x00008E4D }, /* GL_FIRST_VERTEX_CONVENTION_EXT */

-   { 11041, 0x0000140C }, /* GL_FIXED */

-   { 11050, 0x0000140C }, /* GL_FIXED_OES */

-   { 11063, 0x0000891D }, /* GL_FIXED_ONLY */

-   { 11077, 0x00001D00 }, /* GL_FLAT */

-   { 11085, 0x00001406 }, /* GL_FLOAT */

-   { 11094, 0x00008B5A }, /* GL_FLOAT_MAT2 */

-   { 11108, 0x00008B5A }, /* GL_FLOAT_MAT2_ARB */

-   { 11126, 0x00008B65 }, /* GL_FLOAT_MAT2x3 */

-   { 11142, 0x00008B66 }, /* GL_FLOAT_MAT2x4 */

-   { 11158, 0x00008B5B }, /* GL_FLOAT_MAT3 */

-   { 11172, 0x00008B5B }, /* GL_FLOAT_MAT3_ARB */

-   { 11190, 0x00008B67 }, /* GL_FLOAT_MAT3x2 */

-   { 11206, 0x00008B68 }, /* GL_FLOAT_MAT3x4 */

-   { 11222, 0x00008B5C }, /* GL_FLOAT_MAT4 */

-   { 11236, 0x00008B5C }, /* GL_FLOAT_MAT4_ARB */

-   { 11254, 0x00008B69 }, /* GL_FLOAT_MAT4x2 */

-   { 11270, 0x00008B6A }, /* GL_FLOAT_MAT4x3 */

-   { 11286, 0x00008B50 }, /* GL_FLOAT_VEC2 */

-   { 11300, 0x00008B50 }, /* GL_FLOAT_VEC2_ARB */

-   { 11318, 0x00008B51 }, /* GL_FLOAT_VEC3 */

-   { 11332, 0x00008B51 }, /* GL_FLOAT_VEC3_ARB */

-   { 11350, 0x00008B52 }, /* GL_FLOAT_VEC4 */

-   { 11364, 0x00008B52 }, /* GL_FLOAT_VEC4_ARB */

-   { 11382, 0x00000B60 }, /* GL_FOG */

-   { 11389, 0x00000080 }, /* GL_FOG_BIT */

-   { 11400, 0x00000B66 }, /* GL_FOG_COLOR */

-   { 11413, 0x00008451 }, /* GL_FOG_COORD */

-   { 11426, 0x00008451 }, /* GL_FOG_COORDINATE */

-   { 11444, 0x00008457 }, /* GL_FOG_COORDINATE_ARRAY */

-   { 11468, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */

-   { 11507, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB */

-   { 11550, 0x00008456 }, /* GL_FOG_COORDINATE_ARRAY_POINTER */

-   { 11582, 0x00008455 }, /* GL_FOG_COORDINATE_ARRAY_STRIDE */

-   { 11613, 0x00008454 }, /* GL_FOG_COORDINATE_ARRAY_TYPE */

-   { 11642, 0x00008450 }, /* GL_FOG_COORDINATE_SOURCE */

-   { 11667, 0x00008457 }, /* GL_FOG_COORD_ARRAY */

-   { 11686, 0x0000889D }, /* GL_FOG_COORD_ARRAY_BUFFER_BINDING */

-   { 11720, 0x00008456 }, /* GL_FOG_COORD_ARRAY_POINTER */

-   { 11747, 0x00008455 }, /* GL_FOG_COORD_ARRAY_STRIDE */

-   { 11773, 0x00008454 }, /* GL_FOG_COORD_ARRAY_TYPE */

-   { 11797, 0x00008450 }, /* GL_FOG_COORD_SRC */

-   { 11814, 0x00000B62 }, /* GL_FOG_DENSITY */

-   { 11829, 0x0000855A }, /* GL_FOG_DISTANCE_MODE_NV */

-   { 11853, 0x00000B64 }, /* GL_FOG_END */

-   { 11864, 0x00000C54 }, /* GL_FOG_HINT */

-   { 11876, 0x00000B61 }, /* GL_FOG_INDEX */

-   { 11889, 0x00000B65 }, /* GL_FOG_MODE */

-   { 11901, 0x00008198 }, /* GL_FOG_OFFSET_SGIX */

-   { 11920, 0x00008199 }, /* GL_FOG_OFFSET_VALUE_SGIX */

-   { 11945, 0x00000B63 }, /* GL_FOG_START */

-   { 11958, 0x00008452 }, /* GL_FRAGMENT_DEPTH */

-   { 11976, 0x00008804 }, /* GL_FRAGMENT_PROGRAM_ARB */

-   { 12000, 0x00008B30 }, /* GL_FRAGMENT_SHADER */

-   { 12019, 0x00008B30 }, /* GL_FRAGMENT_SHADER_ARB */

-   { 12042, 0x00008B8B }, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */

-   { 12077, 0x00008B8B }, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES */

-   { 12116, 0x00008D40 }, /* GL_FRAMEBUFFER */

-   { 12131, 0x00008215 }, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */

-   { 12168, 0x00008214 }, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */

-   { 12204, 0x00008210 }, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */

-   { 12245, 0x00008211 }, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */

-   { 12286, 0x00008216 }, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */

-   { 12323, 0x00008213 }, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */

-   { 12360, 0x00008DA7 }, /* GL_FRAMEBUFFER_ATTACHMENT_LAYERED */

-   { 12394, 0x00008DA7 }, /* GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB */

-   { 12432, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */

-   { 12470, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT */

-   { 12512, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES */

-   { 12554, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */

-   { 12592, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT */

-   { 12634, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES */

-   { 12676, 0x00008212 }, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */

-   { 12711, 0x00008217 }, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */

-   { 12750, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT */

-   { 12799, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES */

-   { 12848, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */

-   { 12896, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT */

-   { 12948, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES */

-   { 13000, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */

-   { 13040, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT */

-   { 13084, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */

-   { 13124, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT */

-   { 13168, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES */

-   { 13212, 0x00008CA6 }, /* GL_FRAMEBUFFER_BINDING */

-   { 13235, 0x00008CA6 }, /* GL_FRAMEBUFFER_BINDING_EXT */

-   { 13262, 0x00008CA6 }, /* GL_FRAMEBUFFER_BINDING_OES */

-   { 13289, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE */

-   { 13313, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE_EXT */

-   { 13341, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE_OES */

-   { 13369, 0x00008218 }, /* GL_FRAMEBUFFER_DEFAULT */

-   { 13392, 0x00008D40 }, /* GL_FRAMEBUFFER_EXT */

-   { 13411, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */

-   { 13448, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT */

-   { 13489, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES */

-   { 13530, 0x00008CD9 }, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS */

-   { 13567, 0x00008CD9 }, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */

-   { 13608, 0x00008CD9 }, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES */

-   { 13649, 0x00008CDB }, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER */

-   { 13687, 0x00008CDB }, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */

-   { 13729, 0x00008CDB }, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_OES */

-   { 13771, 0x00008CD8 }, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */

-   { 13822, 0x00008CDA }, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */

-   { 13860, 0x00008CDA }, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES */

-   { 13898, 0x00008DA9 }, /* GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB */

-   { 13940, 0x00008DA8 }, /* GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS */

-   { 13980, 0x00008DA8 }, /* GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB */

-   { 14024, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */

-   { 14069, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT */

-   { 14118, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES */

-   { 14167, 0x00008D56 }, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */

-   { 14205, 0x00008D56 }, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT */

-   { 14247, 0x00008CDC }, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER */

-   { 14285, 0x00008CDC }, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */

-   { 14327, 0x00008CDC }, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_OES */

-   { 14369, 0x00008D40 }, /* GL_FRAMEBUFFER_OES */

-   { 14388, 0x00008CDE }, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */

-   { 14420, 0x00008219 }, /* GL_FRAMEBUFFER_UNDEFINED */

-   { 14445, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED */

-   { 14472, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED_EXT */

-   { 14503, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED_OES */

-   { 14534, 0x00000404 }, /* GL_FRONT */

-   { 14543, 0x00000408 }, /* GL_FRONT_AND_BACK */

-   { 14561, 0x00000B46 }, /* GL_FRONT_FACE */

-   { 14575, 0x00000400 }, /* GL_FRONT_LEFT */

-   { 14589, 0x00000401 }, /* GL_FRONT_RIGHT */

-   { 14604, 0x00008006 }, /* GL_FUNC_ADD */

-   { 14616, 0x00008006 }, /* GL_FUNC_ADD_EXT */

-   { 14632, 0x00008006 }, /* GL_FUNC_ADD_OES */

-   { 14648, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT */

-   { 14673, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT_EXT */

-   { 14702, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT_OES */

-   { 14731, 0x0000800A }, /* GL_FUNC_SUBTRACT */

-   { 14748, 0x0000800A }, /* GL_FUNC_SUBTRACT_EXT */

-   { 14769, 0x0000800A }, /* GL_FUNC_SUBTRACT_OES */

-   { 14790, 0x00008191 }, /* GL_GENERATE_MIPMAP */

-   { 14809, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT */

-   { 14833, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT_SGIS */

-   { 14862, 0x00008191 }, /* GL_GENERATE_MIPMAP_SGIS */

-   { 14886, 0x00008917 }, /* GL_GEOMETRY_INPUT_TYPE */

-   { 14909, 0x00008DDB }, /* GL_GEOMETRY_INPUT_TYPE_ARB */

-   { 14936, 0x00008918 }, /* GL_GEOMETRY_OUTPUT_TYPE */

-   { 14960, 0x00008DDC }, /* GL_GEOMETRY_OUTPUT_TYPE_ARB */

-   { 14988, 0x00008DD9 }, /* GL_GEOMETRY_SHADER */

-   { 15007, 0x00008DD9 }, /* GL_GEOMETRY_SHADER_ARB */

-   { 15030, 0x00008916 }, /* GL_GEOMETRY_VERTICES_OUT */

-   { 15055, 0x00008DDA }, /* GL_GEOMETRY_VERTICES_OUT_ARB */

-   { 15084, 0x00000206 }, /* GL_GEQUAL */

-   { 15094, 0x00000204 }, /* GL_GREATER */

-   { 15105, 0x00001904 }, /* GL_GREEN */

-   { 15114, 0x00000D19 }, /* GL_GREEN_BIAS */

-   { 15128, 0x00000D53 }, /* GL_GREEN_BITS */

-   { 15142, 0x00008D95 }, /* GL_GREEN_INTEGER */

-   { 15159, 0x00008D95 }, /* GL_GREEN_INTEGER_EXT */

-   { 15180, 0x00000D18 }, /* GL_GREEN_SCALE */

-   { 15195, 0x0000140B }, /* GL_HALF_FLOAT */

-   { 15209, 0x00008D61 }, /* GL_HALF_FLOAT_OES */

-   { 15227, 0x00008DF2 }, /* GL_HIGH_FLOAT */

-   { 15241, 0x00008DF5 }, /* GL_HIGH_INT */

-   { 15253, 0x00008000 }, /* GL_HINT_BIT */

-   { 15265, 0x00008024 }, /* GL_HISTOGRAM */

-   { 15278, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE */

-   { 15302, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE_EXT */

-   { 15330, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE */

-   { 15353, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE_EXT */

-   { 15380, 0x00008024 }, /* GL_HISTOGRAM_EXT */

-   { 15397, 0x00008027 }, /* GL_HISTOGRAM_FORMAT */

-   { 15417, 0x00008027 }, /* GL_HISTOGRAM_FORMAT_EXT */

-   { 15441, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE */

-   { 15465, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE_EXT */

-   { 15493, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE */

-   { 15521, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE_EXT */

-   { 15553, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE */

-   { 15575, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE_EXT */

-   { 15601, 0x0000802D }, /* GL_HISTOGRAM_SINK */

-   { 15619, 0x0000802D }, /* GL_HISTOGRAM_SINK_EXT */

-   { 15641, 0x00008026 }, /* GL_HISTOGRAM_WIDTH */

-   { 15660, 0x00008026 }, /* GL_HISTOGRAM_WIDTH_EXT */

-   { 15683, 0x0000862A }, /* GL_IDENTITY_NV */

-   { 15698, 0x00008150 }, /* GL_IGNORE_BORDER_HP */

-   { 15718, 0x00008B9B }, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT */

-   { 15754, 0x00008B9B }, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */

-   { 15794, 0x00008B9A }, /* GL_IMPLEMENTATION_COLOR_READ_TYPE */

-   { 15828, 0x00008B9A }, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */

-   { 15866, 0x00001E02 }, /* GL_INCR */

-   { 15874, 0x00008507 }, /* GL_INCR_WRAP */

-   { 15887, 0x00008507 }, /* GL_INCR_WRAP_EXT */

-   { 15904, 0x00008222 }, /* GL_INDEX */

-   { 15913, 0x00008077 }, /* GL_INDEX_ARRAY */

-   { 15928, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING */

-   { 15958, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING_ARB */

-   { 15992, 0x00008091 }, /* GL_INDEX_ARRAY_POINTER */

-   { 16015, 0x00008086 }, /* GL_INDEX_ARRAY_STRIDE */

-   { 16037, 0x00008085 }, /* GL_INDEX_ARRAY_TYPE */

-   { 16057, 0x00000D51 }, /* GL_INDEX_BITS */

-   { 16071, 0x00000C20 }, /* GL_INDEX_CLEAR_VALUE */

-   { 16092, 0x00000BF1 }, /* GL_INDEX_LOGIC_OP */

-   { 16110, 0x00000C30 }, /* GL_INDEX_MODE */

-   { 16124, 0x00000D13 }, /* GL_INDEX_OFFSET */

-   { 16140, 0x00000D12 }, /* GL_INDEX_SHIFT */

-   { 16155, 0x00000C21 }, /* GL_INDEX_WRITEMASK */

-   { 16174, 0x00008B84 }, /* GL_INFO_LOG_LENGTH */

-   { 16193, 0x00001404 }, /* GL_INT */

-   { 16200, 0x00008049 }, /* GL_INTENSITY */

-   { 16213, 0x0000804C }, /* GL_INTENSITY12 */

-   { 16228, 0x0000804C }, /* GL_INTENSITY12_EXT */

-   { 16247, 0x0000804D }, /* GL_INTENSITY16 */

-   { 16262, 0x00008D8B }, /* GL_INTENSITY16I_EXT */

-   { 16282, 0x00008D79 }, /* GL_INTENSITY16UI_EXT */

-   { 16303, 0x0000804D }, /* GL_INTENSITY16_EXT */

-   { 16322, 0x00008D85 }, /* GL_INTENSITY32I_EXT */

-   { 16342, 0x00008D73 }, /* GL_INTENSITY32UI_EXT */

-   { 16363, 0x0000804A }, /* GL_INTENSITY4 */

-   { 16377, 0x0000804A }, /* GL_INTENSITY4_EXT */

-   { 16395, 0x0000804B }, /* GL_INTENSITY8 */

-   { 16409, 0x00008D91 }, /* GL_INTENSITY8I_EXT */

-   { 16428, 0x00008D7F }, /* GL_INTENSITY8UI_EXT */

-   { 16448, 0x0000804B }, /* GL_INTENSITY8_EXT */

-   { 16466, 0x00008049 }, /* GL_INTENSITY_EXT */

-   { 16483, 0x00008C8C }, /* GL_INTERLEAVED_ATTRIBS */

-   { 16506, 0x00008C8C }, /* GL_INTERLEAVED_ATTRIBS_EXT */

-   { 16533, 0x00008575 }, /* GL_INTERPOLATE */

-   { 16548, 0x00008575 }, /* GL_INTERPOLATE_ARB */

-   { 16567, 0x00008575 }, /* GL_INTERPOLATE_EXT */

-   { 16586, 0x00008DF7 }, /* GL_INT_10_10_10_2_OES */

-   { 16608, 0x00008DC9 }, /* GL_INT_SAMPLER_1D */

-   { 16626, 0x00008DCE }, /* GL_INT_SAMPLER_1D_ARRAY */

-   { 16650, 0x00008DCE }, /* GL_INT_SAMPLER_1D_ARRAY_EXT */

-   { 16678, 0x00008DC9 }, /* GL_INT_SAMPLER_1D_EXT */

-   { 16700, 0x00008DCA }, /* GL_INT_SAMPLER_2D */

-   { 16718, 0x00008DCF }, /* GL_INT_SAMPLER_2D_ARRAY */

-   { 16742, 0x00008DCF }, /* GL_INT_SAMPLER_2D_ARRAY_EXT */

-   { 16770, 0x00008DCA }, /* GL_INT_SAMPLER_2D_EXT */

-   { 16792, 0x00008DCD }, /* GL_INT_SAMPLER_2D_RECT */

-   { 16815, 0x00008DCD }, /* GL_INT_SAMPLER_2D_RECT_EXT */

-   { 16842, 0x00008DCB }, /* GL_INT_SAMPLER_3D */

-   { 16860, 0x00008DCB }, /* GL_INT_SAMPLER_3D_EXT */

-   { 16882, 0x00008DD0 }, /* GL_INT_SAMPLER_BUFFER */

-   { 16904, 0x00008DD0 }, /* GL_INT_SAMPLER_BUFFER_EXT */

-   { 16930, 0x00008DCC }, /* GL_INT_SAMPLER_CUBE */

-   { 16950, 0x00008DCC }, /* GL_INT_SAMPLER_CUBE_EXT */

-   { 16974, 0x00008B53 }, /* GL_INT_VEC2 */

-   { 16986, 0x00008B53 }, /* GL_INT_VEC2_ARB */

-   { 17002, 0x00008B54 }, /* GL_INT_VEC3 */

-   { 17014, 0x00008B54 }, /* GL_INT_VEC3_ARB */

-   { 17030, 0x00008B55 }, /* GL_INT_VEC4 */

-   { 17042, 0x00008B55 }, /* GL_INT_VEC4_ARB */

-   { 17058, 0x00000500 }, /* GL_INVALID_ENUM */

-   { 17074, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION */

-   { 17107, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */

-   { 17144, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_OES */

-   { 17181, 0x00000502 }, /* GL_INVALID_OPERATION */

-   { 17202, 0x00000501 }, /* GL_INVALID_VALUE */

-   { 17219, 0x0000862B }, /* GL_INVERSE_NV */

-   { 17233, 0x0000862D }, /* GL_INVERSE_TRANSPOSE_NV */

-   { 17257, 0x0000150A }, /* GL_INVERT */

-   { 17267, 0x00001E00 }, /* GL_KEEP */

-   { 17275, 0x00008E4E }, /* GL_LAST_VERTEX_CONVENTION */

-   { 17301, 0x00008E4E }, /* GL_LAST_VERTEX_CONVENTION_EXT */

-   { 17331, 0x00000406 }, /* GL_LEFT */

-   { 17339, 0x00000203 }, /* GL_LEQUAL */

-   { 17349, 0x00000201 }, /* GL_LESS */

-   { 17357, 0x00004000 }, /* GL_LIGHT0 */

-   { 17367, 0x00004001 }, /* GL_LIGHT1 */

-   { 17377, 0x00004002 }, /* GL_LIGHT2 */

-   { 17387, 0x00004003 }, /* GL_LIGHT3 */

-   { 17397, 0x00004004 }, /* GL_LIGHT4 */

-   { 17407, 0x00004005 }, /* GL_LIGHT5 */

-   { 17417, 0x00004006 }, /* GL_LIGHT6 */

-   { 17427, 0x00004007 }, /* GL_LIGHT7 */

-   { 17437, 0x00000B50 }, /* GL_LIGHTING */

-   { 17449, 0x00000040 }, /* GL_LIGHTING_BIT */

-   { 17465, 0x00000B53 }, /* GL_LIGHT_MODEL_AMBIENT */

-   { 17488, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL */

-   { 17517, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL_EXT */

-   { 17550, 0x00000B51 }, /* GL_LIGHT_MODEL_LOCAL_VIEWER */

-   { 17578, 0x00000B52 }, /* GL_LIGHT_MODEL_TWO_SIDE */

-   { 17602, 0x00001B01 }, /* GL_LINE */

-   { 17610, 0x00002601 }, /* GL_LINEAR */

-   { 17620, 0x00001208 }, /* GL_LINEAR_ATTENUATION */

-   { 17642, 0x00008170 }, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */

-   { 17672, 0x0000844F }, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */

-   { 17703, 0x00002703 }, /* GL_LINEAR_MIPMAP_LINEAR */

-   { 17727, 0x00002701 }, /* GL_LINEAR_MIPMAP_NEAREST */

-   { 17752, 0x00000001 }, /* GL_LINES */

-   { 17761, 0x0000000A }, /* GL_LINES_ADJACENCY */

-   { 17780, 0x0000000A }, /* GL_LINES_ADJACENCY_ARB */

-   { 17803, 0x00000004 }, /* GL_LINE_BIT */

-   { 17815, 0x00000002 }, /* GL_LINE_LOOP */

-   { 17828, 0x00000707 }, /* GL_LINE_RESET_TOKEN */

-   { 17848, 0x00000B20 }, /* GL_LINE_SMOOTH */

-   { 17863, 0x00000C52 }, /* GL_LINE_SMOOTH_HINT */

-   { 17883, 0x00000B24 }, /* GL_LINE_STIPPLE */

-   { 17899, 0x00000B25 }, /* GL_LINE_STIPPLE_PATTERN */

-   { 17923, 0x00000B26 }, /* GL_LINE_STIPPLE_REPEAT */

-   { 17946, 0x00000003 }, /* GL_LINE_STRIP */

-   { 17960, 0x0000000B }, /* GL_LINE_STRIP_ADJACENCY */

-   { 17984, 0x0000000B }, /* GL_LINE_STRIP_ADJACENCY_ARB */

-   { 18012, 0x00000702 }, /* GL_LINE_TOKEN */

-   { 18026, 0x00000B21 }, /* GL_LINE_WIDTH */

-   { 18040, 0x00000B23 }, /* GL_LINE_WIDTH_GRANULARITY */

-   { 18066, 0x00000B22 }, /* GL_LINE_WIDTH_RANGE */

-   { 18086, 0x00008B82 }, /* GL_LINK_STATUS */

-   { 18101, 0x00000B32 }, /* GL_LIST_BASE */

-   { 18114, 0x00020000 }, /* GL_LIST_BIT */

-   { 18126, 0x00000B33 }, /* GL_LIST_INDEX */

-   { 18140, 0x00000B30 }, /* GL_LIST_MODE */

-   { 18153, 0x00000101 }, /* GL_LOAD */

-   { 18161, 0x00000BF1 }, /* GL_LOGIC_OP */

-   { 18173, 0x00000BF0 }, /* GL_LOGIC_OP_MODE */

-   { 18190, 0x00008CA1 }, /* GL_LOWER_LEFT */

-   { 18204, 0x00008DF0 }, /* GL_LOW_FLOAT */

-   { 18217, 0x00008DF3 }, /* GL_LOW_INT */

-   { 18228, 0x00001909 }, /* GL_LUMINANCE */

-   { 18241, 0x00008041 }, /* GL_LUMINANCE12 */

-   { 18256, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12 */

-   { 18279, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12_EXT */

-   { 18306, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4 */

-   { 18328, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4_EXT */

-   { 18354, 0x00008041 }, /* GL_LUMINANCE12_EXT */

-   { 18373, 0x00008042 }, /* GL_LUMINANCE16 */

-   { 18388, 0x00008D8C }, /* GL_LUMINANCE16I_EXT */

-   { 18408, 0x00008D7A }, /* GL_LUMINANCE16UI_EXT */

-   { 18429, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16 */

-   { 18452, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16_EXT */

-   { 18479, 0x00008042 }, /* GL_LUMINANCE16_EXT */

-   { 18498, 0x00008D86 }, /* GL_LUMINANCE32I_EXT */

-   { 18518, 0x00008D74 }, /* GL_LUMINANCE32UI_EXT */

-   { 18539, 0x0000803F }, /* GL_LUMINANCE4 */

-   { 18553, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4 */

-   { 18574, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4_EXT */

-   { 18599, 0x0000803F }, /* GL_LUMINANCE4_EXT */

-   { 18617, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2 */

-   { 18638, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2_EXT */

-   { 18663, 0x00008040 }, /* GL_LUMINANCE8 */

-   { 18677, 0x00008D92 }, /* GL_LUMINANCE8I_EXT */

-   { 18696, 0x00008D80 }, /* GL_LUMINANCE8UI_EXT */

-   { 18716, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8 */

-   { 18737, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8_EXT */

-   { 18762, 0x00008040 }, /* GL_LUMINANCE8_EXT */

-   { 18780, 0x0000190A }, /* GL_LUMINANCE_ALPHA */

-   { 18799, 0x00008D8D }, /* GL_LUMINANCE_ALPHA16I_EXT */

-   { 18825, 0x00008D7B }, /* GL_LUMINANCE_ALPHA16UI_EXT */

-   { 18852, 0x00008D87 }, /* GL_LUMINANCE_ALPHA32I_EXT */

-   { 18878, 0x00008D75 }, /* GL_LUMINANCE_ALPHA32UI_EXT */

-   { 18905, 0x00008D93 }, /* GL_LUMINANCE_ALPHA8I_EXT */

-   { 18930, 0x00008D81 }, /* GL_LUMINANCE_ALPHA8UI_EXT */

-   { 18956, 0x00008D9D }, /* GL_LUMINANCE_ALPHA_INTEGER_EXT */

-   { 18987, 0x00008D9C }, /* GL_LUMINANCE_INTEGER_EXT */

-   { 19012, 0x0000821B }, /* GL_MAJOR_VERSION */

-   { 19029, 0x00000D90 }, /* GL_MAP1_COLOR_4 */

-   { 19045, 0x00000DD0 }, /* GL_MAP1_GRID_DOMAIN */

-   { 19065, 0x00000DD1 }, /* GL_MAP1_GRID_SEGMENTS */

-   { 19087, 0x00000D91 }, /* GL_MAP1_INDEX */

-   { 19101, 0x00000D92 }, /* GL_MAP1_NORMAL */

-   { 19116, 0x00000D93 }, /* GL_MAP1_TEXTURE_COORD_1 */

-   { 19140, 0x00000D94 }, /* GL_MAP1_TEXTURE_COORD_2 */

-   { 19164, 0x00000D95 }, /* GL_MAP1_TEXTURE_COORD_3 */

-   { 19188, 0x00000D96 }, /* GL_MAP1_TEXTURE_COORD_4 */

-   { 19212, 0x00000D97 }, /* GL_MAP1_VERTEX_3 */

-   { 19229, 0x00000D98 }, /* GL_MAP1_VERTEX_4 */

-   { 19246, 0x00008660 }, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */

-   { 19274, 0x0000866A }, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */

-   { 19303, 0x0000866B }, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */

-   { 19332, 0x0000866C }, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */

-   { 19361, 0x0000866D }, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */

-   { 19390, 0x0000866E }, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */

-   { 19419, 0x0000866F }, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */

-   { 19448, 0x00008661 }, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */

-   { 19476, 0x00008662 }, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */

-   { 19504, 0x00008663 }, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */

-   { 19532, 0x00008664 }, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */

-   { 19560, 0x00008665 }, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */

-   { 19588, 0x00008666 }, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */

-   { 19616, 0x00008667 }, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */

-   { 19644, 0x00008668 }, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */

-   { 19672, 0x00008669 }, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */

-   { 19700, 0x00000DB0 }, /* GL_MAP2_COLOR_4 */

-   { 19716, 0x00000DD2 }, /* GL_MAP2_GRID_DOMAIN */

-   { 19736, 0x00000DD3 }, /* GL_MAP2_GRID_SEGMENTS */

-   { 19758, 0x00000DB1 }, /* GL_MAP2_INDEX */

-   { 19772, 0x00000DB2 }, /* GL_MAP2_NORMAL */

-   { 19787, 0x00000DB3 }, /* GL_MAP2_TEXTURE_COORD_1 */

-   { 19811, 0x00000DB4 }, /* GL_MAP2_TEXTURE_COORD_2 */

-   { 19835, 0x00000DB5 }, /* GL_MAP2_TEXTURE_COORD_3 */

-   { 19859, 0x00000DB6 }, /* GL_MAP2_TEXTURE_COORD_4 */

-   { 19883, 0x00000DB7 }, /* GL_MAP2_VERTEX_3 */

-   { 19900, 0x00000DB8 }, /* GL_MAP2_VERTEX_4 */

-   { 19917, 0x00008670 }, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */

-   { 19945, 0x0000867A }, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */

-   { 19974, 0x0000867B }, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */

-   { 20003, 0x0000867C }, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */

-   { 20032, 0x0000867D }, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */

-   { 20061, 0x0000867E }, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */

-   { 20090, 0x0000867F }, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */

-   { 20119, 0x00008671 }, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */

-   { 20147, 0x00008672 }, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */

-   { 20175, 0x00008673 }, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */

-   { 20203, 0x00008674 }, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */

-   { 20231, 0x00008675 }, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */

-   { 20259, 0x00008676 }, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */

-   { 20287, 0x00008677 }, /* GL_MAP2_VERTEX_ATTRIB7_4_NV */

-   { 20315, 0x00008678 }, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */

-   { 20343, 0x00008679 }, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */

-   { 20371, 0x00000D10 }, /* GL_MAP_COLOR */

-   { 20384, 0x00000010 }, /* GL_MAP_FLUSH_EXPLICIT_BIT */

-   { 20410, 0x00000008 }, /* GL_MAP_INVALIDATE_BUFFER_BIT */

-   { 20439, 0x00000004 }, /* GL_MAP_INVALIDATE_RANGE_BIT */

-   { 20467, 0x00000001 }, /* GL_MAP_READ_BIT */

-   { 20483, 0x00000D11 }, /* GL_MAP_STENCIL */

-   { 20498, 0x00000020 }, /* GL_MAP_UNSYNCHRONIZED_BIT */

-   { 20524, 0x00000002 }, /* GL_MAP_WRITE_BIT */

-   { 20541, 0x000088C0 }, /* GL_MATRIX0_ARB */

-   { 20556, 0x00008630 }, /* GL_MATRIX0_NV */

-   { 20570, 0x000088CA }, /* GL_MATRIX10_ARB */

-   { 20586, 0x000088CB }, /* GL_MATRIX11_ARB */

-   { 20602, 0x000088CC }, /* GL_MATRIX12_ARB */

-   { 20618, 0x000088CD }, /* GL_MATRIX13_ARB */

-   { 20634, 0x000088CE }, /* GL_MATRIX14_ARB */

-   { 20650, 0x000088CF }, /* GL_MATRIX15_ARB */

-   { 20666, 0x000088D0 }, /* GL_MATRIX16_ARB */

-   { 20682, 0x000088D1 }, /* GL_MATRIX17_ARB */

-   { 20698, 0x000088D2 }, /* GL_MATRIX18_ARB */

-   { 20714, 0x000088D3 }, /* GL_MATRIX19_ARB */

-   { 20730, 0x000088C1 }, /* GL_MATRIX1_ARB */

-   { 20745, 0x00008631 }, /* GL_MATRIX1_NV */

-   { 20759, 0x000088D4 }, /* GL_MATRIX20_ARB */

-   { 20775, 0x000088D5 }, /* GL_MATRIX21_ARB */

-   { 20791, 0x000088D6 }, /* GL_MATRIX22_ARB */

-   { 20807, 0x000088D7 }, /* GL_MATRIX23_ARB */

-   { 20823, 0x000088D8 }, /* GL_MATRIX24_ARB */

-   { 20839, 0x000088D9 }, /* GL_MATRIX25_ARB */

-   { 20855, 0x000088DA }, /* GL_MATRIX26_ARB */

-   { 20871, 0x000088DB }, /* GL_MATRIX27_ARB */

-   { 20887, 0x000088DC }, /* GL_MATRIX28_ARB */

-   { 20903, 0x000088DD }, /* GL_MATRIX29_ARB */

-   { 20919, 0x000088C2 }, /* GL_MATRIX2_ARB */

-   { 20934, 0x00008632 }, /* GL_MATRIX2_NV */

-   { 20948, 0x000088DE }, /* GL_MATRIX30_ARB */

-   { 20964, 0x000088DF }, /* GL_MATRIX31_ARB */

-   { 20980, 0x000088C3 }, /* GL_MATRIX3_ARB */

-   { 20995, 0x00008633 }, /* GL_MATRIX3_NV */

-   { 21009, 0x000088C4 }, /* GL_MATRIX4_ARB */

-   { 21024, 0x00008634 }, /* GL_MATRIX4_NV */

-   { 21038, 0x000088C5 }, /* GL_MATRIX5_ARB */

-   { 21053, 0x00008635 }, /* GL_MATRIX5_NV */

-   { 21067, 0x000088C6 }, /* GL_MATRIX6_ARB */

-   { 21082, 0x00008636 }, /* GL_MATRIX6_NV */

-   { 21096, 0x000088C7 }, /* GL_MATRIX7_ARB */

-   { 21111, 0x00008637 }, /* GL_MATRIX7_NV */

-   { 21125, 0x000088C8 }, /* GL_MATRIX8_ARB */

-   { 21140, 0x000088C9 }, /* GL_MATRIX9_ARB */

-   { 21155, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_ARB */

-   { 21181, 0x00008B9E }, /* GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES */

-   { 21222, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_OES */

-   { 21248, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */

-   { 21282, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_OES */

-   { 21316, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */

-   { 21347, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_OES */

-   { 21378, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */

-   { 21411, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_OES */

-   { 21444, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */

-   { 21475, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_OES */

-   { 21506, 0x00000BA0 }, /* GL_MATRIX_MODE */

-   { 21521, 0x00008840 }, /* GL_MATRIX_PALETTE_ARB */

-   { 21543, 0x00008840 }, /* GL_MATRIX_PALETTE_OES */

-   { 21565, 0x00008008 }, /* GL_MAX */

-   { 21572, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE */

-   { 21595, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE_OES */

-   { 21622, 0x000088FF }, /* GL_MAX_ARRAY_TEXTURE_LAYERS */

-   { 21650, 0x000088FF }, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */

-   { 21682, 0x00000D35 }, /* GL_MAX_ATTRIB_STACK_DEPTH */

-   { 21708, 0x00000D3B }, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */

-   { 21741, 0x00008177 }, /* GL_MAX_CLIPMAP_DEPTH_SGIX */

-   { 21767, 0x00008178 }, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */

-   { 21801, 0x00000D32 }, /* GL_MAX_CLIP_DISTANCES */

-   { 21823, 0x00000D32 }, /* GL_MAX_CLIP_PLANES */

-   { 21842, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS */

-   { 21867, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS_EXT */

-   { 21896, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */

-   { 21928, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI */

-   { 21964, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */

-   { 22000, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB */

-   { 22040, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT */

-   { 22066, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT_EXT */

-   { 22096, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH */

-   { 22121, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH_EXT */

-   { 22150, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */

-   { 22179, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB */

-   { 22212, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_OES */

-   { 22245, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS */

-   { 22265, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ARB */

-   { 22289, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ATI */

-   { 22313, 0x000080E9 }, /* GL_MAX_ELEMENTS_INDICES */

-   { 22337, 0x000080E8 }, /* GL_MAX_ELEMENTS_VERTICES */

-   { 22362, 0x00000D30 }, /* GL_MAX_EVAL_ORDER */

-   { 22380, 0x00008008 }, /* GL_MAX_EXT */

-   { 22391, 0x00009125 }, /* GL_MAX_FRAGMENT_INPUT_COMPONENTS */

-   { 22424, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */

-   { 22459, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB */

-   { 22498, 0x00008DFD }, /* GL_MAX_FRAGMENT_UNIFORM_VECTORS */

-   { 22530, 0x00009123 }, /* GL_MAX_GEOMETRY_INPUT_COMPONENTS */

-   { 22563, 0x00009124 }, /* GL_MAX_GEOMETRY_OUTPUT_COMPONENTS */

-   { 22597, 0x00008DE0 }, /* GL_MAX_GEOMETRY_OUTPUT_VERTICES */

-   { 22629, 0x00008DE0 }, /* GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB */

-   { 22665, 0x00008C29 }, /* GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS */

-   { 22701, 0x00008C29 }, /* GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB */

-   { 22741, 0x00008DE1 }, /* GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS */

-   { 22781, 0x00008DE1 }, /* GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB */

-   { 22825, 0x00008DDF }, /* GL_MAX_GEOMETRY_UNIFORM_COMPONENTS */

-   { 22860, 0x00008DDF }, /* GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB */

-   { 22899, 0x00008DDD }, /* GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB */

-   { 22938, 0x00000D31 }, /* GL_MAX_LIGHTS */

-   { 22952, 0x00000B31 }, /* GL_MAX_LIST_NESTING */

-   { 22972, 0x00008841 }, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */

-   { 23010, 0x00000D36 }, /* GL_MAX_MODELVIEW_STACK_DEPTH */

-   { 23039, 0x00000D37 }, /* GL_MAX_NAME_STACK_DEPTH */

-   { 23063, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_ARB */

-   { 23091, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_OES */

-   { 23119, 0x00000D34 }, /* GL_MAX_PIXEL_MAP_TABLE */

-   { 23142, 0x000088B1 }, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */

-   { 23179, 0x0000880B }, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */

-   { 23215, 0x000088AD }, /* GL_MAX_PROGRAM_ATTRIBS_ARB */

-   { 23242, 0x000088F5 }, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */

-   { 23271, 0x000088B5 }, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */

-   { 23305, 0x000088F4 }, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */

-   { 23341, 0x000088F6 }, /* GL_MAX_PROGRAM_IF_DEPTH_NV */

-   { 23368, 0x000088A1 }, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */

-   { 23400, 0x000088B4 }, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */

-   { 23436, 0x000088F8 }, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */

-   { 23465, 0x000088F7 }, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */

-   { 23494, 0x0000862F }, /* GL_MAX_PROGRAM_MATRICES_ARB */

-   { 23522, 0x0000862E }, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */

-   { 23560, 0x000088B3 }, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */

-   { 23604, 0x0000880E }, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */

-   { 23647, 0x000088AF }, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */

-   { 23681, 0x000088A3 }, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */

-   { 23720, 0x000088AB }, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */

-   { 23757, 0x000088A7 }, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */

-   { 23795, 0x00008810 }, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */

-   { 23838, 0x0000880F }, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */

-   { 23881, 0x000088A9 }, /* GL_MAX_PROGRAM_PARAMETERS_ARB */

-   { 23911, 0x000088A5 }, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */

-   { 23942, 0x00008905 }, /* GL_MAX_PROGRAM_TEXEL_OFFSET */

-   { 23970, 0x00008905 }, /* GL_MAX_PROGRAM_TEXEL_OFFSET_EXT */

-   { 24002, 0x0000880D }, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */

-   { 24038, 0x0000880C }, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */

-   { 24074, 0x00000D38 }, /* GL_MAX_PROJECTION_STACK_DEPTH */

-   { 24104, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE */

-   { 24134, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */

-   { 24168, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_NV */

-   { 24201, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE */

-   { 24226, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_EXT */

-   { 24255, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_OES */

-   { 24284, 0x00008D57 }, /* GL_MAX_SAMPLES */

-   { 24299, 0x00008D57 }, /* GL_MAX_SAMPLES_EXT */

-   { 24318, 0x00009111 }, /* GL_MAX_SERVER_WAIT_TIMEOUT */

-   { 24345, 0x00008504 }, /* GL_MAX_SHININESS_NV */

-   { 24365, 0x00008505 }, /* GL_MAX_SPOT_EXPONENT_NV */

-   { 24389, 0x00008C2B }, /* GL_MAX_TEXTURE_BUFFER_SIZE */

-   { 24416, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS */

-   { 24438, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS_ARB */

-   { 24464, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS */

-   { 24491, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS_ARB */

-   { 24522, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS */

-   { 24546, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS_EXT */

-   { 24574, 0x000084FF }, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */

-   { 24608, 0x00000D33 }, /* GL_MAX_TEXTURE_SIZE */

-   { 24628, 0x00000D39 }, /* GL_MAX_TEXTURE_STACK_DEPTH */

-   { 24655, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS */

-   { 24676, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS_ARB */

-   { 24701, 0x0000862F }, /* GL_MAX_TRACK_MATRICES_NV */

-   { 24726, 0x0000862E }, /* GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */

-   { 24761, 0x00008C8A }, /* GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS */

-   { 24810, 0x00008C8A }, /* GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT */

-   { 24863, 0x00008C8B }, /* GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS */

-   { 24906, 0x00008C8B }, /* GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT */

-   { 24953, 0x00008C80 }, /* GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS */

-   { 24999, 0x00008C80 }, /* GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT */

-   { 25049, 0x00008B4B }, /* GL_MAX_VARYING_COMPONENTS */

-   { 25075, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS */

-   { 25097, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS_ARB */

-   { 25123, 0x00008DFC }, /* GL_MAX_VARYING_VECTORS */

-   { 25146, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS */

-   { 25168, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS_ARB */

-   { 25194, 0x00009122 }, /* GL_MAX_VERTEX_OUTPUT_COMPONENTS */

-   { 25226, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */

-   { 25260, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */

-   { 25298, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */

-   { 25331, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB */

-   { 25368, 0x00008DFB }, /* GL_MAX_VERTEX_UNIFORM_VECTORS */

-   { 25398, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_ARB */

-   { 25422, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_OES */

-   { 25446, 0x00008DDE }, /* GL_MAX_VERTEX_VARYING_COMPONENTS_ARB */

-   { 25483, 0x00000D3A }, /* GL_MAX_VIEWPORT_DIMS */

-   { 25504, 0x00008DF1 }, /* GL_MEDIUM_FLOAT */

-   { 25520, 0x00008DF4 }, /* GL_MEDIUM_INT */

-   { 25534, 0x00008007 }, /* GL_MIN */

-   { 25541, 0x0000802E }, /* GL_MINMAX */

-   { 25551, 0x0000802E }, /* GL_MINMAX_EXT */

-   { 25565, 0x0000802F }, /* GL_MINMAX_FORMAT */

-   { 25582, 0x0000802F }, /* GL_MINMAX_FORMAT_EXT */

-   { 25603, 0x00008030 }, /* GL_MINMAX_SINK */

-   { 25618, 0x00008030 }, /* GL_MINMAX_SINK_EXT */

-   { 25637, 0x0000821C }, /* GL_MINOR_VERSION */

-   { 25654, 0x00008007 }, /* GL_MIN_EXT */

-   { 25665, 0x00008904 }, /* GL_MIN_PROGRAM_TEXEL_OFFSET */

-   { 25693, 0x00008904 }, /* GL_MIN_PROGRAM_TEXEL_OFFSET_EXT */

-   { 25725, 0x00008370 }, /* GL_MIRRORED_REPEAT */

-   { 25744, 0x00008370 }, /* GL_MIRRORED_REPEAT_ARB */

-   { 25767, 0x00008370 }, /* GL_MIRRORED_REPEAT_IBM */

-   { 25790, 0x00008742 }, /* GL_MIRROR_CLAMP_ATI */

-   { 25810, 0x00008742 }, /* GL_MIRROR_CLAMP_EXT */

-   { 25830, 0x00008912 }, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */

-   { 25860, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_ATI */

-   { 25888, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */

-   { 25916, 0x00001700 }, /* GL_MODELVIEW */

-   { 25929, 0x00001700 }, /* GL_MODELVIEW0_ARB */

-   { 25947, 0x0000872A }, /* GL_MODELVIEW10_ARB */

-   { 25966, 0x0000872B }, /* GL_MODELVIEW11_ARB */

-   { 25985, 0x0000872C }, /* GL_MODELVIEW12_ARB */

-   { 26004, 0x0000872D }, /* GL_MODELVIEW13_ARB */

-   { 26023, 0x0000872E }, /* GL_MODELVIEW14_ARB */

-   { 26042, 0x0000872F }, /* GL_MODELVIEW15_ARB */

-   { 26061, 0x00008730 }, /* GL_MODELVIEW16_ARB */

-   { 26080, 0x00008731 }, /* GL_MODELVIEW17_ARB */

-   { 26099, 0x00008732 }, /* GL_MODELVIEW18_ARB */

-   { 26118, 0x00008733 }, /* GL_MODELVIEW19_ARB */

-   { 26137, 0x0000850A }, /* GL_MODELVIEW1_ARB */

-   { 26155, 0x00008734 }, /* GL_MODELVIEW20_ARB */

-   { 26174, 0x00008735 }, /* GL_MODELVIEW21_ARB */

-   { 26193, 0x00008736 }, /* GL_MODELVIEW22_ARB */

-   { 26212, 0x00008737 }, /* GL_MODELVIEW23_ARB */

-   { 26231, 0x00008738 }, /* GL_MODELVIEW24_ARB */

-   { 26250, 0x00008739 }, /* GL_MODELVIEW25_ARB */

-   { 26269, 0x0000873A }, /* GL_MODELVIEW26_ARB */

-   { 26288, 0x0000873B }, /* GL_MODELVIEW27_ARB */

-   { 26307, 0x0000873C }, /* GL_MODELVIEW28_ARB */

-   { 26326, 0x0000873D }, /* GL_MODELVIEW29_ARB */

-   { 26345, 0x00008722 }, /* GL_MODELVIEW2_ARB */

-   { 26363, 0x0000873E }, /* GL_MODELVIEW30_ARB */

-   { 26382, 0x0000873F }, /* GL_MODELVIEW31_ARB */

-   { 26401, 0x00008723 }, /* GL_MODELVIEW3_ARB */

-   { 26419, 0x00008724 }, /* GL_MODELVIEW4_ARB */

-   { 26437, 0x00008725 }, /* GL_MODELVIEW5_ARB */

-   { 26455, 0x00008726 }, /* GL_MODELVIEW6_ARB */

-   { 26473, 0x00008727 }, /* GL_MODELVIEW7_ARB */

-   { 26491, 0x00008728 }, /* GL_MODELVIEW8_ARB */

-   { 26509, 0x00008729 }, /* GL_MODELVIEW9_ARB */

-   { 26527, 0x00000BA6 }, /* GL_MODELVIEW_MATRIX */

-   { 26547, 0x0000898D }, /* GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES */

-   { 26589, 0x00008629 }, /* GL_MODELVIEW_PROJECTION_NV */

-   { 26616, 0x00000BA3 }, /* GL_MODELVIEW_STACK_DEPTH */

-   { 26641, 0x00002100 }, /* GL_MODULATE */

-   { 26653, 0x00008744 }, /* GL_MODULATE_ADD_ATI */

-   { 26673, 0x00008745 }, /* GL_MODULATE_SIGNED_ADD_ATI */

-   { 26700, 0x00008746 }, /* GL_MODULATE_SUBTRACT_ATI */

-   { 26725, 0x00000103 }, /* GL_MULT */

-   { 26733, 0x0000809D }, /* GL_MULTISAMPLE */

-   { 26748, 0x000086B2 }, /* GL_MULTISAMPLE_3DFX */

-   { 26768, 0x0000809D }, /* GL_MULTISAMPLE_ARB */

-   { 26787, 0x20000000 }, /* GL_MULTISAMPLE_BIT */

-   { 26806, 0x20000000 }, /* GL_MULTISAMPLE_BIT_3DFX */

-   { 26830, 0x20000000 }, /* GL_MULTISAMPLE_BIT_ARB */

-   { 26853, 0x00008534 }, /* GL_MULTISAMPLE_FILTER_HINT_NV */

-   { 26883, 0x00002A25 }, /* GL_N3F_V3F */

-   { 26894, 0x00000D70 }, /* GL_NAME_STACK_DEPTH */

-   { 26914, 0x0000150E }, /* GL_NAND */

-   { 26922, 0x00002600 }, /* GL_NEAREST */

-   { 26933, 0x0000844E }, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */

-   { 26964, 0x0000844D }, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */

-   { 26996, 0x00002702 }, /* GL_NEAREST_MIPMAP_LINEAR */

-   { 27021, 0x00002700 }, /* GL_NEAREST_MIPMAP_NEAREST */

-   { 27047, 0x00000200 }, /* GL_NEVER */

-   { 27056, 0x00001102 }, /* GL_NICEST */

-   { 27066, 0x00000000 }, /* GL_NONE */

-   { 27074, 0x00000000 }, /* GL_NONE_OES */

-   { 27086, 0x00001505 }, /* GL_NOOP */

-   { 27094, 0x00001508 }, /* GL_NOR */

-   { 27101, 0x00000BA1 }, /* GL_NORMALIZE */

-   { 27114, 0x00008075 }, /* GL_NORMAL_ARRAY */

-   { 27130, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING */

-   { 27161, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING_ARB */

-   { 27196, 0x0000808F }, /* GL_NORMAL_ARRAY_POINTER */

-   { 27220, 0x0000807F }, /* GL_NORMAL_ARRAY_STRIDE */

-   { 27243, 0x0000807E }, /* GL_NORMAL_ARRAY_TYPE */

-   { 27264, 0x00008511 }, /* GL_NORMAL_MAP */

-   { 27278, 0x00008511 }, /* GL_NORMAL_MAP_ARB */

-   { 27296, 0x00008511 }, /* GL_NORMAL_MAP_NV */

-   { 27313, 0x00008511 }, /* GL_NORMAL_MAP_OES */

-   { 27331, 0x00000205 }, /* GL_NOTEQUAL */

-   { 27343, 0x00000000 }, /* GL_NO_ERROR */

-   { 27355, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */

-   { 27389, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB */

-   { 27427, 0x0000821D }, /* GL_NUM_EXTENSIONS */

-   { 27445, 0x000087FE }, /* GL_NUM_PROGRAM_BINARY_FORMATS_OES */

-   { 27479, 0x00008DF9 }, /* GL_NUM_SHADER_BINARY_FORMATS */

-   { 27508, 0x00008B89 }, /* GL_OBJECT_ACTIVE_ATTRIBUTES_ARB */

-   { 27540, 0x00008B8A }, /* GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB */

-   { 27582, 0x00008B86 }, /* GL_OBJECT_ACTIVE_UNIFORMS_ARB */

-   { 27612, 0x00008B87 }, /* GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB */

-   { 27652, 0x00008B85 }, /* GL_OBJECT_ATTACHED_OBJECTS_ARB */

-   { 27683, 0x00008B81 }, /* GL_OBJECT_COMPILE_STATUS_ARB */

-   { 27712, 0x00008B80 }, /* GL_OBJECT_DELETE_STATUS_ARB */

-   { 27740, 0x00008B84 }, /* GL_OBJECT_INFO_LOG_LENGTH_ARB */

-   { 27770, 0x00002401 }, /* GL_OBJECT_LINEAR */

-   { 27787, 0x00008B82 }, /* GL_OBJECT_LINK_STATUS_ARB */

-   { 27813, 0x00002501 }, /* GL_OBJECT_PLANE */

-   { 27829, 0x00008B88 }, /* GL_OBJECT_SHADER_SOURCE_LENGTH_ARB */

-   { 27864, 0x00008B4F }, /* GL_OBJECT_SUBTYPE_ARB */

-   { 27886, 0x00009112 }, /* GL_OBJECT_TYPE */

-   { 27901, 0x00008B4E }, /* GL_OBJECT_TYPE_ARB */

-   { 27920, 0x00008B83 }, /* GL_OBJECT_VALIDATE_STATUS_ARB */

-   { 27950, 0x00008165 }, /* GL_OCCLUSION_TEST_HP */

-   { 27971, 0x00008166 }, /* GL_OCCLUSION_TEST_RESULT_HP */

-   { 27999, 0x00000001 }, /* GL_ONE */

-   { 28006, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA */

-   { 28034, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA_EXT */

-   { 28066, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR */

-   { 28094, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR_EXT */

-   { 28126, 0x00000305 }, /* GL_ONE_MINUS_DST_ALPHA */

-   { 28149, 0x00000307 }, /* GL_ONE_MINUS_DST_COLOR */

-   { 28172, 0x00000303 }, /* GL_ONE_MINUS_SRC_ALPHA */

-   { 28195, 0x00000301 }, /* GL_ONE_MINUS_SRC_COLOR */

-   { 28218, 0x00008598 }, /* GL_OPERAND0_ALPHA */

-   { 28236, 0x00008598 }, /* GL_OPERAND0_ALPHA_ARB */

-   { 28258, 0x00008598 }, /* GL_OPERAND0_ALPHA_EXT */

-   { 28280, 0x00008590 }, /* GL_OPERAND0_RGB */

-   { 28296, 0x00008590 }, /* GL_OPERAND0_RGB_ARB */

-   { 28316, 0x00008590 }, /* GL_OPERAND0_RGB_EXT */

-   { 28336, 0x00008599 }, /* GL_OPERAND1_ALPHA */

-   { 28354, 0x00008599 }, /* GL_OPERAND1_ALPHA_ARB */

-   { 28376, 0x00008599 }, /* GL_OPERAND1_ALPHA_EXT */

-   { 28398, 0x00008591 }, /* GL_OPERAND1_RGB */

-   { 28414, 0x00008591 }, /* GL_OPERAND1_RGB_ARB */

-   { 28434, 0x00008591 }, /* GL_OPERAND1_RGB_EXT */

-   { 28454, 0x0000859A }, /* GL_OPERAND2_ALPHA */

-   { 28472, 0x0000859A }, /* GL_OPERAND2_ALPHA_ARB */

-   { 28494, 0x0000859A }, /* GL_OPERAND2_ALPHA_EXT */

-   { 28516, 0x00008592 }, /* GL_OPERAND2_RGB */

-   { 28532, 0x00008592 }, /* GL_OPERAND2_RGB_ARB */

-   { 28552, 0x00008592 }, /* GL_OPERAND2_RGB_EXT */

-   { 28572, 0x0000859B }, /* GL_OPERAND3_ALPHA_NV */

-   { 28593, 0x00008593 }, /* GL_OPERAND3_RGB_NV */

-   { 28612, 0x00001507 }, /* GL_OR */

-   { 28618, 0x00000A01 }, /* GL_ORDER */

-   { 28627, 0x0000150D }, /* GL_OR_INVERTED */

-   { 28642, 0x0000150B }, /* GL_OR_REVERSE */

-   { 28656, 0x00000505 }, /* GL_OUT_OF_MEMORY */

-   { 28673, 0x00000D05 }, /* GL_PACK_ALIGNMENT */

-   { 28691, 0x0000806C }, /* GL_PACK_IMAGE_HEIGHT */

-   { 28712, 0x00008758 }, /* GL_PACK_INVERT_MESA */

-   { 28732, 0x00000D01 }, /* GL_PACK_LSB_FIRST */

-   { 28750, 0x00000D02 }, /* GL_PACK_ROW_LENGTH */

-   { 28769, 0x0000806B }, /* GL_PACK_SKIP_IMAGES */

-   { 28789, 0x00000D04 }, /* GL_PACK_SKIP_PIXELS */

-   { 28809, 0x00000D03 }, /* GL_PACK_SKIP_ROWS */

-   { 28827, 0x00000D00 }, /* GL_PACK_SWAP_BYTES */

-   { 28846, 0x00008B92 }, /* GL_PALETTE4_R5_G6_B5_OES */

-   { 28871, 0x00008B94 }, /* GL_PALETTE4_RGB5_A1_OES */

-   { 28895, 0x00008B90 }, /* GL_PALETTE4_RGB8_OES */

-   { 28916, 0x00008B93 }, /* GL_PALETTE4_RGBA4_OES */

-   { 28938, 0x00008B91 }, /* GL_PALETTE4_RGBA8_OES */

-   { 28960, 0x00008B97 }, /* GL_PALETTE8_R5_G6_B5_OES */

-   { 28985, 0x00008B99 }, /* GL_PALETTE8_RGB5_A1_OES */

-   { 29009, 0x00008B95 }, /* GL_PALETTE8_RGB8_OES */

-   { 29030, 0x00008B98 }, /* GL_PALETTE8_RGBA4_OES */

-   { 29052, 0x00008B96 }, /* GL_PALETTE8_RGBA8_OES */

-   { 29074, 0x00000700 }, /* GL_PASS_THROUGH_TOKEN */

-   { 29096, 0x00000C50 }, /* GL_PERSPECTIVE_CORRECTION_HINT */

-   { 29127, 0x00000C79 }, /* GL_PIXEL_MAP_A_TO_A */

-   { 29147, 0x00000CB9 }, /* GL_PIXEL_MAP_A_TO_A_SIZE */

-   { 29172, 0x00000C78 }, /* GL_PIXEL_MAP_B_TO_B */

-   { 29192, 0x00000CB8 }, /* GL_PIXEL_MAP_B_TO_B_SIZE */

-   { 29217, 0x00000C77 }, /* GL_PIXEL_MAP_G_TO_G */

-   { 29237, 0x00000CB7 }, /* GL_PIXEL_MAP_G_TO_G_SIZE */

-   { 29262, 0x00000C75 }, /* GL_PIXEL_MAP_I_TO_A */

-   { 29282, 0x00000CB5 }, /* GL_PIXEL_MAP_I_TO_A_SIZE */

-   { 29307, 0x00000C74 }, /* GL_PIXEL_MAP_I_TO_B */

-   { 29327, 0x00000CB4 }, /* GL_PIXEL_MAP_I_TO_B_SIZE */

-   { 29352, 0x00000C73 }, /* GL_PIXEL_MAP_I_TO_G */

-   { 29372, 0x00000CB3 }, /* GL_PIXEL_MAP_I_TO_G_SIZE */

-   { 29397, 0x00000C70 }, /* GL_PIXEL_MAP_I_TO_I */

-   { 29417, 0x00000CB0 }, /* GL_PIXEL_MAP_I_TO_I_SIZE */

-   { 29442, 0x00000C72 }, /* GL_PIXEL_MAP_I_TO_R */

-   { 29462, 0x00000CB2 }, /* GL_PIXEL_MAP_I_TO_R_SIZE */

-   { 29487, 0x00000C76 }, /* GL_PIXEL_MAP_R_TO_R */

-   { 29507, 0x00000CB6 }, /* GL_PIXEL_MAP_R_TO_R_SIZE */

-   { 29532, 0x00000C71 }, /* GL_PIXEL_MAP_S_TO_S */

-   { 29552, 0x00000CB1 }, /* GL_PIXEL_MAP_S_TO_S_SIZE */

-   { 29577, 0x00000020 }, /* GL_PIXEL_MODE_BIT */

-   { 29595, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER */

-   { 29616, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING */

-   { 29645, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING_EXT */

-   { 29678, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER_EXT */

-   { 29703, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER */

-   { 29726, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING */

-   { 29757, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING_EXT */

-   { 29792, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER_EXT */

-   { 29819, 0x00001B00 }, /* GL_POINT */

-   { 29828, 0x00000000 }, /* GL_POINTS */

-   { 29838, 0x00000002 }, /* GL_POINT_BIT */

-   { 29851, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION */

-   { 29881, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_ARB */

-   { 29915, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_EXT */

-   { 29949, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_SGIS */

-   { 29984, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE */

-   { 30013, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_ARB */

-   { 30046, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_EXT */

-   { 30079, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_SGIS */

-   { 30113, 0x00000B11 }, /* GL_POINT_SIZE */

-   { 30127, 0x00008B9F }, /* GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES */

-   { 30166, 0x00008B9C }, /* GL_POINT_SIZE_ARRAY_OES */

-   { 30190, 0x0000898C }, /* GL_POINT_SIZE_ARRAY_POINTER_OES */

-   { 30222, 0x0000898B }, /* GL_POINT_SIZE_ARRAY_STRIDE_OES */

-   { 30253, 0x0000898A }, /* GL_POINT_SIZE_ARRAY_TYPE_OES */

-   { 30282, 0x00000B13 }, /* GL_POINT_SIZE_GRANULARITY */

-   { 30308, 0x00008127 }, /* GL_POINT_SIZE_MAX */

-   { 30326, 0x00008127 }, /* GL_POINT_SIZE_MAX_ARB */

-   { 30348, 0x00008127 }, /* GL_POINT_SIZE_MAX_EXT */

-   { 30370, 0x00008127 }, /* GL_POINT_SIZE_MAX_SGIS */

-   { 30393, 0x00008126 }, /* GL_POINT_SIZE_MIN */

-   { 30411, 0x00008126 }, /* GL_POINT_SIZE_MIN_ARB */

-   { 30433, 0x00008126 }, /* GL_POINT_SIZE_MIN_EXT */

-   { 30455, 0x00008126 }, /* GL_POINT_SIZE_MIN_SGIS */

-   { 30478, 0x00000B12 }, /* GL_POINT_SIZE_RANGE */

-   { 30498, 0x00000B10 }, /* GL_POINT_SMOOTH */

-   { 30514, 0x00000C51 }, /* GL_POINT_SMOOTH_HINT */

-   { 30535, 0x00008861 }, /* GL_POINT_SPRITE */

-   { 30551, 0x00008861 }, /* GL_POINT_SPRITE_ARB */

-   { 30571, 0x00008CA0 }, /* GL_POINT_SPRITE_COORD_ORIGIN */

-   { 30600, 0x00008861 }, /* GL_POINT_SPRITE_NV */

-   { 30619, 0x00008861 }, /* GL_POINT_SPRITE_OES */

-   { 30639, 0x00008863 }, /* GL_POINT_SPRITE_R_MODE_NV */

-   { 30665, 0x00000701 }, /* GL_POINT_TOKEN */

-   { 30680, 0x00000009 }, /* GL_POLYGON */

-   { 30691, 0x00000008 }, /* GL_POLYGON_BIT */

-   { 30706, 0x00000B40 }, /* GL_POLYGON_MODE */

-   { 30722, 0x00008039 }, /* GL_POLYGON_OFFSET_BIAS */

-   { 30745, 0x00008038 }, /* GL_POLYGON_OFFSET_FACTOR */

-   { 30770, 0x00008037 }, /* GL_POLYGON_OFFSET_FILL */

-   { 30793, 0x00002A02 }, /* GL_POLYGON_OFFSET_LINE */

-   { 30816, 0x00002A01 }, /* GL_POLYGON_OFFSET_POINT */

-   { 30840, 0x00002A00 }, /* GL_POLYGON_OFFSET_UNITS */

-   { 30864, 0x00000B41 }, /* GL_POLYGON_SMOOTH */

-   { 30882, 0x00000C53 }, /* GL_POLYGON_SMOOTH_HINT */

-   { 30905, 0x00000B42 }, /* GL_POLYGON_STIPPLE */

-   { 30924, 0x00000010 }, /* GL_POLYGON_STIPPLE_BIT */

-   { 30947, 0x00000703 }, /* GL_POLYGON_TOKEN */

-   { 30964, 0x00001203 }, /* GL_POSITION */

-   { 30976, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */

-   { 31008, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI */

-   { 31044, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */

-   { 31077, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI */

-   { 31114, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */

-   { 31145, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI */

-   { 31180, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */

-   { 31212, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI */

-   { 31248, 0x000080D2 }, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */

-   { 31281, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */

-   { 31313, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI */

-   { 31349, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */

-   { 31382, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI */

-   { 31419, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS */

-   { 31449, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS_SGI */

-   { 31483, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE */

-   { 31514, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE_SGI */

-   { 31549, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS */

-   { 31580, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS_EXT */

-   { 31615, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE */

-   { 31647, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE_EXT */

-   { 31683, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS */

-   { 31713, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS_EXT */

-   { 31747, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE */

-   { 31778, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE_EXT */

-   { 31813, 0x000080D1 }, /* GL_POST_CONVOLUTION_COLOR_TABLE */

-   { 31845, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS */

-   { 31876, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS_EXT */

-   { 31911, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE */

-   { 31943, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE_EXT */

-   { 31979, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS */

-   { 32008, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS_EXT */

-   { 32041, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE */

-   { 32071, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE_EXT */

-   { 32105, 0x0000817B }, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */

-   { 32144, 0x00008179 }, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */

-   { 32177, 0x0000817C }, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */

-   { 32217, 0x0000817A }, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */

-   { 32251, 0x00008578 }, /* GL_PREVIOUS */

-   { 32263, 0x00008578 }, /* GL_PREVIOUS_ARB */

-   { 32279, 0x00008578 }, /* GL_PREVIOUS_EXT */

-   { 32295, 0x00008577 }, /* GL_PRIMARY_COLOR */

-   { 32312, 0x00008577 }, /* GL_PRIMARY_COLOR_ARB */

-   { 32333, 0x00008577 }, /* GL_PRIMARY_COLOR_EXT */

-   { 32354, 0x00008C87 }, /* GL_PRIMITIVES_GENERATED */

-   { 32378, 0x00008C87 }, /* GL_PRIMITIVES_GENERATED_EXT */

-   { 32406, 0x00008F9D }, /* GL_PRIMITIVE_RESTART */

-   { 32427, 0x00008F9E }, /* GL_PRIMITIVE_RESTART_INDEX */

-   { 32454, 0x00008559 }, /* GL_PRIMITIVE_RESTART_INDEX_NV */

-   { 32484, 0x00008558 }, /* GL_PRIMITIVE_RESTART_NV */

-   { 32508, 0x000088B0 }, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */

-   { 32541, 0x00008805 }, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */

-   { 32573, 0x000088AC }, /* GL_PROGRAM_ATTRIBS_ARB */

-   { 32596, 0x000087FF }, /* GL_PROGRAM_BINARY_FORMATS_OES */

-   { 32626, 0x00008741 }, /* GL_PROGRAM_BINARY_LENGTH_OES */

-   { 32655, 0x00008677 }, /* GL_PROGRAM_BINDING_ARB */

-   { 32678, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_ARB */

-   { 32708, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_NV */

-   { 32737, 0x00008874 }, /* GL_PROGRAM_ERROR_STRING_ARB */

-   { 32765, 0x00008876 }, /* GL_PROGRAM_FORMAT_ARB */

-   { 32787, 0x00008875 }, /* GL_PROGRAM_FORMAT_ASCII_ARB */

-   { 32815, 0x000088A0 }, /* GL_PROGRAM_INSTRUCTIONS_ARB */

-   { 32843, 0x00008627 }, /* GL_PROGRAM_LENGTH_ARB */

-   { 32865, 0x00008627 }, /* GL_PROGRAM_LENGTH_NV */

-   { 32886, 0x000088B2 }, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */

-   { 32926, 0x00008808 }, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */

-   { 32965, 0x000088AE }, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */

-   { 32995, 0x000088A2 }, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */

-   { 33030, 0x000088AA }, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */

-   { 33063, 0x000088A6 }, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */

-   { 33097, 0x0000880A }, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */

-   { 33136, 0x00008809 }, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */

-   { 33175, 0x00008B40 }, /* GL_PROGRAM_OBJECT_ARB */

-   { 33197, 0x000088A8 }, /* GL_PROGRAM_PARAMETERS_ARB */

-   { 33223, 0x00008644 }, /* GL_PROGRAM_PARAMETER_NV */

-   { 33247, 0x00008642 }, /* GL_PROGRAM_POINT_SIZE */

-   { 33269, 0x00008642 }, /* GL_PROGRAM_POINT_SIZE_ARB */

-   { 33295, 0x00008647 }, /* GL_PROGRAM_RESIDENT_NV */

-   { 33318, 0x00008628 }, /* GL_PROGRAM_STRING_ARB */

-   { 33340, 0x00008628 }, /* GL_PROGRAM_STRING_NV */

-   { 33361, 0x00008646 }, /* GL_PROGRAM_TARGET_NV */

-   { 33382, 0x000088A4 }, /* GL_PROGRAM_TEMPORARIES_ARB */

-   { 33409, 0x00008807 }, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */

-   { 33441, 0x00008806 }, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */

-   { 33473, 0x000088B6 }, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */

-   { 33508, 0x00001701 }, /* GL_PROJECTION */

-   { 33522, 0x00000BA7 }, /* GL_PROJECTION_MATRIX */

-   { 33543, 0x0000898E }, /* GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES */

-   { 33586, 0x00000BA4 }, /* GL_PROJECTION_STACK_DEPTH */

-   { 33612, 0x00008E4F }, /* GL_PROVOKING_VERTEX */

-   { 33632, 0x00008E4F }, /* GL_PROVOKING_VERTEX_EXT */

-   { 33656, 0x000080D3 }, /* GL_PROXY_COLOR_TABLE */

-   { 33677, 0x00008025 }, /* GL_PROXY_HISTOGRAM */

-   { 33696, 0x00008025 }, /* GL_PROXY_HISTOGRAM_EXT */

-   { 33719, 0x000080D5 }, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */

-   { 33758, 0x000080D4 }, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */

-   { 33796, 0x00008063 }, /* GL_PROXY_TEXTURE_1D */

-   { 33816, 0x00008C19 }, /* GL_PROXY_TEXTURE_1D_ARRAY */

-   { 33842, 0x00008C19 }, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */

-   { 33872, 0x00008063 }, /* GL_PROXY_TEXTURE_1D_EXT */

-   { 33896, 0x00008064 }, /* GL_PROXY_TEXTURE_2D */

-   { 33916, 0x00008C1B }, /* GL_PROXY_TEXTURE_2D_ARRAY */

-   { 33942, 0x00008C1B }, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */

-   { 33972, 0x00008064 }, /* GL_PROXY_TEXTURE_2D_EXT */

-   { 33996, 0x00008070 }, /* GL_PROXY_TEXTURE_3D */

-   { 34016, 0x000080BD }, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */

-   { 34049, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP */

-   { 34075, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP_ARB */

-   { 34105, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE */

-   { 34132, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */

-   { 34163, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_NV */

-   { 34193, 0x00008A1D }, /* GL_PURGEABLE_APPLE */

-   { 34212, 0x00002003 }, /* GL_Q */

-   { 34217, 0x00001209 }, /* GL_QUADRATIC_ATTENUATION */

-   { 34242, 0x00000007 }, /* GL_QUADS */

-   { 34251, 0x00008E4C }, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION */

-   { 34295, 0x00008E4C }, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT */

-   { 34343, 0x00008614 }, /* GL_QUAD_MESH_SUN */

-   { 34360, 0x00000008 }, /* GL_QUAD_STRIP */

-   { 34374, 0x00008E16 }, /* GL_QUERY_BY_REGION_NO_WAIT */

-   { 34401, 0x00008E16 }, /* GL_QUERY_BY_REGION_NO_WAIT_NV */

-   { 34431, 0x00008E15 }, /* GL_QUERY_BY_REGION_WAIT */

-   { 34455, 0x00008E15 }, /* GL_QUERY_BY_REGION_WAIT_NV */

-   { 34482, 0x00008864 }, /* GL_QUERY_COUNTER_BITS */

-   { 34504, 0x00008864 }, /* GL_QUERY_COUNTER_BITS_ARB */

-   { 34530, 0x00008E14 }, /* GL_QUERY_NO_WAIT */

-   { 34547, 0x00008E14 }, /* GL_QUERY_NO_WAIT_NV */

-   { 34567, 0x00008866 }, /* GL_QUERY_RESULT */

-   { 34583, 0x00008866 }, /* GL_QUERY_RESULT_ARB */

-   { 34603, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE */

-   { 34629, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE_ARB */

-   { 34659, 0x00008E13 }, /* GL_QUERY_WAIT */

-   { 34673, 0x00008E13 }, /* GL_QUERY_WAIT_NV */

-   { 34690, 0x00002002 }, /* GL_R */

-   { 34695, 0x00008C3A }, /* GL_R11F_G11F_B10F */

-   { 34713, 0x00008F98 }, /* GL_R16_SNORM */

-   { 34726, 0x00002A10 }, /* GL_R3_G3_B2 */

-   { 34738, 0x00008F94 }, /* GL_R8_SNORM */

-   { 34750, 0x00008C89 }, /* GL_RASTERIZER_DISCARD */

-   { 34772, 0x00008C89 }, /* GL_RASTERIZER_DISCARD_EXT */

-   { 34798, 0x00019262 }, /* GL_RASTER_POSITION_UNCLIPPED_IBM */

-   { 34831, 0x00000C02 }, /* GL_READ_BUFFER */

-   { 34846, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER */

-   { 34866, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING */

-   { 34894, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING_EXT */

-   { 34926, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER_EXT */

-   { 34950, 0x000088B8 }, /* GL_READ_ONLY */

-   { 34963, 0x000088B8 }, /* GL_READ_ONLY_ARB */

-   { 34980, 0x000088BA }, /* GL_READ_WRITE */

-   { 34994, 0x000088BA }, /* GL_READ_WRITE_ARB */

-   { 35012, 0x00001903 }, /* GL_RED */

-   { 35019, 0x00008016 }, /* GL_REDUCE */

-   { 35029, 0x00008016 }, /* GL_REDUCE_EXT */

-   { 35043, 0x00000D15 }, /* GL_RED_BIAS */

-   { 35055, 0x00000D52 }, /* GL_RED_BITS */

-   { 35067, 0x00008D94 }, /* GL_RED_INTEGER */

-   { 35082, 0x00008D94 }, /* GL_RED_INTEGER_EXT */

-   { 35101, 0x00000D14 }, /* GL_RED_SCALE */

-   { 35114, 0x00008F90 }, /* GL_RED_SNORM */

-   { 35127, 0x00008512 }, /* GL_REFLECTION_MAP */

-   { 35145, 0x00008512 }, /* GL_REFLECTION_MAP_ARB */

-   { 35167, 0x00008512 }, /* GL_REFLECTION_MAP_NV */

-   { 35188, 0x00008512 }, /* GL_REFLECTION_MAP_OES */

-   { 35210, 0x00008A19 }, /* GL_RELEASED_APPLE */

-   { 35228, 0x00001C00 }, /* GL_RENDER */

-   { 35238, 0x00008D41 }, /* GL_RENDERBUFFER */

-   { 35254, 0x00008D53 }, /* GL_RENDERBUFFER_ALPHA_SIZE */

-   { 35281, 0x00008D53 }, /* GL_RENDERBUFFER_ALPHA_SIZE_OES */

-   { 35312, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING */

-   { 35336, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_EXT */

-   { 35364, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_OES */

-   { 35392, 0x00008D52 }, /* GL_RENDERBUFFER_BLUE_SIZE */

-   { 35418, 0x00008D52 }, /* GL_RENDERBUFFER_BLUE_SIZE_OES */

-   { 35448, 0x00008D54 }, /* GL_RENDERBUFFER_DEPTH_SIZE */

-   { 35475, 0x00008D54 }, /* GL_RENDERBUFFER_DEPTH_SIZE_OES */

-   { 35506, 0x00008D41 }, /* GL_RENDERBUFFER_EXT */

-   { 35526, 0x00008D51 }, /* GL_RENDERBUFFER_GREEN_SIZE */

-   { 35553, 0x00008D51 }, /* GL_RENDERBUFFER_GREEN_SIZE_OES */

-   { 35584, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT */

-   { 35607, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_EXT */

-   { 35634, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_OES */

-   { 35661, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT */

-   { 35693, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */

-   { 35729, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_OES */

-   { 35765, 0x00008D41 }, /* GL_RENDERBUFFER_OES */

-   { 35785, 0x00008D50 }, /* GL_RENDERBUFFER_RED_SIZE */

-   { 35810, 0x00008D50 }, /* GL_RENDERBUFFER_RED_SIZE_OES */

-   { 35839, 0x00008CAB }, /* GL_RENDERBUFFER_SAMPLES */

-   { 35863, 0x00008CAB }, /* GL_RENDERBUFFER_SAMPLES_EXT */

-   { 35891, 0x00008D55 }, /* GL_RENDERBUFFER_STENCIL_SIZE */

-   { 35920, 0x00008D55 }, /* GL_RENDERBUFFER_STENCIL_SIZE_OES */

-   { 35953, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH */

-   { 35975, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_EXT */

-   { 36001, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_OES */

-   { 36027, 0x00001F01 }, /* GL_RENDERER */

-   { 36039, 0x00000C40 }, /* GL_RENDER_MODE */

-   { 36054, 0x00002901 }, /* GL_REPEAT */

-   { 36064, 0x00001E01 }, /* GL_REPLACE */

-   { 36075, 0x00008062 }, /* GL_REPLACE_EXT */

-   { 36090, 0x00008153 }, /* GL_REPLICATE_BORDER_HP */

-   { 36113, 0x0000803A }, /* GL_RESCALE_NORMAL */

-   { 36131, 0x0000803A }, /* GL_RESCALE_NORMAL_EXT */

-   { 36153, 0x00008A1B }, /* GL_RETAINED_APPLE */

-   { 36171, 0x00000102 }, /* GL_RETURN */

-   { 36181, 0x00008F99 }, /* GL_RG16_SNORM */

-   { 36195, 0x00008F95 }, /* GL_RG8_SNORM */

-   { 36208, 0x00001907 }, /* GL_RGB */

-   { 36215, 0x00008052 }, /* GL_RGB10 */

-   { 36224, 0x00008059 }, /* GL_RGB10_A2 */

-   { 36236, 0x00008059 }, /* GL_RGB10_A2_EXT */

-   { 36252, 0x00008052 }, /* GL_RGB10_EXT */

-   { 36265, 0x00008053 }, /* GL_RGB12 */

-   { 36274, 0x00008053 }, /* GL_RGB12_EXT */

-   { 36287, 0x00008054 }, /* GL_RGB16 */

-   { 36296, 0x0000881B }, /* GL_RGB16F */

-   { 36306, 0x00008D89 }, /* GL_RGB16I */

-   { 36316, 0x00008D89 }, /* GL_RGB16I_EXT */

-   { 36330, 0x00008D77 }, /* GL_RGB16UI */

-   { 36341, 0x00008D77 }, /* GL_RGB16UI_EXT */

-   { 36356, 0x00008054 }, /* GL_RGB16_EXT */

-   { 36369, 0x00008F9A }, /* GL_RGB16_SNORM */

-   { 36384, 0x0000804E }, /* GL_RGB2_EXT */

-   { 36396, 0x00008815 }, /* GL_RGB32F */

-   { 36406, 0x00008D83 }, /* GL_RGB32I */

-   { 36416, 0x00008D83 }, /* GL_RGB32I_EXT */

-   { 36430, 0x00008D71 }, /* GL_RGB32UI */

-   { 36441, 0x00008D71 }, /* GL_RGB32UI_EXT */

-   { 36456, 0x0000804F }, /* GL_RGB4 */

-   { 36464, 0x0000804F }, /* GL_RGB4_EXT */

-   { 36476, 0x000083A1 }, /* GL_RGB4_S3TC */

-   { 36489, 0x00008050 }, /* GL_RGB5 */

-   { 36497, 0x00008D62 }, /* GL_RGB565 */

-   { 36507, 0x00008D62 }, /* GL_RGB565_OES */

-   { 36521, 0x00008057 }, /* GL_RGB5_A1 */

-   { 36532, 0x00008057 }, /* GL_RGB5_A1_EXT */

-   { 36547, 0x00008057 }, /* GL_RGB5_A1_OES */

-   { 36562, 0x00008050 }, /* GL_RGB5_EXT */

-   { 36574, 0x00008051 }, /* GL_RGB8 */

-   { 36582, 0x00008D8F }, /* GL_RGB8I */

-   { 36591, 0x00008D8F }, /* GL_RGB8I_EXT */

-   { 36604, 0x00008D7D }, /* GL_RGB8UI */

-   { 36614, 0x00008D7D }, /* GL_RGB8UI_EXT */

-   { 36628, 0x00008051 }, /* GL_RGB8_EXT */

-   { 36640, 0x00008051 }, /* GL_RGB8_OES */

-   { 36652, 0x00008F96 }, /* GL_RGB8_SNORM */

-   { 36666, 0x00008C3D }, /* GL_RGB9_E5 */

-   { 36677, 0x00001908 }, /* GL_RGBA */

-   { 36685, 0x0000805A }, /* GL_RGBA12 */

-   { 36695, 0x0000805A }, /* GL_RGBA12_EXT */

-   { 36709, 0x0000805B }, /* GL_RGBA16 */

-   { 36719, 0x0000881A }, /* GL_RGBA16F */

-   { 36730, 0x00008D88 }, /* GL_RGBA16I */

-   { 36741, 0x00008D88 }, /* GL_RGBA16I_EXT */

-   { 36756, 0x00008D76 }, /* GL_RGBA16UI */

-   { 36768, 0x00008D76 }, /* GL_RGBA16UI_EXT */

-   { 36784, 0x0000805B }, /* GL_RGBA16_EXT */

-   { 36798, 0x00008F9B }, /* GL_RGBA16_SNORM */

-   { 36814, 0x00008055 }, /* GL_RGBA2 */

-   { 36823, 0x00008055 }, /* GL_RGBA2_EXT */

-   { 36836, 0x00008814 }, /* GL_RGBA32F */

-   { 36847, 0x00008D82 }, /* GL_RGBA32I */

-   { 36858, 0x00008D82 }, /* GL_RGBA32I_EXT */

-   { 36873, 0x00008D70 }, /* GL_RGBA32UI */

-   { 36885, 0x00008D70 }, /* GL_RGBA32UI_EXT */

-   { 36901, 0x00008056 }, /* GL_RGBA4 */

-   { 36910, 0x000083A5 }, /* GL_RGBA4_DXT5_S3TC */

-   { 36929, 0x00008056 }, /* GL_RGBA4_EXT */

-   { 36942, 0x00008056 }, /* GL_RGBA4_OES */

-   { 36955, 0x000083A3 }, /* GL_RGBA4_S3TC */

-   { 36969, 0x00008058 }, /* GL_RGBA8 */

-   { 36978, 0x00008D8E }, /* GL_RGBA8I */

-   { 36988, 0x00008D8E }, /* GL_RGBA8I_EXT */

-   { 37002, 0x00008D7C }, /* GL_RGBA8UI */

-   { 37013, 0x00008D7C }, /* GL_RGBA8UI_EXT */

-   { 37028, 0x00008058 }, /* GL_RGBA8_EXT */

-   { 37041, 0x00008058 }, /* GL_RGBA8_OES */

-   { 37054, 0x00008F97 }, /* GL_RGBA8_SNORM */

-   { 37069, 0x000083A4 }, /* GL_RGBA_DXT5_S3TC */

-   { 37087, 0x00008D99 }, /* GL_RGBA_INTEGER */

-   { 37103, 0x00008D99 }, /* GL_RGBA_INTEGER_EXT */

-   { 37123, 0x00008D9E }, /* GL_RGBA_INTEGER_MODE_EXT */

-   { 37148, 0x00000C31 }, /* GL_RGBA_MODE */

-   { 37161, 0x000083A2 }, /* GL_RGBA_S3TC */

-   { 37174, 0x00008F93 }, /* GL_RGBA_SNORM */

-   { 37188, 0x00008D98 }, /* GL_RGB_INTEGER */

-   { 37203, 0x00008D98 }, /* GL_RGB_INTEGER_EXT */

-   { 37222, 0x000083A0 }, /* GL_RGB_S3TC */

-   { 37234, 0x00008573 }, /* GL_RGB_SCALE */

-   { 37247, 0x00008573 }, /* GL_RGB_SCALE_ARB */

-   { 37264, 0x00008573 }, /* GL_RGB_SCALE_EXT */

-   { 37281, 0x00008F92 }, /* GL_RGB_SNORM */

-   { 37294, 0x00008F91 }, /* GL_RG_SNORM */

-   { 37306, 0x00000407 }, /* GL_RIGHT */

-   { 37315, 0x00002000 }, /* GL_S */

-   { 37320, 0x00008B5D }, /* GL_SAMPLER_1D */

-   { 37334, 0x00008DC0 }, /* GL_SAMPLER_1D_ARRAY */

-   { 37354, 0x00008DC0 }, /* GL_SAMPLER_1D_ARRAY_EXT */

-   { 37378, 0x00008DC3 }, /* GL_SAMPLER_1D_ARRAY_SHADOW */

-   { 37405, 0x00008DC3 }, /* GL_SAMPLER_1D_ARRAY_SHADOW_EXT */

-   { 37436, 0x00008B61 }, /* GL_SAMPLER_1D_SHADOW */

-   { 37457, 0x00008B5E }, /* GL_SAMPLER_2D */

-   { 37471, 0x00008DC1 }, /* GL_SAMPLER_2D_ARRAY */

-   { 37491, 0x00008DC1 }, /* GL_SAMPLER_2D_ARRAY_EXT */

-   { 37515, 0x00008DC4 }, /* GL_SAMPLER_2D_ARRAY_SHADOW */

-   { 37542, 0x00008DC4 }, /* GL_SAMPLER_2D_ARRAY_SHADOW_EXT */

-   { 37573, 0x00008B63 }, /* GL_SAMPLER_2D_RECT */

-   { 37592, 0x00008B64 }, /* GL_SAMPLER_2D_RECT_SHADOW */

-   { 37618, 0x00008B62 }, /* GL_SAMPLER_2D_SHADOW */

-   { 37639, 0x00008B5F }, /* GL_SAMPLER_3D */

-   { 37653, 0x00008B5F }, /* GL_SAMPLER_3D_OES */

-   { 37671, 0x00008DC2 }, /* GL_SAMPLER_BUFFER */

-   { 37689, 0x00008DC2 }, /* GL_SAMPLER_BUFFER_EXT */

-   { 37711, 0x00008B60 }, /* GL_SAMPLER_CUBE */

-   { 37727, 0x00008DC5 }, /* GL_SAMPLER_CUBE_SHADOW */

-   { 37750, 0x00008DC5 }, /* GL_SAMPLER_CUBE_SHADOW_EXT */

-   { 37777, 0x000080A9 }, /* GL_SAMPLES */

-   { 37788, 0x000086B4 }, /* GL_SAMPLES_3DFX */

-   { 37804, 0x000080A9 }, /* GL_SAMPLES_ARB */

-   { 37819, 0x00008914 }, /* GL_SAMPLES_PASSED */

-   { 37837, 0x00008914 }, /* GL_SAMPLES_PASSED_ARB */

-   { 37859, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE */

-   { 37887, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE_ARB */

-   { 37919, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE */

-   { 37942, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE_ARB */

-   { 37969, 0x000080A8 }, /* GL_SAMPLE_BUFFERS */

-   { 37987, 0x000086B3 }, /* GL_SAMPLE_BUFFERS_3DFX */

-   { 38010, 0x000080A8 }, /* GL_SAMPLE_BUFFERS_ARB */

-   { 38032, 0x000080A0 }, /* GL_SAMPLE_COVERAGE */

-   { 38051, 0x000080A0 }, /* GL_SAMPLE_COVERAGE_ARB */

-   { 38074, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT */

-   { 38100, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT_ARB */

-   { 38130, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE */

-   { 38155, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE_ARB */

-   { 38184, 0x00080000 }, /* GL_SCISSOR_BIT */

-   { 38199, 0x00000C10 }, /* GL_SCISSOR_BOX */

-   { 38214, 0x00000C11 }, /* GL_SCISSOR_TEST */

-   { 38230, 0x0000845E }, /* GL_SECONDARY_COLOR_ARRAY */

-   { 38255, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */

-   { 38295, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB */

-   { 38339, 0x0000845D }, /* GL_SECONDARY_COLOR_ARRAY_POINTER */

-   { 38372, 0x0000845A }, /* GL_SECONDARY_COLOR_ARRAY_SIZE */

-   { 38402, 0x0000845C }, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */

-   { 38434, 0x0000845B }, /* GL_SECONDARY_COLOR_ARRAY_TYPE */

-   { 38464, 0x00001C02 }, /* GL_SELECT */

-   { 38474, 0x00000DF3 }, /* GL_SELECTION_BUFFER_POINTER */

-   { 38502, 0x00000DF4 }, /* GL_SELECTION_BUFFER_SIZE */

-   { 38527, 0x00008012 }, /* GL_SEPARABLE_2D */

-   { 38543, 0x00008C8D }, /* GL_SEPARATE_ATTRIBS */

-   { 38563, 0x00008C8D }, /* GL_SEPARATE_ATTRIBS_EXT */

-   { 38587, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR */

-   { 38614, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR_EXT */

-   { 38645, 0x0000150F }, /* GL_SET */

-   { 38652, 0x00008DF8 }, /* GL_SHADER_BINARY_FORMATS */

-   { 38677, 0x00008DFA }, /* GL_SHADER_COMPILER */

-   { 38696, 0x00008B48 }, /* GL_SHADER_OBJECT_ARB */

-   { 38717, 0x00008B88 }, /* GL_SHADER_SOURCE_LENGTH */

-   { 38741, 0x00008B4F }, /* GL_SHADER_TYPE */

-   { 38756, 0x00000B54 }, /* GL_SHADE_MODEL */

-   { 38771, 0x00008B8C }, /* GL_SHADING_LANGUAGE_VERSION */

-   { 38799, 0x000080BF }, /* GL_SHADOW_AMBIENT_SGIX */

-   { 38822, 0x000081FB }, /* GL_SHARED_TEXTURE_PALETTE_EXT */

-   { 38852, 0x00001601 }, /* GL_SHININESS */

-   { 38865, 0x00001402 }, /* GL_SHORT */

-   { 38874, 0x00009119 }, /* GL_SIGNALED */

-   { 38886, 0x00008F9C }, /* GL_SIGNED_NORMALIZED */

-   { 38907, 0x000081F9 }, /* GL_SINGLE_COLOR */

-   { 38923, 0x000081F9 }, /* GL_SINGLE_COLOR_EXT */

-   { 38943, 0x000085CC }, /* GL_SLICE_ACCUM_SUN */

-   { 38962, 0x00008C46 }, /* GL_SLUMINANCE */

-   { 38976, 0x00008C47 }, /* GL_SLUMINANCE8 */

-   { 38991, 0x00008C45 }, /* GL_SLUMINANCE8_ALPHA8 */

-   { 39013, 0x00008C44 }, /* GL_SLUMINANCE_ALPHA */

-   { 39033, 0x00001D01 }, /* GL_SMOOTH */

-   { 39043, 0x00000B23 }, /* GL_SMOOTH_LINE_WIDTH_GRANULARITY */

-   { 39076, 0x00000B22 }, /* GL_SMOOTH_LINE_WIDTH_RANGE */

-   { 39103, 0x00000B13 }, /* GL_SMOOTH_POINT_SIZE_GRANULARITY */

-   { 39136, 0x00000B12 }, /* GL_SMOOTH_POINT_SIZE_RANGE */

-   { 39163, 0x00008588 }, /* GL_SOURCE0_ALPHA */

-   { 39180, 0x00008588 }, /* GL_SOURCE0_ALPHA_ARB */

-   { 39201, 0x00008588 }, /* GL_SOURCE0_ALPHA_EXT */

-   { 39222, 0x00008580 }, /* GL_SOURCE0_RGB */

-   { 39237, 0x00008580 }, /* GL_SOURCE0_RGB_ARB */

-   { 39256, 0x00008580 }, /* GL_SOURCE0_RGB_EXT */

-   { 39275, 0x00008589 }, /* GL_SOURCE1_ALPHA */

-   { 39292, 0x00008589 }, /* GL_SOURCE1_ALPHA_ARB */

-   { 39313, 0x00008589 }, /* GL_SOURCE1_ALPHA_EXT */

-   { 39334, 0x00008581 }, /* GL_SOURCE1_RGB */

-   { 39349, 0x00008581 }, /* GL_SOURCE1_RGB_ARB */

-   { 39368, 0x00008581 }, /* GL_SOURCE1_RGB_EXT */

-   { 39387, 0x0000858A }, /* GL_SOURCE2_ALPHA */

-   { 39404, 0x0000858A }, /* GL_SOURCE2_ALPHA_ARB */

-   { 39425, 0x0000858A }, /* GL_SOURCE2_ALPHA_EXT */

-   { 39446, 0x00008582 }, /* GL_SOURCE2_RGB */

-   { 39461, 0x00008582 }, /* GL_SOURCE2_RGB_ARB */

-   { 39480, 0x00008582 }, /* GL_SOURCE2_RGB_EXT */

-   { 39499, 0x0000858B }, /* GL_SOURCE3_ALPHA_NV */

-   { 39519, 0x00008583 }, /* GL_SOURCE3_RGB_NV */

-   { 39537, 0x00001202 }, /* GL_SPECULAR */

-   { 39549, 0x00002402 }, /* GL_SPHERE_MAP */

-   { 39563, 0x00001206 }, /* GL_SPOT_CUTOFF */

-   { 39578, 0x00001204 }, /* GL_SPOT_DIRECTION */

-   { 39596, 0x00001205 }, /* GL_SPOT_EXPONENT */

-   { 39613, 0x00008588 }, /* GL_SRC0_ALPHA */

-   { 39627, 0x00008580 }, /* GL_SRC0_RGB */

-   { 39639, 0x00008589 }, /* GL_SRC1_ALPHA */

-   { 39653, 0x00008581 }, /* GL_SRC1_RGB */

-   { 39665, 0x0000858A }, /* GL_SRC2_ALPHA */

-   { 39679, 0x00008582 }, /* GL_SRC2_RGB */

-   { 39691, 0x00000302 }, /* GL_SRC_ALPHA */

-   { 39704, 0x00000308 }, /* GL_SRC_ALPHA_SATURATE */

-   { 39726, 0x00000300 }, /* GL_SRC_COLOR */

-   { 39739, 0x00008C40 }, /* GL_SRGB */

-   { 39747, 0x00008C41 }, /* GL_SRGB8 */

-   { 39756, 0x00008C43 }, /* GL_SRGB8_ALPHA8 */

-   { 39772, 0x00008C42 }, /* GL_SRGB_ALPHA */

-   { 39786, 0x00000503 }, /* GL_STACK_OVERFLOW */

-   { 39804, 0x00000504 }, /* GL_STACK_UNDERFLOW */

-   { 39823, 0x000088E6 }, /* GL_STATIC_COPY */

-   { 39838, 0x000088E6 }, /* GL_STATIC_COPY_ARB */

-   { 39857, 0x000088E4 }, /* GL_STATIC_DRAW */

-   { 39872, 0x000088E4 }, /* GL_STATIC_DRAW_ARB */

-   { 39891, 0x000088E5 }, /* GL_STATIC_READ */

-   { 39906, 0x000088E5 }, /* GL_STATIC_READ_ARB */

-   { 39925, 0x00001802 }, /* GL_STENCIL */

-   { 39936, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT */

-   { 39958, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_EXT */

-   { 39984, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_OES */

-   { 40010, 0x00008801 }, /* GL_STENCIL_BACK_FAIL */

-   { 40031, 0x00008801 }, /* GL_STENCIL_BACK_FAIL_ATI */

-   { 40056, 0x00008800 }, /* GL_STENCIL_BACK_FUNC */

-   { 40077, 0x00008800 }, /* GL_STENCIL_BACK_FUNC_ATI */

-   { 40102, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */

-   { 40134, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI */

-   { 40170, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */

-   { 40202, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI */

-   { 40238, 0x00008CA3 }, /* GL_STENCIL_BACK_REF */

-   { 40258, 0x00008CA4 }, /* GL_STENCIL_BACK_VALUE_MASK */

-   { 40285, 0x00008CA5 }, /* GL_STENCIL_BACK_WRITEMASK */

-   { 40311, 0x00000D57 }, /* GL_STENCIL_BITS */

-   { 40327, 0x00008224 }, /* GL_STENCIL_BUFFER */

-   { 40345, 0x00000400 }, /* GL_STENCIL_BUFFER_BIT */

-   { 40367, 0x00000B91 }, /* GL_STENCIL_CLEAR_VALUE */

-   { 40390, 0x00000B94 }, /* GL_STENCIL_FAIL */

-   { 40406, 0x00000B92 }, /* GL_STENCIL_FUNC */

-   { 40422, 0x00001901 }, /* GL_STENCIL_INDEX */

-   { 40439, 0x00008D46 }, /* GL_STENCIL_INDEX1 */

-   { 40457, 0x00008D49 }, /* GL_STENCIL_INDEX16 */

-   { 40476, 0x00008D49 }, /* GL_STENCIL_INDEX16_EXT */

-   { 40499, 0x00008D46 }, /* GL_STENCIL_INDEX1_EXT */

-   { 40521, 0x00008D46 }, /* GL_STENCIL_INDEX1_OES */

-   { 40543, 0x00008D47 }, /* GL_STENCIL_INDEX4 */

-   { 40561, 0x00008D47 }, /* GL_STENCIL_INDEX4_EXT */

-   { 40583, 0x00008D47 }, /* GL_STENCIL_INDEX4_OES */

-   { 40605, 0x00008D48 }, /* GL_STENCIL_INDEX8 */

-   { 40623, 0x00008D48 }, /* GL_STENCIL_INDEX8_EXT */

-   { 40645, 0x00008D48 }, /* GL_STENCIL_INDEX8_OES */

-   { 40667, 0x00008D45 }, /* GL_STENCIL_INDEX_EXT */

-   { 40688, 0x00000B95 }, /* GL_STENCIL_PASS_DEPTH_FAIL */

-   { 40715, 0x00000B96 }, /* GL_STENCIL_PASS_DEPTH_PASS */

-   { 40742, 0x00000B97 }, /* GL_STENCIL_REF */

-   { 40757, 0x00000B90 }, /* GL_STENCIL_TEST */

-   { 40773, 0x00008910 }, /* GL_STENCIL_TEST_TWO_SIDE_EXT */

-   { 40802, 0x00000B93 }, /* GL_STENCIL_VALUE_MASK */

-   { 40824, 0x00000B98 }, /* GL_STENCIL_WRITEMASK */

-   { 40845, 0x00000C33 }, /* GL_STEREO */

-   { 40855, 0x000085BE }, /* GL_STORAGE_CACHED_APPLE */

-   { 40879, 0x000085BD }, /* GL_STORAGE_PRIVATE_APPLE */

-   { 40904, 0x000085BF }, /* GL_STORAGE_SHARED_APPLE */

-   { 40928, 0x000088E2 }, /* GL_STREAM_COPY */

-   { 40943, 0x000088E2 }, /* GL_STREAM_COPY_ARB */

-   { 40962, 0x000088E0 }, /* GL_STREAM_DRAW */

-   { 40977, 0x000088E0 }, /* GL_STREAM_DRAW_ARB */

-   { 40996, 0x000088E1 }, /* GL_STREAM_READ */

-   { 41011, 0x000088E1 }, /* GL_STREAM_READ_ARB */

-   { 41030, 0x00000D50 }, /* GL_SUBPIXEL_BITS */

-   { 41047, 0x000084E7 }, /* GL_SUBTRACT */

-   { 41059, 0x000084E7 }, /* GL_SUBTRACT_ARB */

-   { 41075, 0x00009113 }, /* GL_SYNC_CONDITION */

-   { 41093, 0x00009116 }, /* GL_SYNC_FENCE */

-   { 41107, 0x00009115 }, /* GL_SYNC_FLAGS */

-   { 41121, 0x00000001 }, /* GL_SYNC_FLUSH_COMMANDS_BIT */

-   { 41148, 0x00009117 }, /* GL_SYNC_GPU_COMMANDS_COMPLETE */

-   { 41178, 0x00009114 }, /* GL_SYNC_STATUS */

-   { 41193, 0x00002001 }, /* GL_T */

-   { 41198, 0x00002A2A }, /* GL_T2F_C3F_V3F */

-   { 41213, 0x00002A2C }, /* GL_T2F_C4F_N3F_V3F */

-   { 41232, 0x00002A29 }, /* GL_T2F_C4UB_V3F */

-   { 41248, 0x00002A2B }, /* GL_T2F_N3F_V3F */

-   { 41263, 0x00002A27 }, /* GL_T2F_V3F */

-   { 41274, 0x00002A2D }, /* GL_T4F_C4F_N3F_V4F */

-   { 41293, 0x00002A28 }, /* GL_T4F_V4F */

-   { 41304, 0x00008031 }, /* GL_TABLE_TOO_LARGE_EXT */

-   { 41327, 0x00001702 }, /* GL_TEXTURE */

-   { 41338, 0x000084C0 }, /* GL_TEXTURE0 */

-   { 41350, 0x000084C0 }, /* GL_TEXTURE0_ARB */

-   { 41366, 0x000084C1 }, /* GL_TEXTURE1 */

-   { 41378, 0x000084CA }, /* GL_TEXTURE10 */

-   { 41391, 0x000084CA }, /* GL_TEXTURE10_ARB */

-   { 41408, 0x000084CB }, /* GL_TEXTURE11 */

-   { 41421, 0x000084CB }, /* GL_TEXTURE11_ARB */

-   { 41438, 0x000084CC }, /* GL_TEXTURE12 */

-   { 41451, 0x000084CC }, /* GL_TEXTURE12_ARB */

-   { 41468, 0x000084CD }, /* GL_TEXTURE13 */

-   { 41481, 0x000084CD }, /* GL_TEXTURE13_ARB */

-   { 41498, 0x000084CE }, /* GL_TEXTURE14 */

-   { 41511, 0x000084CE }, /* GL_TEXTURE14_ARB */

-   { 41528, 0x000084CF }, /* GL_TEXTURE15 */

-   { 41541, 0x000084CF }, /* GL_TEXTURE15_ARB */

-   { 41558, 0x000084D0 }, /* GL_TEXTURE16 */

-   { 41571, 0x000084D0 }, /* GL_TEXTURE16_ARB */

-   { 41588, 0x000084D1 }, /* GL_TEXTURE17 */

-   { 41601, 0x000084D1 }, /* GL_TEXTURE17_ARB */

-   { 41618, 0x000084D2 }, /* GL_TEXTURE18 */

-   { 41631, 0x000084D2 }, /* GL_TEXTURE18_ARB */

-   { 41648, 0x000084D3 }, /* GL_TEXTURE19 */

-   { 41661, 0x000084D3 }, /* GL_TEXTURE19_ARB */

-   { 41678, 0x000084C1 }, /* GL_TEXTURE1_ARB */

-   { 41694, 0x000084C2 }, /* GL_TEXTURE2 */

-   { 41706, 0x000084D4 }, /* GL_TEXTURE20 */

-   { 41719, 0x000084D4 }, /* GL_TEXTURE20_ARB */

-   { 41736, 0x000084D5 }, /* GL_TEXTURE21 */

-   { 41749, 0x000084D5 }, /* GL_TEXTURE21_ARB */

-   { 41766, 0x000084D6 }, /* GL_TEXTURE22 */

-   { 41779, 0x000084D6 }, /* GL_TEXTURE22_ARB */

-   { 41796, 0x000084D7 }, /* GL_TEXTURE23 */

-   { 41809, 0x000084D7 }, /* GL_TEXTURE23_ARB */

-   { 41826, 0x000084D8 }, /* GL_TEXTURE24 */

-   { 41839, 0x000084D8 }, /* GL_TEXTURE24_ARB */

-   { 41856, 0x000084D9 }, /* GL_TEXTURE25 */

-   { 41869, 0x000084D9 }, /* GL_TEXTURE25_ARB */

-   { 41886, 0x000084DA }, /* GL_TEXTURE26 */

-   { 41899, 0x000084DA }, /* GL_TEXTURE26_ARB */

-   { 41916, 0x000084DB }, /* GL_TEXTURE27 */

-   { 41929, 0x000084DB }, /* GL_TEXTURE27_ARB */

-   { 41946, 0x000084DC }, /* GL_TEXTURE28 */

-   { 41959, 0x000084DC }, /* GL_TEXTURE28_ARB */

-   { 41976, 0x000084DD }, /* GL_TEXTURE29 */

-   { 41989, 0x000084DD }, /* GL_TEXTURE29_ARB */

-   { 42006, 0x000084C2 }, /* GL_TEXTURE2_ARB */

-   { 42022, 0x000084C3 }, /* GL_TEXTURE3 */

-   { 42034, 0x000084DE }, /* GL_TEXTURE30 */

-   { 42047, 0x000084DE }, /* GL_TEXTURE30_ARB */

-   { 42064, 0x000084DF }, /* GL_TEXTURE31 */

-   { 42077, 0x000084DF }, /* GL_TEXTURE31_ARB */

-   { 42094, 0x000084C3 }, /* GL_TEXTURE3_ARB */

-   { 42110, 0x000084C4 }, /* GL_TEXTURE4 */

-   { 42122, 0x000084C4 }, /* GL_TEXTURE4_ARB */

-   { 42138, 0x000084C5 }, /* GL_TEXTURE5 */

-   { 42150, 0x000084C5 }, /* GL_TEXTURE5_ARB */

-   { 42166, 0x000084C6 }, /* GL_TEXTURE6 */

-   { 42178, 0x000084C6 }, /* GL_TEXTURE6_ARB */

-   { 42194, 0x000084C7 }, /* GL_TEXTURE7 */

-   { 42206, 0x000084C7 }, /* GL_TEXTURE7_ARB */

-   { 42222, 0x000084C8 }, /* GL_TEXTURE8 */

-   { 42234, 0x000084C8 }, /* GL_TEXTURE8_ARB */

-   { 42250, 0x000084C9 }, /* GL_TEXTURE9 */

-   { 42262, 0x000084C9 }, /* GL_TEXTURE9_ARB */

-   { 42278, 0x00000DE0 }, /* GL_TEXTURE_1D */

-   { 42292, 0x00008C18 }, /* GL_TEXTURE_1D_ARRAY */

-   { 42312, 0x00008C18 }, /* GL_TEXTURE_1D_ARRAY_EXT */

-   { 42336, 0x00000DE1 }, /* GL_TEXTURE_2D */

-   { 42350, 0x00008C1A }, /* GL_TEXTURE_2D_ARRAY */

-   { 42370, 0x00008C1A }, /* GL_TEXTURE_2D_ARRAY_EXT */

-   { 42394, 0x0000806F }, /* GL_TEXTURE_3D */

-   { 42408, 0x0000806F }, /* GL_TEXTURE_3D_OES */

-   { 42426, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE */

-   { 42448, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE_EXT */

-   { 42474, 0x0000813C }, /* GL_TEXTURE_BASE_LEVEL */

-   { 42496, 0x00008068 }, /* GL_TEXTURE_BINDING_1D */

-   { 42518, 0x00008C1C }, /* GL_TEXTURE_BINDING_1D_ARRAY */

-   { 42546, 0x00008C1C }, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */

-   { 42578, 0x00008069 }, /* GL_TEXTURE_BINDING_2D */

-   { 42600, 0x00008C1D }, /* GL_TEXTURE_BINDING_2D_ARRAY */

-   { 42628, 0x00008C1D }, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */

-   { 42660, 0x0000806A }, /* GL_TEXTURE_BINDING_3D */

-   { 42682, 0x0000806A }, /* GL_TEXTURE_BINDING_3D_OES */

-   { 42708, 0x00008C2C }, /* GL_TEXTURE_BINDING_BUFFER */

-   { 42734, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP */

-   { 42762, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_ARB */

-   { 42794, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_OES */

-   { 42826, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE */

-   { 42855, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */

-   { 42888, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_NV */

-   { 42920, 0x00040000 }, /* GL_TEXTURE_BIT */

-   { 42935, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE */

-   { 42956, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE_EXT */

-   { 42981, 0x00001005 }, /* GL_TEXTURE_BORDER */

-   { 42999, 0x00001004 }, /* GL_TEXTURE_BORDER_COLOR */

-   { 43023, 0x00008C2A }, /* GL_TEXTURE_BUFFER */

-   { 43041, 0x00008C2D }, /* GL_TEXTURE_BUFFER_DATA_STORE_BINDING */

-   { 43078, 0x00008C2E }, /* GL_TEXTURE_BUFFER_FORMAT */

-   { 43103, 0x00008171 }, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */

-   { 43134, 0x00008176 }, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */

-   { 43164, 0x00008172 }, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */

-   { 43194, 0x00008175 }, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */

-   { 43229, 0x00008173 }, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */

-   { 43260, 0x00008174 }, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */

-   { 43298, 0x000080BC }, /* GL_TEXTURE_COLOR_TABLE_SGI */

-   { 43325, 0x000081EF }, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */

-   { 43357, 0x000080BF }, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */

-   { 43391, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC */

-   { 43415, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC_ARB */

-   { 43443, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE */

-   { 43467, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE_ARB */

-   { 43495, 0x0000819B }, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */

-   { 43528, 0x0000819A }, /* GL_TEXTURE_COMPARE_SGIX */

-   { 43552, 0x00001003 }, /* GL_TEXTURE_COMPONENTS */

-   { 43574, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED */

-   { 43596, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED_ARB */

-   { 43622, 0x000086A3 }, /* GL_TEXTURE_COMPRESSED_FORMATS_ARB */

-   { 43656, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */

-   { 43689, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB */

-   { 43726, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT */

-   { 43754, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT_ARB */

-   { 43786, 0x00008078 }, /* GL_TEXTURE_COORD_ARRAY */

-   { 43809, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */

-   { 43847, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB */

-   { 43889, 0x00008092 }, /* GL_TEXTURE_COORD_ARRAY_POINTER */

-   { 43920, 0x00008088 }, /* GL_TEXTURE_COORD_ARRAY_SIZE */

-   { 43948, 0x0000808A }, /* GL_TEXTURE_COORD_ARRAY_STRIDE */

-   { 43978, 0x00008089 }, /* GL_TEXTURE_COORD_ARRAY_TYPE */

-   { 44006, 0x00008B9D }, /* GL_TEXTURE_CROP_RECT_OES */

-   { 44031, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP */

-   { 44051, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_ARB */

-   { 44075, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */

-   { 44106, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB */

-   { 44141, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES */

-   { 44176, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */

-   { 44207, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB */

-   { 44242, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES */

-   { 44277, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */

-   { 44308, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB */

-   { 44343, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES */

-   { 44378, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_OES */

-   { 44402, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */

-   { 44433, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB */

-   { 44468, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES */

-   { 44503, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */

-   { 44534, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB */

-   { 44569, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES */

-   { 44604, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */

-   { 44635, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB */

-   { 44670, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES */

-   { 44705, 0x000088F4 }, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */

-   { 44734, 0x00008071 }, /* GL_TEXTURE_DEPTH */

-   { 44751, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE */

-   { 44773, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE_ARB */

-   { 44799, 0x00002300 }, /* GL_TEXTURE_ENV */

-   { 44814, 0x00002201 }, /* GL_TEXTURE_ENV_COLOR */

-   { 44835, 0x00002200 }, /* GL_TEXTURE_ENV_MODE */

-   { 44855, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL */

-   { 44881, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL_EXT */

-   { 44911, 0x00002500 }, /* GL_TEXTURE_GEN_MODE */

-   { 44931, 0x00002500 }, /* GL_TEXTURE_GEN_MODE_OES */

-   { 44955, 0x00000C63 }, /* GL_TEXTURE_GEN_Q */

-   { 44972, 0x00000C62 }, /* GL_TEXTURE_GEN_R */

-   { 44989, 0x00000C60 }, /* GL_TEXTURE_GEN_S */

-   { 45006, 0x00008D60 }, /* GL_TEXTURE_GEN_STR_OES */

-   { 45029, 0x00000C61 }, /* GL_TEXTURE_GEN_T */

-   { 45046, 0x0000819D }, /* GL_TEXTURE_GEQUAL_R_SGIX */

-   { 45071, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE */

-   { 45093, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE_EXT */

-   { 45119, 0x00001001 }, /* GL_TEXTURE_HEIGHT */

-   { 45137, 0x000080ED }, /* GL_TEXTURE_INDEX_SIZE_EXT */

-   { 45163, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE */

-   { 45189, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE_EXT */

-   { 45219, 0x00001003 }, /* GL_TEXTURE_INTERNAL_FORMAT */

-   { 45246, 0x0000819C }, /* GL_TEXTURE_LEQUAL_R_SGIX */

-   { 45271, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS */

-   { 45291, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS_EXT */

-   { 45315, 0x00008190 }, /* GL_TEXTURE_LOD_BIAS_R_SGIX */

-   { 45342, 0x0000818E }, /* GL_TEXTURE_LOD_BIAS_S_SGIX */

-   { 45369, 0x0000818F }, /* GL_TEXTURE_LOD_BIAS_T_SGIX */

-   { 45396, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE */

-   { 45422, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE_EXT */

-   { 45452, 0x00002800 }, /* GL_TEXTURE_MAG_FILTER */

-   { 45474, 0x00000BA8 }, /* GL_TEXTURE_MATRIX */

-   { 45492, 0x0000898F }, /* GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES */

-   { 45532, 0x000084FE }, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */

-   { 45562, 0x0000836B }, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */

-   { 45590, 0x00008369 }, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */

-   { 45618, 0x0000836A }, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */

-   { 45646, 0x0000813D }, /* GL_TEXTURE_MAX_LEVEL */

-   { 45667, 0x0000813B }, /* GL_TEXTURE_MAX_LOD */

-   { 45686, 0x00002801 }, /* GL_TEXTURE_MIN_FILTER */

-   { 45708, 0x0000813A }, /* GL_TEXTURE_MIN_LOD */

-   { 45727, 0x00008066 }, /* GL_TEXTURE_PRIORITY */

-   { 45747, 0x000085B7 }, /* GL_TEXTURE_RANGE_LENGTH_APPLE */

-   { 45777, 0x000085B8 }, /* GL_TEXTURE_RANGE_POINTER_APPLE */

-   { 45808, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE */

-   { 45829, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_ARB */

-   { 45854, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_NV */

-   { 45878, 0x0000805C }, /* GL_TEXTURE_RED_SIZE */

-   { 45898, 0x0000805C }, /* GL_TEXTURE_RED_SIZE_EXT */

-   { 45922, 0x00008067 }, /* GL_TEXTURE_RESIDENT */

-   { 45942, 0x00008C3F }, /* GL_TEXTURE_SHARED_SIZE */

-   { 45965, 0x00000BA5 }, /* GL_TEXTURE_STACK_DEPTH */

-   { 45988, 0x000088F1 }, /* GL_TEXTURE_STENCIL_SIZE */

-   { 46012, 0x000088F1 }, /* GL_TEXTURE_STENCIL_SIZE_EXT */

-   { 46040, 0x000085BC }, /* GL_TEXTURE_STORAGE_HINT_APPLE */

-   { 46070, 0x00008065 }, /* GL_TEXTURE_TOO_LARGE_EXT */

-   { 46095, 0x0000888F }, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */

-   { 46129, 0x00001000 }, /* GL_TEXTURE_WIDTH */

-   { 46146, 0x00008072 }, /* GL_TEXTURE_WRAP_R */

-   { 46164, 0x00008072 }, /* GL_TEXTURE_WRAP_R_OES */

-   { 46186, 0x00002802 }, /* GL_TEXTURE_WRAP_S */

-   { 46204, 0x00002803 }, /* GL_TEXTURE_WRAP_T */

-   { 46222, 0x0000911B }, /* GL_TIMEOUT_EXPIRED */

-   { 46241, 0x000088BF }, /* GL_TIME_ELAPSED_EXT */

-   { 46261, 0x00008648 }, /* GL_TRACK_MATRIX_NV */

-   { 46280, 0x00008649 }, /* GL_TRACK_MATRIX_TRANSFORM_NV */

-   { 46309, 0x00001000 }, /* GL_TRANSFORM_BIT */

-   { 46326, 0x00008E22 }, /* GL_TRANSFORM_FEEDBACK */

-   { 46348, 0x00008E25 }, /* GL_TRANSFORM_FEEDBACK_BINDING */

-   { 46378, 0x00008C8E }, /* GL_TRANSFORM_FEEDBACK_BUFFER */

-   { 46407, 0x00008E24 }, /* GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE */

-   { 46443, 0x00008C8F }, /* GL_TRANSFORM_FEEDBACK_BUFFER_BINDING */

-   { 46480, 0x00008C8F }, /* GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT */

-   { 46521, 0x00008C8E }, /* GL_TRANSFORM_FEEDBACK_BUFFER_EXT */

-   { 46554, 0x00008C7F }, /* GL_TRANSFORM_FEEDBACK_BUFFER_MODE */

-   { 46588, 0x00008C7F }, /* GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT */

-   { 46626, 0x00008E23 }, /* GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED */

-   { 46662, 0x00008C85 }, /* GL_TRANSFORM_FEEDBACK_BUFFER_SIZE */

-   { 46696, 0x00008C85 }, /* GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT */

-   { 46734, 0x00008C84 }, /* GL_TRANSFORM_FEEDBACK_BUFFER_START */

-   { 46769, 0x00008C84 }, /* GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT */

-   { 46808, 0x00008C88 }, /* GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN */

-   { 46849, 0x00008C88 }, /* GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT */

-   { 46894, 0x00008C83 }, /* GL_TRANSFORM_FEEDBACK_VARYINGS */

-   { 46925, 0x00008C83 }, /* GL_TRANSFORM_FEEDBACK_VARYINGS_EXT */

-   { 46960, 0x00008C76 }, /* GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH */

-   { 47001, 0x00008C76 }, /* GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT */

-   { 47046, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX */

-   { 47072, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX_ARB */

-   { 47102, 0x000088B7 }, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */

-   { 47134, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX */

-   { 47164, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX_ARB */

-   { 47198, 0x0000862C }, /* GL_TRANSPOSE_NV */

-   { 47214, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX */

-   { 47245, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX_ARB */

-   { 47280, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX */

-   { 47308, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX_ARB */

-   { 47340, 0x00000004 }, /* GL_TRIANGLES */

-   { 47353, 0x0000000C }, /* GL_TRIANGLES_ADJACENCY */

-   { 47376, 0x0000000C }, /* GL_TRIANGLES_ADJACENCY_ARB */

-   { 47403, 0x00000006 }, /* GL_TRIANGLE_FAN */

-   { 47419, 0x00008615 }, /* GL_TRIANGLE_MESH_SUN */

-   { 47440, 0x00000005 }, /* GL_TRIANGLE_STRIP */

-   { 47458, 0x0000000D }, /* GL_TRIANGLE_STRIP_ADJACENCY */

-   { 47486, 0x0000000D }, /* GL_TRIANGLE_STRIP_ADJACENCY_ARB */

-   { 47518, 0x00000001 }, /* GL_TRUE */

-   { 47526, 0x00008A1C }, /* GL_UNDEFINED_APPLE */

-   { 47545, 0x00000CF5 }, /* GL_UNPACK_ALIGNMENT */

-   { 47565, 0x0000806E }, /* GL_UNPACK_IMAGE_HEIGHT */

-   { 47588, 0x00000CF1 }, /* GL_UNPACK_LSB_FIRST */

-   { 47608, 0x00000CF2 }, /* GL_UNPACK_ROW_LENGTH */

-   { 47629, 0x0000806D }, /* GL_UNPACK_SKIP_IMAGES */

-   { 47651, 0x00000CF4 }, /* GL_UNPACK_SKIP_PIXELS */

-   { 47673, 0x00000CF3 }, /* GL_UNPACK_SKIP_ROWS */

-   { 47693, 0x00000CF0 }, /* GL_UNPACK_SWAP_BYTES */

-   { 47714, 0x00009118 }, /* GL_UNSIGNALED */

-   { 47728, 0x00001401 }, /* GL_UNSIGNED_BYTE */

-   { 47745, 0x00008362 }, /* GL_UNSIGNED_BYTE_2_3_3_REV */

-   { 47772, 0x00008032 }, /* GL_UNSIGNED_BYTE_3_3_2 */

-   { 47795, 0x00001405 }, /* GL_UNSIGNED_INT */

-   { 47811, 0x00008C3B }, /* GL_UNSIGNED_INT_10F_11F_11F_REV */

-   { 47843, 0x00008036 }, /* GL_UNSIGNED_INT_10_10_10_2 */

-   { 47870, 0x00008DF6 }, /* GL_UNSIGNED_INT_10_10_10_2_OES */

-   { 47901, 0x000084FA }, /* GL_UNSIGNED_INT_24_8 */

-   { 47922, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_EXT */

-   { 47947, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_NV */

-   { 47971, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_OES */

-   { 47996, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV */

-   { 48027, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV_EXT */

-   { 48062, 0x00008C3E }, /* GL_UNSIGNED_INT_5_9_9_9_REV */

-   { 48090, 0x00008035 }, /* GL_UNSIGNED_INT_8_8_8_8 */

-   { 48114, 0x00008367 }, /* GL_UNSIGNED_INT_8_8_8_8_REV */

-   { 48142, 0x00008DD1 }, /* GL_UNSIGNED_INT_SAMPLER_1D */

-   { 48169, 0x00008DD6 }, /* GL_UNSIGNED_INT_SAMPLER_1D_ARRAY */

-   { 48202, 0x00008DD6 }, /* GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT */

-   { 48239, 0x00008DD1 }, /* GL_UNSIGNED_INT_SAMPLER_1D_EXT */

-   { 48270, 0x00008DD2 }, /* GL_UNSIGNED_INT_SAMPLER_2D */

-   { 48297, 0x00008DD7 }, /* GL_UNSIGNED_INT_SAMPLER_2D_ARRAY */

-   { 48330, 0x00008DD7 }, /* GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT */

-   { 48367, 0x00008DD2 }, /* GL_UNSIGNED_INT_SAMPLER_2D_EXT */

-   { 48398, 0x00008DD5 }, /* GL_UNSIGNED_INT_SAMPLER_2D_RECT */

-   { 48430, 0x00008DD5 }, /* GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT */

-   { 48466, 0x00008DD3 }, /* GL_UNSIGNED_INT_SAMPLER_3D */

-   { 48493, 0x00008DD3 }, /* GL_UNSIGNED_INT_SAMPLER_3D_EXT */

-   { 48524, 0x00008DD8 }, /* GL_UNSIGNED_INT_SAMPLER_BUFFER */

-   { 48555, 0x00008DD8 }, /* GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT */

-   { 48590, 0x00008DD4 }, /* GL_UNSIGNED_INT_SAMPLER_CUBE */

-   { 48619, 0x00008DD4 }, /* GL_UNSIGNED_INT_SAMPLER_CUBE_EXT */

-   { 48652, 0x00008DC6 }, /* GL_UNSIGNED_INT_VEC2 */

-   { 48673, 0x00008DC6 }, /* GL_UNSIGNED_INT_VEC2_EXT */

-   { 48698, 0x00008DC7 }, /* GL_UNSIGNED_INT_VEC3 */

-   { 48719, 0x00008DC7 }, /* GL_UNSIGNED_INT_VEC3_EXT */

-   { 48744, 0x00008DC8 }, /* GL_UNSIGNED_INT_VEC4 */

-   { 48765, 0x00008DC8 }, /* GL_UNSIGNED_INT_VEC4_EXT */

-   { 48790, 0x00008C17 }, /* GL_UNSIGNED_NORMALIZED */

-   { 48813, 0x00001403 }, /* GL_UNSIGNED_SHORT */

-   { 48831, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */

-   { 48861, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT */

-   { 48895, 0x00008033 }, /* GL_UNSIGNED_SHORT_4_4_4_4 */

-   { 48921, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */

-   { 48951, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT */

-   { 48985, 0x00008034 }, /* GL_UNSIGNED_SHORT_5_5_5_1 */

-   { 49011, 0x00008363 }, /* GL_UNSIGNED_SHORT_5_6_5 */

-   { 49035, 0x00008364 }, /* GL_UNSIGNED_SHORT_5_6_5_REV */

-   { 49063, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_APPLE */

-   { 49091, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_MESA */

-   { 49118, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */

-   { 49150, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_MESA */

-   { 49181, 0x00008CA2 }, /* GL_UPPER_LEFT */

-   { 49195, 0x00002A20 }, /* GL_V2F */

-   { 49202, 0x00002A21 }, /* GL_V3F */

-   { 49209, 0x00008B83 }, /* GL_VALIDATE_STATUS */

-   { 49228, 0x00001F00 }, /* GL_VENDOR */

-   { 49238, 0x00001F02 }, /* GL_VERSION */

-   { 49249, 0x00008074 }, /* GL_VERTEX_ARRAY */

-   { 49265, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING */

-   { 49289, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING_APPLE */

-   { 49319, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING */

-   { 49350, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING_ARB */

-   { 49385, 0x0000808E }, /* GL_VERTEX_ARRAY_POINTER */

-   { 49409, 0x0000807A }, /* GL_VERTEX_ARRAY_SIZE */

-   { 49430, 0x0000807C }, /* GL_VERTEX_ARRAY_STRIDE */

-   { 49453, 0x0000807B }, /* GL_VERTEX_ARRAY_TYPE */

-   { 49474, 0x00008650 }, /* GL_VERTEX_ATTRIB_ARRAY0_NV */

-   { 49501, 0x0000865A }, /* GL_VERTEX_ATTRIB_ARRAY10_NV */

-   { 49529, 0x0000865B }, /* GL_VERTEX_ATTRIB_ARRAY11_NV */

-   { 49557, 0x0000865C }, /* GL_VERTEX_ATTRIB_ARRAY12_NV */

-   { 49585, 0x0000865D }, /* GL_VERTEX_ATTRIB_ARRAY13_NV */

-   { 49613, 0x0000865E }, /* GL_VERTEX_ATTRIB_ARRAY14_NV */

-   { 49641, 0x0000865F }, /* GL_VERTEX_ATTRIB_ARRAY15_NV */

-   { 49669, 0x00008651 }, /* GL_VERTEX_ATTRIB_ARRAY1_NV */

-   { 49696, 0x00008652 }, /* GL_VERTEX_ATTRIB_ARRAY2_NV */

-   { 49723, 0x00008653 }, /* GL_VERTEX_ATTRIB_ARRAY3_NV */

-   { 49750, 0x00008654 }, /* GL_VERTEX_ATTRIB_ARRAY4_NV */

-   { 49777, 0x00008655 }, /* GL_VERTEX_ATTRIB_ARRAY5_NV */

-   { 49804, 0x00008656 }, /* GL_VERTEX_ATTRIB_ARRAY6_NV */

-   { 49831, 0x00008657 }, /* GL_VERTEX_ATTRIB_ARRAY7_NV */

-   { 49858, 0x00008658 }, /* GL_VERTEX_ATTRIB_ARRAY8_NV */

-   { 49885, 0x00008659 }, /* GL_VERTEX_ATTRIB_ARRAY9_NV */

-   { 49912, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */

-   { 49950, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB */

-   { 49992, 0x000088FE }, /* GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB */

-   { 50027, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */

-   { 50058, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */

-   { 50093, 0x000088FD }, /* GL_VERTEX_ATTRIB_ARRAY_INTEGER */

-   { 50124, 0x000088FD }, /* GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT */

-   { 50159, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */

-   { 50193, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */

-   { 50231, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */

-   { 50262, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */

-   { 50297, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */

-   { 50325, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */

-   { 50357, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */

-   { 50387, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */

-   { 50421, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */

-   { 50449, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */

-   { 50481, 0x000086A7 }, /* GL_VERTEX_BLEND_ARB */

-   { 50501, 0x00008620 }, /* GL_VERTEX_PROGRAM_ARB */

-   { 50523, 0x0000864A }, /* GL_VERTEX_PROGRAM_BINDING_NV */

-   { 50552, 0x00008620 }, /* GL_VERTEX_PROGRAM_NV */

-   { 50573, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE */

-   { 50602, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */

-   { 50635, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_NV */

-   { 50667, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE */

-   { 50694, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */

-   { 50725, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_NV */

-   { 50755, 0x00008B31 }, /* GL_VERTEX_SHADER */

-   { 50772, 0x00008B31 }, /* GL_VERTEX_SHADER_ARB */

-   { 50793, 0x00008621 }, /* GL_VERTEX_STATE_PROGRAM_NV */

-   { 50820, 0x00000BA2 }, /* GL_VIEWPORT */

-   { 50832, 0x00000800 }, /* GL_VIEWPORT_BIT */

-   { 50848, 0x00008A1A }, /* GL_VOLATILE_APPLE */

-   { 50866, 0x0000911D }, /* GL_WAIT_FAILED */

-   { 50881, 0x000086AD }, /* GL_WEIGHT_ARRAY_ARB */

-   { 50901, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */

-   { 50932, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB */

-   { 50967, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_OES */

-   { 51002, 0x000086AD }, /* GL_WEIGHT_ARRAY_OES */

-   { 51022, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_ARB */

-   { 51050, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_OES */

-   { 51078, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_ARB */

-   { 51103, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_OES */

-   { 51128, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_ARB */

-   { 51155, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_OES */

-   { 51182, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_ARB */

-   { 51207, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_OES */

-   { 51232, 0x000086A6 }, /* GL_WEIGHT_SUM_UNITY_ARB */

-   { 51256, 0x000081D4 }, /* GL_WRAP_BORDER_SUN */

-   { 51275, 0x000088B9 }, /* GL_WRITE_ONLY */

-   { 51289, 0x000088B9 }, /* GL_WRITE_ONLY_ARB */

-   { 51307, 0x000088B9 }, /* GL_WRITE_ONLY_OES */

-   { 51325, 0x00001506 }, /* GL_XOR */

-   { 51332, 0x000085B9 }, /* GL_YCBCR_422_APPLE */

-   { 51351, 0x00008757 }, /* GL_YCBCR_MESA */

-   { 51365, 0x00000000 }, /* GL_ZERO */

-   { 51373, 0x00000D16 }, /* GL_ZOOM_X */

-   { 51383, 0x00000D17 }, /* GL_ZOOM_Y */

-};

-

-static const unsigned reduced_enums[1552] =

-{

-       535, /* GL_FALSE */

-       827, /* GL_LINES */

-       831, /* GL_LINE_LOOP */

-       838, /* GL_LINE_STRIP */

-      2135, /* GL_TRIANGLES */

-      2140, /* GL_TRIANGLE_STRIP */

-      2138, /* GL_TRIANGLE_FAN */

-      1507, /* GL_QUADS */

-      1511, /* GL_QUAD_STRIP */

-      1378, /* GL_POLYGON */

-       828, /* GL_LINES_ADJACENCY */

-       839, /* GL_LINE_STRIP_ADJACENCY */

-      2136, /* GL_TRIANGLES_ADJACENCY */

-      2141, /* GL_TRIANGLE_STRIP_ADJACENCY */

-      1390, /* GL_POLYGON_STIPPLE_BIT */

-      1333, /* GL_PIXEL_MODE_BIT */

-       814, /* GL_LIGHTING_BIT */

-       568, /* GL_FOG_BIT */

-         8, /* GL_ACCUM */

-       850, /* GL_LOAD */

-      1596, /* GL_RETURN */

-      1200, /* GL_MULT */

-        24, /* GL_ADD */

-      1216, /* GL_NEVER */

-       804, /* GL_LESS */

-       525, /* GL_EQUAL */

-       803, /* GL_LEQUAL */

-       691, /* GL_GREATER */

-      1233, /* GL_NOTEQUAL */

-       690, /* GL_GEQUAL */

-        55, /* GL_ALWAYS */

-      1803, /* GL_SRC_COLOR */

-      1266, /* GL_ONE_MINUS_SRC_COLOR */

-      1801, /* GL_SRC_ALPHA */

-      1265, /* GL_ONE_MINUS_SRC_ALPHA */

-       504, /* GL_DST_ALPHA */

-      1263, /* GL_ONE_MINUS_DST_ALPHA */

-       505, /* GL_DST_COLOR */

-      1264, /* GL_ONE_MINUS_DST_COLOR */

-      1802, /* GL_SRC_ALPHA_SATURATE */

-       667, /* GL_FRONT_LEFT */

-       668, /* GL_FRONT_RIGHT */

-        77, /* GL_BACK_LEFT */

-        78, /* GL_BACK_RIGHT */

-       664, /* GL_FRONT */

-        76, /* GL_BACK */

-       802, /* GL_LEFT */

-      1685, /* GL_RIGHT */

-       665, /* GL_FRONT_AND_BACK */

-        71, /* GL_AUX0 */

-        72, /* GL_AUX1 */

-        73, /* GL_AUX2 */

-        74, /* GL_AUX3 */

-       790, /* GL_INVALID_ENUM */

-       795, /* GL_INVALID_VALUE */

-       794, /* GL_INVALID_OPERATION */

-      1808, /* GL_STACK_OVERFLOW */

-      1809, /* GL_STACK_UNDERFLOW */

-      1291, /* GL_OUT_OF_MEMORY */

-       791, /* GL_INVALID_FRAMEBUFFER_OPERATION */

-         0, /* GL_2D */

-         2, /* GL_3D */

-         3, /* GL_3D_COLOR */

-         4, /* GL_3D_COLOR_TEXTURE */

-         6, /* GL_4D_COLOR_TEXTURE */

-      1311, /* GL_PASS_THROUGH_TOKEN */

-      1377, /* GL_POINT_TOKEN */

-       841, /* GL_LINE_TOKEN */

-      1391, /* GL_POLYGON_TOKEN */

-        87, /* GL_BITMAP_TOKEN */

-       503, /* GL_DRAW_PIXEL_TOKEN */

-       349, /* GL_COPY_PIXEL_TOKEN */

-       832, /* GL_LINE_RESET_TOKEN */

-       528, /* GL_EXP */

-       529, /* GL_EXP2 */

-       386, /* GL_CW */

-       154, /* GL_CCW */

-       184, /* GL_COEFF */

-      1288, /* GL_ORDER */

-       440, /* GL_DOMAIN */

-       359, /* GL_CURRENT_COLOR */

-       362, /* GL_CURRENT_INDEX */

-       368, /* GL_CURRENT_NORMAL */

-       382, /* GL_CURRENT_TEXTURE_COORDS */

-       374, /* GL_CURRENT_RASTER_COLOR */

-       376, /* GL_CURRENT_RASTER_INDEX */

-       380, /* GL_CURRENT_RASTER_TEXTURE_COORDS */

-       377, /* GL_CURRENT_RASTER_POSITION */

-       378, /* GL_CURRENT_RASTER_POSITION_VALID */

-       375, /* GL_CURRENT_RASTER_DISTANCE */

-      1369, /* GL_POINT_SMOOTH */

-      1353, /* GL_POINT_SIZE */

-      1368, /* GL_POINT_SIZE_RANGE */

-      1359, /* GL_POINT_SIZE_GRANULARITY */

-       833, /* GL_LINE_SMOOTH */

-       842, /* GL_LINE_WIDTH */

-       844, /* GL_LINE_WIDTH_RANGE */

-       843, /* GL_LINE_WIDTH_GRANULARITY */

-       835, /* GL_LINE_STIPPLE */

-       836, /* GL_LINE_STIPPLE_PATTERN */

-       837, /* GL_LINE_STIPPLE_REPEAT */

-       849, /* GL_LIST_MODE */

-      1056, /* GL_MAX_LIST_NESTING */

-       846, /* GL_LIST_BASE */

-       848, /* GL_LIST_INDEX */

-      1380, /* GL_POLYGON_MODE */

-      1387, /* GL_POLYGON_SMOOTH */

-      1389, /* GL_POLYGON_STIPPLE */

-       514, /* GL_EDGE_FLAG */

-       352, /* GL_CULL_FACE */

-       353, /* GL_CULL_FACE_MODE */

-       666, /* GL_FRONT_FACE */

-       813, /* GL_LIGHTING */

-       818, /* GL_LIGHT_MODEL_LOCAL_VIEWER */

-       819, /* GL_LIGHT_MODEL_TWO_SIDE */

-       815, /* GL_LIGHT_MODEL_AMBIENT */

-      1750, /* GL_SHADE_MODEL */

-       232, /* GL_COLOR_MATERIAL_FACE */

-       233, /* GL_COLOR_MATERIAL_PARAMETER */

-       231, /* GL_COLOR_MATERIAL */

-       567, /* GL_FOG */

-       589, /* GL_FOG_INDEX */

-       585, /* GL_FOG_DENSITY */

-       593, /* GL_FOG_START */

-       587, /* GL_FOG_END */

-       590, /* GL_FOG_MODE */

-       569, /* GL_FOG_COLOR */

-       425, /* GL_DEPTH_RANGE */

-       434, /* GL_DEPTH_TEST */

-       437, /* GL_DEPTH_WRITEMASK */

-       410, /* GL_DEPTH_CLEAR_VALUE */

-       424, /* GL_DEPTH_FUNC */

-        12, /* GL_ACCUM_CLEAR_VALUE */

-      1853, /* GL_STENCIL_TEST */

-      1834, /* GL_STENCIL_CLEAR_VALUE */

-      1836, /* GL_STENCIL_FUNC */

-      1855, /* GL_STENCIL_VALUE_MASK */

-      1835, /* GL_STENCIL_FAIL */

-      1850, /* GL_STENCIL_PASS_DEPTH_FAIL */

-      1851, /* GL_STENCIL_PASS_DEPTH_PASS */

-      1852, /* GL_STENCIL_REF */

-      1856, /* GL_STENCIL_WRITEMASK */

-      1006, /* GL_MATRIX_MODE */

-      1222, /* GL_NORMALIZE */

-      2267, /* GL_VIEWPORT */

-      1195, /* GL_MODELVIEW_STACK_DEPTH */

-      1481, /* GL_PROJECTION_STACK_DEPTH */

-      2089, /* GL_TEXTURE_STACK_DEPTH */

-      1192, /* GL_MODELVIEW_MATRIX */

-      1479, /* GL_PROJECTION_MATRIX */

-      2069, /* GL_TEXTURE_MATRIX */

-        69, /* GL_ATTRIB_STACK_DEPTH */

-       166, /* GL_CLIENT_ATTRIB_STACK_DEPTH */

-        51, /* GL_ALPHA_TEST */

-        52, /* GL_ALPHA_TEST_FUNC */

-        53, /* GL_ALPHA_TEST_REF */

-       439, /* GL_DITHER */

-        91, /* GL_BLEND_DST */

-       105, /* GL_BLEND_SRC */

-        88, /* GL_BLEND */

-       852, /* GL_LOGIC_OP_MODE */

-       739, /* GL_INDEX_LOGIC_OP */

-       230, /* GL_COLOR_LOGIC_OP */

-        75, /* GL_AUX_BUFFERS */

-       450, /* GL_DRAW_BUFFER */

-      1534, /* GL_READ_BUFFER */

-      1727, /* GL_SCISSOR_BOX */

-      1728, /* GL_SCISSOR_TEST */

-       738, /* GL_INDEX_CLEAR_VALUE */

-       743, /* GL_INDEX_WRITEMASK */

-       227, /* GL_COLOR_CLEAR_VALUE */

-       269, /* GL_COLOR_WRITEMASK */

-       740, /* GL_INDEX_MODE */

-      1674, /* GL_RGBA_MODE */

-       449, /* GL_DOUBLEBUFFER */

-      1857, /* GL_STEREO */

-      1588, /* GL_RENDER_MODE */

-      1312, /* GL_PERSPECTIVE_CORRECTION_HINT */

-      1370, /* GL_POINT_SMOOTH_HINT */

-       834, /* GL_LINE_SMOOTH_HINT */

-      1388, /* GL_POLYGON_SMOOTH_HINT */

-       588, /* GL_FOG_HINT */

-      2049, /* GL_TEXTURE_GEN_S */

-      2051, /* GL_TEXTURE_GEN_T */

-      2048, /* GL_TEXTURE_GEN_R */

-      2047, /* GL_TEXTURE_GEN_Q */

-      1325, /* GL_PIXEL_MAP_I_TO_I */

-      1331, /* GL_PIXEL_MAP_S_TO_S */

-      1327, /* GL_PIXEL_MAP_I_TO_R */

-      1323, /* GL_PIXEL_MAP_I_TO_G */

-      1321, /* GL_PIXEL_MAP_I_TO_B */

-      1319, /* GL_PIXEL_MAP_I_TO_A */

-      1329, /* GL_PIXEL_MAP_R_TO_R */

-      1317, /* GL_PIXEL_MAP_G_TO_G */

-      1315, /* GL_PIXEL_MAP_B_TO_B */

-      1313, /* GL_PIXEL_MAP_A_TO_A */

-      1326, /* GL_PIXEL_MAP_I_TO_I_SIZE */

-      1332, /* GL_PIXEL_MAP_S_TO_S_SIZE */

-      1328, /* GL_PIXEL_MAP_I_TO_R_SIZE */

-      1324, /* GL_PIXEL_MAP_I_TO_G_SIZE */

-      1322, /* GL_PIXEL_MAP_I_TO_B_SIZE */

-      1320, /* GL_PIXEL_MAP_I_TO_A_SIZE */

-      1330, /* GL_PIXEL_MAP_R_TO_R_SIZE */

-      1318, /* GL_PIXEL_MAP_G_TO_G_SIZE */

-      1316, /* GL_PIXEL_MAP_B_TO_B_SIZE */

-      1314, /* GL_PIXEL_MAP_A_TO_A_SIZE */

-      2152, /* GL_UNPACK_SWAP_BYTES */

-      2147, /* GL_UNPACK_LSB_FIRST */

-      2148, /* GL_UNPACK_ROW_LENGTH */

-      2151, /* GL_UNPACK_SKIP_ROWS */

-      2150, /* GL_UNPACK_SKIP_PIXELS */

-      2145, /* GL_UNPACK_ALIGNMENT */

-      1300, /* GL_PACK_SWAP_BYTES */

-      1295, /* GL_PACK_LSB_FIRST */

-      1296, /* GL_PACK_ROW_LENGTH */

-      1299, /* GL_PACK_SKIP_ROWS */

-      1298, /* GL_PACK_SKIP_PIXELS */

-      1292, /* GL_PACK_ALIGNMENT */

-       947, /* GL_MAP_COLOR */

-       952, /* GL_MAP_STENCIL */

-       742, /* GL_INDEX_SHIFT */

-       741, /* GL_INDEX_OFFSET */

-      1550, /* GL_RED_SCALE */

-      1546, /* GL_RED_BIAS */

-      2293, /* GL_ZOOM_X */

-      2294, /* GL_ZOOM_Y */

-       697, /* GL_GREEN_SCALE */

-       693, /* GL_GREEN_BIAS */

-       115, /* GL_BLUE_SCALE */

-       111, /* GL_BLUE_BIAS */

-        50, /* GL_ALPHA_SCALE */

-        47, /* GL_ALPHA_BIAS */

-       426, /* GL_DEPTH_SCALE */

-       402, /* GL_DEPTH_BIAS */

-      1038, /* GL_MAX_EVAL_ORDER */

-      1055, /* GL_MAX_LIGHTS */

-      1018, /* GL_MAX_CLIP_DISTANCES */

-      1110, /* GL_MAX_TEXTURE_SIZE */

-      1062, /* GL_MAX_PIXEL_MAP_TABLE */

-      1014, /* GL_MAX_ATTRIB_STACK_DEPTH */

-      1058, /* GL_MAX_MODELVIEW_STACK_DEPTH */

-      1059, /* GL_MAX_NAME_STACK_DEPTH */

-      1090, /* GL_MAX_PROJECTION_STACK_DEPTH */

-      1111, /* GL_MAX_TEXTURE_STACK_DEPTH */

-      1137, /* GL_MAX_VIEWPORT_DIMS */

-      1015, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */

-      1867, /* GL_SUBPIXEL_BITS */

-       737, /* GL_INDEX_BITS */

-      1547, /* GL_RED_BITS */

-       694, /* GL_GREEN_BITS */

-       112, /* GL_BLUE_BITS */

-        48, /* GL_ALPHA_BITS */

-       403, /* GL_DEPTH_BITS */

-      1831, /* GL_STENCIL_BITS */

-        14, /* GL_ACCUM_RED_BITS */

-        13, /* GL_ACCUM_GREEN_BITS */

-        10, /* GL_ACCUM_BLUE_BITS */

-         9, /* GL_ACCUM_ALPHA_BITS */

-      1209, /* GL_NAME_STACK_DEPTH */

-        70, /* GL_AUTO_NORMAL */

-       893, /* GL_MAP1_COLOR_4 */

-       896, /* GL_MAP1_INDEX */

-       897, /* GL_MAP1_NORMAL */

-       898, /* GL_MAP1_TEXTURE_COORD_1 */

-       899, /* GL_MAP1_TEXTURE_COORD_2 */

-       900, /* GL_MAP1_TEXTURE_COORD_3 */

-       901, /* GL_MAP1_TEXTURE_COORD_4 */

-       902, /* GL_MAP1_VERTEX_3 */

-       903, /* GL_MAP1_VERTEX_4 */

-       920, /* GL_MAP2_COLOR_4 */

-       923, /* GL_MAP2_INDEX */

-       924, /* GL_MAP2_NORMAL */

-       925, /* GL_MAP2_TEXTURE_COORD_1 */

-       926, /* GL_MAP2_TEXTURE_COORD_2 */

-       927, /* GL_MAP2_TEXTURE_COORD_3 */

-       928, /* GL_MAP2_TEXTURE_COORD_4 */

-       929, /* GL_MAP2_VERTEX_3 */

-       930, /* GL_MAP2_VERTEX_4 */

-       894, /* GL_MAP1_GRID_DOMAIN */

-       895, /* GL_MAP1_GRID_SEGMENTS */

-       921, /* GL_MAP2_GRID_DOMAIN */

-       922, /* GL_MAP2_GRID_SEGMENTS */

-      1950, /* GL_TEXTURE_1D */

-      1953, /* GL_TEXTURE_2D */

-       538, /* GL_FEEDBACK_BUFFER_POINTER */

-       539, /* GL_FEEDBACK_BUFFER_SIZE */

-       540, /* GL_FEEDBACK_BUFFER_TYPE */

-      1737, /* GL_SELECTION_BUFFER_POINTER */

-      1738, /* GL_SELECTION_BUFFER_SIZE */

-      2095, /* GL_TEXTURE_WIDTH */

-      2055, /* GL_TEXTURE_HEIGHT */

-      1999, /* GL_TEXTURE_COMPONENTS */

-      1980, /* GL_TEXTURE_BORDER_COLOR */

-      1979, /* GL_TEXTURE_BORDER */

-       441, /* GL_DONT_CARE */

-       536, /* GL_FASTEST */

-      1217, /* GL_NICEST */

-        56, /* GL_AMBIENT */

-       438, /* GL_DIFFUSE */

-      1790, /* GL_SPECULAR */

-      1392, /* GL_POSITION */

-      1793, /* GL_SPOT_DIRECTION */

-      1794, /* GL_SPOT_EXPONENT */

-      1792, /* GL_SPOT_CUTOFF */

-       317, /* GL_CONSTANT_ATTENUATION */

-       822, /* GL_LINEAR_ATTENUATION */

-      1506, /* GL_QUADRATIC_ATTENUATION */

-       284, /* GL_COMPILE */

-       285, /* GL_COMPILE_AND_EXECUTE */

-       149, /* GL_BYTE */

-      2154, /* GL_UNSIGNED_BYTE */

-      1755, /* GL_SHORT */

-      2193, /* GL_UNSIGNED_SHORT */

-       745, /* GL_INT */

-      2157, /* GL_UNSIGNED_INT */

-       548, /* GL_FLOAT */

-         1, /* GL_2_BYTES */

-         5, /* GL_3_BYTES */

-         7, /* GL_4_BYTES */

-       448, /* GL_DOUBLE */

-       698, /* GL_HALF_FLOAT */

-       544, /* GL_FIXED */

-       162, /* GL_CLEAR */

-        58, /* GL_AND */

-        60, /* GL_AND_REVERSE */

-       347, /* GL_COPY */

-        59, /* GL_AND_INVERTED */

-      1220, /* GL_NOOP */

-      2289, /* GL_XOR */

-      1287, /* GL_OR */

-      1221, /* GL_NOR */

-       526, /* GL_EQUIV */

-       798, /* GL_INVERT */

-      1290, /* GL_OR_REVERSE */

-       348, /* GL_COPY_INVERTED */

-      1289, /* GL_OR_INVERTED */

-      1210, /* GL_NAND */

-      1744, /* GL_SET */

-       523, /* GL_EMISSION */

-      1754, /* GL_SHININESS */

-        57, /* GL_AMBIENT_AND_DIFFUSE */

-       229, /* GL_COLOR_INDEXES */

-      1159, /* GL_MODELVIEW */

-      1478, /* GL_PROJECTION */

-      1885, /* GL_TEXTURE */

-       185, /* GL_COLOR */

-       395, /* GL_DEPTH */

-      1816, /* GL_STENCIL */

-       228, /* GL_COLOR_INDEX */

-      1837, /* GL_STENCIL_INDEX */

-       411, /* GL_DEPTH_COMPONENT */

-      1543, /* GL_RED */

-       692, /* GL_GREEN */

-       110, /* GL_BLUE */

-        32, /* GL_ALPHA */

-      1599, /* GL_RGB */

-      1639, /* GL_RGBA */

-       856, /* GL_LUMINANCE */

-       883, /* GL_LUMINANCE_ALPHA */

-        86, /* GL_BITMAP */

-      1342, /* GL_POINT */

-       820, /* GL_LINE */

-       541, /* GL_FILL */

-      1557, /* GL_RENDER */

-       537, /* GL_FEEDBACK */

-      1736, /* GL_SELECT */

-       547, /* GL_FLAT */

-      1765, /* GL_SMOOTH */

-       799, /* GL_KEEP */

-      1590, /* GL_REPLACE */

-       727, /* GL_INCR */

-       391, /* GL_DECR */

-      2210, /* GL_VENDOR */

-      1587, /* GL_RENDERER */

-      2211, /* GL_VERSION */

-       530, /* GL_EXTENSIONS */

-      1686, /* GL_S */

-      1876, /* GL_T */

-      1526, /* GL_R */

-      1505, /* GL_Q */

-      1196, /* GL_MODULATE */

-       390, /* GL_DECAL */

-      2042, /* GL_TEXTURE_ENV_MODE */

-      2041, /* GL_TEXTURE_ENV_COLOR */

-      2040, /* GL_TEXTURE_ENV */

-       531, /* GL_EYE_LINEAR */

-      1248, /* GL_OBJECT_LINEAR */

-      1791, /* GL_SPHERE_MAP */

-      2045, /* GL_TEXTURE_GEN_MODE */

-      1250, /* GL_OBJECT_PLANE */

-       532, /* GL_EYE_PLANE */

-      1211, /* GL_NEAREST */

-       821, /* GL_LINEAR */

-      1215, /* GL_NEAREST_MIPMAP_NEAREST */

-       826, /* GL_LINEAR_MIPMAP_NEAREST */

-      1214, /* GL_NEAREST_MIPMAP_LINEAR */

-       825, /* GL_LINEAR_MIPMAP_LINEAR */

-      2068, /* GL_TEXTURE_MAG_FILTER */

-      2077, /* GL_TEXTURE_MIN_FILTER */

-      2098, /* GL_TEXTURE_WRAP_S */

-      2099, /* GL_TEXTURE_WRAP_T */

-       155, /* GL_CLAMP */

-      1589, /* GL_REPEAT */

-      1386, /* GL_POLYGON_OFFSET_UNITS */

-      1385, /* GL_POLYGON_OFFSET_POINT */

-      1384, /* GL_POLYGON_OFFSET_LINE */

-      1529, /* GL_R3_G3_B2 */

-      2207, /* GL_V2F */

-      2208, /* GL_V3F */

-       152, /* GL_C4UB_V2F */

-       153, /* GL_C4UB_V3F */

-       150, /* GL_C3F_V3F */

-      1208, /* GL_N3F_V3F */

-       151, /* GL_C4F_N3F_V3F */

-      1881, /* GL_T2F_V3F */

-      1883, /* GL_T4F_V4F */

-      1879, /* GL_T2F_C4UB_V3F */

-      1877, /* GL_T2F_C3F_V3F */

-      1880, /* GL_T2F_N3F_V3F */

-      1878, /* GL_T2F_C4F_N3F_V3F */

-      1882, /* GL_T4F_C4F_N3F_V4F */

-       169, /* GL_CLIP_DISTANCE0 */

-       170, /* GL_CLIP_DISTANCE1 */

-       171, /* GL_CLIP_DISTANCE2 */

-       172, /* GL_CLIP_DISTANCE3 */

-       173, /* GL_CLIP_DISTANCE4 */

-       174, /* GL_CLIP_DISTANCE5 */

-       175, /* GL_CLIP_DISTANCE6 */

-       176, /* GL_CLIP_DISTANCE7 */

-       805, /* GL_LIGHT0 */

-       806, /* GL_LIGHT1 */

-       807, /* GL_LIGHT2 */

-       808, /* GL_LIGHT3 */

-       809, /* GL_LIGHT4 */

-       810, /* GL_LIGHT5 */

-       811, /* GL_LIGHT6 */

-       812, /* GL_LIGHT7 */

-       702, /* GL_HINT_BIT */

-       319, /* GL_CONSTANT_COLOR */

-      1261, /* GL_ONE_MINUS_CONSTANT_COLOR */

-       314, /* GL_CONSTANT_ALPHA */

-      1259, /* GL_ONE_MINUS_CONSTANT_ALPHA */

-        89, /* GL_BLEND_COLOR */

-       669, /* GL_FUNC_ADD */

-      1140, /* GL_MIN */

-      1009, /* GL_MAX */

-        96, /* GL_BLEND_EQUATION */

-       675, /* GL_FUNC_SUBTRACT */

-       672, /* GL_FUNC_REVERSE_SUBTRACT */

-       327, /* GL_CONVOLUTION_1D */

-       328, /* GL_CONVOLUTION_2D */

-      1739, /* GL_SEPARABLE_2D */

-       331, /* GL_CONVOLUTION_BORDER_MODE */

-       335, /* GL_CONVOLUTION_FILTER_SCALE */

-       333, /* GL_CONVOLUTION_FILTER_BIAS */

-      1544, /* GL_REDUCE */

-       337, /* GL_CONVOLUTION_FORMAT */

-       341, /* GL_CONVOLUTION_WIDTH */

-       339, /* GL_CONVOLUTION_HEIGHT */

-      1028, /* GL_MAX_CONVOLUTION_WIDTH */

-      1026, /* GL_MAX_CONVOLUTION_HEIGHT */

-      1425, /* GL_POST_CONVOLUTION_RED_SCALE */

-      1421, /* GL_POST_CONVOLUTION_GREEN_SCALE */

-      1416, /* GL_POST_CONVOLUTION_BLUE_SCALE */

-      1412, /* GL_POST_CONVOLUTION_ALPHA_SCALE */

-      1423, /* GL_POST_CONVOLUTION_RED_BIAS */

-      1419, /* GL_POST_CONVOLUTION_GREEN_BIAS */

-      1414, /* GL_POST_CONVOLUTION_BLUE_BIAS */

-      1410, /* GL_POST_CONVOLUTION_ALPHA_BIAS */

-       703, /* GL_HISTOGRAM */

-      1485, /* GL_PROXY_HISTOGRAM */

-       719, /* GL_HISTOGRAM_WIDTH */

-       709, /* GL_HISTOGRAM_FORMAT */

-       715, /* GL_HISTOGRAM_RED_SIZE */

-       711, /* GL_HISTOGRAM_GREEN_SIZE */

-       706, /* GL_HISTOGRAM_BLUE_SIZE */

-       704, /* GL_HISTOGRAM_ALPHA_SIZE */

-       713, /* GL_HISTOGRAM_LUMINANCE_SIZE */

-       717, /* GL_HISTOGRAM_SINK */

-      1141, /* GL_MINMAX */

-      1143, /* GL_MINMAX_FORMAT */

-      1145, /* GL_MINMAX_SINK */

-      1884, /* GL_TABLE_TOO_LARGE_EXT */

-      2156, /* GL_UNSIGNED_BYTE_3_3_2 */

-      2196, /* GL_UNSIGNED_SHORT_4_4_4_4 */

-      2199, /* GL_UNSIGNED_SHORT_5_5_5_1 */

-      2168, /* GL_UNSIGNED_INT_8_8_8_8 */

-      2159, /* GL_UNSIGNED_INT_10_10_10_2 */

-      1383, /* GL_POLYGON_OFFSET_FILL */

-      1382, /* GL_POLYGON_OFFSET_FACTOR */

-      1381, /* GL_POLYGON_OFFSET_BIAS */

-      1593, /* GL_RESCALE_NORMAL */

-        41, /* GL_ALPHA4 */

-        43, /* GL_ALPHA8 */

-        33, /* GL_ALPHA12 */

-        35, /* GL_ALPHA16 */

-       871, /* GL_LUMINANCE4 */

-       877, /* GL_LUMINANCE8 */

-       857, /* GL_LUMINANCE12 */

-       863, /* GL_LUMINANCE16 */

-       872, /* GL_LUMINANCE4_ALPHA4 */

-       875, /* GL_LUMINANCE6_ALPHA2 */

-       880, /* GL_LUMINANCE8_ALPHA8 */

-       860, /* GL_LUMINANCE12_ALPHA4 */

-       858, /* GL_LUMINANCE12_ALPHA12 */

-       866, /* GL_LUMINANCE16_ALPHA16 */

-       746, /* GL_INTENSITY */

-       755, /* GL_INTENSITY4 */

-       757, /* GL_INTENSITY8 */

-       747, /* GL_INTENSITY12 */

-       749, /* GL_INTENSITY16 */

-      1614, /* GL_RGB2_EXT */

-      1620, /* GL_RGB4 */

-      1623, /* GL_RGB5 */

-      1630, /* GL_RGB8 */

-      1600, /* GL_RGB10 */

-      1604, /* GL_RGB12 */

-      1606, /* GL_RGB16 */

-      1650, /* GL_RGBA2 */

-      1657, /* GL_RGBA4 */

-      1626, /* GL_RGB5_A1 */

-      1662, /* GL_RGBA8 */

-      1601, /* GL_RGB10_A2 */

-      1640, /* GL_RGBA12 */

-      1642, /* GL_RGBA16 */

-      2085, /* GL_TEXTURE_RED_SIZE */

-      2053, /* GL_TEXTURE_GREEN_SIZE */

-      1977, /* GL_TEXTURE_BLUE_SIZE */

-      1958, /* GL_TEXTURE_ALPHA_SIZE */

-      2066, /* GL_TEXTURE_LUMINANCE_SIZE */

-      2057, /* GL_TEXTURE_INTENSITY_SIZE */

-      1591, /* GL_REPLACE_EXT */

-      1489, /* GL_PROXY_TEXTURE_1D */

-      1493, /* GL_PROXY_TEXTURE_2D */

-      2093, /* GL_TEXTURE_TOO_LARGE_EXT */

-      2079, /* GL_TEXTURE_PRIORITY */

-      2087, /* GL_TEXTURE_RESIDENT */

-      1961, /* GL_TEXTURE_BINDING_1D */

-      1964, /* GL_TEXTURE_BINDING_2D */

-      1967, /* GL_TEXTURE_BINDING_3D */

-      1297, /* GL_PACK_SKIP_IMAGES */

-      1293, /* GL_PACK_IMAGE_HEIGHT */

-      2149, /* GL_UNPACK_SKIP_IMAGES */

-      2146, /* GL_UNPACK_IMAGE_HEIGHT */

-      1956, /* GL_TEXTURE_3D */

-      1497, /* GL_PROXY_TEXTURE_3D */

-      2037, /* GL_TEXTURE_DEPTH */

-      2096, /* GL_TEXTURE_WRAP_R */

-      1010, /* GL_MAX_3D_TEXTURE_SIZE */

-      2212, /* GL_VERTEX_ARRAY */

-      1223, /* GL_NORMAL_ARRAY */

-       186, /* GL_COLOR_ARRAY */

-       731, /* GL_INDEX_ARRAY */

-      2007, /* GL_TEXTURE_COORD_ARRAY */

-       515, /* GL_EDGE_FLAG_ARRAY */

-      2218, /* GL_VERTEX_ARRAY_SIZE */

-      2220, /* GL_VERTEX_ARRAY_TYPE */

-      2219, /* GL_VERTEX_ARRAY_STRIDE */

-      1228, /* GL_NORMAL_ARRAY_TYPE */

-      1227, /* GL_NORMAL_ARRAY_STRIDE */

-       190, /* GL_COLOR_ARRAY_SIZE */

-       192, /* GL_COLOR_ARRAY_TYPE */

-       191, /* GL_COLOR_ARRAY_STRIDE */

-       736, /* GL_INDEX_ARRAY_TYPE */

-       735, /* GL_INDEX_ARRAY_STRIDE */

-      2011, /* GL_TEXTURE_COORD_ARRAY_SIZE */

-      2013, /* GL_TEXTURE_COORD_ARRAY_TYPE */

-      2012, /* GL_TEXTURE_COORD_ARRAY_STRIDE */

-       519, /* GL_EDGE_FLAG_ARRAY_STRIDE */

-      2217, /* GL_VERTEX_ARRAY_POINTER */

-      1226, /* GL_NORMAL_ARRAY_POINTER */

-       189, /* GL_COLOR_ARRAY_POINTER */

-       734, /* GL_INDEX_ARRAY_POINTER */

-      2010, /* GL_TEXTURE_COORD_ARRAY_POINTER */

-       518, /* GL_EDGE_FLAG_ARRAY_POINTER */

-      1201, /* GL_MULTISAMPLE */

-      1713, /* GL_SAMPLE_ALPHA_TO_COVERAGE */

-      1715, /* GL_SAMPLE_ALPHA_TO_ONE */

-      1720, /* GL_SAMPLE_COVERAGE */

-      1717, /* GL_SAMPLE_BUFFERS */

-      1708, /* GL_SAMPLES */

-      1724, /* GL_SAMPLE_COVERAGE_VALUE */

-      1722, /* GL_SAMPLE_COVERAGE_INVERT */

-       234, /* GL_COLOR_MATRIX */

-       236, /* GL_COLOR_MATRIX_STACK_DEPTH */

-      1022, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */

-      1408, /* GL_POST_COLOR_MATRIX_RED_SCALE */

-      1404, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */

-      1399, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */

-      1395, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */

-      1406, /* GL_POST_COLOR_MATRIX_RED_BIAS */

-      1402, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */

-      1397, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */

-      1393, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */

-      1990, /* GL_TEXTURE_COLOR_TABLE_SGI */

-      1498, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */

-      1992, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */

-        94, /* GL_BLEND_DST_RGB */

-       108, /* GL_BLEND_SRC_RGB */

-        92, /* GL_BLEND_DST_ALPHA */

-       106, /* GL_BLEND_SRC_ALPHA */

-       240, /* GL_COLOR_TABLE */

-      1418, /* GL_POST_CONVOLUTION_COLOR_TABLE */

-      1401, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */

-      1484, /* GL_PROXY_COLOR_TABLE */

-      1488, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */

-      1487, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */

-       264, /* GL_COLOR_TABLE_SCALE */

-       244, /* GL_COLOR_TABLE_BIAS */

-       249, /* GL_COLOR_TABLE_FORMAT */

-       266, /* GL_COLOR_TABLE_WIDTH */

-       261, /* GL_COLOR_TABLE_RED_SIZE */

-       252, /* GL_COLOR_TABLE_GREEN_SIZE */

-       246, /* GL_COLOR_TABLE_BLUE_SIZE */

-       241, /* GL_COLOR_TABLE_ALPHA_SIZE */

-       258, /* GL_COLOR_TABLE_LUMINANCE_SIZE */

-       255, /* GL_COLOR_TABLE_INTENSITY_SIZE */

-        79, /* GL_BGR */

-        80, /* GL_BGRA */

-      1037, /* GL_MAX_ELEMENTS_VERTICES */

-      1036, /* GL_MAX_ELEMENTS_INDICES */

-      2056, /* GL_TEXTURE_INDEX_SIZE_EXT */

-       183, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */

-      1364, /* GL_POINT_SIZE_MIN */

-      1360, /* GL_POINT_SIZE_MAX */

-      1349, /* GL_POINT_FADE_THRESHOLD_SIZE */

-      1345, /* GL_POINT_DISTANCE_ATTENUATION */

-       157, /* GL_CLAMP_TO_BORDER */

-       160, /* GL_CLAMP_TO_EDGE */

-      2078, /* GL_TEXTURE_MIN_LOD */

-      2076, /* GL_TEXTURE_MAX_LOD */

-      1960, /* GL_TEXTURE_BASE_LEVEL */

-      2075, /* GL_TEXTURE_MAX_LEVEL */

-       722, /* GL_IGNORE_BORDER_HP */

-       318, /* GL_CONSTANT_BORDER_HP */

-      1592, /* GL_REPLICATE_BORDER_HP */

-       329, /* GL_CONVOLUTION_BORDER_COLOR */

-      1256, /* GL_OCCLUSION_TEST_HP */

-      1257, /* GL_OCCLUSION_TEST_RESULT_HP */

-       823, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */

-      1984, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */

-      1986, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */

-      1988, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */

-      1989, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */

-      1987, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */

-      1985, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */

-      1016, /* GL_MAX_CLIPMAP_DEPTH_SGIX */

-      1017, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */

-      1428, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */

-      1430, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */

-      1427, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */

-      1429, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */

-      2064, /* GL_TEXTURE_LOD_BIAS_S_SGIX */

-      2065, /* GL_TEXTURE_LOD_BIAS_T_SGIX */

-      2063, /* GL_TEXTURE_LOD_BIAS_R_SGIX */

-       678, /* GL_GENERATE_MIPMAP */

-       679, /* GL_GENERATE_MIPMAP_HINT */

-       591, /* GL_FOG_OFFSET_SGIX */

-       592, /* GL_FOG_OFFSET_VALUE_SGIX */

-      1998, /* GL_TEXTURE_COMPARE_SGIX */

-      1997, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */

-      2060, /* GL_TEXTURE_LEQUAL_R_SGIX */

-      2052, /* GL_TEXTURE_GEQUAL_R_SGIX */

-       412, /* GL_DEPTH_COMPONENT16 */

-       416, /* GL_DEPTH_COMPONENT24 */

-       420, /* GL_DEPTH_COMPONENT32 */

-       354, /* GL_CULL_VERTEX_EXT */

-       356, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */

-       355, /* GL_CULL_VERTEX_EYE_POSITION_EXT */

-      2285, /* GL_WRAP_BORDER_SUN */

-      1991, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */

-       816, /* GL_LIGHT_MODEL_COLOR_CONTROL */

-      1758, /* GL_SINGLE_COLOR */

-      1742, /* GL_SEPARATE_SPECULAR_COLOR */

-      1753, /* GL_SHARED_TEXTURE_PALETTE_EXT */

-       603, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */

-       604, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */

-       615, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */

-       606, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */

-       602, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */

-       601, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */

-       605, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */

-       616, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */

-       633, /* GL_FRAMEBUFFER_DEFAULT */

-       660, /* GL_FRAMEBUFFER_UNDEFINED */

-       428, /* GL_DEPTH_STENCIL_ATTACHMENT */

-       892, /* GL_MAJOR_VERSION */

-      1147, /* GL_MINOR_VERSION */

-      1237, /* GL_NUM_EXTENSIONS */

-       324, /* GL_CONTEXT_FLAGS */

-       730, /* GL_INDEX */

-       406, /* GL_DEPTH_BUFFER */

-      1832, /* GL_STENCIL_BUFFER */

-       295, /* GL_COMPRESSED_RED */

-       296, /* GL_COMPRESSED_RG */

-      2155, /* GL_UNSIGNED_BYTE_2_3_3_REV */

-      2200, /* GL_UNSIGNED_SHORT_5_6_5 */

-      2201, /* GL_UNSIGNED_SHORT_5_6_5_REV */

-      2197, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */

-      2194, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */

-      2169, /* GL_UNSIGNED_INT_8_8_8_8_REV */

-      2165, /* GL_UNSIGNED_INT_2_10_10_10_REV */

-      2073, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */

-      2074, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */

-      2072, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */

-      1151, /* GL_MIRRORED_REPEAT */

-      1679, /* GL_RGB_S3TC */

-      1622, /* GL_RGB4_S3TC */

-      1675, /* GL_RGBA_S3TC */

-      1661, /* GL_RGBA4_S3TC */

-      1670, /* GL_RGBA_DXT5_S3TC */

-      1658, /* GL_RGBA4_DXT5_S3TC */

-       306, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */

-       301, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */

-       302, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */

-       303, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */

-      1213, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */

-      1212, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */

-       824, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */

-       578, /* GL_FOG_COORDINATE_SOURCE */

-       570, /* GL_FOG_COORD */

-       594, /* GL_FRAGMENT_DEPTH */

-       360, /* GL_CURRENT_FOG_COORD */

-       577, /* GL_FOG_COORDINATE_ARRAY_TYPE */

-       576, /* GL_FOG_COORDINATE_ARRAY_STRIDE */

-       575, /* GL_FOG_COORDINATE_ARRAY_POINTER */

-       572, /* GL_FOG_COORDINATE_ARRAY */

-       238, /* GL_COLOR_SUM */

-       381, /* GL_CURRENT_SECONDARY_COLOR */

-      1733, /* GL_SECONDARY_COLOR_ARRAY_SIZE */

-      1735, /* GL_SECONDARY_COLOR_ARRAY_TYPE */

-      1734, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */

-      1732, /* GL_SECONDARY_COLOR_ARRAY_POINTER */

-      1729, /* GL_SECONDARY_COLOR_ARRAY */

-       379, /* GL_CURRENT_RASTER_SECONDARY_COLOR */

-        29, /* GL_ALIASED_POINT_SIZE_RANGE */

-        28, /* GL_ALIASED_LINE_WIDTH_RANGE */

-      1886, /* GL_TEXTURE0 */

-      1888, /* GL_TEXTURE1 */

-      1910, /* GL_TEXTURE2 */

-      1932, /* GL_TEXTURE3 */

-      1938, /* GL_TEXTURE4 */

-      1940, /* GL_TEXTURE5 */

-      1942, /* GL_TEXTURE6 */

-      1944, /* GL_TEXTURE7 */

-      1946, /* GL_TEXTURE8 */

-      1948, /* GL_TEXTURE9 */

-      1889, /* GL_TEXTURE10 */

-      1891, /* GL_TEXTURE11 */

-      1893, /* GL_TEXTURE12 */

-      1895, /* GL_TEXTURE13 */

-      1897, /* GL_TEXTURE14 */

-      1899, /* GL_TEXTURE15 */

-      1901, /* GL_TEXTURE16 */

-      1903, /* GL_TEXTURE17 */

-      1905, /* GL_TEXTURE18 */

-      1907, /* GL_TEXTURE19 */

-      1911, /* GL_TEXTURE20 */

-      1913, /* GL_TEXTURE21 */

-      1915, /* GL_TEXTURE22 */

-      1917, /* GL_TEXTURE23 */

-      1919, /* GL_TEXTURE24 */

-      1921, /* GL_TEXTURE25 */

-      1923, /* GL_TEXTURE26 */

-      1925, /* GL_TEXTURE27 */

-      1927, /* GL_TEXTURE28 */

-      1929, /* GL_TEXTURE29 */

-      1933, /* GL_TEXTURE30 */

-      1935, /* GL_TEXTURE31 */

-        19, /* GL_ACTIVE_TEXTURE */

-       163, /* GL_CLIENT_ACTIVE_TEXTURE */

-      1112, /* GL_MAX_TEXTURE_UNITS */

-      2128, /* GL_TRANSPOSE_MODELVIEW_MATRIX */

-      2131, /* GL_TRANSPOSE_PROJECTION_MATRIX */

-      2133, /* GL_TRANSPOSE_TEXTURE_MATRIX */

-      2125, /* GL_TRANSPOSE_COLOR_MATRIX */

-      1868, /* GL_SUBTRACT */

-      1094, /* GL_MAX_RENDERBUFFER_SIZE */

-       287, /* GL_COMPRESSED_ALPHA */

-       291, /* GL_COMPRESSED_LUMINANCE */

-       292, /* GL_COMPRESSED_LUMINANCE_ALPHA */

-       289, /* GL_COMPRESSED_INTENSITY */

-       297, /* GL_COMPRESSED_RGB */

-       298, /* GL_COMPRESSED_RGBA */

-      2005, /* GL_TEXTURE_COMPRESSION_HINT */

-      2082, /* GL_TEXTURE_RECTANGLE */

-      1973, /* GL_TEXTURE_BINDING_RECTANGLE */

-      1501, /* GL_PROXY_TEXTURE_RECTANGLE */

-      1091, /* GL_MAX_RECTANGLE_TEXTURE_SIZE */

-       427, /* GL_DEPTH_STENCIL */

-      2161, /* GL_UNSIGNED_INT_24_8 */

-      1107, /* GL_MAX_TEXTURE_LOD_BIAS */

-      2071, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */

-      1109, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */

-      2043, /* GL_TEXTURE_FILTER_CONTROL */

-      2061, /* GL_TEXTURE_LOD_BIAS */

-       271, /* GL_COMBINE4 */

-      1100, /* GL_MAX_SHININESS_NV */

-      1101, /* GL_MAX_SPOT_EXPONENT_NV */

-       728, /* GL_INCR_WRAP */

-       392, /* GL_DECR_WRAP */

-      1171, /* GL_MODELVIEW1_ARB */

-      1229, /* GL_NORMAL_MAP */

-      1552, /* GL_REFLECTION_MAP */

-      2015, /* GL_TEXTURE_CUBE_MAP */

-      1970, /* GL_TEXTURE_BINDING_CUBE_MAP */

-      2027, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */

-      2017, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */

-      2030, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */

-      2020, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */

-      2033, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */

-      2023, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */

-      1499, /* GL_PROXY_TEXTURE_CUBE_MAP */

-      1030, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */

-      1207, /* GL_MULTISAMPLE_FILTER_HINT_NV */

-      1442, /* GL_PRIMITIVE_RESTART_NV */

-      1441, /* GL_PRIMITIVE_RESTART_INDEX_NV */

-       586, /* GL_FOG_DISTANCE_MODE_NV */

-       534, /* GL_EYE_RADIAL_NV */

-       533, /* GL_EYE_PLANE_ABSOLUTE_NV */

-       270, /* GL_COMBINE */

-       277, /* GL_COMBINE_RGB */

-       272, /* GL_COMBINE_ALPHA */

-      1680, /* GL_RGB_SCALE */

-        25, /* GL_ADD_SIGNED */

-       764, /* GL_INTERPOLATE */

-       313, /* GL_CONSTANT */

-      1434, /* GL_PRIMARY_COLOR */

-      1431, /* GL_PREVIOUS */

-      1773, /* GL_SOURCE0_RGB */

-      1779, /* GL_SOURCE1_RGB */

-      1785, /* GL_SOURCE2_RGB */

-      1789, /* GL_SOURCE3_RGB_NV */

-      1770, /* GL_SOURCE0_ALPHA */

-      1776, /* GL_SOURCE1_ALPHA */

-      1782, /* GL_SOURCE2_ALPHA */

-      1788, /* GL_SOURCE3_ALPHA_NV */

-      1270, /* GL_OPERAND0_RGB */

-      1276, /* GL_OPERAND1_RGB */

-      1282, /* GL_OPERAND2_RGB */

-      1286, /* GL_OPERAND3_RGB_NV */

-      1267, /* GL_OPERAND0_ALPHA */

-      1273, /* GL_OPERAND1_ALPHA */

-      1279, /* GL_OPERAND2_ALPHA */

-      1285, /* GL_OPERAND3_ALPHA_NV */

-       137, /* GL_BUFFER_OBJECT_APPLE */

-      2213, /* GL_VERTEX_ARRAY_BINDING */

-      2080, /* GL_TEXTURE_RANGE_LENGTH_APPLE */

-      2081, /* GL_TEXTURE_RANGE_POINTER_APPLE */

-      2290, /* GL_YCBCR_422_APPLE */

-      2202, /* GL_UNSIGNED_SHORT_8_8_APPLE */

-      2204, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */

-      2092, /* GL_TEXTURE_STORAGE_HINT_APPLE */

-      1859, /* GL_STORAGE_PRIVATE_APPLE */

-      1858, /* GL_STORAGE_CACHED_APPLE */

-      1860, /* GL_STORAGE_SHARED_APPLE */

-      1760, /* GL_SLICE_ACCUM_SUN */

-      1510, /* GL_QUAD_MESH_SUN */

-      2139, /* GL_TRIANGLE_MESH_SUN */

-      2255, /* GL_VERTEX_PROGRAM_ARB */

-      2266, /* GL_VERTEX_STATE_PROGRAM_NV */

-      2240, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */

-      2248, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */

-      2250, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */

-      2252, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */

-       383, /* GL_CURRENT_VERTEX_ATTRIB */

-      1455, /* GL_PROGRAM_LENGTH_ARB */

-      1471, /* GL_PROGRAM_STRING_ARB */

-      1194, /* GL_MODELVIEW_PROJECTION_NV */

-       721, /* GL_IDENTITY_NV */

-       796, /* GL_INVERSE_NV */

-      2130, /* GL_TRANSPOSE_NV */

-       797, /* GL_INVERSE_TRANSPOSE_NV */

-      1075, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */

-      1074, /* GL_MAX_PROGRAM_MATRICES_ARB */

-       956, /* GL_MATRIX0_NV */

-       968, /* GL_MATRIX1_NV */

-       980, /* GL_MATRIX2_NV */

-       984, /* GL_MATRIX3_NV */

-       986, /* GL_MATRIX4_NV */

-       988, /* GL_MATRIX5_NV */

-       990, /* GL_MATRIX6_NV */

-       992, /* GL_MATRIX7_NV */

-       366, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */

-       363, /* GL_CURRENT_MATRIX_ARB */

-      1468, /* GL_PROGRAM_POINT_SIZE */

-      2261, /* GL_VERTEX_PROGRAM_TWO_SIDE */

-      1467, /* GL_PROGRAM_PARAMETER_NV */

-      2246, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */

-      1473, /* GL_PROGRAM_TARGET_NV */

-      1470, /* GL_PROGRAM_RESIDENT_NV */

-      2102, /* GL_TRACK_MATRIX_NV */

-      2103, /* GL_TRACK_MATRIX_TRANSFORM_NV */

-      2256, /* GL_VERTEX_PROGRAM_BINDING_NV */

-      1449, /* GL_PROGRAM_ERROR_POSITION_ARB */

-       408, /* GL_DEPTH_CLAMP */

-      2221, /* GL_VERTEX_ATTRIB_ARRAY0_NV */

-      2228, /* GL_VERTEX_ATTRIB_ARRAY1_NV */

-      2229, /* GL_VERTEX_ATTRIB_ARRAY2_NV */

-      2230, /* GL_VERTEX_ATTRIB_ARRAY3_NV */

-      2231, /* GL_VERTEX_ATTRIB_ARRAY4_NV */

-      2232, /* GL_VERTEX_ATTRIB_ARRAY5_NV */

-      2233, /* GL_VERTEX_ATTRIB_ARRAY6_NV */

-      2234, /* GL_VERTEX_ATTRIB_ARRAY7_NV */

-      2235, /* GL_VERTEX_ATTRIB_ARRAY8_NV */

-      2236, /* GL_VERTEX_ATTRIB_ARRAY9_NV */

-      2222, /* GL_VERTEX_ATTRIB_ARRAY10_NV */

-      2223, /* GL_VERTEX_ATTRIB_ARRAY11_NV */

-      2224, /* GL_VERTEX_ATTRIB_ARRAY12_NV */

-      2225, /* GL_VERTEX_ATTRIB_ARRAY13_NV */

-      2226, /* GL_VERTEX_ATTRIB_ARRAY14_NV */

-      2227, /* GL_VERTEX_ATTRIB_ARRAY15_NV */

-       904, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */

-       911, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */

-       912, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */

-       913, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */

-       914, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */

-       915, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */

-       916, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */

-       917, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */

-       918, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */

-       919, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */

-       905, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */

-       906, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */

-       907, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */

-       908, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */

-       909, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */

-       910, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */

-       931, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */

-       938, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */

-       939, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */

-       940, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */

-       941, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */

-       942, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */

-       943, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */

-      1448, /* GL_PROGRAM_BINDING_ARB */

-       945, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */

-       946, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */

-       932, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */

-       933, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */

-       934, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */

-       935, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */

-       936, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */

-       937, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */

-      2003, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */

-      2000, /* GL_TEXTURE_COMPRESSED */

-      1235, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */

-       311, /* GL_COMPRESSED_TEXTURE_FORMATS */

-      1134, /* GL_MAX_VERTEX_UNITS_ARB */

-        23, /* GL_ACTIVE_VERTEX_UNITS_ARB */

-      2284, /* GL_WEIGHT_SUM_UNITY_ARB */

-      2254, /* GL_VERTEX_BLEND_ARB */

-       385, /* GL_CURRENT_WEIGHT_ARB */

-      2282, /* GL_WEIGHT_ARRAY_TYPE_ARB */

-      2280, /* GL_WEIGHT_ARRAY_STRIDE_ARB */

-      2278, /* GL_WEIGHT_ARRAY_SIZE_ARB */

-      2276, /* GL_WEIGHT_ARRAY_POINTER_ARB */

-      2271, /* GL_WEIGHT_ARRAY_ARB */

-       442, /* GL_DOT3_RGB */

-       443, /* GL_DOT3_RGBA */

-       305, /* GL_COMPRESSED_RGB_FXT1_3DFX */

-       300, /* GL_COMPRESSED_RGBA_FXT1_3DFX */

-      1202, /* GL_MULTISAMPLE_3DFX */

-      1718, /* GL_SAMPLE_BUFFERS_3DFX */

-      1709, /* GL_SAMPLES_3DFX */

-      1182, /* GL_MODELVIEW2_ARB */

-      1185, /* GL_MODELVIEW3_ARB */

-      1186, /* GL_MODELVIEW4_ARB */

-      1187, /* GL_MODELVIEW5_ARB */

-      1188, /* GL_MODELVIEW6_ARB */

-      1189, /* GL_MODELVIEW7_ARB */

-      1190, /* GL_MODELVIEW8_ARB */

-      1191, /* GL_MODELVIEW9_ARB */

-      1161, /* GL_MODELVIEW10_ARB */

-      1162, /* GL_MODELVIEW11_ARB */

-      1163, /* GL_MODELVIEW12_ARB */

-      1164, /* GL_MODELVIEW13_ARB */

-      1165, /* GL_MODELVIEW14_ARB */

-      1166, /* GL_MODELVIEW15_ARB */

-      1167, /* GL_MODELVIEW16_ARB */

-      1168, /* GL_MODELVIEW17_ARB */

-      1169, /* GL_MODELVIEW18_ARB */

-      1170, /* GL_MODELVIEW19_ARB */

-      1172, /* GL_MODELVIEW20_ARB */

-      1173, /* GL_MODELVIEW21_ARB */

-      1174, /* GL_MODELVIEW22_ARB */

-      1175, /* GL_MODELVIEW23_ARB */

-      1176, /* GL_MODELVIEW24_ARB */

-      1177, /* GL_MODELVIEW25_ARB */

-      1178, /* GL_MODELVIEW26_ARB */

-      1179, /* GL_MODELVIEW27_ARB */

-      1180, /* GL_MODELVIEW28_ARB */

-      1181, /* GL_MODELVIEW29_ARB */

-      1183, /* GL_MODELVIEW30_ARB */

-      1184, /* GL_MODELVIEW31_ARB */

-       447, /* GL_DOT3_RGB_EXT */

-       445, /* GL_DOT3_RGBA_EXT */

-      1155, /* GL_MIRROR_CLAMP_EXT */

-      1158, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */

-      1197, /* GL_MODULATE_ADD_ATI */

-      1198, /* GL_MODULATE_SIGNED_ADD_ATI */

-      1199, /* GL_MODULATE_SUBTRACT_ATI */

-      2291, /* GL_YCBCR_MESA */

-      1294, /* GL_PACK_INVERT_MESA */

-       388, /* GL_DEBUG_OBJECT_MESA */

-       389, /* GL_DEBUG_PRINT_MESA */

-       387, /* GL_DEBUG_ASSERT_MESA */

-       139, /* GL_BUFFER_SIZE */

-       141, /* GL_BUFFER_USAGE */

-       145, /* GL_BUMP_ROT_MATRIX_ATI */

-       146, /* GL_BUMP_ROT_MATRIX_SIZE_ATI */

-       144, /* GL_BUMP_NUM_TEX_UNITS_ATI */

-       148, /* GL_BUMP_TEX_UNITS_ATI */

-       507, /* GL_DUDV_ATI */

-       506, /* GL_DU8DV8_ATI */

-       143, /* GL_BUMP_ENVMAP_ATI */

-       147, /* GL_BUMP_TARGET_ATI */

-      1238, /* GL_NUM_PROGRAM_BINARY_FORMATS_OES */

-      1446, /* GL_PROGRAM_BINARY_FORMATS_OES */

-      1822, /* GL_STENCIL_BACK_FUNC */

-      1820, /* GL_STENCIL_BACK_FAIL */

-      1824, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */

-      1826, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */

-       595, /* GL_FRAGMENT_PROGRAM_ARB */

-      1444, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */

-      1476, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */

-      1475, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */

-      1458, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */

-      1464, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */

-      1463, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */

-      1064, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */

-      1089, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */

-      1088, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */

-      1077, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */

-      1083, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */

-      1082, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */

-      1652, /* GL_RGBA32F */

-      1615, /* GL_RGB32F */

-      1643, /* GL_RGBA16F */

-      1607, /* GL_RGB16F */

-      1033, /* GL_MAX_DRAW_BUFFERS */

-       451, /* GL_DRAW_BUFFER0 */

-       454, /* GL_DRAW_BUFFER1 */

-       475, /* GL_DRAW_BUFFER2 */

-       478, /* GL_DRAW_BUFFER3 */

-       481, /* GL_DRAW_BUFFER4 */

-       484, /* GL_DRAW_BUFFER5 */

-       487, /* GL_DRAW_BUFFER6 */

-       490, /* GL_DRAW_BUFFER7 */

-       493, /* GL_DRAW_BUFFER8 */

-       496, /* GL_DRAW_BUFFER9 */

-       455, /* GL_DRAW_BUFFER10 */

-       458, /* GL_DRAW_BUFFER11 */

-       461, /* GL_DRAW_BUFFER12 */

-       464, /* GL_DRAW_BUFFER13 */

-       467, /* GL_DRAW_BUFFER14 */

-       470, /* GL_DRAW_BUFFER15 */

-        97, /* GL_BLEND_EQUATION_ALPHA */

-      1007, /* GL_MATRIX_PALETTE_ARB */

-      1057, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */

-      1060, /* GL_MAX_PALETTE_MATRICES_ARB */

-       369, /* GL_CURRENT_PALETTE_MATRIX_ARB */

-       995, /* GL_MATRIX_INDEX_ARRAY_ARB */

-       364, /* GL_CURRENT_MATRIX_INDEX_ARB */

-      1000, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */

-      1004, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */

-      1002, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */

-       998, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */

-      2038, /* GL_TEXTURE_DEPTH_SIZE */

-       435, /* GL_DEPTH_TEXTURE_MODE */

-      1995, /* GL_TEXTURE_COMPARE_MODE */

-      1993, /* GL_TEXTURE_COMPARE_FUNC */

-       281, /* GL_COMPARE_REF_TO_TEXTURE */

-      1371, /* GL_POINT_SPRITE */

-       343, /* GL_COORD_REPLACE */

-      1376, /* GL_POINT_SPRITE_R_MODE_NV */

-      1516, /* GL_QUERY_COUNTER_BITS */

-       372, /* GL_CURRENT_QUERY */

-      1520, /* GL_QUERY_RESULT */

-      1522, /* GL_QUERY_RESULT_AVAILABLE */

-      1126, /* GL_MAX_VERTEX_ATTRIBS */

-      2244, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */

-       433, /* GL_DEPTH_STENCIL_TO_RGBA_NV */

-       432, /* GL_DEPTH_STENCIL_TO_BGRA_NV */

-      1103, /* GL_MAX_TEXTURE_COORDS */

-      1105, /* GL_MAX_TEXTURE_IMAGE_UNITS */

-      1451, /* GL_PROGRAM_ERROR_STRING_ARB */

-      1453, /* GL_PROGRAM_FORMAT_ASCII_ARB */

-      1452, /* GL_PROGRAM_FORMAT_ARB */

-      2094, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */

-       405, /* GL_DEPTH_BOUNDS_TEST_EXT */

-       404, /* GL_DEPTH_BOUNDS_EXT */

-        61, /* GL_ARRAY_BUFFER */

-       520, /* GL_ELEMENT_ARRAY_BUFFER */

-        62, /* GL_ARRAY_BUFFER_BINDING */

-       521, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */

-      2215, /* GL_VERTEX_ARRAY_BUFFER_BINDING */

-      1224, /* GL_NORMAL_ARRAY_BUFFER_BINDING */

-       187, /* GL_COLOR_ARRAY_BUFFER_BINDING */

-       732, /* GL_INDEX_ARRAY_BUFFER_BINDING */

-      2008, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */

-       516, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */

-      1730, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */

-       573, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */

-      2272, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */

-      2237, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */

-      1454, /* GL_PROGRAM_INSTRUCTIONS_ARB */

-      1070, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */

-      1460, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */

-      1079, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */

-      1474, /* GL_PROGRAM_TEMPORARIES_ARB */

-      1085, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */

-      1462, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */

-      1081, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */

-      1466, /* GL_PROGRAM_PARAMETERS_ARB */

-      1084, /* GL_MAX_PROGRAM_PARAMETERS_ARB */

-      1461, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */

-      1080, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */

-      1445, /* GL_PROGRAM_ATTRIBS_ARB */

-      1065, /* GL_MAX_PROGRAM_ATTRIBS_ARB */

-      1459, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */

-      1078, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */

-      1443, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */

-      1063, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */

-      1457, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */

-      1076, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */

-      1071, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */

-      1067, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */

-      1477, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */

-      2127, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */

-      1539, /* GL_READ_ONLY */

-      2286, /* GL_WRITE_ONLY */

-      1541, /* GL_READ_WRITE */

-       124, /* GL_BUFFER_ACCESS */

-       129, /* GL_BUFFER_MAPPED */

-       134, /* GL_BUFFER_MAP_POINTER */

-      2101, /* GL_TIME_ELAPSED_EXT */

-       955, /* GL_MATRIX0_ARB */

-       967, /* GL_MATRIX1_ARB */

-       979, /* GL_MATRIX2_ARB */

-       983, /* GL_MATRIX3_ARB */

-       985, /* GL_MATRIX4_ARB */

-       987, /* GL_MATRIX5_ARB */

-       989, /* GL_MATRIX6_ARB */

-       991, /* GL_MATRIX7_ARB */

-       993, /* GL_MATRIX8_ARB */

-       994, /* GL_MATRIX9_ARB */

-       957, /* GL_MATRIX10_ARB */

-       958, /* GL_MATRIX11_ARB */

-       959, /* GL_MATRIX12_ARB */

-       960, /* GL_MATRIX13_ARB */

-       961, /* GL_MATRIX14_ARB */

-       962, /* GL_MATRIX15_ARB */

-       963, /* GL_MATRIX16_ARB */

-       964, /* GL_MATRIX17_ARB */

-       965, /* GL_MATRIX18_ARB */

-       966, /* GL_MATRIX19_ARB */

-       969, /* GL_MATRIX20_ARB */

-       970, /* GL_MATRIX21_ARB */

-       971, /* GL_MATRIX22_ARB */

-       972, /* GL_MATRIX23_ARB */

-       973, /* GL_MATRIX24_ARB */

-       974, /* GL_MATRIX25_ARB */

-       975, /* GL_MATRIX26_ARB */

-       976, /* GL_MATRIX27_ARB */

-       977, /* GL_MATRIX28_ARB */

-       978, /* GL_MATRIX29_ARB */

-       981, /* GL_MATRIX30_ARB */

-       982, /* GL_MATRIX31_ARB */

-      1863, /* GL_STREAM_DRAW */

-      1865, /* GL_STREAM_READ */

-      1861, /* GL_STREAM_COPY */

-      1812, /* GL_STATIC_DRAW */

-      1814, /* GL_STATIC_READ */

-      1810, /* GL_STATIC_COPY */

-       510, /* GL_DYNAMIC_DRAW */

-       512, /* GL_DYNAMIC_READ */

-       508, /* GL_DYNAMIC_COPY */

-      1334, /* GL_PIXEL_PACK_BUFFER */

-      1338, /* GL_PIXEL_UNPACK_BUFFER */

-      1335, /* GL_PIXEL_PACK_BUFFER_BINDING */

-      1339, /* GL_PIXEL_UNPACK_BUFFER_BINDING */

-       396, /* GL_DEPTH24_STENCIL8 */

-      2090, /* GL_TEXTURE_STENCIL_SIZE */

-      2036, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */

-      1066, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */

-      1069, /* GL_MAX_PROGRAM_IF_DEPTH_NV */

-      1073, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */

-      1072, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */

-      2242, /* GL_VERTEX_ATTRIB_ARRAY_INTEGER */

-      2239, /* GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB */

-      1012, /* GL_MAX_ARRAY_TEXTURE_LAYERS */

-      1149, /* GL_MIN_PROGRAM_TEXEL_OFFSET */

-      1086, /* GL_MAX_PROGRAM_TEXEL_OFFSET */

-      1854, /* GL_STENCIL_TEST_TWO_SIDE_EXT */

-        18, /* GL_ACTIVE_STENCIL_FACE_EXT */

-      1156, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */

-      1711, /* GL_SAMPLES_PASSED */

-       688, /* GL_GEOMETRY_VERTICES_OUT */

-       682, /* GL_GEOMETRY_INPUT_TYPE */

-       684, /* GL_GEOMETRY_OUTPUT_TYPE */

-       156, /* GL_CLAMP_READ_COLOR */

-       546, /* GL_FIXED_ONLY */

-      1358, /* GL_POINT_SIZE_ARRAY_TYPE_OES */

-      1357, /* GL_POINT_SIZE_ARRAY_STRIDE_OES */

-      1356, /* GL_POINT_SIZE_ARRAY_POINTER_OES */

-      1193, /* GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES */

-      1480, /* GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES */

-      2070, /* GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES */

-       138, /* GL_BUFFER_SERIALIZED_MODIFY_APPLE */

-       128, /* GL_BUFFER_FLUSHING_UNMAP_APPLE */

-      1556, /* GL_RELEASED_APPLE */

-      2269, /* GL_VOLATILE_APPLE */

-      1595, /* GL_RETAINED_APPLE */

-      2144, /* GL_UNDEFINED_APPLE */

-      1504, /* GL_PURGEABLE_APPLE */

-       596, /* GL_FRAGMENT_SHADER */

-      2264, /* GL_VERTEX_SHADER */

-      1465, /* GL_PROGRAM_OBJECT_ARB */

-      1747, /* GL_SHADER_OBJECT_ARB */

-      1041, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */

-      1131, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */

-      1122, /* GL_MAX_VARYING_COMPONENTS */

-      1129, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */

-      1024, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */

-      1254, /* GL_OBJECT_TYPE_ARB */

-      1749, /* GL_SHADER_TYPE */

-       561, /* GL_FLOAT_VEC2 */

-       563, /* GL_FLOAT_VEC3 */

-       565, /* GL_FLOAT_VEC4 */

-       784, /* GL_INT_VEC2 */

-       786, /* GL_INT_VEC3 */

-       788, /* GL_INT_VEC4 */

-       116, /* GL_BOOL */

-       118, /* GL_BOOL_VEC2 */

-       120, /* GL_BOOL_VEC3 */

-       122, /* GL_BOOL_VEC4 */

-       549, /* GL_FLOAT_MAT2 */

-       553, /* GL_FLOAT_MAT3 */

-       557, /* GL_FLOAT_MAT4 */

-      1687, /* GL_SAMPLER_1D */

-      1693, /* GL_SAMPLER_2D */

-      1701, /* GL_SAMPLER_3D */

-      1705, /* GL_SAMPLER_CUBE */

-      1692, /* GL_SAMPLER_1D_SHADOW */

-      1700, /* GL_SAMPLER_2D_SHADOW */

-      1698, /* GL_SAMPLER_2D_RECT */

-      1699, /* GL_SAMPLER_2D_RECT_SHADOW */

-       551, /* GL_FLOAT_MAT2x3 */

-       552, /* GL_FLOAT_MAT2x4 */

-       555, /* GL_FLOAT_MAT3x2 */

-       556, /* GL_FLOAT_MAT3x4 */

-       559, /* GL_FLOAT_MAT4x2 */

-       560, /* GL_FLOAT_MAT4x3 */

-       394, /* GL_DELETE_STATUS */

-       286, /* GL_COMPILE_STATUS */

-       845, /* GL_LINK_STATUS */

-      2209, /* GL_VALIDATE_STATUS */

-       744, /* GL_INFO_LOG_LENGTH */

-        64, /* GL_ATTACHED_SHADERS */

-        21, /* GL_ACTIVE_UNIFORMS */

-        22, /* GL_ACTIVE_UNIFORM_MAX_LENGTH */

-      1748, /* GL_SHADER_SOURCE_LENGTH */

-        15, /* GL_ACTIVE_ATTRIBUTES */

-        16, /* GL_ACTIVE_ATTRIBUTE_MAX_LENGTH */

-       598, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */

-      1751, /* GL_SHADING_LANGUAGE_VERSION */

-       371, /* GL_CURRENT_PROGRAM */

-      1303, /* GL_PALETTE4_RGB8_OES */

-      1305, /* GL_PALETTE4_RGBA8_OES */

-      1301, /* GL_PALETTE4_R5_G6_B5_OES */

-      1304, /* GL_PALETTE4_RGBA4_OES */

-      1302, /* GL_PALETTE4_RGB5_A1_OES */

-      1308, /* GL_PALETTE8_RGB8_OES */

-      1310, /* GL_PALETTE8_RGBA8_OES */

-      1306, /* GL_PALETTE8_R5_G6_B5_OES */

-      1309, /* GL_PALETTE8_RGBA4_OES */

-      1307, /* GL_PALETTE8_RGB5_A1_OES */

-       725, /* GL_IMPLEMENTATION_COLOR_READ_TYPE */

-       723, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT */

-      1355, /* GL_POINT_SIZE_ARRAY_OES */

-      2014, /* GL_TEXTURE_CROP_RECT_OES */

-       996, /* GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES */

-      1354, /* GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES */

-      2192, /* GL_UNSIGNED_NORMALIZED */

-      1951, /* GL_TEXTURE_1D_ARRAY */

-      1490, /* GL_PROXY_TEXTURE_1D_ARRAY */

-      1954, /* GL_TEXTURE_2D_ARRAY */

-      1494, /* GL_PROXY_TEXTURE_2D_ARRAY */

-      1962, /* GL_TEXTURE_BINDING_1D_ARRAY */

-      1965, /* GL_TEXTURE_BINDING_2D_ARRAY */

-      1048, /* GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS */

-      1981, /* GL_TEXTURE_BUFFER */

-      1102, /* GL_MAX_TEXTURE_BUFFER_SIZE */

-      1969, /* GL_TEXTURE_BINDING_BUFFER */

-      1982, /* GL_TEXTURE_BUFFER_DATA_STORE_BINDING */

-      1983, /* GL_TEXTURE_BUFFER_FORMAT */

-      1527, /* GL_R11F_G11F_B10F */

-      2158, /* GL_UNSIGNED_INT_10F_11F_11F_REV */

-      1638, /* GL_RGB9_E5 */

-      2167, /* GL_UNSIGNED_INT_5_9_9_9_REV */

-      2088, /* GL_TEXTURE_SHARED_SIZE */

-      1804, /* GL_SRGB */

-      1805, /* GL_SRGB8 */

-      1807, /* GL_SRGB_ALPHA */

-      1806, /* GL_SRGB8_ALPHA8 */

-      1764, /* GL_SLUMINANCE_ALPHA */

-      1763, /* GL_SLUMINANCE8_ALPHA8 */

-      1761, /* GL_SLUMINANCE */

-      1762, /* GL_SLUMINANCE8 */

-       309, /* GL_COMPRESSED_SRGB */

-       310, /* GL_COMPRESSED_SRGB_ALPHA */

-       307, /* GL_COMPRESSED_SLUMINANCE */

-       308, /* GL_COMPRESSED_SLUMINANCE_ALPHA */

-      2123, /* GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH */

-      2112, /* GL_TRANSFORM_FEEDBACK_BUFFER_MODE */

-      1120, /* GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS */

-      2121, /* GL_TRANSFORM_FEEDBACK_VARYINGS */

-      2117, /* GL_TRANSFORM_FEEDBACK_BUFFER_START */

-      2115, /* GL_TRANSFORM_FEEDBACK_BUFFER_SIZE */

-      1437, /* GL_PRIMITIVES_GENERATED */

-      2119, /* GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN */

-      1531, /* GL_RASTERIZER_DISCARD */

-      1116, /* GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS */

-      1118, /* GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS */

-       762, /* GL_INTERLEAVED_ATTRIBS */

-      1740, /* GL_SEPARATE_ATTRIBS */

-      2107, /* GL_TRANSFORM_FEEDBACK_BUFFER */

-      2109, /* GL_TRANSFORM_FEEDBACK_BUFFER_BINDING */

-      1373, /* GL_POINT_SPRITE_COORD_ORIGIN */

-       853, /* GL_LOWER_LEFT */

-      2206, /* GL_UPPER_LEFT */

-      1828, /* GL_STENCIL_BACK_REF */

-      1829, /* GL_STENCIL_BACK_VALUE_MASK */

-      1830, /* GL_STENCIL_BACK_WRITEMASK */

-       500, /* GL_DRAW_FRAMEBUFFER_BINDING */

-      1561, /* GL_RENDERBUFFER_BINDING */

-      1535, /* GL_READ_FRAMEBUFFER */

-       499, /* GL_DRAW_FRAMEBUFFER */

-      1536, /* GL_READ_FRAMEBUFFER_BINDING */

-      1580, /* GL_RENDERBUFFER_SAMPLES */

-       612, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */

-       609, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */

-       624, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */

-       619, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */

-       622, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */

-       630, /* GL_FRAMEBUFFER_COMPLETE */

-       635, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */

-       650, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */

-       644, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */

-       639, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */

-       645, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */

-       641, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER */

-       655, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER */

-       661, /* GL_FRAMEBUFFER_UNSUPPORTED */

-       659, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */

-      1020, /* GL_MAX_COLOR_ATTACHMENTS */

-       193, /* GL_COLOR_ATTACHMENT0 */

-       196, /* GL_COLOR_ATTACHMENT1 */

-       210, /* GL_COLOR_ATTACHMENT2 */

-       212, /* GL_COLOR_ATTACHMENT3 */

-       214, /* GL_COLOR_ATTACHMENT4 */

-       216, /* GL_COLOR_ATTACHMENT5 */

-       218, /* GL_COLOR_ATTACHMENT6 */

-       220, /* GL_COLOR_ATTACHMENT7 */

-       222, /* GL_COLOR_ATTACHMENT8 */

-       224, /* GL_COLOR_ATTACHMENT9 */

-       197, /* GL_COLOR_ATTACHMENT10 */

-       199, /* GL_COLOR_ATTACHMENT11 */

-       201, /* GL_COLOR_ATTACHMENT12 */

-       203, /* GL_COLOR_ATTACHMENT13 */

-       205, /* GL_COLOR_ATTACHMENT14 */

-       207, /* GL_COLOR_ATTACHMENT15 */

-       399, /* GL_DEPTH_ATTACHMENT */

-      1817, /* GL_STENCIL_ATTACHMENT */

-       600, /* GL_FRAMEBUFFER */

-      1558, /* GL_RENDERBUFFER */

-      1584, /* GL_RENDERBUFFER_WIDTH */

-      1571, /* GL_RENDERBUFFER_HEIGHT */

-      1574, /* GL_RENDERBUFFER_INTERNAL_FORMAT */

-      1849, /* GL_STENCIL_INDEX_EXT */

-      1838, /* GL_STENCIL_INDEX1 */

-      1843, /* GL_STENCIL_INDEX4 */

-      1846, /* GL_STENCIL_INDEX8 */

-      1839, /* GL_STENCIL_INDEX16 */

-      1578, /* GL_RENDERBUFFER_RED_SIZE */

-      1569, /* GL_RENDERBUFFER_GREEN_SIZE */

-      1564, /* GL_RENDERBUFFER_BLUE_SIZE */

-      1559, /* GL_RENDERBUFFER_ALPHA_SIZE */

-      1566, /* GL_RENDERBUFFER_DEPTH_SIZE */

-      1582, /* GL_RENDERBUFFER_STENCIL_SIZE */

-       653, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */

-      1097, /* GL_MAX_SAMPLES */

-      2050, /* GL_TEXTURE_GEN_STR_OES */

-       699, /* GL_HALF_FLOAT_OES */

-      1625, /* GL_RGB565_OES */

-      1655, /* GL_RGBA32UI */

-      1618, /* GL_RGB32UI */

-        40, /* GL_ALPHA32UI_EXT */

-       754, /* GL_INTENSITY32UI_EXT */

-       870, /* GL_LUMINANCE32UI_EXT */

-       887, /* GL_LUMINANCE_ALPHA32UI_EXT */

-      1646, /* GL_RGBA16UI */

-      1610, /* GL_RGB16UI */

-        37, /* GL_ALPHA16UI_EXT */

-       751, /* GL_INTENSITY16UI_EXT */

-       865, /* GL_LUMINANCE16UI_EXT */

-       885, /* GL_LUMINANCE_ALPHA16UI_EXT */

-      1665, /* GL_RGBA8UI */

-      1633, /* GL_RGB8UI */

-        45, /* GL_ALPHA8UI_EXT */

-       759, /* GL_INTENSITY8UI_EXT */

-       879, /* GL_LUMINANCE8UI_EXT */

-       889, /* GL_LUMINANCE_ALPHA8UI_EXT */

-      1653, /* GL_RGBA32I */

-      1616, /* GL_RGB32I */

-        39, /* GL_ALPHA32I_EXT */

-       753, /* GL_INTENSITY32I_EXT */

-       869, /* GL_LUMINANCE32I_EXT */

-       886, /* GL_LUMINANCE_ALPHA32I_EXT */

-      1644, /* GL_RGBA16I */

-      1608, /* GL_RGB16I */

-        36, /* GL_ALPHA16I_EXT */

-       750, /* GL_INTENSITY16I_EXT */

-       864, /* GL_LUMINANCE16I_EXT */

-       884, /* GL_LUMINANCE_ALPHA16I_EXT */

-      1663, /* GL_RGBA8I */

-      1631, /* GL_RGB8I */

-        44, /* GL_ALPHA8I_EXT */

-       758, /* GL_INTENSITY8I_EXT */

-       878, /* GL_LUMINANCE8I_EXT */

-       888, /* GL_LUMINANCE_ALPHA8I_EXT */

-      1548, /* GL_RED_INTEGER */

-       695, /* GL_GREEN_INTEGER */

-       113, /* GL_BLUE_INTEGER */

-        49, /* GL_ALPHA_INTEGER_EXT */

-      1677, /* GL_RGB_INTEGER */

-      1671, /* GL_RGBA_INTEGER */

-        84, /* GL_BGR_INTEGER */

-        82, /* GL_BGRA_INTEGER */

-       891, /* GL_LUMINANCE_INTEGER_EXT */

-       890, /* GL_LUMINANCE_ALPHA_INTEGER_EXT */

-      1673, /* GL_RGBA_INTEGER_MODE_EXT */

-       607, /* GL_FRAMEBUFFER_ATTACHMENT_LAYERED */

-       648, /* GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS */

-       647, /* GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB */

-      1688, /* GL_SAMPLER_1D_ARRAY */

-      1694, /* GL_SAMPLER_2D_ARRAY */

-      1703, /* GL_SAMPLER_BUFFER */

-      1690, /* GL_SAMPLER_1D_ARRAY_SHADOW */

-      1696, /* GL_SAMPLER_2D_ARRAY_SHADOW */

-      1706, /* GL_SAMPLER_CUBE_SHADOW */

-      2186, /* GL_UNSIGNED_INT_VEC2 */

-      2188, /* GL_UNSIGNED_INT_VEC3 */

-      2190, /* GL_UNSIGNED_INT_VEC4 */

-       768, /* GL_INT_SAMPLER_1D */

-       772, /* GL_INT_SAMPLER_2D */

-       778, /* GL_INT_SAMPLER_3D */

-       782, /* GL_INT_SAMPLER_CUBE */

-       776, /* GL_INT_SAMPLER_2D_RECT */

-       769, /* GL_INT_SAMPLER_1D_ARRAY */

-       773, /* GL_INT_SAMPLER_2D_ARRAY */

-       780, /* GL_INT_SAMPLER_BUFFER */

-      2170, /* GL_UNSIGNED_INT_SAMPLER_1D */

-      2174, /* GL_UNSIGNED_INT_SAMPLER_2D */

-      2180, /* GL_UNSIGNED_INT_SAMPLER_3D */

-      2184, /* GL_UNSIGNED_INT_SAMPLER_CUBE */

-      2178, /* GL_UNSIGNED_INT_SAMPLER_2D_RECT */

-      2171, /* GL_UNSIGNED_INT_SAMPLER_1D_ARRAY */

-      2175, /* GL_UNSIGNED_INT_SAMPLER_2D_ARRAY */

-      2182, /* GL_UNSIGNED_INT_SAMPLER_BUFFER */

-       686, /* GL_GEOMETRY_SHADER */

-       689, /* GL_GEOMETRY_VERTICES_OUT_ARB */

-       683, /* GL_GEOMETRY_INPUT_TYPE_ARB */

-       685, /* GL_GEOMETRY_OUTPUT_TYPE_ARB */

-      1054, /* GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB */

-      1136, /* GL_MAX_VERTEX_VARYING_COMPONENTS_ARB */

-      1052, /* GL_MAX_GEOMETRY_UNIFORM_COMPONENTS */

-      1046, /* GL_MAX_GEOMETRY_OUTPUT_VERTICES */

-      1050, /* GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS */

-       854, /* GL_LOW_FLOAT */

-      1138, /* GL_MEDIUM_FLOAT */

-       700, /* GL_HIGH_FLOAT */

-       855, /* GL_LOW_INT */

-      1139, /* GL_MEDIUM_INT */

-       701, /* GL_HIGH_INT */

-      2160, /* GL_UNSIGNED_INT_10_10_10_2_OES */

-       767, /* GL_INT_10_10_10_2_OES */

-      1745, /* GL_SHADER_BINARY_FORMATS */

-      1239, /* GL_NUM_SHADER_BINARY_FORMATS */

-      1746, /* GL_SHADER_COMPILER */

-      1133, /* GL_MAX_VERTEX_UNIFORM_VECTORS */

-      1125, /* GL_MAX_VARYING_VECTORS */

-      1043, /* GL_MAX_FRAGMENT_UNIFORM_VECTORS */

-      1524, /* GL_QUERY_WAIT */

-      1518, /* GL_QUERY_NO_WAIT */

-      1514, /* GL_QUERY_BY_REGION_WAIT */

-      1512, /* GL_QUERY_BY_REGION_NO_WAIT */

-      2105, /* GL_TRANSFORM_FEEDBACK */

-      2114, /* GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED */

-      2108, /* GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE */

-      2106, /* GL_TRANSFORM_FEEDBACK_BINDING */

-      1508, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION */

-       542, /* GL_FIRST_VERTEX_CONVENTION */

-       800, /* GL_LAST_VERTEX_CONVENTION */

-      1482, /* GL_PROVOKING_VERTEX */

-       350, /* GL_COPY_READ_BUFFER */

-       351, /* GL_COPY_WRITE_BUFFER */

-      1551, /* GL_RED_SNORM */

-      1684, /* GL_RG_SNORM */

-      1683, /* GL_RGB_SNORM */

-      1676, /* GL_RGBA_SNORM */

-      1530, /* GL_R8_SNORM */

-      1598, /* GL_RG8_SNORM */

-      1637, /* GL_RGB8_SNORM */

-      1669, /* GL_RGBA8_SNORM */

-      1528, /* GL_R16_SNORM */

-      1597, /* GL_RG16_SNORM */

-      1613, /* GL_RGB16_SNORM */

-      1649, /* GL_RGBA16_SNORM */

-      1757, /* GL_SIGNED_NORMALIZED */

-      1439, /* GL_PRIMITIVE_RESTART */

-      1440, /* GL_PRIMITIVE_RESTART_INDEX */

-      1099, /* GL_MAX_SERVER_WAIT_TIMEOUT */

-      1253, /* GL_OBJECT_TYPE */

-      1870, /* GL_SYNC_CONDITION */

-      1875, /* GL_SYNC_STATUS */

-      1872, /* GL_SYNC_FLAGS */

-      1871, /* GL_SYNC_FENCE */

-      1874, /* GL_SYNC_GPU_COMMANDS_COMPLETE */

-      2153, /* GL_UNSIGNALED */

-      1756, /* GL_SIGNALED */

-        54, /* GL_ALREADY_SIGNALED */

-      2100, /* GL_TIMEOUT_EXPIRED */

-       312, /* GL_CONDITION_SATISFIED */

-      2270, /* GL_WAIT_FAILED */

-       126, /* GL_BUFFER_ACCESS_FLAGS */

-       132, /* GL_BUFFER_MAP_LENGTH */

-       133, /* GL_BUFFER_MAP_OFFSET */

-      1128, /* GL_MAX_VERTEX_OUTPUT_COMPONENTS */

-      1044, /* GL_MAX_GEOMETRY_INPUT_COMPONENTS */

-      1045, /* GL_MAX_GEOMETRY_OUTPUT_COMPONENTS */

-      1040, /* GL_MAX_FRAGMENT_INPUT_COMPONENTS */

-       326, /* GL_CONTEXT_PROFILE_MASK */

-       527, /* GL_EVAL_BIT */

-      1533, /* GL_RASTER_POSITION_UNCLIPPED_IBM */

-       847, /* GL_LIST_BIT */

-      1976, /* GL_TEXTURE_BIT */

-      1726, /* GL_SCISSOR_BIT */

-        30, /* GL_ALL_ATTRIB_BITS */

-      1204, /* GL_MULTISAMPLE_BIT */

-        31, /* GL_ALL_CLIENT_ATTRIB_BITS */

-};

-

-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 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 *) _mesa_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_snprintf(token_tmp, sizeof(token_tmp) - 1, "0x%x", nr);

-      token_tmp[sizeof(token_tmp) - 1] = '\0';

-      return token_tmp;

-   }

-}

-

-/**

- * Primitive names

- */

-static const char *prim_names[PRIM_UNKNOWN + 1] = {

-   "GL_POINTS",

-   "GL_LINES",

-   "GL_LINE_LOOP",

-   "GL_LINE_STRIP",

-   "GL_TRIANGLES",

-   "GL_TRIANGLE_STRIP",

-   "GL_TRIANGLE_FAN",

-   "GL_QUADS",

-   "GL_QUAD_STRIP",

-   "GL_POLYGON",

-   "outside begin/end",

-   "inside unknown primitive",

-   "unknown state"

-};

-

-

-/* Get the name of an enum given that it is a primitive type.  Avoids

- * GL_FALSE/GL_POINTS ambiguity and others.

- */

-const char *

-_mesa_lookup_prim_by_nr(GLuint nr)

-{

-   if (nr < Elements(prim_names))

-      return prim_names[nr];

-   else

-      return "invalid mode";

-}

-

-

-int _mesa_lookup_enum_by_name( const char *symbol )

-{

-   enum_elt * f = NULL;

-

-   if ( symbol != NULL ) {

-      f = (enum_elt *) _mesa_bsearch(symbol, all_enums,

-                                     Elements(all_enums),

-                                     sizeof( enum_elt ),

-                                     (cfunc) compar_name);

-   }

-

-   return (f != NULL) ? f->n : -1;

-}

-

-

+/* 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 "main/glheader.h"
+#include "main/mfeatures.h"
+#include "main/enums.h"
+#include "main/imports.h"
+#include "main/mtypes.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_PROGRAM_EXT\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_ALPHA16I_EXT\0"
+   "GL_ALPHA16UI_EXT\0"
+   "GL_ALPHA16_EXT\0"
+   "GL_ALPHA32I_EXT\0"
+   "GL_ALPHA32UI_EXT\0"
+   "GL_ALPHA4\0"
+   "GL_ALPHA4_EXT\0"
+   "GL_ALPHA8\0"
+   "GL_ALPHA8I_EXT\0"
+   "GL_ALPHA8UI_EXT\0"
+   "GL_ALPHA8_EXT\0"
+   "GL_ALPHA_BIAS\0"
+   "GL_ALPHA_BITS\0"
+   "GL_ALPHA_INTEGER_EXT\0"
+   "GL_ALPHA_SCALE\0"
+   "GL_ALPHA_TEST\0"
+   "GL_ALPHA_TEST_FUNC\0"
+   "GL_ALPHA_TEST_REF\0"
+   "GL_ALREADY_SIGNALED\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_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_BGRA_EXT\0"
+   "GL_BGRA_INTEGER\0"
+   "GL_BGRA_INTEGER_EXT\0"
+   "GL_BGR_INTEGER\0"
+   "GL_BGR_INTEGER_EXT\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_ALPHA_OES\0"
+   "GL_BLEND_DST_RGB\0"
+   "GL_BLEND_DST_RGB_OES\0"
+   "GL_BLEND_EQUATION\0"
+   "GL_BLEND_EQUATION_ALPHA\0"
+   "GL_BLEND_EQUATION_ALPHA_EXT\0"
+   "GL_BLEND_EQUATION_ALPHA_OES\0"
+   "GL_BLEND_EQUATION_EXT\0"
+   "GL_BLEND_EQUATION_OES\0"
+   "GL_BLEND_EQUATION_RGB\0"
+   "GL_BLEND_EQUATION_RGB_EXT\0"
+   "GL_BLEND_EQUATION_RGB_OES\0"
+   "GL_BLEND_SRC\0"
+   "GL_BLEND_SRC_ALPHA\0"
+   "GL_BLEND_SRC_ALPHA_OES\0"
+   "GL_BLEND_SRC_RGB\0"
+   "GL_BLEND_SRC_RGB_OES\0"
+   "GL_BLUE\0"
+   "GL_BLUE_BIAS\0"
+   "GL_BLUE_BITS\0"
+   "GL_BLUE_INTEGER\0"
+   "GL_BLUE_INTEGER_EXT\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_ACCESS_FLAGS\0"
+   "GL_BUFFER_ACCESS_OES\0"
+   "GL_BUFFER_FLUSHING_UNMAP_APPLE\0"
+   "GL_BUFFER_MAPPED\0"
+   "GL_BUFFER_MAPPED_ARB\0"
+   "GL_BUFFER_MAPPED_OES\0"
+   "GL_BUFFER_MAP_LENGTH\0"
+   "GL_BUFFER_MAP_OFFSET\0"
+   "GL_BUFFER_MAP_POINTER\0"
+   "GL_BUFFER_MAP_POINTER_ARB\0"
+   "GL_BUFFER_MAP_POINTER_OES\0"
+   "GL_BUFFER_OBJECT_APPLE\0"
+   "GL_BUFFER_SERIALIZED_MODIFY_APPLE\0"
+   "GL_BUFFER_SIZE\0"
+   "GL_BUFFER_SIZE_ARB\0"
+   "GL_BUFFER_USAGE\0"
+   "GL_BUFFER_USAGE_ARB\0"
+   "GL_BUMP_ENVMAP_ATI\0"
+   "GL_BUMP_NUM_TEX_UNITS_ATI\0"
+   "GL_BUMP_ROT_MATRIX_ATI\0"
+   "GL_BUMP_ROT_MATRIX_SIZE_ATI\0"
+   "GL_BUMP_TARGET_ATI\0"
+   "GL_BUMP_TEX_UNITS_ATI\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_FRAGMENT_COLOR_ARB\0"
+   "GL_CLAMP_READ_COLOR\0"
+   "GL_CLAMP_READ_COLOR_ARB\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_CLAMP_VERTEX_COLOR_ARB\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_DISTANCE0\0"
+   "GL_CLIP_DISTANCE1\0"
+   "GL_CLIP_DISTANCE2\0"
+   "GL_CLIP_DISTANCE3\0"
+   "GL_CLIP_DISTANCE4\0"
+   "GL_CLIP_DISTANCE5\0"
+   "GL_CLIP_DISTANCE6\0"
+   "GL_CLIP_DISTANCE7\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\0"
+   "GL_COLOR_ATTACHMENT0_EXT\0"
+   "GL_COLOR_ATTACHMENT0_OES\0"
+   "GL_COLOR_ATTACHMENT1\0"
+   "GL_COLOR_ATTACHMENT10\0"
+   "GL_COLOR_ATTACHMENT10_EXT\0"
+   "GL_COLOR_ATTACHMENT11\0"
+   "GL_COLOR_ATTACHMENT11_EXT\0"
+   "GL_COLOR_ATTACHMENT12\0"
+   "GL_COLOR_ATTACHMENT12_EXT\0"
+   "GL_COLOR_ATTACHMENT13\0"
+   "GL_COLOR_ATTACHMENT13_EXT\0"
+   "GL_COLOR_ATTACHMENT14\0"
+   "GL_COLOR_ATTACHMENT14_EXT\0"
+   "GL_COLOR_ATTACHMENT15\0"
+   "GL_COLOR_ATTACHMENT15_EXT\0"
+   "GL_COLOR_ATTACHMENT1_EXT\0"
+   "GL_COLOR_ATTACHMENT2\0"
+   "GL_COLOR_ATTACHMENT2_EXT\0"
+   "GL_COLOR_ATTACHMENT3\0"
+   "GL_COLOR_ATTACHMENT3_EXT\0"
+   "GL_COLOR_ATTACHMENT4\0"
+   "GL_COLOR_ATTACHMENT4_EXT\0"
+   "GL_COLOR_ATTACHMENT5\0"
+   "GL_COLOR_ATTACHMENT5_EXT\0"
+   "GL_COLOR_ATTACHMENT6\0"
+   "GL_COLOR_ATTACHMENT6_EXT\0"
+   "GL_COLOR_ATTACHMENT7\0"
+   "GL_COLOR_ATTACHMENT7_EXT\0"
+   "GL_COLOR_ATTACHMENT8\0"
+   "GL_COLOR_ATTACHMENT8_EXT\0"
+   "GL_COLOR_ATTACHMENT9\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_REF_TO_TEXTURE\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_RED\0"
+   "GL_COMPRESSED_RG\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_SLUMINANCE\0"
+   "GL_COMPRESSED_SLUMINANCE_ALPHA\0"
+   "GL_COMPRESSED_SRGB\0"
+   "GL_COMPRESSED_SRGB_ALPHA\0"
+   "GL_COMPRESSED_TEXTURE_FORMATS\0"
+   "GL_CONDITION_SATISFIED\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_CONTEXT_COMPATIBILITY_PROFILE_BIT\0"
+   "GL_CONTEXT_CORE_PROFILE_BIT\0"
+   "GL_CONTEXT_FLAGS\0"
+   "GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT\0"
+   "GL_CONTEXT_PROFILE_MASK\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_COORD_REPLACE_OES\0"
+   "GL_COPY\0"
+   "GL_COPY_INVERTED\0"
+   "GL_COPY_PIXEL_TOKEN\0"
+   "GL_COPY_READ_BUFFER\0"
+   "GL_COPY_WRITE_BUFFER\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_PALETTE_MATRIX_OES\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_SECONDARY_COLOR\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_DEPTH24_STENCIL8\0"
+   "GL_DEPTH24_STENCIL8_EXT\0"
+   "GL_DEPTH24_STENCIL8_OES\0"
+   "GL_DEPTH_ATTACHMENT\0"
+   "GL_DEPTH_ATTACHMENT_EXT\0"
+   "GL_DEPTH_ATTACHMENT_OES\0"
+   "GL_DEPTH_BIAS\0"
+   "GL_DEPTH_BITS\0"
+   "GL_DEPTH_BOUNDS_EXT\0"
+   "GL_DEPTH_BOUNDS_TEST_EXT\0"
+   "GL_DEPTH_BUFFER\0"
+   "GL_DEPTH_BUFFER_BIT\0"
+   "GL_DEPTH_CLAMP\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_OES\0"
+   "GL_DEPTH_COMPONENT16_SGIX\0"
+   "GL_DEPTH_COMPONENT24\0"
+   "GL_DEPTH_COMPONENT24_ARB\0"
+   "GL_DEPTH_COMPONENT24_OES\0"
+   "GL_DEPTH_COMPONENT24_SGIX\0"
+   "GL_DEPTH_COMPONENT32\0"
+   "GL_DEPTH_COMPONENT32_ARB\0"
+   "GL_DEPTH_COMPONENT32_OES\0"
+   "GL_DEPTH_COMPONENT32_SGIX\0"
+   "GL_DEPTH_FUNC\0"
+   "GL_DEPTH_RANGE\0"
+   "GL_DEPTH_SCALE\0"
+   "GL_DEPTH_STENCIL\0"
+   "GL_DEPTH_STENCIL_ATTACHMENT\0"
+   "GL_DEPTH_STENCIL_EXT\0"
+   "GL_DEPTH_STENCIL_NV\0"
+   "GL_DEPTH_STENCIL_OES\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\0"
+   "GL_DRAW_FRAMEBUFFER_BINDING\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_DU8DV8_ATI\0"
+   "GL_DUDV_ATI\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_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_FIRST_VERTEX_CONVENTION\0"
+   "GL_FIRST_VERTEX_CONVENTION_EXT\0"
+   "GL_FIXED\0"
+   "GL_FIXED_OES\0"
+   "GL_FIXED_ONLY\0"
+   "GL_FIXED_ONLY_ARB\0"
+   "GL_FLAT\0"
+   "GL_FLOAT\0"
+   "GL_FLOAT_MAT2\0"
+   "GL_FLOAT_MAT2_ARB\0"
+   "GL_FLOAT_MAT2x3\0"
+   "GL_FLOAT_MAT2x4\0"
+   "GL_FLOAT_MAT3\0"
+   "GL_FLOAT_MAT3_ARB\0"
+   "GL_FLOAT_MAT3x2\0"
+   "GL_FLOAT_MAT3x4\0"
+   "GL_FLOAT_MAT4\0"
+   "GL_FLOAT_MAT4_ARB\0"
+   "GL_FLOAT_MAT4x2\0"
+   "GL_FLOAT_MAT4x3\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_FRAGMENT_SHADER_DERIVATIVE_HINT_OES\0"
+   "GL_FRAMEBUFFER\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_LAYERED\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT\0"
+   "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES\0"
+   "GL_FRAMEBUFFER_BINDING\0"
+   "GL_FRAMEBUFFER_BINDING_EXT\0"
+   "GL_FRAMEBUFFER_BINDING_OES\0"
+   "GL_FRAMEBUFFER_COMPLETE\0"
+   "GL_FRAMEBUFFER_COMPLETE_EXT\0"
+   "GL_FRAMEBUFFER_COMPLETE_OES\0"
+   "GL_FRAMEBUFFER_DEFAULT\0"
+   "GL_FRAMEBUFFER_EXT\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_OES\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT\0"
+   "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_OES\0"
+   "GL_FRAMEBUFFER_OES\0"
+   "GL_FRAMEBUFFER_STATUS_ERROR_EXT\0"
+   "GL_FRAMEBUFFER_UNDEFINED\0"
+   "GL_FRAMEBUFFER_UNSUPPORTED\0"
+   "GL_FRAMEBUFFER_UNSUPPORTED_EXT\0"
+   "GL_FRAMEBUFFER_UNSUPPORTED_OES\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_ADD_OES\0"
+   "GL_FUNC_REVERSE_SUBTRACT\0"
+   "GL_FUNC_REVERSE_SUBTRACT_EXT\0"
+   "GL_FUNC_REVERSE_SUBTRACT_OES\0"
+   "GL_FUNC_SUBTRACT\0"
+   "GL_FUNC_SUBTRACT_EXT\0"
+   "GL_FUNC_SUBTRACT_OES\0"
+   "GL_GENERATE_MIPMAP\0"
+   "GL_GENERATE_MIPMAP_HINT\0"
+   "GL_GENERATE_MIPMAP_HINT_SGIS\0"
+   "GL_GENERATE_MIPMAP_SGIS\0"
+   "GL_GEOMETRY_INPUT_TYPE\0"
+   "GL_GEOMETRY_INPUT_TYPE_ARB\0"
+   "GL_GEOMETRY_OUTPUT_TYPE\0"
+   "GL_GEOMETRY_OUTPUT_TYPE_ARB\0"
+   "GL_GEOMETRY_SHADER\0"
+   "GL_GEOMETRY_SHADER_ARB\0"
+   "GL_GEOMETRY_VERTICES_OUT\0"
+   "GL_GEOMETRY_VERTICES_OUT_ARB\0"
+   "GL_GEQUAL\0"
+   "GL_GREATER\0"
+   "GL_GREEN\0"
+   "GL_GREEN_BIAS\0"
+   "GL_GREEN_BITS\0"
+   "GL_GREEN_INTEGER\0"
+   "GL_GREEN_INTEGER_EXT\0"
+   "GL_GREEN_SCALE\0"
+   "GL_HALF_FLOAT\0"
+   "GL_HALF_FLOAT_OES\0"
+   "GL_HIGH_FLOAT\0"
+   "GL_HIGH_INT\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\0"
+   "GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES\0"
+   "GL_IMPLEMENTATION_COLOR_READ_TYPE\0"
+   "GL_IMPLEMENTATION_COLOR_READ_TYPE_OES\0"
+   "GL_INCR\0"
+   "GL_INCR_WRAP\0"
+   "GL_INCR_WRAP_EXT\0"
+   "GL_INDEX\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_INTENSITY16I_EXT\0"
+   "GL_INTENSITY16UI_EXT\0"
+   "GL_INTENSITY16_EXT\0"
+   "GL_INTENSITY32I_EXT\0"
+   "GL_INTENSITY32UI_EXT\0"
+   "GL_INTENSITY4\0"
+   "GL_INTENSITY4_EXT\0"
+   "GL_INTENSITY8\0"
+   "GL_INTENSITY8I_EXT\0"
+   "GL_INTENSITY8UI_EXT\0"
+   "GL_INTENSITY8_EXT\0"
+   "GL_INTENSITY_EXT\0"
+   "GL_INTERLEAVED_ATTRIBS\0"
+   "GL_INTERLEAVED_ATTRIBS_EXT\0"
+   "GL_INTERPOLATE\0"
+   "GL_INTERPOLATE_ARB\0"
+   "GL_INTERPOLATE_EXT\0"
+   "GL_INT_10_10_10_2_OES\0"
+   "GL_INT_SAMPLER_1D\0"
+   "GL_INT_SAMPLER_1D_ARRAY\0"
+   "GL_INT_SAMPLER_1D_ARRAY_EXT\0"
+   "GL_INT_SAMPLER_1D_EXT\0"
+   "GL_INT_SAMPLER_2D\0"
+   "GL_INT_SAMPLER_2D_ARRAY\0"
+   "GL_INT_SAMPLER_2D_ARRAY_EXT\0"
+   "GL_INT_SAMPLER_2D_EXT\0"
+   "GL_INT_SAMPLER_2D_RECT\0"
+   "GL_INT_SAMPLER_2D_RECT_EXT\0"
+   "GL_INT_SAMPLER_3D\0"
+   "GL_INT_SAMPLER_3D_EXT\0"
+   "GL_INT_SAMPLER_BUFFER\0"
+   "GL_INT_SAMPLER_BUFFER_EXT\0"
+   "GL_INT_SAMPLER_CUBE\0"
+   "GL_INT_SAMPLER_CUBE_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\0"
+   "GL_INVALID_FRAMEBUFFER_OPERATION_EXT\0"
+   "GL_INVALID_FRAMEBUFFER_OPERATION_OES\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_LAST_VERTEX_CONVENTION\0"
+   "GL_LAST_VERTEX_CONVENTION_EXT\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_LINES_ADJACENCY\0"
+   "GL_LINES_ADJACENCY_ARB\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_STRIP_ADJACENCY\0"
+   "GL_LINE_STRIP_ADJACENCY_ARB\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_LOW_FLOAT\0"
+   "GL_LOW_INT\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_LUMINANCE16I_EXT\0"
+   "GL_LUMINANCE16UI_EXT\0"
+   "GL_LUMINANCE16_ALPHA16\0"
+   "GL_LUMINANCE16_ALPHA16_EXT\0"
+   "GL_LUMINANCE16_EXT\0"
+   "GL_LUMINANCE32I_EXT\0"
+   "GL_LUMINANCE32UI_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_LUMINANCE8I_EXT\0"
+   "GL_LUMINANCE8UI_EXT\0"
+   "GL_LUMINANCE8_ALPHA8\0"
+   "GL_LUMINANCE8_ALPHA8_EXT\0"
+   "GL_LUMINANCE8_EXT\0"
+   "GL_LUMINANCE_ALPHA\0"
+   "GL_LUMINANCE_ALPHA16I_EXT\0"
+   "GL_LUMINANCE_ALPHA16UI_EXT\0"
+   "GL_LUMINANCE_ALPHA32I_EXT\0"
+   "GL_LUMINANCE_ALPHA32UI_EXT\0"
+   "GL_LUMINANCE_ALPHA8I_EXT\0"
+   "GL_LUMINANCE_ALPHA8UI_EXT\0"
+   "GL_LUMINANCE_ALPHA_INTEGER_EXT\0"
+   "GL_LUMINANCE_INTEGER_EXT\0"
+   "GL_MAJOR_VERSION\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_FLUSH_EXPLICIT_BIT\0"
+   "GL_MAP_INVALIDATE_BUFFER_BIT\0"
+   "GL_MAP_INVALIDATE_RANGE_BIT\0"
+   "GL_MAP_READ_BIT\0"
+   "GL_MAP_STENCIL\0"
+   "GL_MAP_UNSYNCHRONIZED_BIT\0"
+   "GL_MAP_WRITE_BIT\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_BUFFER_BINDING_OES\0"
+   "GL_MATRIX_INDEX_ARRAY_OES\0"
+   "GL_MATRIX_INDEX_ARRAY_POINTER_ARB\0"
+   "GL_MATRIX_INDEX_ARRAY_POINTER_OES\0"
+   "GL_MATRIX_INDEX_ARRAY_SIZE_ARB\0"
+   "GL_MATRIX_INDEX_ARRAY_SIZE_OES\0"
+   "GL_MATRIX_INDEX_ARRAY_STRIDE_ARB\0"
+   "GL_MATRIX_INDEX_ARRAY_STRIDE_OES\0"
+   "GL_MATRIX_INDEX_ARRAY_TYPE_ARB\0"
+   "GL_MATRIX_INDEX_ARRAY_TYPE_OES\0"
+   "GL_MATRIX_MODE\0"
+   "GL_MATRIX_PALETTE_ARB\0"
+   "GL_MATRIX_PALETTE_OES\0"
+   "GL_MAX\0"
+   "GL_MAX_3D_TEXTURE_SIZE\0"
+   "GL_MAX_3D_TEXTURE_SIZE_OES\0"
+   "GL_MAX_ARRAY_TEXTURE_LAYERS\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_DISTANCES\0"
+   "GL_MAX_CLIP_PLANES\0"
+   "GL_MAX_COLOR_ATTACHMENTS\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_CUBE_MAP_TEXTURE_SIZE_OES\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_INPUT_COMPONENTS\0"
+   "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS\0"
+   "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB\0"
+   "GL_MAX_FRAGMENT_UNIFORM_VECTORS\0"
+   "GL_MAX_GEOMETRY_INPUT_COMPONENTS\0"
+   "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS\0"
+   "GL_MAX_GEOMETRY_OUTPUT_VERTICES\0"
+   "GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB\0"
+   "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS\0"
+   "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB\0"
+   "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS\0"
+   "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB\0"
+   "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS\0"
+   "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB\0"
+   "GL_MAX_GEOMETRY_VARYING_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_PALETTE_MATRICES_OES\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_TEXEL_OFFSET\0"
+   "GL_MAX_PROGRAM_TEXEL_OFFSET_EXT\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\0"
+   "GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB\0"
+   "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV\0"
+   "GL_MAX_RENDERBUFFER_SIZE\0"
+   "GL_MAX_RENDERBUFFER_SIZE_EXT\0"
+   "GL_MAX_RENDERBUFFER_SIZE_OES\0"
+   "GL_MAX_SAMPLES\0"
+   "GL_MAX_SAMPLES_EXT\0"
+   "GL_MAX_SERVER_WAIT_TIMEOUT\0"
+   "GL_MAX_SHININESS_NV\0"
+   "GL_MAX_SPOT_EXPONENT_NV\0"
+   "GL_MAX_TEXTURE_BUFFER_SIZE\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_LOD_BIAS_EXT\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_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS\0"
+   "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT\0"
+   "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS\0"
+   "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT\0"
+   "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS\0"
+   "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT\0"
+   "GL_MAX_VARYING_COMPONENTS\0"
+   "GL_MAX_VARYING_FLOATS\0"
+   "GL_MAX_VARYING_FLOATS_ARB\0"
+   "GL_MAX_VARYING_VECTORS\0"
+   "GL_MAX_VERTEX_ATTRIBS\0"
+   "GL_MAX_VERTEX_ATTRIBS_ARB\0"
+   "GL_MAX_VERTEX_OUTPUT_COMPONENTS\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_UNIFORM_VECTORS\0"
+   "GL_MAX_VERTEX_UNITS_ARB\0"
+   "GL_MAX_VERTEX_UNITS_OES\0"
+   "GL_MAX_VERTEX_VARYING_COMPONENTS_ARB\0"
+   "GL_MAX_VIEWPORT_DIMS\0"
+   "GL_MEDIUM_FLOAT\0"
+   "GL_MEDIUM_INT\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_MINOR_VERSION\0"
+   "GL_MIN_EXT\0"
+   "GL_MIN_PROGRAM_TEXEL_OFFSET\0"
+   "GL_MIN_PROGRAM_TEXEL_OFFSET_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_MATRIX_FLOAT_AS_INT_BITS_OES\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_NONE_OES\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_NORMAL_MAP_OES\0"
+   "GL_NOTEQUAL\0"
+   "GL_NO_ERROR\0"
+   "GL_NUM_COMPRESSED_TEXTURE_FORMATS\0"
+   "GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB\0"
+   "GL_NUM_EXTENSIONS\0"
+   "GL_NUM_PROGRAM_BINARY_FORMATS_OES\0"
+   "GL_NUM_SHADER_BINARY_FORMATS\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\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\0"
+   "GL_PIXEL_PACK_BUFFER_BINDING\0"
+   "GL_PIXEL_PACK_BUFFER_BINDING_EXT\0"
+   "GL_PIXEL_PACK_BUFFER_EXT\0"
+   "GL_PIXEL_UNPACK_BUFFER\0"
+   "GL_PIXEL_UNPACK_BUFFER_BINDING\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_ARRAY_BUFFER_BINDING_OES\0"
+   "GL_POINT_SIZE_ARRAY_OES\0"
+   "GL_POINT_SIZE_ARRAY_POINTER_OES\0"
+   "GL_POINT_SIZE_ARRAY_STRIDE_OES\0"
+   "GL_POINT_SIZE_ARRAY_TYPE_OES\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_OES\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_PRIMITIVES_GENERATED\0"
+   "GL_PRIMITIVES_GENERATED_EXT\0"
+   "GL_PRIMITIVE_RESTART\0"
+   "GL_PRIMITIVE_RESTART_INDEX\0"
+   "GL_PRIMITIVE_RESTART_INDEX_NV\0"
+   "GL_PRIMITIVE_RESTART_NV\0"
+   "GL_PROGRAM_ADDRESS_REGISTERS_ARB\0"
+   "GL_PROGRAM_ALU_INSTRUCTIONS_ARB\0"
+   "GL_PROGRAM_ATTRIBS_ARB\0"
+   "GL_PROGRAM_BINARY_FORMATS_OES\0"
+   "GL_PROGRAM_BINARY_LENGTH_OES\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_POINT_SIZE\0"
+   "GL_PROGRAM_POINT_SIZE_ARB\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_MATRIX_FLOAT_AS_INT_BITS_OES\0"
+   "GL_PROJECTION_STACK_DEPTH\0"
+   "GL_PROVOKING_VERTEX\0"
+   "GL_PROVOKING_VERTEX_EXT\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\0"
+   "GL_PROXY_TEXTURE_1D_ARRAY_EXT\0"
+   "GL_PROXY_TEXTURE_1D_EXT\0"
+   "GL_PROXY_TEXTURE_2D\0"
+   "GL_PROXY_TEXTURE_2D_ARRAY\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\0"
+   "GL_PROXY_TEXTURE_RECTANGLE_ARB\0"
+   "GL_PROXY_TEXTURE_RECTANGLE_NV\0"
+   "GL_PURGEABLE_APPLE\0"
+   "GL_Q\0"
+   "GL_QUADRATIC_ATTENUATION\0"
+   "GL_QUADS\0"
+   "GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION\0"
+   "GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT\0"
+   "GL_QUAD_MESH_SUN\0"
+   "GL_QUAD_STRIP\0"
+   "GL_QUERY_BY_REGION_NO_WAIT\0"
+   "GL_QUERY_BY_REGION_NO_WAIT_NV\0"
+   "GL_QUERY_BY_REGION_WAIT\0"
+   "GL_QUERY_BY_REGION_WAIT_NV\0"
+   "GL_QUERY_COUNTER_BITS\0"
+   "GL_QUERY_COUNTER_BITS_ARB\0"
+   "GL_QUERY_NO_WAIT\0"
+   "GL_QUERY_NO_WAIT_NV\0"
+   "GL_QUERY_RESULT\0"
+   "GL_QUERY_RESULT_ARB\0"
+   "GL_QUERY_RESULT_AVAILABLE\0"
+   "GL_QUERY_RESULT_AVAILABLE_ARB\0"
+   "GL_QUERY_WAIT\0"
+   "GL_QUERY_WAIT_NV\0"
+   "GL_R\0"
+   "GL_R11F_G11F_B10F\0"
+   "GL_R16_SNORM\0"
+   "GL_R3_G3_B2\0"
+   "GL_R8_SNORM\0"
+   "GL_RASTERIZER_DISCARD\0"
+   "GL_RASTERIZER_DISCARD_EXT\0"
+   "GL_RASTER_POSITION_UNCLIPPED_IBM\0"
+   "GL_READ_BUFFER\0"
+   "GL_READ_FRAMEBUFFER\0"
+   "GL_READ_FRAMEBUFFER_BINDING\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_INTEGER\0"
+   "GL_RED_INTEGER_EXT\0"
+   "GL_RED_SCALE\0"
+   "GL_RED_SNORM\0"
+   "GL_REFLECTION_MAP\0"
+   "GL_REFLECTION_MAP_ARB\0"
+   "GL_REFLECTION_MAP_NV\0"
+   "GL_REFLECTION_MAP_OES\0"
+   "GL_RELEASED_APPLE\0"
+   "GL_RENDER\0"
+   "GL_RENDERBUFFER\0"
+   "GL_RENDERBUFFER_ALPHA_SIZE\0"
+   "GL_RENDERBUFFER_ALPHA_SIZE_OES\0"
+   "GL_RENDERBUFFER_BINDING\0"
+   "GL_RENDERBUFFER_BINDING_EXT\0"
+   "GL_RENDERBUFFER_BINDING_OES\0"
+   "GL_RENDERBUFFER_BLUE_SIZE\0"
+   "GL_RENDERBUFFER_BLUE_SIZE_OES\0"
+   "GL_RENDERBUFFER_DEPTH_SIZE\0"
+   "GL_RENDERBUFFER_DEPTH_SIZE_OES\0"
+   "GL_RENDERBUFFER_EXT\0"
+   "GL_RENDERBUFFER_GREEN_SIZE\0"
+   "GL_RENDERBUFFER_GREEN_SIZE_OES\0"
+   "GL_RENDERBUFFER_HEIGHT\0"
+   "GL_RENDERBUFFER_HEIGHT_EXT\0"
+   "GL_RENDERBUFFER_HEIGHT_OES\0"
+   "GL_RENDERBUFFER_INTERNAL_FORMAT\0"
+   "GL_RENDERBUFFER_INTERNAL_FORMAT_EXT\0"
+   "GL_RENDERBUFFER_INTERNAL_FORMAT_OES\0"
+   "GL_RENDERBUFFER_OES\0"
+   "GL_RENDERBUFFER_RED_SIZE\0"
+   "GL_RENDERBUFFER_RED_SIZE_OES\0"
+   "GL_RENDERBUFFER_SAMPLES\0"
+   "GL_RENDERBUFFER_SAMPLES_EXT\0"
+   "GL_RENDERBUFFER_STENCIL_SIZE\0"
+   "GL_RENDERBUFFER_STENCIL_SIZE_OES\0"
+   "GL_RENDERBUFFER_WIDTH\0"
+   "GL_RENDERBUFFER_WIDTH_EXT\0"
+   "GL_RENDERBUFFER_WIDTH_OES\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_RETAINED_APPLE\0"
+   "GL_RETURN\0"
+   "GL_RG16_SNORM\0"
+   "GL_RG8_SNORM\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_RGB16F\0"
+   "GL_RGB16I\0"
+   "GL_RGB16I_EXT\0"
+   "GL_RGB16UI\0"
+   "GL_RGB16UI_EXT\0"
+   "GL_RGB16_EXT\0"
+   "GL_RGB16_SNORM\0"
+   "GL_RGB2_EXT\0"
+   "GL_RGB32F\0"
+   "GL_RGB32I\0"
+   "GL_RGB32I_EXT\0"
+   "GL_RGB32UI\0"
+   "GL_RGB32UI_EXT\0"
+   "GL_RGB4\0"
+   "GL_RGB4_EXT\0"
+   "GL_RGB4_S3TC\0"
+   "GL_RGB5\0"
+   "GL_RGB565\0"
+   "GL_RGB565_OES\0"
+   "GL_RGB5_A1\0"
+   "GL_RGB5_A1_EXT\0"
+   "GL_RGB5_A1_OES\0"
+   "GL_RGB5_EXT\0"
+   "GL_RGB8\0"
+   "GL_RGB8I\0"
+   "GL_RGB8I_EXT\0"
+   "GL_RGB8UI\0"
+   "GL_RGB8UI_EXT\0"
+   "GL_RGB8_EXT\0"
+   "GL_RGB8_OES\0"
+   "GL_RGB8_SNORM\0"
+   "GL_RGB9_E5\0"
+   "GL_RGBA\0"
+   "GL_RGBA12\0"
+   "GL_RGBA12_EXT\0"
+   "GL_RGBA16\0"
+   "GL_RGBA16F\0"
+   "GL_RGBA16I\0"
+   "GL_RGBA16I_EXT\0"
+   "GL_RGBA16UI\0"
+   "GL_RGBA16UI_EXT\0"
+   "GL_RGBA16_EXT\0"
+   "GL_RGBA16_SNORM\0"
+   "GL_RGBA2\0"
+   "GL_RGBA2_EXT\0"
+   "GL_RGBA32F\0"
+   "GL_RGBA32I\0"
+   "GL_RGBA32I_EXT\0"
+   "GL_RGBA32UI\0"
+   "GL_RGBA32UI_EXT\0"
+   "GL_RGBA4\0"
+   "GL_RGBA4_DXT5_S3TC\0"
+   "GL_RGBA4_EXT\0"
+   "GL_RGBA4_OES\0"
+   "GL_RGBA4_S3TC\0"
+   "GL_RGBA8\0"
+   "GL_RGBA8I\0"
+   "GL_RGBA8I_EXT\0"
+   "GL_RGBA8UI\0"
+   "GL_RGBA8UI_EXT\0"
+   "GL_RGBA8_EXT\0"
+   "GL_RGBA8_OES\0"
+   "GL_RGBA8_SNORM\0"
+   "GL_RGBA_DXT5_S3TC\0"
+   "GL_RGBA_FLOAT_MODE_ARB\0"
+   "GL_RGBA_INTEGER\0"
+   "GL_RGBA_INTEGER_EXT\0"
+   "GL_RGBA_INTEGER_MODE_EXT\0"
+   "GL_RGBA_MODE\0"
+   "GL_RGBA_S3TC\0"
+   "GL_RGBA_SNORM\0"
+   "GL_RGB_INTEGER\0"
+   "GL_RGB_INTEGER_EXT\0"
+   "GL_RGB_S3TC\0"
+   "GL_RGB_SCALE\0"
+   "GL_RGB_SCALE_ARB\0"
+   "GL_RGB_SCALE_EXT\0"
+   "GL_RGB_SNORM\0"
+   "GL_RG_SNORM\0"
+   "GL_RIGHT\0"
+   "GL_S\0"
+   "GL_SAMPLER_1D\0"
+   "GL_SAMPLER_1D_ARRAY\0"
+   "GL_SAMPLER_1D_ARRAY_EXT\0"
+   "GL_SAMPLER_1D_ARRAY_SHADOW\0"
+   "GL_SAMPLER_1D_ARRAY_SHADOW_EXT\0"
+   "GL_SAMPLER_1D_SHADOW\0"
+   "GL_SAMPLER_2D\0"
+   "GL_SAMPLER_2D_ARRAY\0"
+   "GL_SAMPLER_2D_ARRAY_EXT\0"
+   "GL_SAMPLER_2D_ARRAY_SHADOW\0"
+   "GL_SAMPLER_2D_ARRAY_SHADOW_EXT\0"
+   "GL_SAMPLER_2D_RECT\0"
+   "GL_SAMPLER_2D_RECT_SHADOW\0"
+   "GL_SAMPLER_2D_SHADOW\0"
+   "GL_SAMPLER_3D\0"
+   "GL_SAMPLER_3D_OES\0"
+   "GL_SAMPLER_BUFFER\0"
+   "GL_SAMPLER_BUFFER_EXT\0"
+   "GL_SAMPLER_CUBE\0"
+   "GL_SAMPLER_CUBE_SHADOW\0"
+   "GL_SAMPLER_CUBE_SHADOW_EXT\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_ATTRIBS\0"
+   "GL_SEPARATE_ATTRIBS_EXT\0"
+   "GL_SEPARATE_SPECULAR_COLOR\0"
+   "GL_SEPARATE_SPECULAR_COLOR_EXT\0"
+   "GL_SET\0"
+   "GL_SHADER_BINARY_FORMATS\0"
+   "GL_SHADER_COMPILER\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_SIGNALED\0"
+   "GL_SIGNED_NORMALIZED\0"
+   "GL_SINGLE_COLOR\0"
+   "GL_SINGLE_COLOR_EXT\0"
+   "GL_SLICE_ACCUM_SUN\0"
+   "GL_SLUMINANCE\0"
+   "GL_SLUMINANCE8\0"
+   "GL_SLUMINANCE8_ALPHA8\0"
+   "GL_SLUMINANCE_ALPHA\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_SRGB\0"
+   "GL_SRGB8\0"
+   "GL_SRGB8_ALPHA8\0"
+   "GL_SRGB_ALPHA\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\0"
+   "GL_STENCIL_ATTACHMENT_EXT\0"
+   "GL_STENCIL_ATTACHMENT_OES\0"
+   "GL_STENCIL_BACK_FAIL\0"
+   "GL_STENCIL_BACK_FAIL_ATI\0"
+   "GL_STENCIL_BACK_FUNC\0"
+   "GL_STENCIL_BACK_FUNC_ATI\0"
+   "GL_STENCIL_BACK_PASS_DEPTH_FAIL\0"
+   "GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI\0"
+   "GL_STENCIL_BACK_PASS_DEPTH_PASS\0"
+   "GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI\0"
+   "GL_STENCIL_BACK_REF\0"
+   "GL_STENCIL_BACK_VALUE_MASK\0"
+   "GL_STENCIL_BACK_WRITEMASK\0"
+   "GL_STENCIL_BITS\0"
+   "GL_STENCIL_BUFFER\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_INDEX1\0"
+   "GL_STENCIL_INDEX16\0"
+   "GL_STENCIL_INDEX16_EXT\0"
+   "GL_STENCIL_INDEX1_EXT\0"
+   "GL_STENCIL_INDEX1_OES\0"
+   "GL_STENCIL_INDEX4\0"
+   "GL_STENCIL_INDEX4_EXT\0"
+   "GL_STENCIL_INDEX4_OES\0"
+   "GL_STENCIL_INDEX8\0"
+   "GL_STENCIL_INDEX8_EXT\0"
+   "GL_STENCIL_INDEX8_OES\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_STORAGE_CACHED_APPLE\0"
+   "GL_STORAGE_PRIVATE_APPLE\0"
+   "GL_STORAGE_SHARED_APPLE\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_SYNC_CONDITION\0"
+   "GL_SYNC_FENCE\0"
+   "GL_SYNC_FLAGS\0"
+   "GL_SYNC_FLUSH_COMMANDS_BIT\0"
+   "GL_SYNC_GPU_COMMANDS_COMPLETE\0"
+   "GL_SYNC_STATUS\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\0"
+   "GL_TEXTURE_1D_ARRAY_EXT\0"
+   "GL_TEXTURE_2D\0"
+   "GL_TEXTURE_2D_ARRAY\0"
+   "GL_TEXTURE_2D_ARRAY_EXT\0"
+   "GL_TEXTURE_3D\0"
+   "GL_TEXTURE_3D_OES\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\0"
+   "GL_TEXTURE_BINDING_1D_ARRAY_EXT\0"
+   "GL_TEXTURE_BINDING_2D\0"
+   "GL_TEXTURE_BINDING_2D_ARRAY\0"
+   "GL_TEXTURE_BINDING_2D_ARRAY_EXT\0"
+   "GL_TEXTURE_BINDING_3D\0"
+   "GL_TEXTURE_BINDING_3D_OES\0"
+   "GL_TEXTURE_BINDING_BUFFER\0"
+   "GL_TEXTURE_BINDING_CUBE_MAP\0"
+   "GL_TEXTURE_BINDING_CUBE_MAP_ARB\0"
+   "GL_TEXTURE_BINDING_CUBE_MAP_OES\0"
+   "GL_TEXTURE_BINDING_RECTANGLE\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_BUFFER\0"
+   "GL_TEXTURE_BUFFER_DATA_STORE_BINDING\0"
+   "GL_TEXTURE_BUFFER_FORMAT\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_CROP_RECT_OES\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_X_OES\0"
+   "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y\0"
+   "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB\0"
+   "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES\0"
+   "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z\0"
+   "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB\0"
+   "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES\0"
+   "GL_TEXTURE_CUBE_MAP_OES\0"
+   "GL_TEXTURE_CUBE_MAP_POSITIVE_X\0"
+   "GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB\0"
+   "GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES\0"
+   "GL_TEXTURE_CUBE_MAP_POSITIVE_Y\0"
+   "GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB\0"
+   "GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES\0"
+   "GL_TEXTURE_CUBE_MAP_POSITIVE_Z\0"
+   "GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB\0"
+   "GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES\0"
+   "GL_TEXTURE_CUBE_MAP_SEAMLESS\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_FILTER_CONTROL_EXT\0"
+   "GL_TEXTURE_GEN_MODE\0"
+   "GL_TEXTURE_GEN_MODE_OES\0"
+   "GL_TEXTURE_GEN_Q\0"
+   "GL_TEXTURE_GEN_R\0"
+   "GL_TEXTURE_GEN_S\0"
+   "GL_TEXTURE_GEN_STR_OES\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_MATRIX_FLOAT_AS_INT_BITS_OES\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_RANGE_LENGTH_APPLE\0"
+   "GL_TEXTURE_RANGE_POINTER_APPLE\0"
+   "GL_TEXTURE_RECTANGLE\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_SHARED_SIZE\0"
+   "GL_TEXTURE_STACK_DEPTH\0"
+   "GL_TEXTURE_STENCIL_SIZE\0"
+   "GL_TEXTURE_STENCIL_SIZE_EXT\0"
+   "GL_TEXTURE_STORAGE_HINT_APPLE\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_R_OES\0"
+   "GL_TEXTURE_WRAP_S\0"
+   "GL_TEXTURE_WRAP_T\0"
+   "GL_TIMEOUT_EXPIRED\0"
+   "GL_TIME_ELAPSED_EXT\0"
+   "GL_TRACK_MATRIX_NV\0"
+   "GL_TRACK_MATRIX_TRANSFORM_NV\0"
+   "GL_TRANSFORM_BIT\0"
+   "GL_TRANSFORM_FEEDBACK\0"
+   "GL_TRANSFORM_FEEDBACK_BINDING\0"
+   "GL_TRANSFORM_FEEDBACK_BUFFER\0"
+   "GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE\0"
+   "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING\0"
+   "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT\0"
+   "GL_TRANSFORM_FEEDBACK_BUFFER_EXT\0"
+   "GL_TRANSFORM_FEEDBACK_BUFFER_MODE\0"
+   "GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT\0"
+   "GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED\0"
+   "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE\0"
+   "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT\0"
+   "GL_TRANSFORM_FEEDBACK_BUFFER_START\0"
+   "GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT\0"
+   "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN\0"
+   "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT\0"
+   "GL_TRANSFORM_FEEDBACK_VARYINGS\0"
+   "GL_TRANSFORM_FEEDBACK_VARYINGS_EXT\0"
+   "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH\0"
+   "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT\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_TRIANGLES_ADJACENCY\0"
+   "GL_TRIANGLES_ADJACENCY_ARB\0"
+   "GL_TRIANGLE_FAN\0"
+   "GL_TRIANGLE_MESH_SUN\0"
+   "GL_TRIANGLE_STRIP\0"
+   "GL_TRIANGLE_STRIP_ADJACENCY\0"
+   "GL_TRIANGLE_STRIP_ADJACENCY_ARB\0"
+   "GL_TRUE\0"
+   "GL_UNDEFINED_APPLE\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_UNSIGNALED\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_10F_11F_11F_REV\0"
+   "GL_UNSIGNED_INT_10_10_10_2\0"
+   "GL_UNSIGNED_INT_10_10_10_2_OES\0"
+   "GL_UNSIGNED_INT_24_8\0"
+   "GL_UNSIGNED_INT_24_8_EXT\0"
+   "GL_UNSIGNED_INT_24_8_NV\0"
+   "GL_UNSIGNED_INT_24_8_OES\0"
+   "GL_UNSIGNED_INT_2_10_10_10_REV\0"
+   "GL_UNSIGNED_INT_2_10_10_10_REV_EXT\0"
+   "GL_UNSIGNED_INT_5_9_9_9_REV\0"
+   "GL_UNSIGNED_INT_8_8_8_8\0"
+   "GL_UNSIGNED_INT_8_8_8_8_REV\0"
+   "GL_UNSIGNED_INT_SAMPLER_1D\0"
+   "GL_UNSIGNED_INT_SAMPLER_1D_ARRAY\0"
+   "GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT\0"
+   "GL_UNSIGNED_INT_SAMPLER_1D_EXT\0"
+   "GL_UNSIGNED_INT_SAMPLER_2D\0"
+   "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY\0"
+   "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT\0"
+   "GL_UNSIGNED_INT_SAMPLER_2D_EXT\0"
+   "GL_UNSIGNED_INT_SAMPLER_2D_RECT\0"
+   "GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT\0"
+   "GL_UNSIGNED_INT_SAMPLER_3D\0"
+   "GL_UNSIGNED_INT_SAMPLER_3D_EXT\0"
+   "GL_UNSIGNED_INT_SAMPLER_BUFFER\0"
+   "GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT\0"
+   "GL_UNSIGNED_INT_SAMPLER_CUBE\0"
+   "GL_UNSIGNED_INT_SAMPLER_CUBE_EXT\0"
+   "GL_UNSIGNED_INT_VEC2\0"
+   "GL_UNSIGNED_INT_VEC2_EXT\0"
+   "GL_UNSIGNED_INT_VEC3\0"
+   "GL_UNSIGNED_INT_VEC3_EXT\0"
+   "GL_UNSIGNED_INT_VEC4\0"
+   "GL_UNSIGNED_INT_VEC4_EXT\0"
+   "GL_UNSIGNED_NORMALIZED\0"
+   "GL_UNSIGNED_SHORT\0"
+   "GL_UNSIGNED_SHORT_1_5_5_5_REV\0"
+   "GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT\0"
+   "GL_UNSIGNED_SHORT_4_4_4_4\0"
+   "GL_UNSIGNED_SHORT_4_4_4_4_REV\0"
+   "GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT\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\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_DIVISOR_ARB\0"
+   "GL_VERTEX_ATTRIB_ARRAY_ENABLED\0"
+   "GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB\0"
+   "GL_VERTEX_ATTRIB_ARRAY_INTEGER\0"
+   "GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT\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_VOLATILE_APPLE\0"
+   "GL_WAIT_FAILED\0"
+   "GL_WEIGHT_ARRAY_ARB\0"
+   "GL_WEIGHT_ARRAY_BUFFER_BINDING\0"
+   "GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB\0"
+   "GL_WEIGHT_ARRAY_BUFFER_BINDING_OES\0"
+   "GL_WEIGHT_ARRAY_OES\0"
+   "GL_WEIGHT_ARRAY_POINTER_ARB\0"
+   "GL_WEIGHT_ARRAY_POINTER_OES\0"
+   "GL_WEIGHT_ARRAY_SIZE_ARB\0"
+   "GL_WEIGHT_ARRAY_SIZE_OES\0"
+   "GL_WEIGHT_ARRAY_STRIDE_ARB\0"
+   "GL_WEIGHT_ARRAY_STRIDE_OES\0"
+   "GL_WEIGHT_ARRAY_TYPE_ARB\0"
+   "GL_WEIGHT_ARRAY_TYPE_OES\0"
+   "GL_WEIGHT_SUM_UNITY_ARB\0"
+   "GL_WRAP_BORDER_SUN\0"
+   "GL_WRITE_ONLY\0"
+   "GL_WRITE_ONLY_ARB\0"
+   "GL_WRITE_ONLY_OES\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[2300] =
+{
+   {     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, 0x00008B8D }, /* GL_ACTIVE_PROGRAM_EXT */
+   {   298, 0x00008911 }, /* GL_ACTIVE_STENCIL_FACE_EXT */
+   {   325, 0x000084E0 }, /* GL_ACTIVE_TEXTURE */
+   {   343, 0x000084E0 }, /* GL_ACTIVE_TEXTURE_ARB */
+   {   365, 0x00008B86 }, /* GL_ACTIVE_UNIFORMS */
+   {   384, 0x00008B87 }, /* GL_ACTIVE_UNIFORM_MAX_LENGTH */
+   {   413, 0x000086A5 }, /* GL_ACTIVE_VERTEX_UNITS_ARB */
+   {   440, 0x00000104 }, /* GL_ADD */
+   {   447, 0x00008574 }, /* GL_ADD_SIGNED */
+   {   461, 0x00008574 }, /* GL_ADD_SIGNED_ARB */
+   {   479, 0x00008574 }, /* GL_ADD_SIGNED_EXT */
+   {   497, 0x0000846E }, /* GL_ALIASED_LINE_WIDTH_RANGE */
+   {   525, 0x0000846D }, /* GL_ALIASED_POINT_SIZE_RANGE */
+   {   553, 0x000FFFFF }, /* GL_ALL_ATTRIB_BITS */
+   {   572, 0xFFFFFFFF }, /* GL_ALL_CLIENT_ATTRIB_BITS */
+   {   598, 0x00001906 }, /* GL_ALPHA */
+   {   607, 0x0000803D }, /* GL_ALPHA12 */
+   {   618, 0x0000803D }, /* GL_ALPHA12_EXT */
+   {   633, 0x0000803E }, /* GL_ALPHA16 */
+   {   644, 0x00008D8A }, /* GL_ALPHA16I_EXT */
+   {   660, 0x00008D78 }, /* GL_ALPHA16UI_EXT */
+   {   677, 0x0000803E }, /* GL_ALPHA16_EXT */
+   {   692, 0x00008D84 }, /* GL_ALPHA32I_EXT */
+   {   708, 0x00008D72 }, /* GL_ALPHA32UI_EXT */
+   {   725, 0x0000803B }, /* GL_ALPHA4 */
+   {   735, 0x0000803B }, /* GL_ALPHA4_EXT */
+   {   749, 0x0000803C }, /* GL_ALPHA8 */
+   {   759, 0x00008D90 }, /* GL_ALPHA8I_EXT */
+   {   774, 0x00008D7E }, /* GL_ALPHA8UI_EXT */
+   {   790, 0x0000803C }, /* GL_ALPHA8_EXT */
+   {   804, 0x00000D1D }, /* GL_ALPHA_BIAS */
+   {   818, 0x00000D55 }, /* GL_ALPHA_BITS */
+   {   832, 0x00008D97 }, /* GL_ALPHA_INTEGER_EXT */
+   {   853, 0x00000D1C }, /* GL_ALPHA_SCALE */
+   {   868, 0x00000BC0 }, /* GL_ALPHA_TEST */
+   {   882, 0x00000BC1 }, /* GL_ALPHA_TEST_FUNC */
+   {   901, 0x00000BC2 }, /* GL_ALPHA_TEST_REF */
+   {   919, 0x0000911A }, /* GL_ALREADY_SIGNALED */
+   {   939, 0x00000207 }, /* GL_ALWAYS */
+   {   949, 0x00001200 }, /* GL_AMBIENT */
+   {   960, 0x00001602 }, /* GL_AMBIENT_AND_DIFFUSE */
+   {   983, 0x00001501 }, /* GL_AND */
+   {   990, 0x00001504 }, /* GL_AND_INVERTED */
+   {  1006, 0x00001502 }, /* GL_AND_REVERSE */
+   {  1021, 0x00008892 }, /* GL_ARRAY_BUFFER */
+   {  1037, 0x00008894 }, /* GL_ARRAY_BUFFER_BINDING */
+   {  1061, 0x00008894 }, /* GL_ARRAY_BUFFER_BINDING_ARB */
+   {  1089, 0x00008B85 }, /* GL_ATTACHED_SHADERS */
+   {  1109, 0x00008645 }, /* GL_ATTRIB_ARRAY_POINTER_NV */
+   {  1136, 0x00008623 }, /* GL_ATTRIB_ARRAY_SIZE_NV */
+   {  1160, 0x00008624 }, /* GL_ATTRIB_ARRAY_STRIDE_NV */
+   {  1186, 0x00008625 }, /* GL_ATTRIB_ARRAY_TYPE_NV */
+   {  1210, 0x00000BB0 }, /* GL_ATTRIB_STACK_DEPTH */
+   {  1232, 0x00000D80 }, /* GL_AUTO_NORMAL */
+   {  1247, 0x00000409 }, /* GL_AUX0 */
+   {  1255, 0x0000040A }, /* GL_AUX1 */
+   {  1263, 0x0000040B }, /* GL_AUX2 */
+   {  1271, 0x0000040C }, /* GL_AUX3 */
+   {  1279, 0x00000C00 }, /* GL_AUX_BUFFERS */
+   {  1294, 0x00000405 }, /* GL_BACK */
+   {  1302, 0x00000402 }, /* GL_BACK_LEFT */
+   {  1315, 0x00000403 }, /* GL_BACK_RIGHT */
+   {  1329, 0x000080E0 }, /* GL_BGR */
+   {  1336, 0x000080E1 }, /* GL_BGRA */
+   {  1344, 0x000080E1 }, /* GL_BGRA_EXT */
+   {  1356, 0x00008D9B }, /* GL_BGRA_INTEGER */
+   {  1372, 0x00008D9B }, /* GL_BGRA_INTEGER_EXT */
+   {  1392, 0x00008D9A }, /* GL_BGR_INTEGER */
+   {  1407, 0x00008D9A }, /* GL_BGR_INTEGER_EXT */
+   {  1426, 0x00001A00 }, /* GL_BITMAP */
+   {  1436, 0x00000704 }, /* GL_BITMAP_TOKEN */
+   {  1452, 0x00000BE2 }, /* GL_BLEND */
+   {  1461, 0x00008005 }, /* GL_BLEND_COLOR */
+   {  1476, 0x00008005 }, /* GL_BLEND_COLOR_EXT */
+   {  1495, 0x00000BE0 }, /* GL_BLEND_DST */
+   {  1508, 0x000080CA }, /* GL_BLEND_DST_ALPHA */
+   {  1527, 0x000080CA }, /* GL_BLEND_DST_ALPHA_OES */
+   {  1550, 0x000080C8 }, /* GL_BLEND_DST_RGB */
+   {  1567, 0x000080C8 }, /* GL_BLEND_DST_RGB_OES */
+   {  1588, 0x00008009 }, /* GL_BLEND_EQUATION */
+   {  1606, 0x0000883D }, /* GL_BLEND_EQUATION_ALPHA */
+   {  1630, 0x0000883D }, /* GL_BLEND_EQUATION_ALPHA_EXT */
+   {  1658, 0x0000883D }, /* GL_BLEND_EQUATION_ALPHA_OES */
+   {  1686, 0x00008009 }, /* GL_BLEND_EQUATION_EXT */
+   {  1708, 0x00008009 }, /* GL_BLEND_EQUATION_OES */
+   {  1730, 0x00008009 }, /* GL_BLEND_EQUATION_RGB */
+   {  1752, 0x00008009 }, /* GL_BLEND_EQUATION_RGB_EXT */
+   {  1778, 0x00008009 }, /* GL_BLEND_EQUATION_RGB_OES */
+   {  1804, 0x00000BE1 }, /* GL_BLEND_SRC */
+   {  1817, 0x000080CB }, /* GL_BLEND_SRC_ALPHA */
+   {  1836, 0x000080CB }, /* GL_BLEND_SRC_ALPHA_OES */
+   {  1859, 0x000080C9 }, /* GL_BLEND_SRC_RGB */
+   {  1876, 0x000080C9 }, /* GL_BLEND_SRC_RGB_OES */
+   {  1897, 0x00001905 }, /* GL_BLUE */
+   {  1905, 0x00000D1B }, /* GL_BLUE_BIAS */
+   {  1918, 0x00000D54 }, /* GL_BLUE_BITS */
+   {  1931, 0x00008D96 }, /* GL_BLUE_INTEGER */
+   {  1947, 0x00008D96 }, /* GL_BLUE_INTEGER_EXT */
+   {  1967, 0x00000D1A }, /* GL_BLUE_SCALE */
+   {  1981, 0x00008B56 }, /* GL_BOOL */
+   {  1989, 0x00008B56 }, /* GL_BOOL_ARB */
+   {  2001, 0x00008B57 }, /* GL_BOOL_VEC2 */
+   {  2014, 0x00008B57 }, /* GL_BOOL_VEC2_ARB */
+   {  2031, 0x00008B58 }, /* GL_BOOL_VEC3 */
+   {  2044, 0x00008B58 }, /* GL_BOOL_VEC3_ARB */
+   {  2061, 0x00008B59 }, /* GL_BOOL_VEC4 */
+   {  2074, 0x00008B59 }, /* GL_BOOL_VEC4_ARB */
+   {  2091, 0x000088BB }, /* GL_BUFFER_ACCESS */
+   {  2108, 0x000088BB }, /* GL_BUFFER_ACCESS_ARB */
+   {  2129, 0x0000911F }, /* GL_BUFFER_ACCESS_FLAGS */
+   {  2152, 0x000088BB }, /* GL_BUFFER_ACCESS_OES */
+   {  2173, 0x00008A13 }, /* GL_BUFFER_FLUSHING_UNMAP_APPLE */
+   {  2204, 0x000088BC }, /* GL_BUFFER_MAPPED */
+   {  2221, 0x000088BC }, /* GL_BUFFER_MAPPED_ARB */
+   {  2242, 0x000088BC }, /* GL_BUFFER_MAPPED_OES */
+   {  2263, 0x00009120 }, /* GL_BUFFER_MAP_LENGTH */
+   {  2284, 0x00009121 }, /* GL_BUFFER_MAP_OFFSET */
+   {  2305, 0x000088BD }, /* GL_BUFFER_MAP_POINTER */
+   {  2327, 0x000088BD }, /* GL_BUFFER_MAP_POINTER_ARB */
+   {  2353, 0x000088BD }, /* GL_BUFFER_MAP_POINTER_OES */
+   {  2379, 0x000085B3 }, /* GL_BUFFER_OBJECT_APPLE */
+   {  2402, 0x00008A12 }, /* GL_BUFFER_SERIALIZED_MODIFY_APPLE */
+   {  2436, 0x00008764 }, /* GL_BUFFER_SIZE */
+   {  2451, 0x00008764 }, /* GL_BUFFER_SIZE_ARB */
+   {  2470, 0x00008765 }, /* GL_BUFFER_USAGE */
+   {  2486, 0x00008765 }, /* GL_BUFFER_USAGE_ARB */
+   {  2506, 0x0000877B }, /* GL_BUMP_ENVMAP_ATI */
+   {  2525, 0x00008777 }, /* GL_BUMP_NUM_TEX_UNITS_ATI */
+   {  2551, 0x00008775 }, /* GL_BUMP_ROT_MATRIX_ATI */
+   {  2574, 0x00008776 }, /* GL_BUMP_ROT_MATRIX_SIZE_ATI */
+   {  2602, 0x0000877C }, /* GL_BUMP_TARGET_ATI */
+   {  2621, 0x00008778 }, /* GL_BUMP_TEX_UNITS_ATI */
+   {  2643, 0x00001400 }, /* GL_BYTE */
+   {  2651, 0x00002A24 }, /* GL_C3F_V3F */
+   {  2662, 0x00002A26 }, /* GL_C4F_N3F_V3F */
+   {  2677, 0x00002A22 }, /* GL_C4UB_V2F */
+   {  2689, 0x00002A23 }, /* GL_C4UB_V3F */
+   {  2701, 0x00000901 }, /* GL_CCW */
+   {  2708, 0x00002900 }, /* GL_CLAMP */
+   {  2717, 0x0000891B }, /* GL_CLAMP_FRAGMENT_COLOR_ARB */
+   {  2745, 0x0000891C }, /* GL_CLAMP_READ_COLOR */
+   {  2765, 0x0000891C }, /* GL_CLAMP_READ_COLOR_ARB */
+   {  2789, 0x0000812D }, /* GL_CLAMP_TO_BORDER */
+   {  2808, 0x0000812D }, /* GL_CLAMP_TO_BORDER_ARB */
+   {  2831, 0x0000812D }, /* GL_CLAMP_TO_BORDER_SGIS */
+   {  2855, 0x0000812F }, /* GL_CLAMP_TO_EDGE */
+   {  2872, 0x0000812F }, /* GL_CLAMP_TO_EDGE_SGIS */
+   {  2894, 0x0000891A }, /* GL_CLAMP_VERTEX_COLOR_ARB */
+   {  2920, 0x00001500 }, /* GL_CLEAR */
+   {  2929, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE */
+   {  2954, 0x000084E1 }, /* GL_CLIENT_ACTIVE_TEXTURE_ARB */
+   {  2983, 0xFFFFFFFF }, /* GL_CLIENT_ALL_ATTRIB_BITS */
+   {  3009, 0x00000BB1 }, /* GL_CLIENT_ATTRIB_STACK_DEPTH */
+   {  3038, 0x00000001 }, /* GL_CLIENT_PIXEL_STORE_BIT */
+   {  3064, 0x00000002 }, /* GL_CLIENT_VERTEX_ARRAY_BIT */
+   {  3091, 0x00003000 }, /* GL_CLIP_DISTANCE0 */
+   {  3109, 0x00003001 }, /* GL_CLIP_DISTANCE1 */
+   {  3127, 0x00003002 }, /* GL_CLIP_DISTANCE2 */
+   {  3145, 0x00003003 }, /* GL_CLIP_DISTANCE3 */
+   {  3163, 0x00003004 }, /* GL_CLIP_DISTANCE4 */
+   {  3181, 0x00003005 }, /* GL_CLIP_DISTANCE5 */
+   {  3199, 0x00003006 }, /* GL_CLIP_DISTANCE6 */
+   {  3217, 0x00003007 }, /* GL_CLIP_DISTANCE7 */
+   {  3235, 0x00003000 }, /* GL_CLIP_PLANE0 */
+   {  3250, 0x00003001 }, /* GL_CLIP_PLANE1 */
+   {  3265, 0x00003002 }, /* GL_CLIP_PLANE2 */
+   {  3280, 0x00003003 }, /* GL_CLIP_PLANE3 */
+   {  3295, 0x00003004 }, /* GL_CLIP_PLANE4 */
+   {  3310, 0x00003005 }, /* GL_CLIP_PLANE5 */
+   {  3325, 0x000080F0 }, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */
+   {  3358, 0x00000A00 }, /* GL_COEFF */
+   {  3367, 0x00001800 }, /* GL_COLOR */
+   {  3376, 0x00008076 }, /* GL_COLOR_ARRAY */
+   {  3391, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING */
+   {  3421, 0x00008898 }, /* GL_COLOR_ARRAY_BUFFER_BINDING_ARB */
+   {  3455, 0x00008090 }, /* GL_COLOR_ARRAY_POINTER */
+   {  3478, 0x00008081 }, /* GL_COLOR_ARRAY_SIZE */
+   {  3498, 0x00008083 }, /* GL_COLOR_ARRAY_STRIDE */
+   {  3520, 0x00008082 }, /* GL_COLOR_ARRAY_TYPE */
+   {  3540, 0x00008CE0 }, /* GL_COLOR_ATTACHMENT0 */
+   {  3561, 0x00008CE0 }, /* GL_COLOR_ATTACHMENT0_EXT */
+   {  3586, 0x00008CE0 }, /* GL_COLOR_ATTACHMENT0_OES */
+   {  3611, 0x00008CE1 }, /* GL_COLOR_ATTACHMENT1 */
+   {  3632, 0x00008CEA }, /* GL_COLOR_ATTACHMENT10 */
+   {  3654, 0x00008CEA }, /* GL_COLOR_ATTACHMENT10_EXT */
+   {  3680, 0x00008CEB }, /* GL_COLOR_ATTACHMENT11 */
+   {  3702, 0x00008CEB }, /* GL_COLOR_ATTACHMENT11_EXT */
+   {  3728, 0x00008CEC }, /* GL_COLOR_ATTACHMENT12 */
+   {  3750, 0x00008CEC }, /* GL_COLOR_ATTACHMENT12_EXT */
+   {  3776, 0x00008CED }, /* GL_COLOR_ATTACHMENT13 */
+   {  3798, 0x00008CED }, /* GL_COLOR_ATTACHMENT13_EXT */
+   {  3824, 0x00008CEE }, /* GL_COLOR_ATTACHMENT14 */
+   {  3846, 0x00008CEE }, /* GL_COLOR_ATTACHMENT14_EXT */
+   {  3872, 0x00008CEF }, /* GL_COLOR_ATTACHMENT15 */
+   {  3894, 0x00008CEF }, /* GL_COLOR_ATTACHMENT15_EXT */
+   {  3920, 0x00008CE1 }, /* GL_COLOR_ATTACHMENT1_EXT */
+   {  3945, 0x00008CE2 }, /* GL_COLOR_ATTACHMENT2 */
+   {  3966, 0x00008CE2 }, /* GL_COLOR_ATTACHMENT2_EXT */
+   {  3991, 0x00008CE3 }, /* GL_COLOR_ATTACHMENT3 */
+   {  4012, 0x00008CE3 }, /* GL_COLOR_ATTACHMENT3_EXT */
+   {  4037, 0x00008CE4 }, /* GL_COLOR_ATTACHMENT4 */
+   {  4058, 0x00008CE4 }, /* GL_COLOR_ATTACHMENT4_EXT */
+   {  4083, 0x00008CE5 }, /* GL_COLOR_ATTACHMENT5 */
+   {  4104, 0x00008CE5 }, /* GL_COLOR_ATTACHMENT5_EXT */
+   {  4129, 0x00008CE6 }, /* GL_COLOR_ATTACHMENT6 */
+   {  4150, 0x00008CE6 }, /* GL_COLOR_ATTACHMENT6_EXT */
+   {  4175, 0x00008CE7 }, /* GL_COLOR_ATTACHMENT7 */
+   {  4196, 0x00008CE7 }, /* GL_COLOR_ATTACHMENT7_EXT */
+   {  4221, 0x00008CE8 }, /* GL_COLOR_ATTACHMENT8 */
+   {  4242, 0x00008CE8 }, /* GL_COLOR_ATTACHMENT8_EXT */
+   {  4267, 0x00008CE9 }, /* GL_COLOR_ATTACHMENT9 */
+   {  4288, 0x00008CE9 }, /* GL_COLOR_ATTACHMENT9_EXT */
+   {  4313, 0x00004000 }, /* GL_COLOR_BUFFER_BIT */
+   {  4333, 0x00000C22 }, /* GL_COLOR_CLEAR_VALUE */
+   {  4354, 0x00001900 }, /* GL_COLOR_INDEX */
+   {  4369, 0x00001603 }, /* GL_COLOR_INDEXES */
+   {  4386, 0x00000BF2 }, /* GL_COLOR_LOGIC_OP */
+   {  4404, 0x00000B57 }, /* GL_COLOR_MATERIAL */
+   {  4422, 0x00000B55 }, /* GL_COLOR_MATERIAL_FACE */
+   {  4445, 0x00000B56 }, /* GL_COLOR_MATERIAL_PARAMETER */
+   {  4473, 0x000080B1 }, /* GL_COLOR_MATRIX */
+   {  4489, 0x000080B1 }, /* GL_COLOR_MATRIX_SGI */
+   {  4509, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH */
+   {  4537, 0x000080B2 }, /* GL_COLOR_MATRIX_STACK_DEPTH_SGI */
+   {  4569, 0x00008458 }, /* GL_COLOR_SUM */
+   {  4582, 0x00008458 }, /* GL_COLOR_SUM_ARB */
+   {  4599, 0x000080D0 }, /* GL_COLOR_TABLE */
+   {  4614, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE */
+   {  4640, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_EXT */
+   {  4670, 0x000080DD }, /* GL_COLOR_TABLE_ALPHA_SIZE_SGI */
+   {  4700, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS */
+   {  4720, 0x000080D7 }, /* GL_COLOR_TABLE_BIAS_SGI */
+   {  4744, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE */
+   {  4769, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_EXT */
+   {  4798, 0x000080DC }, /* GL_COLOR_TABLE_BLUE_SIZE_SGI */
+   {  4827, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT */
+   {  4849, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_EXT */
+   {  4875, 0x000080D8 }, /* GL_COLOR_TABLE_FORMAT_SGI */
+   {  4901, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE */
+   {  4927, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_EXT */
+   {  4957, 0x000080DB }, /* GL_COLOR_TABLE_GREEN_SIZE_SGI */
+   {  4987, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE */
+   {  5017, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_EXT */
+   {  5051, 0x000080DF }, /* GL_COLOR_TABLE_INTENSITY_SIZE_SGI */
+   {  5085, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE */
+   {  5115, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_EXT */
+   {  5149, 0x000080DE }, /* GL_COLOR_TABLE_LUMINANCE_SIZE_SGI */
+   {  5183, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE */
+   {  5207, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_EXT */
+   {  5235, 0x000080DA }, /* GL_COLOR_TABLE_RED_SIZE_SGI */
+   {  5263, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE */
+   {  5284, 0x000080D6 }, /* GL_COLOR_TABLE_SCALE_SGI */
+   {  5309, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH */
+   {  5330, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_EXT */
+   {  5355, 0x000080D9 }, /* GL_COLOR_TABLE_WIDTH_SGI */
+   {  5380, 0x00000C23 }, /* GL_COLOR_WRITEMASK */
+   {  5399, 0x00008570 }, /* GL_COMBINE */
+   {  5410, 0x00008503 }, /* GL_COMBINE4 */
+   {  5422, 0x00008572 }, /* GL_COMBINE_ALPHA */
+   {  5439, 0x00008572 }, /* GL_COMBINE_ALPHA_ARB */
+   {  5460, 0x00008572 }, /* GL_COMBINE_ALPHA_EXT */
+   {  5481, 0x00008570 }, /* GL_COMBINE_ARB */
+   {  5496, 0x00008570 }, /* GL_COMBINE_EXT */
+   {  5511, 0x00008571 }, /* GL_COMBINE_RGB */
+   {  5526, 0x00008571 }, /* GL_COMBINE_RGB_ARB */
+   {  5545, 0x00008571 }, /* GL_COMBINE_RGB_EXT */
+   {  5564, 0x0000884E }, /* GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT */
+   {  5600, 0x0000884E }, /* GL_COMPARE_REF_TO_TEXTURE */
+   {  5626, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE */
+   {  5650, 0x0000884E }, /* GL_COMPARE_R_TO_TEXTURE_ARB */
+   {  5678, 0x00001300 }, /* GL_COMPILE */
+   {  5689, 0x00001301 }, /* GL_COMPILE_AND_EXECUTE */
+   {  5712, 0x00008B81 }, /* GL_COMPILE_STATUS */
+   {  5730, 0x000084E9 }, /* GL_COMPRESSED_ALPHA */
+   {  5750, 0x000084E9 }, /* GL_COMPRESSED_ALPHA_ARB */
+   {  5774, 0x000084EC }, /* GL_COMPRESSED_INTENSITY */
+   {  5798, 0x000084EC }, /* GL_COMPRESSED_INTENSITY_ARB */
+   {  5826, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE */
+   {  5850, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA */
+   {  5880, 0x000084EB }, /* GL_COMPRESSED_LUMINANCE_ALPHA_ARB */
+   {  5914, 0x000084EA }, /* GL_COMPRESSED_LUMINANCE_ARB */
+   {  5942, 0x00008225 }, /* GL_COMPRESSED_RED */
+   {  5960, 0x00008226 }, /* GL_COMPRESSED_RG */
+   {  5977, 0x000084ED }, /* GL_COMPRESSED_RGB */
+   {  5995, 0x000084EE }, /* GL_COMPRESSED_RGBA */
+   {  6014, 0x000084EE }, /* GL_COMPRESSED_RGBA_ARB */
+   {  6037, 0x000086B1 }, /* GL_COMPRESSED_RGBA_FXT1_3DFX */
+   {  6066, 0x000083F1 }, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */
+   {  6099, 0x000083F2 }, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */
+   {  6132, 0x000083F3 }, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */
+   {  6165, 0x000084ED }, /* GL_COMPRESSED_RGB_ARB */
+   {  6187, 0x000086B0 }, /* GL_COMPRESSED_RGB_FXT1_3DFX */
+   {  6215, 0x000083F0 }, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */
+   {  6247, 0x00008C4A }, /* GL_COMPRESSED_SLUMINANCE */
+   {  6272, 0x00008C4B }, /* GL_COMPRESSED_SLUMINANCE_ALPHA */
+   {  6303, 0x00008C48 }, /* GL_COMPRESSED_SRGB */
+   {  6322, 0x00008C49 }, /* GL_COMPRESSED_SRGB_ALPHA */
+   {  6347, 0x000086A3 }, /* GL_COMPRESSED_TEXTURE_FORMATS */
+   {  6377, 0x0000911C }, /* GL_CONDITION_SATISFIED */
+   {  6400, 0x00008576 }, /* GL_CONSTANT */
+   {  6412, 0x00008003 }, /* GL_CONSTANT_ALPHA */
+   {  6430, 0x00008003 }, /* GL_CONSTANT_ALPHA_EXT */
+   {  6452, 0x00008576 }, /* GL_CONSTANT_ARB */
+   {  6468, 0x00001207 }, /* GL_CONSTANT_ATTENUATION */
+   {  6492, 0x00008151 }, /* GL_CONSTANT_BORDER_HP */
+   {  6514, 0x00008001 }, /* GL_CONSTANT_COLOR */
+   {  6532, 0x00008001 }, /* GL_CONSTANT_COLOR_EXT */
+   {  6554, 0x00008576 }, /* GL_CONSTANT_EXT */
+   {  6570, 0x00000002 }, /* GL_CONTEXT_COMPATIBILITY_PROFILE_BIT */
+   {  6607, 0x00000001 }, /* GL_CONTEXT_CORE_PROFILE_BIT */
+   {  6635, 0x0000821E }, /* GL_CONTEXT_FLAGS */
+   {  6652, 0x00000001 }, /* GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT */
+   {  6691, 0x00009126 }, /* GL_CONTEXT_PROFILE_MASK */
+   {  6715, 0x00008010 }, /* GL_CONVOLUTION_1D */
+   {  6733, 0x00008011 }, /* GL_CONVOLUTION_2D */
+   {  6751, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR */
+   {  6779, 0x00008154 }, /* GL_CONVOLUTION_BORDER_COLOR_HP */
+   {  6810, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE */
+   {  6837, 0x00008013 }, /* GL_CONVOLUTION_BORDER_MODE_EXT */
+   {  6868, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS */
+   {  6895, 0x00008015 }, /* GL_CONVOLUTION_FILTER_BIAS_EXT */
+   {  6926, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE */
+   {  6954, 0x00008014 }, /* GL_CONVOLUTION_FILTER_SCALE_EXT */
+   {  6986, 0x00008017 }, /* GL_CONVOLUTION_FORMAT */
+   {  7008, 0x00008017 }, /* GL_CONVOLUTION_FORMAT_EXT */
+   {  7034, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT */
+   {  7056, 0x00008019 }, /* GL_CONVOLUTION_HEIGHT_EXT */
+   {  7082, 0x00008018 }, /* GL_CONVOLUTION_WIDTH */
+   {  7103, 0x00008018 }, /* GL_CONVOLUTION_WIDTH_EXT */
+   {  7128, 0x00008862 }, /* GL_COORD_REPLACE */
+   {  7145, 0x00008862 }, /* GL_COORD_REPLACE_ARB */
+   {  7166, 0x00008862 }, /* GL_COORD_REPLACE_NV */
+   {  7186, 0x00008862 }, /* GL_COORD_REPLACE_OES */
+   {  7207, 0x00001503 }, /* GL_COPY */
+   {  7215, 0x0000150C }, /* GL_COPY_INVERTED */
+   {  7232, 0x00000706 }, /* GL_COPY_PIXEL_TOKEN */
+   {  7252, 0x00008F36 }, /* GL_COPY_READ_BUFFER */
+   {  7272, 0x00008F37 }, /* GL_COPY_WRITE_BUFFER */
+   {  7293, 0x00000B44 }, /* GL_CULL_FACE */
+   {  7306, 0x00000B45 }, /* GL_CULL_FACE_MODE */
+   {  7324, 0x000081AA }, /* GL_CULL_VERTEX_EXT */
+   {  7343, 0x000081AC }, /* GL_CULL_VERTEX_EYE_POSITION_EXT */
+   {  7375, 0x000081AB }, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */
+   {  7410, 0x00008626 }, /* GL_CURRENT_ATTRIB_NV */
+   {  7431, 0x00000001 }, /* GL_CURRENT_BIT */
+   {  7446, 0x00000B00 }, /* GL_CURRENT_COLOR */
+   {  7463, 0x00008453 }, /* GL_CURRENT_FOG_COORD */
+   {  7484, 0x00008453 }, /* GL_CURRENT_FOG_COORDINATE */
+   {  7510, 0x00000B01 }, /* GL_CURRENT_INDEX */
+   {  7527, 0x00008641 }, /* GL_CURRENT_MATRIX_ARB */
+   {  7549, 0x00008845 }, /* GL_CURRENT_MATRIX_INDEX_ARB */
+   {  7577, 0x00008641 }, /* GL_CURRENT_MATRIX_NV */
+   {  7598, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */
+   {  7632, 0x00008640 }, /* GL_CURRENT_MATRIX_STACK_DEPTH_NV */
+   {  7665, 0x00000B02 }, /* GL_CURRENT_NORMAL */
+   {  7683, 0x00008843 }, /* GL_CURRENT_PALETTE_MATRIX_ARB */
+   {  7713, 0x00008843 }, /* GL_CURRENT_PALETTE_MATRIX_OES */
+   {  7743, 0x00008B8D }, /* GL_CURRENT_PROGRAM */
+   {  7762, 0x00008865 }, /* GL_CURRENT_QUERY */
+   {  7779, 0x00008865 }, /* GL_CURRENT_QUERY_ARB */
+   {  7800, 0x00000B04 }, /* GL_CURRENT_RASTER_COLOR */
+   {  7824, 0x00000B09 }, /* GL_CURRENT_RASTER_DISTANCE */
+   {  7851, 0x00000B05 }, /* GL_CURRENT_RASTER_INDEX */
+   {  7875, 0x00000B07 }, /* GL_CURRENT_RASTER_POSITION */
+   {  7902, 0x00000B08 }, /* GL_CURRENT_RASTER_POSITION_VALID */
+   {  7935, 0x0000845F }, /* GL_CURRENT_RASTER_SECONDARY_COLOR */
+   {  7969, 0x00000B06 }, /* GL_CURRENT_RASTER_TEXTURE_COORDS */
+   {  8002, 0x00008459 }, /* GL_CURRENT_SECONDARY_COLOR */
+   {  8029, 0x00000B03 }, /* GL_CURRENT_TEXTURE_COORDS */
+   {  8055, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB */
+   {  8080, 0x00008626 }, /* GL_CURRENT_VERTEX_ATTRIB_ARB */
+   {  8109, 0x000086A8 }, /* GL_CURRENT_WEIGHT_ARB */
+   {  8131, 0x00000900 }, /* GL_CW */
+   {  8137, 0x0000875B }, /* GL_DEBUG_ASSERT_MESA */
+   {  8158, 0x00008759 }, /* GL_DEBUG_OBJECT_MESA */
+   {  8179, 0x0000875A }, /* GL_DEBUG_PRINT_MESA */
+   {  8199, 0x00002101 }, /* GL_DECAL */
+   {  8208, 0x00001E03 }, /* GL_DECR */
+   {  8216, 0x00008508 }, /* GL_DECR_WRAP */
+   {  8229, 0x00008508 }, /* GL_DECR_WRAP_EXT */
+   {  8246, 0x00008B80 }, /* GL_DELETE_STATUS */
+   {  8263, 0x00001801 }, /* GL_DEPTH */
+   {  8272, 0x000088F0 }, /* GL_DEPTH24_STENCIL8 */
+   {  8292, 0x000088F0 }, /* GL_DEPTH24_STENCIL8_EXT */
+   {  8316, 0x000088F0 }, /* GL_DEPTH24_STENCIL8_OES */
+   {  8340, 0x00008D00 }, /* GL_DEPTH_ATTACHMENT */
+   {  8360, 0x00008D00 }, /* GL_DEPTH_ATTACHMENT_EXT */
+   {  8384, 0x00008D00 }, /* GL_DEPTH_ATTACHMENT_OES */
+   {  8408, 0x00000D1F }, /* GL_DEPTH_BIAS */
+   {  8422, 0x00000D56 }, /* GL_DEPTH_BITS */
+   {  8436, 0x00008891 }, /* GL_DEPTH_BOUNDS_EXT */
+   {  8456, 0x00008890 }, /* GL_DEPTH_BOUNDS_TEST_EXT */
+   {  8481, 0x00008223 }, /* GL_DEPTH_BUFFER */
+   {  8497, 0x00000100 }, /* GL_DEPTH_BUFFER_BIT */
+   {  8517, 0x0000864F }, /* GL_DEPTH_CLAMP */
+   {  8532, 0x0000864F }, /* GL_DEPTH_CLAMP_NV */
+   {  8550, 0x00000B73 }, /* GL_DEPTH_CLEAR_VALUE */
+   {  8571, 0x00001902 }, /* GL_DEPTH_COMPONENT */
+   {  8590, 0x000081A5 }, /* GL_DEPTH_COMPONENT16 */
+   {  8611, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_ARB */
+   {  8636, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_OES */
+   {  8661, 0x000081A5 }, /* GL_DEPTH_COMPONENT16_SGIX */
+   {  8687, 0x000081A6 }, /* GL_DEPTH_COMPONENT24 */
+   {  8708, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_ARB */
+   {  8733, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_OES */
+   {  8758, 0x000081A6 }, /* GL_DEPTH_COMPONENT24_SGIX */
+   {  8784, 0x000081A7 }, /* GL_DEPTH_COMPONENT32 */
+   {  8805, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_ARB */
+   {  8830, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_OES */
+   {  8855, 0x000081A7 }, /* GL_DEPTH_COMPONENT32_SGIX */
+   {  8881, 0x00000B74 }, /* GL_DEPTH_FUNC */
+   {  8895, 0x00000B70 }, /* GL_DEPTH_RANGE */
+   {  8910, 0x00000D1E }, /* GL_DEPTH_SCALE */
+   {  8925, 0x000084F9 }, /* GL_DEPTH_STENCIL */
+   {  8942, 0x0000821A }, /* GL_DEPTH_STENCIL_ATTACHMENT */
+   {  8970, 0x000084F9 }, /* GL_DEPTH_STENCIL_EXT */
+   {  8991, 0x000084F9 }, /* GL_DEPTH_STENCIL_NV */
+   {  9011, 0x000084F9 }, /* GL_DEPTH_STENCIL_OES */
+   {  9032, 0x0000886F }, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
+   {  9060, 0x0000886E }, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
+   {  9088, 0x00000B71 }, /* GL_DEPTH_TEST */
+   {  9102, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE */
+   {  9124, 0x0000884B }, /* GL_DEPTH_TEXTURE_MODE_ARB */
+   {  9150, 0x00000B72 }, /* GL_DEPTH_WRITEMASK */
+   {  9169, 0x00001201 }, /* GL_DIFFUSE */
+   {  9180, 0x00000BD0 }, /* GL_DITHER */
+   {  9190, 0x00000A02 }, /* GL_DOMAIN */
+   {  9200, 0x00001100 }, /* GL_DONT_CARE */
+   {  9213, 0x000086AE }, /* GL_DOT3_RGB */
+   {  9225, 0x000086AF }, /* GL_DOT3_RGBA */
+   {  9238, 0x000086AF }, /* GL_DOT3_RGBA_ARB */
+   {  9255, 0x00008741 }, /* GL_DOT3_RGBA_EXT */
+   {  9272, 0x000086AE }, /* GL_DOT3_RGB_ARB */
+   {  9288, 0x00008740 }, /* GL_DOT3_RGB_EXT */
+   {  9304, 0x0000140A }, /* GL_DOUBLE */
+   {  9314, 0x00000C32 }, /* GL_DOUBLEBUFFER */
+   {  9330, 0x00000C01 }, /* GL_DRAW_BUFFER */
+   {  9345, 0x00008825 }, /* GL_DRAW_BUFFER0 */
+   {  9361, 0x00008825 }, /* GL_DRAW_BUFFER0_ARB */
+   {  9381, 0x00008825 }, /* GL_DRAW_BUFFER0_ATI */
+   {  9401, 0x00008826 }, /* GL_DRAW_BUFFER1 */
+   {  9417, 0x0000882F }, /* GL_DRAW_BUFFER10 */
+   {  9434, 0x0000882F }, /* GL_DRAW_BUFFER10_ARB */
+   {  9455, 0x0000882F }, /* GL_DRAW_BUFFER10_ATI */
+   {  9476, 0x00008830 }, /* GL_DRAW_BUFFER11 */
+   {  9493, 0x00008830 }, /* GL_DRAW_BUFFER11_ARB */
+   {  9514, 0x00008830 }, /* GL_DRAW_BUFFER11_ATI */
+   {  9535, 0x00008831 }, /* GL_DRAW_BUFFER12 */
+   {  9552, 0x00008831 }, /* GL_DRAW_BUFFER12_ARB */
+   {  9573, 0x00008831 }, /* GL_DRAW_BUFFER12_ATI */
+   {  9594, 0x00008832 }, /* GL_DRAW_BUFFER13 */
+   {  9611, 0x00008832 }, /* GL_DRAW_BUFFER13_ARB */
+   {  9632, 0x00008832 }, /* GL_DRAW_BUFFER13_ATI */
+   {  9653, 0x00008833 }, /* GL_DRAW_BUFFER14 */
+   {  9670, 0x00008833 }, /* GL_DRAW_BUFFER14_ARB */
+   {  9691, 0x00008833 }, /* GL_DRAW_BUFFER14_ATI */
+   {  9712, 0x00008834 }, /* GL_DRAW_BUFFER15 */
+   {  9729, 0x00008834 }, /* GL_DRAW_BUFFER15_ARB */
+   {  9750, 0x00008834 }, /* GL_DRAW_BUFFER15_ATI */
+   {  9771, 0x00008826 }, /* GL_DRAW_BUFFER1_ARB */
+   {  9791, 0x00008826 }, /* GL_DRAW_BUFFER1_ATI */
+   {  9811, 0x00008827 }, /* GL_DRAW_BUFFER2 */
+   {  9827, 0x00008827 }, /* GL_DRAW_BUFFER2_ARB */
+   {  9847, 0x00008827 }, /* GL_DRAW_BUFFER2_ATI */
+   {  9867, 0x00008828 }, /* GL_DRAW_BUFFER3 */
+   {  9883, 0x00008828 }, /* GL_DRAW_BUFFER3_ARB */
+   {  9903, 0x00008828 }, /* GL_DRAW_BUFFER3_ATI */
+   {  9923, 0x00008829 }, /* GL_DRAW_BUFFER4 */
+   {  9939, 0x00008829 }, /* GL_DRAW_BUFFER4_ARB */
+   {  9959, 0x00008829 }, /* GL_DRAW_BUFFER4_ATI */
+   {  9979, 0x0000882A }, /* GL_DRAW_BUFFER5 */
+   {  9995, 0x0000882A }, /* GL_DRAW_BUFFER5_ARB */
+   { 10015, 0x0000882A }, /* GL_DRAW_BUFFER5_ATI */
+   { 10035, 0x0000882B }, /* GL_DRAW_BUFFER6 */
+   { 10051, 0x0000882B }, /* GL_DRAW_BUFFER6_ARB */
+   { 10071, 0x0000882B }, /* GL_DRAW_BUFFER6_ATI */
+   { 10091, 0x0000882C }, /* GL_DRAW_BUFFER7 */
+   { 10107, 0x0000882C }, /* GL_DRAW_BUFFER7_ARB */
+   { 10127, 0x0000882C }, /* GL_DRAW_BUFFER7_ATI */
+   { 10147, 0x0000882D }, /* GL_DRAW_BUFFER8 */
+   { 10163, 0x0000882D }, /* GL_DRAW_BUFFER8_ARB */
+   { 10183, 0x0000882D }, /* GL_DRAW_BUFFER8_ATI */
+   { 10203, 0x0000882E }, /* GL_DRAW_BUFFER9 */
+   { 10219, 0x0000882E }, /* GL_DRAW_BUFFER9_ARB */
+   { 10239, 0x0000882E }, /* GL_DRAW_BUFFER9_ATI */
+   { 10259, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER */
+   { 10279, 0x00008CA6 }, /* GL_DRAW_FRAMEBUFFER_BINDING */
+   { 10307, 0x00008CA6 }, /* GL_DRAW_FRAMEBUFFER_BINDING_EXT */
+   { 10339, 0x00008CA9 }, /* GL_DRAW_FRAMEBUFFER_EXT */
+   { 10363, 0x00000705 }, /* GL_DRAW_PIXEL_TOKEN */
+   { 10383, 0x00000304 }, /* GL_DST_ALPHA */
+   { 10396, 0x00000306 }, /* GL_DST_COLOR */
+   { 10409, 0x0000877A }, /* GL_DU8DV8_ATI */
+   { 10423, 0x00008779 }, /* GL_DUDV_ATI */
+   { 10435, 0x000088EA }, /* GL_DYNAMIC_COPY */
+   { 10451, 0x000088EA }, /* GL_DYNAMIC_COPY_ARB */
+   { 10471, 0x000088E8 }, /* GL_DYNAMIC_DRAW */
+   { 10487, 0x000088E8 }, /* GL_DYNAMIC_DRAW_ARB */
+   { 10507, 0x000088E9 }, /* GL_DYNAMIC_READ */
+   { 10523, 0x000088E9 }, /* GL_DYNAMIC_READ_ARB */
+   { 10543, 0x00000B43 }, /* GL_EDGE_FLAG */
+   { 10556, 0x00008079 }, /* GL_EDGE_FLAG_ARRAY */
+   { 10575, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
+   { 10609, 0x0000889B }, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB */
+   { 10647, 0x00008093 }, /* GL_EDGE_FLAG_ARRAY_POINTER */
+   { 10674, 0x0000808C }, /* GL_EDGE_FLAG_ARRAY_STRIDE */
+   { 10700, 0x00008893 }, /* GL_ELEMENT_ARRAY_BUFFER */
+   { 10724, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
+   { 10756, 0x00008895 }, /* GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB */
+   { 10792, 0x00001600 }, /* GL_EMISSION */
+   { 10804, 0x00002000 }, /* GL_ENABLE_BIT */
+   { 10818, 0x00000202 }, /* GL_EQUAL */
+   { 10827, 0x00001509 }, /* GL_EQUIV */
+   { 10836, 0x00010000 }, /* GL_EVAL_BIT */
+   { 10848, 0x00000800 }, /* GL_EXP */
+   { 10855, 0x00000801 }, /* GL_EXP2 */
+   { 10863, 0x00001F03 }, /* GL_EXTENSIONS */
+   { 10877, 0x00002400 }, /* GL_EYE_LINEAR */
+   { 10891, 0x00002502 }, /* GL_EYE_PLANE */
+   { 10904, 0x0000855C }, /* GL_EYE_PLANE_ABSOLUTE_NV */
+   { 10929, 0x0000855B }, /* GL_EYE_RADIAL_NV */
+   { 10946, 0x00000000 }, /* GL_FALSE */
+   { 10955, 0x00001101 }, /* GL_FASTEST */
+   { 10966, 0x00001C01 }, /* GL_FEEDBACK */
+   { 10978, 0x00000DF0 }, /* GL_FEEDBACK_BUFFER_POINTER */
+   { 11005, 0x00000DF1 }, /* GL_FEEDBACK_BUFFER_SIZE */
+   { 11029, 0x00000DF2 }, /* GL_FEEDBACK_BUFFER_TYPE */
+   { 11053, 0x00001B02 }, /* GL_FILL */
+   { 11061, 0x00008E4D }, /* GL_FIRST_VERTEX_CONVENTION */
+   { 11088, 0x00008E4D }, /* GL_FIRST_VERTEX_CONVENTION_EXT */
+   { 11119, 0x0000140C }, /* GL_FIXED */
+   { 11128, 0x0000140C }, /* GL_FIXED_OES */
+   { 11141, 0x0000891D }, /* GL_FIXED_ONLY */
+   { 11155, 0x0000891D }, /* GL_FIXED_ONLY_ARB */
+   { 11173, 0x00001D00 }, /* GL_FLAT */
+   { 11181, 0x00001406 }, /* GL_FLOAT */
+   { 11190, 0x00008B5A }, /* GL_FLOAT_MAT2 */
+   { 11204, 0x00008B5A }, /* GL_FLOAT_MAT2_ARB */
+   { 11222, 0x00008B65 }, /* GL_FLOAT_MAT2x3 */
+   { 11238, 0x00008B66 }, /* GL_FLOAT_MAT2x4 */
+   { 11254, 0x00008B5B }, /* GL_FLOAT_MAT3 */
+   { 11268, 0x00008B5B }, /* GL_FLOAT_MAT3_ARB */
+   { 11286, 0x00008B67 }, /* GL_FLOAT_MAT3x2 */
+   { 11302, 0x00008B68 }, /* GL_FLOAT_MAT3x4 */
+   { 11318, 0x00008B5C }, /* GL_FLOAT_MAT4 */
+   { 11332, 0x00008B5C }, /* GL_FLOAT_MAT4_ARB */
+   { 11350, 0x00008B69 }, /* GL_FLOAT_MAT4x2 */
+   { 11366, 0x00008B6A }, /* GL_FLOAT_MAT4x3 */
+   { 11382, 0x00008B50 }, /* GL_FLOAT_VEC2 */
+   { 11396, 0x00008B50 }, /* GL_FLOAT_VEC2_ARB */
+   { 11414, 0x00008B51 }, /* GL_FLOAT_VEC3 */
+   { 11428, 0x00008B51 }, /* GL_FLOAT_VEC3_ARB */
+   { 11446, 0x00008B52 }, /* GL_FLOAT_VEC4 */
+   { 11460, 0x00008B52 }, /* GL_FLOAT_VEC4_ARB */
+   { 11478, 0x00000B60 }, /* GL_FOG */
+   { 11485, 0x00000080 }, /* GL_FOG_BIT */
+   { 11496, 0x00000B66 }, /* GL_FOG_COLOR */
+   { 11509, 0x00008451 }, /* GL_FOG_COORD */
+   { 11522, 0x00008451 }, /* GL_FOG_COORDINATE */
+   { 11540, 0x00008457 }, /* GL_FOG_COORDINATE_ARRAY */
+   { 11564, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
+   { 11603, 0x0000889D }, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB */
+   { 11646, 0x00008456 }, /* GL_FOG_COORDINATE_ARRAY_POINTER */
+   { 11678, 0x00008455 }, /* GL_FOG_COORDINATE_ARRAY_STRIDE */
+   { 11709, 0x00008454 }, /* GL_FOG_COORDINATE_ARRAY_TYPE */
+   { 11738, 0x00008450 }, /* GL_FOG_COORDINATE_SOURCE */
+   { 11763, 0x00008457 }, /* GL_FOG_COORD_ARRAY */
+   { 11782, 0x0000889D }, /* GL_FOG_COORD_ARRAY_BUFFER_BINDING */
+   { 11816, 0x00008456 }, /* GL_FOG_COORD_ARRAY_POINTER */
+   { 11843, 0x00008455 }, /* GL_FOG_COORD_ARRAY_STRIDE */
+   { 11869, 0x00008454 }, /* GL_FOG_COORD_ARRAY_TYPE */
+   { 11893, 0x00008450 }, /* GL_FOG_COORD_SRC */
+   { 11910, 0x00000B62 }, /* GL_FOG_DENSITY */
+   { 11925, 0x0000855A }, /* GL_FOG_DISTANCE_MODE_NV */
+   { 11949, 0x00000B64 }, /* GL_FOG_END */
+   { 11960, 0x00000C54 }, /* GL_FOG_HINT */
+   { 11972, 0x00000B61 }, /* GL_FOG_INDEX */
+   { 11985, 0x00000B65 }, /* GL_FOG_MODE */
+   { 11997, 0x00008198 }, /* GL_FOG_OFFSET_SGIX */
+   { 12016, 0x00008199 }, /* GL_FOG_OFFSET_VALUE_SGIX */
+   { 12041, 0x00000B63 }, /* GL_FOG_START */
+   { 12054, 0x00008452 }, /* GL_FRAGMENT_DEPTH */
+   { 12072, 0x00008804 }, /* GL_FRAGMENT_PROGRAM_ARB */
+   { 12096, 0x00008B30 }, /* GL_FRAGMENT_SHADER */
+   { 12115, 0x00008B30 }, /* GL_FRAGMENT_SHADER_ARB */
+   { 12138, 0x00008B8B }, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */
+   { 12173, 0x00008B8B }, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES */
+   { 12212, 0x00008D40 }, /* GL_FRAMEBUFFER */
+   { 12227, 0x00008215 }, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */
+   { 12264, 0x00008214 }, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */
+   { 12300, 0x00008210 }, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */
+   { 12341, 0x00008211 }, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */
+   { 12382, 0x00008216 }, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */
+   { 12419, 0x00008213 }, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */
+   { 12456, 0x00008DA7 }, /* GL_FRAMEBUFFER_ATTACHMENT_LAYERED */
+   { 12490, 0x00008DA7 }, /* GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB */
+   { 12528, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */
+   { 12566, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT */
+   { 12608, 0x00008CD1 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES */
+   { 12650, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */
+   { 12688, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT */
+   { 12730, 0x00008CD0 }, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES */
+   { 12772, 0x00008212 }, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */
+   { 12807, 0x00008217 }, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */
+   { 12846, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT */
+   { 12895, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES */
+   { 12944, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */
+   { 12992, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT */
+   { 13044, 0x00008CD3 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES */
+   { 13096, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */
+   { 13136, 0x00008CD4 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT */
+   { 13180, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */
+   { 13220, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT */
+   { 13264, 0x00008CD2 }, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES */
+   { 13308, 0x00008CA6 }, /* GL_FRAMEBUFFER_BINDING */
+   { 13331, 0x00008CA6 }, /* GL_FRAMEBUFFER_BINDING_EXT */
+   { 13358, 0x00008CA6 }, /* GL_FRAMEBUFFER_BINDING_OES */
+   { 13385, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE */
+   { 13409, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE_EXT */
+   { 13437, 0x00008CD5 }, /* GL_FRAMEBUFFER_COMPLETE_OES */
+   { 13465, 0x00008218 }, /* GL_FRAMEBUFFER_DEFAULT */
+   { 13488, 0x00008D40 }, /* GL_FRAMEBUFFER_EXT */
+   { 13507, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */
+   { 13544, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT */
+   { 13585, 0x00008CD6 }, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES */
+   { 13626, 0x00008CD9 }, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS */
+   { 13663, 0x00008CD9 }, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */
+   { 13704, 0x00008CD9 }, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES */
+   { 13745, 0x00008CDB }, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER */
+   { 13783, 0x00008CDB }, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT */
+   { 13825, 0x00008CDB }, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_OES */
+   { 13867, 0x00008CD8 }, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */
+   { 13918, 0x00008CDA }, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */
+   { 13956, 0x00008CDA }, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES */
+   { 13994, 0x00008DA9 }, /* GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB */
+   { 14036, 0x00008DA8 }, /* GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS */
+   { 14076, 0x00008DA8 }, /* GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB */
+   { 14120, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */
+   { 14165, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT */
+   { 14214, 0x00008CD7 }, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES */
+   { 14263, 0x00008D56 }, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */
+   { 14301, 0x00008D56 }, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT */
+   { 14343, 0x00008CDC }, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER */
+   { 14381, 0x00008CDC }, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT */
+   { 14423, 0x00008CDC }, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_OES */
+   { 14465, 0x00008D40 }, /* GL_FRAMEBUFFER_OES */
+   { 14484, 0x00008CDE }, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */
+   { 14516, 0x00008219 }, /* GL_FRAMEBUFFER_UNDEFINED */
+   { 14541, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED */
+   { 14568, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED_EXT */
+   { 14599, 0x00008CDD }, /* GL_FRAMEBUFFER_UNSUPPORTED_OES */
+   { 14630, 0x00000404 }, /* GL_FRONT */
+   { 14639, 0x00000408 }, /* GL_FRONT_AND_BACK */
+   { 14657, 0x00000B46 }, /* GL_FRONT_FACE */
+   { 14671, 0x00000400 }, /* GL_FRONT_LEFT */
+   { 14685, 0x00000401 }, /* GL_FRONT_RIGHT */
+   { 14700, 0x00008006 }, /* GL_FUNC_ADD */
+   { 14712, 0x00008006 }, /* GL_FUNC_ADD_EXT */
+   { 14728, 0x00008006 }, /* GL_FUNC_ADD_OES */
+   { 14744, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT */
+   { 14769, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT_EXT */
+   { 14798, 0x0000800B }, /* GL_FUNC_REVERSE_SUBTRACT_OES */
+   { 14827, 0x0000800A }, /* GL_FUNC_SUBTRACT */
+   { 14844, 0x0000800A }, /* GL_FUNC_SUBTRACT_EXT */
+   { 14865, 0x0000800A }, /* GL_FUNC_SUBTRACT_OES */
+   { 14886, 0x00008191 }, /* GL_GENERATE_MIPMAP */
+   { 14905, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT */
+   { 14929, 0x00008192 }, /* GL_GENERATE_MIPMAP_HINT_SGIS */
+   { 14958, 0x00008191 }, /* GL_GENERATE_MIPMAP_SGIS */
+   { 14982, 0x00008917 }, /* GL_GEOMETRY_INPUT_TYPE */
+   { 15005, 0x00008DDB }, /* GL_GEOMETRY_INPUT_TYPE_ARB */
+   { 15032, 0x00008918 }, /* GL_GEOMETRY_OUTPUT_TYPE */
+   { 15056, 0x00008DDC }, /* GL_GEOMETRY_OUTPUT_TYPE_ARB */
+   { 15084, 0x00008DD9 }, /* GL_GEOMETRY_SHADER */
+   { 15103, 0x00008DD9 }, /* GL_GEOMETRY_SHADER_ARB */
+   { 15126, 0x00008916 }, /* GL_GEOMETRY_VERTICES_OUT */
+   { 15151, 0x00008DDA }, /* GL_GEOMETRY_VERTICES_OUT_ARB */
+   { 15180, 0x00000206 }, /* GL_GEQUAL */
+   { 15190, 0x00000204 }, /* GL_GREATER */
+   { 15201, 0x00001904 }, /* GL_GREEN */
+   { 15210, 0x00000D19 }, /* GL_GREEN_BIAS */
+   { 15224, 0x00000D53 }, /* GL_GREEN_BITS */
+   { 15238, 0x00008D95 }, /* GL_GREEN_INTEGER */
+   { 15255, 0x00008D95 }, /* GL_GREEN_INTEGER_EXT */
+   { 15276, 0x00000D18 }, /* GL_GREEN_SCALE */
+   { 15291, 0x0000140B }, /* GL_HALF_FLOAT */
+   { 15305, 0x00008D61 }, /* GL_HALF_FLOAT_OES */
+   { 15323, 0x00008DF2 }, /* GL_HIGH_FLOAT */
+   { 15337, 0x00008DF5 }, /* GL_HIGH_INT */
+   { 15349, 0x00008000 }, /* GL_HINT_BIT */
+   { 15361, 0x00008024 }, /* GL_HISTOGRAM */
+   { 15374, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE */
+   { 15398, 0x0000802B }, /* GL_HISTOGRAM_ALPHA_SIZE_EXT */
+   { 15426, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE */
+   { 15449, 0x0000802A }, /* GL_HISTOGRAM_BLUE_SIZE_EXT */
+   { 15476, 0x00008024 }, /* GL_HISTOGRAM_EXT */
+   { 15493, 0x00008027 }, /* GL_HISTOGRAM_FORMAT */
+   { 15513, 0x00008027 }, /* GL_HISTOGRAM_FORMAT_EXT */
+   { 15537, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE */
+   { 15561, 0x00008029 }, /* GL_HISTOGRAM_GREEN_SIZE_EXT */
+   { 15589, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE */
+   { 15617, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE_EXT */
+   { 15649, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE */
+   { 15671, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE_EXT */
+   { 15697, 0x0000802D }, /* GL_HISTOGRAM_SINK */
+   { 15715, 0x0000802D }, /* GL_HISTOGRAM_SINK_EXT */
+   { 15737, 0x00008026 }, /* GL_HISTOGRAM_WIDTH */
+   { 15756, 0x00008026 }, /* GL_HISTOGRAM_WIDTH_EXT */
+   { 15779, 0x0000862A }, /* GL_IDENTITY_NV */
+   { 15794, 0x00008150 }, /* GL_IGNORE_BORDER_HP */
+   { 15814, 0x00008B9B }, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT */
+   { 15850, 0x00008B9B }, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
+   { 15890, 0x00008B9A }, /* GL_IMPLEMENTATION_COLOR_READ_TYPE */
+   { 15924, 0x00008B9A }, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
+   { 15962, 0x00001E02 }, /* GL_INCR */
+   { 15970, 0x00008507 }, /* GL_INCR_WRAP */
+   { 15983, 0x00008507 }, /* GL_INCR_WRAP_EXT */
+   { 16000, 0x00008222 }, /* GL_INDEX */
+   { 16009, 0x00008077 }, /* GL_INDEX_ARRAY */
+   { 16024, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING */
+   { 16054, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING_ARB */
+   { 16088, 0x00008091 }, /* GL_INDEX_ARRAY_POINTER */
+   { 16111, 0x00008086 }, /* GL_INDEX_ARRAY_STRIDE */
+   { 16133, 0x00008085 }, /* GL_INDEX_ARRAY_TYPE */
+   { 16153, 0x00000D51 }, /* GL_INDEX_BITS */
+   { 16167, 0x00000C20 }, /* GL_INDEX_CLEAR_VALUE */
+   { 16188, 0x00000BF1 }, /* GL_INDEX_LOGIC_OP */
+   { 16206, 0x00000C30 }, /* GL_INDEX_MODE */
+   { 16220, 0x00000D13 }, /* GL_INDEX_OFFSET */
+   { 16236, 0x00000D12 }, /* GL_INDEX_SHIFT */
+   { 16251, 0x00000C21 }, /* GL_INDEX_WRITEMASK */
+   { 16270, 0x00008B84 }, /* GL_INFO_LOG_LENGTH */
+   { 16289, 0x00001404 }, /* GL_INT */
+   { 16296, 0x00008049 }, /* GL_INTENSITY */
+   { 16309, 0x0000804C }, /* GL_INTENSITY12 */
+   { 16324, 0x0000804C }, /* GL_INTENSITY12_EXT */
+   { 16343, 0x0000804D }, /* GL_INTENSITY16 */
+   { 16358, 0x00008D8B }, /* GL_INTENSITY16I_EXT */
+   { 16378, 0x00008D79 }, /* GL_INTENSITY16UI_EXT */
+   { 16399, 0x0000804D }, /* GL_INTENSITY16_EXT */
+   { 16418, 0x00008D85 }, /* GL_INTENSITY32I_EXT */
+   { 16438, 0x00008D73 }, /* GL_INTENSITY32UI_EXT */
+   { 16459, 0x0000804A }, /* GL_INTENSITY4 */
+   { 16473, 0x0000804A }, /* GL_INTENSITY4_EXT */
+   { 16491, 0x0000804B }, /* GL_INTENSITY8 */
+   { 16505, 0x00008D91 }, /* GL_INTENSITY8I_EXT */
+   { 16524, 0x00008D7F }, /* GL_INTENSITY8UI_EXT */
+   { 16544, 0x0000804B }, /* GL_INTENSITY8_EXT */
+   { 16562, 0x00008049 }, /* GL_INTENSITY_EXT */
+   { 16579, 0x00008C8C }, /* GL_INTERLEAVED_ATTRIBS */
+   { 16602, 0x00008C8C }, /* GL_INTERLEAVED_ATTRIBS_EXT */
+   { 16629, 0x00008575 }, /* GL_INTERPOLATE */
+   { 16644, 0x00008575 }, /* GL_INTERPOLATE_ARB */
+   { 16663, 0x00008575 }, /* GL_INTERPOLATE_EXT */
+   { 16682, 0x00008DF7 }, /* GL_INT_10_10_10_2_OES */
+   { 16704, 0x00008DC9 }, /* GL_INT_SAMPLER_1D */
+   { 16722, 0x00008DCE }, /* GL_INT_SAMPLER_1D_ARRAY */
+   { 16746, 0x00008DCE }, /* GL_INT_SAMPLER_1D_ARRAY_EXT */
+   { 16774, 0x00008DC9 }, /* GL_INT_SAMPLER_1D_EXT */
+   { 16796, 0x00008DCA }, /* GL_INT_SAMPLER_2D */
+   { 16814, 0x00008DCF }, /* GL_INT_SAMPLER_2D_ARRAY */
+   { 16838, 0x00008DCF }, /* GL_INT_SAMPLER_2D_ARRAY_EXT */
+   { 16866, 0x00008DCA }, /* GL_INT_SAMPLER_2D_EXT */
+   { 16888, 0x00008DCD }, /* GL_INT_SAMPLER_2D_RECT */
+   { 16911, 0x00008DCD }, /* GL_INT_SAMPLER_2D_RECT_EXT */
+   { 16938, 0x00008DCB }, /* GL_INT_SAMPLER_3D */
+   { 16956, 0x00008DCB }, /* GL_INT_SAMPLER_3D_EXT */
+   { 16978, 0x00008DD0 }, /* GL_INT_SAMPLER_BUFFER */
+   { 17000, 0x00008DD0 }, /* GL_INT_SAMPLER_BUFFER_EXT */
+   { 17026, 0x00008DCC }, /* GL_INT_SAMPLER_CUBE */
+   { 17046, 0x00008DCC }, /* GL_INT_SAMPLER_CUBE_EXT */
+   { 17070, 0x00008B53 }, /* GL_INT_VEC2 */
+   { 17082, 0x00008B53 }, /* GL_INT_VEC2_ARB */
+   { 17098, 0x00008B54 }, /* GL_INT_VEC3 */
+   { 17110, 0x00008B54 }, /* GL_INT_VEC3_ARB */
+   { 17126, 0x00008B55 }, /* GL_INT_VEC4 */
+   { 17138, 0x00008B55 }, /* GL_INT_VEC4_ARB */
+   { 17154, 0x00000500 }, /* GL_INVALID_ENUM */
+   { 17170, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION */
+   { 17203, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */
+   { 17240, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_OES */
+   { 17277, 0x00000502 }, /* GL_INVALID_OPERATION */
+   { 17298, 0x00000501 }, /* GL_INVALID_VALUE */
+   { 17315, 0x0000862B }, /* GL_INVERSE_NV */
+   { 17329, 0x0000862D }, /* GL_INVERSE_TRANSPOSE_NV */
+   { 17353, 0x0000150A }, /* GL_INVERT */
+   { 17363, 0x00001E00 }, /* GL_KEEP */
+   { 17371, 0x00008E4E }, /* GL_LAST_VERTEX_CONVENTION */
+   { 17397, 0x00008E4E }, /* GL_LAST_VERTEX_CONVENTION_EXT */
+   { 17427, 0x00000406 }, /* GL_LEFT */
+   { 17435, 0x00000203 }, /* GL_LEQUAL */
+   { 17445, 0x00000201 }, /* GL_LESS */
+   { 17453, 0x00004000 }, /* GL_LIGHT0 */
+   { 17463, 0x00004001 }, /* GL_LIGHT1 */
+   { 17473, 0x00004002 }, /* GL_LIGHT2 */
+   { 17483, 0x00004003 }, /* GL_LIGHT3 */
+   { 17493, 0x00004004 }, /* GL_LIGHT4 */
+   { 17503, 0x00004005 }, /* GL_LIGHT5 */
+   { 17513, 0x00004006 }, /* GL_LIGHT6 */
+   { 17523, 0x00004007 }, /* GL_LIGHT7 */
+   { 17533, 0x00000B50 }, /* GL_LIGHTING */
+   { 17545, 0x00000040 }, /* GL_LIGHTING_BIT */
+   { 17561, 0x00000B53 }, /* GL_LIGHT_MODEL_AMBIENT */
+   { 17584, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL */
+   { 17613, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL_EXT */
+   { 17646, 0x00000B51 }, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
+   { 17674, 0x00000B52 }, /* GL_LIGHT_MODEL_TWO_SIDE */
+   { 17698, 0x00001B01 }, /* GL_LINE */
+   { 17706, 0x00002601 }, /* GL_LINEAR */
+   { 17716, 0x00001208 }, /* GL_LINEAR_ATTENUATION */
+   { 17738, 0x00008170 }, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
+   { 17768, 0x0000844F }, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
+   { 17799, 0x00002703 }, /* GL_LINEAR_MIPMAP_LINEAR */
+   { 17823, 0x00002701 }, /* GL_LINEAR_MIPMAP_NEAREST */
+   { 17848, 0x00000001 }, /* GL_LINES */
+   { 17857, 0x0000000A }, /* GL_LINES_ADJACENCY */
+   { 17876, 0x0000000A }, /* GL_LINES_ADJACENCY_ARB */
+   { 17899, 0x00000004 }, /* GL_LINE_BIT */
+   { 17911, 0x00000002 }, /* GL_LINE_LOOP */
+   { 17924, 0x00000707 }, /* GL_LINE_RESET_TOKEN */
+   { 17944, 0x00000B20 }, /* GL_LINE_SMOOTH */
+   { 17959, 0x00000C52 }, /* GL_LINE_SMOOTH_HINT */
+   { 17979, 0x00000B24 }, /* GL_LINE_STIPPLE */
+   { 17995, 0x00000B25 }, /* GL_LINE_STIPPLE_PATTERN */
+   { 18019, 0x00000B26 }, /* GL_LINE_STIPPLE_REPEAT */
+   { 18042, 0x00000003 }, /* GL_LINE_STRIP */
+   { 18056, 0x0000000B }, /* GL_LINE_STRIP_ADJACENCY */
+   { 18080, 0x0000000B }, /* GL_LINE_STRIP_ADJACENCY_ARB */
+   { 18108, 0x00000702 }, /* GL_LINE_TOKEN */
+   { 18122, 0x00000B21 }, /* GL_LINE_WIDTH */
+   { 18136, 0x00000B23 }, /* GL_LINE_WIDTH_GRANULARITY */
+   { 18162, 0x00000B22 }, /* GL_LINE_WIDTH_RANGE */
+   { 18182, 0x00008B82 }, /* GL_LINK_STATUS */
+   { 18197, 0x00000B32 }, /* GL_LIST_BASE */
+   { 18210, 0x00020000 }, /* GL_LIST_BIT */
+   { 18222, 0x00000B33 }, /* GL_LIST_INDEX */
+   { 18236, 0x00000B30 }, /* GL_LIST_MODE */
+   { 18249, 0x00000101 }, /* GL_LOAD */
+   { 18257, 0x00000BF1 }, /* GL_LOGIC_OP */
+   { 18269, 0x00000BF0 }, /* GL_LOGIC_OP_MODE */
+   { 18286, 0x00008CA1 }, /* GL_LOWER_LEFT */
+   { 18300, 0x00008DF0 }, /* GL_LOW_FLOAT */
+   { 18313, 0x00008DF3 }, /* GL_LOW_INT */
+   { 18324, 0x00001909 }, /* GL_LUMINANCE */
+   { 18337, 0x00008041 }, /* GL_LUMINANCE12 */
+   { 18352, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12 */
+   { 18375, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12_EXT */
+   { 18402, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4 */
+   { 18424, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4_EXT */
+   { 18450, 0x00008041 }, /* GL_LUMINANCE12_EXT */
+   { 18469, 0x00008042 }, /* GL_LUMINANCE16 */
+   { 18484, 0x00008D8C }, /* GL_LUMINANCE16I_EXT */
+   { 18504, 0x00008D7A }, /* GL_LUMINANCE16UI_EXT */
+   { 18525, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16 */
+   { 18548, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16_EXT */
+   { 18575, 0x00008042 }, /* GL_LUMINANCE16_EXT */
+   { 18594, 0x00008D86 }, /* GL_LUMINANCE32I_EXT */
+   { 18614, 0x00008D74 }, /* GL_LUMINANCE32UI_EXT */
+   { 18635, 0x0000803F }, /* GL_LUMINANCE4 */
+   { 18649, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4 */
+   { 18670, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4_EXT */
+   { 18695, 0x0000803F }, /* GL_LUMINANCE4_EXT */
+   { 18713, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2 */
+   { 18734, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2_EXT */
+   { 18759, 0x00008040 }, /* GL_LUMINANCE8 */
+   { 18773, 0x00008D92 }, /* GL_LUMINANCE8I_EXT */
+   { 18792, 0x00008D80 }, /* GL_LUMINANCE8UI_EXT */
+   { 18812, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8 */
+   { 18833, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8_EXT */
+   { 18858, 0x00008040 }, /* GL_LUMINANCE8_EXT */
+   { 18876, 0x0000190A }, /* GL_LUMINANCE_ALPHA */
+   { 18895, 0x00008D8D }, /* GL_LUMINANCE_ALPHA16I_EXT */
+   { 18921, 0x00008D7B }, /* GL_LUMINANCE_ALPHA16UI_EXT */
+   { 18948, 0x00008D87 }, /* GL_LUMINANCE_ALPHA32I_EXT */
+   { 18974, 0x00008D75 }, /* GL_LUMINANCE_ALPHA32UI_EXT */
+   { 19001, 0x00008D93 }, /* GL_LUMINANCE_ALPHA8I_EXT */
+   { 19026, 0x00008D81 }, /* GL_LUMINANCE_ALPHA8UI_EXT */
+   { 19052, 0x00008D9D }, /* GL_LUMINANCE_ALPHA_INTEGER_EXT */
+   { 19083, 0x00008D9C }, /* GL_LUMINANCE_INTEGER_EXT */
+   { 19108, 0x0000821B }, /* GL_MAJOR_VERSION */
+   { 19125, 0x00000D90 }, /* GL_MAP1_COLOR_4 */
+   { 19141, 0x00000DD0 }, /* GL_MAP1_GRID_DOMAIN */
+   { 19161, 0x00000DD1 }, /* GL_MAP1_GRID_SEGMENTS */
+   { 19183, 0x00000D91 }, /* GL_MAP1_INDEX */
+   { 19197, 0x00000D92 }, /* GL_MAP1_NORMAL */
+   { 19212, 0x00000D93 }, /* GL_MAP1_TEXTURE_COORD_1 */
+   { 19236, 0x00000D94 }, /* GL_MAP1_TEXTURE_COORD_2 */
+   { 19260, 0x00000D95 }, /* GL_MAP1_TEXTURE_COORD_3 */
+   { 19284, 0x00000D96 }, /* GL_MAP1_TEXTURE_COORD_4 */
+   { 19308, 0x00000D97 }, /* GL_MAP1_VERTEX_3 */
+   { 19325, 0x00000D98 }, /* GL_MAP1_VERTEX_4 */
+   { 19342, 0x00008660 }, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
+   { 19370, 0x0000866A }, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
+   { 19399, 0x0000866B }, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
+   { 19428, 0x0000866C }, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
+   { 19457, 0x0000866D }, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
+   { 19486, 0x0000866E }, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
+   { 19515, 0x0000866F }, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
+   { 19544, 0x00008661 }, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
+   { 19572, 0x00008662 }, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
+   { 19600, 0x00008663 }, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
+   { 19628, 0x00008664 }, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
+   { 19656, 0x00008665 }, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
+   { 19684, 0x00008666 }, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
+   { 19712, 0x00008667 }, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
+   { 19740, 0x00008668 }, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
+   { 19768, 0x00008669 }, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
+   { 19796, 0x00000DB0 }, /* GL_MAP2_COLOR_4 */
+   { 19812, 0x00000DD2 }, /* GL_MAP2_GRID_DOMAIN */
+   { 19832, 0x00000DD3 }, /* GL_MAP2_GRID_SEGMENTS */
+   { 19854, 0x00000DB1 }, /* GL_MAP2_INDEX */
+   { 19868, 0x00000DB2 }, /* GL_MAP2_NORMAL */
+   { 19883, 0x00000DB3 }, /* GL_MAP2_TEXTURE_COORD_1 */
+   { 19907, 0x00000DB4 }, /* GL_MAP2_TEXTURE_COORD_2 */
+   { 19931, 0x00000DB5 }, /* GL_MAP2_TEXTURE_COORD_3 */
+   { 19955, 0x00000DB6 }, /* GL_MAP2_TEXTURE_COORD_4 */
+   { 19979, 0x00000DB7 }, /* GL_MAP2_VERTEX_3 */
+   { 19996, 0x00000DB8 }, /* GL_MAP2_VERTEX_4 */
+   { 20013, 0x00008670 }, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
+   { 20041, 0x0000867A }, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
+   { 20070, 0x0000867B }, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
+   { 20099, 0x0000867C }, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
+   { 20128, 0x0000867D }, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
+   { 20157, 0x0000867E }, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
+   { 20186, 0x0000867F }, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
+   { 20215, 0x00008671 }, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
+   { 20243, 0x00008672 }, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
+   { 20271, 0x00008673 }, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
+   { 20299, 0x00008674 }, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
+   { 20327, 0x00008675 }, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
+   { 20355, 0x00008676 }, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
+   { 20383, 0x00008677 }, /* GL_MAP2_VERTEX_ATTRIB7_4_NV */
+   { 20411, 0x00008678 }, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
+   { 20439, 0x00008679 }, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
+   { 20467, 0x00000D10 }, /* GL_MAP_COLOR */
+   { 20480, 0x00000010 }, /* GL_MAP_FLUSH_EXPLICIT_BIT */
+   { 20506, 0x00000008 }, /* GL_MAP_INVALIDATE_BUFFER_BIT */
+   { 20535, 0x00000004 }, /* GL_MAP_INVALIDATE_RANGE_BIT */
+   { 20563, 0x00000001 }, /* GL_MAP_READ_BIT */
+   { 20579, 0x00000D11 }, /* GL_MAP_STENCIL */
+   { 20594, 0x00000020 }, /* GL_MAP_UNSYNCHRONIZED_BIT */
+   { 20620, 0x00000002 }, /* GL_MAP_WRITE_BIT */
+   { 20637, 0x000088C0 }, /* GL_MATRIX0_ARB */
+   { 20652, 0x00008630 }, /* GL_MATRIX0_NV */
+   { 20666, 0x000088CA }, /* GL_MATRIX10_ARB */
+   { 20682, 0x000088CB }, /* GL_MATRIX11_ARB */
+   { 20698, 0x000088CC }, /* GL_MATRIX12_ARB */
+   { 20714, 0x000088CD }, /* GL_MATRIX13_ARB */
+   { 20730, 0x000088CE }, /* GL_MATRIX14_ARB */
+   { 20746, 0x000088CF }, /* GL_MATRIX15_ARB */
+   { 20762, 0x000088D0 }, /* GL_MATRIX16_ARB */
+   { 20778, 0x000088D1 }, /* GL_MATRIX17_ARB */
+   { 20794, 0x000088D2 }, /* GL_MATRIX18_ARB */
+   { 20810, 0x000088D3 }, /* GL_MATRIX19_ARB */
+   { 20826, 0x000088C1 }, /* GL_MATRIX1_ARB */
+   { 20841, 0x00008631 }, /* GL_MATRIX1_NV */
+   { 20855, 0x000088D4 }, /* GL_MATRIX20_ARB */
+   { 20871, 0x000088D5 }, /* GL_MATRIX21_ARB */
+   { 20887, 0x000088D6 }, /* GL_MATRIX22_ARB */
+   { 20903, 0x000088D7 }, /* GL_MATRIX23_ARB */
+   { 20919, 0x000088D8 }, /* GL_MATRIX24_ARB */
+   { 20935, 0x000088D9 }, /* GL_MATRIX25_ARB */
+   { 20951, 0x000088DA }, /* GL_MATRIX26_ARB */
+   { 20967, 0x000088DB }, /* GL_MATRIX27_ARB */
+   { 20983, 0x000088DC }, /* GL_MATRIX28_ARB */
+   { 20999, 0x000088DD }, /* GL_MATRIX29_ARB */
+   { 21015, 0x000088C2 }, /* GL_MATRIX2_ARB */
+   { 21030, 0x00008632 }, /* GL_MATRIX2_NV */
+   { 21044, 0x000088DE }, /* GL_MATRIX30_ARB */
+   { 21060, 0x000088DF }, /* GL_MATRIX31_ARB */
+   { 21076, 0x000088C3 }, /* GL_MATRIX3_ARB */
+   { 21091, 0x00008633 }, /* GL_MATRIX3_NV */
+   { 21105, 0x000088C4 }, /* GL_MATRIX4_ARB */
+   { 21120, 0x00008634 }, /* GL_MATRIX4_NV */
+   { 21134, 0x000088C5 }, /* GL_MATRIX5_ARB */
+   { 21149, 0x00008635 }, /* GL_MATRIX5_NV */
+   { 21163, 0x000088C6 }, /* GL_MATRIX6_ARB */
+   { 21178, 0x00008636 }, /* GL_MATRIX6_NV */
+   { 21192, 0x000088C7 }, /* GL_MATRIX7_ARB */
+   { 21207, 0x00008637 }, /* GL_MATRIX7_NV */
+   { 21221, 0x000088C8 }, /* GL_MATRIX8_ARB */
+   { 21236, 0x000088C9 }, /* GL_MATRIX9_ARB */
+   { 21251, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_ARB */
+   { 21277, 0x00008B9E }, /* GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES */
+   { 21318, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_OES */
+   { 21344, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
+   { 21378, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_OES */
+   { 21412, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
+   { 21443, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_OES */
+   { 21474, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
+   { 21507, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_OES */
+   { 21540, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
+   { 21571, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_OES */
+   { 21602, 0x00000BA0 }, /* GL_MATRIX_MODE */
+   { 21617, 0x00008840 }, /* GL_MATRIX_PALETTE_ARB */
+   { 21639, 0x00008840 }, /* GL_MATRIX_PALETTE_OES */
+   { 21661, 0x00008008 }, /* GL_MAX */
+   { 21668, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE */
+   { 21691, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE_OES */
+   { 21718, 0x000088FF }, /* GL_MAX_ARRAY_TEXTURE_LAYERS */
+   { 21746, 0x000088FF }, /* GL_MAX_ARRAY_TEXTURE_LAYERS_EXT */
+   { 21778, 0x00000D35 }, /* GL_MAX_ATTRIB_STACK_DEPTH */
+   { 21804, 0x00000D3B }, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
+   { 21837, 0x00008177 }, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
+   { 21863, 0x00008178 }, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+   { 21897, 0x00000D32 }, /* GL_MAX_CLIP_DISTANCES */
+   { 21919, 0x00000D32 }, /* GL_MAX_CLIP_PLANES */
+   { 21938, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS */
+   { 21963, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
+   { 21992, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
+   { 22024, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI */
+   { 22060, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
+   { 22096, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB */
+   { 22136, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT */
+   { 22162, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT_EXT */
+   { 22192, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH */
+   { 22217, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH_EXT */
+   { 22246, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
+   { 22275, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB */
+   { 22308, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_OES */
+   { 22341, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS */
+   { 22361, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ARB */
+   { 22385, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ATI */
+   { 22409, 0x000080E9 }, /* GL_MAX_ELEMENTS_INDICES */
+   { 22433, 0x000080E8 }, /* GL_MAX_ELEMENTS_VERTICES */
+   { 22458, 0x00000D30 }, /* GL_MAX_EVAL_ORDER */
+   { 22476, 0x00008008 }, /* GL_MAX_EXT */
+   { 22487, 0x00009125 }, /* GL_MAX_FRAGMENT_INPUT_COMPONENTS */
+   { 22520, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
+   { 22555, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB */
+   { 22594, 0x00008DFD }, /* GL_MAX_FRAGMENT_UNIFORM_VECTORS */
+   { 22626, 0x00009123 }, /* GL_MAX_GEOMETRY_INPUT_COMPONENTS */
+   { 22659, 0x00009124 }, /* GL_MAX_GEOMETRY_OUTPUT_COMPONENTS */
+   { 22693, 0x00008DE0 }, /* GL_MAX_GEOMETRY_OUTPUT_VERTICES */
+   { 22725, 0x00008DE0 }, /* GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB */
+   { 22761, 0x00008C29 }, /* GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS */
+   { 22797, 0x00008C29 }, /* GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB */
+   { 22837, 0x00008DE1 }, /* GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS */
+   { 22877, 0x00008DE1 }, /* GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB */
+   { 22921, 0x00008DDF }, /* GL_MAX_GEOMETRY_UNIFORM_COMPONENTS */
+   { 22956, 0x00008DDF }, /* GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB */
+   { 22995, 0x00008DDD }, /* GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB */
+   { 23034, 0x00000D31 }, /* GL_MAX_LIGHTS */
+   { 23048, 0x00000B31 }, /* GL_MAX_LIST_NESTING */
+   { 23068, 0x00008841 }, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
+   { 23106, 0x00000D36 }, /* GL_MAX_MODELVIEW_STACK_DEPTH */
+   { 23135, 0x00000D37 }, /* GL_MAX_NAME_STACK_DEPTH */
+   { 23159, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_ARB */
+   { 23187, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_OES */
+   { 23215, 0x00000D34 }, /* GL_MAX_PIXEL_MAP_TABLE */
+   { 23238, 0x000088B1 }, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
+   { 23275, 0x0000880B }, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
+   { 23311, 0x000088AD }, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
+   { 23338, 0x000088F5 }, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
+   { 23367, 0x000088B5 }, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
+   { 23401, 0x000088F4 }, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */
+   { 23437, 0x000088F6 }, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
+   { 23464, 0x000088A1 }, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
+   { 23496, 0x000088B4 }, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
+   { 23532, 0x000088F8 }, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
+   { 23561, 0x000088F7 }, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
+   { 23590, 0x0000862F }, /* GL_MAX_PROGRAM_MATRICES_ARB */
+   { 23618, 0x0000862E }, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
+   { 23656, 0x000088B3 }, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+   { 23700, 0x0000880E }, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+   { 23743, 0x000088AF }, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
+   { 23777, 0x000088A3 }, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+   { 23816, 0x000088AB }, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
+   { 23853, 0x000088A7 }, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
+   { 23891, 0x00008810 }, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+   { 23934, 0x0000880F }, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+   { 23977, 0x000088A9 }, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
+   { 24007, 0x000088A5 }, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
+   { 24038, 0x00008905 }, /* GL_MAX_PROGRAM_TEXEL_OFFSET */
+   { 24066, 0x00008905 }, /* GL_MAX_PROGRAM_TEXEL_OFFSET_EXT */
+   { 24098, 0x0000880D }, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
+   { 24134, 0x0000880C }, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
+   { 24170, 0x00000D38 }, /* GL_MAX_PROJECTION_STACK_DEPTH */
+   { 24200, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE */
+   { 24230, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
+   { 24264, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_NV */
+   { 24297, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE */
+   { 24322, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
+   { 24351, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_OES */
+   { 24380, 0x00008D57 }, /* GL_MAX_SAMPLES */
+   { 24395, 0x00008D57 }, /* GL_MAX_SAMPLES_EXT */
+   { 24414, 0x00009111 }, /* GL_MAX_SERVER_WAIT_TIMEOUT */
+   { 24441, 0x00008504 }, /* GL_MAX_SHININESS_NV */
+   { 24461, 0x00008505 }, /* GL_MAX_SPOT_EXPONENT_NV */
+   { 24485, 0x00008C2B }, /* GL_MAX_TEXTURE_BUFFER_SIZE */
+   { 24512, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS */
+   { 24534, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS_ARB */
+   { 24560, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS */
+   { 24587, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS_ARB */
+   { 24618, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS */
+   { 24642, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS_EXT */
+   { 24670, 0x000084FF }, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
+   { 24704, 0x00000D33 }, /* GL_MAX_TEXTURE_SIZE */
+   { 24724, 0x00000D39 }, /* GL_MAX_TEXTURE_STACK_DEPTH */
+   { 24751, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS */
+   { 24772, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS_ARB */
+   { 24797, 0x0000862F }, /* GL_MAX_TRACK_MATRICES_NV */
+   { 24822, 0x0000862E }, /* GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */
+   { 24857, 0x00008C8A }, /* GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS */
+   { 24906, 0x00008C8A }, /* GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT */
+   { 24959, 0x00008C8B }, /* GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS */
+   { 25002, 0x00008C8B }, /* GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT */
+   { 25049, 0x00008C80 }, /* GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS */
+   { 25095, 0x00008C80 }, /* GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT */
+   { 25145, 0x00008B4B }, /* GL_MAX_VARYING_COMPONENTS */
+   { 25171, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS */
+   { 25193, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS_ARB */
+   { 25219, 0x00008DFC }, /* GL_MAX_VARYING_VECTORS */
+   { 25242, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS */
+   { 25264, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS_ARB */
+   { 25290, 0x00009122 }, /* GL_MAX_VERTEX_OUTPUT_COMPONENTS */
+   { 25322, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
+   { 25356, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */
+   { 25394, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
+   { 25427, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB */
+   { 25464, 0x00008DFB }, /* GL_MAX_VERTEX_UNIFORM_VECTORS */
+   { 25494, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_ARB */
+   { 25518, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_OES */
+   { 25542, 0x00008DDE }, /* GL_MAX_VERTEX_VARYING_COMPONENTS_ARB */
+   { 25579, 0x00000D3A }, /* GL_MAX_VIEWPORT_DIMS */
+   { 25600, 0x00008DF1 }, /* GL_MEDIUM_FLOAT */
+   { 25616, 0x00008DF4 }, /* GL_MEDIUM_INT */
+   { 25630, 0x00008007 }, /* GL_MIN */
+   { 25637, 0x0000802E }, /* GL_MINMAX */
+   { 25647, 0x0000802E }, /* GL_MINMAX_EXT */
+   { 25661, 0x0000802F }, /* GL_MINMAX_FORMAT */
+   { 25678, 0x0000802F }, /* GL_MINMAX_FORMAT_EXT */
+   { 25699, 0x00008030 }, /* GL_MINMAX_SINK */
+   { 25714, 0x00008030 }, /* GL_MINMAX_SINK_EXT */
+   { 25733, 0x0000821C }, /* GL_MINOR_VERSION */
+   { 25750, 0x00008007 }, /* GL_MIN_EXT */
+   { 25761, 0x00008904 }, /* GL_MIN_PROGRAM_TEXEL_OFFSET */
+   { 25789, 0x00008904 }, /* GL_MIN_PROGRAM_TEXEL_OFFSET_EXT */
+   { 25821, 0x00008370 }, /* GL_MIRRORED_REPEAT */
+   { 25840, 0x00008370 }, /* GL_MIRRORED_REPEAT_ARB */
+   { 25863, 0x00008370 }, /* GL_MIRRORED_REPEAT_IBM */
+   { 25886, 0x00008742 }, /* GL_MIRROR_CLAMP_ATI */
+   { 25906, 0x00008742 }, /* GL_MIRROR_CLAMP_EXT */
+   { 25926, 0x00008912 }, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
+   { 25956, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_ATI */
+   { 25984, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
+   { 26012, 0x00001700 }, /* GL_MODELVIEW */
+   { 26025, 0x00001700 }, /* GL_MODELVIEW0_ARB */
+   { 26043, 0x0000872A }, /* GL_MODELVIEW10_ARB */
+   { 26062, 0x0000872B }, /* GL_MODELVIEW11_ARB */
+   { 26081, 0x0000872C }, /* GL_MODELVIEW12_ARB */
+   { 26100, 0x0000872D }, /* GL_MODELVIEW13_ARB */
+   { 26119, 0x0000872E }, /* GL_MODELVIEW14_ARB */
+   { 26138, 0x0000872F }, /* GL_MODELVIEW15_ARB */
+   { 26157, 0x00008730 }, /* GL_MODELVIEW16_ARB */
+   { 26176, 0x00008731 }, /* GL_MODELVIEW17_ARB */
+   { 26195, 0x00008732 }, /* GL_MODELVIEW18_ARB */
+   { 26214, 0x00008733 }, /* GL_MODELVIEW19_ARB */
+   { 26233, 0x0000850A }, /* GL_MODELVIEW1_ARB */
+   { 26251, 0x00008734 }, /* GL_MODELVIEW20_ARB */
+   { 26270, 0x00008735 }, /* GL_MODELVIEW21_ARB */
+   { 26289, 0x00008736 }, /* GL_MODELVIEW22_ARB */
+   { 26308, 0x00008737 }, /* GL_MODELVIEW23_ARB */
+   { 26327, 0x00008738 }, /* GL_MODELVIEW24_ARB */
+   { 26346, 0x00008739 }, /* GL_MODELVIEW25_ARB */
+   { 26365, 0x0000873A }, /* GL_MODELVIEW26_ARB */
+   { 26384, 0x0000873B }, /* GL_MODELVIEW27_ARB */
+   { 26403, 0x0000873C }, /* GL_MODELVIEW28_ARB */
+   { 26422, 0x0000873D }, /* GL_MODELVIEW29_ARB */
+   { 26441, 0x00008722 }, /* GL_MODELVIEW2_ARB */
+   { 26459, 0x0000873E }, /* GL_MODELVIEW30_ARB */
+   { 26478, 0x0000873F }, /* GL_MODELVIEW31_ARB */
+   { 26497, 0x00008723 }, /* GL_MODELVIEW3_ARB */
+   { 26515, 0x00008724 }, /* GL_MODELVIEW4_ARB */
+   { 26533, 0x00008725 }, /* GL_MODELVIEW5_ARB */
+   { 26551, 0x00008726 }, /* GL_MODELVIEW6_ARB */
+   { 26569, 0x00008727 }, /* GL_MODELVIEW7_ARB */
+   { 26587, 0x00008728 }, /* GL_MODELVIEW8_ARB */
+   { 26605, 0x00008729 }, /* GL_MODELVIEW9_ARB */
+   { 26623, 0x00000BA6 }, /* GL_MODELVIEW_MATRIX */
+   { 26643, 0x0000898D }, /* GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES */
+   { 26685, 0x00008629 }, /* GL_MODELVIEW_PROJECTION_NV */
+   { 26712, 0x00000BA3 }, /* GL_MODELVIEW_STACK_DEPTH */
+   { 26737, 0x00002100 }, /* GL_MODULATE */
+   { 26749, 0x00008744 }, /* GL_MODULATE_ADD_ATI */
+   { 26769, 0x00008745 }, /* GL_MODULATE_SIGNED_ADD_ATI */
+   { 26796, 0x00008746 }, /* GL_MODULATE_SUBTRACT_ATI */
+   { 26821, 0x00000103 }, /* GL_MULT */
+   { 26829, 0x0000809D }, /* GL_MULTISAMPLE */
+   { 26844, 0x000086B2 }, /* GL_MULTISAMPLE_3DFX */
+   { 26864, 0x0000809D }, /* GL_MULTISAMPLE_ARB */
+   { 26883, 0x20000000 }, /* GL_MULTISAMPLE_BIT */
+   { 26902, 0x20000000 }, /* GL_MULTISAMPLE_BIT_3DFX */
+   { 26926, 0x20000000 }, /* GL_MULTISAMPLE_BIT_ARB */
+   { 26949, 0x00008534 }, /* GL_MULTISAMPLE_FILTER_HINT_NV */
+   { 26979, 0x00002A25 }, /* GL_N3F_V3F */
+   { 26990, 0x00000D70 }, /* GL_NAME_STACK_DEPTH */
+   { 27010, 0x0000150E }, /* GL_NAND */
+   { 27018, 0x00002600 }, /* GL_NEAREST */
+   { 27029, 0x0000844E }, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
+   { 27060, 0x0000844D }, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
+   { 27092, 0x00002702 }, /* GL_NEAREST_MIPMAP_LINEAR */
+   { 27117, 0x00002700 }, /* GL_NEAREST_MIPMAP_NEAREST */
+   { 27143, 0x00000200 }, /* GL_NEVER */
+   { 27152, 0x00001102 }, /* GL_NICEST */
+   { 27162, 0x00000000 }, /* GL_NONE */
+   { 27170, 0x00000000 }, /* GL_NONE_OES */
+   { 27182, 0x00001505 }, /* GL_NOOP */
+   { 27190, 0x00001508 }, /* GL_NOR */
+   { 27197, 0x00000BA1 }, /* GL_NORMALIZE */
+   { 27210, 0x00008075 }, /* GL_NORMAL_ARRAY */
+   { 27226, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
+   { 27257, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING_ARB */
+   { 27292, 0x0000808F }, /* GL_NORMAL_ARRAY_POINTER */
+   { 27316, 0x0000807F }, /* GL_NORMAL_ARRAY_STRIDE */
+   { 27339, 0x0000807E }, /* GL_NORMAL_ARRAY_TYPE */
+   { 27360, 0x00008511 }, /* GL_NORMAL_MAP */
+   { 27374, 0x00008511 }, /* GL_NORMAL_MAP_ARB */
+   { 27392, 0x00008511 }, /* GL_NORMAL_MAP_NV */
+   { 27409, 0x00008511 }, /* GL_NORMAL_MAP_OES */
+   { 27427, 0x00000205 }, /* GL_NOTEQUAL */
+   { 27439, 0x00000000 }, /* GL_NO_ERROR */
+   { 27451, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
+   { 27485, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB */
+   { 27523, 0x0000821D }, /* GL_NUM_EXTENSIONS */
+   { 27541, 0x000087FE }, /* GL_NUM_PROGRAM_BINARY_FORMATS_OES */
+   { 27575, 0x00008DF9 }, /* GL_NUM_SHADER_BINARY_FORMATS */
+   { 27604, 0x00008B89 }, /* GL_OBJECT_ACTIVE_ATTRIBUTES_ARB */
+   { 27636, 0x00008B8A }, /* GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB */
+   { 27678, 0x00008B86 }, /* GL_OBJECT_ACTIVE_UNIFORMS_ARB */
+   { 27708, 0x00008B87 }, /* GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB */
+   { 27748, 0x00008B85 }, /* GL_OBJECT_ATTACHED_OBJECTS_ARB */
+   { 27779, 0x00008B81 }, /* GL_OBJECT_COMPILE_STATUS_ARB */
+   { 27808, 0x00008B80 }, /* GL_OBJECT_DELETE_STATUS_ARB */
+   { 27836, 0x00008B84 }, /* GL_OBJECT_INFO_LOG_LENGTH_ARB */
+   { 27866, 0x00002401 }, /* GL_OBJECT_LINEAR */
+   { 27883, 0x00008B82 }, /* GL_OBJECT_LINK_STATUS_ARB */
+   { 27909, 0x00002501 }, /* GL_OBJECT_PLANE */
+   { 27925, 0x00008B88 }, /* GL_OBJECT_SHADER_SOURCE_LENGTH_ARB */
+   { 27960, 0x00008B4F }, /* GL_OBJECT_SUBTYPE_ARB */
+   { 27982, 0x00009112 }, /* GL_OBJECT_TYPE */
+   { 27997, 0x00008B4E }, /* GL_OBJECT_TYPE_ARB */
+   { 28016, 0x00008B83 }, /* GL_OBJECT_VALIDATE_STATUS_ARB */
+   { 28046, 0x00008165 }, /* GL_OCCLUSION_TEST_HP */
+   { 28067, 0x00008166 }, /* GL_OCCLUSION_TEST_RESULT_HP */
+   { 28095, 0x00000001 }, /* GL_ONE */
+   { 28102, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA */
+   { 28130, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA_EXT */
+   { 28162, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR */
+   { 28190, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR_EXT */
+   { 28222, 0x00000305 }, /* GL_ONE_MINUS_DST_ALPHA */
+   { 28245, 0x00000307 }, /* GL_ONE_MINUS_DST_COLOR */
+   { 28268, 0x00000303 }, /* GL_ONE_MINUS_SRC_ALPHA */
+   { 28291, 0x00000301 }, /* GL_ONE_MINUS_SRC_COLOR */
+   { 28314, 0x00008598 }, /* GL_OPERAND0_ALPHA */
+   { 28332, 0x00008598 }, /* GL_OPERAND0_ALPHA_ARB */
+   { 28354, 0x00008598 }, /* GL_OPERAND0_ALPHA_EXT */
+   { 28376, 0x00008590 }, /* GL_OPERAND0_RGB */
+   { 28392, 0x00008590 }, /* GL_OPERAND0_RGB_ARB */
+   { 28412, 0x00008590 }, /* GL_OPERAND0_RGB_EXT */
+   { 28432, 0x00008599 }, /* GL_OPERAND1_ALPHA */
+   { 28450, 0x00008599 }, /* GL_OPERAND1_ALPHA_ARB */
+   { 28472, 0x00008599 }, /* GL_OPERAND1_ALPHA_EXT */
+   { 28494, 0x00008591 }, /* GL_OPERAND1_RGB */
+   { 28510, 0x00008591 }, /* GL_OPERAND1_RGB_ARB */
+   { 28530, 0x00008591 }, /* GL_OPERAND1_RGB_EXT */
+   { 28550, 0x0000859A }, /* GL_OPERAND2_ALPHA */
+   { 28568, 0x0000859A }, /* GL_OPERAND2_ALPHA_ARB */
+   { 28590, 0x0000859A }, /* GL_OPERAND2_ALPHA_EXT */
+   { 28612, 0x00008592 }, /* GL_OPERAND2_RGB */
+   { 28628, 0x00008592 }, /* GL_OPERAND2_RGB_ARB */
+   { 28648, 0x00008592 }, /* GL_OPERAND2_RGB_EXT */
+   { 28668, 0x0000859B }, /* GL_OPERAND3_ALPHA_NV */
+   { 28689, 0x00008593 }, /* GL_OPERAND3_RGB_NV */
+   { 28708, 0x00001507 }, /* GL_OR */
+   { 28714, 0x00000A01 }, /* GL_ORDER */
+   { 28723, 0x0000150D }, /* GL_OR_INVERTED */
+   { 28738, 0x0000150B }, /* GL_OR_REVERSE */
+   { 28752, 0x00000505 }, /* GL_OUT_OF_MEMORY */
+   { 28769, 0x00000D05 }, /* GL_PACK_ALIGNMENT */
+   { 28787, 0x0000806C }, /* GL_PACK_IMAGE_HEIGHT */
+   { 28808, 0x00008758 }, /* GL_PACK_INVERT_MESA */
+   { 28828, 0x00000D01 }, /* GL_PACK_LSB_FIRST */
+   { 28846, 0x00000D02 }, /* GL_PACK_ROW_LENGTH */
+   { 28865, 0x0000806B }, /* GL_PACK_SKIP_IMAGES */
+   { 28885, 0x00000D04 }, /* GL_PACK_SKIP_PIXELS */
+   { 28905, 0x00000D03 }, /* GL_PACK_SKIP_ROWS */
+   { 28923, 0x00000D00 }, /* GL_PACK_SWAP_BYTES */
+   { 28942, 0x00008B92 }, /* GL_PALETTE4_R5_G6_B5_OES */
+   { 28967, 0x00008B94 }, /* GL_PALETTE4_RGB5_A1_OES */
+   { 28991, 0x00008B90 }, /* GL_PALETTE4_RGB8_OES */
+   { 29012, 0x00008B93 }, /* GL_PALETTE4_RGBA4_OES */
+   { 29034, 0x00008B91 }, /* GL_PALETTE4_RGBA8_OES */
+   { 29056, 0x00008B97 }, /* GL_PALETTE8_R5_G6_B5_OES */
+   { 29081, 0x00008B99 }, /* GL_PALETTE8_RGB5_A1_OES */
+   { 29105, 0x00008B95 }, /* GL_PALETTE8_RGB8_OES */
+   { 29126, 0x00008B98 }, /* GL_PALETTE8_RGBA4_OES */
+   { 29148, 0x00008B96 }, /* GL_PALETTE8_RGBA8_OES */
+   { 29170, 0x00000700 }, /* GL_PASS_THROUGH_TOKEN */
+   { 29192, 0x00000C50 }, /* GL_PERSPECTIVE_CORRECTION_HINT */
+   { 29223, 0x00000C79 }, /* GL_PIXEL_MAP_A_TO_A */
+   { 29243, 0x00000CB9 }, /* GL_PIXEL_MAP_A_TO_A_SIZE */
+   { 29268, 0x00000C78 }, /* GL_PIXEL_MAP_B_TO_B */
+   { 29288, 0x00000CB8 }, /* GL_PIXEL_MAP_B_TO_B_SIZE */
+   { 29313, 0x00000C77 }, /* GL_PIXEL_MAP_G_TO_G */
+   { 29333, 0x00000CB7 }, /* GL_PIXEL_MAP_G_TO_G_SIZE */
+   { 29358, 0x00000C75 }, /* GL_PIXEL_MAP_I_TO_A */
+   { 29378, 0x00000CB5 }, /* GL_PIXEL_MAP_I_TO_A_SIZE */
+   { 29403, 0x00000C74 }, /* GL_PIXEL_MAP_I_TO_B */
+   { 29423, 0x00000CB4 }, /* GL_PIXEL_MAP_I_TO_B_SIZE */
+   { 29448, 0x00000C73 }, /* GL_PIXEL_MAP_I_TO_G */
+   { 29468, 0x00000CB3 }, /* GL_PIXEL_MAP_I_TO_G_SIZE */
+   { 29493, 0x00000C70 }, /* GL_PIXEL_MAP_I_TO_I */
+   { 29513, 0x00000CB0 }, /* GL_PIXEL_MAP_I_TO_I_SIZE */
+   { 29538, 0x00000C72 }, /* GL_PIXEL_MAP_I_TO_R */
+   { 29558, 0x00000CB2 }, /* GL_PIXEL_MAP_I_TO_R_SIZE */
+   { 29583, 0x00000C76 }, /* GL_PIXEL_MAP_R_TO_R */
+   { 29603, 0x00000CB6 }, /* GL_PIXEL_MAP_R_TO_R_SIZE */
+   { 29628, 0x00000C71 }, /* GL_PIXEL_MAP_S_TO_S */
+   { 29648, 0x00000CB1 }, /* GL_PIXEL_MAP_S_TO_S_SIZE */
+   { 29673, 0x00000020 }, /* GL_PIXEL_MODE_BIT */
+   { 29691, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER */
+   { 29712, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING */
+   { 29741, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING_EXT */
+   { 29774, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER_EXT */
+   { 29799, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER */
+   { 29822, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING */
+   { 29853, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING_EXT */
+   { 29888, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER_EXT */
+   { 29915, 0x00001B00 }, /* GL_POINT */
+   { 29924, 0x00000000 }, /* GL_POINTS */
+   { 29934, 0x00000002 }, /* GL_POINT_BIT */
+   { 29947, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION */
+   { 29977, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_ARB */
+   { 30011, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_EXT */
+   { 30045, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_SGIS */
+   { 30080, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE */
+   { 30109, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_ARB */
+   { 30142, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_EXT */
+   { 30175, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_SGIS */
+   { 30209, 0x00000B11 }, /* GL_POINT_SIZE */
+   { 30223, 0x00008B9F }, /* GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES */
+   { 30262, 0x00008B9C }, /* GL_POINT_SIZE_ARRAY_OES */
+   { 30286, 0x0000898C }, /* GL_POINT_SIZE_ARRAY_POINTER_OES */
+   { 30318, 0x0000898B }, /* GL_POINT_SIZE_ARRAY_STRIDE_OES */
+   { 30349, 0x0000898A }, /* GL_POINT_SIZE_ARRAY_TYPE_OES */
+   { 30378, 0x00000B13 }, /* GL_POINT_SIZE_GRANULARITY */
+   { 30404, 0x00008127 }, /* GL_POINT_SIZE_MAX */
+   { 30422, 0x00008127 }, /* GL_POINT_SIZE_MAX_ARB */
+   { 30444, 0x00008127 }, /* GL_POINT_SIZE_MAX_EXT */
+   { 30466, 0x00008127 }, /* GL_POINT_SIZE_MAX_SGIS */
+   { 30489, 0x00008126 }, /* GL_POINT_SIZE_MIN */
+   { 30507, 0x00008126 }, /* GL_POINT_SIZE_MIN_ARB */
+   { 30529, 0x00008126 }, /* GL_POINT_SIZE_MIN_EXT */
+   { 30551, 0x00008126 }, /* GL_POINT_SIZE_MIN_SGIS */
+   { 30574, 0x00000B12 }, /* GL_POINT_SIZE_RANGE */
+   { 30594, 0x00000B10 }, /* GL_POINT_SMOOTH */
+   { 30610, 0x00000C51 }, /* GL_POINT_SMOOTH_HINT */
+   { 30631, 0x00008861 }, /* GL_POINT_SPRITE */
+   { 30647, 0x00008861 }, /* GL_POINT_SPRITE_ARB */
+   { 30667, 0x00008CA0 }, /* GL_POINT_SPRITE_COORD_ORIGIN */
+   { 30696, 0x00008861 }, /* GL_POINT_SPRITE_NV */
+   { 30715, 0x00008861 }, /* GL_POINT_SPRITE_OES */
+   { 30735, 0x00008863 }, /* GL_POINT_SPRITE_R_MODE_NV */
+   { 30761, 0x00000701 }, /* GL_POINT_TOKEN */
+   { 30776, 0x00000009 }, /* GL_POLYGON */
+   { 30787, 0x00000008 }, /* GL_POLYGON_BIT */
+   { 30802, 0x00000B40 }, /* GL_POLYGON_MODE */
+   { 30818, 0x00008039 }, /* GL_POLYGON_OFFSET_BIAS */
+   { 30841, 0x00008038 }, /* GL_POLYGON_OFFSET_FACTOR */
+   { 30866, 0x00008037 }, /* GL_POLYGON_OFFSET_FILL */
+   { 30889, 0x00002A02 }, /* GL_POLYGON_OFFSET_LINE */
+   { 30912, 0x00002A01 }, /* GL_POLYGON_OFFSET_POINT */
+   { 30936, 0x00002A00 }, /* GL_POLYGON_OFFSET_UNITS */
+   { 30960, 0x00000B41 }, /* GL_POLYGON_SMOOTH */
+   { 30978, 0x00000C53 }, /* GL_POLYGON_SMOOTH_HINT */
+   { 31001, 0x00000B42 }, /* GL_POLYGON_STIPPLE */
+   { 31020, 0x00000010 }, /* GL_POLYGON_STIPPLE_BIT */
+   { 31043, 0x00000703 }, /* GL_POLYGON_TOKEN */
+   { 31060, 0x00001203 }, /* GL_POSITION */
+   { 31072, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
+   { 31104, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI */
+   { 31140, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
+   { 31173, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI */
+   { 31210, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
+   { 31241, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI */
+   { 31276, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
+   { 31308, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI */
+   { 31344, 0x000080D2 }, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
+   { 31377, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
+   { 31409, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI */
+   { 31445, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
+   { 31478, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI */
+   { 31515, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS */
+   { 31545, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS_SGI */
+   { 31579, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE */
+   { 31610, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE_SGI */
+   { 31645, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
+   { 31676, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS_EXT */
+   { 31711, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
+   { 31743, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE_EXT */
+   { 31779, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS */
+   { 31809, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS_EXT */
+   { 31843, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE */
+   { 31874, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE_EXT */
+   { 31909, 0x000080D1 }, /* GL_POST_CONVOLUTION_COLOR_TABLE */
+   { 31941, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS */
+   { 31972, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS_EXT */
+   { 32007, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE */
+   { 32039, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE_EXT */
+   { 32075, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS */
+   { 32104, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS_EXT */
+   { 32137, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE */
+   { 32167, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE_EXT */
+   { 32201, 0x0000817B }, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
+   { 32240, 0x00008179 }, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
+   { 32273, 0x0000817C }, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
+   { 32313, 0x0000817A }, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
+   { 32347, 0x00008578 }, /* GL_PREVIOUS */
+   { 32359, 0x00008578 }, /* GL_PREVIOUS_ARB */
+   { 32375, 0x00008578 }, /* GL_PREVIOUS_EXT */
+   { 32391, 0x00008577 }, /* GL_PRIMARY_COLOR */
+   { 32408, 0x00008577 }, /* GL_PRIMARY_COLOR_ARB */
+   { 32429, 0x00008577 }, /* GL_PRIMARY_COLOR_EXT */
+   { 32450, 0x00008C87 }, /* GL_PRIMITIVES_GENERATED */
+   { 32474, 0x00008C87 }, /* GL_PRIMITIVES_GENERATED_EXT */
+   { 32502, 0x00008F9D }, /* GL_PRIMITIVE_RESTART */
+   { 32523, 0x00008F9E }, /* GL_PRIMITIVE_RESTART_INDEX */
+   { 32550, 0x00008559 }, /* GL_PRIMITIVE_RESTART_INDEX_NV */
+   { 32580, 0x00008558 }, /* GL_PRIMITIVE_RESTART_NV */
+   { 32604, 0x000088B0 }, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
+   { 32637, 0x00008805 }, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
+   { 32669, 0x000088AC }, /* GL_PROGRAM_ATTRIBS_ARB */
+   { 32692, 0x000087FF }, /* GL_PROGRAM_BINARY_FORMATS_OES */
+   { 32722, 0x00008741 }, /* GL_PROGRAM_BINARY_LENGTH_OES */
+   { 32751, 0x00008677 }, /* GL_PROGRAM_BINDING_ARB */
+   { 32774, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_ARB */
+   { 32804, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_NV */
+   { 32833, 0x00008874 }, /* GL_PROGRAM_ERROR_STRING_ARB */
+   { 32861, 0x00008876 }, /* GL_PROGRAM_FORMAT_ARB */
+   { 32883, 0x00008875 }, /* GL_PROGRAM_FORMAT_ASCII_ARB */
+   { 32911, 0x000088A0 }, /* GL_PROGRAM_INSTRUCTIONS_ARB */
+   { 32939, 0x00008627 }, /* GL_PROGRAM_LENGTH_ARB */
+   { 32961, 0x00008627 }, /* GL_PROGRAM_LENGTH_NV */
+   { 32982, 0x000088B2 }, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+   { 33022, 0x00008808 }, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+   { 33061, 0x000088AE }, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
+   { 33091, 0x000088A2 }, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+   { 33126, 0x000088AA }, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
+   { 33159, 0x000088A6 }, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
+   { 33193, 0x0000880A }, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+   { 33232, 0x00008809 }, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+   { 33271, 0x00008B40 }, /* GL_PROGRAM_OBJECT_ARB */
+   { 33293, 0x000088A8 }, /* GL_PROGRAM_PARAMETERS_ARB */
+   { 33319, 0x00008644 }, /* GL_PROGRAM_PARAMETER_NV */
+   { 33343, 0x00008642 }, /* GL_PROGRAM_POINT_SIZE */
+   { 33365, 0x00008642 }, /* GL_PROGRAM_POINT_SIZE_ARB */
+   { 33391, 0x00008647 }, /* GL_PROGRAM_RESIDENT_NV */
+   { 33414, 0x00008628 }, /* GL_PROGRAM_STRING_ARB */
+   { 33436, 0x00008628 }, /* GL_PROGRAM_STRING_NV */
+   { 33457, 0x00008646 }, /* GL_PROGRAM_TARGET_NV */
+   { 33478, 0x000088A4 }, /* GL_PROGRAM_TEMPORARIES_ARB */
+   { 33505, 0x00008807 }, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
+   { 33537, 0x00008806 }, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
+   { 33569, 0x000088B6 }, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
+   { 33604, 0x00001701 }, /* GL_PROJECTION */
+   { 33618, 0x00000BA7 }, /* GL_PROJECTION_MATRIX */
+   { 33639, 0x0000898E }, /* GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES */
+   { 33682, 0x00000BA4 }, /* GL_PROJECTION_STACK_DEPTH */
+   { 33708, 0x00008E4F }, /* GL_PROVOKING_VERTEX */
+   { 33728, 0x00008E4F }, /* GL_PROVOKING_VERTEX_EXT */
+   { 33752, 0x000080D3 }, /* GL_PROXY_COLOR_TABLE */
+   { 33773, 0x00008025 }, /* GL_PROXY_HISTOGRAM */
+   { 33792, 0x00008025 }, /* GL_PROXY_HISTOGRAM_EXT */
+   { 33815, 0x000080D5 }, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
+   { 33854, 0x000080D4 }, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
+   { 33892, 0x00008063 }, /* GL_PROXY_TEXTURE_1D */
+   { 33912, 0x00008C19 }, /* GL_PROXY_TEXTURE_1D_ARRAY */
+   { 33938, 0x00008C19 }, /* GL_PROXY_TEXTURE_1D_ARRAY_EXT */
+   { 33968, 0x00008063 }, /* GL_PROXY_TEXTURE_1D_EXT */
+   { 33992, 0x00008064 }, /* GL_PROXY_TEXTURE_2D */
+   { 34012, 0x00008C1B }, /* GL_PROXY_TEXTURE_2D_ARRAY */
+   { 34038, 0x00008C1B }, /* GL_PROXY_TEXTURE_2D_ARRAY_EXT */
+   { 34068, 0x00008064 }, /* GL_PROXY_TEXTURE_2D_EXT */
+   { 34092, 0x00008070 }, /* GL_PROXY_TEXTURE_3D */
+   { 34112, 0x000080BD }, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
+   { 34145, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP */
+   { 34171, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP_ARB */
+   { 34201, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE */
+   { 34228, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
+   { 34259, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_NV */
+   { 34289, 0x00008A1D }, /* GL_PURGEABLE_APPLE */
+   { 34308, 0x00002003 }, /* GL_Q */
+   { 34313, 0x00001209 }, /* GL_QUADRATIC_ATTENUATION */
+   { 34338, 0x00000007 }, /* GL_QUADS */
+   { 34347, 0x00008E4C }, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION */
+   { 34391, 0x00008E4C }, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT */
+   { 34439, 0x00008614 }, /* GL_QUAD_MESH_SUN */
+   { 34456, 0x00000008 }, /* GL_QUAD_STRIP */
+   { 34470, 0x00008E16 }, /* GL_QUERY_BY_REGION_NO_WAIT */
+   { 34497, 0x00008E16 }, /* GL_QUERY_BY_REGION_NO_WAIT_NV */
+   { 34527, 0x00008E15 }, /* GL_QUERY_BY_REGION_WAIT */
+   { 34551, 0x00008E15 }, /* GL_QUERY_BY_REGION_WAIT_NV */
+   { 34578, 0x00008864 }, /* GL_QUERY_COUNTER_BITS */
+   { 34600, 0x00008864 }, /* GL_QUERY_COUNTER_BITS_ARB */
+   { 34626, 0x00008E14 }, /* GL_QUERY_NO_WAIT */
+   { 34643, 0x00008E14 }, /* GL_QUERY_NO_WAIT_NV */
+   { 34663, 0x00008866 }, /* GL_QUERY_RESULT */
+   { 34679, 0x00008866 }, /* GL_QUERY_RESULT_ARB */
+   { 34699, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE */
+   { 34725, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE_ARB */
+   { 34755, 0x00008E13 }, /* GL_QUERY_WAIT */
+   { 34769, 0x00008E13 }, /* GL_QUERY_WAIT_NV */
+   { 34786, 0x00002002 }, /* GL_R */
+   { 34791, 0x00008C3A }, /* GL_R11F_G11F_B10F */
+   { 34809, 0x00008F98 }, /* GL_R16_SNORM */
+   { 34822, 0x00002A10 }, /* GL_R3_G3_B2 */
+   { 34834, 0x00008F94 }, /* GL_R8_SNORM */
+   { 34846, 0x00008C89 }, /* GL_RASTERIZER_DISCARD */
+   { 34868, 0x00008C89 }, /* GL_RASTERIZER_DISCARD_EXT */
+   { 34894, 0x00019262 }, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
+   { 34927, 0x00000C02 }, /* GL_READ_BUFFER */
+   { 34942, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER */
+   { 34962, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING */
+   { 34990, 0x00008CAA }, /* GL_READ_FRAMEBUFFER_BINDING_EXT */
+   { 35022, 0x00008CA8 }, /* GL_READ_FRAMEBUFFER_EXT */
+   { 35046, 0x000088B8 }, /* GL_READ_ONLY */
+   { 35059, 0x000088B8 }, /* GL_READ_ONLY_ARB */
+   { 35076, 0x000088BA }, /* GL_READ_WRITE */
+   { 35090, 0x000088BA }, /* GL_READ_WRITE_ARB */
+   { 35108, 0x00001903 }, /* GL_RED */
+   { 35115, 0x00008016 }, /* GL_REDUCE */
+   { 35125, 0x00008016 }, /* GL_REDUCE_EXT */
+   { 35139, 0x00000D15 }, /* GL_RED_BIAS */
+   { 35151, 0x00000D52 }, /* GL_RED_BITS */
+   { 35163, 0x00008D94 }, /* GL_RED_INTEGER */
+   { 35178, 0x00008D94 }, /* GL_RED_INTEGER_EXT */
+   { 35197, 0x00000D14 }, /* GL_RED_SCALE */
+   { 35210, 0x00008F90 }, /* GL_RED_SNORM */
+   { 35223, 0x00008512 }, /* GL_REFLECTION_MAP */
+   { 35241, 0x00008512 }, /* GL_REFLECTION_MAP_ARB */
+   { 35263, 0x00008512 }, /* GL_REFLECTION_MAP_NV */
+   { 35284, 0x00008512 }, /* GL_REFLECTION_MAP_OES */
+   { 35306, 0x00008A19 }, /* GL_RELEASED_APPLE */
+   { 35324, 0x00001C00 }, /* GL_RENDER */
+   { 35334, 0x00008D41 }, /* GL_RENDERBUFFER */
+   { 35350, 0x00008D53 }, /* GL_RENDERBUFFER_ALPHA_SIZE */
+   { 35377, 0x00008D53 }, /* GL_RENDERBUFFER_ALPHA_SIZE_OES */
+   { 35408, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING */
+   { 35432, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_EXT */
+   { 35460, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_OES */
+   { 35488, 0x00008D52 }, /* GL_RENDERBUFFER_BLUE_SIZE */
+   { 35514, 0x00008D52 }, /* GL_RENDERBUFFER_BLUE_SIZE_OES */
+   { 35544, 0x00008D54 }, /* GL_RENDERBUFFER_DEPTH_SIZE */
+   { 35571, 0x00008D54 }, /* GL_RENDERBUFFER_DEPTH_SIZE_OES */
+   { 35602, 0x00008D41 }, /* GL_RENDERBUFFER_EXT */
+   { 35622, 0x00008D51 }, /* GL_RENDERBUFFER_GREEN_SIZE */
+   { 35649, 0x00008D51 }, /* GL_RENDERBUFFER_GREEN_SIZE_OES */
+   { 35680, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT */
+   { 35703, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_EXT */
+   { 35730, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_OES */
+   { 35757, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT */
+   { 35789, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */
+   { 35825, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_OES */
+   { 35861, 0x00008D41 }, /* GL_RENDERBUFFER_OES */
+   { 35881, 0x00008D50 }, /* GL_RENDERBUFFER_RED_SIZE */
+   { 35906, 0x00008D50 }, /* GL_RENDERBUFFER_RED_SIZE_OES */
+   { 35935, 0x00008CAB }, /* GL_RENDERBUFFER_SAMPLES */
+   { 35959, 0x00008CAB }, /* GL_RENDERBUFFER_SAMPLES_EXT */
+   { 35987, 0x00008D55 }, /* GL_RENDERBUFFER_STENCIL_SIZE */
+   { 36016, 0x00008D55 }, /* GL_RENDERBUFFER_STENCIL_SIZE_OES */
+   { 36049, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH */
+   { 36071, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_EXT */
+   { 36097, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_OES */
+   { 36123, 0x00001F01 }, /* GL_RENDERER */
+   { 36135, 0x00000C40 }, /* GL_RENDER_MODE */
+   { 36150, 0x00002901 }, /* GL_REPEAT */
+   { 36160, 0x00001E01 }, /* GL_REPLACE */
+   { 36171, 0x00008062 }, /* GL_REPLACE_EXT */
+   { 36186, 0x00008153 }, /* GL_REPLICATE_BORDER_HP */
+   { 36209, 0x0000803A }, /* GL_RESCALE_NORMAL */
+   { 36227, 0x0000803A }, /* GL_RESCALE_NORMAL_EXT */
+   { 36249, 0x00008A1B }, /* GL_RETAINED_APPLE */
+   { 36267, 0x00000102 }, /* GL_RETURN */
+   { 36277, 0x00008F99 }, /* GL_RG16_SNORM */
+   { 36291, 0x00008F95 }, /* GL_RG8_SNORM */
+   { 36304, 0x00001907 }, /* GL_RGB */
+   { 36311, 0x00008052 }, /* GL_RGB10 */
+   { 36320, 0x00008059 }, /* GL_RGB10_A2 */
+   { 36332, 0x00008059 }, /* GL_RGB10_A2_EXT */
+   { 36348, 0x00008052 }, /* GL_RGB10_EXT */
+   { 36361, 0x00008053 }, /* GL_RGB12 */
+   { 36370, 0x00008053 }, /* GL_RGB12_EXT */
+   { 36383, 0x00008054 }, /* GL_RGB16 */
+   { 36392, 0x0000881B }, /* GL_RGB16F */
+   { 36402, 0x00008D89 }, /* GL_RGB16I */
+   { 36412, 0x00008D89 }, /* GL_RGB16I_EXT */
+   { 36426, 0x00008D77 }, /* GL_RGB16UI */
+   { 36437, 0x00008D77 }, /* GL_RGB16UI_EXT */
+   { 36452, 0x00008054 }, /* GL_RGB16_EXT */
+   { 36465, 0x00008F9A }, /* GL_RGB16_SNORM */
+   { 36480, 0x0000804E }, /* GL_RGB2_EXT */
+   { 36492, 0x00008815 }, /* GL_RGB32F */
+   { 36502, 0x00008D83 }, /* GL_RGB32I */
+   { 36512, 0x00008D83 }, /* GL_RGB32I_EXT */
+   { 36526, 0x00008D71 }, /* GL_RGB32UI */
+   { 36537, 0x00008D71 }, /* GL_RGB32UI_EXT */
+   { 36552, 0x0000804F }, /* GL_RGB4 */
+   { 36560, 0x0000804F }, /* GL_RGB4_EXT */
+   { 36572, 0x000083A1 }, /* GL_RGB4_S3TC */
+   { 36585, 0x00008050 }, /* GL_RGB5 */
+   { 36593, 0x00008D62 }, /* GL_RGB565 */
+   { 36603, 0x00008D62 }, /* GL_RGB565_OES */
+   { 36617, 0x00008057 }, /* GL_RGB5_A1 */
+   { 36628, 0x00008057 }, /* GL_RGB5_A1_EXT */
+   { 36643, 0x00008057 }, /* GL_RGB5_A1_OES */
+   { 36658, 0x00008050 }, /* GL_RGB5_EXT */
+   { 36670, 0x00008051 }, /* GL_RGB8 */
+   { 36678, 0x00008D8F }, /* GL_RGB8I */
+   { 36687, 0x00008D8F }, /* GL_RGB8I_EXT */
+   { 36700, 0x00008D7D }, /* GL_RGB8UI */
+   { 36710, 0x00008D7D }, /* GL_RGB8UI_EXT */
+   { 36724, 0x00008051 }, /* GL_RGB8_EXT */
+   { 36736, 0x00008051 }, /* GL_RGB8_OES */
+   { 36748, 0x00008F96 }, /* GL_RGB8_SNORM */
+   { 36762, 0x00008C3D }, /* GL_RGB9_E5 */
+   { 36773, 0x00001908 }, /* GL_RGBA */
+   { 36781, 0x0000805A }, /* GL_RGBA12 */
+   { 36791, 0x0000805A }, /* GL_RGBA12_EXT */
+   { 36805, 0x0000805B }, /* GL_RGBA16 */
+   { 36815, 0x0000881A }, /* GL_RGBA16F */
+   { 36826, 0x00008D88 }, /* GL_RGBA16I */
+   { 36837, 0x00008D88 }, /* GL_RGBA16I_EXT */
+   { 36852, 0x00008D76 }, /* GL_RGBA16UI */
+   { 36864, 0x00008D76 }, /* GL_RGBA16UI_EXT */
+   { 36880, 0x0000805B }, /* GL_RGBA16_EXT */
+   { 36894, 0x00008F9B }, /* GL_RGBA16_SNORM */
+   { 36910, 0x00008055 }, /* GL_RGBA2 */
+   { 36919, 0x00008055 }, /* GL_RGBA2_EXT */
+   { 36932, 0x00008814 }, /* GL_RGBA32F */
+   { 36943, 0x00008D82 }, /* GL_RGBA32I */
+   { 36954, 0x00008D82 }, /* GL_RGBA32I_EXT */
+   { 36969, 0x00008D70 }, /* GL_RGBA32UI */
+   { 36981, 0x00008D70 }, /* GL_RGBA32UI_EXT */
+   { 36997, 0x00008056 }, /* GL_RGBA4 */
+   { 37006, 0x000083A5 }, /* GL_RGBA4_DXT5_S3TC */
+   { 37025, 0x00008056 }, /* GL_RGBA4_EXT */
+   { 37038, 0x00008056 }, /* GL_RGBA4_OES */
+   { 37051, 0x000083A3 }, /* GL_RGBA4_S3TC */
+   { 37065, 0x00008058 }, /* GL_RGBA8 */
+   { 37074, 0x00008D8E }, /* GL_RGBA8I */
+   { 37084, 0x00008D8E }, /* GL_RGBA8I_EXT */
+   { 37098, 0x00008D7C }, /* GL_RGBA8UI */
+   { 37109, 0x00008D7C }, /* GL_RGBA8UI_EXT */
+   { 37124, 0x00008058 }, /* GL_RGBA8_EXT */
+   { 37137, 0x00008058 }, /* GL_RGBA8_OES */
+   { 37150, 0x00008F97 }, /* GL_RGBA8_SNORM */
+   { 37165, 0x000083A4 }, /* GL_RGBA_DXT5_S3TC */
+   { 37183, 0x00008820 }, /* GL_RGBA_FLOAT_MODE_ARB */
+   { 37206, 0x00008D99 }, /* GL_RGBA_INTEGER */
+   { 37222, 0x00008D99 }, /* GL_RGBA_INTEGER_EXT */
+   { 37242, 0x00008D9E }, /* GL_RGBA_INTEGER_MODE_EXT */
+   { 37267, 0x00000C31 }, /* GL_RGBA_MODE */
+   { 37280, 0x000083A2 }, /* GL_RGBA_S3TC */
+   { 37293, 0x00008F93 }, /* GL_RGBA_SNORM */
+   { 37307, 0x00008D98 }, /* GL_RGB_INTEGER */
+   { 37322, 0x00008D98 }, /* GL_RGB_INTEGER_EXT */
+   { 37341, 0x000083A0 }, /* GL_RGB_S3TC */
+   { 37353, 0x00008573 }, /* GL_RGB_SCALE */
+   { 37366, 0x00008573 }, /* GL_RGB_SCALE_ARB */
+   { 37383, 0x00008573 }, /* GL_RGB_SCALE_EXT */
+   { 37400, 0x00008F92 }, /* GL_RGB_SNORM */
+   { 37413, 0x00008F91 }, /* GL_RG_SNORM */
+   { 37425, 0x00000407 }, /* GL_RIGHT */
+   { 37434, 0x00002000 }, /* GL_S */
+   { 37439, 0x00008B5D }, /* GL_SAMPLER_1D */
+   { 37453, 0x00008DC0 }, /* GL_SAMPLER_1D_ARRAY */
+   { 37473, 0x00008DC0 }, /* GL_SAMPLER_1D_ARRAY_EXT */
+   { 37497, 0x00008DC3 }, /* GL_SAMPLER_1D_ARRAY_SHADOW */
+   { 37524, 0x00008DC3 }, /* GL_SAMPLER_1D_ARRAY_SHADOW_EXT */
+   { 37555, 0x00008B61 }, /* GL_SAMPLER_1D_SHADOW */
+   { 37576, 0x00008B5E }, /* GL_SAMPLER_2D */
+   { 37590, 0x00008DC1 }, /* GL_SAMPLER_2D_ARRAY */
+   { 37610, 0x00008DC1 }, /* GL_SAMPLER_2D_ARRAY_EXT */
+   { 37634, 0x00008DC4 }, /* GL_SAMPLER_2D_ARRAY_SHADOW */
+   { 37661, 0x00008DC4 }, /* GL_SAMPLER_2D_ARRAY_SHADOW_EXT */
+   { 37692, 0x00008B63 }, /* GL_SAMPLER_2D_RECT */
+   { 37711, 0x00008B64 }, /* GL_SAMPLER_2D_RECT_SHADOW */
+   { 37737, 0x00008B62 }, /* GL_SAMPLER_2D_SHADOW */
+   { 37758, 0x00008B5F }, /* GL_SAMPLER_3D */
+   { 37772, 0x00008B5F }, /* GL_SAMPLER_3D_OES */
+   { 37790, 0x00008DC2 }, /* GL_SAMPLER_BUFFER */
+   { 37808, 0x00008DC2 }, /* GL_SAMPLER_BUFFER_EXT */
+   { 37830, 0x00008B60 }, /* GL_SAMPLER_CUBE */
+   { 37846, 0x00008DC5 }, /* GL_SAMPLER_CUBE_SHADOW */
+   { 37869, 0x00008DC5 }, /* GL_SAMPLER_CUBE_SHADOW_EXT */
+   { 37896, 0x000080A9 }, /* GL_SAMPLES */
+   { 37907, 0x000086B4 }, /* GL_SAMPLES_3DFX */
+   { 37923, 0x000080A9 }, /* GL_SAMPLES_ARB */
+   { 37938, 0x00008914 }, /* GL_SAMPLES_PASSED */
+   { 37956, 0x00008914 }, /* GL_SAMPLES_PASSED_ARB */
+   { 37978, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
+   { 38006, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE_ARB */
+   { 38038, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE */
+   { 38061, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE_ARB */
+   { 38088, 0x000080A8 }, /* GL_SAMPLE_BUFFERS */
+   { 38106, 0x000086B3 }, /* GL_SAMPLE_BUFFERS_3DFX */
+   { 38129, 0x000080A8 }, /* GL_SAMPLE_BUFFERS_ARB */
+   { 38151, 0x000080A0 }, /* GL_SAMPLE_COVERAGE */
+   { 38170, 0x000080A0 }, /* GL_SAMPLE_COVERAGE_ARB */
+   { 38193, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT */
+   { 38219, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT_ARB */
+   { 38249, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE */
+   { 38274, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE_ARB */
+   { 38303, 0x00080000 }, /* GL_SCISSOR_BIT */
+   { 38318, 0x00000C10 }, /* GL_SCISSOR_BOX */
+   { 38333, 0x00000C11 }, /* GL_SCISSOR_TEST */
+   { 38349, 0x0000845E }, /* GL_SECONDARY_COLOR_ARRAY */
+   { 38374, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
+   { 38414, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB */
+   { 38458, 0x0000845D }, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
+   { 38491, 0x0000845A }, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
+   { 38521, 0x0000845C }, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
+   { 38553, 0x0000845B }, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
+   { 38583, 0x00001C02 }, /* GL_SELECT */
+   { 38593, 0x00000DF3 }, /* GL_SELECTION_BUFFER_POINTER */
+   { 38621, 0x00000DF4 }, /* GL_SELECTION_BUFFER_SIZE */
+   { 38646, 0x00008012 }, /* GL_SEPARABLE_2D */
+   { 38662, 0x00008C8D }, /* GL_SEPARATE_ATTRIBS */
+   { 38682, 0x00008C8D }, /* GL_SEPARATE_ATTRIBS_EXT */
+   { 38706, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR */
+   { 38733, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR_EXT */
+   { 38764, 0x0000150F }, /* GL_SET */
+   { 38771, 0x00008DF8 }, /* GL_SHADER_BINARY_FORMATS */
+   { 38796, 0x00008DFA }, /* GL_SHADER_COMPILER */
+   { 38815, 0x00008B48 }, /* GL_SHADER_OBJECT_ARB */
+   { 38836, 0x00008B88 }, /* GL_SHADER_SOURCE_LENGTH */
+   { 38860, 0x00008B4F }, /* GL_SHADER_TYPE */
+   { 38875, 0x00000B54 }, /* GL_SHADE_MODEL */
+   { 38890, 0x00008B8C }, /* GL_SHADING_LANGUAGE_VERSION */
+   { 38918, 0x000080BF }, /* GL_SHADOW_AMBIENT_SGIX */
+   { 38941, 0x000081FB }, /* GL_SHARED_TEXTURE_PALETTE_EXT */
+   { 38971, 0x00001601 }, /* GL_SHININESS */
+   { 38984, 0x00001402 }, /* GL_SHORT */
+   { 38993, 0x00009119 }, /* GL_SIGNALED */
+   { 39005, 0x00008F9C }, /* GL_SIGNED_NORMALIZED */
+   { 39026, 0x000081F9 }, /* GL_SINGLE_COLOR */
+   { 39042, 0x000081F9 }, /* GL_SINGLE_COLOR_EXT */
+   { 39062, 0x000085CC }, /* GL_SLICE_ACCUM_SUN */
+   { 39081, 0x00008C46 }, /* GL_SLUMINANCE */
+   { 39095, 0x00008C47 }, /* GL_SLUMINANCE8 */
+   { 39110, 0x00008C45 }, /* GL_SLUMINANCE8_ALPHA8 */
+   { 39132, 0x00008C44 }, /* GL_SLUMINANCE_ALPHA */
+   { 39152, 0x00001D01 }, /* GL_SMOOTH */
+   { 39162, 0x00000B23 }, /* GL_SMOOTH_LINE_WIDTH_GRANULARITY */
+   { 39195, 0x00000B22 }, /* GL_SMOOTH_LINE_WIDTH_RANGE */
+   { 39222, 0x00000B13 }, /* GL_SMOOTH_POINT_SIZE_GRANULARITY */
+   { 39255, 0x00000B12 }, /* GL_SMOOTH_POINT_SIZE_RANGE */
+   { 39282, 0x00008588 }, /* GL_SOURCE0_ALPHA */
+   { 39299, 0x00008588 }, /* GL_SOURCE0_ALPHA_ARB */
+   { 39320, 0x00008588 }, /* GL_SOURCE0_ALPHA_EXT */
+   { 39341, 0x00008580 }, /* GL_SOURCE0_RGB */
+   { 39356, 0x00008580 }, /* GL_SOURCE0_RGB_ARB */
+   { 39375, 0x00008580 }, /* GL_SOURCE0_RGB_EXT */
+   { 39394, 0x00008589 }, /* GL_SOURCE1_ALPHA */
+   { 39411, 0x00008589 }, /* GL_SOURCE1_ALPHA_ARB */
+   { 39432, 0x00008589 }, /* GL_SOURCE1_ALPHA_EXT */
+   { 39453, 0x00008581 }, /* GL_SOURCE1_RGB */
+   { 39468, 0x00008581 }, /* GL_SOURCE1_RGB_ARB */
+   { 39487, 0x00008581 }, /* GL_SOURCE1_RGB_EXT */
+   { 39506, 0x0000858A }, /* GL_SOURCE2_ALPHA */
+   { 39523, 0x0000858A }, /* GL_SOURCE2_ALPHA_ARB */
+   { 39544, 0x0000858A }, /* GL_SOURCE2_ALPHA_EXT */
+   { 39565, 0x00008582 }, /* GL_SOURCE2_RGB */
+   { 39580, 0x00008582 }, /* GL_SOURCE2_RGB_ARB */
+   { 39599, 0x00008582 }, /* GL_SOURCE2_RGB_EXT */
+   { 39618, 0x0000858B }, /* GL_SOURCE3_ALPHA_NV */
+   { 39638, 0x00008583 }, /* GL_SOURCE3_RGB_NV */
+   { 39656, 0x00001202 }, /* GL_SPECULAR */
+   { 39668, 0x00002402 }, /* GL_SPHERE_MAP */
+   { 39682, 0x00001206 }, /* GL_SPOT_CUTOFF */
+   { 39697, 0x00001204 }, /* GL_SPOT_DIRECTION */
+   { 39715, 0x00001205 }, /* GL_SPOT_EXPONENT */
+   { 39732, 0x00008588 }, /* GL_SRC0_ALPHA */
+   { 39746, 0x00008580 }, /* GL_SRC0_RGB */
+   { 39758, 0x00008589 }, /* GL_SRC1_ALPHA */
+   { 39772, 0x00008581 }, /* GL_SRC1_RGB */
+   { 39784, 0x0000858A }, /* GL_SRC2_ALPHA */
+   { 39798, 0x00008582 }, /* GL_SRC2_RGB */
+   { 39810, 0x00000302 }, /* GL_SRC_ALPHA */
+   { 39823, 0x00000308 }, /* GL_SRC_ALPHA_SATURATE */
+   { 39845, 0x00000300 }, /* GL_SRC_COLOR */
+   { 39858, 0x00008C40 }, /* GL_SRGB */
+   { 39866, 0x00008C41 }, /* GL_SRGB8 */
+   { 39875, 0x00008C43 }, /* GL_SRGB8_ALPHA8 */
+   { 39891, 0x00008C42 }, /* GL_SRGB_ALPHA */
+   { 39905, 0x00000503 }, /* GL_STACK_OVERFLOW */
+   { 39923, 0x00000504 }, /* GL_STACK_UNDERFLOW */
+   { 39942, 0x000088E6 }, /* GL_STATIC_COPY */
+   { 39957, 0x000088E6 }, /* GL_STATIC_COPY_ARB */
+   { 39976, 0x000088E4 }, /* GL_STATIC_DRAW */
+   { 39991, 0x000088E4 }, /* GL_STATIC_DRAW_ARB */
+   { 40010, 0x000088E5 }, /* GL_STATIC_READ */
+   { 40025, 0x000088E5 }, /* GL_STATIC_READ_ARB */
+   { 40044, 0x00001802 }, /* GL_STENCIL */
+   { 40055, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT */
+   { 40077, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_EXT */
+   { 40103, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_OES */
+   { 40129, 0x00008801 }, /* GL_STENCIL_BACK_FAIL */
+   { 40150, 0x00008801 }, /* GL_STENCIL_BACK_FAIL_ATI */
+   { 40175, 0x00008800 }, /* GL_STENCIL_BACK_FUNC */
+   { 40196, 0x00008800 }, /* GL_STENCIL_BACK_FUNC_ATI */
+   { 40221, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
+   { 40253, 0x00008802 }, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI */
+   { 40289, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
+   { 40321, 0x00008803 }, /* GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI */
+   { 40357, 0x00008CA3 }, /* GL_STENCIL_BACK_REF */
+   { 40377, 0x00008CA4 }, /* GL_STENCIL_BACK_VALUE_MASK */
+   { 40404, 0x00008CA5 }, /* GL_STENCIL_BACK_WRITEMASK */
+   { 40430, 0x00000D57 }, /* GL_STENCIL_BITS */
+   { 40446, 0x00008224 }, /* GL_STENCIL_BUFFER */
+   { 40464, 0x00000400 }, /* GL_STENCIL_BUFFER_BIT */
+   { 40486, 0x00000B91 }, /* GL_STENCIL_CLEAR_VALUE */
+   { 40509, 0x00000B94 }, /* GL_STENCIL_FAIL */
+   { 40525, 0x00000B92 }, /* GL_STENCIL_FUNC */
+   { 40541, 0x00001901 }, /* GL_STENCIL_INDEX */
+   { 40558, 0x00008D46 }, /* GL_STENCIL_INDEX1 */
+   { 40576, 0x00008D49 }, /* GL_STENCIL_INDEX16 */
+   { 40595, 0x00008D49 }, /* GL_STENCIL_INDEX16_EXT */
+   { 40618, 0x00008D46 }, /* GL_STENCIL_INDEX1_EXT */
+   { 40640, 0x00008D46 }, /* GL_STENCIL_INDEX1_OES */
+   { 40662, 0x00008D47 }, /* GL_STENCIL_INDEX4 */
+   { 40680, 0x00008D47 }, /* GL_STENCIL_INDEX4_EXT */
+   { 40702, 0x00008D47 }, /* GL_STENCIL_INDEX4_OES */
+   { 40724, 0x00008D48 }, /* GL_STENCIL_INDEX8 */
+   { 40742, 0x00008D48 }, /* GL_STENCIL_INDEX8_EXT */
+   { 40764, 0x00008D48 }, /* GL_STENCIL_INDEX8_OES */
+   { 40786, 0x00008D45 }, /* GL_STENCIL_INDEX_EXT */
+   { 40807, 0x00000B95 }, /* GL_STENCIL_PASS_DEPTH_FAIL */
+   { 40834, 0x00000B96 }, /* GL_STENCIL_PASS_DEPTH_PASS */
+   { 40861, 0x00000B97 }, /* GL_STENCIL_REF */
+   { 40876, 0x00000B90 }, /* GL_STENCIL_TEST */
+   { 40892, 0x00008910 }, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
+   { 40921, 0x00000B93 }, /* GL_STENCIL_VALUE_MASK */
+   { 40943, 0x00000B98 }, /* GL_STENCIL_WRITEMASK */
+   { 40964, 0x00000C33 }, /* GL_STEREO */
+   { 40974, 0x000085BE }, /* GL_STORAGE_CACHED_APPLE */
+   { 40998, 0x000085BD }, /* GL_STORAGE_PRIVATE_APPLE */
+   { 41023, 0x000085BF }, /* GL_STORAGE_SHARED_APPLE */
+   { 41047, 0x000088E2 }, /* GL_STREAM_COPY */
+   { 41062, 0x000088E2 }, /* GL_STREAM_COPY_ARB */
+   { 41081, 0x000088E0 }, /* GL_STREAM_DRAW */
+   { 41096, 0x000088E0 }, /* GL_STREAM_DRAW_ARB */
+   { 41115, 0x000088E1 }, /* GL_STREAM_READ */
+   { 41130, 0x000088E1 }, /* GL_STREAM_READ_ARB */
+   { 41149, 0x00000D50 }, /* GL_SUBPIXEL_BITS */
+   { 41166, 0x000084E7 }, /* GL_SUBTRACT */
+   { 41178, 0x000084E7 }, /* GL_SUBTRACT_ARB */
+   { 41194, 0x00009113 }, /* GL_SYNC_CONDITION */
+   { 41212, 0x00009116 }, /* GL_SYNC_FENCE */
+   { 41226, 0x00009115 }, /* GL_SYNC_FLAGS */
+   { 41240, 0x00000001 }, /* GL_SYNC_FLUSH_COMMANDS_BIT */
+   { 41267, 0x00009117 }, /* GL_SYNC_GPU_COMMANDS_COMPLETE */
+   { 41297, 0x00009114 }, /* GL_SYNC_STATUS */
+   { 41312, 0x00002001 }, /* GL_T */
+   { 41317, 0x00002A2A }, /* GL_T2F_C3F_V3F */
+   { 41332, 0x00002A2C }, /* GL_T2F_C4F_N3F_V3F */
+   { 41351, 0x00002A29 }, /* GL_T2F_C4UB_V3F */
+   { 41367, 0x00002A2B }, /* GL_T2F_N3F_V3F */
+   { 41382, 0x00002A27 }, /* GL_T2F_V3F */
+   { 41393, 0x00002A2D }, /* GL_T4F_C4F_N3F_V4F */
+   { 41412, 0x00002A28 }, /* GL_T4F_V4F */
+   { 41423, 0x00008031 }, /* GL_TABLE_TOO_LARGE_EXT */
+   { 41446, 0x00001702 }, /* GL_TEXTURE */
+   { 41457, 0x000084C0 }, /* GL_TEXTURE0 */
+   { 41469, 0x000084C0 }, /* GL_TEXTURE0_ARB */
+   { 41485, 0x000084C1 }, /* GL_TEXTURE1 */
+   { 41497, 0x000084CA }, /* GL_TEXTURE10 */
+   { 41510, 0x000084CA }, /* GL_TEXTURE10_ARB */
+   { 41527, 0x000084CB }, /* GL_TEXTURE11 */
+   { 41540, 0x000084CB }, /* GL_TEXTURE11_ARB */
+   { 41557, 0x000084CC }, /* GL_TEXTURE12 */
+   { 41570, 0x000084CC }, /* GL_TEXTURE12_ARB */
+   { 41587, 0x000084CD }, /* GL_TEXTURE13 */
+   { 41600, 0x000084CD }, /* GL_TEXTURE13_ARB */
+   { 41617, 0x000084CE }, /* GL_TEXTURE14 */
+   { 41630, 0x000084CE }, /* GL_TEXTURE14_ARB */
+   { 41647, 0x000084CF }, /* GL_TEXTURE15 */
+   { 41660, 0x000084CF }, /* GL_TEXTURE15_ARB */
+   { 41677, 0x000084D0 }, /* GL_TEXTURE16 */
+   { 41690, 0x000084D0 }, /* GL_TEXTURE16_ARB */
+   { 41707, 0x000084D1 }, /* GL_TEXTURE17 */
+   { 41720, 0x000084D1 }, /* GL_TEXTURE17_ARB */
+   { 41737, 0x000084D2 }, /* GL_TEXTURE18 */
+   { 41750, 0x000084D2 }, /* GL_TEXTURE18_ARB */
+   { 41767, 0x000084D3 }, /* GL_TEXTURE19 */
+   { 41780, 0x000084D3 }, /* GL_TEXTURE19_ARB */
+   { 41797, 0x000084C1 }, /* GL_TEXTURE1_ARB */
+   { 41813, 0x000084C2 }, /* GL_TEXTURE2 */
+   { 41825, 0x000084D4 }, /* GL_TEXTURE20 */
+   { 41838, 0x000084D4 }, /* GL_TEXTURE20_ARB */
+   { 41855, 0x000084D5 }, /* GL_TEXTURE21 */
+   { 41868, 0x000084D5 }, /* GL_TEXTURE21_ARB */
+   { 41885, 0x000084D6 }, /* GL_TEXTURE22 */
+   { 41898, 0x000084D6 }, /* GL_TEXTURE22_ARB */
+   { 41915, 0x000084D7 }, /* GL_TEXTURE23 */
+   { 41928, 0x000084D7 }, /* GL_TEXTURE23_ARB */
+   { 41945, 0x000084D8 }, /* GL_TEXTURE24 */
+   { 41958, 0x000084D8 }, /* GL_TEXTURE24_ARB */
+   { 41975, 0x000084D9 }, /* GL_TEXTURE25 */
+   { 41988, 0x000084D9 }, /* GL_TEXTURE25_ARB */
+   { 42005, 0x000084DA }, /* GL_TEXTURE26 */
+   { 42018, 0x000084DA }, /* GL_TEXTURE26_ARB */
+   { 42035, 0x000084DB }, /* GL_TEXTURE27 */
+   { 42048, 0x000084DB }, /* GL_TEXTURE27_ARB */
+   { 42065, 0x000084DC }, /* GL_TEXTURE28 */
+   { 42078, 0x000084DC }, /* GL_TEXTURE28_ARB */
+   { 42095, 0x000084DD }, /* GL_TEXTURE29 */
+   { 42108, 0x000084DD }, /* GL_TEXTURE29_ARB */
+   { 42125, 0x000084C2 }, /* GL_TEXTURE2_ARB */
+   { 42141, 0x000084C3 }, /* GL_TEXTURE3 */
+   { 42153, 0x000084DE }, /* GL_TEXTURE30 */
+   { 42166, 0x000084DE }, /* GL_TEXTURE30_ARB */
+   { 42183, 0x000084DF }, /* GL_TEXTURE31 */
+   { 42196, 0x000084DF }, /* GL_TEXTURE31_ARB */
+   { 42213, 0x000084C3 }, /* GL_TEXTURE3_ARB */
+   { 42229, 0x000084C4 }, /* GL_TEXTURE4 */
+   { 42241, 0x000084C4 }, /* GL_TEXTURE4_ARB */
+   { 42257, 0x000084C5 }, /* GL_TEXTURE5 */
+   { 42269, 0x000084C5 }, /* GL_TEXTURE5_ARB */
+   { 42285, 0x000084C6 }, /* GL_TEXTURE6 */
+   { 42297, 0x000084C6 }, /* GL_TEXTURE6_ARB */
+   { 42313, 0x000084C7 }, /* GL_TEXTURE7 */
+   { 42325, 0x000084C7 }, /* GL_TEXTURE7_ARB */
+   { 42341, 0x000084C8 }, /* GL_TEXTURE8 */
+   { 42353, 0x000084C8 }, /* GL_TEXTURE8_ARB */
+   { 42369, 0x000084C9 }, /* GL_TEXTURE9 */
+   { 42381, 0x000084C9 }, /* GL_TEXTURE9_ARB */
+   { 42397, 0x00000DE0 }, /* GL_TEXTURE_1D */
+   { 42411, 0x00008C18 }, /* GL_TEXTURE_1D_ARRAY */
+   { 42431, 0x00008C18 }, /* GL_TEXTURE_1D_ARRAY_EXT */
+   { 42455, 0x00000DE1 }, /* GL_TEXTURE_2D */
+   { 42469, 0x00008C1A }, /* GL_TEXTURE_2D_ARRAY */
+   { 42489, 0x00008C1A }, /* GL_TEXTURE_2D_ARRAY_EXT */
+   { 42513, 0x0000806F }, /* GL_TEXTURE_3D */
+   { 42527, 0x0000806F }, /* GL_TEXTURE_3D_OES */
+   { 42545, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE */
+   { 42567, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE_EXT */
+   { 42593, 0x0000813C }, /* GL_TEXTURE_BASE_LEVEL */
+   { 42615, 0x00008068 }, /* GL_TEXTURE_BINDING_1D */
+   { 42637, 0x00008C1C }, /* GL_TEXTURE_BINDING_1D_ARRAY */
+   { 42665, 0x00008C1C }, /* GL_TEXTURE_BINDING_1D_ARRAY_EXT */
+   { 42697, 0x00008069 }, /* GL_TEXTURE_BINDING_2D */
+   { 42719, 0x00008C1D }, /* GL_TEXTURE_BINDING_2D_ARRAY */
+   { 42747, 0x00008C1D }, /* GL_TEXTURE_BINDING_2D_ARRAY_EXT */
+   { 42779, 0x0000806A }, /* GL_TEXTURE_BINDING_3D */
+   { 42801, 0x0000806A }, /* GL_TEXTURE_BINDING_3D_OES */
+   { 42827, 0x00008C2C }, /* GL_TEXTURE_BINDING_BUFFER */
+   { 42853, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP */
+   { 42881, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_ARB */
+   { 42913, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_OES */
+   { 42945, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE */
+   { 42974, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
+   { 43007, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_NV */
+   { 43039, 0x00040000 }, /* GL_TEXTURE_BIT */
+   { 43054, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE */
+   { 43075, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE_EXT */
+   { 43100, 0x00001005 }, /* GL_TEXTURE_BORDER */
+   { 43118, 0x00001004 }, /* GL_TEXTURE_BORDER_COLOR */
+   { 43142, 0x00008C2A }, /* GL_TEXTURE_BUFFER */
+   { 43160, 0x00008C2D }, /* GL_TEXTURE_BUFFER_DATA_STORE_BINDING */
+   { 43197, 0x00008C2E }, /* GL_TEXTURE_BUFFER_FORMAT */
+   { 43222, 0x00008171 }, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
+   { 43253, 0x00008176 }, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
+   { 43283, 0x00008172 }, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
+   { 43313, 0x00008175 }, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
+   { 43348, 0x00008173 }, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
+   { 43379, 0x00008174 }, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+   { 43417, 0x000080BC }, /* GL_TEXTURE_COLOR_TABLE_SGI */
+   { 43444, 0x000081EF }, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
+   { 43476, 0x000080BF }, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
+   { 43510, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC */
+   { 43534, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC_ARB */
+   { 43562, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE */
+   { 43586, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE_ARB */
+   { 43614, 0x0000819B }, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
+   { 43647, 0x0000819A }, /* GL_TEXTURE_COMPARE_SGIX */
+   { 43671, 0x00001003 }, /* GL_TEXTURE_COMPONENTS */
+   { 43693, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED */
+   { 43715, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED_ARB */
+   { 43741, 0x000086A3 }, /* GL_TEXTURE_COMPRESSED_FORMATS_ARB */
+   { 43775, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
+   { 43808, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB */
+   { 43845, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT */
+   { 43873, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT_ARB */
+   { 43905, 0x00008078 }, /* GL_TEXTURE_COORD_ARRAY */
+   { 43928, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
+   { 43966, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB */
+   { 44008, 0x00008092 }, /* GL_TEXTURE_COORD_ARRAY_POINTER */
+   { 44039, 0x00008088 }, /* GL_TEXTURE_COORD_ARRAY_SIZE */
+   { 44067, 0x0000808A }, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
+   { 44097, 0x00008089 }, /* GL_TEXTURE_COORD_ARRAY_TYPE */
+   { 44125, 0x00008B9D }, /* GL_TEXTURE_CROP_RECT_OES */
+   { 44150, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP */
+   { 44170, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_ARB */
+   { 44194, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
+   { 44225, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB */
+   { 44260, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES */
+   { 44295, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
+   { 44326, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB */
+   { 44361, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES */
+   { 44396, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
+   { 44427, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB */
+   { 44462, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES */
+   { 44497, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_OES */
+   { 44521, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
+   { 44552, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB */
+   { 44587, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES */
+   { 44622, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
+   { 44653, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB */
+   { 44688, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES */
+   { 44723, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
+   { 44754, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB */
+   { 44789, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES */
+   { 44824, 0x000088F4 }, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */
+   { 44853, 0x00008071 }, /* GL_TEXTURE_DEPTH */
+   { 44870, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE */
+   { 44892, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE_ARB */
+   { 44918, 0x00002300 }, /* GL_TEXTURE_ENV */
+   { 44933, 0x00002201 }, /* GL_TEXTURE_ENV_COLOR */
+   { 44954, 0x00002200 }, /* GL_TEXTURE_ENV_MODE */
+   { 44974, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL */
+   { 45000, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL_EXT */
+   { 45030, 0x00002500 }, /* GL_TEXTURE_GEN_MODE */
+   { 45050, 0x00002500 }, /* GL_TEXTURE_GEN_MODE_OES */
+   { 45074, 0x00000C63 }, /* GL_TEXTURE_GEN_Q */
+   { 45091, 0x00000C62 }, /* GL_TEXTURE_GEN_R */
+   { 45108, 0x00000C60 }, /* GL_TEXTURE_GEN_S */
+   { 45125, 0x00008D60 }, /* GL_TEXTURE_GEN_STR_OES */
+   { 45148, 0x00000C61 }, /* GL_TEXTURE_GEN_T */
+   { 45165, 0x0000819D }, /* GL_TEXTURE_GEQUAL_R_SGIX */
+   { 45190, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE */
+   { 45212, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE_EXT */
+   { 45238, 0x00001001 }, /* GL_TEXTURE_HEIGHT */
+   { 45256, 0x000080ED }, /* GL_TEXTURE_INDEX_SIZE_EXT */
+   { 45282, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE */
+   { 45308, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE_EXT */
+   { 45338, 0x00001003 }, /* GL_TEXTURE_INTERNAL_FORMAT */
+   { 45365, 0x0000819C }, /* GL_TEXTURE_LEQUAL_R_SGIX */
+   { 45390, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS */
+   { 45410, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS_EXT */
+   { 45434, 0x00008190 }, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
+   { 45461, 0x0000818E }, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
+   { 45488, 0x0000818F }, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
+   { 45515, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE */
+   { 45541, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE_EXT */
+   { 45571, 0x00002800 }, /* GL_TEXTURE_MAG_FILTER */
+   { 45593, 0x00000BA8 }, /* GL_TEXTURE_MATRIX */
+   { 45611, 0x0000898F }, /* GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES */
+   { 45651, 0x000084FE }, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
+   { 45681, 0x0000836B }, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
+   { 45709, 0x00008369 }, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
+   { 45737, 0x0000836A }, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
+   { 45765, 0x0000813D }, /* GL_TEXTURE_MAX_LEVEL */
+   { 45786, 0x0000813B }, /* GL_TEXTURE_MAX_LOD */
+   { 45805, 0x00002801 }, /* GL_TEXTURE_MIN_FILTER */
+   { 45827, 0x0000813A }, /* GL_TEXTURE_MIN_LOD */
+   { 45846, 0x00008066 }, /* GL_TEXTURE_PRIORITY */
+   { 45866, 0x000085B7 }, /* GL_TEXTURE_RANGE_LENGTH_APPLE */
+   { 45896, 0x000085B8 }, /* GL_TEXTURE_RANGE_POINTER_APPLE */
+   { 45927, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE */
+   { 45948, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_ARB */
+   { 45973, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_NV */
+   { 45997, 0x0000805C }, /* GL_TEXTURE_RED_SIZE */
+   { 46017, 0x0000805C }, /* GL_TEXTURE_RED_SIZE_EXT */
+   { 46041, 0x00008067 }, /* GL_TEXTURE_RESIDENT */
+   { 46061, 0x00008C3F }, /* GL_TEXTURE_SHARED_SIZE */
+   { 46084, 0x00000BA5 }, /* GL_TEXTURE_STACK_DEPTH */
+   { 46107, 0x000088F1 }, /* GL_TEXTURE_STENCIL_SIZE */
+   { 46131, 0x000088F1 }, /* GL_TEXTURE_STENCIL_SIZE_EXT */
+   { 46159, 0x000085BC }, /* GL_TEXTURE_STORAGE_HINT_APPLE */
+   { 46189, 0x00008065 }, /* GL_TEXTURE_TOO_LARGE_EXT */
+   { 46214, 0x0000888F }, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
+   { 46248, 0x00001000 }, /* GL_TEXTURE_WIDTH */
+   { 46265, 0x00008072 }, /* GL_TEXTURE_WRAP_R */
+   { 46283, 0x00008072 }, /* GL_TEXTURE_WRAP_R_OES */
+   { 46305, 0x00002802 }, /* GL_TEXTURE_WRAP_S */
+   { 46323, 0x00002803 }, /* GL_TEXTURE_WRAP_T */
+   { 46341, 0x0000911B }, /* GL_TIMEOUT_EXPIRED */
+   { 46360, 0x000088BF }, /* GL_TIME_ELAPSED_EXT */
+   { 46380, 0x00008648 }, /* GL_TRACK_MATRIX_NV */
+   { 46399, 0x00008649 }, /* GL_TRACK_MATRIX_TRANSFORM_NV */
+   { 46428, 0x00001000 }, /* GL_TRANSFORM_BIT */
+   { 46445, 0x00008E22 }, /* GL_TRANSFORM_FEEDBACK */
+   { 46467, 0x00008E25 }, /* GL_TRANSFORM_FEEDBACK_BINDING */
+   { 46497, 0x00008C8E }, /* GL_TRANSFORM_FEEDBACK_BUFFER */
+   { 46526, 0x00008E24 }, /* GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE */
+   { 46562, 0x00008C8F }, /* GL_TRANSFORM_FEEDBACK_BUFFER_BINDING */
+   { 46599, 0x00008C8F }, /* GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT */
+   { 46640, 0x00008C8E }, /* GL_TRANSFORM_FEEDBACK_BUFFER_EXT */
+   { 46673, 0x00008C7F }, /* GL_TRANSFORM_FEEDBACK_BUFFER_MODE */
+   { 46707, 0x00008C7F }, /* GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT */
+   { 46745, 0x00008E23 }, /* GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED */
+   { 46781, 0x00008C85 }, /* GL_TRANSFORM_FEEDBACK_BUFFER_SIZE */
+   { 46815, 0x00008C85 }, /* GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT */
+   { 46853, 0x00008C84 }, /* GL_TRANSFORM_FEEDBACK_BUFFER_START */
+   { 46888, 0x00008C84 }, /* GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT */
+   { 46927, 0x00008C88 }, /* GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN */
+   { 46968, 0x00008C88 }, /* GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT */
+   { 47013, 0x00008C83 }, /* GL_TRANSFORM_FEEDBACK_VARYINGS */
+   { 47044, 0x00008C83 }, /* GL_TRANSFORM_FEEDBACK_VARYINGS_EXT */
+   { 47079, 0x00008C76 }, /* GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH */
+   { 47120, 0x00008C76 }, /* GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT */
+   { 47165, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX */
+   { 47191, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX_ARB */
+   { 47221, 0x000088B7 }, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
+   { 47253, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
+   { 47283, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX_ARB */
+   { 47317, 0x0000862C }, /* GL_TRANSPOSE_NV */
+   { 47333, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX */
+   { 47364, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX_ARB */
+   { 47399, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX */
+   { 47427, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX_ARB */
+   { 47459, 0x00000004 }, /* GL_TRIANGLES */
+   { 47472, 0x0000000C }, /* GL_TRIANGLES_ADJACENCY */
+   { 47495, 0x0000000C }, /* GL_TRIANGLES_ADJACENCY_ARB */
+   { 47522, 0x00000006 }, /* GL_TRIANGLE_FAN */
+   { 47538, 0x00008615 }, /* GL_TRIANGLE_MESH_SUN */
+   { 47559, 0x00000005 }, /* GL_TRIANGLE_STRIP */
+   { 47577, 0x0000000D }, /* GL_TRIANGLE_STRIP_ADJACENCY */
+   { 47605, 0x0000000D }, /* GL_TRIANGLE_STRIP_ADJACENCY_ARB */
+   { 47637, 0x00000001 }, /* GL_TRUE */
+   { 47645, 0x00008A1C }, /* GL_UNDEFINED_APPLE */
+   { 47664, 0x00000CF5 }, /* GL_UNPACK_ALIGNMENT */
+   { 47684, 0x0000806E }, /* GL_UNPACK_IMAGE_HEIGHT */
+   { 47707, 0x00000CF1 }, /* GL_UNPACK_LSB_FIRST */
+   { 47727, 0x00000CF2 }, /* GL_UNPACK_ROW_LENGTH */
+   { 47748, 0x0000806D }, /* GL_UNPACK_SKIP_IMAGES */
+   { 47770, 0x00000CF4 }, /* GL_UNPACK_SKIP_PIXELS */
+   { 47792, 0x00000CF3 }, /* GL_UNPACK_SKIP_ROWS */
+   { 47812, 0x00000CF0 }, /* GL_UNPACK_SWAP_BYTES */
+   { 47833, 0x00009118 }, /* GL_UNSIGNALED */
+   { 47847, 0x00001401 }, /* GL_UNSIGNED_BYTE */
+   { 47864, 0x00008362 }, /* GL_UNSIGNED_BYTE_2_3_3_REV */
+   { 47891, 0x00008032 }, /* GL_UNSIGNED_BYTE_3_3_2 */
+   { 47914, 0x00001405 }, /* GL_UNSIGNED_INT */
+   { 47930, 0x00008C3B }, /* GL_UNSIGNED_INT_10F_11F_11F_REV */
+   { 47962, 0x00008036 }, /* GL_UNSIGNED_INT_10_10_10_2 */
+   { 47989, 0x00008DF6 }, /* GL_UNSIGNED_INT_10_10_10_2_OES */
+   { 48020, 0x000084FA }, /* GL_UNSIGNED_INT_24_8 */
+   { 48041, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_EXT */
+   { 48066, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_NV */
+   { 48090, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_OES */
+   { 48115, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV */
+   { 48146, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV_EXT */
+   { 48181, 0x00008C3E }, /* GL_UNSIGNED_INT_5_9_9_9_REV */
+   { 48209, 0x00008035 }, /* GL_UNSIGNED_INT_8_8_8_8 */
+   { 48233, 0x00008367 }, /* GL_UNSIGNED_INT_8_8_8_8_REV */
+   { 48261, 0x00008DD1 }, /* GL_UNSIGNED_INT_SAMPLER_1D */
+   { 48288, 0x00008DD6 }, /* GL_UNSIGNED_INT_SAMPLER_1D_ARRAY */
+   { 48321, 0x00008DD6 }, /* GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT */
+   { 48358, 0x00008DD1 }, /* GL_UNSIGNED_INT_SAMPLER_1D_EXT */
+   { 48389, 0x00008DD2 }, /* GL_UNSIGNED_INT_SAMPLER_2D */
+   { 48416, 0x00008DD7 }, /* GL_UNSIGNED_INT_SAMPLER_2D_ARRAY */
+   { 48449, 0x00008DD7 }, /* GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT */
+   { 48486, 0x00008DD2 }, /* GL_UNSIGNED_INT_SAMPLER_2D_EXT */
+   { 48517, 0x00008DD5 }, /* GL_UNSIGNED_INT_SAMPLER_2D_RECT */
+   { 48549, 0x00008DD5 }, /* GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT */
+   { 48585, 0x00008DD3 }, /* GL_UNSIGNED_INT_SAMPLER_3D */
+   { 48612, 0x00008DD3 }, /* GL_UNSIGNED_INT_SAMPLER_3D_EXT */
+   { 48643, 0x00008DD8 }, /* GL_UNSIGNED_INT_SAMPLER_BUFFER */
+   { 48674, 0x00008DD8 }, /* GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT */
+   { 48709, 0x00008DD4 }, /* GL_UNSIGNED_INT_SAMPLER_CUBE */
+   { 48738, 0x00008DD4 }, /* GL_UNSIGNED_INT_SAMPLER_CUBE_EXT */
+   { 48771, 0x00008DC6 }, /* GL_UNSIGNED_INT_VEC2 */
+   { 48792, 0x00008DC6 }, /* GL_UNSIGNED_INT_VEC2_EXT */
+   { 48817, 0x00008DC7 }, /* GL_UNSIGNED_INT_VEC3 */
+   { 48838, 0x00008DC7 }, /* GL_UNSIGNED_INT_VEC3_EXT */
+   { 48863, 0x00008DC8 }, /* GL_UNSIGNED_INT_VEC4 */
+   { 48884, 0x00008DC8 }, /* GL_UNSIGNED_INT_VEC4_EXT */
+   { 48909, 0x00008C17 }, /* GL_UNSIGNED_NORMALIZED */
+   { 48932, 0x00001403 }, /* GL_UNSIGNED_SHORT */
+   { 48950, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
+   { 48980, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT */
+   { 49014, 0x00008033 }, /* GL_UNSIGNED_SHORT_4_4_4_4 */
+   { 49040, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
+   { 49070, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT */
+   { 49104, 0x00008034 }, /* GL_UNSIGNED_SHORT_5_5_5_1 */
+   { 49130, 0x00008363 }, /* GL_UNSIGNED_SHORT_5_6_5 */
+   { 49154, 0x00008364 }, /* GL_UNSIGNED_SHORT_5_6_5_REV */
+   { 49182, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_APPLE */
+   { 49210, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_MESA */
+   { 49237, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
+   { 49269, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_MESA */
+   { 49300, 0x00008CA2 }, /* GL_UPPER_LEFT */
+   { 49314, 0x00002A20 }, /* GL_V2F */
+   { 49321, 0x00002A21 }, /* GL_V3F */
+   { 49328, 0x00008B83 }, /* GL_VALIDATE_STATUS */
+   { 49347, 0x00001F00 }, /* GL_VENDOR */
+   { 49357, 0x00001F02 }, /* GL_VERSION */
+   { 49368, 0x00008074 }, /* GL_VERTEX_ARRAY */
+   { 49384, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING */
+   { 49408, 0x000085B5 }, /* GL_VERTEX_ARRAY_BINDING_APPLE */
+   { 49438, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
+   { 49469, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING_ARB */
+   { 49504, 0x0000808E }, /* GL_VERTEX_ARRAY_POINTER */
+   { 49528, 0x0000807A }, /* GL_VERTEX_ARRAY_SIZE */
+   { 49549, 0x0000807C }, /* GL_VERTEX_ARRAY_STRIDE */
+   { 49572, 0x0000807B }, /* GL_VERTEX_ARRAY_TYPE */
+   { 49593, 0x00008650 }, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
+   { 49620, 0x0000865A }, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
+   { 49648, 0x0000865B }, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
+   { 49676, 0x0000865C }, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
+   { 49704, 0x0000865D }, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
+   { 49732, 0x0000865E }, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
+   { 49760, 0x0000865F }, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
+   { 49788, 0x00008651 }, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
+   { 49815, 0x00008652 }, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
+   { 49842, 0x00008653 }, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
+   { 49869, 0x00008654 }, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
+   { 49896, 0x00008655 }, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
+   { 49923, 0x00008656 }, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
+   { 49950, 0x00008657 }, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
+   { 49977, 0x00008658 }, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
+   { 50004, 0x00008659 }, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
+   { 50031, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
+   { 50069, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB */
+   { 50111, 0x000088FE }, /* GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB */
+   { 50146, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
+   { 50177, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */
+   { 50212, 0x000088FD }, /* GL_VERTEX_ATTRIB_ARRAY_INTEGER */
+   { 50243, 0x000088FD }, /* GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT */
+   { 50278, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
+   { 50312, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */
+   { 50350, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
+   { 50381, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */
+   { 50416, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
+   { 50444, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */
+   { 50476, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
+   { 50506, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */
+   { 50540, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
+   { 50568, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */
+   { 50600, 0x000086A7 }, /* GL_VERTEX_BLEND_ARB */
+   { 50620, 0x00008620 }, /* GL_VERTEX_PROGRAM_ARB */
+   { 50642, 0x0000864A }, /* GL_VERTEX_PROGRAM_BINDING_NV */
+   { 50671, 0x00008620 }, /* GL_VERTEX_PROGRAM_NV */
+   { 50692, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE */
+   { 50721, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */
+   { 50754, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_NV */
+   { 50786, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE */
+   { 50813, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */
+   { 50844, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_NV */
+   { 50874, 0x00008B31 }, /* GL_VERTEX_SHADER */
+   { 50891, 0x00008B31 }, /* GL_VERTEX_SHADER_ARB */
+   { 50912, 0x00008621 }, /* GL_VERTEX_STATE_PROGRAM_NV */
+   { 50939, 0x00000BA2 }, /* GL_VIEWPORT */
+   { 50951, 0x00000800 }, /* GL_VIEWPORT_BIT */
+   { 50967, 0x00008A1A }, /* GL_VOLATILE_APPLE */
+   { 50985, 0x0000911D }, /* GL_WAIT_FAILED */
+   { 51000, 0x000086AD }, /* GL_WEIGHT_ARRAY_ARB */
+   { 51020, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
+   { 51051, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB */
+   { 51086, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_OES */
+   { 51121, 0x000086AD }, /* GL_WEIGHT_ARRAY_OES */
+   { 51141, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_ARB */
+   { 51169, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_OES */
+   { 51197, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_ARB */
+   { 51222, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_OES */
+   { 51247, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
+   { 51274, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_OES */
+   { 51301, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_ARB */
+   { 51326, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_OES */
+   { 51351, 0x000086A6 }, /* GL_WEIGHT_SUM_UNITY_ARB */
+   { 51375, 0x000081D4 }, /* GL_WRAP_BORDER_SUN */
+   { 51394, 0x000088B9 }, /* GL_WRITE_ONLY */
+   { 51408, 0x000088B9 }, /* GL_WRITE_ONLY_ARB */
+   { 51426, 0x000088B9 }, /* GL_WRITE_ONLY_OES */
+   { 51444, 0x00001506 }, /* GL_XOR */
+   { 51451, 0x000085B9 }, /* GL_YCBCR_422_APPLE */
+   { 51470, 0x00008757 }, /* GL_YCBCR_MESA */
+   { 51484, 0x00000000 }, /* GL_ZERO */
+   { 51492, 0x00000D16 }, /* GL_ZOOM_X */
+   { 51502, 0x00000D17 }, /* GL_ZOOM_Y */
+};
+
+static const unsigned reduced_enums[1555] =
+{
+       538, /* GL_FALSE */
+       831, /* GL_LINES */
+       835, /* GL_LINE_LOOP */
+       842, /* GL_LINE_STRIP */
+      2140, /* GL_TRIANGLES */
+      2145, /* GL_TRIANGLE_STRIP */
+      2143, /* GL_TRIANGLE_FAN */
+      1511, /* GL_QUADS */
+      1515, /* GL_QUAD_STRIP */
+      1382, /* GL_POLYGON */
+       832, /* GL_LINES_ADJACENCY */
+       843, /* GL_LINE_STRIP_ADJACENCY */
+      2141, /* GL_TRIANGLES_ADJACENCY */
+      2146, /* GL_TRIANGLE_STRIP_ADJACENCY */
+      1394, /* GL_POLYGON_STIPPLE_BIT */
+      1337, /* GL_PIXEL_MODE_BIT */
+       818, /* GL_LIGHTING_BIT */
+       572, /* GL_FOG_BIT */
+         8, /* GL_ACCUM */
+       854, /* GL_LOAD */
+      1600, /* GL_RETURN */
+      1204, /* GL_MULT */
+        24, /* GL_ADD */
+      1220, /* GL_NEVER */
+       808, /* GL_LESS */
+       528, /* GL_EQUAL */
+       807, /* GL_LEQUAL */
+       695, /* GL_GREATER */
+      1237, /* GL_NOTEQUAL */
+       694, /* GL_GEQUAL */
+        55, /* GL_ALWAYS */
+      1808, /* GL_SRC_COLOR */
+      1270, /* GL_ONE_MINUS_SRC_COLOR */
+      1806, /* GL_SRC_ALPHA */
+      1269, /* GL_ONE_MINUS_SRC_ALPHA */
+       507, /* GL_DST_ALPHA */
+      1267, /* GL_ONE_MINUS_DST_ALPHA */
+       508, /* GL_DST_COLOR */
+      1268, /* GL_ONE_MINUS_DST_COLOR */
+      1807, /* GL_SRC_ALPHA_SATURATE */
+       671, /* GL_FRONT_LEFT */
+       672, /* GL_FRONT_RIGHT */
+        77, /* GL_BACK_LEFT */
+        78, /* GL_BACK_RIGHT */
+       668, /* GL_FRONT */
+        76, /* GL_BACK */
+       806, /* GL_LEFT */
+      1690, /* GL_RIGHT */
+       669, /* GL_FRONT_AND_BACK */
+        71, /* GL_AUX0 */
+        72, /* GL_AUX1 */
+        73, /* GL_AUX2 */
+        74, /* GL_AUX3 */
+       794, /* GL_INVALID_ENUM */
+       799, /* GL_INVALID_VALUE */
+       798, /* GL_INVALID_OPERATION */
+      1813, /* GL_STACK_OVERFLOW */
+      1814, /* GL_STACK_UNDERFLOW */
+      1295, /* GL_OUT_OF_MEMORY */
+       795, /* GL_INVALID_FRAMEBUFFER_OPERATION */
+         0, /* GL_2D */
+         2, /* GL_3D */
+         3, /* GL_3D_COLOR */
+         4, /* GL_3D_COLOR_TEXTURE */
+         6, /* GL_4D_COLOR_TEXTURE */
+      1315, /* GL_PASS_THROUGH_TOKEN */
+      1381, /* GL_POINT_TOKEN */
+       845, /* GL_LINE_TOKEN */
+      1395, /* GL_POLYGON_TOKEN */
+        87, /* GL_BITMAP_TOKEN */
+       506, /* GL_DRAW_PIXEL_TOKEN */
+       352, /* GL_COPY_PIXEL_TOKEN */
+       836, /* GL_LINE_RESET_TOKEN */
+       531, /* GL_EXP */
+       532, /* GL_EXP2 */
+       389, /* GL_CW */
+       154, /* GL_CCW */
+       187, /* GL_COEFF */
+      1292, /* GL_ORDER */
+       443, /* GL_DOMAIN */
+       362, /* GL_CURRENT_COLOR */
+       365, /* GL_CURRENT_INDEX */
+       371, /* GL_CURRENT_NORMAL */
+       385, /* GL_CURRENT_TEXTURE_COORDS */
+       377, /* GL_CURRENT_RASTER_COLOR */
+       379, /* GL_CURRENT_RASTER_INDEX */
+       383, /* GL_CURRENT_RASTER_TEXTURE_COORDS */
+       380, /* GL_CURRENT_RASTER_POSITION */
+       381, /* GL_CURRENT_RASTER_POSITION_VALID */
+       378, /* GL_CURRENT_RASTER_DISTANCE */
+      1373, /* GL_POINT_SMOOTH */
+      1357, /* GL_POINT_SIZE */
+      1372, /* GL_POINT_SIZE_RANGE */
+      1363, /* GL_POINT_SIZE_GRANULARITY */
+       837, /* GL_LINE_SMOOTH */
+       846, /* GL_LINE_WIDTH */
+       848, /* GL_LINE_WIDTH_RANGE */
+       847, /* GL_LINE_WIDTH_GRANULARITY */
+       839, /* GL_LINE_STIPPLE */
+       840, /* GL_LINE_STIPPLE_PATTERN */
+       841, /* GL_LINE_STIPPLE_REPEAT */
+       853, /* GL_LIST_MODE */
+      1060, /* GL_MAX_LIST_NESTING */
+       850, /* GL_LIST_BASE */
+       852, /* GL_LIST_INDEX */
+      1384, /* GL_POLYGON_MODE */
+      1391, /* GL_POLYGON_SMOOTH */
+      1393, /* GL_POLYGON_STIPPLE */
+       517, /* GL_EDGE_FLAG */
+       355, /* GL_CULL_FACE */
+       356, /* GL_CULL_FACE_MODE */
+       670, /* GL_FRONT_FACE */
+       817, /* GL_LIGHTING */
+       822, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
+       823, /* GL_LIGHT_MODEL_TWO_SIDE */
+       819, /* GL_LIGHT_MODEL_AMBIENT */
+      1755, /* GL_SHADE_MODEL */
+       235, /* GL_COLOR_MATERIAL_FACE */
+       236, /* GL_COLOR_MATERIAL_PARAMETER */
+       234, /* GL_COLOR_MATERIAL */
+       571, /* GL_FOG */
+       593, /* GL_FOG_INDEX */
+       589, /* GL_FOG_DENSITY */
+       597, /* GL_FOG_START */
+       591, /* GL_FOG_END */
+       594, /* GL_FOG_MODE */
+       573, /* GL_FOG_COLOR */
+       428, /* GL_DEPTH_RANGE */
+       437, /* GL_DEPTH_TEST */
+       440, /* GL_DEPTH_WRITEMASK */
+       413, /* GL_DEPTH_CLEAR_VALUE */
+       427, /* GL_DEPTH_FUNC */
+        12, /* GL_ACCUM_CLEAR_VALUE */
+      1858, /* GL_STENCIL_TEST */
+      1839, /* GL_STENCIL_CLEAR_VALUE */
+      1841, /* GL_STENCIL_FUNC */
+      1860, /* GL_STENCIL_VALUE_MASK */
+      1840, /* GL_STENCIL_FAIL */
+      1855, /* GL_STENCIL_PASS_DEPTH_FAIL */
+      1856, /* GL_STENCIL_PASS_DEPTH_PASS */
+      1857, /* GL_STENCIL_REF */
+      1861, /* GL_STENCIL_WRITEMASK */
+      1010, /* GL_MATRIX_MODE */
+      1226, /* GL_NORMALIZE */
+      2272, /* GL_VIEWPORT */
+      1199, /* GL_MODELVIEW_STACK_DEPTH */
+      1485, /* GL_PROJECTION_STACK_DEPTH */
+      2094, /* GL_TEXTURE_STACK_DEPTH */
+      1196, /* GL_MODELVIEW_MATRIX */
+      1483, /* GL_PROJECTION_MATRIX */
+      2074, /* GL_TEXTURE_MATRIX */
+        69, /* GL_ATTRIB_STACK_DEPTH */
+       169, /* GL_CLIENT_ATTRIB_STACK_DEPTH */
+        51, /* GL_ALPHA_TEST */
+        52, /* GL_ALPHA_TEST_FUNC */
+        53, /* GL_ALPHA_TEST_REF */
+       442, /* GL_DITHER */
+        91, /* GL_BLEND_DST */
+       105, /* GL_BLEND_SRC */
+        88, /* GL_BLEND */
+       856, /* GL_LOGIC_OP_MODE */
+       743, /* GL_INDEX_LOGIC_OP */
+       233, /* GL_COLOR_LOGIC_OP */
+        75, /* GL_AUX_BUFFERS */
+       453, /* GL_DRAW_BUFFER */
+      1538, /* GL_READ_BUFFER */
+      1732, /* GL_SCISSOR_BOX */
+      1733, /* GL_SCISSOR_TEST */
+       742, /* GL_INDEX_CLEAR_VALUE */
+       747, /* GL_INDEX_WRITEMASK */
+       230, /* GL_COLOR_CLEAR_VALUE */
+       272, /* GL_COLOR_WRITEMASK */
+       744, /* GL_INDEX_MODE */
+      1679, /* GL_RGBA_MODE */
+       452, /* GL_DOUBLEBUFFER */
+      1862, /* GL_STEREO */
+      1592, /* GL_RENDER_MODE */
+      1316, /* GL_PERSPECTIVE_CORRECTION_HINT */
+      1374, /* GL_POINT_SMOOTH_HINT */
+       838, /* GL_LINE_SMOOTH_HINT */
+      1392, /* GL_POLYGON_SMOOTH_HINT */
+       592, /* GL_FOG_HINT */
+      2054, /* GL_TEXTURE_GEN_S */
+      2056, /* GL_TEXTURE_GEN_T */
+      2053, /* GL_TEXTURE_GEN_R */
+      2052, /* GL_TEXTURE_GEN_Q */
+      1329, /* GL_PIXEL_MAP_I_TO_I */
+      1335, /* GL_PIXEL_MAP_S_TO_S */
+      1331, /* GL_PIXEL_MAP_I_TO_R */
+      1327, /* GL_PIXEL_MAP_I_TO_G */
+      1325, /* GL_PIXEL_MAP_I_TO_B */
+      1323, /* GL_PIXEL_MAP_I_TO_A */
+      1333, /* GL_PIXEL_MAP_R_TO_R */
+      1321, /* GL_PIXEL_MAP_G_TO_G */
+      1319, /* GL_PIXEL_MAP_B_TO_B */
+      1317, /* GL_PIXEL_MAP_A_TO_A */
+      1330, /* GL_PIXEL_MAP_I_TO_I_SIZE */
+      1336, /* GL_PIXEL_MAP_S_TO_S_SIZE */
+      1332, /* GL_PIXEL_MAP_I_TO_R_SIZE */
+      1328, /* GL_PIXEL_MAP_I_TO_G_SIZE */
+      1326, /* GL_PIXEL_MAP_I_TO_B_SIZE */
+      1324, /* GL_PIXEL_MAP_I_TO_A_SIZE */
+      1334, /* GL_PIXEL_MAP_R_TO_R_SIZE */
+      1322, /* GL_PIXEL_MAP_G_TO_G_SIZE */
+      1320, /* GL_PIXEL_MAP_B_TO_B_SIZE */
+      1318, /* GL_PIXEL_MAP_A_TO_A_SIZE */
+      2157, /* GL_UNPACK_SWAP_BYTES */
+      2152, /* GL_UNPACK_LSB_FIRST */
+      2153, /* GL_UNPACK_ROW_LENGTH */
+      2156, /* GL_UNPACK_SKIP_ROWS */
+      2155, /* GL_UNPACK_SKIP_PIXELS */
+      2150, /* GL_UNPACK_ALIGNMENT */
+      1304, /* GL_PACK_SWAP_BYTES */
+      1299, /* GL_PACK_LSB_FIRST */
+      1300, /* GL_PACK_ROW_LENGTH */
+      1303, /* GL_PACK_SKIP_ROWS */
+      1302, /* GL_PACK_SKIP_PIXELS */
+      1296, /* GL_PACK_ALIGNMENT */
+       951, /* GL_MAP_COLOR */
+       956, /* GL_MAP_STENCIL */
+       746, /* GL_INDEX_SHIFT */
+       745, /* GL_INDEX_OFFSET */
+      1554, /* GL_RED_SCALE */
+      1550, /* GL_RED_BIAS */
+      2298, /* GL_ZOOM_X */
+      2299, /* GL_ZOOM_Y */
+       701, /* GL_GREEN_SCALE */
+       697, /* GL_GREEN_BIAS */
+       115, /* GL_BLUE_SCALE */
+       111, /* GL_BLUE_BIAS */
+        50, /* GL_ALPHA_SCALE */
+        47, /* GL_ALPHA_BIAS */
+       429, /* GL_DEPTH_SCALE */
+       405, /* GL_DEPTH_BIAS */
+      1042, /* GL_MAX_EVAL_ORDER */
+      1059, /* GL_MAX_LIGHTS */
+      1022, /* GL_MAX_CLIP_DISTANCES */
+      1114, /* GL_MAX_TEXTURE_SIZE */
+      1066, /* GL_MAX_PIXEL_MAP_TABLE */
+      1018, /* GL_MAX_ATTRIB_STACK_DEPTH */
+      1062, /* GL_MAX_MODELVIEW_STACK_DEPTH */
+      1063, /* GL_MAX_NAME_STACK_DEPTH */
+      1094, /* GL_MAX_PROJECTION_STACK_DEPTH */
+      1115, /* GL_MAX_TEXTURE_STACK_DEPTH */
+      1141, /* GL_MAX_VIEWPORT_DIMS */
+      1019, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
+      1872, /* GL_SUBPIXEL_BITS */
+       741, /* GL_INDEX_BITS */
+      1551, /* GL_RED_BITS */
+       698, /* GL_GREEN_BITS */
+       112, /* GL_BLUE_BITS */
+        48, /* GL_ALPHA_BITS */
+       406, /* GL_DEPTH_BITS */
+      1836, /* GL_STENCIL_BITS */
+        14, /* GL_ACCUM_RED_BITS */
+        13, /* GL_ACCUM_GREEN_BITS */
+        10, /* GL_ACCUM_BLUE_BITS */
+         9, /* GL_ACCUM_ALPHA_BITS */
+      1213, /* GL_NAME_STACK_DEPTH */
+        70, /* GL_AUTO_NORMAL */
+       897, /* GL_MAP1_COLOR_4 */
+       900, /* GL_MAP1_INDEX */
+       901, /* GL_MAP1_NORMAL */
+       902, /* GL_MAP1_TEXTURE_COORD_1 */
+       903, /* GL_MAP1_TEXTURE_COORD_2 */
+       904, /* GL_MAP1_TEXTURE_COORD_3 */
+       905, /* GL_MAP1_TEXTURE_COORD_4 */
+       906, /* GL_MAP1_VERTEX_3 */
+       907, /* GL_MAP1_VERTEX_4 */
+       924, /* GL_MAP2_COLOR_4 */
+       927, /* GL_MAP2_INDEX */
+       928, /* GL_MAP2_NORMAL */
+       929, /* GL_MAP2_TEXTURE_COORD_1 */
+       930, /* GL_MAP2_TEXTURE_COORD_2 */
+       931, /* GL_MAP2_TEXTURE_COORD_3 */
+       932, /* GL_MAP2_TEXTURE_COORD_4 */
+       933, /* GL_MAP2_VERTEX_3 */
+       934, /* GL_MAP2_VERTEX_4 */
+       898, /* GL_MAP1_GRID_DOMAIN */
+       899, /* GL_MAP1_GRID_SEGMENTS */
+       925, /* GL_MAP2_GRID_DOMAIN */
+       926, /* GL_MAP2_GRID_SEGMENTS */
+      1955, /* GL_TEXTURE_1D */
+      1958, /* GL_TEXTURE_2D */
+       541, /* GL_FEEDBACK_BUFFER_POINTER */
+       542, /* GL_FEEDBACK_BUFFER_SIZE */
+       543, /* GL_FEEDBACK_BUFFER_TYPE */
+      1742, /* GL_SELECTION_BUFFER_POINTER */
+      1743, /* GL_SELECTION_BUFFER_SIZE */
+      2100, /* GL_TEXTURE_WIDTH */
+      2060, /* GL_TEXTURE_HEIGHT */
+      2004, /* GL_TEXTURE_COMPONENTS */
+      1985, /* GL_TEXTURE_BORDER_COLOR */
+      1984, /* GL_TEXTURE_BORDER */
+       444, /* GL_DONT_CARE */
+       539, /* GL_FASTEST */
+      1221, /* GL_NICEST */
+        56, /* GL_AMBIENT */
+       441, /* GL_DIFFUSE */
+      1795, /* GL_SPECULAR */
+      1396, /* GL_POSITION */
+      1798, /* GL_SPOT_DIRECTION */
+      1799, /* GL_SPOT_EXPONENT */
+      1797, /* GL_SPOT_CUTOFF */
+       320, /* GL_CONSTANT_ATTENUATION */
+       826, /* GL_LINEAR_ATTENUATION */
+      1510, /* GL_QUADRATIC_ATTENUATION */
+       287, /* GL_COMPILE */
+       288, /* GL_COMPILE_AND_EXECUTE */
+       149, /* GL_BYTE */
+      2159, /* GL_UNSIGNED_BYTE */
+      1760, /* GL_SHORT */
+      2198, /* GL_UNSIGNED_SHORT */
+       749, /* GL_INT */
+      2162, /* GL_UNSIGNED_INT */
+       552, /* GL_FLOAT */
+         1, /* GL_2_BYTES */
+         5, /* GL_3_BYTES */
+         7, /* GL_4_BYTES */
+       451, /* GL_DOUBLE */
+       702, /* GL_HALF_FLOAT */
+       547, /* GL_FIXED */
+       165, /* GL_CLEAR */
+        58, /* GL_AND */
+        60, /* GL_AND_REVERSE */
+       350, /* GL_COPY */
+        59, /* GL_AND_INVERTED */
+      1224, /* GL_NOOP */
+      2294, /* GL_XOR */
+      1291, /* GL_OR */
+      1225, /* GL_NOR */
+       529, /* GL_EQUIV */
+       802, /* GL_INVERT */
+      1294, /* GL_OR_REVERSE */
+       351, /* GL_COPY_INVERTED */
+      1293, /* GL_OR_INVERTED */
+      1214, /* GL_NAND */
+      1749, /* GL_SET */
+       526, /* GL_EMISSION */
+      1759, /* GL_SHININESS */
+        57, /* GL_AMBIENT_AND_DIFFUSE */
+       232, /* GL_COLOR_INDEXES */
+      1163, /* GL_MODELVIEW */
+      1482, /* GL_PROJECTION */
+      1890, /* GL_TEXTURE */
+       188, /* GL_COLOR */
+       398, /* GL_DEPTH */
+      1821, /* GL_STENCIL */
+       231, /* GL_COLOR_INDEX */
+      1842, /* GL_STENCIL_INDEX */
+       414, /* GL_DEPTH_COMPONENT */
+      1547, /* GL_RED */
+       696, /* GL_GREEN */
+       110, /* GL_BLUE */
+        32, /* GL_ALPHA */
+      1603, /* GL_RGB */
+      1643, /* GL_RGBA */
+       860, /* GL_LUMINANCE */
+       887, /* GL_LUMINANCE_ALPHA */
+        86, /* GL_BITMAP */
+      1346, /* GL_POINT */
+       824, /* GL_LINE */
+       544, /* GL_FILL */
+      1561, /* GL_RENDER */
+       540, /* GL_FEEDBACK */
+      1741, /* GL_SELECT */
+       551, /* GL_FLAT */
+      1770, /* GL_SMOOTH */
+       803, /* GL_KEEP */
+      1594, /* GL_REPLACE */
+       731, /* GL_INCR */
+       394, /* GL_DECR */
+      2215, /* GL_VENDOR */
+      1591, /* GL_RENDERER */
+      2216, /* GL_VERSION */
+       533, /* GL_EXTENSIONS */
+      1691, /* GL_S */
+      1881, /* GL_T */
+      1530, /* GL_R */
+      1509, /* GL_Q */
+      1200, /* GL_MODULATE */
+       393, /* GL_DECAL */
+      2047, /* GL_TEXTURE_ENV_MODE */
+      2046, /* GL_TEXTURE_ENV_COLOR */
+      2045, /* GL_TEXTURE_ENV */
+       534, /* GL_EYE_LINEAR */
+      1252, /* GL_OBJECT_LINEAR */
+      1796, /* GL_SPHERE_MAP */
+      2050, /* GL_TEXTURE_GEN_MODE */
+      1254, /* GL_OBJECT_PLANE */
+       535, /* GL_EYE_PLANE */
+      1215, /* GL_NEAREST */
+       825, /* GL_LINEAR */
+      1219, /* GL_NEAREST_MIPMAP_NEAREST */
+       830, /* GL_LINEAR_MIPMAP_NEAREST */
+      1218, /* GL_NEAREST_MIPMAP_LINEAR */
+       829, /* GL_LINEAR_MIPMAP_LINEAR */
+      2073, /* GL_TEXTURE_MAG_FILTER */
+      2082, /* GL_TEXTURE_MIN_FILTER */
+      2103, /* GL_TEXTURE_WRAP_S */
+      2104, /* GL_TEXTURE_WRAP_T */
+       155, /* GL_CLAMP */
+      1593, /* GL_REPEAT */
+      1390, /* GL_POLYGON_OFFSET_UNITS */
+      1389, /* GL_POLYGON_OFFSET_POINT */
+      1388, /* GL_POLYGON_OFFSET_LINE */
+      1533, /* GL_R3_G3_B2 */
+      2212, /* GL_V2F */
+      2213, /* GL_V3F */
+       152, /* GL_C4UB_V2F */
+       153, /* GL_C4UB_V3F */
+       150, /* GL_C3F_V3F */
+      1212, /* GL_N3F_V3F */
+       151, /* GL_C4F_N3F_V3F */
+      1886, /* GL_T2F_V3F */
+      1888, /* GL_T4F_V4F */
+      1884, /* GL_T2F_C4UB_V3F */
+      1882, /* GL_T2F_C3F_V3F */
+      1885, /* GL_T2F_N3F_V3F */
+      1883, /* GL_T2F_C4F_N3F_V3F */
+      1887, /* GL_T4F_C4F_N3F_V4F */
+       172, /* GL_CLIP_DISTANCE0 */
+       173, /* GL_CLIP_DISTANCE1 */
+       174, /* GL_CLIP_DISTANCE2 */
+       175, /* GL_CLIP_DISTANCE3 */
+       176, /* GL_CLIP_DISTANCE4 */
+       177, /* GL_CLIP_DISTANCE5 */
+       178, /* GL_CLIP_DISTANCE6 */
+       179, /* GL_CLIP_DISTANCE7 */
+       809, /* GL_LIGHT0 */
+       810, /* GL_LIGHT1 */
+       811, /* GL_LIGHT2 */
+       812, /* GL_LIGHT3 */
+       813, /* GL_LIGHT4 */
+       814, /* GL_LIGHT5 */
+       815, /* GL_LIGHT6 */
+       816, /* GL_LIGHT7 */
+       706, /* GL_HINT_BIT */
+       322, /* GL_CONSTANT_COLOR */
+      1265, /* GL_ONE_MINUS_CONSTANT_COLOR */
+       317, /* GL_CONSTANT_ALPHA */
+      1263, /* GL_ONE_MINUS_CONSTANT_ALPHA */
+        89, /* GL_BLEND_COLOR */
+       673, /* GL_FUNC_ADD */
+      1144, /* GL_MIN */
+      1013, /* GL_MAX */
+        96, /* GL_BLEND_EQUATION */
+       679, /* GL_FUNC_SUBTRACT */
+       676, /* GL_FUNC_REVERSE_SUBTRACT */
+       330, /* GL_CONVOLUTION_1D */
+       331, /* GL_CONVOLUTION_2D */
+      1744, /* GL_SEPARABLE_2D */
+       334, /* GL_CONVOLUTION_BORDER_MODE */
+       338, /* GL_CONVOLUTION_FILTER_SCALE */
+       336, /* GL_CONVOLUTION_FILTER_BIAS */
+      1548, /* GL_REDUCE */
+       340, /* GL_CONVOLUTION_FORMAT */
+       344, /* GL_CONVOLUTION_WIDTH */
+       342, /* GL_CONVOLUTION_HEIGHT */
+      1032, /* GL_MAX_CONVOLUTION_WIDTH */
+      1030, /* GL_MAX_CONVOLUTION_HEIGHT */
+      1429, /* GL_POST_CONVOLUTION_RED_SCALE */
+      1425, /* GL_POST_CONVOLUTION_GREEN_SCALE */
+      1420, /* GL_POST_CONVOLUTION_BLUE_SCALE */
+      1416, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
+      1427, /* GL_POST_CONVOLUTION_RED_BIAS */
+      1423, /* GL_POST_CONVOLUTION_GREEN_BIAS */
+      1418, /* GL_POST_CONVOLUTION_BLUE_BIAS */
+      1414, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
+       707, /* GL_HISTOGRAM */
+      1489, /* GL_PROXY_HISTOGRAM */
+       723, /* GL_HISTOGRAM_WIDTH */
+       713, /* GL_HISTOGRAM_FORMAT */
+       719, /* GL_HISTOGRAM_RED_SIZE */
+       715, /* GL_HISTOGRAM_GREEN_SIZE */
+       710, /* GL_HISTOGRAM_BLUE_SIZE */
+       708, /* GL_HISTOGRAM_ALPHA_SIZE */
+       717, /* GL_HISTOGRAM_LUMINANCE_SIZE */
+       721, /* GL_HISTOGRAM_SINK */
+      1145, /* GL_MINMAX */
+      1147, /* GL_MINMAX_FORMAT */
+      1149, /* GL_MINMAX_SINK */
+      1889, /* GL_TABLE_TOO_LARGE_EXT */
+      2161, /* GL_UNSIGNED_BYTE_3_3_2 */
+      2201, /* GL_UNSIGNED_SHORT_4_4_4_4 */
+      2204, /* GL_UNSIGNED_SHORT_5_5_5_1 */
+      2173, /* GL_UNSIGNED_INT_8_8_8_8 */
+      2164, /* GL_UNSIGNED_INT_10_10_10_2 */
+      1387, /* GL_POLYGON_OFFSET_FILL */
+      1386, /* GL_POLYGON_OFFSET_FACTOR */
+      1385, /* GL_POLYGON_OFFSET_BIAS */
+      1597, /* GL_RESCALE_NORMAL */
+        41, /* GL_ALPHA4 */
+        43, /* GL_ALPHA8 */
+        33, /* GL_ALPHA12 */
+        35, /* GL_ALPHA16 */
+       875, /* GL_LUMINANCE4 */
+       881, /* GL_LUMINANCE8 */
+       861, /* GL_LUMINANCE12 */
+       867, /* GL_LUMINANCE16 */
+       876, /* GL_LUMINANCE4_ALPHA4 */
+       879, /* GL_LUMINANCE6_ALPHA2 */
+       884, /* GL_LUMINANCE8_ALPHA8 */
+       864, /* GL_LUMINANCE12_ALPHA4 */
+       862, /* GL_LUMINANCE12_ALPHA12 */
+       870, /* GL_LUMINANCE16_ALPHA16 */
+       750, /* GL_INTENSITY */
+       759, /* GL_INTENSITY4 */
+       761, /* GL_INTENSITY8 */
+       751, /* GL_INTENSITY12 */
+       753, /* GL_INTENSITY16 */
+      1618, /* GL_RGB2_EXT */
+      1624, /* GL_RGB4 */
+      1627, /* GL_RGB5 */
+      1634, /* GL_RGB8 */
+      1604, /* GL_RGB10 */
+      1608, /* GL_RGB12 */
+      1610, /* GL_RGB16 */
+      1654, /* GL_RGBA2 */
+      1661, /* GL_RGBA4 */
+      1630, /* GL_RGB5_A1 */
+      1666, /* GL_RGBA8 */
+      1605, /* GL_RGB10_A2 */
+      1644, /* GL_RGBA12 */
+      1646, /* GL_RGBA16 */
+      2090, /* GL_TEXTURE_RED_SIZE */
+      2058, /* GL_TEXTURE_GREEN_SIZE */
+      1982, /* GL_TEXTURE_BLUE_SIZE */
+      1963, /* GL_TEXTURE_ALPHA_SIZE */
+      2071, /* GL_TEXTURE_LUMINANCE_SIZE */
+      2062, /* GL_TEXTURE_INTENSITY_SIZE */
+      1595, /* GL_REPLACE_EXT */
+      1493, /* GL_PROXY_TEXTURE_1D */
+      1497, /* GL_PROXY_TEXTURE_2D */
+      2098, /* GL_TEXTURE_TOO_LARGE_EXT */
+      2084, /* GL_TEXTURE_PRIORITY */
+      2092, /* GL_TEXTURE_RESIDENT */
+      1966, /* GL_TEXTURE_BINDING_1D */
+      1969, /* GL_TEXTURE_BINDING_2D */
+      1972, /* GL_TEXTURE_BINDING_3D */
+      1301, /* GL_PACK_SKIP_IMAGES */
+      1297, /* GL_PACK_IMAGE_HEIGHT */
+      2154, /* GL_UNPACK_SKIP_IMAGES */
+      2151, /* GL_UNPACK_IMAGE_HEIGHT */
+      1961, /* GL_TEXTURE_3D */
+      1501, /* GL_PROXY_TEXTURE_3D */
+      2042, /* GL_TEXTURE_DEPTH */
+      2101, /* GL_TEXTURE_WRAP_R */
+      1014, /* GL_MAX_3D_TEXTURE_SIZE */
+      2217, /* GL_VERTEX_ARRAY */
+      1227, /* GL_NORMAL_ARRAY */
+       189, /* GL_COLOR_ARRAY */
+       735, /* GL_INDEX_ARRAY */
+      2012, /* GL_TEXTURE_COORD_ARRAY */
+       518, /* GL_EDGE_FLAG_ARRAY */
+      2223, /* GL_VERTEX_ARRAY_SIZE */
+      2225, /* GL_VERTEX_ARRAY_TYPE */
+      2224, /* GL_VERTEX_ARRAY_STRIDE */
+      1232, /* GL_NORMAL_ARRAY_TYPE */
+      1231, /* GL_NORMAL_ARRAY_STRIDE */
+       193, /* GL_COLOR_ARRAY_SIZE */
+       195, /* GL_COLOR_ARRAY_TYPE */
+       194, /* GL_COLOR_ARRAY_STRIDE */
+       740, /* GL_INDEX_ARRAY_TYPE */
+       739, /* GL_INDEX_ARRAY_STRIDE */
+      2016, /* GL_TEXTURE_COORD_ARRAY_SIZE */
+      2018, /* GL_TEXTURE_COORD_ARRAY_TYPE */
+      2017, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
+       522, /* GL_EDGE_FLAG_ARRAY_STRIDE */
+      2222, /* GL_VERTEX_ARRAY_POINTER */
+      1230, /* GL_NORMAL_ARRAY_POINTER */
+       192, /* GL_COLOR_ARRAY_POINTER */
+       738, /* GL_INDEX_ARRAY_POINTER */
+      2015, /* GL_TEXTURE_COORD_ARRAY_POINTER */
+       521, /* GL_EDGE_FLAG_ARRAY_POINTER */
+      1205, /* GL_MULTISAMPLE */
+      1718, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
+      1720, /* GL_SAMPLE_ALPHA_TO_ONE */
+      1725, /* GL_SAMPLE_COVERAGE */
+      1722, /* GL_SAMPLE_BUFFERS */
+      1713, /* GL_SAMPLES */
+      1729, /* GL_SAMPLE_COVERAGE_VALUE */
+      1727, /* GL_SAMPLE_COVERAGE_INVERT */
+       237, /* GL_COLOR_MATRIX */
+       239, /* GL_COLOR_MATRIX_STACK_DEPTH */
+      1026, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
+      1412, /* GL_POST_COLOR_MATRIX_RED_SCALE */
+      1408, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
+      1403, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
+      1399, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
+      1410, /* GL_POST_COLOR_MATRIX_RED_BIAS */
+      1406, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
+      1401, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
+      1397, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
+      1995, /* GL_TEXTURE_COLOR_TABLE_SGI */
+      1502, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
+      1997, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
+        94, /* GL_BLEND_DST_RGB */
+       108, /* GL_BLEND_SRC_RGB */
+        92, /* GL_BLEND_DST_ALPHA */
+       106, /* GL_BLEND_SRC_ALPHA */
+       243, /* GL_COLOR_TABLE */
+      1422, /* GL_POST_CONVOLUTION_COLOR_TABLE */
+      1405, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
+      1488, /* GL_PROXY_COLOR_TABLE */
+      1492, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
+      1491, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
+       267, /* GL_COLOR_TABLE_SCALE */
+       247, /* GL_COLOR_TABLE_BIAS */
+       252, /* GL_COLOR_TABLE_FORMAT */
+       269, /* GL_COLOR_TABLE_WIDTH */
+       264, /* GL_COLOR_TABLE_RED_SIZE */
+       255, /* GL_COLOR_TABLE_GREEN_SIZE */
+       249, /* GL_COLOR_TABLE_BLUE_SIZE */
+       244, /* GL_COLOR_TABLE_ALPHA_SIZE */
+       261, /* GL_COLOR_TABLE_LUMINANCE_SIZE */
+       258, /* GL_COLOR_TABLE_INTENSITY_SIZE */
+        79, /* GL_BGR */
+        80, /* GL_BGRA */
+      1041, /* GL_MAX_ELEMENTS_VERTICES */
+      1040, /* GL_MAX_ELEMENTS_INDICES */
+      2061, /* GL_TEXTURE_INDEX_SIZE_EXT */
+       186, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */
+      1368, /* GL_POINT_SIZE_MIN */
+      1364, /* GL_POINT_SIZE_MAX */
+      1353, /* GL_POINT_FADE_THRESHOLD_SIZE */
+      1349, /* GL_POINT_DISTANCE_ATTENUATION */
+       159, /* GL_CLAMP_TO_BORDER */
+       162, /* GL_CLAMP_TO_EDGE */
+      2083, /* GL_TEXTURE_MIN_LOD */
+      2081, /* GL_TEXTURE_MAX_LOD */
+      1965, /* GL_TEXTURE_BASE_LEVEL */
+      2080, /* GL_TEXTURE_MAX_LEVEL */
+       726, /* GL_IGNORE_BORDER_HP */
+       321, /* GL_CONSTANT_BORDER_HP */
+      1596, /* GL_REPLICATE_BORDER_HP */
+       332, /* GL_CONVOLUTION_BORDER_COLOR */
+      1260, /* GL_OCCLUSION_TEST_HP */
+      1261, /* GL_OCCLUSION_TEST_RESULT_HP */
+       827, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
+      1989, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
+      1991, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
+      1993, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
+      1994, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+      1992, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
+      1990, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
+      1020, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
+      1021, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+      1432, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
+      1434, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
+      1431, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
+      1433, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
+      2069, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
+      2070, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
+      2068, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
+       682, /* GL_GENERATE_MIPMAP */
+       683, /* GL_GENERATE_MIPMAP_HINT */
+       595, /* GL_FOG_OFFSET_SGIX */
+       596, /* GL_FOG_OFFSET_VALUE_SGIX */
+      2003, /* GL_TEXTURE_COMPARE_SGIX */
+      2002, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
+      2065, /* GL_TEXTURE_LEQUAL_R_SGIX */
+      2057, /* GL_TEXTURE_GEQUAL_R_SGIX */
+       415, /* GL_DEPTH_COMPONENT16 */
+       419, /* GL_DEPTH_COMPONENT24 */
+       423, /* GL_DEPTH_COMPONENT32 */
+       357, /* GL_CULL_VERTEX_EXT */
+       359, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */
+       358, /* GL_CULL_VERTEX_EYE_POSITION_EXT */
+      2290, /* GL_WRAP_BORDER_SUN */
+      1996, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
+       820, /* GL_LIGHT_MODEL_COLOR_CONTROL */
+      1763, /* GL_SINGLE_COLOR */
+      1747, /* GL_SEPARATE_SPECULAR_COLOR */
+      1758, /* GL_SHARED_TEXTURE_PALETTE_EXT */
+       607, /* GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING */
+       608, /* GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE */
+       619, /* GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE */
+       610, /* GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE */
+       606, /* GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE */
+       605, /* GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE */
+       609, /* GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE */
+       620, /* GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE */
+       637, /* GL_FRAMEBUFFER_DEFAULT */
+       664, /* GL_FRAMEBUFFER_UNDEFINED */
+       431, /* GL_DEPTH_STENCIL_ATTACHMENT */
+       896, /* GL_MAJOR_VERSION */
+      1151, /* GL_MINOR_VERSION */
+      1241, /* GL_NUM_EXTENSIONS */
+       327, /* GL_CONTEXT_FLAGS */
+       734, /* GL_INDEX */
+       409, /* GL_DEPTH_BUFFER */
+      1837, /* GL_STENCIL_BUFFER */
+       298, /* GL_COMPRESSED_RED */
+       299, /* GL_COMPRESSED_RG */
+      2160, /* GL_UNSIGNED_BYTE_2_3_3_REV */
+      2205, /* GL_UNSIGNED_SHORT_5_6_5 */
+      2206, /* GL_UNSIGNED_SHORT_5_6_5_REV */
+      2202, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
+      2199, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
+      2174, /* GL_UNSIGNED_INT_8_8_8_8_REV */
+      2170, /* GL_UNSIGNED_INT_2_10_10_10_REV */
+      2078, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
+      2079, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
+      2077, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
+      1155, /* GL_MIRRORED_REPEAT */
+      1684, /* GL_RGB_S3TC */
+      1626, /* GL_RGB4_S3TC */
+      1680, /* GL_RGBA_S3TC */
+      1665, /* GL_RGBA4_S3TC */
+      1674, /* GL_RGBA_DXT5_S3TC */
+      1662, /* GL_RGBA4_DXT5_S3TC */
+       309, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */
+       304, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */
+       305, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */
+       306, /* GL_COMPRESSED_RGBA_S3TC_DXT5_EXT */
+      1217, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
+      1216, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
+       828, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
+       582, /* GL_FOG_COORDINATE_SOURCE */
+       574, /* GL_FOG_COORD */
+       598, /* GL_FRAGMENT_DEPTH */
+       363, /* GL_CURRENT_FOG_COORD */
+       581, /* GL_FOG_COORDINATE_ARRAY_TYPE */
+       580, /* GL_FOG_COORDINATE_ARRAY_STRIDE */
+       579, /* GL_FOG_COORDINATE_ARRAY_POINTER */
+       576, /* GL_FOG_COORDINATE_ARRAY */
+       241, /* GL_COLOR_SUM */
+       384, /* GL_CURRENT_SECONDARY_COLOR */
+      1738, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
+      1740, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
+      1739, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
+      1737, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
+      1734, /* GL_SECONDARY_COLOR_ARRAY */
+       382, /* GL_CURRENT_RASTER_SECONDARY_COLOR */
+        29, /* GL_ALIASED_POINT_SIZE_RANGE */
+        28, /* GL_ALIASED_LINE_WIDTH_RANGE */
+      1891, /* GL_TEXTURE0 */
+      1893, /* GL_TEXTURE1 */
+      1915, /* GL_TEXTURE2 */
+      1937, /* GL_TEXTURE3 */
+      1943, /* GL_TEXTURE4 */
+      1945, /* GL_TEXTURE5 */
+      1947, /* GL_TEXTURE6 */
+      1949, /* GL_TEXTURE7 */
+      1951, /* GL_TEXTURE8 */
+      1953, /* GL_TEXTURE9 */
+      1894, /* GL_TEXTURE10 */
+      1896, /* GL_TEXTURE11 */
+      1898, /* GL_TEXTURE12 */
+      1900, /* GL_TEXTURE13 */
+      1902, /* GL_TEXTURE14 */
+      1904, /* GL_TEXTURE15 */
+      1906, /* GL_TEXTURE16 */
+      1908, /* GL_TEXTURE17 */
+      1910, /* GL_TEXTURE18 */
+      1912, /* GL_TEXTURE19 */
+      1916, /* GL_TEXTURE20 */
+      1918, /* GL_TEXTURE21 */
+      1920, /* GL_TEXTURE22 */
+      1922, /* GL_TEXTURE23 */
+      1924, /* GL_TEXTURE24 */
+      1926, /* GL_TEXTURE25 */
+      1928, /* GL_TEXTURE26 */
+      1930, /* GL_TEXTURE27 */
+      1932, /* GL_TEXTURE28 */
+      1934, /* GL_TEXTURE29 */
+      1938, /* GL_TEXTURE30 */
+      1940, /* GL_TEXTURE31 */
+        19, /* GL_ACTIVE_TEXTURE */
+       166, /* GL_CLIENT_ACTIVE_TEXTURE */
+      1116, /* GL_MAX_TEXTURE_UNITS */
+      2133, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
+      2136, /* GL_TRANSPOSE_PROJECTION_MATRIX */
+      2138, /* GL_TRANSPOSE_TEXTURE_MATRIX */
+      2130, /* GL_TRANSPOSE_COLOR_MATRIX */
+      1873, /* GL_SUBTRACT */
+      1098, /* GL_MAX_RENDERBUFFER_SIZE */
+       290, /* GL_COMPRESSED_ALPHA */
+       294, /* GL_COMPRESSED_LUMINANCE */
+       295, /* GL_COMPRESSED_LUMINANCE_ALPHA */
+       292, /* GL_COMPRESSED_INTENSITY */
+       300, /* GL_COMPRESSED_RGB */
+       301, /* GL_COMPRESSED_RGBA */
+      2010, /* GL_TEXTURE_COMPRESSION_HINT */
+      2087, /* GL_TEXTURE_RECTANGLE */
+      1978, /* GL_TEXTURE_BINDING_RECTANGLE */
+      1505, /* GL_PROXY_TEXTURE_RECTANGLE */
+      1095, /* GL_MAX_RECTANGLE_TEXTURE_SIZE */
+       430, /* GL_DEPTH_STENCIL */
+      2166, /* GL_UNSIGNED_INT_24_8 */
+      1111, /* GL_MAX_TEXTURE_LOD_BIAS */
+      2076, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
+      1113, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
+      2048, /* GL_TEXTURE_FILTER_CONTROL */
+      2066, /* GL_TEXTURE_LOD_BIAS */
+       274, /* GL_COMBINE4 */
+      1104, /* GL_MAX_SHININESS_NV */
+      1105, /* GL_MAX_SPOT_EXPONENT_NV */
+       732, /* GL_INCR_WRAP */
+       395, /* GL_DECR_WRAP */
+      1175, /* GL_MODELVIEW1_ARB */
+      1233, /* GL_NORMAL_MAP */
+      1556, /* GL_REFLECTION_MAP */
+      2020, /* GL_TEXTURE_CUBE_MAP */
+      1975, /* GL_TEXTURE_BINDING_CUBE_MAP */
+      2032, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
+      2022, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
+      2035, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
+      2025, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
+      2038, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
+      2028, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
+      1503, /* GL_PROXY_TEXTURE_CUBE_MAP */
+      1034, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
+      1211, /* GL_MULTISAMPLE_FILTER_HINT_NV */
+      1446, /* GL_PRIMITIVE_RESTART_NV */
+      1445, /* GL_PRIMITIVE_RESTART_INDEX_NV */
+       590, /* GL_FOG_DISTANCE_MODE_NV */
+       537, /* GL_EYE_RADIAL_NV */
+       536, /* GL_EYE_PLANE_ABSOLUTE_NV */
+       273, /* GL_COMBINE */
+       280, /* GL_COMBINE_RGB */
+       275, /* GL_COMBINE_ALPHA */
+      1685, /* GL_RGB_SCALE */
+        25, /* GL_ADD_SIGNED */
+       768, /* GL_INTERPOLATE */
+       316, /* GL_CONSTANT */
+      1438, /* GL_PRIMARY_COLOR */
+      1435, /* GL_PREVIOUS */
+      1778, /* GL_SOURCE0_RGB */
+      1784, /* GL_SOURCE1_RGB */
+      1790, /* GL_SOURCE2_RGB */
+      1794, /* GL_SOURCE3_RGB_NV */
+      1775, /* GL_SOURCE0_ALPHA */
+      1781, /* GL_SOURCE1_ALPHA */
+      1787, /* GL_SOURCE2_ALPHA */
+      1793, /* GL_SOURCE3_ALPHA_NV */
+      1274, /* GL_OPERAND0_RGB */
+      1280, /* GL_OPERAND1_RGB */
+      1286, /* GL_OPERAND2_RGB */
+      1290, /* GL_OPERAND3_RGB_NV */
+      1271, /* GL_OPERAND0_ALPHA */
+      1277, /* GL_OPERAND1_ALPHA */
+      1283, /* GL_OPERAND2_ALPHA */
+      1289, /* GL_OPERAND3_ALPHA_NV */
+       137, /* GL_BUFFER_OBJECT_APPLE */
+      2218, /* GL_VERTEX_ARRAY_BINDING */
+      2085, /* GL_TEXTURE_RANGE_LENGTH_APPLE */
+      2086, /* GL_TEXTURE_RANGE_POINTER_APPLE */
+      2295, /* GL_YCBCR_422_APPLE */
+      2207, /* GL_UNSIGNED_SHORT_8_8_APPLE */
+      2209, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
+      2097, /* GL_TEXTURE_STORAGE_HINT_APPLE */
+      1864, /* GL_STORAGE_PRIVATE_APPLE */
+      1863, /* GL_STORAGE_CACHED_APPLE */
+      1865, /* GL_STORAGE_SHARED_APPLE */
+      1765, /* GL_SLICE_ACCUM_SUN */
+      1514, /* GL_QUAD_MESH_SUN */
+      2144, /* GL_TRIANGLE_MESH_SUN */
+      2260, /* GL_VERTEX_PROGRAM_ARB */
+      2271, /* GL_VERTEX_STATE_PROGRAM_NV */
+      2245, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED */
+      2253, /* GL_VERTEX_ATTRIB_ARRAY_SIZE */
+      2255, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE */
+      2257, /* GL_VERTEX_ATTRIB_ARRAY_TYPE */
+       386, /* GL_CURRENT_VERTEX_ATTRIB */
+      1459, /* GL_PROGRAM_LENGTH_ARB */
+      1475, /* GL_PROGRAM_STRING_ARB */
+      1198, /* GL_MODELVIEW_PROJECTION_NV */
+       725, /* GL_IDENTITY_NV */
+       800, /* GL_INVERSE_NV */
+      2135, /* GL_TRANSPOSE_NV */
+       801, /* GL_INVERSE_TRANSPOSE_NV */
+      1079, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
+      1078, /* GL_MAX_PROGRAM_MATRICES_ARB */
+       960, /* GL_MATRIX0_NV */
+       972, /* GL_MATRIX1_NV */
+       984, /* GL_MATRIX2_NV */
+       988, /* GL_MATRIX3_NV */
+       990, /* GL_MATRIX4_NV */
+       992, /* GL_MATRIX5_NV */
+       994, /* GL_MATRIX6_NV */
+       996, /* GL_MATRIX7_NV */
+       369, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */
+       366, /* GL_CURRENT_MATRIX_ARB */
+      1472, /* GL_PROGRAM_POINT_SIZE */
+      2266, /* GL_VERTEX_PROGRAM_TWO_SIDE */
+      1471, /* GL_PROGRAM_PARAMETER_NV */
+      2251, /* GL_VERTEX_ATTRIB_ARRAY_POINTER */
+      1477, /* GL_PROGRAM_TARGET_NV */
+      1474, /* GL_PROGRAM_RESIDENT_NV */
+      2107, /* GL_TRACK_MATRIX_NV */
+      2108, /* GL_TRACK_MATRIX_TRANSFORM_NV */
+      2261, /* GL_VERTEX_PROGRAM_BINDING_NV */
+      1453, /* GL_PROGRAM_ERROR_POSITION_ARB */
+       411, /* GL_DEPTH_CLAMP */
+      2226, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
+      2233, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
+      2234, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
+      2235, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
+      2236, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
+      2237, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
+      2238, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
+      2239, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
+      2240, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
+      2241, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
+      2227, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
+      2228, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
+      2229, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
+      2230, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
+      2231, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
+      2232, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
+       908, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
+       915, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
+       916, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
+       917, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
+       918, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
+       919, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
+       920, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
+       921, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
+       922, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
+       923, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
+       909, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
+       910, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
+       911, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
+       912, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
+       913, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
+       914, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
+       935, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
+       942, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
+       943, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
+       944, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
+       945, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
+       946, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
+       947, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
+      1452, /* GL_PROGRAM_BINDING_ARB */
+       949, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
+       950, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
+       936, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
+       937, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
+       938, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
+       939, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
+       940, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
+       941, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
+      2008, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
+      2005, /* GL_TEXTURE_COMPRESSED */
+      1239, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
+       314, /* GL_COMPRESSED_TEXTURE_FORMATS */
+      1138, /* GL_MAX_VERTEX_UNITS_ARB */
+        23, /* GL_ACTIVE_VERTEX_UNITS_ARB */
+      2289, /* GL_WEIGHT_SUM_UNITY_ARB */
+      2259, /* GL_VERTEX_BLEND_ARB */
+       388, /* GL_CURRENT_WEIGHT_ARB */
+      2287, /* GL_WEIGHT_ARRAY_TYPE_ARB */
+      2285, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
+      2283, /* GL_WEIGHT_ARRAY_SIZE_ARB */
+      2281, /* GL_WEIGHT_ARRAY_POINTER_ARB */
+      2276, /* GL_WEIGHT_ARRAY_ARB */
+       445, /* GL_DOT3_RGB */
+       446, /* GL_DOT3_RGBA */
+       308, /* GL_COMPRESSED_RGB_FXT1_3DFX */
+       303, /* GL_COMPRESSED_RGBA_FXT1_3DFX */
+      1206, /* GL_MULTISAMPLE_3DFX */
+      1723, /* GL_SAMPLE_BUFFERS_3DFX */
+      1714, /* GL_SAMPLES_3DFX */
+      1186, /* GL_MODELVIEW2_ARB */
+      1189, /* GL_MODELVIEW3_ARB */
+      1190, /* GL_MODELVIEW4_ARB */
+      1191, /* GL_MODELVIEW5_ARB */
+      1192, /* GL_MODELVIEW6_ARB */
+      1193, /* GL_MODELVIEW7_ARB */
+      1194, /* GL_MODELVIEW8_ARB */
+      1195, /* GL_MODELVIEW9_ARB */
+      1165, /* GL_MODELVIEW10_ARB */
+      1166, /* GL_MODELVIEW11_ARB */
+      1167, /* GL_MODELVIEW12_ARB */
+      1168, /* GL_MODELVIEW13_ARB */
+      1169, /* GL_MODELVIEW14_ARB */
+      1170, /* GL_MODELVIEW15_ARB */
+      1171, /* GL_MODELVIEW16_ARB */
+      1172, /* GL_MODELVIEW17_ARB */
+      1173, /* GL_MODELVIEW18_ARB */
+      1174, /* GL_MODELVIEW19_ARB */
+      1176, /* GL_MODELVIEW20_ARB */
+      1177, /* GL_MODELVIEW21_ARB */
+      1178, /* GL_MODELVIEW22_ARB */
+      1179, /* GL_MODELVIEW23_ARB */
+      1180, /* GL_MODELVIEW24_ARB */
+      1181, /* GL_MODELVIEW25_ARB */
+      1182, /* GL_MODELVIEW26_ARB */
+      1183, /* GL_MODELVIEW27_ARB */
+      1184, /* GL_MODELVIEW28_ARB */
+      1185, /* GL_MODELVIEW29_ARB */
+      1187, /* GL_MODELVIEW30_ARB */
+      1188, /* GL_MODELVIEW31_ARB */
+       450, /* GL_DOT3_RGB_EXT */
+       448, /* GL_DOT3_RGBA_EXT */
+      1159, /* GL_MIRROR_CLAMP_EXT */
+      1162, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
+      1201, /* GL_MODULATE_ADD_ATI */
+      1202, /* GL_MODULATE_SIGNED_ADD_ATI */
+      1203, /* GL_MODULATE_SUBTRACT_ATI */
+      2296, /* GL_YCBCR_MESA */
+      1298, /* GL_PACK_INVERT_MESA */
+       391, /* GL_DEBUG_OBJECT_MESA */
+       392, /* GL_DEBUG_PRINT_MESA */
+       390, /* GL_DEBUG_ASSERT_MESA */
+       139, /* GL_BUFFER_SIZE */
+       141, /* GL_BUFFER_USAGE */
+       145, /* GL_BUMP_ROT_MATRIX_ATI */
+       146, /* GL_BUMP_ROT_MATRIX_SIZE_ATI */
+       144, /* GL_BUMP_NUM_TEX_UNITS_ATI */
+       148, /* GL_BUMP_TEX_UNITS_ATI */
+       510, /* GL_DUDV_ATI */
+       509, /* GL_DU8DV8_ATI */
+       143, /* GL_BUMP_ENVMAP_ATI */
+       147, /* GL_BUMP_TARGET_ATI */
+      1242, /* GL_NUM_PROGRAM_BINARY_FORMATS_OES */
+      1450, /* GL_PROGRAM_BINARY_FORMATS_OES */
+      1827, /* GL_STENCIL_BACK_FUNC */
+      1825, /* GL_STENCIL_BACK_FAIL */
+      1829, /* GL_STENCIL_BACK_PASS_DEPTH_FAIL */
+      1831, /* GL_STENCIL_BACK_PASS_DEPTH_PASS */
+       599, /* GL_FRAGMENT_PROGRAM_ARB */
+      1448, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
+      1480, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
+      1479, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
+      1462, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+      1468, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+      1467, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+      1068, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
+      1093, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
+      1092, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
+      1081, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+      1087, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+      1086, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+      1656, /* GL_RGBA32F */
+      1619, /* GL_RGB32F */
+      1647, /* GL_RGBA16F */
+      1611, /* GL_RGB16F */
+      1675, /* GL_RGBA_FLOAT_MODE_ARB */
+      1037, /* GL_MAX_DRAW_BUFFERS */
+       454, /* GL_DRAW_BUFFER0 */
+       457, /* GL_DRAW_BUFFER1 */
+       478, /* GL_DRAW_BUFFER2 */
+       481, /* GL_DRAW_BUFFER3 */
+       484, /* GL_DRAW_BUFFER4 */
+       487, /* GL_DRAW_BUFFER5 */
+       490, /* GL_DRAW_BUFFER6 */
+       493, /* GL_DRAW_BUFFER7 */
+       496, /* GL_DRAW_BUFFER8 */
+       499, /* GL_DRAW_BUFFER9 */
+       458, /* GL_DRAW_BUFFER10 */
+       461, /* GL_DRAW_BUFFER11 */
+       464, /* GL_DRAW_BUFFER12 */
+       467, /* GL_DRAW_BUFFER13 */
+       470, /* GL_DRAW_BUFFER14 */
+       473, /* GL_DRAW_BUFFER15 */
+        97, /* GL_BLEND_EQUATION_ALPHA */
+      1011, /* GL_MATRIX_PALETTE_ARB */
+      1061, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
+      1064, /* GL_MAX_PALETTE_MATRICES_ARB */
+       372, /* GL_CURRENT_PALETTE_MATRIX_ARB */
+       999, /* GL_MATRIX_INDEX_ARRAY_ARB */
+       367, /* GL_CURRENT_MATRIX_INDEX_ARB */
+      1004, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
+      1008, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
+      1006, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
+      1002, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
+      2043, /* GL_TEXTURE_DEPTH_SIZE */
+       438, /* GL_DEPTH_TEXTURE_MODE */
+      2000, /* GL_TEXTURE_COMPARE_MODE */
+      1998, /* GL_TEXTURE_COMPARE_FUNC */
+       284, /* GL_COMPARE_REF_TO_TEXTURE */
+      1375, /* GL_POINT_SPRITE */
+       346, /* GL_COORD_REPLACE */
+      1380, /* GL_POINT_SPRITE_R_MODE_NV */
+      1520, /* GL_QUERY_COUNTER_BITS */
+       375, /* GL_CURRENT_QUERY */
+      1524, /* GL_QUERY_RESULT */
+      1526, /* GL_QUERY_RESULT_AVAILABLE */
+      1130, /* GL_MAX_VERTEX_ATTRIBS */
+      2249, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED */
+       436, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
+       435, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
+      1107, /* GL_MAX_TEXTURE_COORDS */
+      1109, /* GL_MAX_TEXTURE_IMAGE_UNITS */
+      1455, /* GL_PROGRAM_ERROR_STRING_ARB */
+      1457, /* GL_PROGRAM_FORMAT_ASCII_ARB */
+      1456, /* GL_PROGRAM_FORMAT_ARB */
+      2099, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
+       408, /* GL_DEPTH_BOUNDS_TEST_EXT */
+       407, /* GL_DEPTH_BOUNDS_EXT */
+        61, /* GL_ARRAY_BUFFER */
+       523, /* GL_ELEMENT_ARRAY_BUFFER */
+        62, /* GL_ARRAY_BUFFER_BINDING */
+       524, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
+      2220, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
+      1228, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
+       190, /* GL_COLOR_ARRAY_BUFFER_BINDING */
+       736, /* GL_INDEX_ARRAY_BUFFER_BINDING */
+      2013, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
+       519, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
+      1735, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
+       577, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
+      2277, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
+      2242, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
+      1458, /* GL_PROGRAM_INSTRUCTIONS_ARB */
+      1074, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
+      1464, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+      1083, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+      1478, /* GL_PROGRAM_TEMPORARIES_ARB */
+      1089, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
+      1466, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
+      1085, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
+      1470, /* GL_PROGRAM_PARAMETERS_ARB */
+      1088, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
+      1465, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
+      1084, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
+      1449, /* GL_PROGRAM_ATTRIBS_ARB */
+      1069, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
+      1463, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
+      1082, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
+      1447, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
+      1067, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
+      1461, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+      1080, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+      1075, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
+      1071, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
+      1481, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
+      2132, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
+      1543, /* GL_READ_ONLY */
+      2291, /* GL_WRITE_ONLY */
+      1545, /* GL_READ_WRITE */
+       124, /* GL_BUFFER_ACCESS */
+       129, /* GL_BUFFER_MAPPED */
+       134, /* GL_BUFFER_MAP_POINTER */
+      2106, /* GL_TIME_ELAPSED_EXT */
+       959, /* GL_MATRIX0_ARB */
+       971, /* GL_MATRIX1_ARB */
+       983, /* GL_MATRIX2_ARB */
+       987, /* GL_MATRIX3_ARB */
+       989, /* GL_MATRIX4_ARB */
+       991, /* GL_MATRIX5_ARB */
+       993, /* GL_MATRIX6_ARB */
+       995, /* GL_MATRIX7_ARB */
+       997, /* GL_MATRIX8_ARB */
+       998, /* GL_MATRIX9_ARB */
+       961, /* GL_MATRIX10_ARB */
+       962, /* GL_MATRIX11_ARB */
+       963, /* GL_MATRIX12_ARB */
+       964, /* GL_MATRIX13_ARB */
+       965, /* GL_MATRIX14_ARB */
+       966, /* GL_MATRIX15_ARB */
+       967, /* GL_MATRIX16_ARB */
+       968, /* GL_MATRIX17_ARB */
+       969, /* GL_MATRIX18_ARB */
+       970, /* GL_MATRIX19_ARB */
+       973, /* GL_MATRIX20_ARB */
+       974, /* GL_MATRIX21_ARB */
+       975, /* GL_MATRIX22_ARB */
+       976, /* GL_MATRIX23_ARB */
+       977, /* GL_MATRIX24_ARB */
+       978, /* GL_MATRIX25_ARB */
+       979, /* GL_MATRIX26_ARB */
+       980, /* GL_MATRIX27_ARB */
+       981, /* GL_MATRIX28_ARB */
+       982, /* GL_MATRIX29_ARB */
+       985, /* GL_MATRIX30_ARB */
+       986, /* GL_MATRIX31_ARB */
+      1868, /* GL_STREAM_DRAW */
+      1870, /* GL_STREAM_READ */
+      1866, /* GL_STREAM_COPY */
+      1817, /* GL_STATIC_DRAW */
+      1819, /* GL_STATIC_READ */
+      1815, /* GL_STATIC_COPY */
+       513, /* GL_DYNAMIC_DRAW */
+       515, /* GL_DYNAMIC_READ */
+       511, /* GL_DYNAMIC_COPY */
+      1338, /* GL_PIXEL_PACK_BUFFER */
+      1342, /* GL_PIXEL_UNPACK_BUFFER */
+      1339, /* GL_PIXEL_PACK_BUFFER_BINDING */
+      1343, /* GL_PIXEL_UNPACK_BUFFER_BINDING */
+       399, /* GL_DEPTH24_STENCIL8 */
+      2095, /* GL_TEXTURE_STENCIL_SIZE */
+      2041, /* GL_TEXTURE_CUBE_MAP_SEAMLESS */
+      1070, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
+      1073, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
+      1077, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
+      1076, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
+      2247, /* GL_VERTEX_ATTRIB_ARRAY_INTEGER */
+      2244, /* GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB */
+      1016, /* GL_MAX_ARRAY_TEXTURE_LAYERS */
+      1153, /* GL_MIN_PROGRAM_TEXEL_OFFSET */
+      1090, /* GL_MAX_PROGRAM_TEXEL_OFFSET */
+      1859, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
+        18, /* GL_ACTIVE_STENCIL_FACE_EXT */
+      1160, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
+      1716, /* GL_SAMPLES_PASSED */
+       692, /* GL_GEOMETRY_VERTICES_OUT */
+       686, /* GL_GEOMETRY_INPUT_TYPE */
+       688, /* GL_GEOMETRY_OUTPUT_TYPE */
+       164, /* GL_CLAMP_VERTEX_COLOR_ARB */
+       156, /* GL_CLAMP_FRAGMENT_COLOR_ARB */
+       157, /* GL_CLAMP_READ_COLOR */
+       549, /* GL_FIXED_ONLY */
+      1362, /* GL_POINT_SIZE_ARRAY_TYPE_OES */
+      1361, /* GL_POINT_SIZE_ARRAY_STRIDE_OES */
+      1360, /* GL_POINT_SIZE_ARRAY_POINTER_OES */
+      1197, /* GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES */
+      1484, /* GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES */
+      2075, /* GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES */
+       138, /* GL_BUFFER_SERIALIZED_MODIFY_APPLE */
+       128, /* GL_BUFFER_FLUSHING_UNMAP_APPLE */
+      1560, /* GL_RELEASED_APPLE */
+      2274, /* GL_VOLATILE_APPLE */
+      1599, /* GL_RETAINED_APPLE */
+      2149, /* GL_UNDEFINED_APPLE */
+      1508, /* GL_PURGEABLE_APPLE */
+       600, /* GL_FRAGMENT_SHADER */
+      2269, /* GL_VERTEX_SHADER */
+      1469, /* GL_PROGRAM_OBJECT_ARB */
+      1752, /* GL_SHADER_OBJECT_ARB */
+      1045, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS */
+      1135, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS */
+      1126, /* GL_MAX_VARYING_COMPONENTS */
+      1133, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS */
+      1028, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS */
+      1258, /* GL_OBJECT_TYPE_ARB */
+      1754, /* GL_SHADER_TYPE */
+       565, /* GL_FLOAT_VEC2 */
+       567, /* GL_FLOAT_VEC3 */
+       569, /* GL_FLOAT_VEC4 */
+       788, /* GL_INT_VEC2 */
+       790, /* GL_INT_VEC3 */
+       792, /* GL_INT_VEC4 */
+       116, /* GL_BOOL */
+       118, /* GL_BOOL_VEC2 */
+       120, /* GL_BOOL_VEC3 */
+       122, /* GL_BOOL_VEC4 */
+       553, /* GL_FLOAT_MAT2 */
+       557, /* GL_FLOAT_MAT3 */
+       561, /* GL_FLOAT_MAT4 */
+      1692, /* GL_SAMPLER_1D */
+      1698, /* GL_SAMPLER_2D */
+      1706, /* GL_SAMPLER_3D */
+      1710, /* GL_SAMPLER_CUBE */
+      1697, /* GL_SAMPLER_1D_SHADOW */
+      1705, /* GL_SAMPLER_2D_SHADOW */
+      1703, /* GL_SAMPLER_2D_RECT */
+      1704, /* GL_SAMPLER_2D_RECT_SHADOW */
+       555, /* GL_FLOAT_MAT2x3 */
+       556, /* GL_FLOAT_MAT2x4 */
+       559, /* GL_FLOAT_MAT3x2 */
+       560, /* GL_FLOAT_MAT3x4 */
+       563, /* GL_FLOAT_MAT4x2 */
+       564, /* GL_FLOAT_MAT4x3 */
+       397, /* GL_DELETE_STATUS */
+       289, /* GL_COMPILE_STATUS */
+       849, /* GL_LINK_STATUS */
+      2214, /* GL_VALIDATE_STATUS */
+       748, /* GL_INFO_LOG_LENGTH */
+        64, /* GL_ATTACHED_SHADERS */
+        21, /* GL_ACTIVE_UNIFORMS */
+        22, /* GL_ACTIVE_UNIFORM_MAX_LENGTH */
+      1753, /* GL_SHADER_SOURCE_LENGTH */
+        15, /* GL_ACTIVE_ATTRIBUTES */
+        16, /* GL_ACTIVE_ATTRIBUTE_MAX_LENGTH */
+       602, /* GL_FRAGMENT_SHADER_DERIVATIVE_HINT */
+      1756, /* GL_SHADING_LANGUAGE_VERSION */
+       374, /* GL_CURRENT_PROGRAM */
+      1307, /* GL_PALETTE4_RGB8_OES */
+      1309, /* GL_PALETTE4_RGBA8_OES */
+      1305, /* GL_PALETTE4_R5_G6_B5_OES */
+      1308, /* GL_PALETTE4_RGBA4_OES */
+      1306, /* GL_PALETTE4_RGB5_A1_OES */
+      1312, /* GL_PALETTE8_RGB8_OES */
+      1314, /* GL_PALETTE8_RGBA8_OES */
+      1310, /* GL_PALETTE8_R5_G6_B5_OES */
+      1313, /* GL_PALETTE8_RGBA4_OES */
+      1311, /* GL_PALETTE8_RGB5_A1_OES */
+       729, /* GL_IMPLEMENTATION_COLOR_READ_TYPE */
+       727, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT */
+      1359, /* GL_POINT_SIZE_ARRAY_OES */
+      2019, /* GL_TEXTURE_CROP_RECT_OES */
+      1000, /* GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES */
+      1358, /* GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES */
+      2197, /* GL_UNSIGNED_NORMALIZED */
+      1956, /* GL_TEXTURE_1D_ARRAY */
+      1494, /* GL_PROXY_TEXTURE_1D_ARRAY */
+      1959, /* GL_TEXTURE_2D_ARRAY */
+      1498, /* GL_PROXY_TEXTURE_2D_ARRAY */
+      1967, /* GL_TEXTURE_BINDING_1D_ARRAY */
+      1970, /* GL_TEXTURE_BINDING_2D_ARRAY */
+      1052, /* GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS */
+      1986, /* GL_TEXTURE_BUFFER */
+      1106, /* GL_MAX_TEXTURE_BUFFER_SIZE */
+      1974, /* GL_TEXTURE_BINDING_BUFFER */
+      1987, /* GL_TEXTURE_BUFFER_DATA_STORE_BINDING */
+      1988, /* GL_TEXTURE_BUFFER_FORMAT */
+      1531, /* GL_R11F_G11F_B10F */
+      2163, /* GL_UNSIGNED_INT_10F_11F_11F_REV */
+      1642, /* GL_RGB9_E5 */
+      2172, /* GL_UNSIGNED_INT_5_9_9_9_REV */
+      2093, /* GL_TEXTURE_SHARED_SIZE */
+      1809, /* GL_SRGB */
+      1810, /* GL_SRGB8 */
+      1812, /* GL_SRGB_ALPHA */
+      1811, /* GL_SRGB8_ALPHA8 */
+      1769, /* GL_SLUMINANCE_ALPHA */
+      1768, /* GL_SLUMINANCE8_ALPHA8 */
+      1766, /* GL_SLUMINANCE */
+      1767, /* GL_SLUMINANCE8 */
+       312, /* GL_COMPRESSED_SRGB */
+       313, /* GL_COMPRESSED_SRGB_ALPHA */
+       310, /* GL_COMPRESSED_SLUMINANCE */
+       311, /* GL_COMPRESSED_SLUMINANCE_ALPHA */
+      2128, /* GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH */
+      2117, /* GL_TRANSFORM_FEEDBACK_BUFFER_MODE */
+      1124, /* GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS */
+      2126, /* GL_TRANSFORM_FEEDBACK_VARYINGS */
+      2122, /* GL_TRANSFORM_FEEDBACK_BUFFER_START */
+      2120, /* GL_TRANSFORM_FEEDBACK_BUFFER_SIZE */
+      1441, /* GL_PRIMITIVES_GENERATED */
+      2124, /* GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN */
+      1535, /* GL_RASTERIZER_DISCARD */
+      1120, /* GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS */
+      1122, /* GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS */
+       766, /* GL_INTERLEAVED_ATTRIBS */
+      1745, /* GL_SEPARATE_ATTRIBS */
+      2112, /* GL_TRANSFORM_FEEDBACK_BUFFER */
+      2114, /* GL_TRANSFORM_FEEDBACK_BUFFER_BINDING */
+      1377, /* GL_POINT_SPRITE_COORD_ORIGIN */
+       857, /* GL_LOWER_LEFT */
+      2211, /* GL_UPPER_LEFT */
+      1833, /* GL_STENCIL_BACK_REF */
+      1834, /* GL_STENCIL_BACK_VALUE_MASK */
+      1835, /* GL_STENCIL_BACK_WRITEMASK */
+       503, /* GL_DRAW_FRAMEBUFFER_BINDING */
+      1565, /* GL_RENDERBUFFER_BINDING */
+      1539, /* GL_READ_FRAMEBUFFER */
+       502, /* GL_DRAW_FRAMEBUFFER */
+      1540, /* GL_READ_FRAMEBUFFER_BINDING */
+      1584, /* GL_RENDERBUFFER_SAMPLES */
+       616, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE */
+       613, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME */
+       628, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL */
+       623, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE */
+       626, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER */
+       634, /* GL_FRAMEBUFFER_COMPLETE */
+       639, /* GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT */
+       654, /* GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT */
+       648, /* GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT */
+       643, /* GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT */
+       649, /* GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT */
+       645, /* GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER */
+       659, /* GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER */
+       665, /* GL_FRAMEBUFFER_UNSUPPORTED */
+       663, /* GL_FRAMEBUFFER_STATUS_ERROR_EXT */
+      1024, /* GL_MAX_COLOR_ATTACHMENTS */
+       196, /* GL_COLOR_ATTACHMENT0 */
+       199, /* GL_COLOR_ATTACHMENT1 */
+       213, /* GL_COLOR_ATTACHMENT2 */
+       215, /* GL_COLOR_ATTACHMENT3 */
+       217, /* GL_COLOR_ATTACHMENT4 */
+       219, /* GL_COLOR_ATTACHMENT5 */
+       221, /* GL_COLOR_ATTACHMENT6 */
+       223, /* GL_COLOR_ATTACHMENT7 */
+       225, /* GL_COLOR_ATTACHMENT8 */
+       227, /* GL_COLOR_ATTACHMENT9 */
+       200, /* GL_COLOR_ATTACHMENT10 */
+       202, /* GL_COLOR_ATTACHMENT11 */
+       204, /* GL_COLOR_ATTACHMENT12 */
+       206, /* GL_COLOR_ATTACHMENT13 */
+       208, /* GL_COLOR_ATTACHMENT14 */
+       210, /* GL_COLOR_ATTACHMENT15 */
+       402, /* GL_DEPTH_ATTACHMENT */
+      1822, /* GL_STENCIL_ATTACHMENT */
+       604, /* GL_FRAMEBUFFER */
+      1562, /* GL_RENDERBUFFER */
+      1588, /* GL_RENDERBUFFER_WIDTH */
+      1575, /* GL_RENDERBUFFER_HEIGHT */
+      1578, /* GL_RENDERBUFFER_INTERNAL_FORMAT */
+      1854, /* GL_STENCIL_INDEX_EXT */
+      1843, /* GL_STENCIL_INDEX1 */
+      1848, /* GL_STENCIL_INDEX4 */
+      1851, /* GL_STENCIL_INDEX8 */
+      1844, /* GL_STENCIL_INDEX16 */
+      1582, /* GL_RENDERBUFFER_RED_SIZE */
+      1573, /* GL_RENDERBUFFER_GREEN_SIZE */
+      1568, /* GL_RENDERBUFFER_BLUE_SIZE */
+      1563, /* GL_RENDERBUFFER_ALPHA_SIZE */
+      1570, /* GL_RENDERBUFFER_DEPTH_SIZE */
+      1586, /* GL_RENDERBUFFER_STENCIL_SIZE */
+       657, /* GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE */
+      1101, /* GL_MAX_SAMPLES */
+      2055, /* GL_TEXTURE_GEN_STR_OES */
+       703, /* GL_HALF_FLOAT_OES */
+      1629, /* GL_RGB565_OES */
+      1659, /* GL_RGBA32UI */
+      1622, /* GL_RGB32UI */
+        40, /* GL_ALPHA32UI_EXT */
+       758, /* GL_INTENSITY32UI_EXT */
+       874, /* GL_LUMINANCE32UI_EXT */
+       891, /* GL_LUMINANCE_ALPHA32UI_EXT */
+      1650, /* GL_RGBA16UI */
+      1614, /* GL_RGB16UI */
+        37, /* GL_ALPHA16UI_EXT */
+       755, /* GL_INTENSITY16UI_EXT */
+       869, /* GL_LUMINANCE16UI_EXT */
+       889, /* GL_LUMINANCE_ALPHA16UI_EXT */
+      1669, /* GL_RGBA8UI */
+      1637, /* GL_RGB8UI */
+        45, /* GL_ALPHA8UI_EXT */
+       763, /* GL_INTENSITY8UI_EXT */
+       883, /* GL_LUMINANCE8UI_EXT */
+       893, /* GL_LUMINANCE_ALPHA8UI_EXT */
+      1657, /* GL_RGBA32I */
+      1620, /* GL_RGB32I */
+        39, /* GL_ALPHA32I_EXT */
+       757, /* GL_INTENSITY32I_EXT */
+       873, /* GL_LUMINANCE32I_EXT */
+       890, /* GL_LUMINANCE_ALPHA32I_EXT */
+      1648, /* GL_RGBA16I */
+      1612, /* GL_RGB16I */
+        36, /* GL_ALPHA16I_EXT */
+       754, /* GL_INTENSITY16I_EXT */
+       868, /* GL_LUMINANCE16I_EXT */
+       888, /* GL_LUMINANCE_ALPHA16I_EXT */
+      1667, /* GL_RGBA8I */
+      1635, /* GL_RGB8I */
+        44, /* GL_ALPHA8I_EXT */
+       762, /* GL_INTENSITY8I_EXT */
+       882, /* GL_LUMINANCE8I_EXT */
+       892, /* GL_LUMINANCE_ALPHA8I_EXT */
+      1552, /* GL_RED_INTEGER */
+       699, /* GL_GREEN_INTEGER */
+       113, /* GL_BLUE_INTEGER */
+        49, /* GL_ALPHA_INTEGER_EXT */
+      1682, /* GL_RGB_INTEGER */
+      1676, /* GL_RGBA_INTEGER */
+        84, /* GL_BGR_INTEGER */
+        82, /* GL_BGRA_INTEGER */
+       895, /* GL_LUMINANCE_INTEGER_EXT */
+       894, /* GL_LUMINANCE_ALPHA_INTEGER_EXT */
+      1678, /* GL_RGBA_INTEGER_MODE_EXT */
+       611, /* GL_FRAMEBUFFER_ATTACHMENT_LAYERED */
+       652, /* GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS */
+       651, /* GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB */
+      1693, /* GL_SAMPLER_1D_ARRAY */
+      1699, /* GL_SAMPLER_2D_ARRAY */
+      1708, /* GL_SAMPLER_BUFFER */
+      1695, /* GL_SAMPLER_1D_ARRAY_SHADOW */
+      1701, /* GL_SAMPLER_2D_ARRAY_SHADOW */
+      1711, /* GL_SAMPLER_CUBE_SHADOW */
+      2191, /* GL_UNSIGNED_INT_VEC2 */
+      2193, /* GL_UNSIGNED_INT_VEC3 */
+      2195, /* GL_UNSIGNED_INT_VEC4 */
+       772, /* GL_INT_SAMPLER_1D */
+       776, /* GL_INT_SAMPLER_2D */
+       782, /* GL_INT_SAMPLER_3D */
+       786, /* GL_INT_SAMPLER_CUBE */
+       780, /* GL_INT_SAMPLER_2D_RECT */
+       773, /* GL_INT_SAMPLER_1D_ARRAY */
+       777, /* GL_INT_SAMPLER_2D_ARRAY */
+       784, /* GL_INT_SAMPLER_BUFFER */
+      2175, /* GL_UNSIGNED_INT_SAMPLER_1D */
+      2179, /* GL_UNSIGNED_INT_SAMPLER_2D */
+      2185, /* GL_UNSIGNED_INT_SAMPLER_3D */
+      2189, /* GL_UNSIGNED_INT_SAMPLER_CUBE */
+      2183, /* GL_UNSIGNED_INT_SAMPLER_2D_RECT */
+      2176, /* GL_UNSIGNED_INT_SAMPLER_1D_ARRAY */
+      2180, /* GL_UNSIGNED_INT_SAMPLER_2D_ARRAY */
+      2187, /* GL_UNSIGNED_INT_SAMPLER_BUFFER */
+       690, /* GL_GEOMETRY_SHADER */
+       693, /* GL_GEOMETRY_VERTICES_OUT_ARB */
+       687, /* GL_GEOMETRY_INPUT_TYPE_ARB */
+       689, /* GL_GEOMETRY_OUTPUT_TYPE_ARB */
+      1058, /* GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB */
+      1140, /* GL_MAX_VERTEX_VARYING_COMPONENTS_ARB */
+      1056, /* GL_MAX_GEOMETRY_UNIFORM_COMPONENTS */
+      1050, /* GL_MAX_GEOMETRY_OUTPUT_VERTICES */
+      1054, /* GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS */
+       858, /* GL_LOW_FLOAT */
+      1142, /* GL_MEDIUM_FLOAT */
+       704, /* GL_HIGH_FLOAT */
+       859, /* GL_LOW_INT */
+      1143, /* GL_MEDIUM_INT */
+       705, /* GL_HIGH_INT */
+      2165, /* GL_UNSIGNED_INT_10_10_10_2_OES */
+       771, /* GL_INT_10_10_10_2_OES */
+      1750, /* GL_SHADER_BINARY_FORMATS */
+      1243, /* GL_NUM_SHADER_BINARY_FORMATS */
+      1751, /* GL_SHADER_COMPILER */
+      1137, /* GL_MAX_VERTEX_UNIFORM_VECTORS */
+      1129, /* GL_MAX_VARYING_VECTORS */
+      1047, /* GL_MAX_FRAGMENT_UNIFORM_VECTORS */
+      1528, /* GL_QUERY_WAIT */
+      1522, /* GL_QUERY_NO_WAIT */
+      1518, /* GL_QUERY_BY_REGION_WAIT */
+      1516, /* GL_QUERY_BY_REGION_NO_WAIT */
+      2110, /* GL_TRANSFORM_FEEDBACK */
+      2119, /* GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED */
+      2113, /* GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE */
+      2111, /* GL_TRANSFORM_FEEDBACK_BINDING */
+      1512, /* GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION */
+       545, /* GL_FIRST_VERTEX_CONVENTION */
+       804, /* GL_LAST_VERTEX_CONVENTION */
+      1486, /* GL_PROVOKING_VERTEX */
+       353, /* GL_COPY_READ_BUFFER */
+       354, /* GL_COPY_WRITE_BUFFER */
+      1555, /* GL_RED_SNORM */
+      1689, /* GL_RG_SNORM */
+      1688, /* GL_RGB_SNORM */
+      1681, /* GL_RGBA_SNORM */
+      1534, /* GL_R8_SNORM */
+      1602, /* GL_RG8_SNORM */
+      1641, /* GL_RGB8_SNORM */
+      1673, /* GL_RGBA8_SNORM */
+      1532, /* GL_R16_SNORM */
+      1601, /* GL_RG16_SNORM */
+      1617, /* GL_RGB16_SNORM */
+      1653, /* GL_RGBA16_SNORM */
+      1762, /* GL_SIGNED_NORMALIZED */
+      1443, /* GL_PRIMITIVE_RESTART */
+      1444, /* GL_PRIMITIVE_RESTART_INDEX */
+      1103, /* GL_MAX_SERVER_WAIT_TIMEOUT */
+      1257, /* GL_OBJECT_TYPE */
+      1875, /* GL_SYNC_CONDITION */
+      1880, /* GL_SYNC_STATUS */
+      1877, /* GL_SYNC_FLAGS */
+      1876, /* GL_SYNC_FENCE */
+      1879, /* GL_SYNC_GPU_COMMANDS_COMPLETE */
+      2158, /* GL_UNSIGNALED */
+      1761, /* GL_SIGNALED */
+        54, /* GL_ALREADY_SIGNALED */
+      2105, /* GL_TIMEOUT_EXPIRED */
+       315, /* GL_CONDITION_SATISFIED */
+      2275, /* GL_WAIT_FAILED */
+       126, /* GL_BUFFER_ACCESS_FLAGS */
+       132, /* GL_BUFFER_MAP_LENGTH */
+       133, /* GL_BUFFER_MAP_OFFSET */
+      1132, /* GL_MAX_VERTEX_OUTPUT_COMPONENTS */
+      1048, /* GL_MAX_GEOMETRY_INPUT_COMPONENTS */
+      1049, /* GL_MAX_GEOMETRY_OUTPUT_COMPONENTS */
+      1044, /* GL_MAX_FRAGMENT_INPUT_COMPONENTS */
+       329, /* GL_CONTEXT_PROFILE_MASK */
+       530, /* GL_EVAL_BIT */
+      1537, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
+       851, /* GL_LIST_BIT */
+      1981, /* GL_TEXTURE_BIT */
+      1731, /* GL_SCISSOR_BIT */
+        30, /* GL_ALL_ATTRIB_BITS */
+      1208, /* GL_MULTISAMPLE_BIT */
+        31, /* GL_ALL_CLIENT_ATTRIB_BITS */
+};
+
+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 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 *) _mesa_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_snprintf(token_tmp, sizeof(token_tmp) - 1, "0x%x", nr);
+      token_tmp[sizeof(token_tmp) - 1] = '\0';
+      return token_tmp;
+   }
+}
+
+/**
+ * Primitive names
+ */
+static const char *prim_names[PRIM_UNKNOWN + 1] = {
+   "GL_POINTS",
+   "GL_LINES",
+   "GL_LINE_LOOP",
+   "GL_LINE_STRIP",
+   "GL_TRIANGLES",
+   "GL_TRIANGLE_STRIP",
+   "GL_TRIANGLE_FAN",
+   "GL_QUADS",
+   "GL_QUAD_STRIP",
+   "GL_POLYGON",
+   "outside begin/end",
+   "inside unknown primitive",
+   "unknown state"
+};
+
+
+/* Get the name of an enum given that it is a primitive type.  Avoids
+ * GL_FALSE/GL_POINTS ambiguity and others.
+ */
+const char *
+_mesa_lookup_prim_by_nr(GLuint nr)
+{
+   if (nr < Elements(prim_names))
+      return prim_names[nr];
+   else
+      return "invalid mode";
+}
+
+
+int _mesa_lookup_enum_by_name( const char *symbol )
+{
+   enum_elt * f = NULL;
+
+   if ( symbol != NULL ) {
+      f = (enum_elt *) _mesa_bsearch(symbol, all_enums,
+                                     Elements(all_enums),
+                                     sizeof( enum_elt ),
+                                     (cfunc) compar_name);
+   }
+
+   return (f != NULL) ? f->n : -1;
+}
+
+
diff --git a/mesalib/src/mesa/main/extensions.c b/mesalib/src/mesa/main/extensions.c
index d0c08ca71..285e08d75 100644
--- a/mesalib/src/mesa/main/extensions.c
+++ b/mesalib/src/mesa/main/extensions.c
@@ -79,6 +79,7 @@ static const struct extension extension_table[] = {
    /* ARB Extensions */
    { "GL_ARB_ES2_compatibility",                   o(ARB_ES2_compatibility),                   GL,             2009 },
    { "GL_ARB_blend_func_extended",                 o(ARB_blend_func_extended),                 GL,             2009 },
+   { "GL_ARB_color_buffer_float",                  o(ARB_color_buffer_float),                  GL,             2004 },
    { "GL_ARB_copy_buffer",                         o(ARB_copy_buffer),                         GL,             2008 },
    { "GL_ARB_depth_buffer_float",                  o(ARB_depth_buffer_float),                  GL,             2008 },
    { "GL_ARB_depth_clamp",                         o(ARB_depth_clamp),                         GL,             2003 },
@@ -202,6 +203,7 @@ static const struct extension extension_table[] = {
    { "GL_EXT_texture",                             o(EXT_texture),                             GL,             1996 },
    { "GL_EXT_texture_rectangle",                   o(NV_texture_rectangle),                    GL,             2004 },
    { "GL_EXT_texture_shared_exponent",             o(EXT_texture_shared_exponent),             GL,             2004 },
+   { "GL_EXT_texture_snorm",                       o(EXT_texture_snorm),                       GL,             2009 },
    { "GL_EXT_texture_sRGB",                        o(EXT_texture_sRGB),                        GL,             2004 },
    { "GL_EXT_texture_sRGB_decode",                 o(EXT_texture_sRGB_decode),                        GL,      2006 },
    { "GL_EXT_texture_swizzle",                     o(EXT_texture_swizzle),                     GL,             2008 },
@@ -273,7 +275,7 @@ static const struct extension extension_table[] = {
    { "GL_MESA_pack_invert",                        o(MESA_pack_invert),                        GL,             2002 },
    { "GL_MESA_resize_buffers",                     o(MESA_resize_buffers),                     GL,             1999 },
    { "GL_MESA_texture_array",                      o(MESA_texture_array),                      GL,             2007 },
-   { "GL_MESA_texture_signed_rgba",                o(MESA_texture_signed_rgba),                GL,             2009 },
+   { "GL_MESA_texture_signed_rgba",                o(EXT_texture_snorm),                       GL,             2009 },
    { "GL_MESA_window_pos",                         o(ARB_window_pos),                          GL,             2000 },
    { "GL_MESAX_texture_float",                     o(ARB_texture_float),                       GL,             2009 },
    { "GL_MESA_ycbcr_texture",                      o(MESA_ycbcr_texture),                      GL,             2002 },
diff --git a/mesalib/src/mesa/main/fbobject.c b/mesalib/src/mesa/main/fbobject.c
index cc13103de..4eab3e119 100644
--- a/mesalib/src/mesa/main/fbobject.c
+++ b/mesalib/src/mesa/main/fbobject.c
@@ -1081,7 +1081,6 @@ _mesa_base_fbo_format(struct gl_context *ctx, GLenum internalFormat)
    case GL_RGB10_A2:
    case GL_RGBA12:
    case GL_RGBA16:
-   case GL_RGBA16_SNORM:
    case GL_SRGB8_ALPHA8_EXT:
       return GL_RGBA;
    case GL_STENCIL_INDEX:
@@ -1109,6 +1108,43 @@ _mesa_base_fbo_format(struct gl_context *ctx, GLenum internalFormat)
    case GL_RG8:
    case GL_RG16:
       return ctx->Extensions.ARB_texture_rg ? GL_RG : 0;
+   /* signed normalized texture formats */
+   case GL_RED_SNORM:
+   case GL_R8_SNORM:
+   case GL_R16_SNORM:
+      return ctx->Extensions.EXT_texture_snorm ? GL_RED : 0;
+   case GL_RG_SNORM:
+   case GL_RG8_SNORM:
+   case GL_RG16_SNORM:
+      return ctx->Extensions.EXT_texture_snorm ? GL_RG : 0;
+   case GL_RGB_SNORM:
+   case GL_RGB8_SNORM:
+   case GL_RGB16_SNORM:
+      return ctx->Extensions.EXT_texture_snorm ? GL_RGB : 0;
+   case GL_RGBA_SNORM:
+   case GL_RGBA8_SNORM:
+   case GL_RGBA16_SNORM:
+      return ctx->Extensions.EXT_texture_snorm ? GL_RGBA : 0;
+   case GL_ALPHA_SNORM:
+   case GL_ALPHA8_SNORM:
+   case GL_ALPHA16_SNORM:
+      return ctx->Extensions.EXT_texture_snorm &&
+             ctx->Extensions.ARB_framebuffer_object ? GL_ALPHA : 0;
+   case GL_LUMINANCE_SNORM:
+   case GL_LUMINANCE8_SNORM:
+   case GL_LUMINANCE16_SNORM:
+      return ctx->Extensions.EXT_texture_snorm &&
+             ctx->Extensions.ARB_framebuffer_object ? GL_LUMINANCE : 0;
+   case GL_LUMINANCE_ALPHA_SNORM:
+   case GL_LUMINANCE8_ALPHA8_SNORM:
+   case GL_LUMINANCE16_ALPHA16_SNORM:
+      return ctx->Extensions.EXT_texture_snorm &&
+             ctx->Extensions.ARB_framebuffer_object ? GL_LUMINANCE_ALPHA : 0;
+   case GL_INTENSITY_SNORM:
+   case GL_INTENSITY8_SNORM:
+   case GL_INTENSITY16_SNORM:
+      return ctx->Extensions.EXT_texture_snorm &&
+             ctx->Extensions.ARB_framebuffer_object ? GL_INTENSITY : 0;
    /* XXX add floating point and integer formats eventually */
    default:
       return 0;
diff --git a/mesalib/src/mesa/main/ff_fragment_shader.cpp b/mesalib/src/mesa/main/ff_fragment_shader.cpp
index 0bc534df5..bf65a4f64 100644
--- a/mesalib/src/mesa/main/ff_fragment_shader.cpp
+++ b/mesalib/src/mesa/main/ff_fragment_shader.cpp
@@ -1,1623 +1,1623 @@
-/**************************************************************************

- * 

- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

- * All Rights Reserved.

- * Copyright 2009 VMware, Inc.  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 TUNGSTEN GRAPHICS AND/OR ITS 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.

- * 

- **************************************************************************/

-

-extern "C" {

-#include "glheader.h"

-#include "imports.h"

-#include "mtypes.h"

-#include "program/program.h"

-#include "program/prog_parameter.h"

-#include "program/prog_cache.h"

-#include "program/prog_instruction.h"

-#include "program/prog_print.h"

-#include "program/prog_statevars.h"

-#include "program/programopt.h"

-#include "texenvprogram.h"

-}

-

-/*

- * Note on texture units:

- *

- * The number of texture units supported by fixed-function fragment

- * processing is MAX_TEXTURE_COORD_UNITS, not MAX_TEXTURE_IMAGE_UNITS.

- * That's because there's a one-to-one correspondence between texture

- * coordinates and samplers in fixed-function processing.

- *

- * Since fixed-function vertex processing is limited to MAX_TEXTURE_COORD_UNITS

- * sets of texcoords, so is fixed-function fragment processing.

- *

- * We can safely use ctx->Const.MaxTextureUnits for loop bounds.

- */

-

-

-struct texenvprog_cache_item

-{

-   GLuint hash;

-   void *key;

-   struct gl_fragment_program *data;

-   struct texenvprog_cache_item *next;

-};

-

-static GLboolean

-texenv_doing_secondary_color(struct gl_context *ctx)

-{

-   if (ctx->Light.Enabled &&

-       (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR))

-      return GL_TRUE;

-

-   if (ctx->Fog.ColorSumEnabled)

-      return GL_TRUE;

-

-   return GL_FALSE;

-}

-

-/**

- * Up to nine instructions per tex unit, plus fog, specular color.

- */

-#define MAX_INSTRUCTIONS ((MAX_TEXTURE_COORD_UNITS * 9) + 12)

-

-#define DISASSEM (MESA_VERBOSE & VERBOSE_DISASSEM)

-

-struct mode_opt {

-#ifdef __GNUC__

-   __extension__ GLubyte Source:4;  /**< SRC_x */

-   __extension__ GLubyte Operand:3; /**< OPR_x */

-#else

-   GLubyte Source;  /**< SRC_x */

-   GLubyte Operand; /**< OPR_x */

-#endif

-};

-

-struct state_key {

-   GLuint nr_enabled_units:8;

-   GLuint enabled_units:8;

-   GLuint separate_specular:1;

-   GLuint fog_enabled:1;

-   GLuint fog_mode:2;          /**< FOG_x */

-   GLuint inputs_available:12;

-   GLuint num_draw_buffers:4;

-

-   /* NOTE: This array of structs must be last! (see "keySize" below) */

-   struct {

-      GLuint enabled:1;

-      GLuint source_index:3;   /**< TEXTURE_x_INDEX */

-      GLuint shadow:1;

-      GLuint ScaleShiftRGB:2;

-      GLuint ScaleShiftA:2;

-

-      GLuint NumArgsRGB:3;  /**< up to MAX_COMBINER_TERMS */

-      GLuint ModeRGB:5;     /**< MODE_x */

-

-      GLuint NumArgsA:3;  /**< up to MAX_COMBINER_TERMS */

-      GLuint ModeA:5;     /**< MODE_x */

-

-      GLuint texture_cyl_wrap:1; /**< For gallium test/debug only */

-

-      struct mode_opt OptRGB[MAX_COMBINER_TERMS];

-      struct mode_opt OptA[MAX_COMBINER_TERMS];

-   } unit[MAX_TEXTURE_UNITS];

-};

-

-#define FOG_LINEAR  0

-#define FOG_EXP     1

-#define FOG_EXP2    2

-#define FOG_UNKNOWN 3

-

-static GLuint translate_fog_mode( GLenum mode )

-{

-   switch (mode) {

-   case GL_LINEAR: return FOG_LINEAR;

-   case GL_EXP: return FOG_EXP;

-   case GL_EXP2: return FOG_EXP2;

-   default: return FOG_UNKNOWN;

-   }

-}

-

-#define OPR_SRC_COLOR           0

-#define OPR_ONE_MINUS_SRC_COLOR 1

-#define OPR_SRC_ALPHA           2

-#define OPR_ONE_MINUS_SRC_ALPHA	3

-#define OPR_ZERO                4

-#define OPR_ONE                 5

-#define OPR_UNKNOWN             7

-

-static GLuint translate_operand( GLenum operand )

-{

-   switch (operand) {

-   case GL_SRC_COLOR: return OPR_SRC_COLOR;

-   case GL_ONE_MINUS_SRC_COLOR: return OPR_ONE_MINUS_SRC_COLOR;

-   case GL_SRC_ALPHA: return OPR_SRC_ALPHA;

-   case GL_ONE_MINUS_SRC_ALPHA: return OPR_ONE_MINUS_SRC_ALPHA;

-   case GL_ZERO: return OPR_ZERO;

-   case GL_ONE: return OPR_ONE;

-   default:

-      assert(0);

-      return OPR_UNKNOWN;

-   }

-}

-

-#define SRC_TEXTURE  0

-#define SRC_TEXTURE0 1

-#define SRC_TEXTURE1 2

-#define SRC_TEXTURE2 3

-#define SRC_TEXTURE3 4

-#define SRC_TEXTURE4 5

-#define SRC_TEXTURE5 6

-#define SRC_TEXTURE6 7

-#define SRC_TEXTURE7 8

-#define SRC_CONSTANT 9

-#define SRC_PRIMARY_COLOR 10

-#define SRC_PREVIOUS 11

-#define SRC_ZERO     12

-#define SRC_UNKNOWN  15

-

-static GLuint translate_source( GLenum src )

-{

-   switch (src) {

-   case GL_TEXTURE: return SRC_TEXTURE;

-   case GL_TEXTURE0:

-   case GL_TEXTURE1:

-   case GL_TEXTURE2:

-   case GL_TEXTURE3:

-   case GL_TEXTURE4:

-   case GL_TEXTURE5:

-   case GL_TEXTURE6:

-   case GL_TEXTURE7: return SRC_TEXTURE0 + (src - GL_TEXTURE0);

-   case GL_CONSTANT: return SRC_CONSTANT;

-   case GL_PRIMARY_COLOR: return SRC_PRIMARY_COLOR;

-   case GL_PREVIOUS: return SRC_PREVIOUS;

-   case GL_ZERO:

-      return SRC_ZERO;

-   default:

-      assert(0);

-      return SRC_UNKNOWN;

-   }

-}

-

-#define MODE_REPLACE                     0  /* r = a0 */

-#define MODE_MODULATE                    1  /* r = a0 * a1 */

-#define MODE_ADD                         2  /* r = a0 + a1 */

-#define MODE_ADD_SIGNED                  3  /* r = a0 + a1 - 0.5 */

-#define MODE_INTERPOLATE                 4  /* r = a0 * a2 + a1 * (1 - a2) */

-#define MODE_SUBTRACT                    5  /* r = a0 - a1 */

-#define MODE_DOT3_RGB                    6  /* r = a0 . a1 */

-#define MODE_DOT3_RGB_EXT                7  /* r = a0 . a1 */

-#define MODE_DOT3_RGBA                   8  /* r = a0 . a1 */

-#define MODE_DOT3_RGBA_EXT               9  /* r = a0 . a1 */

-#define MODE_MODULATE_ADD_ATI           10  /* r = a0 * a2 + a1 */

-#define MODE_MODULATE_SIGNED_ADD_ATI    11  /* r = a0 * a2 + a1 - 0.5 */

-#define MODE_MODULATE_SUBTRACT_ATI      12  /* r = a0 * a2 - a1 */

-#define MODE_ADD_PRODUCTS               13  /* r = a0 * a1 + a2 * a3 */

-#define MODE_ADD_PRODUCTS_SIGNED        14  /* r = a0 * a1 + a2 * a3 - 0.5 */

-#define MODE_BUMP_ENVMAP_ATI            15  /* special */

-#define MODE_UNKNOWN                    16

-

-/**

- * Translate GL combiner state into a MODE_x value

- */

-static GLuint translate_mode( GLenum envMode, GLenum mode )

-{

-   switch (mode) {

-   case GL_REPLACE: return MODE_REPLACE;

-   case GL_MODULATE: return MODE_MODULATE;

-   case GL_ADD:

-      if (envMode == GL_COMBINE4_NV)

-         return MODE_ADD_PRODUCTS;

-      else

-         return MODE_ADD;

-   case GL_ADD_SIGNED:

-      if (envMode == GL_COMBINE4_NV)

-         return MODE_ADD_PRODUCTS_SIGNED;

-      else

-         return MODE_ADD_SIGNED;

-   case GL_INTERPOLATE: return MODE_INTERPOLATE;

-   case GL_SUBTRACT: return MODE_SUBTRACT;

-   case GL_DOT3_RGB: return MODE_DOT3_RGB;

-   case GL_DOT3_RGB_EXT: return MODE_DOT3_RGB_EXT;

-   case GL_DOT3_RGBA: return MODE_DOT3_RGBA;

-   case GL_DOT3_RGBA_EXT: return MODE_DOT3_RGBA_EXT;

-   case GL_MODULATE_ADD_ATI: return MODE_MODULATE_ADD_ATI;

-   case GL_MODULATE_SIGNED_ADD_ATI: return MODE_MODULATE_SIGNED_ADD_ATI;

-   case GL_MODULATE_SUBTRACT_ATI: return MODE_MODULATE_SUBTRACT_ATI;

-   case GL_BUMP_ENVMAP_ATI: return MODE_BUMP_ENVMAP_ATI;

-   default:

-      assert(0);

-      return MODE_UNKNOWN;

-   }

-}

-

-

-/**

- * Do we need to clamp the results of the given texture env/combine mode?

- * If the inputs to the mode are in [0,1] we don't always have to clamp

- * the results.

- */

-static GLboolean

-need_saturate( GLuint mode )

-{

-   switch (mode) {

-   case MODE_REPLACE:

-   case MODE_MODULATE:

-   case MODE_INTERPOLATE:

-      return GL_FALSE;

-   case MODE_ADD:

-   case MODE_ADD_SIGNED:

-   case MODE_SUBTRACT:

-   case MODE_DOT3_RGB:

-   case MODE_DOT3_RGB_EXT:

-   case MODE_DOT3_RGBA:

-   case MODE_DOT3_RGBA_EXT:

-   case MODE_MODULATE_ADD_ATI:

-   case MODE_MODULATE_SIGNED_ADD_ATI:

-   case MODE_MODULATE_SUBTRACT_ATI:

-   case MODE_ADD_PRODUCTS:

-   case MODE_ADD_PRODUCTS_SIGNED:

-   case MODE_BUMP_ENVMAP_ATI:

-      return GL_TRUE;

-   default:

-      assert(0);

-      return GL_FALSE;

-   }

-}

-

-

-

-/**

- * Translate TEXTURE_x_BIT to TEXTURE_x_INDEX.

- */

-static GLuint translate_tex_src_bit( GLbitfield bit )

-{

-   ASSERT(bit);

-   return _mesa_ffs(bit) - 1;

-}

-

-

-#define VERT_BIT_TEX_ANY    (0xff << VERT_ATTRIB_TEX0)

-#define VERT_RESULT_TEX_ANY (0xff << VERT_RESULT_TEX0)

-

-/**

- * Identify all possible varying inputs.  The fragment program will

- * never reference non-varying inputs, but will track them via state

- * constants instead.

- *

- * This function figures out all the inputs that the fragment program

- * has access to.  The bitmask is later reduced to just those which

- * are actually referenced.

- */

-static GLbitfield get_fp_input_mask( struct gl_context *ctx )

-{

-   /* _NEW_PROGRAM */

-   const GLboolean vertexShader =

-      (ctx->Shader.CurrentVertexProgram &&

-       ctx->Shader.CurrentVertexProgram->LinkStatus &&

-       ctx->Shader.CurrentVertexProgram->VertexProgram);

-   const GLboolean vertexProgram = ctx->VertexProgram._Enabled;

-   GLbitfield fp_inputs = 0x0;

-

-   if (ctx->VertexProgram._Overriden) {

-      /* Somebody's messing with the vertex program and we don't have

-       * a clue what's happening.  Assume that it could be producing

-       * all possible outputs.

-       */

-      fp_inputs = ~0;

-   }

-   else if (ctx->RenderMode == GL_FEEDBACK) {

-      /* _NEW_RENDERMODE */

-      fp_inputs = (FRAG_BIT_COL0 | FRAG_BIT_TEX0);

-   }

-   else if (!(vertexProgram || vertexShader) ||

-            !ctx->VertexProgram._Current) {

-      /* Fixed function vertex logic */

-      /* _NEW_ARRAY */

-      GLbitfield varying_inputs = ctx->varying_vp_inputs;

-

-      /* These get generated in the setup routine regardless of the

-       * vertex program:

-       */

-      /* _NEW_POINT */

-      if (ctx->Point.PointSprite)

-         varying_inputs |= FRAG_BITS_TEX_ANY;

-

-      /* First look at what values may be computed by the generated

-       * vertex program:

-       */

-      /* _NEW_LIGHT */

-      if (ctx->Light.Enabled) {

-         fp_inputs |= FRAG_BIT_COL0;

-

-         if (texenv_doing_secondary_color(ctx))

-            fp_inputs |= FRAG_BIT_COL1;

-      }

-

-      /* _NEW_TEXTURE */

-      fp_inputs |= (ctx->Texture._TexGenEnabled |

-                    ctx->Texture._TexMatEnabled) << FRAG_ATTRIB_TEX0;

-

-      /* Then look at what might be varying as a result of enabled

-       * arrays, etc:

-       */

-      if (varying_inputs & VERT_BIT_COLOR0)

-         fp_inputs |= FRAG_BIT_COL0;

-      if (varying_inputs & VERT_BIT_COLOR1)

-         fp_inputs |= FRAG_BIT_COL1;

-

-      fp_inputs |= (((varying_inputs & VERT_BIT_TEX_ANY) >> VERT_ATTRIB_TEX0) 

-                    << FRAG_ATTRIB_TEX0);

-

-   }

-   else {

-      /* calculate from vp->outputs */

-      struct gl_vertex_program *vprog;

-      GLbitfield64 vp_outputs;

-

-      /* Choose GLSL vertex shader over ARB vertex program.  Need this

-       * since vertex shader state validation comes after fragment state

-       * validation (see additional comments in state.c).

-       */

-      if (vertexShader)

-         vprog = ctx->Shader.CurrentVertexProgram->VertexProgram;

-      else

-         vprog = ctx->VertexProgram.Current;

-

-      vp_outputs = vprog->Base.OutputsWritten;

-

-      /* These get generated in the setup routine regardless of the

-       * vertex program:

-       */

-      /* _NEW_POINT */

-      if (ctx->Point.PointSprite)

-         vp_outputs |= FRAG_BITS_TEX_ANY;

-

-      if (vp_outputs & (1 << VERT_RESULT_COL0))

-         fp_inputs |= FRAG_BIT_COL0;

-      if (vp_outputs & (1 << VERT_RESULT_COL1))

-         fp_inputs |= FRAG_BIT_COL1;

-

-      fp_inputs |= (((vp_outputs & VERT_RESULT_TEX_ANY) >> VERT_RESULT_TEX0) 

-                    << FRAG_ATTRIB_TEX0);

-   }

-   

-   return fp_inputs;

-}

-

-

-/**

- * Examine current texture environment state and generate a unique

- * key to identify it.

- */

-static GLuint make_state_key( struct gl_context *ctx,  struct state_key *key )

-{

-   GLuint i, j;

-   GLbitfield inputs_referenced = FRAG_BIT_COL0;

-   const GLbitfield inputs_available = get_fp_input_mask( ctx );

-   GLuint keySize;

-

-   memset(key, 0, sizeof(*key));

-

-   /* _NEW_TEXTURE */

-   for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {

-      const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];

-      const struct gl_texture_object *texObj = texUnit->_Current;

-      const struct gl_tex_env_combine_state *comb = texUnit->_CurrentCombine;

-      GLenum format;

-

-      if (!texUnit->_ReallyEnabled || !texUnit->Enabled)

-         continue;

-

-      format = texObj->Image[0][texObj->BaseLevel]->_BaseFormat;

-

-      key->unit[i].enabled = 1;

-      key->enabled_units |= (1<<i);

-      key->nr_enabled_units = i + 1;

-      inputs_referenced |= FRAG_BIT_TEX(i);

-

-      key->unit[i].source_index =

-         translate_tex_src_bit(texUnit->_ReallyEnabled);

-

-      key->unit[i].shadow = ((texObj->CompareMode == GL_COMPARE_R_TO_TEXTURE) &&

-                             ((format == GL_DEPTH_COMPONENT) || 

-                              (format == GL_DEPTH_STENCIL_EXT)));

-

-      key->unit[i].NumArgsRGB = comb->_NumArgsRGB;

-      key->unit[i].NumArgsA = comb->_NumArgsA;

-

-      key->unit[i].ModeRGB =

-	 translate_mode(texUnit->EnvMode, comb->ModeRGB);

-      key->unit[i].ModeA =

-	 translate_mode(texUnit->EnvMode, comb->ModeA);

-

-      key->unit[i].ScaleShiftRGB = comb->ScaleShiftRGB;

-      key->unit[i].ScaleShiftA = comb->ScaleShiftA;

-

-      for (j = 0; j < MAX_COMBINER_TERMS; j++) {

-         key->unit[i].OptRGB[j].Operand = translate_operand(comb->OperandRGB[j]);

-         key->unit[i].OptA[j].Operand = translate_operand(comb->OperandA[j]);

-         key->unit[i].OptRGB[j].Source = translate_source(comb->SourceRGB[j]);

-         key->unit[i].OptA[j].Source = translate_source(comb->SourceA[j]);

-      }

-

-      if (key->unit[i].ModeRGB == MODE_BUMP_ENVMAP_ATI) {

-         /* requires some special translation */

-         key->unit[i].NumArgsRGB = 2;

-         key->unit[i].ScaleShiftRGB = 0;

-         key->unit[i].OptRGB[0].Operand = OPR_SRC_COLOR;

-         key->unit[i].OptRGB[0].Source = SRC_TEXTURE;

-         key->unit[i].OptRGB[1].Operand = OPR_SRC_COLOR;

-         key->unit[i].OptRGB[1].Source = texUnit->BumpTarget - GL_TEXTURE0 + SRC_TEXTURE0;

-       }

-

-      /* this is a back-door for enabling cylindrical texture wrap mode */

-      if (texObj->Priority == 0.125)

-         key->unit[i].texture_cyl_wrap = 1;

-   }

-

-   /* _NEW_LIGHT | _NEW_FOG */

-   if (texenv_doing_secondary_color(ctx)) {

-      key->separate_specular = 1;

-      inputs_referenced |= FRAG_BIT_COL1;

-   }

-

-   /* _NEW_FOG */

-   if (ctx->Fog.Enabled) {

-      key->fog_enabled = 1;

-      key->fog_mode = translate_fog_mode(ctx->Fog.Mode);

-      inputs_referenced |= FRAG_BIT_FOGC; /* maybe */

-   }

-

-   /* _NEW_BUFFERS */

-   key->num_draw_buffers = ctx->DrawBuffer->_NumColorDrawBuffers;

-

-   key->inputs_available = (inputs_available & inputs_referenced);

-

-   /* compute size of state key, ignoring unused texture units */

-   keySize = sizeof(*key) - sizeof(key->unit)

-      + key->nr_enabled_units * sizeof(key->unit[0]);

-

-   return keySize;

-}

-

-

-/**

- * Use uregs to represent registers internally, translate to Mesa's

- * expected formats on emit.  

- *

- * NOTE: These are passed by value extensively in this file rather

- * than as usual by pointer reference.  If this disturbs you, try

- * remembering they are just 32bits in size.

- *

- * GCC is smart enough to deal with these dword-sized structures in

- * much the same way as if I had defined them as dwords and was using

- * macros to access and set the fields.  This is much nicer and easier

- * to evolve.

- */

-struct ureg {

-   GLuint file:4;

-   GLuint idx:8;

-   GLuint negatebase:1;

-   GLuint swz:12;

-   GLuint pad:7;

-};

-

-static const struct ureg undef = { 

-   PROGRAM_UNDEFINED,

-   255,

-   0,

-   0,

-   0

-};

-

-

-/** State used to build the fragment program:

- */

-struct texenv_fragment_program {

-   struct gl_fragment_program *program;

-   struct state_key *state;

-

-   GLbitfield alu_temps;	/**< Track texture indirections, see spec. */

-   GLbitfield temps_output;	/**< Track texture indirections, see spec. */

-   GLbitfield temp_in_use;	/**< Tracks temporary regs which are in use. */

-   GLboolean error;

-

-   struct ureg src_texture[MAX_TEXTURE_COORD_UNITS];   

-   /* Reg containing each texture unit's sampled texture color,

-    * else undef.

-    */

-

-   struct ureg texcoord_tex[MAX_TEXTURE_COORD_UNITS];

-   /* Reg containing texcoord for a texture unit,

-    * needed for bump mapping, else undef.

-    */

-

-   struct ureg src_previous;	/**< Reg containing color from previous 

-				 * stage.  May need to be decl'd.

-				 */

-

-   GLuint last_tex_stage;	/**< Number of last enabled texture unit */

-

-   struct ureg half;

-   struct ureg one;

-   struct ureg zero;

-};

-

-

-

-static struct ureg make_ureg(GLuint file, GLuint idx)

-{

-   struct ureg reg;

-   reg.file = file;

-   reg.idx = idx;

-   reg.negatebase = 0;

-   reg.swz = SWIZZLE_NOOP;

-   reg.pad = 0;

-   return reg;

-}

-

-static struct ureg swizzle( struct ureg reg, int x, int y, int z, int w )

-{

-   reg.swz = MAKE_SWIZZLE4(GET_SWZ(reg.swz, x),

-			   GET_SWZ(reg.swz, y),

-			   GET_SWZ(reg.swz, z),

-			   GET_SWZ(reg.swz, w));

-

-   return reg;

-}

-

-static struct ureg swizzle1( struct ureg reg, int x )

-{

-   return swizzle(reg, x, x, x, x);

-}

-

-static struct ureg negate( struct ureg reg )

-{

-   reg.negatebase ^= 1;

-   return reg;

-}

-

-static GLboolean is_undef( struct ureg reg )

-{

-   return reg.file == PROGRAM_UNDEFINED;

-}

-

-

-static struct ureg get_temp( struct texenv_fragment_program *p )

-{

-   GLint bit;

-   

-   /* First try and reuse temps which have been used already:

-    */

-   bit = _mesa_ffs( ~p->temp_in_use & p->alu_temps );

-

-   /* Then any unused temporary:

-    */

-   if (!bit)

-      bit = _mesa_ffs( ~p->temp_in_use );

-

-   if (!bit) {

-      _mesa_problem(NULL, "%s: out of temporaries\n", __FILE__);

-      exit(1);

-   }

-

-   if ((GLuint) bit > p->program->Base.NumTemporaries)

-      p->program->Base.NumTemporaries = bit;

-

-   p->temp_in_use |= 1<<(bit-1);

-   return make_ureg(PROGRAM_TEMPORARY, (bit-1));

-}

-

-static struct ureg get_tex_temp( struct texenv_fragment_program *p )

-{

-   int bit;

-   

-   /* First try to find available temp not previously used (to avoid

-    * starting a new texture indirection).  According to the spec, the

-    * ~p->temps_output isn't necessary, but will keep it there for

-    * now:

-    */

-   bit = _mesa_ffs( ~p->temp_in_use & ~p->alu_temps & ~p->temps_output );

-

-   /* Then any unused temporary:

-    */

-   if (!bit) 

-      bit = _mesa_ffs( ~p->temp_in_use );

-

-   if (!bit) {

-      _mesa_problem(NULL, "%s: out of temporaries\n", __FILE__);

-      exit(1);

-   }

-

-   if ((GLuint) bit > p->program->Base.NumTemporaries)

-      p->program->Base.NumTemporaries = bit;

-

-   p->temp_in_use |= 1<<(bit-1);

-   return make_ureg(PROGRAM_TEMPORARY, (bit-1));

-}

-

-

-/** Mark a temp reg as being no longer allocatable. */

-static void reserve_temp( struct texenv_fragment_program *p, struct ureg r )

-{

-   if (r.file == PROGRAM_TEMPORARY)

-      p->temps_output |= (1 << r.idx);

-}

-

-

-static void release_temps(struct gl_context *ctx, struct texenv_fragment_program *p )

-{

-   GLuint max_temp = ctx->Const.FragmentProgram.MaxTemps;

-

-   /* KW: To support tex_env_crossbar, don't release the registers in

-    * temps_output.

-    */

-   if (max_temp >= sizeof(int) * 8)

-      p->temp_in_use = p->temps_output;

-   else

-      p->temp_in_use = ~((1<<max_temp)-1) | p->temps_output;

-}

-

-

-static struct ureg register_param5( struct texenv_fragment_program *p, 

-				    GLint s0,

-				    GLint s1,

-				    GLint s2,

-				    GLint s3,

-				    GLint s4)

-{

-   int tokens[STATE_LENGTH];

-   GLuint idx;

-   tokens[0] = s0;

-   tokens[1] = s1;

-   tokens[2] = s2;

-   tokens[3] = s3;

-   tokens[4] = s4;

-   idx = _mesa_add_state_reference(p->program->Base.Parameters,

-				   (gl_state_index *)tokens);

-   return make_ureg(PROGRAM_STATE_VAR, idx);

-}

-

-

-#define register_param1(p,s0)          register_param5(p,s0,0,0,0,0)

-#define register_param2(p,s0,s1)       register_param5(p,s0,s1,0,0,0)

-#define register_param3(p,s0,s1,s2)    register_param5(p,s0,s1,s2,0,0)

-#define register_param4(p,s0,s1,s2,s3) register_param5(p,s0,s1,s2,s3,0)

-

-static GLuint frag_to_vert_attrib( GLuint attrib )

-{

-   switch (attrib) {

-   case FRAG_ATTRIB_COL0: return VERT_ATTRIB_COLOR0;

-   case FRAG_ATTRIB_COL1: return VERT_ATTRIB_COLOR1;

-   default:

-      assert(attrib >= FRAG_ATTRIB_TEX0);

-      assert(attrib <= FRAG_ATTRIB_TEX7);

-      return attrib - FRAG_ATTRIB_TEX0 + VERT_ATTRIB_TEX0;

-   }

-}

-

-

-static struct ureg register_input( struct texenv_fragment_program *p, GLuint input )

-{

-   if (p->state->inputs_available & (1<<input)) {

-      p->program->Base.InputsRead |= (1 << input);

-      return make_ureg(PROGRAM_INPUT, input);

-   }

-   else {

-      GLuint idx = frag_to_vert_attrib( input );

-      return register_param3( p, STATE_INTERNAL, STATE_CURRENT_ATTRIB, idx );

-   }

-}

-

-

-static void emit_arg( struct prog_src_register *reg,

-		      struct ureg ureg )

-{

-   reg->File = ureg.file;

-   reg->Index = ureg.idx;

-   reg->Swizzle = ureg.swz;

-   reg->Negate = ureg.negatebase ? NEGATE_XYZW : NEGATE_NONE;

-   reg->Abs = GL_FALSE;

-}

-

-static void emit_dst( struct prog_dst_register *dst,

-		      struct ureg ureg, GLuint mask )

-{

-   dst->File = ureg.file;

-   dst->Index = ureg.idx;

-   dst->WriteMask = mask;

-   dst->CondMask = COND_TR;  /* always pass cond test */

-   dst->CondSwizzle = SWIZZLE_NOOP;

-}

-

-static struct prog_instruction *

-emit_op(struct texenv_fragment_program *p,

-	enum prog_opcode op,

-	struct ureg dest,

-	GLuint mask,

-	GLboolean saturate,

-	struct ureg src0,

-	struct ureg src1,

-	struct ureg src2 )

-{

-   const GLuint nr = p->program->Base.NumInstructions++;

-   struct prog_instruction *inst = &p->program->Base.Instructions[nr];

-

-   assert(nr < MAX_INSTRUCTIONS);

-

-   _mesa_init_instructions(inst, 1);

-   inst->Opcode = op;

-   

-   emit_arg( &inst->SrcReg[0], src0 );

-   emit_arg( &inst->SrcReg[1], src1 );

-   emit_arg( &inst->SrcReg[2], src2 );

-   

-   inst->SaturateMode = saturate ? SATURATE_ZERO_ONE : SATURATE_OFF;

-

-   emit_dst( &inst->DstReg, dest, mask );

-

-#if 0

-   /* Accounting for indirection tracking:

-    */

-   if (dest.file == PROGRAM_TEMPORARY)

-      p->temps_output |= 1 << dest.idx;

-#endif

-

-   return inst;

-}

-   

-

-static struct ureg emit_arith( struct texenv_fragment_program *p,

-			       enum prog_opcode op,

-			       struct ureg dest,

-			       GLuint mask,

-			       GLboolean saturate,

-			       struct ureg src0,

-			       struct ureg src1,

-			       struct ureg src2 )

-{

-   emit_op(p, op, dest, mask, saturate, src0, src1, src2);

-   

-   /* Accounting for indirection tracking:

-    */

-   if (src0.file == PROGRAM_TEMPORARY)

-      p->alu_temps |= 1 << src0.idx;

-

-   if (!is_undef(src1) && src1.file == PROGRAM_TEMPORARY)

-      p->alu_temps |= 1 << src1.idx;

-

-   if (!is_undef(src2) && src2.file == PROGRAM_TEMPORARY)

-      p->alu_temps |= 1 << src2.idx;

-

-   if (dest.file == PROGRAM_TEMPORARY)

-      p->alu_temps |= 1 << dest.idx;

-       

-   p->program->Base.NumAluInstructions++;

-   return dest;

-}

-

-static struct ureg emit_texld( struct texenv_fragment_program *p,

-			       enum prog_opcode op,

-			       struct ureg dest,

-			       GLuint destmask,

-			       GLuint tex_unit,

-			       GLuint tex_idx,

-                               GLuint tex_shadow,

-			       struct ureg coord )

-{

-   struct prog_instruction *inst = emit_op( p, op, 

-					  dest, destmask, 

-					  GL_FALSE,	/* don't saturate? */

-					  coord, 	/* arg 0? */

-					  undef,

-					  undef);

-   

-   inst->TexSrcTarget = tex_idx;

-   inst->TexSrcUnit = tex_unit;

-   inst->TexShadow = tex_shadow;

-

-   p->program->Base.NumTexInstructions++;

-

-   /* Accounting for indirection tracking:

-    */

-   reserve_temp(p, dest);

-

-#if 0

-   /* Is this a texture indirection?

-    */

-   if ((coord.file == PROGRAM_TEMPORARY &&

-	(p->temps_output & (1<<coord.idx))) ||

-       (dest.file == PROGRAM_TEMPORARY &&

-	(p->alu_temps & (1<<dest.idx)))) {

-      p->program->Base.NumTexIndirections++;

-      p->temps_output = 1<<coord.idx;

-      p->alu_temps = 0;

-      assert(0);		/* KW: texture env crossbar */

-   }

-#endif

-

-   return dest;

-}

-

-

-static struct ureg register_const4f( struct texenv_fragment_program *p, 

-				     GLfloat s0,

-				     GLfloat s1,

-				     GLfloat s2,

-				     GLfloat s3)

-{

-   GLfloat values[4];

-   GLuint idx, swizzle;

-   struct ureg r;

-   values[0] = s0;

-   values[1] = s1;

-   values[2] = s2;

-   values[3] = s3;

-   idx = _mesa_add_unnamed_constant( p->program->Base.Parameters, values, 4,

-                                     &swizzle );

-   r = make_ureg(PROGRAM_CONSTANT, idx);

-   r.swz = swizzle;

-   return r;

-}

-

-#define register_scalar_const(p, s0)    register_const4f(p, s0, s0, s0, s0)

-#define register_const1f(p, s0)         register_const4f(p, s0, 0, 0, 1)

-#define register_const2f(p, s0, s1)     register_const4f(p, s0, s1, 0, 1)

-#define register_const3f(p, s0, s1, s2) register_const4f(p, s0, s1, s2, 1)

-

-

-static struct ureg get_one( struct texenv_fragment_program *p )

-{

-   if (is_undef(p->one)) 

-      p->one = register_scalar_const(p, 1.0);

-   return p->one;

-}

-

-static struct ureg get_half( struct texenv_fragment_program *p )

-{

-   if (is_undef(p->half)) 

-      p->half = register_scalar_const(p, 0.5);

-   return p->half;

-}

-

-static struct ureg get_zero( struct texenv_fragment_program *p )

-{

-   if (is_undef(p->zero)) 

-      p->zero = register_scalar_const(p, 0.0);

-   return p->zero;

-}

-

-

-static void program_error( struct texenv_fragment_program *p, const char *msg )

-{

-   _mesa_problem(NULL, "%s", msg);

-   p->error = 1;

-}

-

-static struct ureg get_source( struct texenv_fragment_program *p, 

-			       GLuint src, GLuint unit )

-{

-   switch (src) {

-   case SRC_TEXTURE: 

-      assert(!is_undef(p->src_texture[unit]));

-      return p->src_texture[unit];

-

-   case SRC_TEXTURE0:

-   case SRC_TEXTURE1:

-   case SRC_TEXTURE2:

-   case SRC_TEXTURE3:

-   case SRC_TEXTURE4:

-   case SRC_TEXTURE5:

-   case SRC_TEXTURE6:

-   case SRC_TEXTURE7: 

-      assert(!is_undef(p->src_texture[src - SRC_TEXTURE0]));

-      return p->src_texture[src - SRC_TEXTURE0];

-

-   case SRC_CONSTANT:

-      return register_param2(p, STATE_TEXENV_COLOR, unit);

-

-   case SRC_PRIMARY_COLOR:

-      return register_input(p, FRAG_ATTRIB_COL0);

-

-   case SRC_ZERO:

-      return get_zero(p);

-

-   case SRC_PREVIOUS:

-      if (is_undef(p->src_previous))

-	 return register_input(p, FRAG_ATTRIB_COL0);

-      else

-	 return p->src_previous;

-

-   default:

-      assert(0);

-      return undef;

-   }

-}

-

-static struct ureg emit_combine_source( struct texenv_fragment_program *p, 

-					GLuint mask,

-					GLuint unit,

-					GLuint source, 

-					GLuint operand )

-{

-   struct ureg arg, src, one;

-

-   src = get_source(p, source, unit);

-

-   switch (operand) {

-   case OPR_ONE_MINUS_SRC_COLOR: 

-      /* Get unused tmp,

-       * Emit tmp = 1.0 - arg.xyzw

-       */

-      arg = get_temp( p );

-      one = get_one( p );

-      return emit_arith( p, OPCODE_SUB, arg, mask, 0, one, src, undef);

-

-   case OPR_SRC_ALPHA: 

-      if (mask == WRITEMASK_W)

-	 return src;

-      else

-	 return swizzle1( src, SWIZZLE_W );

-   case OPR_ONE_MINUS_SRC_ALPHA: 

-      /* Get unused tmp,

-       * Emit tmp = 1.0 - arg.wwww

-       */

-      arg = get_temp(p);

-      one = get_one(p);

-      return emit_arith(p, OPCODE_SUB, arg, mask, 0,

-			one, swizzle1(src, SWIZZLE_W), undef);

-   case OPR_ZERO:

-      return get_zero(p);

-   case OPR_ONE:

-      return get_one(p);

-   case OPR_SRC_COLOR: 

-      return src;

-   default:

-      assert(0);

-      return src;

-   }

-}

-

-/**

- * Check if the RGB and Alpha sources and operands match for the given

- * texture unit's combinder state.  When the RGB and A sources and

- * operands match, we can emit fewer instructions.

- */

-static GLboolean args_match( const struct state_key *key, GLuint unit )

-{

-   GLuint i, numArgs = key->unit[unit].NumArgsRGB;

-

-   for (i = 0; i < numArgs; i++) {

-      if (key->unit[unit].OptA[i].Source != key->unit[unit].OptRGB[i].Source) 

-	 return GL_FALSE;

-

-      switch (key->unit[unit].OptA[i].Operand) {

-      case OPR_SRC_ALPHA: 

-	 switch (key->unit[unit].OptRGB[i].Operand) {

-	 case OPR_SRC_COLOR: 

-	 case OPR_SRC_ALPHA: 

-	    break;

-	 default:

-	    return GL_FALSE;

-	 }

-	 break;

-      case OPR_ONE_MINUS_SRC_ALPHA: 

-	 switch (key->unit[unit].OptRGB[i].Operand) {

-	 case OPR_ONE_MINUS_SRC_COLOR: 

-	 case OPR_ONE_MINUS_SRC_ALPHA: 

-	    break;

-	 default:

-	    return GL_FALSE;

-	 }

-	 break;

-      default: 

-	 return GL_FALSE;	/* impossible */

-      }

-   }

-

-   return GL_TRUE;

-}

-

-static struct ureg emit_combine( struct texenv_fragment_program *p,

-				 struct ureg dest,

-				 GLuint mask,

-				 GLboolean saturate,

-				 GLuint unit,

-				 GLuint nr,

-				 GLuint mode,

-				 const struct mode_opt *opt)

-{

-   struct ureg src[MAX_COMBINER_TERMS];

-   struct ureg tmp, half;

-   GLuint i;

-

-   assert(nr <= MAX_COMBINER_TERMS);

-

-   for (i = 0; i < nr; i++)

-      src[i] = emit_combine_source( p, mask, unit, opt[i].Source, opt[i].Operand );

-

-   switch (mode) {

-   case MODE_REPLACE: 

-      if (mask == WRITEMASK_XYZW && !saturate)

-	 return src[0];

-      else

-	 return emit_arith( p, OPCODE_MOV, dest, mask, saturate, src[0], undef, undef );

-   case MODE_MODULATE: 

-      return emit_arith( p, OPCODE_MUL, dest, mask, saturate,

-			 src[0], src[1], undef );

-   case MODE_ADD: 

-      return emit_arith( p, OPCODE_ADD, dest, mask, saturate, 

-			 src[0], src[1], undef );

-   case MODE_ADD_SIGNED:

-      /* tmp = arg0 + arg1

-       * result = tmp - .5

-       */

-      half = get_half(p);

-      tmp = get_temp( p );

-      emit_arith( p, OPCODE_ADD, tmp, mask, 0, src[0], src[1], undef );

-      emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp, half, undef );

-      return dest;

-   case MODE_INTERPOLATE: 

-      /* Arg0 * (Arg2) + Arg1 * (1-Arg2) -- note arguments are reordered:

-       */

-      return emit_arith( p, OPCODE_LRP, dest, mask, saturate, src[2], src[0], src[1] );

-

-   case MODE_SUBTRACT: 

-      return emit_arith( p, OPCODE_SUB, dest, mask, saturate, src[0], src[1], undef );

-

-   case MODE_DOT3_RGBA:

-   case MODE_DOT3_RGBA_EXT: 

-   case MODE_DOT3_RGB_EXT:

-   case MODE_DOT3_RGB: {

-      struct ureg tmp0 = get_temp( p );

-      struct ureg tmp1 = get_temp( p );

-      struct ureg neg1 = register_scalar_const(p, -1);

-      struct ureg two  = register_scalar_const(p, 2);

-

-      /* tmp0 = 2*src0 - 1

-       * tmp1 = 2*src1 - 1

-       *

-       * dst = tmp0 dot3 tmp1 

-       */

-      emit_arith( p, OPCODE_MAD, tmp0, WRITEMASK_XYZW, 0, 

-		  two, src[0], neg1);

-

-      if (memcmp(&src[0], &src[1], sizeof(struct ureg)) == 0)

-	 tmp1 = tmp0;

-      else

-	 emit_arith( p, OPCODE_MAD, tmp1, WRITEMASK_XYZW, 0, 

-		     two, src[1], neg1);

-      emit_arith( p, OPCODE_DP3, dest, mask, saturate, tmp0, tmp1, undef);

-      return dest;

-   }

-   case MODE_MODULATE_ADD_ATI:

-      /* Arg0 * Arg2 + Arg1 */

-      return emit_arith( p, OPCODE_MAD, dest, mask, saturate,

-			 src[0], src[2], src[1] );

-   case MODE_MODULATE_SIGNED_ADD_ATI: {

-      /* Arg0 * Arg2 + Arg1 - 0.5 */

-      struct ureg tmp0 = get_temp(p);

-      half = get_half(p);

-      emit_arith( p, OPCODE_MAD, tmp0, mask, 0, src[0], src[2], src[1] );

-      emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp0, half, undef );

-      return dest;

-   }

-   case MODE_MODULATE_SUBTRACT_ATI:

-      /* Arg0 * Arg2 - Arg1 */

-      emit_arith( p, OPCODE_MAD, dest, mask, 0, src[0], src[2], negate(src[1]) );

-      return dest;

-   case MODE_ADD_PRODUCTS:

-      /* Arg0 * Arg1 + Arg2 * Arg3 */

-      {

-         struct ureg tmp0 = get_temp(p);

-         emit_arith( p, OPCODE_MUL, tmp0, mask, 0, src[0], src[1], undef );

-         emit_arith( p, OPCODE_MAD, dest, mask, saturate, src[2], src[3], tmp0 );

-      }

-      return dest;

-   case MODE_ADD_PRODUCTS_SIGNED:

-      /* Arg0 * Arg1 + Arg2 * Arg3 - 0.5 */

-      {

-         struct ureg tmp0 = get_temp(p);

-         half = get_half(p);

-         emit_arith( p, OPCODE_MUL, tmp0, mask, 0, src[0], src[1], undef );

-         emit_arith( p, OPCODE_MAD, tmp0, mask, 0, src[2], src[3], tmp0 );

-         emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp0, half, undef );

-      }

-      return dest;

-   case MODE_BUMP_ENVMAP_ATI:

-      /* special - not handled here */

-      assert(0);

-      return src[0];

-   default: 

-      assert(0);

-      return src[0];

-   }

-}

-

-

-/**

- * Generate instructions for one texture unit's env/combiner mode.

- */

-static struct ureg

-emit_texenv(struct texenv_fragment_program *p, GLuint unit)

-{

-   const struct state_key *key = p->state;

-   GLboolean rgb_saturate, alpha_saturate;

-   GLuint rgb_shift, alpha_shift;

-   struct ureg out, dest;

-

-   if (!key->unit[unit].enabled) {

-      return get_source(p, SRC_PREVIOUS, 0);

-   }

-   if (key->unit[unit].ModeRGB == MODE_BUMP_ENVMAP_ATI) {

-      /* this isn't really a env stage delivering a color and handled elsewhere */

-      return get_source(p, SRC_PREVIOUS, 0);

-   }

-   

-   switch (key->unit[unit].ModeRGB) {

-   case MODE_DOT3_RGB_EXT:

-      alpha_shift = key->unit[unit].ScaleShiftA;

-      rgb_shift = 0;

-      break;

-   case MODE_DOT3_RGBA_EXT:

-      alpha_shift = 0;

-      rgb_shift = 0;

-      break;

-   default:

-      rgb_shift = key->unit[unit].ScaleShiftRGB;

-      alpha_shift = key->unit[unit].ScaleShiftA;

-      break;

-   }

-   

-   /* If we'll do rgb/alpha shifting don't saturate in emit_combine().

-    * We don't want to clamp twice.

-    */

-   if (rgb_shift)

-      rgb_saturate = GL_FALSE;  /* saturate after rgb shift */

-   else if (need_saturate(key->unit[unit].ModeRGB))

-      rgb_saturate = GL_TRUE;

-   else

-      rgb_saturate = GL_FALSE;

-

-   if (alpha_shift)

-      alpha_saturate = GL_FALSE;  /* saturate after alpha shift */

-   else if (need_saturate(key->unit[unit].ModeA))

-      alpha_saturate = GL_TRUE;

-   else

-      alpha_saturate = GL_FALSE;

-

-   /* If this is the very last calculation (and various other conditions

-    * are met), emit directly to the color output register.  Otherwise,

-    * emit to a temporary register.

-    */

-   if (key->separate_specular ||

-       unit != p->last_tex_stage ||

-       alpha_shift ||

-       key->num_draw_buffers != 1 ||

-       rgb_shift)

-      dest = get_temp( p );

-   else

-      dest = make_ureg(PROGRAM_OUTPUT, FRAG_RESULT_COLOR);

-

-   /* Emit the RGB and A combine ops

-    */

-   if (key->unit[unit].ModeRGB == key->unit[unit].ModeA &&

-       args_match(key, unit)) {

-      out = emit_combine( p, dest, WRITEMASK_XYZW, rgb_saturate,

-			  unit,

-			  key->unit[unit].NumArgsRGB,

-			  key->unit[unit].ModeRGB,

-			  key->unit[unit].OptRGB);

-   }

-   else if (key->unit[unit].ModeRGB == MODE_DOT3_RGBA_EXT ||

-	    key->unit[unit].ModeRGB == MODE_DOT3_RGBA) {

-      out = emit_combine( p, dest, WRITEMASK_XYZW, rgb_saturate,

-			  unit,

-			  key->unit[unit].NumArgsRGB,

-			  key->unit[unit].ModeRGB,

-			  key->unit[unit].OptRGB);

-   }

-   else {

-      /* Need to do something to stop from re-emitting identical

-       * argument calculations here:

-       */

-      out = emit_combine( p, dest, WRITEMASK_XYZ, rgb_saturate,

-			  unit,

-			  key->unit[unit].NumArgsRGB,

-			  key->unit[unit].ModeRGB,

-			  key->unit[unit].OptRGB);

-      out = emit_combine( p, dest, WRITEMASK_W, alpha_saturate,

-			  unit,

-			  key->unit[unit].NumArgsA,

-			  key->unit[unit].ModeA,

-			  key->unit[unit].OptA);

-   }

-

-   /* Deal with the final shift:

-    */

-   if (alpha_shift || rgb_shift) {

-      struct ureg shift;

-      GLboolean saturate = GL_TRUE;  /* always saturate at this point */

-

-      if (rgb_shift == alpha_shift) {

-	 shift = register_scalar_const(p, (GLfloat)(1<<rgb_shift));

-      }

-      else {

-	 shift = register_const4f(p, 

-				  (GLfloat)(1<<rgb_shift),

-				  (GLfloat)(1<<rgb_shift),

-				  (GLfloat)(1<<rgb_shift),

-				  (GLfloat)(1<<alpha_shift));

-      }

-      return emit_arith( p, OPCODE_MUL, dest, WRITEMASK_XYZW, 

-			 saturate, out, shift, undef );

-   }

-   else

-      return out;

-}

-

-

-/**

- * Generate instruction for getting a texture source term.

- */

-static void load_texture( struct texenv_fragment_program *p, GLuint unit )

-{

-   if (is_undef(p->src_texture[unit])) {

-      const GLuint texTarget = p->state->unit[unit].source_index;

-      struct ureg texcoord;

-      struct ureg tmp = get_tex_temp( p );

-

-      if (is_undef(p->texcoord_tex[unit])) {

-         texcoord = register_input(p, FRAG_ATTRIB_TEX0+unit);

-      }

-      else {

-         /* might want to reuse this reg for tex output actually */

-         texcoord = p->texcoord_tex[unit];

-      }

-

-      /* TODO: Use D0_MASK_XY where possible.

-       */

-      if (p->state->unit[unit].enabled) {

-         GLboolean shadow = GL_FALSE;

-

-	 if (p->state->unit[unit].shadow) {

-	    p->program->Base.ShadowSamplers |= 1 << unit;

-            shadow = GL_TRUE;

-         }

-

-	 p->src_texture[unit] = emit_texld( p, OPCODE_TXP,

-					    tmp, WRITEMASK_XYZW, 

-					    unit, texTarget, shadow,

-                                            texcoord );

-

-         p->program->Base.SamplersUsed |= (1 << unit);

-         /* This identity mapping should already be in place

-          * (see _mesa_init_program_struct()) but let's be safe.

-          */

-         p->program->Base.SamplerUnits[unit] = unit;

-      }

-      else

-	 p->src_texture[unit] = get_zero(p);

-

-      if (p->state->unit[unit].texture_cyl_wrap) {

-         /* set flag which is checked by Mesa->Gallium program translation */

-         p->program->Base.InputFlags[0] |= PROG_PARAM_BIT_CYL_WRAP;

-      }

-

-   }

-}

-

-static GLboolean load_texenv_source( struct texenv_fragment_program *p, 

-				     GLuint src, GLuint unit )

-{

-   switch (src) {

-   case SRC_TEXTURE:

-      load_texture(p, unit);

-      break;

-

-   case SRC_TEXTURE0:

-   case SRC_TEXTURE1:

-   case SRC_TEXTURE2:

-   case SRC_TEXTURE3:

-   case SRC_TEXTURE4:

-   case SRC_TEXTURE5:

-   case SRC_TEXTURE6:

-   case SRC_TEXTURE7:       

-      load_texture(p, src - SRC_TEXTURE0);

-      break;

-      

-   default:

-      /* not a texture src - do nothing */

-      break;

-   }

- 

-   return GL_TRUE;

-}

-

-

-/**

- * Generate instructions for loading all texture source terms.

- */

-static GLboolean

-load_texunit_sources( struct texenv_fragment_program *p, GLuint unit )

-{

-   const struct state_key *key = p->state;

-   GLuint i;

-

-   for (i = 0; i < key->unit[unit].NumArgsRGB; i++) {

-      load_texenv_source( p, key->unit[unit].OptRGB[i].Source, unit );

-   }

-

-   for (i = 0; i < key->unit[unit].NumArgsA; i++) {

-      load_texenv_source( p, key->unit[unit].OptA[i].Source, unit );

-   }

-

-   return GL_TRUE;

-}

-

-/**

- * Generate instructions for loading bump map textures.

- */

-static GLboolean

-load_texunit_bumpmap( struct texenv_fragment_program *p, GLuint unit )

-{

-   const struct state_key *key = p->state;

-   GLuint bumpedUnitNr = key->unit[unit].OptRGB[1].Source - SRC_TEXTURE0;

-   struct ureg texcDst, bumpMapRes;

-   struct ureg constdudvcolor = register_const4f(p, 0.0, 0.0, 0.0, 1.0);

-   struct ureg texcSrc = register_input(p, FRAG_ATTRIB_TEX0 + bumpedUnitNr);

-   struct ureg rotMat0 = register_param3( p, STATE_INTERNAL, STATE_ROT_MATRIX_0, unit );

-   struct ureg rotMat1 = register_param3( p, STATE_INTERNAL, STATE_ROT_MATRIX_1, unit );

-

-   load_texenv_source( p, unit + SRC_TEXTURE0, unit );

-

-   bumpMapRes = get_source(p, key->unit[unit].OptRGB[0].Source, unit);

-   texcDst = get_tex_temp( p );

-   p->texcoord_tex[bumpedUnitNr] = texcDst;

-

-   /* Apply rot matrix and add coords to be available in next phase.

-    * dest = (Arg0.xxxx * rotMat0 + Arg1) + (Arg0.yyyy * rotMat1)

-    * note only 2 coords are affected the rest are left unchanged (mul by 0)

-    */

-   emit_arith( p, OPCODE_MAD, texcDst, WRITEMASK_XYZW, 0,

-               swizzle1(bumpMapRes, SWIZZLE_X), rotMat0, texcSrc );

-   emit_arith( p, OPCODE_MAD, texcDst, WRITEMASK_XYZW, 0,

-               swizzle1(bumpMapRes, SWIZZLE_Y), rotMat1, texcDst );

-

-   /* Move 0,0,0,1 into bumpmap src if someone (crossbar) is foolish

-    * enough to access this later, should optimize away.

-    */

-   emit_arith( p, OPCODE_MOV, bumpMapRes, WRITEMASK_XYZW, 0,

-               constdudvcolor, undef, undef );

-

-   return GL_TRUE;

-}

-

-/**

- * Generate a new fragment program which implements the context's

- * current texture env/combine mode.

- */

-static void

-create_new_program(struct gl_context *ctx, struct state_key *key,

-                   struct gl_fragment_program *program)

-{

-   struct prog_instruction instBuffer[MAX_INSTRUCTIONS];

-   struct texenv_fragment_program p;

-   GLuint unit;

-   struct ureg cf, out;

-   int i;

-

-   memset(&p, 0, sizeof(p));

-   p.state = key;

-   p.program = program;

-

-   /* During code generation, use locally-allocated instruction buffer,

-    * then alloc dynamic storage below.

-    */

-   p.program->Base.Instructions = instBuffer;

-   p.program->Base.Target = GL_FRAGMENT_PROGRAM_ARB;

-   p.program->Base.String = NULL;

-   p.program->Base.NumTexIndirections = 1; /* is this right? */

-   p.program->Base.NumTexInstructions = 0;

-   p.program->Base.NumAluInstructions = 0;

-   p.program->Base.NumInstructions = 0;

-   p.program->Base.NumTemporaries = 0;

-   p.program->Base.NumParameters = 0;

-   p.program->Base.NumAttributes = 0;

-   p.program->Base.NumAddressRegs = 0;

-   p.program->Base.Parameters = _mesa_new_parameter_list();

-   p.program->Base.InputsRead = 0x0;

-

-   if (key->num_draw_buffers == 1)

-      p.program->Base.OutputsWritten = 1 << FRAG_RESULT_COLOR;

-   else {

-      for (i = 0; i < key->num_draw_buffers; i++)

-	 p.program->Base.OutputsWritten |= (1 << (FRAG_RESULT_DATA0 + i));

-   }

-

-   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {

-      p.src_texture[unit] = undef;

-      p.texcoord_tex[unit] = undef;

-   }

-

-   p.src_previous = undef;

-   p.half = undef;

-   p.zero = undef;

-   p.one = undef;

-

-   p.last_tex_stage = 0;

-   release_temps(ctx, &p);

-

-   if (key->enabled_units && key->num_draw_buffers) {

-      GLboolean needbumpstage = GL_FALSE;

-

-      /* Zeroth pass - bump map textures first */

-      for (unit = 0; unit < key->nr_enabled_units; unit++)

-	 if (key->unit[unit].enabled &&

-             key->unit[unit].ModeRGB == MODE_BUMP_ENVMAP_ATI) {

-	    needbumpstage = GL_TRUE;

-	    load_texunit_bumpmap( &p, unit );

-	 }

-      if (needbumpstage)

-	 p.program->Base.NumTexIndirections++;

-

-      /* First pass - to support texture_env_crossbar, first identify

-       * all referenced texture sources and emit texld instructions

-       * for each:

-       */

-      for (unit = 0; unit < key->nr_enabled_units; unit++)

-	 if (key->unit[unit].enabled) {

-	    load_texunit_sources( &p, unit );

-	    p.last_tex_stage = unit;

-	 }

-

-      /* Second pass - emit combine instructions to build final color:

-       */

-      for (unit = 0; unit < key->nr_enabled_units; unit++)

-	 if (key->unit[unit].enabled) {

-	    p.src_previous = emit_texenv( &p, unit );

-            reserve_temp(&p, p.src_previous); /* don't re-use this temp reg */

-	    release_temps(ctx, &p);	/* release all temps */

-	 }

-   }

-

-   cf = get_source( &p, SRC_PREVIOUS, 0 );

-

-   for (i = 0; i < key->num_draw_buffers; i++) {

-      if (key->num_draw_buffers == 1)

-	 out = make_ureg( PROGRAM_OUTPUT, FRAG_RESULT_COLOR );

-      else {

-	 out = make_ureg( PROGRAM_OUTPUT, FRAG_RESULT_DATA0 + i );

-      }

-

-      if (key->separate_specular) {

-	 /* Emit specular add.

-	  */

-	 struct ureg s = register_input(&p, FRAG_ATTRIB_COL1);

-	 emit_arith( &p, OPCODE_ADD, out, WRITEMASK_XYZ, 0, cf, s, undef );

-	 emit_arith( &p, OPCODE_MOV, out, WRITEMASK_W, 0, cf, undef, undef );

-      }

-      else if (memcmp(&cf, &out, sizeof(cf)) != 0) {

-	 /* Will wind up in here if no texture enabled or a couple of

-	  * other scenarios (GL_REPLACE for instance).

-	  */

-	 emit_arith( &p, OPCODE_MOV, out, WRITEMASK_XYZW, 0, cf, undef, undef );

-      }

-   }

-   /* Finish up:

-    */

-   emit_arith( &p, OPCODE_END, undef, WRITEMASK_XYZW, 0, undef, undef, undef);

-

-   if (key->fog_enabled) {

-      /* Pull fog mode from struct gl_context, the value in the state key is

-       * a reduced value and not what is expected in FogOption

-       */

-      p.program->FogOption = ctx->Fog.Mode;

-      p.program->Base.InputsRead |= FRAG_BIT_FOGC;

-   }

-   else {

-      p.program->FogOption = GL_NONE;

-   }

-

-   if (p.program->Base.NumTexIndirections > ctx->Const.FragmentProgram.MaxTexIndirections) 

-      program_error(&p, "Exceeded max nr indirect texture lookups");

-

-   if (p.program->Base.NumTexInstructions > ctx->Const.FragmentProgram.MaxTexInstructions)

-      program_error(&p, "Exceeded max TEX instructions");

-

-   if (p.program->Base.NumAluInstructions > ctx->Const.FragmentProgram.MaxAluInstructions)

-      program_error(&p, "Exceeded max ALU instructions");

-

-   ASSERT(p.program->Base.NumInstructions <= MAX_INSTRUCTIONS);

-

-   /* Allocate final instruction array */

-   p.program->Base.Instructions

-      = _mesa_alloc_instructions(p.program->Base.NumInstructions);

-   if (!p.program->Base.Instructions) {

-      _mesa_error(ctx, GL_OUT_OF_MEMORY,

-                  "generating tex env program");

-      return;

-   }

-   _mesa_copy_instructions(p.program->Base.Instructions, instBuffer,

-                           p.program->Base.NumInstructions);

-

-   if (key->num_draw_buffers && p.program->FogOption) {

-      _mesa_append_fog_code(ctx, p.program);

-      p.program->FogOption = GL_NONE;

-   }

-

-

-   /* Notify driver the fragment program has (actually) changed.

-    */

-   if (ctx->Driver.ProgramStringNotify) {

-      GLboolean ok = ctx->Driver.ProgramStringNotify(ctx,

-                                                     GL_FRAGMENT_PROGRAM_ARB, 

-                                                     &p.program->Base);

-      /* Driver should be able to handle any texenv programs as long as

-       * the driver correctly reported max number of texture units correctly,

-       * etc.

-       */

-      ASSERT(ok);

-      (void) ok; /* silence unused var warning */

-   }

-

-   if (DISASSEM) {

-      _mesa_print_program(&p.program->Base);

-      printf("\n");

-   }

-}

-

-extern "C" {

-

-/**

- * Return a fragment program which implements the current

- * fixed-function texture, fog and color-sum operations.

- */

-struct gl_fragment_program *

-_mesa_get_fixed_func_fragment_program(struct gl_context *ctx)

-{

-   struct gl_fragment_program *prog;

-   struct state_key key;

-   GLuint keySize;

-	

-   keySize = make_state_key(ctx, &key);

-      

-   prog = (struct gl_fragment_program *)

-      _mesa_search_program_cache(ctx->FragmentProgram.Cache,

-                                 &key, keySize);

-

-   if (!prog) {

-      prog = (struct gl_fragment_program *) 

-         ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);

-

-      create_new_program(ctx, &key, prog);

-

-      _mesa_program_cache_insert(ctx, ctx->FragmentProgram.Cache,

-                                 &key, keySize, &prog->Base);

-   }

-

-   return prog;

-}

-

-}

+/**************************************************************************
+ * 
+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * All Rights Reserved.
+ * Copyright 2009 VMware, Inc.  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 TUNGSTEN GRAPHICS AND/OR ITS 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.
+ * 
+ **************************************************************************/
+
+extern "C" {
+#include "glheader.h"
+#include "imports.h"
+#include "mtypes.h"
+#include "program/program.h"
+#include "program/prog_parameter.h"
+#include "program/prog_cache.h"
+#include "program/prog_instruction.h"
+#include "program/prog_print.h"
+#include "program/prog_statevars.h"
+#include "program/programopt.h"
+#include "texenvprogram.h"
+}
+
+/*
+ * Note on texture units:
+ *
+ * The number of texture units supported by fixed-function fragment
+ * processing is MAX_TEXTURE_COORD_UNITS, not MAX_TEXTURE_IMAGE_UNITS.
+ * That's because there's a one-to-one correspondence between texture
+ * coordinates and samplers in fixed-function processing.
+ *
+ * Since fixed-function vertex processing is limited to MAX_TEXTURE_COORD_UNITS
+ * sets of texcoords, so is fixed-function fragment processing.
+ *
+ * We can safely use ctx->Const.MaxTextureUnits for loop bounds.
+ */
+
+
+struct texenvprog_cache_item
+{
+   GLuint hash;
+   void *key;
+   struct gl_fragment_program *data;
+   struct texenvprog_cache_item *next;
+};
+
+static GLboolean
+texenv_doing_secondary_color(struct gl_context *ctx)
+{
+   if (ctx->Light.Enabled &&
+       (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR))
+      return GL_TRUE;
+
+   if (ctx->Fog.ColorSumEnabled)
+      return GL_TRUE;
+
+   return GL_FALSE;
+}
+
+/**
+ * Up to nine instructions per tex unit, plus fog, specular color.
+ */
+#define MAX_INSTRUCTIONS ((MAX_TEXTURE_COORD_UNITS * 9) + 12)
+
+#define DISASSEM (MESA_VERBOSE & VERBOSE_DISASSEM)
+
+struct mode_opt {
+#ifdef __GNUC__
+   __extension__ GLubyte Source:4;  /**< SRC_x */
+   __extension__ GLubyte Operand:3; /**< OPR_x */
+#else
+   GLubyte Source;  /**< SRC_x */
+   GLubyte Operand; /**< OPR_x */
+#endif
+};
+
+struct state_key {
+   GLuint nr_enabled_units:8;
+   GLuint enabled_units:8;
+   GLuint separate_specular:1;
+   GLuint fog_enabled:1;
+   GLuint fog_mode:2;          /**< FOG_x */
+   GLuint inputs_available:12;
+   GLuint num_draw_buffers:4;
+
+   /* NOTE: This array of structs must be last! (see "keySize" below) */
+   struct {
+      GLuint enabled:1;
+      GLuint source_index:3;   /**< TEXTURE_x_INDEX */
+      GLuint shadow:1;
+      GLuint ScaleShiftRGB:2;
+      GLuint ScaleShiftA:2;
+
+      GLuint NumArgsRGB:3;  /**< up to MAX_COMBINER_TERMS */
+      GLuint ModeRGB:5;     /**< MODE_x */
+
+      GLuint NumArgsA:3;  /**< up to MAX_COMBINER_TERMS */
+      GLuint ModeA:5;     /**< MODE_x */
+
+      GLuint texture_cyl_wrap:1; /**< For gallium test/debug only */
+
+      struct mode_opt OptRGB[MAX_COMBINER_TERMS];
+      struct mode_opt OptA[MAX_COMBINER_TERMS];
+   } unit[MAX_TEXTURE_UNITS];
+};
+
+#define FOG_LINEAR  0
+#define FOG_EXP     1
+#define FOG_EXP2    2
+#define FOG_UNKNOWN 3
+
+static GLuint translate_fog_mode( GLenum mode )
+{
+   switch (mode) {
+   case GL_LINEAR: return FOG_LINEAR;
+   case GL_EXP: return FOG_EXP;
+   case GL_EXP2: return FOG_EXP2;
+   default: return FOG_UNKNOWN;
+   }
+}
+
+#define OPR_SRC_COLOR           0
+#define OPR_ONE_MINUS_SRC_COLOR 1
+#define OPR_SRC_ALPHA           2
+#define OPR_ONE_MINUS_SRC_ALPHA	3
+#define OPR_ZERO                4
+#define OPR_ONE                 5
+#define OPR_UNKNOWN             7
+
+static GLuint translate_operand( GLenum operand )
+{
+   switch (operand) {
+   case GL_SRC_COLOR: return OPR_SRC_COLOR;
+   case GL_ONE_MINUS_SRC_COLOR: return OPR_ONE_MINUS_SRC_COLOR;
+   case GL_SRC_ALPHA: return OPR_SRC_ALPHA;
+   case GL_ONE_MINUS_SRC_ALPHA: return OPR_ONE_MINUS_SRC_ALPHA;
+   case GL_ZERO: return OPR_ZERO;
+   case GL_ONE: return OPR_ONE;
+   default:
+      assert(0);
+      return OPR_UNKNOWN;
+   }
+}
+
+#define SRC_TEXTURE  0
+#define SRC_TEXTURE0 1
+#define SRC_TEXTURE1 2
+#define SRC_TEXTURE2 3
+#define SRC_TEXTURE3 4
+#define SRC_TEXTURE4 5
+#define SRC_TEXTURE5 6
+#define SRC_TEXTURE6 7
+#define SRC_TEXTURE7 8
+#define SRC_CONSTANT 9
+#define SRC_PRIMARY_COLOR 10
+#define SRC_PREVIOUS 11
+#define SRC_ZERO     12
+#define SRC_UNKNOWN  15
+
+static GLuint translate_source( GLenum src )
+{
+   switch (src) {
+   case GL_TEXTURE: return SRC_TEXTURE;
+   case GL_TEXTURE0:
+   case GL_TEXTURE1:
+   case GL_TEXTURE2:
+   case GL_TEXTURE3:
+   case GL_TEXTURE4:
+   case GL_TEXTURE5:
+   case GL_TEXTURE6:
+   case GL_TEXTURE7: return SRC_TEXTURE0 + (src - GL_TEXTURE0);
+   case GL_CONSTANT: return SRC_CONSTANT;
+   case GL_PRIMARY_COLOR: return SRC_PRIMARY_COLOR;
+   case GL_PREVIOUS: return SRC_PREVIOUS;
+   case GL_ZERO:
+      return SRC_ZERO;
+   default:
+      assert(0);
+      return SRC_UNKNOWN;
+   }
+}
+
+#define MODE_REPLACE                     0  /* r = a0 */
+#define MODE_MODULATE                    1  /* r = a0 * a1 */
+#define MODE_ADD                         2  /* r = a0 + a1 */
+#define MODE_ADD_SIGNED                  3  /* r = a0 + a1 - 0.5 */
+#define MODE_INTERPOLATE                 4  /* r = a0 * a2 + a1 * (1 - a2) */
+#define MODE_SUBTRACT                    5  /* r = a0 - a1 */
+#define MODE_DOT3_RGB                    6  /* r = a0 . a1 */
+#define MODE_DOT3_RGB_EXT                7  /* r = a0 . a1 */
+#define MODE_DOT3_RGBA                   8  /* r = a0 . a1 */
+#define MODE_DOT3_RGBA_EXT               9  /* r = a0 . a1 */
+#define MODE_MODULATE_ADD_ATI           10  /* r = a0 * a2 + a1 */
+#define MODE_MODULATE_SIGNED_ADD_ATI    11  /* r = a0 * a2 + a1 - 0.5 */
+#define MODE_MODULATE_SUBTRACT_ATI      12  /* r = a0 * a2 - a1 */
+#define MODE_ADD_PRODUCTS               13  /* r = a0 * a1 + a2 * a3 */
+#define MODE_ADD_PRODUCTS_SIGNED        14  /* r = a0 * a1 + a2 * a3 - 0.5 */
+#define MODE_BUMP_ENVMAP_ATI            15  /* special */
+#define MODE_UNKNOWN                    16
+
+/**
+ * Translate GL combiner state into a MODE_x value
+ */
+static GLuint translate_mode( GLenum envMode, GLenum mode )
+{
+   switch (mode) {
+   case GL_REPLACE: return MODE_REPLACE;
+   case GL_MODULATE: return MODE_MODULATE;
+   case GL_ADD:
+      if (envMode == GL_COMBINE4_NV)
+         return MODE_ADD_PRODUCTS;
+      else
+         return MODE_ADD;
+   case GL_ADD_SIGNED:
+      if (envMode == GL_COMBINE4_NV)
+         return MODE_ADD_PRODUCTS_SIGNED;
+      else
+         return MODE_ADD_SIGNED;
+   case GL_INTERPOLATE: return MODE_INTERPOLATE;
+   case GL_SUBTRACT: return MODE_SUBTRACT;
+   case GL_DOT3_RGB: return MODE_DOT3_RGB;
+   case GL_DOT3_RGB_EXT: return MODE_DOT3_RGB_EXT;
+   case GL_DOT3_RGBA: return MODE_DOT3_RGBA;
+   case GL_DOT3_RGBA_EXT: return MODE_DOT3_RGBA_EXT;
+   case GL_MODULATE_ADD_ATI: return MODE_MODULATE_ADD_ATI;
+   case GL_MODULATE_SIGNED_ADD_ATI: return MODE_MODULATE_SIGNED_ADD_ATI;
+   case GL_MODULATE_SUBTRACT_ATI: return MODE_MODULATE_SUBTRACT_ATI;
+   case GL_BUMP_ENVMAP_ATI: return MODE_BUMP_ENVMAP_ATI;
+   default:
+      assert(0);
+      return MODE_UNKNOWN;
+   }
+}
+
+
+/**
+ * Do we need to clamp the results of the given texture env/combine mode?
+ * If the inputs to the mode are in [0,1] we don't always have to clamp
+ * the results.
+ */
+static GLboolean
+need_saturate( GLuint mode )
+{
+   switch (mode) {
+   case MODE_REPLACE:
+   case MODE_MODULATE:
+   case MODE_INTERPOLATE:
+      return GL_FALSE;
+   case MODE_ADD:
+   case MODE_ADD_SIGNED:
+   case MODE_SUBTRACT:
+   case MODE_DOT3_RGB:
+   case MODE_DOT3_RGB_EXT:
+   case MODE_DOT3_RGBA:
+   case MODE_DOT3_RGBA_EXT:
+   case MODE_MODULATE_ADD_ATI:
+   case MODE_MODULATE_SIGNED_ADD_ATI:
+   case MODE_MODULATE_SUBTRACT_ATI:
+   case MODE_ADD_PRODUCTS:
+   case MODE_ADD_PRODUCTS_SIGNED:
+   case MODE_BUMP_ENVMAP_ATI:
+      return GL_TRUE;
+   default:
+      assert(0);
+      return GL_FALSE;
+   }
+}
+
+
+
+/**
+ * Translate TEXTURE_x_BIT to TEXTURE_x_INDEX.
+ */
+static GLuint translate_tex_src_bit( GLbitfield bit )
+{
+   ASSERT(bit);
+   return _mesa_ffs(bit) - 1;
+}
+
+
+#define VERT_BIT_TEX_ANY    (0xff << VERT_ATTRIB_TEX0)
+#define VERT_RESULT_TEX_ANY (0xff << VERT_RESULT_TEX0)
+
+/**
+ * Identify all possible varying inputs.  The fragment program will
+ * never reference non-varying inputs, but will track them via state
+ * constants instead.
+ *
+ * This function figures out all the inputs that the fragment program
+ * has access to.  The bitmask is later reduced to just those which
+ * are actually referenced.
+ */
+static GLbitfield get_fp_input_mask( struct gl_context *ctx )
+{
+   /* _NEW_PROGRAM */
+   const GLboolean vertexShader =
+      (ctx->Shader.CurrentVertexProgram &&
+       ctx->Shader.CurrentVertexProgram->LinkStatus &&
+       ctx->Shader.CurrentVertexProgram->VertexProgram);
+   const GLboolean vertexProgram = ctx->VertexProgram._Enabled;
+   GLbitfield fp_inputs = 0x0;
+
+   if (ctx->VertexProgram._Overriden) {
+      /* Somebody's messing with the vertex program and we don't have
+       * a clue what's happening.  Assume that it could be producing
+       * all possible outputs.
+       */
+      fp_inputs = ~0;
+   }
+   else if (ctx->RenderMode == GL_FEEDBACK) {
+      /* _NEW_RENDERMODE */
+      fp_inputs = (FRAG_BIT_COL0 | FRAG_BIT_TEX0);
+   }
+   else if (!(vertexProgram || vertexShader) ||
+            !ctx->VertexProgram._Current) {
+      /* Fixed function vertex logic */
+      /* _NEW_ARRAY */
+      GLbitfield varying_inputs = ctx->varying_vp_inputs;
+
+      /* These get generated in the setup routine regardless of the
+       * vertex program:
+       */
+      /* _NEW_POINT */
+      if (ctx->Point.PointSprite)
+         varying_inputs |= FRAG_BITS_TEX_ANY;
+
+      /* First look at what values may be computed by the generated
+       * vertex program:
+       */
+      /* _NEW_LIGHT */
+      if (ctx->Light.Enabled) {
+         fp_inputs |= FRAG_BIT_COL0;
+
+         if (texenv_doing_secondary_color(ctx))
+            fp_inputs |= FRAG_BIT_COL1;
+      }
+
+      /* _NEW_TEXTURE */
+      fp_inputs |= (ctx->Texture._TexGenEnabled |
+                    ctx->Texture._TexMatEnabled) << FRAG_ATTRIB_TEX0;
+
+      /* Then look at what might be varying as a result of enabled
+       * arrays, etc:
+       */
+      if (varying_inputs & VERT_BIT_COLOR0)
+         fp_inputs |= FRAG_BIT_COL0;
+      if (varying_inputs & VERT_BIT_COLOR1)
+         fp_inputs |= FRAG_BIT_COL1;
+
+      fp_inputs |= (((varying_inputs & VERT_BIT_TEX_ANY) >> VERT_ATTRIB_TEX0) 
+                    << FRAG_ATTRIB_TEX0);
+
+   }
+   else {
+      /* calculate from vp->outputs */
+      struct gl_vertex_program *vprog;
+      GLbitfield64 vp_outputs;
+
+      /* Choose GLSL vertex shader over ARB vertex program.  Need this
+       * since vertex shader state validation comes after fragment state
+       * validation (see additional comments in state.c).
+       */
+      if (vertexShader)
+         vprog = ctx->Shader.CurrentVertexProgram->VertexProgram;
+      else
+         vprog = ctx->VertexProgram.Current;
+
+      vp_outputs = vprog->Base.OutputsWritten;
+
+      /* These get generated in the setup routine regardless of the
+       * vertex program:
+       */
+      /* _NEW_POINT */
+      if (ctx->Point.PointSprite)
+         vp_outputs |= FRAG_BITS_TEX_ANY;
+
+      if (vp_outputs & (1 << VERT_RESULT_COL0))
+         fp_inputs |= FRAG_BIT_COL0;
+      if (vp_outputs & (1 << VERT_RESULT_COL1))
+         fp_inputs |= FRAG_BIT_COL1;
+
+      fp_inputs |= (((vp_outputs & VERT_RESULT_TEX_ANY) >> VERT_RESULT_TEX0) 
+                    << FRAG_ATTRIB_TEX0);
+   }
+   
+   return fp_inputs;
+}
+
+
+/**
+ * Examine current texture environment state and generate a unique
+ * key to identify it.
+ */
+static GLuint make_state_key( struct gl_context *ctx,  struct state_key *key )
+{
+   GLuint i, j;
+   GLbitfield inputs_referenced = FRAG_BIT_COL0;
+   const GLbitfield inputs_available = get_fp_input_mask( ctx );
+   GLuint keySize;
+
+   memset(key, 0, sizeof(*key));
+
+   /* _NEW_TEXTURE */
+   for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
+      const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
+      const struct gl_texture_object *texObj = texUnit->_Current;
+      const struct gl_tex_env_combine_state *comb = texUnit->_CurrentCombine;
+      GLenum format;
+
+      if (!texUnit->_ReallyEnabled || !texUnit->Enabled)
+         continue;
+
+      format = texObj->Image[0][texObj->BaseLevel]->_BaseFormat;
+
+      key->unit[i].enabled = 1;
+      key->enabled_units |= (1<<i);
+      key->nr_enabled_units = i + 1;
+      inputs_referenced |= FRAG_BIT_TEX(i);
+
+      key->unit[i].source_index =
+         translate_tex_src_bit(texUnit->_ReallyEnabled);
+
+      key->unit[i].shadow = ((texObj->CompareMode == GL_COMPARE_R_TO_TEXTURE) &&
+                             ((format == GL_DEPTH_COMPONENT) || 
+                              (format == GL_DEPTH_STENCIL_EXT)));
+
+      key->unit[i].NumArgsRGB = comb->_NumArgsRGB;
+      key->unit[i].NumArgsA = comb->_NumArgsA;
+
+      key->unit[i].ModeRGB =
+	 translate_mode(texUnit->EnvMode, comb->ModeRGB);
+      key->unit[i].ModeA =
+	 translate_mode(texUnit->EnvMode, comb->ModeA);
+
+      key->unit[i].ScaleShiftRGB = comb->ScaleShiftRGB;
+      key->unit[i].ScaleShiftA = comb->ScaleShiftA;
+
+      for (j = 0; j < MAX_COMBINER_TERMS; j++) {
+         key->unit[i].OptRGB[j].Operand = translate_operand(comb->OperandRGB[j]);
+         key->unit[i].OptA[j].Operand = translate_operand(comb->OperandA[j]);
+         key->unit[i].OptRGB[j].Source = translate_source(comb->SourceRGB[j]);
+         key->unit[i].OptA[j].Source = translate_source(comb->SourceA[j]);
+      }
+
+      if (key->unit[i].ModeRGB == MODE_BUMP_ENVMAP_ATI) {
+         /* requires some special translation */
+         key->unit[i].NumArgsRGB = 2;
+         key->unit[i].ScaleShiftRGB = 0;
+         key->unit[i].OptRGB[0].Operand = OPR_SRC_COLOR;
+         key->unit[i].OptRGB[0].Source = SRC_TEXTURE;
+         key->unit[i].OptRGB[1].Operand = OPR_SRC_COLOR;
+         key->unit[i].OptRGB[1].Source = texUnit->BumpTarget - GL_TEXTURE0 + SRC_TEXTURE0;
+       }
+
+      /* this is a back-door for enabling cylindrical texture wrap mode */
+      if (texObj->Priority == 0.125)
+         key->unit[i].texture_cyl_wrap = 1;
+   }
+
+   /* _NEW_LIGHT | _NEW_FOG */
+   if (texenv_doing_secondary_color(ctx)) {
+      key->separate_specular = 1;
+      inputs_referenced |= FRAG_BIT_COL1;
+   }
+
+   /* _NEW_FOG */
+   if (ctx->Fog.Enabled) {
+      key->fog_enabled = 1;
+      key->fog_mode = translate_fog_mode(ctx->Fog.Mode);
+      inputs_referenced |= FRAG_BIT_FOGC; /* maybe */
+   }
+
+   /* _NEW_BUFFERS */
+   key->num_draw_buffers = ctx->DrawBuffer->_NumColorDrawBuffers;
+
+   key->inputs_available = (inputs_available & inputs_referenced);
+
+   /* compute size of state key, ignoring unused texture units */
+   keySize = sizeof(*key) - sizeof(key->unit)
+      + key->nr_enabled_units * sizeof(key->unit[0]);
+
+   return keySize;
+}
+
+
+/**
+ * Use uregs to represent registers internally, translate to Mesa's
+ * expected formats on emit.  
+ *
+ * NOTE: These are passed by value extensively in this file rather
+ * than as usual by pointer reference.  If this disturbs you, try
+ * remembering they are just 32bits in size.
+ *
+ * GCC is smart enough to deal with these dword-sized structures in
+ * much the same way as if I had defined them as dwords and was using
+ * macros to access and set the fields.  This is much nicer and easier
+ * to evolve.
+ */
+struct ureg {
+   GLuint file:4;
+   GLuint idx:8;
+   GLuint negatebase:1;
+   GLuint swz:12;
+   GLuint pad:7;
+};
+
+static const struct ureg undef = { 
+   PROGRAM_UNDEFINED,
+   255,
+   0,
+   0,
+   0
+};
+
+
+/** State used to build the fragment program:
+ */
+struct texenv_fragment_program {
+   struct gl_fragment_program *program;
+   struct state_key *state;
+
+   GLbitfield alu_temps;	/**< Track texture indirections, see spec. */
+   GLbitfield temps_output;	/**< Track texture indirections, see spec. */
+   GLbitfield temp_in_use;	/**< Tracks temporary regs which are in use. */
+   GLboolean error;
+
+   struct ureg src_texture[MAX_TEXTURE_COORD_UNITS];   
+   /* Reg containing each texture unit's sampled texture color,
+    * else undef.
+    */
+
+   struct ureg texcoord_tex[MAX_TEXTURE_COORD_UNITS];
+   /* Reg containing texcoord for a texture unit,
+    * needed for bump mapping, else undef.
+    */
+
+   struct ureg src_previous;	/**< Reg containing color from previous 
+				 * stage.  May need to be decl'd.
+				 */
+
+   GLuint last_tex_stage;	/**< Number of last enabled texture unit */
+
+   struct ureg half;
+   struct ureg one;
+   struct ureg zero;
+};
+
+
+
+static struct ureg make_ureg(GLuint file, GLuint idx)
+{
+   struct ureg reg;
+   reg.file = file;
+   reg.idx = idx;
+   reg.negatebase = 0;
+   reg.swz = SWIZZLE_NOOP;
+   reg.pad = 0;
+   return reg;
+}
+
+static struct ureg swizzle( struct ureg reg, int x, int y, int z, int w )
+{
+   reg.swz = MAKE_SWIZZLE4(GET_SWZ(reg.swz, x),
+			   GET_SWZ(reg.swz, y),
+			   GET_SWZ(reg.swz, z),
+			   GET_SWZ(reg.swz, w));
+
+   return reg;
+}
+
+static struct ureg swizzle1( struct ureg reg, int x )
+{
+   return swizzle(reg, x, x, x, x);
+}
+
+static struct ureg negate( struct ureg reg )
+{
+   reg.negatebase ^= 1;
+   return reg;
+}
+
+static GLboolean is_undef( struct ureg reg )
+{
+   return reg.file == PROGRAM_UNDEFINED;
+}
+
+
+static struct ureg get_temp( struct texenv_fragment_program *p )
+{
+   GLint bit;
+   
+   /* First try and reuse temps which have been used already:
+    */
+   bit = _mesa_ffs( ~p->temp_in_use & p->alu_temps );
+
+   /* Then any unused temporary:
+    */
+   if (!bit)
+      bit = _mesa_ffs( ~p->temp_in_use );
+
+   if (!bit) {
+      _mesa_problem(NULL, "%s: out of temporaries\n", __FILE__);
+      exit(1);
+   }
+
+   if ((GLuint) bit > p->program->Base.NumTemporaries)
+      p->program->Base.NumTemporaries = bit;
+
+   p->temp_in_use |= 1<<(bit-1);
+   return make_ureg(PROGRAM_TEMPORARY, (bit-1));
+}
+
+static struct ureg get_tex_temp( struct texenv_fragment_program *p )
+{
+   int bit;
+   
+   /* First try to find available temp not previously used (to avoid
+    * starting a new texture indirection).  According to the spec, the
+    * ~p->temps_output isn't necessary, but will keep it there for
+    * now:
+    */
+   bit = _mesa_ffs( ~p->temp_in_use & ~p->alu_temps & ~p->temps_output );
+
+   /* Then any unused temporary:
+    */
+   if (!bit) 
+      bit = _mesa_ffs( ~p->temp_in_use );
+
+   if (!bit) {
+      _mesa_problem(NULL, "%s: out of temporaries\n", __FILE__);
+      exit(1);
+   }
+
+   if ((GLuint) bit > p->program->Base.NumTemporaries)
+      p->program->Base.NumTemporaries = bit;
+
+   p->temp_in_use |= 1<<(bit-1);
+   return make_ureg(PROGRAM_TEMPORARY, (bit-1));
+}
+
+
+/** Mark a temp reg as being no longer allocatable. */
+static void reserve_temp( struct texenv_fragment_program *p, struct ureg r )
+{
+   if (r.file == PROGRAM_TEMPORARY)
+      p->temps_output |= (1 << r.idx);
+}
+
+
+static void release_temps(struct gl_context *ctx, struct texenv_fragment_program *p )
+{
+   GLuint max_temp = ctx->Const.FragmentProgram.MaxTemps;
+
+   /* KW: To support tex_env_crossbar, don't release the registers in
+    * temps_output.
+    */
+   if (max_temp >= sizeof(int) * 8)
+      p->temp_in_use = p->temps_output;
+   else
+      p->temp_in_use = ~((1<<max_temp)-1) | p->temps_output;
+}
+
+
+static struct ureg register_param5( struct texenv_fragment_program *p, 
+				    GLint s0,
+				    GLint s1,
+				    GLint s2,
+				    GLint s3,
+				    GLint s4)
+{
+   int tokens[STATE_LENGTH];
+   GLuint idx;
+   tokens[0] = s0;
+   tokens[1] = s1;
+   tokens[2] = s2;
+   tokens[3] = s3;
+   tokens[4] = s4;
+   idx = _mesa_add_state_reference(p->program->Base.Parameters,
+				   (gl_state_index *)tokens);
+   return make_ureg(PROGRAM_STATE_VAR, idx);
+}
+
+
+#define register_param1(p,s0)          register_param5(p,s0,0,0,0,0)
+#define register_param2(p,s0,s1)       register_param5(p,s0,s1,0,0,0)
+#define register_param3(p,s0,s1,s2)    register_param5(p,s0,s1,s2,0,0)
+#define register_param4(p,s0,s1,s2,s3) register_param5(p,s0,s1,s2,s3,0)
+
+static GLuint frag_to_vert_attrib( GLuint attrib )
+{
+   switch (attrib) {
+   case FRAG_ATTRIB_COL0: return VERT_ATTRIB_COLOR0;
+   case FRAG_ATTRIB_COL1: return VERT_ATTRIB_COLOR1;
+   default:
+      assert(attrib >= FRAG_ATTRIB_TEX0);
+      assert(attrib <= FRAG_ATTRIB_TEX7);
+      return attrib - FRAG_ATTRIB_TEX0 + VERT_ATTRIB_TEX0;
+   }
+}
+
+
+static struct ureg register_input( struct texenv_fragment_program *p, GLuint input )
+{
+   if (p->state->inputs_available & (1<<input)) {
+      p->program->Base.InputsRead |= (1 << input);
+      return make_ureg(PROGRAM_INPUT, input);
+   }
+   else {
+      GLuint idx = frag_to_vert_attrib( input );
+      return register_param3( p, STATE_INTERNAL, STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED, idx );
+   }
+}
+
+
+static void emit_arg( struct prog_src_register *reg,
+		      struct ureg ureg )
+{
+   reg->File = ureg.file;
+   reg->Index = ureg.idx;
+   reg->Swizzle = ureg.swz;
+   reg->Negate = ureg.negatebase ? NEGATE_XYZW : NEGATE_NONE;
+   reg->Abs = GL_FALSE;
+}
+
+static void emit_dst( struct prog_dst_register *dst,
+		      struct ureg ureg, GLuint mask )
+{
+   dst->File = ureg.file;
+   dst->Index = ureg.idx;
+   dst->WriteMask = mask;
+   dst->CondMask = COND_TR;  /* always pass cond test */
+   dst->CondSwizzle = SWIZZLE_NOOP;
+}
+
+static struct prog_instruction *
+emit_op(struct texenv_fragment_program *p,
+	enum prog_opcode op,
+	struct ureg dest,
+	GLuint mask,
+	GLboolean saturate,
+	struct ureg src0,
+	struct ureg src1,
+	struct ureg src2 )
+{
+   const GLuint nr = p->program->Base.NumInstructions++;
+   struct prog_instruction *inst = &p->program->Base.Instructions[nr];
+
+   assert(nr < MAX_INSTRUCTIONS);
+
+   _mesa_init_instructions(inst, 1);
+   inst->Opcode = op;
+   
+   emit_arg( &inst->SrcReg[0], src0 );
+   emit_arg( &inst->SrcReg[1], src1 );
+   emit_arg( &inst->SrcReg[2], src2 );
+   
+   inst->SaturateMode = saturate ? SATURATE_ZERO_ONE : SATURATE_OFF;
+
+   emit_dst( &inst->DstReg, dest, mask );
+
+#if 0
+   /* Accounting for indirection tracking:
+    */
+   if (dest.file == PROGRAM_TEMPORARY)
+      p->temps_output |= 1 << dest.idx;
+#endif
+
+   return inst;
+}
+   
+
+static struct ureg emit_arith( struct texenv_fragment_program *p,
+			       enum prog_opcode op,
+			       struct ureg dest,
+			       GLuint mask,
+			       GLboolean saturate,
+			       struct ureg src0,
+			       struct ureg src1,
+			       struct ureg src2 )
+{
+   emit_op(p, op, dest, mask, saturate, src0, src1, src2);
+   
+   /* Accounting for indirection tracking:
+    */
+   if (src0.file == PROGRAM_TEMPORARY)
+      p->alu_temps |= 1 << src0.idx;
+
+   if (!is_undef(src1) && src1.file == PROGRAM_TEMPORARY)
+      p->alu_temps |= 1 << src1.idx;
+
+   if (!is_undef(src2) && src2.file == PROGRAM_TEMPORARY)
+      p->alu_temps |= 1 << src2.idx;
+
+   if (dest.file == PROGRAM_TEMPORARY)
+      p->alu_temps |= 1 << dest.idx;
+       
+   p->program->Base.NumAluInstructions++;
+   return dest;
+}
+
+static struct ureg emit_texld( struct texenv_fragment_program *p,
+			       enum prog_opcode op,
+			       struct ureg dest,
+			       GLuint destmask,
+			       GLuint tex_unit,
+			       GLuint tex_idx,
+                               GLuint tex_shadow,
+			       struct ureg coord )
+{
+   struct prog_instruction *inst = emit_op( p, op, 
+					  dest, destmask, 
+					  GL_FALSE,	/* don't saturate? */
+					  coord, 	/* arg 0? */
+					  undef,
+					  undef);
+   
+   inst->TexSrcTarget = tex_idx;
+   inst->TexSrcUnit = tex_unit;
+   inst->TexShadow = tex_shadow;
+
+   p->program->Base.NumTexInstructions++;
+
+   /* Accounting for indirection tracking:
+    */
+   reserve_temp(p, dest);
+
+#if 0
+   /* Is this a texture indirection?
+    */
+   if ((coord.file == PROGRAM_TEMPORARY &&
+	(p->temps_output & (1<<coord.idx))) ||
+       (dest.file == PROGRAM_TEMPORARY &&
+	(p->alu_temps & (1<<dest.idx)))) {
+      p->program->Base.NumTexIndirections++;
+      p->temps_output = 1<<coord.idx;
+      p->alu_temps = 0;
+      assert(0);		/* KW: texture env crossbar */
+   }
+#endif
+
+   return dest;
+}
+
+
+static struct ureg register_const4f( struct texenv_fragment_program *p, 
+				     GLfloat s0,
+				     GLfloat s1,
+				     GLfloat s2,
+				     GLfloat s3)
+{
+   GLfloat values[4];
+   GLuint idx, swizzle;
+   struct ureg r;
+   values[0] = s0;
+   values[1] = s1;
+   values[2] = s2;
+   values[3] = s3;
+   idx = _mesa_add_unnamed_constant( p->program->Base.Parameters, values, 4,
+                                     &swizzle );
+   r = make_ureg(PROGRAM_CONSTANT, idx);
+   r.swz = swizzle;
+   return r;
+}
+
+#define register_scalar_const(p, s0)    register_const4f(p, s0, s0, s0, s0)
+#define register_const1f(p, s0)         register_const4f(p, s0, 0, 0, 1)
+#define register_const2f(p, s0, s1)     register_const4f(p, s0, s1, 0, 1)
+#define register_const3f(p, s0, s1, s2) register_const4f(p, s0, s1, s2, 1)
+
+
+static struct ureg get_one( struct texenv_fragment_program *p )
+{
+   if (is_undef(p->one)) 
+      p->one = register_scalar_const(p, 1.0);
+   return p->one;
+}
+
+static struct ureg get_half( struct texenv_fragment_program *p )
+{
+   if (is_undef(p->half)) 
+      p->half = register_scalar_const(p, 0.5);
+   return p->half;
+}
+
+static struct ureg get_zero( struct texenv_fragment_program *p )
+{
+   if (is_undef(p->zero)) 
+      p->zero = register_scalar_const(p, 0.0);
+   return p->zero;
+}
+
+
+static void program_error( struct texenv_fragment_program *p, const char *msg )
+{
+   _mesa_problem(NULL, "%s", msg);
+   p->error = 1;
+}
+
+static struct ureg get_source( struct texenv_fragment_program *p, 
+			       GLuint src, GLuint unit )
+{
+   switch (src) {
+   case SRC_TEXTURE: 
+      assert(!is_undef(p->src_texture[unit]));
+      return p->src_texture[unit];
+
+   case SRC_TEXTURE0:
+   case SRC_TEXTURE1:
+   case SRC_TEXTURE2:
+   case SRC_TEXTURE3:
+   case SRC_TEXTURE4:
+   case SRC_TEXTURE5:
+   case SRC_TEXTURE6:
+   case SRC_TEXTURE7: 
+      assert(!is_undef(p->src_texture[src - SRC_TEXTURE0]));
+      return p->src_texture[src - SRC_TEXTURE0];
+
+   case SRC_CONSTANT:
+      return register_param2(p, STATE_TEXENV_COLOR, unit);
+
+   case SRC_PRIMARY_COLOR:
+      return register_input(p, FRAG_ATTRIB_COL0);
+
+   case SRC_ZERO:
+      return get_zero(p);
+
+   case SRC_PREVIOUS:
+      if (is_undef(p->src_previous))
+	 return register_input(p, FRAG_ATTRIB_COL0);
+      else
+	 return p->src_previous;
+
+   default:
+      assert(0);
+      return undef;
+   }
+}
+
+static struct ureg emit_combine_source( struct texenv_fragment_program *p, 
+					GLuint mask,
+					GLuint unit,
+					GLuint source, 
+					GLuint operand )
+{
+   struct ureg arg, src, one;
+
+   src = get_source(p, source, unit);
+
+   switch (operand) {
+   case OPR_ONE_MINUS_SRC_COLOR: 
+      /* Get unused tmp,
+       * Emit tmp = 1.0 - arg.xyzw
+       */
+      arg = get_temp( p );
+      one = get_one( p );
+      return emit_arith( p, OPCODE_SUB, arg, mask, 0, one, src, undef);
+
+   case OPR_SRC_ALPHA: 
+      if (mask == WRITEMASK_W)
+	 return src;
+      else
+	 return swizzle1( src, SWIZZLE_W );
+   case OPR_ONE_MINUS_SRC_ALPHA: 
+      /* Get unused tmp,
+       * Emit tmp = 1.0 - arg.wwww
+       */
+      arg = get_temp(p);
+      one = get_one(p);
+      return emit_arith(p, OPCODE_SUB, arg, mask, 0,
+			one, swizzle1(src, SWIZZLE_W), undef);
+   case OPR_ZERO:
+      return get_zero(p);
+   case OPR_ONE:
+      return get_one(p);
+   case OPR_SRC_COLOR: 
+      return src;
+   default:
+      assert(0);
+      return src;
+   }
+}
+
+/**
+ * Check if the RGB and Alpha sources and operands match for the given
+ * texture unit's combinder state.  When the RGB and A sources and
+ * operands match, we can emit fewer instructions.
+ */
+static GLboolean args_match( const struct state_key *key, GLuint unit )
+{
+   GLuint i, numArgs = key->unit[unit].NumArgsRGB;
+
+   for (i = 0; i < numArgs; i++) {
+      if (key->unit[unit].OptA[i].Source != key->unit[unit].OptRGB[i].Source) 
+	 return GL_FALSE;
+
+      switch (key->unit[unit].OptA[i].Operand) {
+      case OPR_SRC_ALPHA: 
+	 switch (key->unit[unit].OptRGB[i].Operand) {
+	 case OPR_SRC_COLOR: 
+	 case OPR_SRC_ALPHA: 
+	    break;
+	 default:
+	    return GL_FALSE;
+	 }
+	 break;
+      case OPR_ONE_MINUS_SRC_ALPHA: 
+	 switch (key->unit[unit].OptRGB[i].Operand) {
+	 case OPR_ONE_MINUS_SRC_COLOR: 
+	 case OPR_ONE_MINUS_SRC_ALPHA: 
+	    break;
+	 default:
+	    return GL_FALSE;
+	 }
+	 break;
+      default: 
+	 return GL_FALSE;	/* impossible */
+      }
+   }
+
+   return GL_TRUE;
+}
+
+static struct ureg emit_combine( struct texenv_fragment_program *p,
+				 struct ureg dest,
+				 GLuint mask,
+				 GLboolean saturate,
+				 GLuint unit,
+				 GLuint nr,
+				 GLuint mode,
+				 const struct mode_opt *opt)
+{
+   struct ureg src[MAX_COMBINER_TERMS];
+   struct ureg tmp, half;
+   GLuint i;
+
+   assert(nr <= MAX_COMBINER_TERMS);
+
+   for (i = 0; i < nr; i++)
+      src[i] = emit_combine_source( p, mask, unit, opt[i].Source, opt[i].Operand );
+
+   switch (mode) {
+   case MODE_REPLACE: 
+      if (mask == WRITEMASK_XYZW && !saturate)
+	 return src[0];
+      else
+	 return emit_arith( p, OPCODE_MOV, dest, mask, saturate, src[0], undef, undef );
+   case MODE_MODULATE: 
+      return emit_arith( p, OPCODE_MUL, dest, mask, saturate,
+			 src[0], src[1], undef );
+   case MODE_ADD: 
+      return emit_arith( p, OPCODE_ADD, dest, mask, saturate, 
+			 src[0], src[1], undef );
+   case MODE_ADD_SIGNED:
+      /* tmp = arg0 + arg1
+       * result = tmp - .5
+       */
+      half = get_half(p);
+      tmp = get_temp( p );
+      emit_arith( p, OPCODE_ADD, tmp, mask, 0, src[0], src[1], undef );
+      emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp, half, undef );
+      return dest;
+   case MODE_INTERPOLATE: 
+      /* Arg0 * (Arg2) + Arg1 * (1-Arg2) -- note arguments are reordered:
+       */
+      return emit_arith( p, OPCODE_LRP, dest, mask, saturate, src[2], src[0], src[1] );
+
+   case MODE_SUBTRACT: 
+      return emit_arith( p, OPCODE_SUB, dest, mask, saturate, src[0], src[1], undef );
+
+   case MODE_DOT3_RGBA:
+   case MODE_DOT3_RGBA_EXT: 
+   case MODE_DOT3_RGB_EXT:
+   case MODE_DOT3_RGB: {
+      struct ureg tmp0 = get_temp( p );
+      struct ureg tmp1 = get_temp( p );
+      struct ureg neg1 = register_scalar_const(p, -1);
+      struct ureg two  = register_scalar_const(p, 2);
+
+      /* tmp0 = 2*src0 - 1
+       * tmp1 = 2*src1 - 1
+       *
+       * dst = tmp0 dot3 tmp1 
+       */
+      emit_arith( p, OPCODE_MAD, tmp0, WRITEMASK_XYZW, 0, 
+		  two, src[0], neg1);
+
+      if (memcmp(&src[0], &src[1], sizeof(struct ureg)) == 0)
+	 tmp1 = tmp0;
+      else
+	 emit_arith( p, OPCODE_MAD, tmp1, WRITEMASK_XYZW, 0, 
+		     two, src[1], neg1);
+      emit_arith( p, OPCODE_DP3, dest, mask, saturate, tmp0, tmp1, undef);
+      return dest;
+   }
+   case MODE_MODULATE_ADD_ATI:
+      /* Arg0 * Arg2 + Arg1 */
+      return emit_arith( p, OPCODE_MAD, dest, mask, saturate,
+			 src[0], src[2], src[1] );
+   case MODE_MODULATE_SIGNED_ADD_ATI: {
+      /* Arg0 * Arg2 + Arg1 - 0.5 */
+      struct ureg tmp0 = get_temp(p);
+      half = get_half(p);
+      emit_arith( p, OPCODE_MAD, tmp0, mask, 0, src[0], src[2], src[1] );
+      emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp0, half, undef );
+      return dest;
+   }
+   case MODE_MODULATE_SUBTRACT_ATI:
+      /* Arg0 * Arg2 - Arg1 */
+      emit_arith( p, OPCODE_MAD, dest, mask, 0, src[0], src[2], negate(src[1]) );
+      return dest;
+   case MODE_ADD_PRODUCTS:
+      /* Arg0 * Arg1 + Arg2 * Arg3 */
+      {
+         struct ureg tmp0 = get_temp(p);
+         emit_arith( p, OPCODE_MUL, tmp0, mask, 0, src[0], src[1], undef );
+         emit_arith( p, OPCODE_MAD, dest, mask, saturate, src[2], src[3], tmp0 );
+      }
+      return dest;
+   case MODE_ADD_PRODUCTS_SIGNED:
+      /* Arg0 * Arg1 + Arg2 * Arg3 - 0.5 */
+      {
+         struct ureg tmp0 = get_temp(p);
+         half = get_half(p);
+         emit_arith( p, OPCODE_MUL, tmp0, mask, 0, src[0], src[1], undef );
+         emit_arith( p, OPCODE_MAD, tmp0, mask, 0, src[2], src[3], tmp0 );
+         emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp0, half, undef );
+      }
+      return dest;
+   case MODE_BUMP_ENVMAP_ATI:
+      /* special - not handled here */
+      assert(0);
+      return src[0];
+   default: 
+      assert(0);
+      return src[0];
+   }
+}
+
+
+/**
+ * Generate instructions for one texture unit's env/combiner mode.
+ */
+static struct ureg
+emit_texenv(struct texenv_fragment_program *p, GLuint unit)
+{
+   const struct state_key *key = p->state;
+   GLboolean rgb_saturate, alpha_saturate;
+   GLuint rgb_shift, alpha_shift;
+   struct ureg out, dest;
+
+   if (!key->unit[unit].enabled) {
+      return get_source(p, SRC_PREVIOUS, 0);
+   }
+   if (key->unit[unit].ModeRGB == MODE_BUMP_ENVMAP_ATI) {
+      /* this isn't really a env stage delivering a color and handled elsewhere */
+      return get_source(p, SRC_PREVIOUS, 0);
+   }
+   
+   switch (key->unit[unit].ModeRGB) {
+   case MODE_DOT3_RGB_EXT:
+      alpha_shift = key->unit[unit].ScaleShiftA;
+      rgb_shift = 0;
+      break;
+   case MODE_DOT3_RGBA_EXT:
+      alpha_shift = 0;
+      rgb_shift = 0;
+      break;
+   default:
+      rgb_shift = key->unit[unit].ScaleShiftRGB;
+      alpha_shift = key->unit[unit].ScaleShiftA;
+      break;
+   }
+   
+   /* If we'll do rgb/alpha shifting don't saturate in emit_combine().
+    * We don't want to clamp twice.
+    */
+   if (rgb_shift)
+      rgb_saturate = GL_FALSE;  /* saturate after rgb shift */
+   else if (need_saturate(key->unit[unit].ModeRGB))
+      rgb_saturate = GL_TRUE;
+   else
+      rgb_saturate = GL_FALSE;
+
+   if (alpha_shift)
+      alpha_saturate = GL_FALSE;  /* saturate after alpha shift */
+   else if (need_saturate(key->unit[unit].ModeA))
+      alpha_saturate = GL_TRUE;
+   else
+      alpha_saturate = GL_FALSE;
+
+   /* If this is the very last calculation (and various other conditions
+    * are met), emit directly to the color output register.  Otherwise,
+    * emit to a temporary register.
+    */
+   if (key->separate_specular ||
+       unit != p->last_tex_stage ||
+       alpha_shift ||
+       key->num_draw_buffers != 1 ||
+       rgb_shift)
+      dest = get_temp( p );
+   else
+      dest = make_ureg(PROGRAM_OUTPUT, FRAG_RESULT_COLOR);
+
+   /* Emit the RGB and A combine ops
+    */
+   if (key->unit[unit].ModeRGB == key->unit[unit].ModeA &&
+       args_match(key, unit)) {
+      out = emit_combine( p, dest, WRITEMASK_XYZW, rgb_saturate,
+			  unit,
+			  key->unit[unit].NumArgsRGB,
+			  key->unit[unit].ModeRGB,
+			  key->unit[unit].OptRGB);
+   }
+   else if (key->unit[unit].ModeRGB == MODE_DOT3_RGBA_EXT ||
+	    key->unit[unit].ModeRGB == MODE_DOT3_RGBA) {
+      out = emit_combine( p, dest, WRITEMASK_XYZW, rgb_saturate,
+			  unit,
+			  key->unit[unit].NumArgsRGB,
+			  key->unit[unit].ModeRGB,
+			  key->unit[unit].OptRGB);
+   }
+   else {
+      /* Need to do something to stop from re-emitting identical
+       * argument calculations here:
+       */
+      out = emit_combine( p, dest, WRITEMASK_XYZ, rgb_saturate,
+			  unit,
+			  key->unit[unit].NumArgsRGB,
+			  key->unit[unit].ModeRGB,
+			  key->unit[unit].OptRGB);
+      out = emit_combine( p, dest, WRITEMASK_W, alpha_saturate,
+			  unit,
+			  key->unit[unit].NumArgsA,
+			  key->unit[unit].ModeA,
+			  key->unit[unit].OptA);
+   }
+
+   /* Deal with the final shift:
+    */
+   if (alpha_shift || rgb_shift) {
+      struct ureg shift;
+      GLboolean saturate = GL_TRUE;  /* always saturate at this point */
+
+      if (rgb_shift == alpha_shift) {
+	 shift = register_scalar_const(p, (GLfloat)(1<<rgb_shift));
+      }
+      else {
+	 shift = register_const4f(p, 
+				  (GLfloat)(1<<rgb_shift),
+				  (GLfloat)(1<<rgb_shift),
+				  (GLfloat)(1<<rgb_shift),
+				  (GLfloat)(1<<alpha_shift));
+      }
+      return emit_arith( p, OPCODE_MUL, dest, WRITEMASK_XYZW, 
+			 saturate, out, shift, undef );
+   }
+   else
+      return out;
+}
+
+
+/**
+ * Generate instruction for getting a texture source term.
+ */
+static void load_texture( struct texenv_fragment_program *p, GLuint unit )
+{
+   if (is_undef(p->src_texture[unit])) {
+      const GLuint texTarget = p->state->unit[unit].source_index;
+      struct ureg texcoord;
+      struct ureg tmp = get_tex_temp( p );
+
+      if (is_undef(p->texcoord_tex[unit])) {
+         texcoord = register_input(p, FRAG_ATTRIB_TEX0+unit);
+      }
+      else {
+         /* might want to reuse this reg for tex output actually */
+         texcoord = p->texcoord_tex[unit];
+      }
+
+      /* TODO: Use D0_MASK_XY where possible.
+       */
+      if (p->state->unit[unit].enabled) {
+         GLboolean shadow = GL_FALSE;
+
+	 if (p->state->unit[unit].shadow) {
+	    p->program->Base.ShadowSamplers |= 1 << unit;
+            shadow = GL_TRUE;
+         }
+
+	 p->src_texture[unit] = emit_texld( p, OPCODE_TXP,
+					    tmp, WRITEMASK_XYZW, 
+					    unit, texTarget, shadow,
+                                            texcoord );
+
+         p->program->Base.SamplersUsed |= (1 << unit);
+         /* This identity mapping should already be in place
+          * (see _mesa_init_program_struct()) but let's be safe.
+          */
+         p->program->Base.SamplerUnits[unit] = unit;
+      }
+      else
+	 p->src_texture[unit] = get_zero(p);
+
+      if (p->state->unit[unit].texture_cyl_wrap) {
+         /* set flag which is checked by Mesa->Gallium program translation */
+         p->program->Base.InputFlags[0] |= PROG_PARAM_BIT_CYL_WRAP;
+      }
+
+   }
+}
+
+static GLboolean load_texenv_source( struct texenv_fragment_program *p, 
+				     GLuint src, GLuint unit )
+{
+   switch (src) {
+   case SRC_TEXTURE:
+      load_texture(p, unit);
+      break;
+
+   case SRC_TEXTURE0:
+   case SRC_TEXTURE1:
+   case SRC_TEXTURE2:
+   case SRC_TEXTURE3:
+   case SRC_TEXTURE4:
+   case SRC_TEXTURE5:
+   case SRC_TEXTURE6:
+   case SRC_TEXTURE7:       
+      load_texture(p, src - SRC_TEXTURE0);
+      break;
+      
+   default:
+      /* not a texture src - do nothing */
+      break;
+   }
+ 
+   return GL_TRUE;
+}
+
+
+/**
+ * Generate instructions for loading all texture source terms.
+ */
+static GLboolean
+load_texunit_sources( struct texenv_fragment_program *p, GLuint unit )
+{
+   const struct state_key *key = p->state;
+   GLuint i;
+
+   for (i = 0; i < key->unit[unit].NumArgsRGB; i++) {
+      load_texenv_source( p, key->unit[unit].OptRGB[i].Source, unit );
+   }
+
+   for (i = 0; i < key->unit[unit].NumArgsA; i++) {
+      load_texenv_source( p, key->unit[unit].OptA[i].Source, unit );
+   }
+
+   return GL_TRUE;
+}
+
+/**
+ * Generate instructions for loading bump map textures.
+ */
+static GLboolean
+load_texunit_bumpmap( struct texenv_fragment_program *p, GLuint unit )
+{
+   const struct state_key *key = p->state;
+   GLuint bumpedUnitNr = key->unit[unit].OptRGB[1].Source - SRC_TEXTURE0;
+   struct ureg texcDst, bumpMapRes;
+   struct ureg constdudvcolor = register_const4f(p, 0.0, 0.0, 0.0, 1.0);
+   struct ureg texcSrc = register_input(p, FRAG_ATTRIB_TEX0 + bumpedUnitNr);
+   struct ureg rotMat0 = register_param3( p, STATE_INTERNAL, STATE_ROT_MATRIX_0, unit );
+   struct ureg rotMat1 = register_param3( p, STATE_INTERNAL, STATE_ROT_MATRIX_1, unit );
+
+   load_texenv_source( p, unit + SRC_TEXTURE0, unit );
+
+   bumpMapRes = get_source(p, key->unit[unit].OptRGB[0].Source, unit);
+   texcDst = get_tex_temp( p );
+   p->texcoord_tex[bumpedUnitNr] = texcDst;
+
+   /* Apply rot matrix and add coords to be available in next phase.
+    * dest = (Arg0.xxxx * rotMat0 + Arg1) + (Arg0.yyyy * rotMat1)
+    * note only 2 coords are affected the rest are left unchanged (mul by 0)
+    */
+   emit_arith( p, OPCODE_MAD, texcDst, WRITEMASK_XYZW, 0,
+               swizzle1(bumpMapRes, SWIZZLE_X), rotMat0, texcSrc );
+   emit_arith( p, OPCODE_MAD, texcDst, WRITEMASK_XYZW, 0,
+               swizzle1(bumpMapRes, SWIZZLE_Y), rotMat1, texcDst );
+
+   /* Move 0,0,0,1 into bumpmap src if someone (crossbar) is foolish
+    * enough to access this later, should optimize away.
+    */
+   emit_arith( p, OPCODE_MOV, bumpMapRes, WRITEMASK_XYZW, 0,
+               constdudvcolor, undef, undef );
+
+   return GL_TRUE;
+}
+
+/**
+ * Generate a new fragment program which implements the context's
+ * current texture env/combine mode.
+ */
+static void
+create_new_program(struct gl_context *ctx, struct state_key *key,
+                   struct gl_fragment_program *program)
+{
+   struct prog_instruction instBuffer[MAX_INSTRUCTIONS];
+   struct texenv_fragment_program p;
+   GLuint unit;
+   struct ureg cf, out;
+   int i;
+
+   memset(&p, 0, sizeof(p));
+   p.state = key;
+   p.program = program;
+
+   /* During code generation, use locally-allocated instruction buffer,
+    * then alloc dynamic storage below.
+    */
+   p.program->Base.Instructions = instBuffer;
+   p.program->Base.Target = GL_FRAGMENT_PROGRAM_ARB;
+   p.program->Base.String = NULL;
+   p.program->Base.NumTexIndirections = 1; /* is this right? */
+   p.program->Base.NumTexInstructions = 0;
+   p.program->Base.NumAluInstructions = 0;
+   p.program->Base.NumInstructions = 0;
+   p.program->Base.NumTemporaries = 0;
+   p.program->Base.NumParameters = 0;
+   p.program->Base.NumAttributes = 0;
+   p.program->Base.NumAddressRegs = 0;
+   p.program->Base.Parameters = _mesa_new_parameter_list();
+   p.program->Base.InputsRead = 0x0;
+
+   if (key->num_draw_buffers == 1)
+      p.program->Base.OutputsWritten = 1 << FRAG_RESULT_COLOR;
+   else {
+      for (i = 0; i < key->num_draw_buffers; i++)
+	 p.program->Base.OutputsWritten |= (1 << (FRAG_RESULT_DATA0 + i));
+   }
+
+   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
+      p.src_texture[unit] = undef;
+      p.texcoord_tex[unit] = undef;
+   }
+
+   p.src_previous = undef;
+   p.half = undef;
+   p.zero = undef;
+   p.one = undef;
+
+   p.last_tex_stage = 0;
+   release_temps(ctx, &p);
+
+   if (key->enabled_units && key->num_draw_buffers) {
+      GLboolean needbumpstage = GL_FALSE;
+
+      /* Zeroth pass - bump map textures first */
+      for (unit = 0; unit < key->nr_enabled_units; unit++)
+	 if (key->unit[unit].enabled &&
+             key->unit[unit].ModeRGB == MODE_BUMP_ENVMAP_ATI) {
+	    needbumpstage = GL_TRUE;
+	    load_texunit_bumpmap( &p, unit );
+	 }
+      if (needbumpstage)
+	 p.program->Base.NumTexIndirections++;
+
+      /* First pass - to support texture_env_crossbar, first identify
+       * all referenced texture sources and emit texld instructions
+       * for each:
+       */
+      for (unit = 0; unit < key->nr_enabled_units; unit++)
+	 if (key->unit[unit].enabled) {
+	    load_texunit_sources( &p, unit );
+	    p.last_tex_stage = unit;
+	 }
+
+      /* Second pass - emit combine instructions to build final color:
+       */
+      for (unit = 0; unit < key->nr_enabled_units; unit++)
+	 if (key->unit[unit].enabled) {
+	    p.src_previous = emit_texenv( &p, unit );
+            reserve_temp(&p, p.src_previous); /* don't re-use this temp reg */
+	    release_temps(ctx, &p);	/* release all temps */
+	 }
+   }
+
+   cf = get_source( &p, SRC_PREVIOUS, 0 );
+
+   for (i = 0; i < key->num_draw_buffers; i++) {
+      if (key->num_draw_buffers == 1)
+	 out = make_ureg( PROGRAM_OUTPUT, FRAG_RESULT_COLOR );
+      else {
+	 out = make_ureg( PROGRAM_OUTPUT, FRAG_RESULT_DATA0 + i );
+      }
+
+      if (key->separate_specular) {
+	 /* Emit specular add.
+	  */
+	 struct ureg s = register_input(&p, FRAG_ATTRIB_COL1);
+	 emit_arith( &p, OPCODE_ADD, out, WRITEMASK_XYZ, 0, cf, s, undef );
+	 emit_arith( &p, OPCODE_MOV, out, WRITEMASK_W, 0, cf, undef, undef );
+      }
+      else if (memcmp(&cf, &out, sizeof(cf)) != 0) {
+	 /* Will wind up in here if no texture enabled or a couple of
+	  * other scenarios (GL_REPLACE for instance).
+	  */
+	 emit_arith( &p, OPCODE_MOV, out, WRITEMASK_XYZW, 0, cf, undef, undef );
+      }
+   }
+   /* Finish up:
+    */
+   emit_arith( &p, OPCODE_END, undef, WRITEMASK_XYZW, 0, undef, undef, undef);
+
+   if (key->fog_enabled) {
+      /* Pull fog mode from struct gl_context, the value in the state key is
+       * a reduced value and not what is expected in FogOption
+       */
+      p.program->FogOption = ctx->Fog.Mode;
+      p.program->Base.InputsRead |= FRAG_BIT_FOGC;
+   }
+   else {
+      p.program->FogOption = GL_NONE;
+   }
+
+   if (p.program->Base.NumTexIndirections > ctx->Const.FragmentProgram.MaxTexIndirections) 
+      program_error(&p, "Exceeded max nr indirect texture lookups");
+
+   if (p.program->Base.NumTexInstructions > ctx->Const.FragmentProgram.MaxTexInstructions)
+      program_error(&p, "Exceeded max TEX instructions");
+
+   if (p.program->Base.NumAluInstructions > ctx->Const.FragmentProgram.MaxAluInstructions)
+      program_error(&p, "Exceeded max ALU instructions");
+
+   ASSERT(p.program->Base.NumInstructions <= MAX_INSTRUCTIONS);
+
+   /* Allocate final instruction array */
+   p.program->Base.Instructions
+      = _mesa_alloc_instructions(p.program->Base.NumInstructions);
+   if (!p.program->Base.Instructions) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY,
+                  "generating tex env program");
+      return;
+   }
+   _mesa_copy_instructions(p.program->Base.Instructions, instBuffer,
+                           p.program->Base.NumInstructions);
+
+   if (key->num_draw_buffers && p.program->FogOption) {
+      _mesa_append_fog_code(ctx, p.program, GL_FALSE);
+      p.program->FogOption = GL_NONE;
+   }
+
+
+   /* Notify driver the fragment program has (actually) changed.
+    */
+   if (ctx->Driver.ProgramStringNotify) {
+      GLboolean ok = ctx->Driver.ProgramStringNotify(ctx,
+                                                     GL_FRAGMENT_PROGRAM_ARB, 
+                                                     &p.program->Base);
+      /* Driver should be able to handle any texenv programs as long as
+       * the driver correctly reported max number of texture units correctly,
+       * etc.
+       */
+      ASSERT(ok);
+      (void) ok; /* silence unused var warning */
+   }
+
+   if (DISASSEM) {
+      _mesa_print_program(&p.program->Base);
+      printf("\n");
+   }
+}
+
+extern "C" {
+
+/**
+ * Return a fragment program which implements the current
+ * fixed-function texture, fog and color-sum operations.
+ */
+struct gl_fragment_program *
+_mesa_get_fixed_func_fragment_program(struct gl_context *ctx)
+{
+   struct gl_fragment_program *prog;
+   struct state_key key;
+   GLuint keySize;
+	
+   keySize = make_state_key(ctx, &key);
+      
+   prog = (struct gl_fragment_program *)
+      _mesa_search_program_cache(ctx->FragmentProgram.Cache,
+                                 &key, keySize);
+
+   if (!prog) {
+      prog = (struct gl_fragment_program *) 
+         ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
+
+      create_new_program(ctx, &key, prog);
+
+      _mesa_program_cache_insert(ctx, ctx->FragmentProgram.Cache,
+                                 &key, keySize, &prog->Base);
+   }
+
+   return prog;
+}
+
+}
diff --git a/mesalib/src/mesa/main/fog.c b/mesalib/src/mesa/main/fog.c
index 70603576c..88aa31a7f 100644
--- a/mesalib/src/mesa/main/fog.c
+++ b/mesalib/src/mesa/main/fog.c
@@ -1,199 +1,204 @@
-/*

- * Mesa 3-D graphics library

- * Version:  5.1

- *

- * Copyright (C) 1999-2003  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.

- */

-

-

-#include "glheader.h"

-#include "colormac.h"

-#include "context.h"

-#include "fog.h"

-#include "macros.h"

-#include "mtypes.h"

-

-

-

-void GLAPIENTRY

-_mesa_Fogf(GLenum pname, GLfloat param)

-{

-   GLfloat fparam[4];

-   fparam[0] = param;

-   fparam[1] = fparam[2] = fparam[3] = 0.0F;

-   _mesa_Fogfv(pname, fparam);

-}

-

-

-void GLAPIENTRY

-_mesa_Fogi(GLenum pname, GLint param )

-{

-   GLfloat fparam[4];

-   fparam[0] = (GLfloat) param;

-   fparam[1] = fparam[2] = fparam[3] = 0.0F;

-   _mesa_Fogfv(pname, fparam);

-}

-

-

-void GLAPIENTRY

-_mesa_Fogiv(GLenum pname, const GLint *params )

-{

-   GLfloat p[4];

-   switch (pname) {

-      case GL_FOG_MODE:

-      case GL_FOG_DENSITY:

-      case GL_FOG_START:

-      case GL_FOG_END:

-      case GL_FOG_INDEX:

-      case GL_FOG_COORDINATE_SOURCE_EXT:

-	 p[0] = (GLfloat) *params;

-	 break;

-      case GL_FOG_COLOR:

-	 p[0] = INT_TO_FLOAT( params[0] );

-	 p[1] = INT_TO_FLOAT( params[1] );

-	 p[2] = INT_TO_FLOAT( params[2] );

-	 p[3] = INT_TO_FLOAT( params[3] );

-	 break;

-      default:

-         /* Error will be caught later in _mesa_Fogfv */

-         ASSIGN_4V(p, 0.0F, 0.0F, 0.0F, 0.0F);

-   }

-   _mesa_Fogfv(pname, p);

-}

-

-

-/**

- * Update the gl_fog_attrib::_Scale field.

- */

-static void

-update_fog_scale(struct gl_context *ctx)

-{

-   if (ctx->Fog.End == ctx->Fog.Start)

-      ctx->Fog._Scale = 1.0f;

-   else

-      ctx->Fog._Scale = 1.0f / (ctx->Fog.End - ctx->Fog.Start);

-}

-

-

-void GLAPIENTRY

-_mesa_Fogfv( GLenum pname, const GLfloat *params )

-{

-   GET_CURRENT_CONTEXT(ctx);

-   GLenum m;

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   switch (pname) {

-      case GL_FOG_MODE:

-         m = (GLenum) (GLint) *params;

-	 switch (m) {

-	 case GL_LINEAR:

-	 case GL_EXP:

-	 case GL_EXP2:

-	    break;

-	 default:

-	    _mesa_error( ctx, GL_INVALID_ENUM, "glFog" );

-            return;

-	 }

-	 if (ctx->Fog.Mode == m)

-	    return;

-	 FLUSH_VERTICES(ctx, _NEW_FOG);

-	 ctx->Fog.Mode = m;

-	 break;

-      case GL_FOG_DENSITY:

-	 if (*params<0.0) {

-	    _mesa_error( ctx, GL_INVALID_VALUE, "glFog" );

-            return;

-	 }

-	 if (ctx->Fog.Density == *params)

-	    return;

-	 FLUSH_VERTICES(ctx, _NEW_FOG);

-	 ctx->Fog.Density = *params;

-	 break;

-      case GL_FOG_START:

-         if (ctx->Fog.Start == *params)

-            return;

-         FLUSH_VERTICES(ctx, _NEW_FOG);

-         ctx->Fog.Start = *params;

-         update_fog_scale(ctx);

-         break;

-      case GL_FOG_END:

-         if (ctx->Fog.End == *params)

-            return;

-         FLUSH_VERTICES(ctx, _NEW_FOG);

-         ctx->Fog.End = *params;

-         update_fog_scale(ctx);

-         break;

-      case GL_FOG_INDEX:

- 	 if (ctx->Fog.Index == *params)

-	    return;

-	 FLUSH_VERTICES(ctx, _NEW_FOG);

- 	 ctx->Fog.Index = *params;

-	 break;

-      case GL_FOG_COLOR:

-	 if (TEST_EQ_4V(ctx->Fog.Color, params))

-	    return;

-	 FLUSH_VERTICES(ctx, _NEW_FOG);

-	 ctx->Fog.Color[0] = CLAMP(params[0], 0.0F, 1.0F);

-	 ctx->Fog.Color[1] = CLAMP(params[1], 0.0F, 1.0F);

-	 ctx->Fog.Color[2] = CLAMP(params[2], 0.0F, 1.0F);

-	 ctx->Fog.Color[3] = CLAMP(params[3], 0.0F, 1.0F);

-         break;

-      case GL_FOG_COORDINATE_SOURCE_EXT: {

-	 GLenum p = (GLenum) (GLint) *params;

-         if (!ctx->Extensions.EXT_fog_coord ||

-             (p != GL_FOG_COORDINATE_EXT && p != GL_FRAGMENT_DEPTH_EXT)) {

-	    _mesa_error(ctx, GL_INVALID_ENUM, "glFog");

-	    return;

-	 }

-	 if (ctx->Fog.FogCoordinateSource == p)

-	    return;

-	 FLUSH_VERTICES(ctx, _NEW_FOG);

-	 ctx->Fog.FogCoordinateSource = p;

-	 break;

-      }

-      default:

-         _mesa_error( ctx, GL_INVALID_ENUM, "glFog" );

-         return;

-   }

-

-   if (ctx->Driver.Fogfv) {

-      (*ctx->Driver.Fogfv)( ctx, pname, params );

-   }

-}

-

-

-/**********************************************************************/

-/*****                      Initialization                        *****/

-/**********************************************************************/

-

-void _mesa_init_fog( struct gl_context * ctx )

-{

-   /* Fog group */

-   ctx->Fog.Enabled = GL_FALSE;

-   ctx->Fog.Mode = GL_EXP;

-   ASSIGN_4V( ctx->Fog.Color, 0.0, 0.0, 0.0, 0.0 );

-   ctx->Fog.Index = 0.0;

-   ctx->Fog.Density = 1.0;

-   ctx->Fog.Start = 0.0;

-   ctx->Fog.End = 1.0;

-   ctx->Fog.ColorSumEnabled = GL_FALSE;

-   ctx->Fog.FogCoordinateSource = GL_FRAGMENT_DEPTH_EXT;

-   ctx->Fog._Scale = 1.0f;

-}

+/*
+ * Mesa 3-D graphics library
+ * Version:  5.1
+ *
+ * Copyright (C) 1999-2003  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.
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "context.h"
+#include "fog.h"
+#include "macros.h"
+#include "mtypes.h"
+
+
+
+void GLAPIENTRY
+_mesa_Fogf(GLenum pname, GLfloat param)
+{
+   GLfloat fparam[4];
+   fparam[0] = param;
+   fparam[1] = fparam[2] = fparam[3] = 0.0F;
+   _mesa_Fogfv(pname, fparam);
+}
+
+
+void GLAPIENTRY
+_mesa_Fogi(GLenum pname, GLint param )
+{
+   GLfloat fparam[4];
+   fparam[0] = (GLfloat) param;
+   fparam[1] = fparam[2] = fparam[3] = 0.0F;
+   _mesa_Fogfv(pname, fparam);
+}
+
+
+void GLAPIENTRY
+_mesa_Fogiv(GLenum pname, const GLint *params )
+{
+   GLfloat p[4];
+   switch (pname) {
+      case GL_FOG_MODE:
+      case GL_FOG_DENSITY:
+      case GL_FOG_START:
+      case GL_FOG_END:
+      case GL_FOG_INDEX:
+      case GL_FOG_COORDINATE_SOURCE_EXT:
+	 p[0] = (GLfloat) *params;
+	 break;
+      case GL_FOG_COLOR:
+	 p[0] = INT_TO_FLOAT( params[0] );
+	 p[1] = INT_TO_FLOAT( params[1] );
+	 p[2] = INT_TO_FLOAT( params[2] );
+	 p[3] = INT_TO_FLOAT( params[3] );
+	 break;
+      default:
+         /* Error will be caught later in _mesa_Fogfv */
+         ASSIGN_4V(p, 0.0F, 0.0F, 0.0F, 0.0F);
+   }
+   _mesa_Fogfv(pname, p);
+}
+
+
+/**
+ * Update the gl_fog_attrib::_Scale field.
+ */
+static void
+update_fog_scale(struct gl_context *ctx)
+{
+   if (ctx->Fog.End == ctx->Fog.Start)
+      ctx->Fog._Scale = 1.0f;
+   else
+      ctx->Fog._Scale = 1.0f / (ctx->Fog.End - ctx->Fog.Start);
+}
+
+
+void GLAPIENTRY
+_mesa_Fogfv( GLenum pname, const GLfloat *params )
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLenum m;
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   switch (pname) {
+      case GL_FOG_MODE:
+         m = (GLenum) (GLint) *params;
+	 switch (m) {
+	 case GL_LINEAR:
+	 case GL_EXP:
+	 case GL_EXP2:
+	    break;
+	 default:
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glFog" );
+            return;
+	 }
+	 if (ctx->Fog.Mode == m)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_FOG);
+	 ctx->Fog.Mode = m;
+	 break;
+      case GL_FOG_DENSITY:
+	 if (*params<0.0) {
+	    _mesa_error( ctx, GL_INVALID_VALUE, "glFog" );
+            return;
+	 }
+	 if (ctx->Fog.Density == *params)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_FOG);
+	 ctx->Fog.Density = *params;
+	 break;
+      case GL_FOG_START:
+         if (ctx->Fog.Start == *params)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_FOG);
+         ctx->Fog.Start = *params;
+         update_fog_scale(ctx);
+         break;
+      case GL_FOG_END:
+         if (ctx->Fog.End == *params)
+            return;
+         FLUSH_VERTICES(ctx, _NEW_FOG);
+         ctx->Fog.End = *params;
+         update_fog_scale(ctx);
+         break;
+      case GL_FOG_INDEX:
+ 	 if (ctx->Fog.Index == *params)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_FOG);
+ 	 ctx->Fog.Index = *params;
+	 break;
+      case GL_FOG_COLOR:
+	 if (TEST_EQ_4V(ctx->Fog.Color, params))
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_FOG);
+	 ctx->Fog.ColorUnclamped[0] = params[0];
+	 ctx->Fog.ColorUnclamped[1] = params[1];
+	 ctx->Fog.ColorUnclamped[2] = params[2];
+	 ctx->Fog.ColorUnclamped[3] = params[3];
+	 ctx->Fog.Color[0] = CLAMP(params[0], 0.0F, 1.0F);
+	 ctx->Fog.Color[1] = CLAMP(params[1], 0.0F, 1.0F);
+	 ctx->Fog.Color[2] = CLAMP(params[2], 0.0F, 1.0F);
+	 ctx->Fog.Color[3] = CLAMP(params[3], 0.0F, 1.0F);
+         break;
+      case GL_FOG_COORDINATE_SOURCE_EXT: {
+	 GLenum p = (GLenum) (GLint) *params;
+         if (!ctx->Extensions.EXT_fog_coord ||
+             (p != GL_FOG_COORDINATE_EXT && p != GL_FRAGMENT_DEPTH_EXT)) {
+	    _mesa_error(ctx, GL_INVALID_ENUM, "glFog");
+	    return;
+	 }
+	 if (ctx->Fog.FogCoordinateSource == p)
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_FOG);
+	 ctx->Fog.FogCoordinateSource = p;
+	 break;
+      }
+      default:
+         _mesa_error( ctx, GL_INVALID_ENUM, "glFog" );
+         return;
+   }
+
+   if (ctx->Driver.Fogfv) {
+      (*ctx->Driver.Fogfv)( ctx, pname, params );
+   }
+}
+
+
+/**********************************************************************/
+/*****                      Initialization                        *****/
+/**********************************************************************/
+
+void _mesa_init_fog( struct gl_context * ctx )
+{
+   /* Fog group */
+   ctx->Fog.Enabled = GL_FALSE;
+   ctx->Fog.Mode = GL_EXP;
+   ASSIGN_4V( ctx->Fog.Color, 0.0, 0.0, 0.0, 0.0 );
+   ASSIGN_4V( ctx->Fog.ColorUnclamped, 0.0, 0.0, 0.0, 0.0 );
+   ctx->Fog.Index = 0.0;
+   ctx->Fog.Density = 1.0;
+   ctx->Fog.Start = 0.0;
+   ctx->Fog.End = 1.0;
+   ctx->Fog.ColorSumEnabled = GL_FALSE;
+   ctx->Fog.FogCoordinateSource = GL_FRAGMENT_DEPTH_EXT;
+   ctx->Fog._Scale = 1.0f;
+}
diff --git a/mesalib/src/mesa/main/formats.c b/mesalib/src/mesa/main/formats.c
index db10c9b4c..e62170b71 100644
--- a/mesalib/src/mesa/main/formats.c
+++ b/mesalib/src/mesa/main/formats.c
@@ -809,8 +809,8 @@ static struct gl_format_info format_info[MESA_FORMAT_COUNT] =
       1, 1, 1                       /* BlockWidth/Height,Bytes */
    },
    {
-      MESA_FORMAT_SIGNED_RG88,
-      "MESA_FORMAT_SIGNED_RG88",
+      MESA_FORMAT_SIGNED_RG88_REV,
+      "MESA_FORMAT_SIGNED_RG88_REV",
       GL_RG,
       GL_SIGNED_NORMALIZED,
       8, 8, 0, 0,
@@ -847,8 +847,8 @@ static struct gl_format_info format_info[MESA_FORMAT_COUNT] =
 
    /* Signed 16 bits / channel */
    {
-      MESA_FORMAT_SIGNED_R_16,
-      "MESA_FORMAT_SIGNED_R_16",
+      MESA_FORMAT_SIGNED_R16,
+      "MESA_FORMAT_SIGNED_R16",
       GL_RED,
       GL_SIGNED_NORMALIZED,
       16, 0, 0, 0,
@@ -856,8 +856,8 @@ static struct gl_format_info format_info[MESA_FORMAT_COUNT] =
       1, 1, 2
    },
    {
-      MESA_FORMAT_SIGNED_RG_16,
-      "MESA_FORMAT_SIGNED_RG_16",
+      MESA_FORMAT_SIGNED_GR1616,
+      "MESA_FORMAT_SIGNED_GR1616",
       GL_RG,
       GL_SIGNED_NORMALIZED,
       16, 16, 0, 0,
@@ -963,6 +963,80 @@ static struct gl_format_info format_info[MESA_FORMAT_COUNT] =
      4, 0, 0, 0, 0,
      4, 4, 16                     /* 16 bytes per 4x4 block */
    },
+
+   /* Signed formats from EXT_texture_snorm that are not in GL3.1 */
+   {
+      MESA_FORMAT_SIGNED_A8,
+      "MESA_FORMAT_SIGNED_A8",
+      GL_ALPHA,
+      GL_SIGNED_NORMALIZED,
+      0, 0, 0, 8,
+      0, 0, 0, 0, 0,
+      1, 1, 1
+   },
+   {
+      MESA_FORMAT_SIGNED_L8,
+      "MESA_FORMAT_SIGNED_L8",
+      GL_LUMINANCE,
+      GL_SIGNED_NORMALIZED,
+      0, 0, 0, 0,
+      8, 0, 0, 0, 0,
+      1, 1, 1
+   },
+   {
+      MESA_FORMAT_SIGNED_AL88,
+      "MESA_FORMAT_SIGNED_AL88",
+      GL_LUMINANCE_ALPHA,
+      GL_SIGNED_NORMALIZED,
+      0, 0, 0, 8,
+      8, 0, 0, 0, 0,
+      1, 1, 2
+   },
+   {
+      MESA_FORMAT_SIGNED_I8,
+      "MESA_FORMAT_SIGNED_I8",
+      GL_INTENSITY,
+      GL_SIGNED_NORMALIZED,
+      0, 0, 0, 0,
+      0, 8, 0, 0, 0,
+      1, 1, 1
+   },
+   {
+      MESA_FORMAT_SIGNED_A16,
+      "MESA_FORMAT_SIGNED_A16",
+      GL_ALPHA,
+      GL_SIGNED_NORMALIZED,
+      0, 0, 0, 16,
+      0, 0, 0, 0, 0,
+      1, 1, 2
+   },
+   {
+      MESA_FORMAT_SIGNED_L16,
+      "MESA_FORMAT_SIGNED_L16",
+      GL_LUMINANCE,
+      GL_SIGNED_NORMALIZED,
+      0, 0, 0, 0,
+      16, 0, 0, 0, 0,
+      1, 1, 2
+   },
+   {
+      MESA_FORMAT_SIGNED_AL1616,
+      "MESA_FORMAT_SIGNED_AL1616",
+      GL_LUMINANCE_ALPHA,
+      GL_SIGNED_NORMALIZED,
+      0, 0, 0, 16,
+      16, 0, 0, 0, 0,
+      1, 1, 4
+   },
+   {
+      MESA_FORMAT_SIGNED_I16,
+      "MESA_FORMAT_SIGNED_I16",
+      GL_INTENSITY,
+      GL_SIGNED_NORMALIZED,
+      0, 0, 0, 0,
+      0, 16, 0, 0, 0,
+      1, 1, 2
+   }
 };
 
 
@@ -1530,10 +1604,14 @@ _mesa_format_to_type_and_comps(gl_format format,
       return;
 
    case MESA_FORMAT_SIGNED_R8:
+   case MESA_FORMAT_SIGNED_A8:
+   case MESA_FORMAT_SIGNED_L8:
+   case MESA_FORMAT_SIGNED_I8:
       *datatype = GL_BYTE;
       *comps = 1;
       return;
-   case MESA_FORMAT_SIGNED_RG88:
+   case MESA_FORMAT_SIGNED_RG88_REV:
+   case MESA_FORMAT_SIGNED_AL88:
       *datatype = GL_BYTE;
       *comps = 2;
       return;
@@ -1549,11 +1627,15 @@ _mesa_format_to_type_and_comps(gl_format format,
       *comps = 4;
       return;
 
-   case MESA_FORMAT_SIGNED_R_16:
+   case MESA_FORMAT_SIGNED_R16:
+   case MESA_FORMAT_SIGNED_A16:
+   case MESA_FORMAT_SIGNED_L16:
+   case MESA_FORMAT_SIGNED_I16:
       *datatype = GL_SHORT;
       *comps = 1;
       return;
-   case MESA_FORMAT_SIGNED_RG_16:
+   case MESA_FORMAT_SIGNED_GR1616:
+   case MESA_FORMAT_SIGNED_AL1616:
       *datatype = GL_SHORT;
       *comps = 2;
       return;
diff --git a/mesalib/src/mesa/main/formats.h b/mesalib/src/mesa/main/formats.h
index 04a18930b..e0c2acbb9 100644
--- a/mesalib/src/mesa/main/formats.h
+++ b/mesalib/src/mesa/main/formats.h
@@ -168,12 +168,12 @@ typedef enum
    /*@{*/
    MESA_FORMAT_DUDV8,             /*                     DUDU DUDU DVDV DVDV */
    MESA_FORMAT_SIGNED_R8,         /*                               RRRR RRRR */
-   MESA_FORMAT_SIGNED_RG88,       /*                     RRRR RRRR GGGG GGGG */
+   MESA_FORMAT_SIGNED_RG88_REV,   /*                     GGGG GGGG RRRR RRRR */
    MESA_FORMAT_SIGNED_RGBX8888,   /* RRRR RRRR GGGG GGGG BBBB BBBB xxxx xxxx */
    MESA_FORMAT_SIGNED_RGBA8888,   /* RRRR RRRR GGGG GGGG BBBB BBBB AAAA AAAA */
    MESA_FORMAT_SIGNED_RGBA8888_REV,/*AAAA AAAA BBBB BBBB GGGG GGGG RRRR RRRR */
-   MESA_FORMAT_SIGNED_R_16,       /* ushort[0]=R */
-   MESA_FORMAT_SIGNED_RG_16,      /* ushort[0]=R, ushort[1]=G */
+   MESA_FORMAT_SIGNED_R16,        /*                     RRRR RRRR RRRR RRRR */
+   MESA_FORMAT_SIGNED_GR1616,     /* GGGG GGGG GGGG GGGG RRRR RRRR RRRR RRRR */
    MESA_FORMAT_SIGNED_RGB_16,     /* ushort[0]=R, ushort[1]=G, ushort[2]=B */
    MESA_FORMAT_SIGNED_RGBA_16,    /* ... */
    MESA_FORMAT_RGBA_16,           /* ... */
@@ -193,6 +193,15 @@ typedef enum
    MESA_FORMAT_SIGNED_LA_LATC2,
    /*@}*/
 
+   MESA_FORMAT_SIGNED_A8,         /*                               AAAA AAAA */
+   MESA_FORMAT_SIGNED_L8,         /*                               LLLL LLLL */
+   MESA_FORMAT_SIGNED_AL88,       /*                     AAAA AAAA LLLL LLLL */
+   MESA_FORMAT_SIGNED_I8,         /*                               IIII IIII */
+   MESA_FORMAT_SIGNED_A16,        /*                     AAAA AAAA AAAA AAAA */
+   MESA_FORMAT_SIGNED_L16,        /*                     LLLL LLLL LLLL LLLL */
+   MESA_FORMAT_SIGNED_AL1616,     /* AAAA AAAA AAAA AAAA LLLL LLLL LLLL LLLL */
+   MESA_FORMAT_SIGNED_I16,        /*                     IIII IIII IIII IIII */
+
    MESA_FORMAT_COUNT
 } gl_format;
 
diff --git a/mesalib/src/mesa/main/get.c b/mesalib/src/mesa/main/get.c
index 81a2a4e7c..9090ca661 100644
--- a/mesalib/src/mesa/main/get.c
+++ b/mesalib/src/mesa/main/get.c
@@ -131,6 +131,7 @@ enum value_extra {
    EXTRA_VERSION_32,
    EXTRA_VERSION_ES2,
    EXTRA_NEW_BUFFERS, 
+   EXTRA_NEW_FRAG_CLAMP,
    EXTRA_VALID_DRAW_BUFFER,
    EXTRA_VALID_TEXTURE_UNIT,
    EXTRA_FLUSH_CURRENT,
@@ -223,6 +224,11 @@ static const int extra_new_buffers[] = {
    EXTRA_END
 };
 
+static const int extra_new_frag_clamp[] = {
+   EXTRA_NEW_FRAG_CLAMP,
+   EXTRA_END
+};
+
 static const int extra_valid_draw_buffer[] = {
    EXTRA_VALID_DRAW_BUFFER,
    EXTRA_END
@@ -374,7 +380,7 @@ static const struct value_desc values[] = {
    { GL_BLEND, CONTEXT_BIT0(Color.BlendEnabled), NO_EXTRA },
    { GL_BLEND_SRC, CONTEXT_ENUM(Color.Blend[0].SrcRGB), NO_EXTRA },
    { GL_BLUE_BITS, BUFFER_INT(Visual.blueBits), extra_new_buffers },
-   { GL_COLOR_CLEAR_VALUE, CONTEXT_FIELD(Color.ClearColor[0], TYPE_FLOATN_4), NO_EXTRA },
+   { GL_COLOR_CLEAR_VALUE, LOC_CUSTOM, TYPE_FLOATN_4, 0, extra_new_frag_clamp },
    { GL_COLOR_WRITEMASK, LOC_CUSTOM, TYPE_INT_4, 0, NO_EXTRA },
    { GL_CULL_FACE, CONTEXT_BOOL(Polygon.CullFlag), NO_EXTRA },
    { GL_CULL_FACE_MODE, CONTEXT_ENUM(Polygon.CullFaceMode), NO_EXTRA },
@@ -511,7 +517,7 @@ static const struct value_desc values[] = {
    { GL_LIGHT_MODEL_TWO_SIDE, CONTEXT_BOOL(Light.Model.TwoSide), NO_EXTRA },
    { GL_ALPHA_TEST, CONTEXT_BOOL(Color.AlphaEnabled), NO_EXTRA },
    { GL_ALPHA_TEST_FUNC, CONTEXT_ENUM(Color.AlphaFunc), NO_EXTRA },
-   { GL_ALPHA_TEST_REF, CONTEXT_FIELD(Color.AlphaRef, TYPE_FLOATN), NO_EXTRA },
+   { GL_ALPHA_TEST_REF, LOC_CUSTOM, TYPE_FLOATN, 0, extra_new_frag_clamp },
    { GL_BLEND_DST, CONTEXT_ENUM(Color.Blend[0].DstRGB), NO_EXTRA },
    { GL_CLIP_PLANE0, CONTEXT_BIT0(Transform.ClipPlanesEnabled), NO_EXTRA },
    { GL_CLIP_PLANE1, CONTEXT_BIT1(Transform.ClipPlanesEnabled), NO_EXTRA },
@@ -530,7 +536,7 @@ static const struct value_desc values[] = {
      extra_flush_current_valid_texture_unit },
    { GL_DISTANCE_ATTENUATION_EXT, CONTEXT_FLOAT3(Point.Params[0]), NO_EXTRA },
    { GL_FOG, CONTEXT_BOOL(Fog.Enabled), NO_EXTRA },
-   { GL_FOG_COLOR, CONTEXT_FIELD(Fog.Color[0], TYPE_FLOATN_4), NO_EXTRA },
+   { GL_FOG_COLOR, LOC_CUSTOM, TYPE_FLOATN_4, 0, extra_new_frag_clamp },
    { GL_FOG_DENSITY, CONTEXT_FLOAT(Fog.Density), NO_EXTRA },
    { GL_FOG_END, CONTEXT_FLOAT(Fog.End), NO_EXTRA },
    { GL_FOG_HINT, CONTEXT_ENUM(Hint.Fog), NO_EXTRA },
@@ -674,7 +680,7 @@ static const struct value_desc values[] = {
    /* GL_ARB_draw_buffers */
    { GL_MAX_DRAW_BUFFERS_ARB, CONTEXT_INT(Const.MaxDrawBuffers), NO_EXTRA },
 
-   { GL_BLEND_COLOR_EXT, CONTEXT_FIELD(Color.BlendColor[0], TYPE_FLOATN_4), NO_EXTRA },
+   { GL_BLEND_COLOR_EXT, LOC_CUSTOM, TYPE_FLOATN_4, 0, extra_new_frag_clamp },
    /* GL_ARB_fragment_program */
    { GL_MAX_TEXTURE_IMAGE_UNITS_ARB, /* == GL_MAX_TEXTURE_IMAGE_UNITS_NV */
      CONTEXT_INT(Const.MaxTextureImageUnits),
@@ -1219,6 +1225,9 @@ static const struct value_desc values[] = {
      CONTEXT_INT(Const.MaxVertexVaryingComponents),
      extra_ARB_geometry_shader4 },
 
+   /* GL_ARB_color_buffer_float */
+   { GL_RGBA_FLOAT_MODE_ARB, BUFFER_FIELD(Visual.floatMode, TYPE_BOOLEAN), 0 },
+
    /* GL_EXT_gpu_shader4 / GL 3.0 */
    { GL_MIN_PROGRAM_TEXEL_OFFSET,
      CONTEXT_INT(Const.MinProgramTexelOffset),
@@ -1633,6 +1642,30 @@ find_custom_value(struct gl_context *ctx, const struct value_desc *d, union valu
       v->value_int = ctx->Array.ArrayObj->PointSize.BufferObj->Name;
       break;
 
+   case GL_FOG_COLOR:
+      if(ctx->Color._ClampFragmentColor)
+         COPY_4FV(v->value_float_4, ctx->Fog.Color);
+      else
+         COPY_4FV(v->value_float_4, ctx->Fog.ColorUnclamped);
+      break;
+   case GL_COLOR_CLEAR_VALUE:
+      if(ctx->Color._ClampFragmentColor)
+         COPY_4FV(v->value_float_4, ctx->Color.ClearColor);
+      else
+         COPY_4FV(v->value_float_4, ctx->Color.ClearColorUnclamped);
+      break;
+   case GL_BLEND_COLOR_EXT:
+      if(ctx->Color._ClampFragmentColor)
+         COPY_4FV(v->value_float_4, ctx->Color.BlendColor);
+      else
+         COPY_4FV(v->value_float_4, ctx->Color.BlendColorUnclamped);
+      break;
+   case GL_ALPHA_TEST_REF:
+      if(ctx->Color._ClampFragmentColor)
+         v->value_float = ctx->Color.AlphaRef;
+      else
+         v->value_float = ctx->Color.AlphaRefUnclamped;
+      break;
    case GL_MAX_VERTEX_UNIFORM_VECTORS:
       v->value_int = ctx->Const.VertexProgram.MaxUniformComponents / 4;
       break;
@@ -1687,6 +1720,10 @@ check_extra(struct gl_context *ctx, const char *func, const struct value_desc *d
 	    enabled++;
 	 }
 	 break;
+      case EXTRA_NEW_FRAG_CLAMP:
+         if (ctx->NewState & (_NEW_BUFFERS | _NEW_FRAG_CLAMP))
+            _mesa_update_state(ctx);
+         break;
       case EXTRA_VERSION_ES2:
 	 if (ctx->API == API_OPENGLES2) {
 	    total++;
diff --git a/mesalib/src/mesa/main/glapidispatch.h b/mesalib/src/mesa/main/glapidispatch.h
index b29c7cb78..e733a8d76 100644
--- a/mesalib/src/mesa/main/glapidispatch.h
+++ b/mesalib/src/mesa/main/glapidispatch.h
@@ -59,7 +59,7 @@
     } while(0)
 
 /* total number of offsets below */
-#define _gloffset_COUNT 892
+#define _gloffset_COUNT 893
 
 #define _gloffset_NewList 0
 #define _gloffset_EndList 1
@@ -636,330 +636,331 @@
 #define _gloffset_GetActiveAttribARB 569
 #define _gloffset_GetAttribLocationARB 570
 #define _gloffset_DrawBuffersARB 571
-#define _gloffset_DrawArraysInstancedARB 572
-#define _gloffset_DrawElementsInstancedARB 573
-#define _gloffset_RenderbufferStorageMultisample 574
-#define _gloffset_FramebufferTextureARB 575
-#define _gloffset_FramebufferTextureFaceARB 576
-#define _gloffset_ProgramParameteriARB 577
-#define _gloffset_VertexAttribDivisorARB 578
-#define _gloffset_FlushMappedBufferRange 579
-#define _gloffset_MapBufferRange 580
-#define _gloffset_BindVertexArray 581
-#define _gloffset_GenVertexArrays 582
-#define _gloffset_CopyBufferSubData 583
-#define _gloffset_ClientWaitSync 584
-#define _gloffset_DeleteSync 585
-#define _gloffset_FenceSync 586
-#define _gloffset_GetInteger64v 587
-#define _gloffset_GetSynciv 588
-#define _gloffset_IsSync 589
-#define _gloffset_WaitSync 590
-#define _gloffset_DrawElementsBaseVertex 591
-#define _gloffset_DrawRangeElementsBaseVertex 592
-#define _gloffset_MultiDrawElementsBaseVertex 593
-#define _gloffset_BlendEquationSeparateiARB 594
-#define _gloffset_BlendEquationiARB 595
-#define _gloffset_BlendFuncSeparateiARB 596
-#define _gloffset_BlendFunciARB 597
-#define _gloffset_BindTransformFeedback 598
-#define _gloffset_DeleteTransformFeedbacks 599
-#define _gloffset_DrawTransformFeedback 600
-#define _gloffset_GenTransformFeedbacks 601
-#define _gloffset_IsTransformFeedback 602
-#define _gloffset_PauseTransformFeedback 603
-#define _gloffset_ResumeTransformFeedback 604
-#define _gloffset_ClearDepthf 605
-#define _gloffset_DepthRangef 606
-#define _gloffset_GetShaderPrecisionFormat 607
-#define _gloffset_ReleaseShaderCompiler 608
-#define _gloffset_ShaderBinary 609
-#define _gloffset_PolygonOffsetEXT 610
-#define _gloffset_GetPixelTexGenParameterfvSGIS 611
-#define _gloffset_GetPixelTexGenParameterivSGIS 612
-#define _gloffset_PixelTexGenParameterfSGIS 613
-#define _gloffset_PixelTexGenParameterfvSGIS 614
-#define _gloffset_PixelTexGenParameteriSGIS 615
-#define _gloffset_PixelTexGenParameterivSGIS 616
-#define _gloffset_SampleMaskSGIS 617
-#define _gloffset_SamplePatternSGIS 618
-#define _gloffset_ColorPointerEXT 619
-#define _gloffset_EdgeFlagPointerEXT 620
-#define _gloffset_IndexPointerEXT 621
-#define _gloffset_NormalPointerEXT 622
-#define _gloffset_TexCoordPointerEXT 623
-#define _gloffset_VertexPointerEXT 624
-#define _gloffset_PointParameterfEXT 625
-#define _gloffset_PointParameterfvEXT 626
-#define _gloffset_LockArraysEXT 627
-#define _gloffset_UnlockArraysEXT 628
-#define _gloffset_SecondaryColor3bEXT 629
-#define _gloffset_SecondaryColor3bvEXT 630
-#define _gloffset_SecondaryColor3dEXT 631
-#define _gloffset_SecondaryColor3dvEXT 632
-#define _gloffset_SecondaryColor3fEXT 633
-#define _gloffset_SecondaryColor3fvEXT 634
-#define _gloffset_SecondaryColor3iEXT 635
-#define _gloffset_SecondaryColor3ivEXT 636
-#define _gloffset_SecondaryColor3sEXT 637
-#define _gloffset_SecondaryColor3svEXT 638
-#define _gloffset_SecondaryColor3ubEXT 639
-#define _gloffset_SecondaryColor3ubvEXT 640
-#define _gloffset_SecondaryColor3uiEXT 641
-#define _gloffset_SecondaryColor3uivEXT 642
-#define _gloffset_SecondaryColor3usEXT 643
-#define _gloffset_SecondaryColor3usvEXT 644
-#define _gloffset_SecondaryColorPointerEXT 645
-#define _gloffset_MultiDrawArraysEXT 646
-#define _gloffset_MultiDrawElementsEXT 647
-#define _gloffset_FogCoordPointerEXT 648
-#define _gloffset_FogCoorddEXT 649
-#define _gloffset_FogCoorddvEXT 650
-#define _gloffset_FogCoordfEXT 651
-#define _gloffset_FogCoordfvEXT 652
-#define _gloffset_PixelTexGenSGIX 653
-#define _gloffset_BlendFuncSeparateEXT 654
-#define _gloffset_FlushVertexArrayRangeNV 655
-#define _gloffset_VertexArrayRangeNV 656
-#define _gloffset_CombinerInputNV 657
-#define _gloffset_CombinerOutputNV 658
-#define _gloffset_CombinerParameterfNV 659
-#define _gloffset_CombinerParameterfvNV 660
-#define _gloffset_CombinerParameteriNV 661
-#define _gloffset_CombinerParameterivNV 662
-#define _gloffset_FinalCombinerInputNV 663
-#define _gloffset_GetCombinerInputParameterfvNV 664
-#define _gloffset_GetCombinerInputParameterivNV 665
-#define _gloffset_GetCombinerOutputParameterfvNV 666
-#define _gloffset_GetCombinerOutputParameterivNV 667
-#define _gloffset_GetFinalCombinerInputParameterfvNV 668
-#define _gloffset_GetFinalCombinerInputParameterivNV 669
-#define _gloffset_ResizeBuffersMESA 670
-#define _gloffset_WindowPos2dMESA 671
-#define _gloffset_WindowPos2dvMESA 672
-#define _gloffset_WindowPos2fMESA 673
-#define _gloffset_WindowPos2fvMESA 674
-#define _gloffset_WindowPos2iMESA 675
-#define _gloffset_WindowPos2ivMESA 676
-#define _gloffset_WindowPos2sMESA 677
-#define _gloffset_WindowPos2svMESA 678
-#define _gloffset_WindowPos3dMESA 679
-#define _gloffset_WindowPos3dvMESA 680
-#define _gloffset_WindowPos3fMESA 681
-#define _gloffset_WindowPos3fvMESA 682
-#define _gloffset_WindowPos3iMESA 683
-#define _gloffset_WindowPos3ivMESA 684
-#define _gloffset_WindowPos3sMESA 685
-#define _gloffset_WindowPos3svMESA 686
-#define _gloffset_WindowPos4dMESA 687
-#define _gloffset_WindowPos4dvMESA 688
-#define _gloffset_WindowPos4fMESA 689
-#define _gloffset_WindowPos4fvMESA 690
-#define _gloffset_WindowPos4iMESA 691
-#define _gloffset_WindowPos4ivMESA 692
-#define _gloffset_WindowPos4sMESA 693
-#define _gloffset_WindowPos4svMESA 694
-#define _gloffset_MultiModeDrawArraysIBM 695
-#define _gloffset_MultiModeDrawElementsIBM 696
-#define _gloffset_DeleteFencesNV 697
-#define _gloffset_FinishFenceNV 698
-#define _gloffset_GenFencesNV 699
-#define _gloffset_GetFenceivNV 700
-#define _gloffset_IsFenceNV 701
-#define _gloffset_SetFenceNV 702
-#define _gloffset_TestFenceNV 703
-#define _gloffset_AreProgramsResidentNV 704
-#define _gloffset_BindProgramNV 705
-#define _gloffset_DeleteProgramsNV 706
-#define _gloffset_ExecuteProgramNV 707
-#define _gloffset_GenProgramsNV 708
-#define _gloffset_GetProgramParameterdvNV 709
-#define _gloffset_GetProgramParameterfvNV 710
-#define _gloffset_GetProgramStringNV 711
-#define _gloffset_GetProgramivNV 712
-#define _gloffset_GetTrackMatrixivNV 713
-#define _gloffset_GetVertexAttribPointervNV 714
-#define _gloffset_GetVertexAttribdvNV 715
-#define _gloffset_GetVertexAttribfvNV 716
-#define _gloffset_GetVertexAttribivNV 717
-#define _gloffset_IsProgramNV 718
-#define _gloffset_LoadProgramNV 719
-#define _gloffset_ProgramParameters4dvNV 720
-#define _gloffset_ProgramParameters4fvNV 721
-#define _gloffset_RequestResidentProgramsNV 722
-#define _gloffset_TrackMatrixNV 723
-#define _gloffset_VertexAttrib1dNV 724
-#define _gloffset_VertexAttrib1dvNV 725
-#define _gloffset_VertexAttrib1fNV 726
-#define _gloffset_VertexAttrib1fvNV 727
-#define _gloffset_VertexAttrib1sNV 728
-#define _gloffset_VertexAttrib1svNV 729
-#define _gloffset_VertexAttrib2dNV 730
-#define _gloffset_VertexAttrib2dvNV 731
-#define _gloffset_VertexAttrib2fNV 732
-#define _gloffset_VertexAttrib2fvNV 733
-#define _gloffset_VertexAttrib2sNV 734
-#define _gloffset_VertexAttrib2svNV 735
-#define _gloffset_VertexAttrib3dNV 736
-#define _gloffset_VertexAttrib3dvNV 737
-#define _gloffset_VertexAttrib3fNV 738
-#define _gloffset_VertexAttrib3fvNV 739
-#define _gloffset_VertexAttrib3sNV 740
-#define _gloffset_VertexAttrib3svNV 741
-#define _gloffset_VertexAttrib4dNV 742
-#define _gloffset_VertexAttrib4dvNV 743
-#define _gloffset_VertexAttrib4fNV 744
-#define _gloffset_VertexAttrib4fvNV 745
-#define _gloffset_VertexAttrib4sNV 746
-#define _gloffset_VertexAttrib4svNV 747
-#define _gloffset_VertexAttrib4ubNV 748
-#define _gloffset_VertexAttrib4ubvNV 749
-#define _gloffset_VertexAttribPointerNV 750
-#define _gloffset_VertexAttribs1dvNV 751
-#define _gloffset_VertexAttribs1fvNV 752
-#define _gloffset_VertexAttribs1svNV 753
-#define _gloffset_VertexAttribs2dvNV 754
-#define _gloffset_VertexAttribs2fvNV 755
-#define _gloffset_VertexAttribs2svNV 756
-#define _gloffset_VertexAttribs3dvNV 757
-#define _gloffset_VertexAttribs3fvNV 758
-#define _gloffset_VertexAttribs3svNV 759
-#define _gloffset_VertexAttribs4dvNV 760
-#define _gloffset_VertexAttribs4fvNV 761
-#define _gloffset_VertexAttribs4svNV 762
-#define _gloffset_VertexAttribs4ubvNV 763
-#define _gloffset_GetTexBumpParameterfvATI 764
-#define _gloffset_GetTexBumpParameterivATI 765
-#define _gloffset_TexBumpParameterfvATI 766
-#define _gloffset_TexBumpParameterivATI 767
-#define _gloffset_AlphaFragmentOp1ATI 768
-#define _gloffset_AlphaFragmentOp2ATI 769
-#define _gloffset_AlphaFragmentOp3ATI 770
-#define _gloffset_BeginFragmentShaderATI 771
-#define _gloffset_BindFragmentShaderATI 772
-#define _gloffset_ColorFragmentOp1ATI 773
-#define _gloffset_ColorFragmentOp2ATI 774
-#define _gloffset_ColorFragmentOp3ATI 775
-#define _gloffset_DeleteFragmentShaderATI 776
-#define _gloffset_EndFragmentShaderATI 777
-#define _gloffset_GenFragmentShadersATI 778
-#define _gloffset_PassTexCoordATI 779
-#define _gloffset_SampleMapATI 780
-#define _gloffset_SetFragmentShaderConstantATI 781
-#define _gloffset_PointParameteriNV 782
-#define _gloffset_PointParameterivNV 783
-#define _gloffset_ActiveStencilFaceEXT 784
-#define _gloffset_BindVertexArrayAPPLE 785
-#define _gloffset_DeleteVertexArraysAPPLE 786
-#define _gloffset_GenVertexArraysAPPLE 787
-#define _gloffset_IsVertexArrayAPPLE 788
-#define _gloffset_GetProgramNamedParameterdvNV 789
-#define _gloffset_GetProgramNamedParameterfvNV 790
-#define _gloffset_ProgramNamedParameter4dNV 791
-#define _gloffset_ProgramNamedParameter4dvNV 792
-#define _gloffset_ProgramNamedParameter4fNV 793
-#define _gloffset_ProgramNamedParameter4fvNV 794
-#define _gloffset_PrimitiveRestartIndexNV 795
-#define _gloffset_PrimitiveRestartNV 796
-#define _gloffset_DepthBoundsEXT 797
-#define _gloffset_BlendEquationSeparateEXT 798
-#define _gloffset_BindFramebufferEXT 799
-#define _gloffset_BindRenderbufferEXT 800
-#define _gloffset_CheckFramebufferStatusEXT 801
-#define _gloffset_DeleteFramebuffersEXT 802
-#define _gloffset_DeleteRenderbuffersEXT 803
-#define _gloffset_FramebufferRenderbufferEXT 804
-#define _gloffset_FramebufferTexture1DEXT 805
-#define _gloffset_FramebufferTexture2DEXT 806
-#define _gloffset_FramebufferTexture3DEXT 807
-#define _gloffset_GenFramebuffersEXT 808
-#define _gloffset_GenRenderbuffersEXT 809
-#define _gloffset_GenerateMipmapEXT 810
-#define _gloffset_GetFramebufferAttachmentParameterivEXT 811
-#define _gloffset_GetRenderbufferParameterivEXT 812
-#define _gloffset_IsFramebufferEXT 813
-#define _gloffset_IsRenderbufferEXT 814
-#define _gloffset_RenderbufferStorageEXT 815
-#define _gloffset_BlitFramebufferEXT 816
-#define _gloffset_BufferParameteriAPPLE 817
-#define _gloffset_FlushMappedBufferRangeAPPLE 818
-#define _gloffset_BindFragDataLocationEXT 819
-#define _gloffset_GetFragDataLocationEXT 820
-#define _gloffset_GetUniformuivEXT 821
-#define _gloffset_GetVertexAttribIivEXT 822
-#define _gloffset_GetVertexAttribIuivEXT 823
-#define _gloffset_Uniform1uiEXT 824
-#define _gloffset_Uniform1uivEXT 825
-#define _gloffset_Uniform2uiEXT 826
-#define _gloffset_Uniform2uivEXT 827
-#define _gloffset_Uniform3uiEXT 828
-#define _gloffset_Uniform3uivEXT 829
-#define _gloffset_Uniform4uiEXT 830
-#define _gloffset_Uniform4uivEXT 831
-#define _gloffset_VertexAttribI1iEXT 832
-#define _gloffset_VertexAttribI1ivEXT 833
-#define _gloffset_VertexAttribI1uiEXT 834
-#define _gloffset_VertexAttribI1uivEXT 835
-#define _gloffset_VertexAttribI2iEXT 836
-#define _gloffset_VertexAttribI2ivEXT 837
-#define _gloffset_VertexAttribI2uiEXT 838
-#define _gloffset_VertexAttribI2uivEXT 839
-#define _gloffset_VertexAttribI3iEXT 840
-#define _gloffset_VertexAttribI3ivEXT 841
-#define _gloffset_VertexAttribI3uiEXT 842
-#define _gloffset_VertexAttribI3uivEXT 843
-#define _gloffset_VertexAttribI4bvEXT 844
-#define _gloffset_VertexAttribI4iEXT 845
-#define _gloffset_VertexAttribI4ivEXT 846
-#define _gloffset_VertexAttribI4svEXT 847
-#define _gloffset_VertexAttribI4ubvEXT 848
-#define _gloffset_VertexAttribI4uiEXT 849
-#define _gloffset_VertexAttribI4uivEXT 850
-#define _gloffset_VertexAttribI4usvEXT 851
-#define _gloffset_VertexAttribIPointerEXT 852
-#define _gloffset_FramebufferTextureLayerEXT 853
-#define _gloffset_ColorMaskIndexedEXT 854
-#define _gloffset_DisableIndexedEXT 855
-#define _gloffset_EnableIndexedEXT 856
-#define _gloffset_GetBooleanIndexedvEXT 857
-#define _gloffset_GetIntegerIndexedvEXT 858
-#define _gloffset_IsEnabledIndexedEXT 859
-#define _gloffset_ClearColorIiEXT 860
-#define _gloffset_ClearColorIuiEXT 861
-#define _gloffset_GetTexParameterIivEXT 862
-#define _gloffset_GetTexParameterIuivEXT 863
-#define _gloffset_TexParameterIivEXT 864
-#define _gloffset_TexParameterIuivEXT 865
-#define _gloffset_BeginConditionalRenderNV 866
-#define _gloffset_EndConditionalRenderNV 867
-#define _gloffset_BeginTransformFeedbackEXT 868
-#define _gloffset_BindBufferBaseEXT 869
-#define _gloffset_BindBufferOffsetEXT 870
-#define _gloffset_BindBufferRangeEXT 871
-#define _gloffset_EndTransformFeedbackEXT 872
-#define _gloffset_GetTransformFeedbackVaryingEXT 873
-#define _gloffset_TransformFeedbackVaryingsEXT 874
-#define _gloffset_ProvokingVertexEXT 875
-#define _gloffset_GetTexParameterPointervAPPLE 876
-#define _gloffset_TextureRangeAPPLE 877
-#define _gloffset_GetObjectParameterivAPPLE 878
-#define _gloffset_ObjectPurgeableAPPLE 879
-#define _gloffset_ObjectUnpurgeableAPPLE 880
-#define _gloffset_ActiveProgramEXT 881
-#define _gloffset_CreateShaderProgramEXT 882
-#define _gloffset_UseShaderProgramEXT 883
-#define _gloffset_TextureBarrierNV 884
-#define _gloffset_StencilFuncSeparateATI 885
-#define _gloffset_ProgramEnvParameters4fvEXT 886
-#define _gloffset_ProgramLocalParameters4fvEXT 887
-#define _gloffset_GetQueryObjecti64vEXT 888
-#define _gloffset_GetQueryObjectui64vEXT 889
-#define _gloffset_EGLImageTargetRenderbufferStorageOES 890
-#define _gloffset_EGLImageTargetTexture2DOES 891
+#define _gloffset_ClampColorARB 572
+#define _gloffset_DrawArraysInstancedARB 573
+#define _gloffset_DrawElementsInstancedARB 574
+#define _gloffset_RenderbufferStorageMultisample 575
+#define _gloffset_FramebufferTextureARB 576
+#define _gloffset_FramebufferTextureFaceARB 577
+#define _gloffset_ProgramParameteriARB 578
+#define _gloffset_VertexAttribDivisorARB 579
+#define _gloffset_FlushMappedBufferRange 580
+#define _gloffset_MapBufferRange 581
+#define _gloffset_BindVertexArray 582
+#define _gloffset_GenVertexArrays 583
+#define _gloffset_CopyBufferSubData 584
+#define _gloffset_ClientWaitSync 585
+#define _gloffset_DeleteSync 586
+#define _gloffset_FenceSync 587
+#define _gloffset_GetInteger64v 588
+#define _gloffset_GetSynciv 589
+#define _gloffset_IsSync 590
+#define _gloffset_WaitSync 591
+#define _gloffset_DrawElementsBaseVertex 592
+#define _gloffset_DrawRangeElementsBaseVertex 593
+#define _gloffset_MultiDrawElementsBaseVertex 594
+#define _gloffset_BlendEquationSeparateiARB 595
+#define _gloffset_BlendEquationiARB 596
+#define _gloffset_BlendFuncSeparateiARB 597
+#define _gloffset_BlendFunciARB 598
+#define _gloffset_BindTransformFeedback 599
+#define _gloffset_DeleteTransformFeedbacks 600
+#define _gloffset_DrawTransformFeedback 601
+#define _gloffset_GenTransformFeedbacks 602
+#define _gloffset_IsTransformFeedback 603
+#define _gloffset_PauseTransformFeedback 604
+#define _gloffset_ResumeTransformFeedback 605
+#define _gloffset_ClearDepthf 606
+#define _gloffset_DepthRangef 607
+#define _gloffset_GetShaderPrecisionFormat 608
+#define _gloffset_ReleaseShaderCompiler 609
+#define _gloffset_ShaderBinary 610
+#define _gloffset_PolygonOffsetEXT 611
+#define _gloffset_GetPixelTexGenParameterfvSGIS 612
+#define _gloffset_GetPixelTexGenParameterivSGIS 613
+#define _gloffset_PixelTexGenParameterfSGIS 614
+#define _gloffset_PixelTexGenParameterfvSGIS 615
+#define _gloffset_PixelTexGenParameteriSGIS 616
+#define _gloffset_PixelTexGenParameterivSGIS 617
+#define _gloffset_SampleMaskSGIS 618
+#define _gloffset_SamplePatternSGIS 619
+#define _gloffset_ColorPointerEXT 620
+#define _gloffset_EdgeFlagPointerEXT 621
+#define _gloffset_IndexPointerEXT 622
+#define _gloffset_NormalPointerEXT 623
+#define _gloffset_TexCoordPointerEXT 624
+#define _gloffset_VertexPointerEXT 625
+#define _gloffset_PointParameterfEXT 626
+#define _gloffset_PointParameterfvEXT 627
+#define _gloffset_LockArraysEXT 628
+#define _gloffset_UnlockArraysEXT 629
+#define _gloffset_SecondaryColor3bEXT 630
+#define _gloffset_SecondaryColor3bvEXT 631
+#define _gloffset_SecondaryColor3dEXT 632
+#define _gloffset_SecondaryColor3dvEXT 633
+#define _gloffset_SecondaryColor3fEXT 634
+#define _gloffset_SecondaryColor3fvEXT 635
+#define _gloffset_SecondaryColor3iEXT 636
+#define _gloffset_SecondaryColor3ivEXT 637
+#define _gloffset_SecondaryColor3sEXT 638
+#define _gloffset_SecondaryColor3svEXT 639
+#define _gloffset_SecondaryColor3ubEXT 640
+#define _gloffset_SecondaryColor3ubvEXT 641
+#define _gloffset_SecondaryColor3uiEXT 642
+#define _gloffset_SecondaryColor3uivEXT 643
+#define _gloffset_SecondaryColor3usEXT 644
+#define _gloffset_SecondaryColor3usvEXT 645
+#define _gloffset_SecondaryColorPointerEXT 646
+#define _gloffset_MultiDrawArraysEXT 647
+#define _gloffset_MultiDrawElementsEXT 648
+#define _gloffset_FogCoordPointerEXT 649
+#define _gloffset_FogCoorddEXT 650
+#define _gloffset_FogCoorddvEXT 651
+#define _gloffset_FogCoordfEXT 652
+#define _gloffset_FogCoordfvEXT 653
+#define _gloffset_PixelTexGenSGIX 654
+#define _gloffset_BlendFuncSeparateEXT 655
+#define _gloffset_FlushVertexArrayRangeNV 656
+#define _gloffset_VertexArrayRangeNV 657
+#define _gloffset_CombinerInputNV 658
+#define _gloffset_CombinerOutputNV 659
+#define _gloffset_CombinerParameterfNV 660
+#define _gloffset_CombinerParameterfvNV 661
+#define _gloffset_CombinerParameteriNV 662
+#define _gloffset_CombinerParameterivNV 663
+#define _gloffset_FinalCombinerInputNV 664
+#define _gloffset_GetCombinerInputParameterfvNV 665
+#define _gloffset_GetCombinerInputParameterivNV 666
+#define _gloffset_GetCombinerOutputParameterfvNV 667
+#define _gloffset_GetCombinerOutputParameterivNV 668
+#define _gloffset_GetFinalCombinerInputParameterfvNV 669
+#define _gloffset_GetFinalCombinerInputParameterivNV 670
+#define _gloffset_ResizeBuffersMESA 671
+#define _gloffset_WindowPos2dMESA 672
+#define _gloffset_WindowPos2dvMESA 673
+#define _gloffset_WindowPos2fMESA 674
+#define _gloffset_WindowPos2fvMESA 675
+#define _gloffset_WindowPos2iMESA 676
+#define _gloffset_WindowPos2ivMESA 677
+#define _gloffset_WindowPos2sMESA 678
+#define _gloffset_WindowPos2svMESA 679
+#define _gloffset_WindowPos3dMESA 680
+#define _gloffset_WindowPos3dvMESA 681
+#define _gloffset_WindowPos3fMESA 682
+#define _gloffset_WindowPos3fvMESA 683
+#define _gloffset_WindowPos3iMESA 684
+#define _gloffset_WindowPos3ivMESA 685
+#define _gloffset_WindowPos3sMESA 686
+#define _gloffset_WindowPos3svMESA 687
+#define _gloffset_WindowPos4dMESA 688
+#define _gloffset_WindowPos4dvMESA 689
+#define _gloffset_WindowPos4fMESA 690
+#define _gloffset_WindowPos4fvMESA 691
+#define _gloffset_WindowPos4iMESA 692
+#define _gloffset_WindowPos4ivMESA 693
+#define _gloffset_WindowPos4sMESA 694
+#define _gloffset_WindowPos4svMESA 695
+#define _gloffset_MultiModeDrawArraysIBM 696
+#define _gloffset_MultiModeDrawElementsIBM 697
+#define _gloffset_DeleteFencesNV 698
+#define _gloffset_FinishFenceNV 699
+#define _gloffset_GenFencesNV 700
+#define _gloffset_GetFenceivNV 701
+#define _gloffset_IsFenceNV 702
+#define _gloffset_SetFenceNV 703
+#define _gloffset_TestFenceNV 704
+#define _gloffset_AreProgramsResidentNV 705
+#define _gloffset_BindProgramNV 706
+#define _gloffset_DeleteProgramsNV 707
+#define _gloffset_ExecuteProgramNV 708
+#define _gloffset_GenProgramsNV 709
+#define _gloffset_GetProgramParameterdvNV 710
+#define _gloffset_GetProgramParameterfvNV 711
+#define _gloffset_GetProgramStringNV 712
+#define _gloffset_GetProgramivNV 713
+#define _gloffset_GetTrackMatrixivNV 714
+#define _gloffset_GetVertexAttribPointervNV 715
+#define _gloffset_GetVertexAttribdvNV 716
+#define _gloffset_GetVertexAttribfvNV 717
+#define _gloffset_GetVertexAttribivNV 718
+#define _gloffset_IsProgramNV 719
+#define _gloffset_LoadProgramNV 720
+#define _gloffset_ProgramParameters4dvNV 721
+#define _gloffset_ProgramParameters4fvNV 722
+#define _gloffset_RequestResidentProgramsNV 723
+#define _gloffset_TrackMatrixNV 724
+#define _gloffset_VertexAttrib1dNV 725
+#define _gloffset_VertexAttrib1dvNV 726
+#define _gloffset_VertexAttrib1fNV 727
+#define _gloffset_VertexAttrib1fvNV 728
+#define _gloffset_VertexAttrib1sNV 729
+#define _gloffset_VertexAttrib1svNV 730
+#define _gloffset_VertexAttrib2dNV 731
+#define _gloffset_VertexAttrib2dvNV 732
+#define _gloffset_VertexAttrib2fNV 733
+#define _gloffset_VertexAttrib2fvNV 734
+#define _gloffset_VertexAttrib2sNV 735
+#define _gloffset_VertexAttrib2svNV 736
+#define _gloffset_VertexAttrib3dNV 737
+#define _gloffset_VertexAttrib3dvNV 738
+#define _gloffset_VertexAttrib3fNV 739
+#define _gloffset_VertexAttrib3fvNV 740
+#define _gloffset_VertexAttrib3sNV 741
+#define _gloffset_VertexAttrib3svNV 742
+#define _gloffset_VertexAttrib4dNV 743
+#define _gloffset_VertexAttrib4dvNV 744
+#define _gloffset_VertexAttrib4fNV 745
+#define _gloffset_VertexAttrib4fvNV 746
+#define _gloffset_VertexAttrib4sNV 747
+#define _gloffset_VertexAttrib4svNV 748
+#define _gloffset_VertexAttrib4ubNV 749
+#define _gloffset_VertexAttrib4ubvNV 750
+#define _gloffset_VertexAttribPointerNV 751
+#define _gloffset_VertexAttribs1dvNV 752
+#define _gloffset_VertexAttribs1fvNV 753
+#define _gloffset_VertexAttribs1svNV 754
+#define _gloffset_VertexAttribs2dvNV 755
+#define _gloffset_VertexAttribs2fvNV 756
+#define _gloffset_VertexAttribs2svNV 757
+#define _gloffset_VertexAttribs3dvNV 758
+#define _gloffset_VertexAttribs3fvNV 759
+#define _gloffset_VertexAttribs3svNV 760
+#define _gloffset_VertexAttribs4dvNV 761
+#define _gloffset_VertexAttribs4fvNV 762
+#define _gloffset_VertexAttribs4svNV 763
+#define _gloffset_VertexAttribs4ubvNV 764
+#define _gloffset_GetTexBumpParameterfvATI 765
+#define _gloffset_GetTexBumpParameterivATI 766
+#define _gloffset_TexBumpParameterfvATI 767
+#define _gloffset_TexBumpParameterivATI 768
+#define _gloffset_AlphaFragmentOp1ATI 769
+#define _gloffset_AlphaFragmentOp2ATI 770
+#define _gloffset_AlphaFragmentOp3ATI 771
+#define _gloffset_BeginFragmentShaderATI 772
+#define _gloffset_BindFragmentShaderATI 773
+#define _gloffset_ColorFragmentOp1ATI 774
+#define _gloffset_ColorFragmentOp2ATI 775
+#define _gloffset_ColorFragmentOp3ATI 776
+#define _gloffset_DeleteFragmentShaderATI 777
+#define _gloffset_EndFragmentShaderATI 778
+#define _gloffset_GenFragmentShadersATI 779
+#define _gloffset_PassTexCoordATI 780
+#define _gloffset_SampleMapATI 781
+#define _gloffset_SetFragmentShaderConstantATI 782
+#define _gloffset_PointParameteriNV 783
+#define _gloffset_PointParameterivNV 784
+#define _gloffset_ActiveStencilFaceEXT 785
+#define _gloffset_BindVertexArrayAPPLE 786
+#define _gloffset_DeleteVertexArraysAPPLE 787
+#define _gloffset_GenVertexArraysAPPLE 788
+#define _gloffset_IsVertexArrayAPPLE 789
+#define _gloffset_GetProgramNamedParameterdvNV 790
+#define _gloffset_GetProgramNamedParameterfvNV 791
+#define _gloffset_ProgramNamedParameter4dNV 792
+#define _gloffset_ProgramNamedParameter4dvNV 793
+#define _gloffset_ProgramNamedParameter4fNV 794
+#define _gloffset_ProgramNamedParameter4fvNV 795
+#define _gloffset_PrimitiveRestartIndexNV 796
+#define _gloffset_PrimitiveRestartNV 797
+#define _gloffset_DepthBoundsEXT 798
+#define _gloffset_BlendEquationSeparateEXT 799
+#define _gloffset_BindFramebufferEXT 800
+#define _gloffset_BindRenderbufferEXT 801
+#define _gloffset_CheckFramebufferStatusEXT 802
+#define _gloffset_DeleteFramebuffersEXT 803
+#define _gloffset_DeleteRenderbuffersEXT 804
+#define _gloffset_FramebufferRenderbufferEXT 805
+#define _gloffset_FramebufferTexture1DEXT 806
+#define _gloffset_FramebufferTexture2DEXT 807
+#define _gloffset_FramebufferTexture3DEXT 808
+#define _gloffset_GenFramebuffersEXT 809
+#define _gloffset_GenRenderbuffersEXT 810
+#define _gloffset_GenerateMipmapEXT 811
+#define _gloffset_GetFramebufferAttachmentParameterivEXT 812
+#define _gloffset_GetRenderbufferParameterivEXT 813
+#define _gloffset_IsFramebufferEXT 814
+#define _gloffset_IsRenderbufferEXT 815
+#define _gloffset_RenderbufferStorageEXT 816
+#define _gloffset_BlitFramebufferEXT 817
+#define _gloffset_BufferParameteriAPPLE 818
+#define _gloffset_FlushMappedBufferRangeAPPLE 819
+#define _gloffset_BindFragDataLocationEXT 820
+#define _gloffset_GetFragDataLocationEXT 821
+#define _gloffset_GetUniformuivEXT 822
+#define _gloffset_GetVertexAttribIivEXT 823
+#define _gloffset_GetVertexAttribIuivEXT 824
+#define _gloffset_Uniform1uiEXT 825
+#define _gloffset_Uniform1uivEXT 826
+#define _gloffset_Uniform2uiEXT 827
+#define _gloffset_Uniform2uivEXT 828
+#define _gloffset_Uniform3uiEXT 829
+#define _gloffset_Uniform3uivEXT 830
+#define _gloffset_Uniform4uiEXT 831
+#define _gloffset_Uniform4uivEXT 832
+#define _gloffset_VertexAttribI1iEXT 833
+#define _gloffset_VertexAttribI1ivEXT 834
+#define _gloffset_VertexAttribI1uiEXT 835
+#define _gloffset_VertexAttribI1uivEXT 836
+#define _gloffset_VertexAttribI2iEXT 837
+#define _gloffset_VertexAttribI2ivEXT 838
+#define _gloffset_VertexAttribI2uiEXT 839
+#define _gloffset_VertexAttribI2uivEXT 840
+#define _gloffset_VertexAttribI3iEXT 841
+#define _gloffset_VertexAttribI3ivEXT 842
+#define _gloffset_VertexAttribI3uiEXT 843
+#define _gloffset_VertexAttribI3uivEXT 844
+#define _gloffset_VertexAttribI4bvEXT 845
+#define _gloffset_VertexAttribI4iEXT 846
+#define _gloffset_VertexAttribI4ivEXT 847
+#define _gloffset_VertexAttribI4svEXT 848
+#define _gloffset_VertexAttribI4ubvEXT 849
+#define _gloffset_VertexAttribI4uiEXT 850
+#define _gloffset_VertexAttribI4uivEXT 851
+#define _gloffset_VertexAttribI4usvEXT 852
+#define _gloffset_VertexAttribIPointerEXT 853
+#define _gloffset_FramebufferTextureLayerEXT 854
+#define _gloffset_ColorMaskIndexedEXT 855
+#define _gloffset_DisableIndexedEXT 856
+#define _gloffset_EnableIndexedEXT 857
+#define _gloffset_GetBooleanIndexedvEXT 858
+#define _gloffset_GetIntegerIndexedvEXT 859
+#define _gloffset_IsEnabledIndexedEXT 860
+#define _gloffset_ClearColorIiEXT 861
+#define _gloffset_ClearColorIuiEXT 862
+#define _gloffset_GetTexParameterIivEXT 863
+#define _gloffset_GetTexParameterIuivEXT 864
+#define _gloffset_TexParameterIivEXT 865
+#define _gloffset_TexParameterIuivEXT 866
+#define _gloffset_BeginConditionalRenderNV 867
+#define _gloffset_EndConditionalRenderNV 868
+#define _gloffset_BeginTransformFeedbackEXT 869
+#define _gloffset_BindBufferBaseEXT 870
+#define _gloffset_BindBufferOffsetEXT 871
+#define _gloffset_BindBufferRangeEXT 872
+#define _gloffset_EndTransformFeedbackEXT 873
+#define _gloffset_GetTransformFeedbackVaryingEXT 874
+#define _gloffset_TransformFeedbackVaryingsEXT 875
+#define _gloffset_ProvokingVertexEXT 876
+#define _gloffset_GetTexParameterPointervAPPLE 877
+#define _gloffset_TextureRangeAPPLE 878
+#define _gloffset_GetObjectParameterivAPPLE 879
+#define _gloffset_ObjectPurgeableAPPLE 880
+#define _gloffset_ObjectUnpurgeableAPPLE 881
+#define _gloffset_ActiveProgramEXT 882
+#define _gloffset_CreateShaderProgramEXT 883
+#define _gloffset_UseShaderProgramEXT 884
+#define _gloffset_TextureBarrierNV 885
+#define _gloffset_StencilFuncSeparateATI 886
+#define _gloffset_ProgramEnvParameters4fvEXT 887
+#define _gloffset_ProgramLocalParameters4fvEXT 888
+#define _gloffset_GetQueryObjecti64vEXT 889
+#define _gloffset_GetQueryObjectui64vEXT 890
+#define _gloffset_EGLImageTargetRenderbufferStorageOES 891
+#define _gloffset_EGLImageTargetTexture2DOES 892
 
 #else /* !_GLAPI_USE_REMAP_TABLE */
 
-#define driDispatchRemapTable_size 484
+#define driDispatchRemapTable_size 485
 extern int driDispatchRemapTable[ driDispatchRemapTable_size ];
 
 #define AttachShader_remap_index 0
@@ -1126,326 +1127,327 @@ extern int driDispatchRemapTable[ driDispatchRemapTable_size ];
 #define GetActiveAttribARB_remap_index 161
 #define GetAttribLocationARB_remap_index 162
 #define DrawBuffersARB_remap_index 163
-#define DrawArraysInstancedARB_remap_index 164
-#define DrawElementsInstancedARB_remap_index 165
-#define RenderbufferStorageMultisample_remap_index 166
-#define FramebufferTextureARB_remap_index 167
-#define FramebufferTextureFaceARB_remap_index 168
-#define ProgramParameteriARB_remap_index 169
-#define VertexAttribDivisorARB_remap_index 170
-#define FlushMappedBufferRange_remap_index 171
-#define MapBufferRange_remap_index 172
-#define BindVertexArray_remap_index 173
-#define GenVertexArrays_remap_index 174
-#define CopyBufferSubData_remap_index 175
-#define ClientWaitSync_remap_index 176
-#define DeleteSync_remap_index 177
-#define FenceSync_remap_index 178
-#define GetInteger64v_remap_index 179
-#define GetSynciv_remap_index 180
-#define IsSync_remap_index 181
-#define WaitSync_remap_index 182
-#define DrawElementsBaseVertex_remap_index 183
-#define DrawRangeElementsBaseVertex_remap_index 184
-#define MultiDrawElementsBaseVertex_remap_index 185
-#define BlendEquationSeparateiARB_remap_index 186
-#define BlendEquationiARB_remap_index 187
-#define BlendFuncSeparateiARB_remap_index 188
-#define BlendFunciARB_remap_index 189
-#define BindTransformFeedback_remap_index 190
-#define DeleteTransformFeedbacks_remap_index 191
-#define DrawTransformFeedback_remap_index 192
-#define GenTransformFeedbacks_remap_index 193
-#define IsTransformFeedback_remap_index 194
-#define PauseTransformFeedback_remap_index 195
-#define ResumeTransformFeedback_remap_index 196
-#define ClearDepthf_remap_index 197
-#define DepthRangef_remap_index 198
-#define GetShaderPrecisionFormat_remap_index 199
-#define ReleaseShaderCompiler_remap_index 200
-#define ShaderBinary_remap_index 201
-#define PolygonOffsetEXT_remap_index 202
-#define GetPixelTexGenParameterfvSGIS_remap_index 203
-#define GetPixelTexGenParameterivSGIS_remap_index 204
-#define PixelTexGenParameterfSGIS_remap_index 205
-#define PixelTexGenParameterfvSGIS_remap_index 206
-#define PixelTexGenParameteriSGIS_remap_index 207
-#define PixelTexGenParameterivSGIS_remap_index 208
-#define SampleMaskSGIS_remap_index 209
-#define SamplePatternSGIS_remap_index 210
-#define ColorPointerEXT_remap_index 211
-#define EdgeFlagPointerEXT_remap_index 212
-#define IndexPointerEXT_remap_index 213
-#define NormalPointerEXT_remap_index 214
-#define TexCoordPointerEXT_remap_index 215
-#define VertexPointerEXT_remap_index 216
-#define PointParameterfEXT_remap_index 217
-#define PointParameterfvEXT_remap_index 218
-#define LockArraysEXT_remap_index 219
-#define UnlockArraysEXT_remap_index 220
-#define SecondaryColor3bEXT_remap_index 221
-#define SecondaryColor3bvEXT_remap_index 222
-#define SecondaryColor3dEXT_remap_index 223
-#define SecondaryColor3dvEXT_remap_index 224
-#define SecondaryColor3fEXT_remap_index 225
-#define SecondaryColor3fvEXT_remap_index 226
-#define SecondaryColor3iEXT_remap_index 227
-#define SecondaryColor3ivEXT_remap_index 228
-#define SecondaryColor3sEXT_remap_index 229
-#define SecondaryColor3svEXT_remap_index 230
-#define SecondaryColor3ubEXT_remap_index 231
-#define SecondaryColor3ubvEXT_remap_index 232
-#define SecondaryColor3uiEXT_remap_index 233
-#define SecondaryColor3uivEXT_remap_index 234
-#define SecondaryColor3usEXT_remap_index 235
-#define SecondaryColor3usvEXT_remap_index 236
-#define SecondaryColorPointerEXT_remap_index 237
-#define MultiDrawArraysEXT_remap_index 238
-#define MultiDrawElementsEXT_remap_index 239
-#define FogCoordPointerEXT_remap_index 240
-#define FogCoorddEXT_remap_index 241
-#define FogCoorddvEXT_remap_index 242
-#define FogCoordfEXT_remap_index 243
-#define FogCoordfvEXT_remap_index 244
-#define PixelTexGenSGIX_remap_index 245
-#define BlendFuncSeparateEXT_remap_index 246
-#define FlushVertexArrayRangeNV_remap_index 247
-#define VertexArrayRangeNV_remap_index 248
-#define CombinerInputNV_remap_index 249
-#define CombinerOutputNV_remap_index 250
-#define CombinerParameterfNV_remap_index 251
-#define CombinerParameterfvNV_remap_index 252
-#define CombinerParameteriNV_remap_index 253
-#define CombinerParameterivNV_remap_index 254
-#define FinalCombinerInputNV_remap_index 255
-#define GetCombinerInputParameterfvNV_remap_index 256
-#define GetCombinerInputParameterivNV_remap_index 257
-#define GetCombinerOutputParameterfvNV_remap_index 258
-#define GetCombinerOutputParameterivNV_remap_index 259
-#define GetFinalCombinerInputParameterfvNV_remap_index 260
-#define GetFinalCombinerInputParameterivNV_remap_index 261
-#define ResizeBuffersMESA_remap_index 262
-#define WindowPos2dMESA_remap_index 263
-#define WindowPos2dvMESA_remap_index 264
-#define WindowPos2fMESA_remap_index 265
-#define WindowPos2fvMESA_remap_index 266
-#define WindowPos2iMESA_remap_index 267
-#define WindowPos2ivMESA_remap_index 268
-#define WindowPos2sMESA_remap_index 269
-#define WindowPos2svMESA_remap_index 270
-#define WindowPos3dMESA_remap_index 271
-#define WindowPos3dvMESA_remap_index 272
-#define WindowPos3fMESA_remap_index 273
-#define WindowPos3fvMESA_remap_index 274
-#define WindowPos3iMESA_remap_index 275
-#define WindowPos3ivMESA_remap_index 276
-#define WindowPos3sMESA_remap_index 277
-#define WindowPos3svMESA_remap_index 278
-#define WindowPos4dMESA_remap_index 279
-#define WindowPos4dvMESA_remap_index 280
-#define WindowPos4fMESA_remap_index 281
-#define WindowPos4fvMESA_remap_index 282
-#define WindowPos4iMESA_remap_index 283
-#define WindowPos4ivMESA_remap_index 284
-#define WindowPos4sMESA_remap_index 285
-#define WindowPos4svMESA_remap_index 286
-#define MultiModeDrawArraysIBM_remap_index 287
-#define MultiModeDrawElementsIBM_remap_index 288
-#define DeleteFencesNV_remap_index 289
-#define FinishFenceNV_remap_index 290
-#define GenFencesNV_remap_index 291
-#define GetFenceivNV_remap_index 292
-#define IsFenceNV_remap_index 293
-#define SetFenceNV_remap_index 294
-#define TestFenceNV_remap_index 295
-#define AreProgramsResidentNV_remap_index 296
-#define BindProgramNV_remap_index 297
-#define DeleteProgramsNV_remap_index 298
-#define ExecuteProgramNV_remap_index 299
-#define GenProgramsNV_remap_index 300
-#define GetProgramParameterdvNV_remap_index 301
-#define GetProgramParameterfvNV_remap_index 302
-#define GetProgramStringNV_remap_index 303
-#define GetProgramivNV_remap_index 304
-#define GetTrackMatrixivNV_remap_index 305
-#define GetVertexAttribPointervNV_remap_index 306
-#define GetVertexAttribdvNV_remap_index 307
-#define GetVertexAttribfvNV_remap_index 308
-#define GetVertexAttribivNV_remap_index 309
-#define IsProgramNV_remap_index 310
-#define LoadProgramNV_remap_index 311
-#define ProgramParameters4dvNV_remap_index 312
-#define ProgramParameters4fvNV_remap_index 313
-#define RequestResidentProgramsNV_remap_index 314
-#define TrackMatrixNV_remap_index 315
-#define VertexAttrib1dNV_remap_index 316
-#define VertexAttrib1dvNV_remap_index 317
-#define VertexAttrib1fNV_remap_index 318
-#define VertexAttrib1fvNV_remap_index 319
-#define VertexAttrib1sNV_remap_index 320
-#define VertexAttrib1svNV_remap_index 321
-#define VertexAttrib2dNV_remap_index 322
-#define VertexAttrib2dvNV_remap_index 323
-#define VertexAttrib2fNV_remap_index 324
-#define VertexAttrib2fvNV_remap_index 325
-#define VertexAttrib2sNV_remap_index 326
-#define VertexAttrib2svNV_remap_index 327
-#define VertexAttrib3dNV_remap_index 328
-#define VertexAttrib3dvNV_remap_index 329
-#define VertexAttrib3fNV_remap_index 330
-#define VertexAttrib3fvNV_remap_index 331
-#define VertexAttrib3sNV_remap_index 332
-#define VertexAttrib3svNV_remap_index 333
-#define VertexAttrib4dNV_remap_index 334
-#define VertexAttrib4dvNV_remap_index 335
-#define VertexAttrib4fNV_remap_index 336
-#define VertexAttrib4fvNV_remap_index 337
-#define VertexAttrib4sNV_remap_index 338
-#define VertexAttrib4svNV_remap_index 339
-#define VertexAttrib4ubNV_remap_index 340
-#define VertexAttrib4ubvNV_remap_index 341
-#define VertexAttribPointerNV_remap_index 342
-#define VertexAttribs1dvNV_remap_index 343
-#define VertexAttribs1fvNV_remap_index 344
-#define VertexAttribs1svNV_remap_index 345
-#define VertexAttribs2dvNV_remap_index 346
-#define VertexAttribs2fvNV_remap_index 347
-#define VertexAttribs2svNV_remap_index 348
-#define VertexAttribs3dvNV_remap_index 349
-#define VertexAttribs3fvNV_remap_index 350
-#define VertexAttribs3svNV_remap_index 351
-#define VertexAttribs4dvNV_remap_index 352
-#define VertexAttribs4fvNV_remap_index 353
-#define VertexAttribs4svNV_remap_index 354
-#define VertexAttribs4ubvNV_remap_index 355
-#define GetTexBumpParameterfvATI_remap_index 356
-#define GetTexBumpParameterivATI_remap_index 357
-#define TexBumpParameterfvATI_remap_index 358
-#define TexBumpParameterivATI_remap_index 359
-#define AlphaFragmentOp1ATI_remap_index 360
-#define AlphaFragmentOp2ATI_remap_index 361
-#define AlphaFragmentOp3ATI_remap_index 362
-#define BeginFragmentShaderATI_remap_index 363
-#define BindFragmentShaderATI_remap_index 364
-#define ColorFragmentOp1ATI_remap_index 365
-#define ColorFragmentOp2ATI_remap_index 366
-#define ColorFragmentOp3ATI_remap_index 367
-#define DeleteFragmentShaderATI_remap_index 368
-#define EndFragmentShaderATI_remap_index 369
-#define GenFragmentShadersATI_remap_index 370
-#define PassTexCoordATI_remap_index 371
-#define SampleMapATI_remap_index 372
-#define SetFragmentShaderConstantATI_remap_index 373
-#define PointParameteriNV_remap_index 374
-#define PointParameterivNV_remap_index 375
-#define ActiveStencilFaceEXT_remap_index 376
-#define BindVertexArrayAPPLE_remap_index 377
-#define DeleteVertexArraysAPPLE_remap_index 378
-#define GenVertexArraysAPPLE_remap_index 379
-#define IsVertexArrayAPPLE_remap_index 380
-#define GetProgramNamedParameterdvNV_remap_index 381
-#define GetProgramNamedParameterfvNV_remap_index 382
-#define ProgramNamedParameter4dNV_remap_index 383
-#define ProgramNamedParameter4dvNV_remap_index 384
-#define ProgramNamedParameter4fNV_remap_index 385
-#define ProgramNamedParameter4fvNV_remap_index 386
-#define PrimitiveRestartIndexNV_remap_index 387
-#define PrimitiveRestartNV_remap_index 388
-#define DepthBoundsEXT_remap_index 389
-#define BlendEquationSeparateEXT_remap_index 390
-#define BindFramebufferEXT_remap_index 391
-#define BindRenderbufferEXT_remap_index 392
-#define CheckFramebufferStatusEXT_remap_index 393
-#define DeleteFramebuffersEXT_remap_index 394
-#define DeleteRenderbuffersEXT_remap_index 395
-#define FramebufferRenderbufferEXT_remap_index 396
-#define FramebufferTexture1DEXT_remap_index 397
-#define FramebufferTexture2DEXT_remap_index 398
-#define FramebufferTexture3DEXT_remap_index 399
-#define GenFramebuffersEXT_remap_index 400
-#define GenRenderbuffersEXT_remap_index 401
-#define GenerateMipmapEXT_remap_index 402
-#define GetFramebufferAttachmentParameterivEXT_remap_index 403
-#define GetRenderbufferParameterivEXT_remap_index 404
-#define IsFramebufferEXT_remap_index 405
-#define IsRenderbufferEXT_remap_index 406
-#define RenderbufferStorageEXT_remap_index 407
-#define BlitFramebufferEXT_remap_index 408
-#define BufferParameteriAPPLE_remap_index 409
-#define FlushMappedBufferRangeAPPLE_remap_index 410
-#define BindFragDataLocationEXT_remap_index 411
-#define GetFragDataLocationEXT_remap_index 412
-#define GetUniformuivEXT_remap_index 413
-#define GetVertexAttribIivEXT_remap_index 414
-#define GetVertexAttribIuivEXT_remap_index 415
-#define Uniform1uiEXT_remap_index 416
-#define Uniform1uivEXT_remap_index 417
-#define Uniform2uiEXT_remap_index 418
-#define Uniform2uivEXT_remap_index 419
-#define Uniform3uiEXT_remap_index 420
-#define Uniform3uivEXT_remap_index 421
-#define Uniform4uiEXT_remap_index 422
-#define Uniform4uivEXT_remap_index 423
-#define VertexAttribI1iEXT_remap_index 424
-#define VertexAttribI1ivEXT_remap_index 425
-#define VertexAttribI1uiEXT_remap_index 426
-#define VertexAttribI1uivEXT_remap_index 427
-#define VertexAttribI2iEXT_remap_index 428
-#define VertexAttribI2ivEXT_remap_index 429
-#define VertexAttribI2uiEXT_remap_index 430
-#define VertexAttribI2uivEXT_remap_index 431
-#define VertexAttribI3iEXT_remap_index 432
-#define VertexAttribI3ivEXT_remap_index 433
-#define VertexAttribI3uiEXT_remap_index 434
-#define VertexAttribI3uivEXT_remap_index 435
-#define VertexAttribI4bvEXT_remap_index 436
-#define VertexAttribI4iEXT_remap_index 437
-#define VertexAttribI4ivEXT_remap_index 438
-#define VertexAttribI4svEXT_remap_index 439
-#define VertexAttribI4ubvEXT_remap_index 440
-#define VertexAttribI4uiEXT_remap_index 441
-#define VertexAttribI4uivEXT_remap_index 442
-#define VertexAttribI4usvEXT_remap_index 443
-#define VertexAttribIPointerEXT_remap_index 444
-#define FramebufferTextureLayerEXT_remap_index 445
-#define ColorMaskIndexedEXT_remap_index 446
-#define DisableIndexedEXT_remap_index 447
-#define EnableIndexedEXT_remap_index 448
-#define GetBooleanIndexedvEXT_remap_index 449
-#define GetIntegerIndexedvEXT_remap_index 450
-#define IsEnabledIndexedEXT_remap_index 451
-#define ClearColorIiEXT_remap_index 452
-#define ClearColorIuiEXT_remap_index 453
-#define GetTexParameterIivEXT_remap_index 454
-#define GetTexParameterIuivEXT_remap_index 455
-#define TexParameterIivEXT_remap_index 456
-#define TexParameterIuivEXT_remap_index 457
-#define BeginConditionalRenderNV_remap_index 458
-#define EndConditionalRenderNV_remap_index 459
-#define BeginTransformFeedbackEXT_remap_index 460
-#define BindBufferBaseEXT_remap_index 461
-#define BindBufferOffsetEXT_remap_index 462
-#define BindBufferRangeEXT_remap_index 463
-#define EndTransformFeedbackEXT_remap_index 464
-#define GetTransformFeedbackVaryingEXT_remap_index 465
-#define TransformFeedbackVaryingsEXT_remap_index 466
-#define ProvokingVertexEXT_remap_index 467
-#define GetTexParameterPointervAPPLE_remap_index 468
-#define TextureRangeAPPLE_remap_index 469
-#define GetObjectParameterivAPPLE_remap_index 470
-#define ObjectPurgeableAPPLE_remap_index 471
-#define ObjectUnpurgeableAPPLE_remap_index 472
-#define ActiveProgramEXT_remap_index 473
-#define CreateShaderProgramEXT_remap_index 474
-#define UseShaderProgramEXT_remap_index 475
-#define TextureBarrierNV_remap_index 476
-#define StencilFuncSeparateATI_remap_index 477
-#define ProgramEnvParameters4fvEXT_remap_index 478
-#define ProgramLocalParameters4fvEXT_remap_index 479
-#define GetQueryObjecti64vEXT_remap_index 480
-#define GetQueryObjectui64vEXT_remap_index 481
-#define EGLImageTargetRenderbufferStorageOES_remap_index 482
-#define EGLImageTargetTexture2DOES_remap_index 483
+#define ClampColorARB_remap_index 164
+#define DrawArraysInstancedARB_remap_index 165
+#define DrawElementsInstancedARB_remap_index 166
+#define RenderbufferStorageMultisample_remap_index 167
+#define FramebufferTextureARB_remap_index 168
+#define FramebufferTextureFaceARB_remap_index 169
+#define ProgramParameteriARB_remap_index 170
+#define VertexAttribDivisorARB_remap_index 171
+#define FlushMappedBufferRange_remap_index 172
+#define MapBufferRange_remap_index 173
+#define BindVertexArray_remap_index 174
+#define GenVertexArrays_remap_index 175
+#define CopyBufferSubData_remap_index 176
+#define ClientWaitSync_remap_index 177
+#define DeleteSync_remap_index 178
+#define FenceSync_remap_index 179
+#define GetInteger64v_remap_index 180
+#define GetSynciv_remap_index 181
+#define IsSync_remap_index 182
+#define WaitSync_remap_index 183
+#define DrawElementsBaseVertex_remap_index 184
+#define DrawRangeElementsBaseVertex_remap_index 185
+#define MultiDrawElementsBaseVertex_remap_index 186
+#define BlendEquationSeparateiARB_remap_index 187
+#define BlendEquationiARB_remap_index 188
+#define BlendFuncSeparateiARB_remap_index 189
+#define BlendFunciARB_remap_index 190
+#define BindTransformFeedback_remap_index 191
+#define DeleteTransformFeedbacks_remap_index 192
+#define DrawTransformFeedback_remap_index 193
+#define GenTransformFeedbacks_remap_index 194
+#define IsTransformFeedback_remap_index 195
+#define PauseTransformFeedback_remap_index 196
+#define ResumeTransformFeedback_remap_index 197
+#define ClearDepthf_remap_index 198
+#define DepthRangef_remap_index 199
+#define GetShaderPrecisionFormat_remap_index 200
+#define ReleaseShaderCompiler_remap_index 201
+#define ShaderBinary_remap_index 202
+#define PolygonOffsetEXT_remap_index 203
+#define GetPixelTexGenParameterfvSGIS_remap_index 204
+#define GetPixelTexGenParameterivSGIS_remap_index 205
+#define PixelTexGenParameterfSGIS_remap_index 206
+#define PixelTexGenParameterfvSGIS_remap_index 207
+#define PixelTexGenParameteriSGIS_remap_index 208
+#define PixelTexGenParameterivSGIS_remap_index 209
+#define SampleMaskSGIS_remap_index 210
+#define SamplePatternSGIS_remap_index 211
+#define ColorPointerEXT_remap_index 212
+#define EdgeFlagPointerEXT_remap_index 213
+#define IndexPointerEXT_remap_index 214
+#define NormalPointerEXT_remap_index 215
+#define TexCoordPointerEXT_remap_index 216
+#define VertexPointerEXT_remap_index 217
+#define PointParameterfEXT_remap_index 218
+#define PointParameterfvEXT_remap_index 219
+#define LockArraysEXT_remap_index 220
+#define UnlockArraysEXT_remap_index 221
+#define SecondaryColor3bEXT_remap_index 222
+#define SecondaryColor3bvEXT_remap_index 223
+#define SecondaryColor3dEXT_remap_index 224
+#define SecondaryColor3dvEXT_remap_index 225
+#define SecondaryColor3fEXT_remap_index 226
+#define SecondaryColor3fvEXT_remap_index 227
+#define SecondaryColor3iEXT_remap_index 228
+#define SecondaryColor3ivEXT_remap_index 229
+#define SecondaryColor3sEXT_remap_index 230
+#define SecondaryColor3svEXT_remap_index 231
+#define SecondaryColor3ubEXT_remap_index 232
+#define SecondaryColor3ubvEXT_remap_index 233
+#define SecondaryColor3uiEXT_remap_index 234
+#define SecondaryColor3uivEXT_remap_index 235
+#define SecondaryColor3usEXT_remap_index 236
+#define SecondaryColor3usvEXT_remap_index 237
+#define SecondaryColorPointerEXT_remap_index 238
+#define MultiDrawArraysEXT_remap_index 239
+#define MultiDrawElementsEXT_remap_index 240
+#define FogCoordPointerEXT_remap_index 241
+#define FogCoorddEXT_remap_index 242
+#define FogCoorddvEXT_remap_index 243
+#define FogCoordfEXT_remap_index 244
+#define FogCoordfvEXT_remap_index 245
+#define PixelTexGenSGIX_remap_index 246
+#define BlendFuncSeparateEXT_remap_index 247
+#define FlushVertexArrayRangeNV_remap_index 248
+#define VertexArrayRangeNV_remap_index 249
+#define CombinerInputNV_remap_index 250
+#define CombinerOutputNV_remap_index 251
+#define CombinerParameterfNV_remap_index 252
+#define CombinerParameterfvNV_remap_index 253
+#define CombinerParameteriNV_remap_index 254
+#define CombinerParameterivNV_remap_index 255
+#define FinalCombinerInputNV_remap_index 256
+#define GetCombinerInputParameterfvNV_remap_index 257
+#define GetCombinerInputParameterivNV_remap_index 258
+#define GetCombinerOutputParameterfvNV_remap_index 259
+#define GetCombinerOutputParameterivNV_remap_index 260
+#define GetFinalCombinerInputParameterfvNV_remap_index 261
+#define GetFinalCombinerInputParameterivNV_remap_index 262
+#define ResizeBuffersMESA_remap_index 263
+#define WindowPos2dMESA_remap_index 264
+#define WindowPos2dvMESA_remap_index 265
+#define WindowPos2fMESA_remap_index 266
+#define WindowPos2fvMESA_remap_index 267
+#define WindowPos2iMESA_remap_index 268
+#define WindowPos2ivMESA_remap_index 269
+#define WindowPos2sMESA_remap_index 270
+#define WindowPos2svMESA_remap_index 271
+#define WindowPos3dMESA_remap_index 272
+#define WindowPos3dvMESA_remap_index 273
+#define WindowPos3fMESA_remap_index 274
+#define WindowPos3fvMESA_remap_index 275
+#define WindowPos3iMESA_remap_index 276
+#define WindowPos3ivMESA_remap_index 277
+#define WindowPos3sMESA_remap_index 278
+#define WindowPos3svMESA_remap_index 279
+#define WindowPos4dMESA_remap_index 280
+#define WindowPos4dvMESA_remap_index 281
+#define WindowPos4fMESA_remap_index 282
+#define WindowPos4fvMESA_remap_index 283
+#define WindowPos4iMESA_remap_index 284
+#define WindowPos4ivMESA_remap_index 285
+#define WindowPos4sMESA_remap_index 286
+#define WindowPos4svMESA_remap_index 287
+#define MultiModeDrawArraysIBM_remap_index 288
+#define MultiModeDrawElementsIBM_remap_index 289
+#define DeleteFencesNV_remap_index 290
+#define FinishFenceNV_remap_index 291
+#define GenFencesNV_remap_index 292
+#define GetFenceivNV_remap_index 293
+#define IsFenceNV_remap_index 294
+#define SetFenceNV_remap_index 295
+#define TestFenceNV_remap_index 296
+#define AreProgramsResidentNV_remap_index 297
+#define BindProgramNV_remap_index 298
+#define DeleteProgramsNV_remap_index 299
+#define ExecuteProgramNV_remap_index 300
+#define GenProgramsNV_remap_index 301
+#define GetProgramParameterdvNV_remap_index 302
+#define GetProgramParameterfvNV_remap_index 303
+#define GetProgramStringNV_remap_index 304
+#define GetProgramivNV_remap_index 305
+#define GetTrackMatrixivNV_remap_index 306
+#define GetVertexAttribPointervNV_remap_index 307
+#define GetVertexAttribdvNV_remap_index 308
+#define GetVertexAttribfvNV_remap_index 309
+#define GetVertexAttribivNV_remap_index 310
+#define IsProgramNV_remap_index 311
+#define LoadProgramNV_remap_index 312
+#define ProgramParameters4dvNV_remap_index 313
+#define ProgramParameters4fvNV_remap_index 314
+#define RequestResidentProgramsNV_remap_index 315
+#define TrackMatrixNV_remap_index 316
+#define VertexAttrib1dNV_remap_index 317
+#define VertexAttrib1dvNV_remap_index 318
+#define VertexAttrib1fNV_remap_index 319
+#define VertexAttrib1fvNV_remap_index 320
+#define VertexAttrib1sNV_remap_index 321
+#define VertexAttrib1svNV_remap_index 322
+#define VertexAttrib2dNV_remap_index 323
+#define VertexAttrib2dvNV_remap_index 324
+#define VertexAttrib2fNV_remap_index 325
+#define VertexAttrib2fvNV_remap_index 326
+#define VertexAttrib2sNV_remap_index 327
+#define VertexAttrib2svNV_remap_index 328
+#define VertexAttrib3dNV_remap_index 329
+#define VertexAttrib3dvNV_remap_index 330
+#define VertexAttrib3fNV_remap_index 331
+#define VertexAttrib3fvNV_remap_index 332
+#define VertexAttrib3sNV_remap_index 333
+#define VertexAttrib3svNV_remap_index 334
+#define VertexAttrib4dNV_remap_index 335
+#define VertexAttrib4dvNV_remap_index 336
+#define VertexAttrib4fNV_remap_index 337
+#define VertexAttrib4fvNV_remap_index 338
+#define VertexAttrib4sNV_remap_index 339
+#define VertexAttrib4svNV_remap_index 340
+#define VertexAttrib4ubNV_remap_index 341
+#define VertexAttrib4ubvNV_remap_index 342
+#define VertexAttribPointerNV_remap_index 343
+#define VertexAttribs1dvNV_remap_index 344
+#define VertexAttribs1fvNV_remap_index 345
+#define VertexAttribs1svNV_remap_index 346
+#define VertexAttribs2dvNV_remap_index 347
+#define VertexAttribs2fvNV_remap_index 348
+#define VertexAttribs2svNV_remap_index 349
+#define VertexAttribs3dvNV_remap_index 350
+#define VertexAttribs3fvNV_remap_index 351
+#define VertexAttribs3svNV_remap_index 352
+#define VertexAttribs4dvNV_remap_index 353
+#define VertexAttribs4fvNV_remap_index 354
+#define VertexAttribs4svNV_remap_index 355
+#define VertexAttribs4ubvNV_remap_index 356
+#define GetTexBumpParameterfvATI_remap_index 357
+#define GetTexBumpParameterivATI_remap_index 358
+#define TexBumpParameterfvATI_remap_index 359
+#define TexBumpParameterivATI_remap_index 360
+#define AlphaFragmentOp1ATI_remap_index 361
+#define AlphaFragmentOp2ATI_remap_index 362
+#define AlphaFragmentOp3ATI_remap_index 363
+#define BeginFragmentShaderATI_remap_index 364
+#define BindFragmentShaderATI_remap_index 365
+#define ColorFragmentOp1ATI_remap_index 366
+#define ColorFragmentOp2ATI_remap_index 367
+#define ColorFragmentOp3ATI_remap_index 368
+#define DeleteFragmentShaderATI_remap_index 369
+#define EndFragmentShaderATI_remap_index 370
+#define GenFragmentShadersATI_remap_index 371
+#define PassTexCoordATI_remap_index 372
+#define SampleMapATI_remap_index 373
+#define SetFragmentShaderConstantATI_remap_index 374
+#define PointParameteriNV_remap_index 375
+#define PointParameterivNV_remap_index 376
+#define ActiveStencilFaceEXT_remap_index 377
+#define BindVertexArrayAPPLE_remap_index 378
+#define DeleteVertexArraysAPPLE_remap_index 379
+#define GenVertexArraysAPPLE_remap_index 380
+#define IsVertexArrayAPPLE_remap_index 381
+#define GetProgramNamedParameterdvNV_remap_index 382
+#define GetProgramNamedParameterfvNV_remap_index 383
+#define ProgramNamedParameter4dNV_remap_index 384
+#define ProgramNamedParameter4dvNV_remap_index 385
+#define ProgramNamedParameter4fNV_remap_index 386
+#define ProgramNamedParameter4fvNV_remap_index 387
+#define PrimitiveRestartIndexNV_remap_index 388
+#define PrimitiveRestartNV_remap_index 389
+#define DepthBoundsEXT_remap_index 390
+#define BlendEquationSeparateEXT_remap_index 391
+#define BindFramebufferEXT_remap_index 392
+#define BindRenderbufferEXT_remap_index 393
+#define CheckFramebufferStatusEXT_remap_index 394
+#define DeleteFramebuffersEXT_remap_index 395
+#define DeleteRenderbuffersEXT_remap_index 396
+#define FramebufferRenderbufferEXT_remap_index 397
+#define FramebufferTexture1DEXT_remap_index 398
+#define FramebufferTexture2DEXT_remap_index 399
+#define FramebufferTexture3DEXT_remap_index 400
+#define GenFramebuffersEXT_remap_index 401
+#define GenRenderbuffersEXT_remap_index 402
+#define GenerateMipmapEXT_remap_index 403
+#define GetFramebufferAttachmentParameterivEXT_remap_index 404
+#define GetRenderbufferParameterivEXT_remap_index 405
+#define IsFramebufferEXT_remap_index 406
+#define IsRenderbufferEXT_remap_index 407
+#define RenderbufferStorageEXT_remap_index 408
+#define BlitFramebufferEXT_remap_index 409
+#define BufferParameteriAPPLE_remap_index 410
+#define FlushMappedBufferRangeAPPLE_remap_index 411
+#define BindFragDataLocationEXT_remap_index 412
+#define GetFragDataLocationEXT_remap_index 413
+#define GetUniformuivEXT_remap_index 414
+#define GetVertexAttribIivEXT_remap_index 415
+#define GetVertexAttribIuivEXT_remap_index 416
+#define Uniform1uiEXT_remap_index 417
+#define Uniform1uivEXT_remap_index 418
+#define Uniform2uiEXT_remap_index 419
+#define Uniform2uivEXT_remap_index 420
+#define Uniform3uiEXT_remap_index 421
+#define Uniform3uivEXT_remap_index 422
+#define Uniform4uiEXT_remap_index 423
+#define Uniform4uivEXT_remap_index 424
+#define VertexAttribI1iEXT_remap_index 425
+#define VertexAttribI1ivEXT_remap_index 426
+#define VertexAttribI1uiEXT_remap_index 427
+#define VertexAttribI1uivEXT_remap_index 428
+#define VertexAttribI2iEXT_remap_index 429
+#define VertexAttribI2ivEXT_remap_index 430
+#define VertexAttribI2uiEXT_remap_index 431
+#define VertexAttribI2uivEXT_remap_index 432
+#define VertexAttribI3iEXT_remap_index 433
+#define VertexAttribI3ivEXT_remap_index 434
+#define VertexAttribI3uiEXT_remap_index 435
+#define VertexAttribI3uivEXT_remap_index 436
+#define VertexAttribI4bvEXT_remap_index 437
+#define VertexAttribI4iEXT_remap_index 438
+#define VertexAttribI4ivEXT_remap_index 439
+#define VertexAttribI4svEXT_remap_index 440
+#define VertexAttribI4ubvEXT_remap_index 441
+#define VertexAttribI4uiEXT_remap_index 442
+#define VertexAttribI4uivEXT_remap_index 443
+#define VertexAttribI4usvEXT_remap_index 444
+#define VertexAttribIPointerEXT_remap_index 445
+#define FramebufferTextureLayerEXT_remap_index 446
+#define ColorMaskIndexedEXT_remap_index 447
+#define DisableIndexedEXT_remap_index 448
+#define EnableIndexedEXT_remap_index 449
+#define GetBooleanIndexedvEXT_remap_index 450
+#define GetIntegerIndexedvEXT_remap_index 451
+#define IsEnabledIndexedEXT_remap_index 452
+#define ClearColorIiEXT_remap_index 453
+#define ClearColorIuiEXT_remap_index 454
+#define GetTexParameterIivEXT_remap_index 455
+#define GetTexParameterIuivEXT_remap_index 456
+#define TexParameterIivEXT_remap_index 457
+#define TexParameterIuivEXT_remap_index 458
+#define BeginConditionalRenderNV_remap_index 459
+#define EndConditionalRenderNV_remap_index 460
+#define BeginTransformFeedbackEXT_remap_index 461
+#define BindBufferBaseEXT_remap_index 462
+#define BindBufferOffsetEXT_remap_index 463
+#define BindBufferRangeEXT_remap_index 464
+#define EndTransformFeedbackEXT_remap_index 465
+#define GetTransformFeedbackVaryingEXT_remap_index 466
+#define TransformFeedbackVaryingsEXT_remap_index 467
+#define ProvokingVertexEXT_remap_index 468
+#define GetTexParameterPointervAPPLE_remap_index 469
+#define TextureRangeAPPLE_remap_index 470
+#define GetObjectParameterivAPPLE_remap_index 471
+#define ObjectPurgeableAPPLE_remap_index 472
+#define ObjectUnpurgeableAPPLE_remap_index 473
+#define ActiveProgramEXT_remap_index 474
+#define CreateShaderProgramEXT_remap_index 475
+#define UseShaderProgramEXT_remap_index 476
+#define TextureBarrierNV_remap_index 477
+#define StencilFuncSeparateATI_remap_index 478
+#define ProgramEnvParameters4fvEXT_remap_index 479
+#define ProgramLocalParameters4fvEXT_remap_index 480
+#define GetQueryObjecti64vEXT_remap_index 481
+#define GetQueryObjectui64vEXT_remap_index 482
+#define EGLImageTargetRenderbufferStorageOES_remap_index 483
+#define EGLImageTargetTexture2DOES_remap_index 484
 
 #define _gloffset_AttachShader driDispatchRemapTable[AttachShader_remap_index]
 #define _gloffset_CreateProgram driDispatchRemapTable[CreateProgram_remap_index]
@@ -1611,6 +1613,7 @@ extern int driDispatchRemapTable[ driDispatchRemapTable_size ];
 #define _gloffset_GetActiveAttribARB driDispatchRemapTable[GetActiveAttribARB_remap_index]
 #define _gloffset_GetAttribLocationARB driDispatchRemapTable[GetAttribLocationARB_remap_index]
 #define _gloffset_DrawBuffersARB driDispatchRemapTable[DrawBuffersARB_remap_index]
+#define _gloffset_ClampColorARB driDispatchRemapTable[ClampColorARB_remap_index]
 #define _gloffset_DrawArraysInstancedARB driDispatchRemapTable[DrawArraysInstancedARB_remap_index]
 #define _gloffset_DrawElementsInstancedARB driDispatchRemapTable[DrawElementsInstancedARB_remap_index]
 #define _gloffset_RenderbufferStorageMultisample driDispatchRemapTable[RenderbufferStorageMultisample_remap_index]
@@ -3650,6 +3653,9 @@ extern int driDispatchRemapTable[ driDispatchRemapTable_size ];
 #define CALL_DrawBuffersARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLenum *)), _gloffset_DrawBuffersARB, parameters)
 #define GET_DrawBuffersARB(disp) GET_by_offset(disp, _gloffset_DrawBuffersARB)
 #define SET_DrawBuffersARB(disp, fn) SET_by_offset(disp, _gloffset_DrawBuffersARB, fn)
+#define CALL_ClampColorARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum)), _gloffset_ClampColorARB, parameters)
+#define GET_ClampColorARB(disp) GET_by_offset(disp, _gloffset_ClampColorARB)
+#define SET_ClampColorARB(disp, fn) SET_by_offset(disp, _gloffset_ClampColorARB, fn)
 #define CALL_DrawArraysInstancedARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLsizei, GLsizei)), _gloffset_DrawArraysInstancedARB, parameters)
 #define GET_DrawArraysInstancedARB(disp) GET_by_offset(disp, _gloffset_DrawArraysInstancedARB)
 #define SET_DrawArraysInstancedARB(disp, fn) SET_by_offset(disp, _gloffset_DrawArraysInstancedARB, fn)
diff --git a/mesalib/src/mesa/main/image.c b/mesalib/src/mesa/main/image.c
index bbde3800e..28841c251 100644
--- a/mesalib/src/mesa/main/image.c
+++ b/mesalib/src/mesa/main/image.c
@@ -748,9 +748,6 @@ _mesa_is_color_format(GLenum format)
       case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
       case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
       case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
-      /* signed, normalized texture formats */
-      case GL_RGBA_SNORM:
-      case GL_RGBA8_SNORM:
       /* generic integer formats */
       case GL_RED_INTEGER_EXT:
       case GL_GREEN_INTEGER_EXT:
@@ -799,6 +796,31 @@ _mesa_is_color_format(GLenum format)
       case GL_INTENSITY8I_EXT:
       case GL_LUMINANCE8I_EXT:
       case GL_LUMINANCE_ALPHA8I_EXT:
+      /* signed, normalized texture formats */
+      case GL_RED_SNORM:
+      case GL_R8_SNORM:
+      case GL_R16_SNORM:
+      case GL_RG_SNORM:
+      case GL_RG8_SNORM:
+      case GL_RG16_SNORM:
+      case GL_RGB_SNORM:
+      case GL_RGB8_SNORM:
+      case GL_RGB16_SNORM:
+      case GL_RGBA_SNORM:
+      case GL_RGBA8_SNORM:
+      case GL_RGBA16_SNORM:
+      case GL_ALPHA_SNORM:
+      case GL_ALPHA8_SNORM:
+      case GL_ALPHA16_SNORM:
+      case GL_LUMINANCE_SNORM:
+      case GL_LUMINANCE8_SNORM:
+      case GL_LUMINANCE16_SNORM:
+      case GL_LUMINANCE_ALPHA_SNORM:
+      case GL_LUMINANCE8_ALPHA8_SNORM:
+      case GL_LUMINANCE16_ALPHA16_SNORM:
+      case GL_INTENSITY_SNORM:
+      case GL_INTENSITY8_SNORM:
+      case GL_INTENSITY16_SNORM:
          return GL_TRUE;
       case GL_YCBCR_MESA:  /* not considered to be RGB */
          /* fall-through */
diff --git a/mesalib/src/mesa/main/macros.h b/mesalib/src/mesa/main/macros.h
index b2ec0ba9b..86a58cc6b 100644
--- a/mesalib/src/mesa/main/macros.h
+++ b/mesalib/src/mesa/main/macros.h
@@ -58,8 +58,7 @@ extern GLfloat _mesa_ubyte_to_float_color_tab[256];
 #define BYTE_TO_FLOAT_TEX(B)    ((B) == -128 ? -1.0F : (B) * (1.0F/127.0F))
 
 /** Convert GLfloat in [-1.0,1.0] to GLbyte in [-128,127], texture/fb data */
-#define FLOAT_TO_BYTE_TEX(X)    ( (GLint) (127.0F * (X)) )
-
+#define FLOAT_TO_BYTE_TEX(X)    CLAMP( (GLint) (127.0F * (X)), -128, 127 )
 
 /** Convert GLushort in [0,65535] to GLfloat in [0.0,1.0] */
 #define USHORT_TO_FLOAT(S)  ((GLfloat) (S) * (1.0F / 65535.0F))
diff --git a/mesalib/src/mesa/main/mtypes.h b/mesalib/src/mesa/main/mtypes.h
index 39577bb02..02676006a 100644
--- a/mesalib/src/mesa/main/mtypes.h
+++ b/mesalib/src/mesa/main/mtypes.h
@@ -691,7 +691,8 @@ struct gl_accum_attrib
 struct gl_colorbuffer_attrib
 {
    GLuint ClearIndex;			/**< Index to use for glClear */
-   GLclampf ClearColor[4];		/**< Color to use for glClear */
+   GLfloat ClearColorUnclamped[4];              /**< Color to use for glClear*/
+   GLclampf ClearColor[4];               /**< Color to use for glClear */
 
    GLuint IndexMask;			/**< Color index write mask */
    GLubyte ColorMask[MAX_DRAW_BUFFERS][4];/**< Each flag is 0xff or 0x0 */
@@ -704,6 +705,7 @@ struct gl_colorbuffer_attrib
    /*@{*/
    GLboolean AlphaEnabled;		/**< Alpha test enabled flag */
    GLenum AlphaFunc;			/**< Alpha test function */
+   GLfloat AlphaRefUnclamped;
    GLclampf AlphaRef;			/**< Alpha reference value */
    /*@}*/
 
@@ -712,7 +714,14 @@ struct gl_colorbuffer_attrib
     */
    /*@{*/
    GLbitfield BlendEnabled;		/**< Per-buffer blend enable flags */
+
+   /* NOTE: this does _not_ depend on fragment clamping or any other clamping control,
+    * only on the fixed-pointness of the render target.
+    * The query does however depend on fragment color clamping.
+    */
+   GLfloat BlendColorUnclamped[4];               /**< Blending color */
    GLfloat BlendColor[4];		/**< Blending color */
+
    struct
    {
       GLenum SrcRGB;             /**< RGB blend source term */
@@ -741,7 +750,9 @@ struct gl_colorbuffer_attrib
    GLboolean DitherFlag;		/**< Dither enable flag */
 
    GLenum ClampFragmentColor; /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */
+   GLboolean _ClampFragmentColor; /** < with GL_FIXED_ONLY_ARB resolved */
    GLenum ClampReadColor;     /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */
+   GLboolean _ClampReadColor;     /** < with GL_FIXED_ONLY_ARB resolved */
 
    GLboolean sRGBEnabled;	/**< Framebuffer sRGB blending/updating requested */
 };
@@ -840,6 +851,7 @@ struct gl_eval_attrib
 struct gl_fog_attrib
 {
    GLboolean Enabled;		/**< Fog enabled flag */
+   GLfloat ColorUnclamped[4];            /**< Fog color */
    GLfloat Color[4];		/**< Fog color */
    GLfloat Density;		/**< Density >= 0.0 */
    GLfloat Start;		/**< Start distance in eye coords */
@@ -921,6 +933,7 @@ struct gl_light_attrib
    GLbitfield ColorMaterialBitmask;	/**< bitmask formed from Face and Mode */
    GLboolean ColorMaterialEnabled;
    GLenum ClampVertexColor;
+   GLboolean _ClampVertexColor;
 
    struct gl_light EnabledList;         /**< List sentinel */
 
@@ -1396,7 +1409,8 @@ struct gl_texture_unit
    GLbitfield _ReallyEnabled;   /**< 0 or exactly one of TEXTURE_*_BIT flags */
 
    GLenum EnvMode;              /**< GL_MODULATE, GL_DECAL, GL_BLEND, etc. */
-   GLfloat EnvColor[4];
+   GLclampf EnvColor[4];
+   GLfloat EnvColorUnclamped[4];
 
    struct gl_texgen GenS;
    struct gl_texgen GenT;
@@ -2704,6 +2718,7 @@ struct gl_extensions
    GLboolean dummy_false; /* Set false by _mesa_init_extensions(). */
    GLboolean ARB_ES2_compatibility;
    GLboolean ARB_blend_func_extended;
+   GLboolean ARB_color_buffer_float;
    GLboolean ARB_copy_buffer;
    GLboolean ARB_depth_buffer_float;
    GLboolean ARB_depth_clamp;
@@ -2813,6 +2828,7 @@ struct gl_extensions
    GLboolean EXT_texture_lod_bias;
    GLboolean EXT_texture_mirror_clamp;
    GLboolean EXT_texture_shared_exponent;
+   GLboolean EXT_texture_snorm;
    GLboolean EXT_texture_sRGB;
    GLboolean EXT_texture_sRGB_decode;
    GLboolean EXT_texture_swizzle;
@@ -2840,7 +2856,6 @@ struct gl_extensions
    GLboolean MESA_resize_buffers;
    GLboolean MESA_ycbcr_texture;
    GLboolean MESA_texture_array;
-   GLboolean MESA_texture_signed_rgba;
    GLboolean NV_blend_square;
    GLboolean NV_conditional_render;
    GLboolean NV_fragment_program;
@@ -2933,6 +2948,7 @@ struct gl_matrix_stack
 #define _NEW_PROGRAM           (1 << 26)  /**< New program/shader state */
 #define _NEW_PROGRAM_CONSTANTS (1 << 27)
 #define _NEW_BUFFER_OBJECT     (1 << 28)
+#define _NEW_FRAG_CLAMP        (1 << 29)
 #define _NEW_ALL ~0
 /*@}*/
 
diff --git a/mesalib/src/mesa/main/pack.c b/mesalib/src/mesa/main/pack.c
index 6463ddfbd..02154585a 100644
--- a/mesalib/src/mesa/main/pack.c
+++ b/mesalib/src/mesa/main/pack.c
@@ -1,5064 +1,5053 @@
-/*

- * Mesa 3-D graphics library

- *

- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

- * Copyright (C) 2009-2010  VMware, Inc.  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

- * THEA AUTHORS 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.

- */

-

-

-/**

- * \file pack.c

- * Image and pixel span packing and unpacking.

- */

-

-

-#include "glheader.h"

-#include "colormac.h"

-#include "enums.h"

-#include "image.h"

-#include "imports.h"

-#include "mtypes.h"

-#include "pack.h"

-#include "pixeltransfer.h"

-#include "imports.h"

-

-

-/**

- * NOTE:

- * Normally, BYTE_TO_FLOAT(0) returns 0.00392  That causes problems when

- * we later convert the float to a packed integer value (such as for

- * GL_RGB5_A1) because we'll wind up with a non-zero value.

- *

- * We redefine the macros here so zero is handled correctly.

- */

-#undef BYTE_TO_FLOAT

-#define BYTE_TO_FLOAT(B)    ((B) == 0 ? 0.0F : ((2.0F * (B) + 1.0F) * (1.0F/255.0F)))

-

-#undef SHORT_TO_FLOAT

-#define SHORT_TO_FLOAT(S)   ((S) == 0 ? 0.0F : ((2.0F * (S) + 1.0F) * (1.0F/65535.0F)))

-

-

-

-/** Compute ceiling of integer quotient of A divided by B. */

-#define CEILING( A, B )  ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 )

-

-

-/**

- * Flip the 8 bits in each byte of the given array.

- *

- * \param p array.

- * \param n number of bytes.

- *

- * \todo try this trick to flip bytes someday:

- * \code

- *  v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);

- *  v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);

- *  v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f);

- * \endcode

- */

-static void

-flip_bytes( GLubyte *p, GLuint n )

-{

-   GLuint i, a, b;

-   for (i = 0; i < n; i++) {

-      b = (GLuint) p[i];        /* words are often faster than bytes */

-      a = ((b & 0x01) << 7) |

-	  ((b & 0x02) << 5) |

-	  ((b & 0x04) << 3) |

-	  ((b & 0x08) << 1) |

-	  ((b & 0x10) >> 1) |

-	  ((b & 0x20) >> 3) |

-	  ((b & 0x40) >> 5) |

-	  ((b & 0x80) >> 7);

-      p[i] = (GLubyte) a;

-   }

-}

-

-

-

-/*

- * Unpack a 32x32 pixel polygon stipple from user memory using the

- * current pixel unpack settings.

- */

-void

-_mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32],

-                              const struct gl_pixelstore_attrib *unpacking )

-{

-   GLubyte *ptrn = (GLubyte *) _mesa_unpack_bitmap(32, 32, pattern, unpacking);

-   if (ptrn) {

-      /* Convert pattern from GLubytes to GLuints and handle big/little

-       * endian differences

-       */

-      GLubyte *p = ptrn;

-      GLint i;

-      for (i = 0; i < 32; i++) {

-         dest[i] = (p[0] << 24)

-                 | (p[1] << 16)

-                 | (p[2] <<  8)

-                 | (p[3]      );

-         p += 4;

-      }

-      free(ptrn);

-   }

-}

-

-

-/*

- * Pack polygon stipple into user memory given current pixel packing

- * settings.

- */

-void

-_mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest,

-                            const struct gl_pixelstore_attrib *packing )

-{

-   /* Convert pattern from GLuints to GLubytes to handle big/little

-    * endian differences.

-    */

-   GLubyte ptrn[32*4];

-   GLint i;

-   for (i = 0; i < 32; i++) {

-      ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff);

-      ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff);

-      ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff);

-      ptrn[i * 4 + 3] = (GLubyte) ((pattern[i]      ) & 0xff);

-   }

-

-   _mesa_pack_bitmap(32, 32, ptrn, dest, packing);

-}

-

-

-/*

- * Unpack bitmap data.  Resulting data will be in most-significant-bit-first

- * order with row alignment = 1 byte.

- */

-GLvoid *

-_mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,

-                     const struct gl_pixelstore_attrib *packing )

-{

-   GLint bytes, row, width_in_bytes;

-   GLubyte *buffer, *dst;

-

-   if (!pixels)

-      return NULL;

-

-   /* Alloc dest storage */

-   bytes = ((width + 7) / 8 * height);

-   buffer = (GLubyte *) malloc( bytes );

-   if (!buffer)

-      return NULL;

-

-   width_in_bytes = CEILING( width, 8 );

-   dst = buffer;

-   for (row = 0; row < height; row++) {

-      const GLubyte *src = (const GLubyte *)

-         _mesa_image_address2d(packing, pixels, width, height,

-                               GL_COLOR_INDEX, GL_BITMAP, row, 0);

-      if (!src) {

-         free(buffer);

-         return NULL;

-      }

-

-      if ((packing->SkipPixels & 7) == 0) {

-         memcpy( dst, src, width_in_bytes );

-         if (packing->LsbFirst) {

-            flip_bytes( dst, width_in_bytes );

-         }

-      }

-      else {

-         /* handling SkipPixels is a bit tricky (no pun intended!) */

-         GLint i;

-         if (packing->LsbFirst) {

-            GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);

-            GLubyte dstMask = 128;

-            const GLubyte *s = src;

-            GLubyte *d = dst;

-            *d = 0;

-            for (i = 0; i < width; i++) {

-               if (*s & srcMask) {

-                  *d |= dstMask;

-               }

-               if (srcMask == 128) {

-                  srcMask = 1;

-                  s++;

-               }

-               else {

-                  srcMask = srcMask << 1;

-               }

-               if (dstMask == 1) {

-                  dstMask = 128;

-                  d++;

-                  *d = 0;

-               }

-               else {

-                  dstMask = dstMask >> 1;

-               }

-            }

-         }

-         else {

-            GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);

-            GLubyte dstMask = 128;

-            const GLubyte *s = src;

-            GLubyte *d = dst;

-            *d = 0;

-            for (i = 0; i < width; i++) {

-               if (*s & srcMask) {

-                  *d |= dstMask;

-               }

-               if (srcMask == 1) {

-                  srcMask = 128;

-                  s++;

-               }

-               else {

-                  srcMask = srcMask >> 1;

-               }

-               if (dstMask == 1) {

-                  dstMask = 128;

-                  d++;

-                  *d = 0;

-               }

-               else {

-                  dstMask = dstMask >> 1;

-               }

-            }

-         }

-      }

-      dst += width_in_bytes;

-   }

-

-   return buffer;

-}

-

-

-/*

- * Pack bitmap data.

- */

-void

-_mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,

-                   GLubyte *dest, const struct gl_pixelstore_attrib *packing )

-{

-   GLint row, width_in_bytes;

-   const GLubyte *src;

-

-   if (!source)

-      return;

-

-   width_in_bytes = CEILING( width, 8 );

-   src = source;

-   for (row = 0; row < height; row++) {

-      GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, dest,

-                       width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);

-      if (!dst)

-         return;

-

-      if ((packing->SkipPixels & 7) == 0) {

-         memcpy( dst, src, width_in_bytes );

-         if (packing->LsbFirst) {

-            flip_bytes( dst, width_in_bytes );

-         }

-      }

-      else {

-         /* handling SkipPixels is a bit tricky (no pun intended!) */

-         GLint i;

-         if (packing->LsbFirst) {

-            GLubyte srcMask = 128;

-            GLubyte dstMask = 1 << (packing->SkipPixels & 0x7);

-            const GLubyte *s = src;

-            GLubyte *d = dst;

-            *d = 0;

-            for (i = 0; i < width; i++) {

-               if (*s & srcMask) {

-                  *d |= dstMask;

-               }

-               if (srcMask == 1) {

-                  srcMask = 128;

-                  s++;

-               }

-               else {

-                  srcMask = srcMask >> 1;

-               }

-               if (dstMask == 128) {

-                  dstMask = 1;

-                  d++;

-                  *d = 0;

-               }

-               else {

-                  dstMask = dstMask << 1;

-               }

-            }

-         }

-         else {

-            GLubyte srcMask = 128;

-            GLubyte dstMask = 128 >> (packing->SkipPixels & 0x7);

-            const GLubyte *s = src;

-            GLubyte *d = dst;

-            *d = 0;

-            for (i = 0; i < width; i++) {

-               if (*s & srcMask) {

-                  *d |= dstMask;

-               }

-               if (srcMask == 1) {

-                  srcMask = 128;

-                  s++;

-               }

-               else {

-                  srcMask = srcMask >> 1;

-               }

-               if (dstMask == 1) {

-                  dstMask = 128;

-                  d++;

-                  *d = 0;

-               }

-               else {

-                  dstMask = dstMask >> 1;

-               }

-            }

-         }

-      }

-      src += width_in_bytes;

-   }

-}

-

-

-/**

- * Get indexes of color components for a basic color format, such as

- * GL_RGBA, GL_RED, GL_LUMINANCE_ALPHA, etc.  Return -1 for indexes

- * that do not apply.

- */

-static void

-get_component_indexes(GLenum format,

-                      GLint *redIndex,

-                      GLint *greenIndex,

-                      GLint *blueIndex,

-                      GLint *alphaIndex,

-                      GLint *luminanceIndex,

-                      GLint *intensityIndex)

-{

-   *redIndex = -1;

-   *greenIndex = -1;

-   *blueIndex = -1;

-   *alphaIndex = -1;

-   *luminanceIndex = -1;

-   *intensityIndex = -1;

-

-   switch (format) {

-   case GL_LUMINANCE:

-   case GL_LUMINANCE_INTEGER_EXT:

-      *luminanceIndex = 0;

-      break;

-   case GL_LUMINANCE_ALPHA:

-   case GL_LUMINANCE_ALPHA_INTEGER_EXT:

-      *luminanceIndex = 0;

-      *alphaIndex = 1;

-      break;

-   case GL_INTENSITY:

-      *intensityIndex = 0;

-      break;

-   case GL_RED:

-   case GL_RED_INTEGER_EXT:

-      *redIndex = 0;

-      break;

-   case GL_GREEN:

-   case GL_GREEN_INTEGER_EXT:

-      *greenIndex = 0;

-      break;

-   case GL_BLUE:

-   case GL_BLUE_INTEGER_EXT:

-      *blueIndex = 0;

-      break;

-   case GL_ALPHA:

-   case GL_ALPHA_INTEGER_EXT:

-      *alphaIndex = 0;

-      break;

-   case GL_RG:

-   case GL_RG_INTEGER:

-      *redIndex = 0;

-      *greenIndex = 1;

-      break;

-   case GL_RGB:

-   case GL_RGB_INTEGER_EXT:

-      *redIndex = 0;

-      *greenIndex = 1;

-      *blueIndex = 2;

-      break;

-   case GL_BGR:

-   case GL_BGR_INTEGER_EXT:

-      *blueIndex = 0;

-      *greenIndex = 1;

-      *redIndex = 2;

-      break;

-   case GL_RGBA:

-   case GL_RGBA_INTEGER_EXT:

-      *redIndex = 0;

-      *greenIndex = 1;

-      *blueIndex = 2;

-      *alphaIndex = 3;

-      break;

-   case GL_BGRA:

-   case GL_BGRA_INTEGER:

-      *redIndex = 2;

-      *greenIndex = 1;

-      *blueIndex = 0;

-      *alphaIndex = 3;

-      break;

-   case GL_ABGR_EXT:

-      *redIndex = 3;

-      *greenIndex = 2;

-      *blueIndex = 1;

-      *alphaIndex = 0;

-      break;

-   case GL_DU8DV8_ATI:

-   case GL_DUDV_ATI:

-      *redIndex = 0;

-      *greenIndex = 1;

-      break;

-   default:

-      assert(0 && "bad format in get_component_indexes()");

-   }

-}

-

-

-

-/**

- * For small integer types, return the min and max possible values.

- * Used for clamping floats to unscaled integer types.

- * \return GL_TRUE if type is handled, GL_FALSE otherwise.

- */

-static GLboolean

-get_type_min_max(GLenum type, GLfloat *min, GLfloat *max)

-{

-   switch (type) {

-   case GL_BYTE:

-      *min = -128.0;

-      *max = 127.0;

-      return GL_TRUE;

-   case GL_UNSIGNED_BYTE:

-      *min = 0.0;

-      *max = 255.0;

-      return GL_TRUE;

-   case GL_SHORT:

-      *min = -32768.0;

-      *max = 32767.0;

-      return GL_TRUE;

-   case GL_UNSIGNED_SHORT:

-      *min = 0.0;

-      *max = 65535.0;

-      return GL_TRUE;

-   default:

-      return GL_FALSE;

-   }

-}

-

-

-

-/**

- * Used to pack an array [][4] of RGBA float colors as specified

- * by the dstFormat, dstType and dstPacking.  Used by glReadPixels.

- * Historically, the RGBA values were in [0,1] and rescaled to fit

- * into GLubytes, etc.  But with new integer formats, the RGBA values

- * may have any value and we don't always rescale when converting to

- * integers.

- *

- * Note: the rgba values will be modified by this function when any pixel

- * transfer ops are enabled.

- */

-void

-_mesa_pack_rgba_span_float(struct gl_context *ctx, GLuint n, GLfloat rgba[][4],

-                           GLenum dstFormat, GLenum dstType,

-                           GLvoid *dstAddr,

-                           const struct gl_pixelstore_attrib *dstPacking,

-                           GLbitfield transferOps)

-{

-   GLfloat *luminance;

-   const GLint comps = _mesa_components_in_format(dstFormat);

-   const GLboolean intDstFormat = _mesa_is_integer_format(dstFormat);

-   GLuint i;

-

-   if (dstFormat == GL_LUMINANCE ||

-       dstFormat == GL_LUMINANCE_ALPHA ||

-       dstFormat == GL_LUMINANCE_INTEGER_EXT ||

-       dstFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT) {

-      luminance = (GLfloat *) malloc(n * sizeof(GLfloat));

-      if (!luminance) {

-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");

-         return;

-      }

-   }

-   else {

-      luminance = NULL;

-   }

-

-   /* XXX

-    * This test should probably go away.  Have the caller set/clear the

-    * IMAGE_CLAMP_BIT as needed.

-    */

-   if (dstType != GL_FLOAT || ctx->Color.ClampReadColor == GL_TRUE) {

-      if (!intDstFormat) {

-         /* need to clamp to [0, 1] */

-         transferOps |= IMAGE_CLAMP_BIT;

-      }

-   }

-

-   if (transferOps) {

-      _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);

-   }

-

-   /*

-    * Component clamping (besides clamping to [0,1] in

-    * _mesa_apply_rgba_transfer_ops()).

-    */

-   if (intDstFormat) {

-      /* clamping to dest type's min/max values */

-      GLfloat min, max;

-      if (get_type_min_max(dstType, &min, &max)) {

-         for (i = 0; i < n; i++) {

-            rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], min, max);

-            rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], min, max);

-            rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], min, max);

-            rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], min, max);

-         }

-      }

-   }

-   else if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) {

-      /* compute luminance values */

-      if (transferOps & IMAGE_CLAMP_BIT) {

-         for (i = 0; i < n; i++) {

-            GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];

-            luminance[i] = CLAMP(sum, 0.0F, 1.0F);

-         }

-      }

-      else {

-         for (i = 0; i < n; i++) {

-            luminance[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];

-         }

-      }

-   }

-

-   /*

-    * Pack/store the pixels.  Ugh!  Lots of cases!!!

-    */

-   switch (dstType) {

-      case GL_UNSIGNED_BYTE:

-         {

-            GLubyte *dst = (GLubyte *) dstAddr;

-            switch (dstFormat) {

-               case GL_RED:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);

-                  break;

-               case GL_GREEN:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);

-                  break;

-               case GL_BLUE:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);

-                  break;

-               case GL_ALPHA:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);

-                  break;

-               case GL_LUMINANCE:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_UBYTE(luminance[i]);

-                  break;

-               case GL_LUMINANCE_ALPHA:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]);

-                     dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);

-                  }

-                  break;

-               case GL_RG:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);

-                     dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);

-                  }

-                  break;

-               case GL_RGB:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);

-                     dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);

-                     dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);

-                  }

-                  break;

-               case GL_RGBA:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);

-                     dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);

-                     dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);

-                     dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);

-                  }

-                  break;

-               case GL_BGR:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);

-                     dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);

-                     dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);

-                  }

-                  break;

-               case GL_BGRA:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);

-                     dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);

-                     dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);

-                     dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);

-                  }

-                  break;

-               case GL_ABGR_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);

-                     dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);

-                     dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);

-                     dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);

-                  }

-                  break;

-               case GL_RED_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLubyte) rgba[i][RCOMP];

-                  }

-                  break;

-               case GL_GREEN_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLubyte) rgba[i][GCOMP];

-                  }

-                  break;

-               case GL_BLUE_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLubyte) rgba[i][BCOMP];

-                  }

-                  break;

-               case GL_ALPHA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLubyte) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_RGB_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = (GLubyte) rgba[i][RCOMP];

-                     dst[i*3+1] = (GLubyte) rgba[i][GCOMP];

-                     dst[i*3+2] = (GLubyte) rgba[i][BCOMP];

-                  }

-                  break;

-               case GL_RGBA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = (GLubyte) rgba[i][RCOMP];

-                     dst[i*4+1] = (GLubyte) rgba[i][GCOMP];

-                     dst[i*4+2] = (GLubyte) rgba[i][BCOMP];

-                     dst[i*4+3] = (GLubyte) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_BGR_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = (GLubyte) rgba[i][BCOMP];

-                     dst[i*3+1] = (GLubyte) rgba[i][GCOMP];

-                     dst[i*3+2] = (GLubyte) rgba[i][RCOMP];

-                  }

-                  break;

-               case GL_BGRA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = (GLubyte) rgba[i][BCOMP];

-                     dst[i*4+1] = (GLubyte) rgba[i][GCOMP];

-                     dst[i*4+2] = (GLubyte) rgba[i][RCOMP];

-                     dst[i*4+3] = (GLubyte) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_LUMINANCE_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = (GLubyte) (rgba[i][RCOMP] +

-                                             rgba[i][GCOMP] +

-                                             rgba[i][BCOMP]);

-                     dst[i*2+1] = (GLubyte) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_LUMINANCE_ALPHA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLubyte) (rgba[i][RCOMP] +

-                                         rgba[i][GCOMP] +

-                                         rgba[i][BCOMP]);

-                  }

-                  break;

-               case GL_DUDV_ATI:

-               case GL_DU8DV8_ATI:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);

-                     dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);

-                  }

-                  break;

-               default:

-                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");

-            }

-         }

-         break;

-      case GL_BYTE:

-         {

-            GLbyte *dst = (GLbyte *) dstAddr;

-            switch (dstFormat) {

-               case GL_RED:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_BYTE(rgba[i][RCOMP]);

-                  break;

-               case GL_GREEN:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_BYTE(rgba[i][GCOMP]);

-                  break;

-               case GL_BLUE:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_BYTE(rgba[i][BCOMP]);

-                  break;

-               case GL_ALPHA:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_BYTE(rgba[i][ACOMP]);

-                  break;

-               case GL_LUMINANCE:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_BYTE(luminance[i]);

-                  break;

-               case GL_LUMINANCE_ALPHA:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]);

-                     dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][ACOMP]);

-                  }

-                  break;

-               case GL_RG:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);

-                     dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);

-                  }

-                  break;

-               case GL_RGB:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);

-                     dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);

-                     dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);

-                  }

-                  break;

-               case GL_RGBA:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);

-                     dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);

-                     dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);

-                     dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);

-                  }

-                  break;

-               case GL_BGR:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);

-                     dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);

-                     dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);

-                  }

-                  break;

-               case GL_BGRA:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);

-                     dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);

-                     dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);

-                     dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);

-                  }

-		  break;

-               case GL_ABGR_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][ACOMP]);

-                     dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][BCOMP]);

-                     dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][GCOMP]);

-                     dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]);

-                  }

-                  break;

-               case GL_RED_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLbyte) rgba[i][RCOMP];

-                  }

-                  break;

-               case GL_GREEN_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLbyte) rgba[i][GCOMP];

-                  }

-                  break;

-               case GL_BLUE_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLbyte) rgba[i][BCOMP];

-                  }

-                  break;

-               case GL_ALPHA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLbyte) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_RGB_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = (GLbyte) rgba[i][RCOMP];

-                     dst[i*3+1] = (GLbyte) rgba[i][GCOMP];

-                     dst[i*3+2] = (GLbyte) rgba[i][BCOMP];

-                  }

-                  break;

-               case GL_RGBA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = (GLbyte) rgba[i][RCOMP];

-                     dst[i*4+1] = (GLbyte) rgba[i][GCOMP];

-                     dst[i*4+2] = (GLbyte) rgba[i][BCOMP];

-                     dst[i*4+3] = (GLbyte) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_BGR_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = (GLbyte) rgba[i][BCOMP];

-                     dst[i*3+1] = (GLbyte) rgba[i][GCOMP];

-                     dst[i*3+2] = (GLbyte) rgba[i][RCOMP];

-                  }

-                  break;

-               case GL_BGRA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = (GLbyte) rgba[i][BCOMP];

-                     dst[i*4+1] = (GLbyte) rgba[i][GCOMP];

-                     dst[i*4+2] = (GLbyte) rgba[i][RCOMP];

-                     dst[i*4+3] = (GLbyte) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_LUMINANCE_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = (GLbyte) (rgba[i][RCOMP] +

-                                            rgba[i][GCOMP] +

-                                            rgba[i][BCOMP]);

-                     dst[i*2+1] = (GLbyte) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_LUMINANCE_ALPHA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLbyte) (rgba[i][RCOMP] +

-                                        rgba[i][GCOMP] +

-                                        rgba[i][BCOMP]);

-                  }

-                  break;

-               case GL_DUDV_ATI:

-               case GL_DU8DV8_ATI:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);

-                     dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);

-                  }

-                  break;

-               default:

-                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");

-            }

-         }

-         break;

-      case GL_UNSIGNED_SHORT:

-         {

-            GLushort *dst = (GLushort *) dstAddr;

-            switch (dstFormat) {

-               case GL_RED:

-                  for (i=0;i<n;i++)

-                     CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][RCOMP]);

-                  break;

-               case GL_GREEN:

-                  for (i=0;i<n;i++)

-                     CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][GCOMP]);

-                  break;

-               case GL_BLUE:

-                  for (i=0;i<n;i++)

-                     CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][BCOMP]);

-                  break;

-               case GL_ALPHA:

-                  for (i=0;i<n;i++)

-                     CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][ACOMP]);

-                  break;

-               case GL_LUMINANCE:

-                  for (i=0;i<n;i++)

-                     UNCLAMPED_FLOAT_TO_USHORT(dst[i], luminance[i]);

-                  break;

-               case GL_LUMINANCE_ALPHA:

-                  for (i=0;i<n;i++) {

-                     UNCLAMPED_FLOAT_TO_USHORT(dst[i*2+0], luminance[i]);

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][ACOMP]);

-                  }

-                  break;

-               case GL_RG:

-                  for (i=0;i<n;i++) {

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*2+0], rgba[i][RCOMP]);

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][GCOMP]);

-                  }

-                  break;

-               case GL_RGB:

-                  for (i=0;i<n;i++) {

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][RCOMP]);

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][BCOMP]);

-                  }

-                  break;

-               case GL_RGBA:

-                  for (i=0;i<n;i++) {

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][RCOMP]);

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][BCOMP]);

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);

-                  }

-                  break;

-               case GL_BGR:

-                  for (i=0;i<n;i++) {

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][BCOMP]);

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][RCOMP]);

-                  }

-                  break;

-               case GL_BGRA:

-                  for (i=0;i<n;i++) {

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][BCOMP]);

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][RCOMP]);

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);

-                  }

-                  break;

-               case GL_ABGR_EXT:

-                  for (i=0;i<n;i++) {

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][ACOMP]);

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][BCOMP]);

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][GCOMP]);

-                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][RCOMP]);

-                  }

-                  break;

-               case GL_RED_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLushort) rgba[i][RCOMP];

-                  }

-                  break;

-               case GL_GREEN_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLushort) rgba[i][GCOMP];

-                  }

-                  break;

-               case GL_BLUE_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLushort) rgba[i][BCOMP];

-                  }

-                  break;

-               case GL_ALPHA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLushort) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_RGB_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = (GLushort) rgba[i][RCOMP];

-                     dst[i*3+1] = (GLushort) rgba[i][GCOMP];

-                     dst[i*3+2] = (GLushort) rgba[i][BCOMP];

-                  }

-                  break;

-               case GL_RGBA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = (GLushort) rgba[i][RCOMP];

-                     dst[i*4+1] = (GLushort) rgba[i][GCOMP];

-                     dst[i*4+2] = (GLushort) rgba[i][BCOMP];

-                     dst[i*4+3] = (GLushort) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_BGR_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = (GLushort) rgba[i][BCOMP];

-                     dst[i*3+1] = (GLushort) rgba[i][GCOMP];

-                     dst[i*3+2] = (GLushort) rgba[i][RCOMP];

-                  }

-                  break;

-               case GL_BGRA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = (GLushort) rgba[i][BCOMP];

-                     dst[i*4+1] = (GLushort) rgba[i][GCOMP];

-                     dst[i*4+2] = (GLushort) rgba[i][RCOMP];

-                     dst[i*4+3] = (GLushort) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_LUMINANCE_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = (GLushort) (rgba[i][RCOMP] +

-                                              rgba[i][GCOMP] +

-                                              rgba[i][BCOMP]);

-                     dst[i*2+1] = (GLushort) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_LUMINANCE_ALPHA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLushort) (rgba[i][RCOMP] +

-                                          rgba[i][GCOMP] +

-                                          rgba[i][BCOMP]);

-                  }

-                  break;

-               case GL_DUDV_ATI:

-               case GL_DU8DV8_ATI:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]);

-                     dst[i*2+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);

-                  }

-                  break;

-               default:

-                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");

-            }

-         }

-         break;

-      case GL_SHORT:

-         {

-            GLshort *dst = (GLshort *) dstAddr;

-            switch (dstFormat) {

-               case GL_RED:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_SHORT(rgba[i][RCOMP]);

-                  break;

-               case GL_GREEN:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_SHORT(rgba[i][GCOMP]);

-                  break;

-               case GL_BLUE:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_SHORT(rgba[i][BCOMP]);

-                  break;

-               case GL_ALPHA:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_SHORT(rgba[i][ACOMP]);

-                  break;

-               case GL_LUMINANCE:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_SHORT(luminance[i]);

-                  break;

-               case GL_LUMINANCE_ALPHA:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]);

-                     dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][ACOMP]);

-                  }

-                  break;

-               case GL_RG:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);

-                     dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);

-                  }

-                  break;

-               case GL_RGB:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);

-                     dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);

-                     dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);

-                  }

-                  break;

-               case GL_RGBA:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);

-                     dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);

-                     dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);

-                     dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);

-                  }

-                  break;

-               case GL_BGR:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);

-                     dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);

-                     dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);

-                  }

-                  break;

-               case GL_BGRA:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);

-                     dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);

-                     dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);

-                     dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);

-                  }

-		  break;

-               case GL_ABGR_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][ACOMP]);

-                     dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][BCOMP]);

-                     dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][GCOMP]);

-                     dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]);

-                  }

-                  break;

-               case GL_RED_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLshort) rgba[i][RCOMP];

-                  }

-                  break;

-               case GL_GREEN_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLshort) rgba[i][GCOMP];

-                  }

-                  break;

-               case GL_BLUE_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLshort) rgba[i][BCOMP];

-                  }

-                  break;

-               case GL_ALPHA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLshort) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_RGB_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = (GLshort) rgba[i][RCOMP];

-                     dst[i*3+1] = (GLshort) rgba[i][GCOMP];

-                     dst[i*3+2] = (GLshort) rgba[i][BCOMP];

-                  }

-                  break;

-               case GL_RGBA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = (GLshort) rgba[i][RCOMP];

-                     dst[i*4+1] = (GLshort) rgba[i][GCOMP];

-                     dst[i*4+2] = (GLshort) rgba[i][BCOMP];

-                     dst[i*4+3] = (GLshort) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_BGR_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = (GLshort) rgba[i][BCOMP];

-                     dst[i*3+1] = (GLshort) rgba[i][GCOMP];

-                     dst[i*3+2] = (GLshort) rgba[i][RCOMP];

-                  }

-                  break;

-               case GL_BGRA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = (GLshort) rgba[i][BCOMP];

-                     dst[i*4+1] = (GLshort) rgba[i][GCOMP];

-                     dst[i*4+2] = (GLshort) rgba[i][RCOMP];

-                     dst[i*4+3] = (GLshort) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_LUMINANCE_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = (GLshort) (rgba[i][RCOMP] +

-                                             rgba[i][GCOMP] +

-                                             rgba[i][BCOMP]);

-                     dst[i*2+1] = (GLshort) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_LUMINANCE_ALPHA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLshort) (rgba[i][RCOMP] +

-                                         rgba[i][GCOMP] +

-                                         rgba[i][BCOMP]);

-                  }

-                  break;

-               case GL_DUDV_ATI:

-               case GL_DU8DV8_ATI:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);

-                     dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);

-                  }

-                  break;

-               default:

-                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");

-            }

-         }

-         break;

-      case GL_UNSIGNED_INT:

-         {

-            GLuint *dst = (GLuint *) dstAddr;

-            switch (dstFormat) {

-               case GL_RED:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]);

-                  break;

-               case GL_GREEN:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]);

-                  break;

-               case GL_BLUE:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]);

-                  break;

-               case GL_ALPHA:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]);

-                  break;

-               case GL_LUMINANCE:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_UINT(luminance[i]);

-                  break;

-               case GL_LUMINANCE_ALPHA:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = FLOAT_TO_UINT(luminance[i]);

-                     dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]);

-                  }

-                  break;

-               case GL_RG:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);

-                     dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);

-                  }

-                  break;

-               case GL_RGB:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);

-                     dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);

-                     dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);

-                  }

-                  break;

-               case GL_RGBA:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);

-                     dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);

-                     dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);

-                     dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);

-                  }

-                  break;

-               case GL_BGR:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);

-                     dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);

-                     dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);

-                  }

-                  break;

-               case GL_BGRA:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);

-                     dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);

-                     dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);

-                     dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);

-                  }

-                  break;

-               case GL_ABGR_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]);

-                     dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]);

-                     dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]);

-                     dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]);

-                  }

-                  break;

-               case GL_RED_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLuint) rgba[i][RCOMP];

-                  }

-                  break;

-               case GL_GREEN_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLuint) rgba[i][GCOMP];

-                  }

-                  break;

-               case GL_BLUE_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLuint) rgba[i][BCOMP];

-                  }

-                  break;

-               case GL_ALPHA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLuint) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_RGB_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = (GLuint) rgba[i][RCOMP];

-                     dst[i*3+1] = (GLuint) rgba[i][GCOMP];

-                     dst[i*3+2] = (GLuint) rgba[i][BCOMP];

-                  }

-                  break;

-               case GL_RGBA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = (GLuint) rgba[i][RCOMP];

-                     dst[i*4+1] = (GLuint) rgba[i][GCOMP];

-                     dst[i*4+2] = (GLuint) rgba[i][BCOMP];

-                     dst[i*4+3] = (GLuint) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_BGR_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = (GLuint) rgba[i][BCOMP];

-                     dst[i*3+1] = (GLuint) rgba[i][GCOMP];

-                     dst[i*3+2] = (GLuint) rgba[i][RCOMP];

-                  }

-                  break;

-               case GL_BGRA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = (GLuint) rgba[i][BCOMP];

-                     dst[i*4+1] = (GLuint) rgba[i][GCOMP];

-                     dst[i*4+2] = (GLuint) rgba[i][RCOMP];

-                     dst[i*4+3] = (GLuint) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_LUMINANCE_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = (GLuint) (rgba[i][RCOMP] +

-                                            rgba[i][GCOMP] +

-                                            rgba[i][BCOMP]);

-                     dst[i*2+1] = (GLuint) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_LUMINANCE_ALPHA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLuint) (rgba[i][RCOMP] +

-                                        rgba[i][GCOMP] +

-                                        rgba[i][BCOMP]);

-                  }

-                  break;

-               case GL_DUDV_ATI:

-               case GL_DU8DV8_ATI:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);

-                     dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);

-                  }

-                  break;

-               default:

-                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");

-            }

-         }

-         break;

-      case GL_INT:

-         {

-            GLint *dst = (GLint *) dstAddr;

-            switch (dstFormat) {

-               case GL_RED:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]);

-                  break;

-               case GL_GREEN:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]);

-                  break;

-               case GL_BLUE:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]);

-                  break;

-               case GL_ALPHA:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]);

-                  break;

-               case GL_LUMINANCE:

-                  for (i=0;i<n;i++)

-                     dst[i] = FLOAT_TO_INT(luminance[i]);

-                  break;

-               case GL_LUMINANCE_ALPHA:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = FLOAT_TO_INT(luminance[i]);

-                     dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]);

-                  }

-                  break;

-               case GL_RG:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);

-                     dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);

-                  }

-                  break;

-               case GL_RGB:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]);

-                     dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);

-                     dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]);

-                  }

-                  break;

-               case GL_RGBA:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]);

-                     dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);

-                     dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]);

-                     dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);

-                  }

-                  break;

-               case GL_BGR:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]);

-                     dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);

-                     dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]);

-                  }

-                  break;

-               case GL_BGRA:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]);

-                     dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);

-                     dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]);

-                     dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);

-                  }

-                  break;

-               case GL_ABGR_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]);

-                     dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]);

-                     dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]);

-                     dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]);

-                  }

-                  break;

-               case GL_DUDV_ATI:

-               case GL_DU8DV8_ATI:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);

-                     dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);

-                  }

-                  break;

-               case GL_RED_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLint) rgba[i][RCOMP];

-                  }

-                  break;

-               case GL_GREEN_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLint) rgba[i][GCOMP];

-                  }

-                  break;

-               case GL_BLUE_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLint) rgba[i][BCOMP];

-                  }

-                  break;

-               case GL_ALPHA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLint) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_RGB_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = (GLint) rgba[i][RCOMP];

-                     dst[i*3+1] = (GLint) rgba[i][GCOMP];

-                     dst[i*3+2] = (GLint) rgba[i][BCOMP];

-                  }

-                  break;

-               case GL_RGBA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = (GLint) rgba[i][RCOMP];

-                     dst[i*4+1] = (GLint) rgba[i][GCOMP];

-                     dst[i*4+2] = (GLint) rgba[i][BCOMP];

-                     dst[i*4+3] = (GLint) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_BGR_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = (GLint) rgba[i][BCOMP];

-                     dst[i*3+1] = (GLint) rgba[i][GCOMP];

-                     dst[i*3+2] = (GLint) rgba[i][RCOMP];

-                  }

-                  break;

-               case GL_BGRA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = (GLint) rgba[i][BCOMP];

-                     dst[i*4+1] = (GLint) rgba[i][GCOMP];

-                     dst[i*4+2] = (GLint) rgba[i][RCOMP];

-                     dst[i*4+3] = (GLint) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_LUMINANCE_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = (GLint) (rgba[i][RCOMP] +

-                                           rgba[i][GCOMP] +

-                                           rgba[i][BCOMP]);

-                     dst[i*2+1] = (GLint) rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_LUMINANCE_ALPHA_INTEGER_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i] = (GLint) (rgba[i][RCOMP] +

-                                       rgba[i][GCOMP] +

-                                       rgba[i][BCOMP]);

-                  }

-                  break;

-               default:

-                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");

-            }

-         }

-         break;

-      case GL_FLOAT:

-         {

-            GLfloat *dst = (GLfloat *) dstAddr;

-            switch (dstFormat) {

-               case GL_RED:

-                  for (i=0;i<n;i++)

-                     dst[i] = rgba[i][RCOMP];

-                  break;

-               case GL_GREEN:

-                  for (i=0;i<n;i++)

-                     dst[i] = rgba[i][GCOMP];

-                  break;

-               case GL_BLUE:

-                  for (i=0;i<n;i++)

-                     dst[i] = rgba[i][BCOMP];

-                  break;

-               case GL_ALPHA:

-                  for (i=0;i<n;i++)

-                     dst[i] = rgba[i][ACOMP];

-                  break;

-               case GL_LUMINANCE:

-                  for (i=0;i<n;i++)

-                     dst[i] = luminance[i];

-                  break;

-               case GL_LUMINANCE_ALPHA:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = luminance[i];

-                     dst[i*2+1] = rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_RG:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = rgba[i][RCOMP];

-                     dst[i*2+1] = rgba[i][GCOMP];

-                  }

-                  break;

-               case GL_RGB:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = rgba[i][RCOMP];

-                     dst[i*3+1] = rgba[i][GCOMP];

-                     dst[i*3+2] = rgba[i][BCOMP];

-                  }

-                  break;

-               case GL_RGBA:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = rgba[i][RCOMP];

-                     dst[i*4+1] = rgba[i][GCOMP];

-                     dst[i*4+2] = rgba[i][BCOMP];

-                     dst[i*4+3] = rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_BGR:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = rgba[i][BCOMP];

-                     dst[i*3+1] = rgba[i][GCOMP];

-                     dst[i*3+2] = rgba[i][RCOMP];

-                  }

-                  break;

-               case GL_BGRA:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = rgba[i][BCOMP];

-                     dst[i*4+1] = rgba[i][GCOMP];

-                     dst[i*4+2] = rgba[i][RCOMP];

-                     dst[i*4+3] = rgba[i][ACOMP];

-                  }

-                  break;

-               case GL_ABGR_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = rgba[i][ACOMP];

-                     dst[i*4+1] = rgba[i][BCOMP];

-                     dst[i*4+2] = rgba[i][GCOMP];

-                     dst[i*4+3] = rgba[i][RCOMP];

-                  }

-                  break;

-               case GL_DUDV_ATI:

-               case GL_DU8DV8_ATI:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = rgba[i][RCOMP];

-                     dst[i*2+1] = rgba[i][GCOMP];

-                  }

-                  break;

-               default:

-                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");

-            }

-         }

-         break;

-      case GL_HALF_FLOAT_ARB:

-         {

-            GLhalfARB *dst = (GLhalfARB *) dstAddr;

-            switch (dstFormat) {

-               case GL_RED:

-                  for (i=0;i<n;i++)

-                     dst[i] = _mesa_float_to_half(rgba[i][RCOMP]);

-                  break;

-               case GL_GREEN:

-                  for (i=0;i<n;i++)

-                     dst[i] = _mesa_float_to_half(rgba[i][GCOMP]);

-                  break;

-               case GL_BLUE:

-                  for (i=0;i<n;i++)

-                     dst[i] = _mesa_float_to_half(rgba[i][BCOMP]);

-                  break;

-               case GL_ALPHA:

-                  for (i=0;i<n;i++)

-                     dst[i] = _mesa_float_to_half(rgba[i][ACOMP]);

-                  break;

-               case GL_LUMINANCE:

-                  for (i=0;i<n;i++)

-                     dst[i] = _mesa_float_to_half(luminance[i]);

-                  break;

-               case GL_LUMINANCE_ALPHA:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = _mesa_float_to_half(luminance[i]);

-                     dst[i*2+1] = _mesa_float_to_half(rgba[i][ACOMP]);

-                  }

-                  break;

-               case GL_RG:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);

-                     dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);

-                  }

-                  break;

-               case GL_RGB:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = _mesa_float_to_half(rgba[i][RCOMP]);

-                     dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);

-                     dst[i*3+2] = _mesa_float_to_half(rgba[i][BCOMP]);

-                  }

-                  break;

-               case GL_RGBA:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = _mesa_float_to_half(rgba[i][RCOMP]);

-                     dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);

-                     dst[i*4+2] = _mesa_float_to_half(rgba[i][BCOMP]);

-                     dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);

-                  }

-                  break;

-               case GL_BGR:

-                  for (i=0;i<n;i++) {

-                     dst[i*3+0] = _mesa_float_to_half(rgba[i][BCOMP]);

-                     dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);

-                     dst[i*3+2] = _mesa_float_to_half(rgba[i][RCOMP]);

-                  }

-                  break;

-               case GL_BGRA:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = _mesa_float_to_half(rgba[i][BCOMP]);

-                     dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);

-                     dst[i*4+2] = _mesa_float_to_half(rgba[i][RCOMP]);

-                     dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);

-                  }

-                  break;

-               case GL_ABGR_EXT:

-                  for (i=0;i<n;i++) {

-                     dst[i*4+0] = _mesa_float_to_half(rgba[i][ACOMP]);

-                     dst[i*4+1] = _mesa_float_to_half(rgba[i][BCOMP]);

-                     dst[i*4+2] = _mesa_float_to_half(rgba[i][GCOMP]);

-                     dst[i*4+3] = _mesa_float_to_half(rgba[i][RCOMP]);

-                  }

-                  break;

-               case GL_DUDV_ATI:

-               case GL_DU8DV8_ATI:

-                  for (i=0;i<n;i++) {

-                     dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);

-                     dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);

-                  }

-                  break;

-               default:

-                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");

-            }

-         }

-         break;

-      case GL_UNSIGNED_BYTE_3_3_2:

-         if (dstFormat == GL_RGB) {

-            GLubyte *dst = (GLubyte *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][RCOMP] * 7.0F) << 5)

-                      | (IROUND(rgba[i][GCOMP] * 7.0F) << 2)

-                      | (IROUND(rgba[i][BCOMP] * 3.0F)     );

-            }

-         }

-         break;

-      case GL_UNSIGNED_BYTE_2_3_3_REV:

-         if (dstFormat == GL_RGB) {

-            GLubyte *dst = (GLubyte *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][RCOMP] * 7.0F)     )

-                      | (IROUND(rgba[i][GCOMP] * 7.0F) << 3)

-                      | (IROUND(rgba[i][BCOMP] * 3.0F) << 6);

-            }

-         }

-         break;

-      case GL_UNSIGNED_SHORT_5_6_5:

-         if (dstFormat == GL_RGB) {

-            GLushort *dst = (GLushort *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11)

-                      | (IROUND(rgba[i][GCOMP] * 63.0F) <<  5)

-                      | (IROUND(rgba[i][BCOMP] * 31.0F)      );

-            }

-         }

-         break;

-      case GL_UNSIGNED_SHORT_5_6_5_REV:

-         if (dstFormat == GL_RGB) {

-            GLushort *dst = (GLushort *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F)      )

-                      | (IROUND(rgba[i][GCOMP] * 63.0F) <<  5)

-                      | (IROUND(rgba[i][BCOMP] * 31.0F) << 11);

-            }

-         }

-         break;

-      case GL_UNSIGNED_SHORT_4_4_4_4:

-         if (dstFormat == GL_RGBA) {

-            GLushort *dst = (GLushort *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][RCOMP] * 15.0F) << 12)

-                      | (IROUND(rgba[i][GCOMP] * 15.0F) <<  8)

-                      | (IROUND(rgba[i][BCOMP] * 15.0F) <<  4)

-                      | (IROUND(rgba[i][ACOMP] * 15.0F)      );

-            }

-         }

-         else if (dstFormat == GL_BGRA) {

-            GLushort *dst = (GLushort *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F) << 12)

-                      | (IROUND(rgba[i][GCOMP] * 15.0F) <<  8)

-                      | (IROUND(rgba[i][RCOMP] * 15.0F) <<  4)

-                      | (IROUND(rgba[i][ACOMP] * 15.0F)      );

-            }

-         }

-         else if (dstFormat == GL_ABGR_EXT) {

-            GLushort *dst = (GLushort *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F) << 12)

-                      | (IROUND(rgba[i][BCOMP] * 15.0F) <<  8)

-                      | (IROUND(rgba[i][GCOMP] * 15.0F) <<  4)

-                      | (IROUND(rgba[i][RCOMP] * 15.0F)      );

-            }

-         }

-         break;

-      case GL_UNSIGNED_SHORT_4_4_4_4_REV:

-         if (dstFormat == GL_RGBA) {

-            GLushort *dst = (GLushort *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][RCOMP] * 15.0F)      )

-                      | (IROUND(rgba[i][GCOMP] * 15.0F) <<  4)

-                      | (IROUND(rgba[i][BCOMP] * 15.0F) <<  8)

-                      | (IROUND(rgba[i][ACOMP] * 15.0F) << 12);

-            }

-         }

-         else if (dstFormat == GL_BGRA) {

-            GLushort *dst = (GLushort *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F)      )

-                      | (IROUND(rgba[i][GCOMP] * 15.0F) <<  4)

-                      | (IROUND(rgba[i][RCOMP] * 15.0F) <<  8)

-                      | (IROUND(rgba[i][ACOMP] * 15.0F) << 12);

-            }

-         }

-         else if (dstFormat == GL_ABGR_EXT) {

-            GLushort *dst = (GLushort *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F)      )

-                      | (IROUND(rgba[i][BCOMP] * 15.0F) <<  4)

-                      | (IROUND(rgba[i][GCOMP] * 15.0F) <<  8)

-                      | (IROUND(rgba[i][RCOMP] * 15.0F) << 12);

-            }

-         }

-         break;

-      case GL_UNSIGNED_SHORT_5_5_5_1:

-         if (dstFormat == GL_RGBA) {

-            GLushort *dst = (GLushort *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11)

-                      | (IROUND(rgba[i][GCOMP] * 31.0F) <<  6)

-                      | (IROUND(rgba[i][BCOMP] * 31.0F) <<  1)

-                      | (IROUND(rgba[i][ACOMP] *  1.0F)      );

-            }

-         }

-         else if (dstFormat == GL_BGRA) {

-            GLushort *dst = (GLushort *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F) << 11)

-                      | (IROUND(rgba[i][GCOMP] * 31.0F) <<  6)

-                      | (IROUND(rgba[i][RCOMP] * 31.0F) <<  1)

-                      | (IROUND(rgba[i][ACOMP] *  1.0F)      );

-            }

-         }

-         else if (dstFormat == GL_ABGR_EXT) {

-            GLushort *dst = (GLushort *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F) << 11)

-                      | (IROUND(rgba[i][BCOMP] * 31.0F) <<  6)

-                      | (IROUND(rgba[i][GCOMP] * 31.0F) <<  1)

-                      | (IROUND(rgba[i][RCOMP] *  1.0F)      );

-            }

-         }

-         break;

-      case GL_UNSIGNED_SHORT_1_5_5_5_REV:

-         if (dstFormat == GL_RGBA) {

-            GLushort *dst = (GLushort *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F)      )

-                      | (IROUND(rgba[i][GCOMP] * 31.0F) <<  5)

-                      | (IROUND(rgba[i][BCOMP] * 31.0F) << 10)

-                      | (IROUND(rgba[i][ACOMP] *  1.0F) << 15);

-            }

-         }

-         else if (dstFormat == GL_BGRA) {

-            GLushort *dst = (GLushort *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F)      )

-                      | (IROUND(rgba[i][GCOMP] * 31.0F) <<  5)

-                      | (IROUND(rgba[i][RCOMP] * 31.0F) << 10)

-                      | (IROUND(rgba[i][ACOMP] *  1.0F) << 15);

-            }

-         }

-         else if (dstFormat == GL_ABGR_EXT) {

-            GLushort *dst = (GLushort *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F)      )

-                      | (IROUND(rgba[i][BCOMP] * 31.0F) <<  5)

-                      | (IROUND(rgba[i][GCOMP] * 31.0F) << 10)

-                      | (IROUND(rgba[i][RCOMP] *  1.0F) << 15);

-            }

-         }

-         break;

-      case GL_UNSIGNED_INT_8_8_8_8:

-         if (dstFormat == GL_RGBA) {

-            GLuint *dst = (GLuint *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][RCOMP] * 255.F) << 24)

-                      | (IROUND(rgba[i][GCOMP] * 255.F) << 16)

-                      | (IROUND(rgba[i][BCOMP] * 255.F) <<  8)

-                      | (IROUND(rgba[i][ACOMP] * 255.F)      );

-            }

-         }

-         else if (dstFormat == GL_BGRA) {

-            GLuint *dst = (GLuint *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][BCOMP] * 255.F) << 24)

-                      | (IROUND(rgba[i][GCOMP] * 255.F) << 16)

-                      | (IROUND(rgba[i][RCOMP] * 255.F) <<  8)

-                      | (IROUND(rgba[i][ACOMP] * 255.F)      );

-            }

-         }

-         else if (dstFormat == GL_ABGR_EXT) {

-            GLuint *dst = (GLuint *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][ACOMP] * 255.F) << 24)

-                      | (IROUND(rgba[i][BCOMP] * 255.F) << 16)

-                      | (IROUND(rgba[i][GCOMP] * 255.F) <<  8)

-                      | (IROUND(rgba[i][RCOMP] * 255.F)      );

-            }

-         }

-         break;

-      case GL_UNSIGNED_INT_8_8_8_8_REV:

-         if (dstFormat == GL_RGBA) {

-            GLuint *dst = (GLuint *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][RCOMP] * 255.0F)      )

-                      | (IROUND(rgba[i][GCOMP] * 255.0F) <<  8)

-                      | (IROUND(rgba[i][BCOMP] * 255.0F) << 16)

-                      | (IROUND(rgba[i][ACOMP] * 255.0F) << 24);

-            }

-         }

-         else if (dstFormat == GL_BGRA) {

-            GLuint *dst = (GLuint *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][BCOMP] * 255.0F)      )

-                      | (IROUND(rgba[i][GCOMP] * 255.0F) <<  8)

-                      | (IROUND(rgba[i][RCOMP] * 255.0F) << 16)

-                      | (IROUND(rgba[i][ACOMP] * 255.0F) << 24);

-            }

-         }

-         else if (dstFormat == GL_ABGR_EXT) {

-            GLuint *dst = (GLuint *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][ACOMP] * 255.0F)      )

-                      | (IROUND(rgba[i][BCOMP] * 255.0F) <<  8)

-                      | (IROUND(rgba[i][GCOMP] * 255.0F) << 16)

-                      | (IROUND(rgba[i][RCOMP] * 255.0F) << 24);

-            }

-         }

-         break;

-      case GL_UNSIGNED_INT_10_10_10_2:

-         if (dstFormat == GL_RGBA) {

-            GLuint *dst = (GLuint *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][RCOMP] * 1023.0F) << 22)

-                      | (IROUND(rgba[i][GCOMP] * 1023.0F) << 12)

-                      | (IROUND(rgba[i][BCOMP] * 1023.0F) <<  2)

-                      | (IROUND(rgba[i][ACOMP] *    3.0F)      );

-            }

-         }

-         else if (dstFormat == GL_BGRA) {

-            GLuint *dst = (GLuint *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F) << 22)

-                      | (IROUND(rgba[i][GCOMP] * 1023.0F) << 12)

-                      | (IROUND(rgba[i][RCOMP] * 1023.0F) <<  2)

-                      | (IROUND(rgba[i][ACOMP] *    3.0F)      );

-            }

-         }

-         else if (dstFormat == GL_ABGR_EXT) {

-            GLuint *dst = (GLuint *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F) << 22)

-                      | (IROUND(rgba[i][BCOMP] * 1023.0F) << 12)

-                      | (IROUND(rgba[i][GCOMP] * 1023.0F) <<  2)

-                      | (IROUND(rgba[i][RCOMP] *    3.0F)      );

-            }

-         }

-         break;

-      case GL_UNSIGNED_INT_2_10_10_10_REV:

-         if (dstFormat == GL_RGBA) {

-            GLuint *dst = (GLuint *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][RCOMP] * 1023.0F)      )

-                      | (IROUND(rgba[i][GCOMP] * 1023.0F) << 10)

-                      | (IROUND(rgba[i][BCOMP] * 1023.0F) << 20)

-                      | (IROUND(rgba[i][ACOMP] *    3.0F) << 30);

-            }

-         }

-         else if (dstFormat == GL_BGRA) {

-            GLuint *dst = (GLuint *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F)      )

-                      | (IROUND(rgba[i][GCOMP] * 1023.0F) << 10)

-                      | (IROUND(rgba[i][RCOMP] * 1023.0F) << 20)

-                      | (IROUND(rgba[i][ACOMP] *    3.0F) << 30);

-            }

-         }

-         else if (dstFormat == GL_ABGR_EXT) {

-            GLuint *dst = (GLuint *) dstAddr;

-            for (i=0;i<n;i++) {

-               dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F)      )

-                      | (IROUND(rgba[i][BCOMP] * 1023.0F) << 10)

-                      | (IROUND(rgba[i][GCOMP] * 1023.0F) << 20)

-                      | (IROUND(rgba[i][RCOMP] *    3.0F) << 30);

-            }

-         }

-         break;

-      default:

-         _mesa_problem(ctx, "bad type in _mesa_pack_rgba_span_float");

-         return;

-   }

-

-   if (dstPacking->SwapBytes) {

-      GLint swapSize = _mesa_sizeof_packed_type(dstType);

-      if (swapSize == 2) {

-         if (dstPacking->SwapBytes) {

-            _mesa_swap2((GLushort *) dstAddr, n * comps);

-         }

-      }

-      else if (swapSize == 4) {

-         if (dstPacking->SwapBytes) {

-            _mesa_swap4((GLuint *) dstAddr, n * comps);

-         }

-      }

-   }

-

-   free(luminance);

-}

-

-

-

-#define SWAP2BYTE(VALUE)			\

-   {						\

-      GLubyte *bytes = (GLubyte *) &(VALUE);	\

-      GLubyte tmp = bytes[0];			\

-      bytes[0] = bytes[1];			\

-      bytes[1] = tmp;				\

-   }

-

-#define SWAP4BYTE(VALUE)			\

-   {						\

-      GLubyte *bytes = (GLubyte *) &(VALUE);	\

-      GLubyte tmp = bytes[0];			\

-      bytes[0] = bytes[3];			\

-      bytes[3] = tmp;				\

-      tmp = bytes[1];				\

-      bytes[1] = bytes[2];			\

-      bytes[2] = tmp;				\

-   }

-

-

-static void

-extract_uint_indexes(GLuint n, GLuint indexes[],

-                     GLenum srcFormat, GLenum srcType, const GLvoid *src,

-                     const struct gl_pixelstore_attrib *unpack )

-{

-   ASSERT(srcFormat == GL_COLOR_INDEX || srcFormat == GL_STENCIL_INDEX);

-

-   ASSERT(srcType == GL_BITMAP ||

-          srcType == GL_UNSIGNED_BYTE ||

-          srcType == GL_BYTE ||

-          srcType == GL_UNSIGNED_SHORT ||

-          srcType == GL_SHORT ||

-          srcType == GL_UNSIGNED_INT ||

-          srcType == GL_INT ||

-          srcType == GL_UNSIGNED_INT_24_8_EXT ||

-          srcType == GL_HALF_FLOAT_ARB ||

-          srcType == GL_FLOAT);

-

-   switch (srcType) {

-      case GL_BITMAP:

-         {

-            GLubyte *ubsrc = (GLubyte *) src;

-            if (unpack->LsbFirst) {

-               GLubyte mask = 1 << (unpack->SkipPixels & 0x7);

-               GLuint i;

-               for (i = 0; i < n; i++) {

-                  indexes[i] = (*ubsrc & mask) ? 1 : 0;

-                  if (mask == 128) {

-                     mask = 1;

-                     ubsrc++;

-                  }

-                  else {

-                     mask = mask << 1;

-                  }

-               }

-            }

-            else {

-               GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);

-               GLuint i;

-               for (i = 0; i < n; i++) {

-                  indexes[i] = (*ubsrc & mask) ? 1 : 0;

-                  if (mask == 1) {

-                     mask = 128;

-                     ubsrc++;

-                  }

-                  else {

-                     mask = mask >> 1;

-                  }

-               }

-            }

-         }

-         break;

-      case GL_UNSIGNED_BYTE:

-         {

-            GLuint i;

-            const GLubyte *s = (const GLubyte *) src;

-            for (i = 0; i < n; i++)

-               indexes[i] = s[i];

-         }

-         break;

-      case GL_BYTE:

-         {

-            GLuint i;

-            const GLbyte *s = (const GLbyte *) src;

-            for (i = 0; i < n; i++)

-               indexes[i] = s[i];

-         }

-         break;

-      case GL_UNSIGNED_SHORT:

-         {

-            GLuint i;

-            const GLushort *s = (const GLushort *) src;

-            if (unpack->SwapBytes) {

-               for (i = 0; i < n; i++) {

-                  GLushort value = s[i];

-                  SWAP2BYTE(value);

-                  indexes[i] = value;

-               }

-            }

-            else {

-               for (i = 0; i < n; i++)

-                  indexes[i] = s[i];

-            }

-         }

-         break;

-      case GL_SHORT:

-         {

-            GLuint i;

-            const GLshort *s = (const GLshort *) src;

-            if (unpack->SwapBytes) {

-               for (i = 0; i < n; i++) {

-                  GLshort value = s[i];

-                  SWAP2BYTE(value);

-                  indexes[i] = value;

-               }

-            }

-            else {

-               for (i = 0; i < n; i++)

-                  indexes[i] = s[i];

-            }

-         }

-         break;

-      case GL_UNSIGNED_INT:

-         {

-            GLuint i;

-            const GLuint *s = (const GLuint *) src;

-            if (unpack->SwapBytes) {

-               for (i = 0; i < n; i++) {

-                  GLuint value = s[i];

-                  SWAP4BYTE(value);

-                  indexes[i] = value;

-               }

-            }

-            else {

-               for (i = 0; i < n; i++)

-                  indexes[i] = s[i];

-            }

-         }

-         break;

-      case GL_INT:

-         {

-            GLuint i;

-            const GLint *s = (const GLint *) src;

-            if (unpack->SwapBytes) {

-               for (i = 0; i < n; i++) {

-                  GLint value = s[i];

-                  SWAP4BYTE(value);

-                  indexes[i] = value;

-               }

-            }

-            else {

-               for (i = 0; i < n; i++)

-                  indexes[i] = s[i];

-            }

-         }

-         break;

-      case GL_FLOAT:

-         {

-            GLuint i;

-            const GLfloat *s = (const GLfloat *) src;

-            if (unpack->SwapBytes) {

-               for (i = 0; i < n; i++) {

-                  GLfloat value = s[i];

-                  SWAP4BYTE(value);

-                  indexes[i] = (GLuint) value;

-               }

-            }

-            else {

-               for (i = 0; i < n; i++)

-                  indexes[i] = (GLuint) s[i];

-            }

-         }

-         break;

-      case GL_HALF_FLOAT_ARB:

-         {

-            GLuint i;

-            const GLhalfARB *s = (const GLhalfARB *) src;

-            if (unpack->SwapBytes) {

-               for (i = 0; i < n; i++) {

-                  GLhalfARB value = s[i];

-                  SWAP2BYTE(value);

-                  indexes[i] = (GLuint) _mesa_half_to_float(value);

-               }

-            }

-            else {

-               for (i = 0; i < n; i++)

-                  indexes[i] = (GLuint) _mesa_half_to_float(s[i]);

-            }

-         }

-         break;

-      case GL_UNSIGNED_INT_24_8_EXT:

-         {

-            GLuint i;

-            const GLuint *s = (const GLuint *) src;

-            if (unpack->SwapBytes) {

-               for (i = 0; i < n; i++) {

-                  GLuint value = s[i];

-                  SWAP4BYTE(value);

-                  indexes[i] = value & 0xff;  /* lower 8 bits */

-               }

-            }

-            else {

-               for (i = 0; i < n; i++)

-                  indexes[i] = s[i] & 0xff;  /* lower 8 bits */

-            }

-         }

-         break;

-

-      default:

-         _mesa_problem(NULL, "bad srcType in extract_uint_indexes");

-         return;

-   }

-}

-

-

-/**

- * Return source/dest RGBA indexes for unpacking pixels.

- */

-static void

-get_component_mapping(GLenum format,

-                      GLint *rSrc,

-                      GLint *gSrc,

-                      GLint *bSrc,

-                      GLint *aSrc,

-                      GLint *rDst,

-                      GLint *gDst,

-                      GLint *bDst,

-                      GLint *aDst)

-{

-   switch (format) {

-   case GL_RED:

-   case GL_RED_INTEGER_EXT:

-      *rSrc = 0;

-      *gSrc = *bSrc = *aSrc = -1;

-      break;

-   case GL_GREEN:

-   case GL_GREEN_INTEGER_EXT:

-      *gSrc = 0;

-      *rSrc = *bSrc = *aSrc = -1;

-      break;

-      case GL_BLUE:

-   case GL_BLUE_INTEGER_EXT:

-      *bSrc = 0;

-      *rSrc = *gSrc = *aSrc = -1;

-      break;

-   case GL_ALPHA:

-   case GL_ALPHA_INTEGER_EXT:

-      *rSrc = *gSrc = *bSrc = -1;

-      *aSrc = 0;

-      break;

-   case GL_LUMINANCE:

-   case GL_LUMINANCE_INTEGER_EXT:

-      *rSrc = *gSrc = *bSrc = 0;

-      *aSrc = -1;

-      break;

-   case GL_LUMINANCE_ALPHA:

-   case GL_LUMINANCE_ALPHA_INTEGER_EXT:

-      *rSrc = *gSrc = *bSrc = 0;

-      *aSrc = 1;

-      break;

-   case GL_INTENSITY:

-      *rSrc = *gSrc = *bSrc = *aSrc = 0;

-      break;

-   case GL_RG:

-   case GL_RG_INTEGER:

-      *rSrc = 0;

-      *gSrc = 1;

-      *bSrc = -1;

-      *aSrc = -1;

-      *rDst = 0;

-      *gDst = 1;

-      *bDst = 2;

-      *aDst = 3;

-      break;

-   case GL_RGB:

-   case GL_RGB_INTEGER:

-      *rSrc = 0;

-      *gSrc = 1;

-      *bSrc = 2;

-      *aSrc = -1;

-      *rDst = 0;

-      *gDst = 1;

-      *bDst = 2;

-      *aDst = 3;

-      break;

-   case GL_BGR:

-      *rSrc = 2;

-      *gSrc = 1;

-      *bSrc = 0;

-      *aSrc = -1;

-      *rDst = 2;

-      *gDst = 1;

-      *bDst = 0;

-      *aDst = 3;

-      break;

-   case GL_RGBA:

-   case GL_RGBA_INTEGER:

-      *rSrc = 0;

-      *gSrc = 1;

-      *bSrc = 2;

-      *aSrc = 3;

-      *rDst = 0;

-      *gDst = 1;

-      *bDst = 2;

-      *aDst = 3;

-      break;

-   case GL_BGRA:

-      *rSrc = 2;

-      *gSrc = 1;

-      *bSrc = 0;

-      *aSrc = 3;

-      *rDst = 2;

-      *gDst = 1;

-      *bDst = 0;

-      *aDst = 3;

-      break;

-   case GL_ABGR_EXT:

-      *rSrc = 3;

-      *gSrc = 2;

-      *bSrc = 1;

-      *aSrc = 0;

-      *rDst = 3;

-      *gDst = 2;

-      *bDst = 1;

-      *aDst = 0;

-      break;

-   case GL_DU8DV8_ATI:

-   case GL_DUDV_ATI:

-      *rSrc = 0;

-      *gSrc = 1;

-      *bSrc = -1;

-      *aSrc = -1;

-      break;

-   default:

-      _mesa_problem(NULL, "bad srcFormat %s in get_component_mapping",

-                    _mesa_lookup_enum_by_nr(format));

-      return;

-   }

-}

-

-

-

-/*

- * This function extracts floating point RGBA values from arbitrary

- * image data.  srcFormat and srcType are the format and type parameters

- * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.

- *

- * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function

- * implements the "Conversion to floating point", "Conversion to RGB",

- * and "Final Expansion to RGBA" operations.

- *

- * Args:  n - number of pixels

- *        rgba - output colors

- *        srcFormat - format of incoming data

- *        srcType - data type of incoming data

- *        src - source data pointer

- *        swapBytes - perform byteswapping of incoming data?

- */

-static void

-extract_float_rgba(GLuint n, GLfloat rgba[][4],

-                   GLenum srcFormat, GLenum srcType, const GLvoid *src,

-                   GLboolean swapBytes)

-{

-   GLint rSrc, gSrc, bSrc, aSrc;

-   GLint stride;

-   GLint rDst, bDst, gDst, aDst;

-   GLboolean intFormat;

-   GLfloat rs = 1.0f, gs = 1.0f, bs = 1.0f, as = 1.0f; /* scale factors */

-

-   ASSERT(srcFormat == GL_RED ||

-          srcFormat == GL_GREEN ||

-          srcFormat == GL_BLUE ||

-          srcFormat == GL_ALPHA ||

-          srcFormat == GL_LUMINANCE ||

-          srcFormat == GL_LUMINANCE_ALPHA ||

-          srcFormat == GL_INTENSITY ||

-          srcFormat == GL_RG ||

-          srcFormat == GL_RGB ||

-          srcFormat == GL_BGR ||

-          srcFormat == GL_RGBA ||

-          srcFormat == GL_BGRA ||

-          srcFormat == GL_ABGR_EXT ||

-          srcFormat == GL_DU8DV8_ATI ||

-          srcFormat == GL_DUDV_ATI ||

-          srcFormat == GL_RED_INTEGER_EXT ||

-          srcFormat == GL_GREEN_INTEGER_EXT ||

-          srcFormat == GL_BLUE_INTEGER_EXT ||

-          srcFormat == GL_ALPHA_INTEGER_EXT ||

-          srcFormat == GL_RGB_INTEGER_EXT ||

-          srcFormat == GL_RGBA_INTEGER_EXT ||

-          srcFormat == GL_BGR_INTEGER_EXT ||

-          srcFormat == GL_BGRA_INTEGER_EXT ||

-          srcFormat == GL_LUMINANCE_INTEGER_EXT ||

-          srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);

-

-   ASSERT(srcType == GL_UNSIGNED_BYTE ||

-          srcType == GL_BYTE ||

-          srcType == GL_UNSIGNED_SHORT ||

-          srcType == GL_SHORT ||

-          srcType == GL_UNSIGNED_INT ||

-          srcType == GL_INT ||

-          srcType == GL_HALF_FLOAT_ARB ||

-          srcType == GL_FLOAT ||

-          srcType == GL_UNSIGNED_BYTE_3_3_2 ||

-          srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||

-          srcType == GL_UNSIGNED_SHORT_5_6_5 ||

-          srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||

-          srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||

-          srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||

-          srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||

-          srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||

-          srcType == GL_UNSIGNED_INT_8_8_8_8 ||

-          srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||

-          srcType == GL_UNSIGNED_INT_10_10_10_2 ||

-          srcType == GL_UNSIGNED_INT_2_10_10_10_REV);

-

-   get_component_mapping(srcFormat,

-                         &rSrc, &gSrc, &bSrc, &aSrc,

-                         &rDst, &gDst, &bDst, &aDst);

-

-   stride = _mesa_components_in_format(srcFormat);

-

-   intFormat = _mesa_is_integer_format(srcFormat);

-

-#define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT_FLT, DEFAULT_INT, TYPE, CONVERSION) \

-   if ((SRC_INDEX) < 0) {						\

-      GLuint i;								\

-      if (intFormat) {							\

-         for (i = 0; i < n; i++) {					\

-            rgba[i][DST_INDEX] = DEFAULT_INT;				\

-         }								\

-      }									\

-      else {								\

-         for (i = 0; i < n; i++) {					\

-            rgba[i][DST_INDEX] = DEFAULT_FLT;				\

-         }								\

-      }									\

-   }									\

-   else if (swapBytes) {						\

-      const TYPE *s = (const TYPE *) src;				\

-      GLuint i;								\

-      for (i = 0; i < n; i++) {						\

-         TYPE value = s[SRC_INDEX];					\

-         if (sizeof(TYPE) == 2) {					\

-            SWAP2BYTE(value);						\

-         }								\

-         else if (sizeof(TYPE) == 4) {					\

-            SWAP4BYTE(value);						\

-         }								\

-         if (intFormat)							\

-            rgba[i][DST_INDEX] = (GLfloat) value;			\

-         else								\

-            rgba[i][DST_INDEX] = (GLfloat) CONVERSION(value);		\

-         s += stride;							\

-      }									\

-   }									\

-   else {								\

-      const TYPE *s = (const TYPE *) src;				\

-      GLuint i;								\

-      if (intFormat) {							\

-         for (i = 0; i < n; i++) {					\

-            rgba[i][DST_INDEX] = (GLfloat) s[SRC_INDEX];		\

-            s += stride;						\

-         }								\

-      }									\

-      else {								\

-         for (i = 0; i < n; i++) {					\

-            rgba[i][DST_INDEX] = (GLfloat) CONVERSION(s[SRC_INDEX]);	\

-            s += stride;						\

-         }								\

-      }									\

-   }

-

-   switch (srcType) {

-      case GL_UNSIGNED_BYTE:

-         PROCESS(rSrc, RCOMP, 0.0F,   0, GLubyte, UBYTE_TO_FLOAT);

-         PROCESS(gSrc, GCOMP, 0.0F,   0, GLubyte, UBYTE_TO_FLOAT);

-         PROCESS(bSrc, BCOMP, 0.0F,   0, GLubyte, UBYTE_TO_FLOAT);

-         PROCESS(aSrc, ACOMP, 1.0F, 255, GLubyte, UBYTE_TO_FLOAT);

-         break;

-      case GL_BYTE:

-         PROCESS(rSrc, RCOMP, 0.0F,   0, GLbyte, BYTE_TO_FLOAT);

-         PROCESS(gSrc, GCOMP, 0.0F,   0, GLbyte, BYTE_TO_FLOAT);

-         PROCESS(bSrc, BCOMP, 0.0F,   0, GLbyte, BYTE_TO_FLOAT);

-         PROCESS(aSrc, ACOMP, 1.0F, 127, GLbyte, BYTE_TO_FLOAT);

-         break;

-      case GL_UNSIGNED_SHORT:

-         PROCESS(rSrc, RCOMP, 0.0F,      0, GLushort, USHORT_TO_FLOAT);

-         PROCESS(gSrc, GCOMP, 0.0F,      0, GLushort, USHORT_TO_FLOAT);

-         PROCESS(bSrc, BCOMP, 0.0F,      0, GLushort, USHORT_TO_FLOAT);

-         PROCESS(aSrc, ACOMP, 1.0F, 0xffff, GLushort, USHORT_TO_FLOAT);

-         break;

-      case GL_SHORT:

-         PROCESS(rSrc, RCOMP, 0.0F,     0, GLshort, SHORT_TO_FLOAT);

-         PROCESS(gSrc, GCOMP, 0.0F,     0, GLshort, SHORT_TO_FLOAT);

-         PROCESS(bSrc, BCOMP, 0.0F,     0, GLshort, SHORT_TO_FLOAT);

-         PROCESS(aSrc, ACOMP, 1.0F, 32767, GLshort, SHORT_TO_FLOAT);

-         break;

-      case GL_UNSIGNED_INT:

-         PROCESS(rSrc, RCOMP, 0.0F,          0, GLuint, UINT_TO_FLOAT);

-         PROCESS(gSrc, GCOMP, 0.0F,          0, GLuint, UINT_TO_FLOAT);

-         PROCESS(bSrc, BCOMP, 0.0F,          0, GLuint, UINT_TO_FLOAT);

-         PROCESS(aSrc, ACOMP, 1.0F, 0xffffffff, GLuint, UINT_TO_FLOAT);

-         break;

-      case GL_INT:

-         PROCESS(rSrc, RCOMP, 0.0F,          0, GLint, INT_TO_FLOAT);

-         PROCESS(gSrc, GCOMP, 0.0F,          0, GLint, INT_TO_FLOAT);

-         PROCESS(bSrc, BCOMP, 0.0F,          0, GLint, INT_TO_FLOAT);

-         PROCESS(aSrc, ACOMP, 1.0F, 2147483647, GLint, INT_TO_FLOAT);

-         break;

-      case GL_FLOAT:

-         PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));

-         PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));

-         PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));

-         PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLfloat, (GLfloat));

-         break;

-      case GL_HALF_FLOAT_ARB:

-         PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);

-         PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);

-         PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);

-         PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLhalfARB, _mesa_half_to_float);

-         break;

-      case GL_UNSIGNED_BYTE_3_3_2:

-         {

-            const GLubyte *ubsrc = (const GLubyte *) src;

-            GLuint i;

-            if (!intFormat) {

-               rs = 1.0F / 7.0F;

-               gs = 1.0F / 7.0F;

-               bs = 1.0F / 3.0F;

-            }

-            for (i = 0; i < n; i ++) {

-               GLubyte p = ubsrc[i];

-               rgba[i][rDst] = ((p >> 5)      ) * rs;

-               rgba[i][gDst] = ((p >> 2) & 0x7) * gs;

-               rgba[i][bDst] = ((p     ) & 0x3) * bs;

-               rgba[i][aDst] = 1.0F;

-            }

-         }

-         break;

-      case GL_UNSIGNED_BYTE_2_3_3_REV:

-         {

-            const GLubyte *ubsrc = (const GLubyte *) src;

-            GLuint i;

-            if (!intFormat) {

-               rs = 1.0F / 7.0F;

-               gs = 1.0F / 7.0F;

-               bs = 1.0F / 3.0F;

-            }

-            for (i = 0; i < n; i ++) {

-               GLubyte p = ubsrc[i];

-               rgba[i][rDst] = ((p     ) & 0x7) * rs;

-               rgba[i][gDst] = ((p >> 3) & 0x7) * gs;

-               rgba[i][bDst] = ((p >> 6)      ) * bs;

-               rgba[i][aDst] = 1.0F;

-            }

-         }

-         break;

-      case GL_UNSIGNED_SHORT_5_6_5:

-         if (!intFormat) {

-            rs = 1.0F / 31.0F;

-            gs = 1.0F / 63.0F;

-            bs = 1.0F / 31.0F;

-         }

-         if (swapBytes) {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               SWAP2BYTE(p);

-               rgba[i][rDst] = ((p >> 11)       ) * rs;

-               rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;

-               rgba[i][bDst] = ((p      ) & 0x1f) * bs;

-               rgba[i][aDst] = 1.0F;

-            }

-         }

-         else {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               rgba[i][rDst] = ((p >> 11)       ) * rs;

-               rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;

-               rgba[i][bDst] = ((p      ) & 0x1f) * bs;

-               rgba[i][aDst] = 1.0F;

-            }

-         }

-         break;

-      case GL_UNSIGNED_SHORT_5_6_5_REV:

-         if (!intFormat) {

-            rs = 1.0F / 31.0F;

-            gs = 1.0F / 63.0F;

-            bs = 1.0F / 31.0F;

-         }

-         if (swapBytes) {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               SWAP2BYTE(p);

-               rgba[i][rDst] = ((p      ) & 0x1f) * rs;

-               rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;

-               rgba[i][bDst] = ((p >> 11)       ) * bs;

-               rgba[i][aDst] = 1.0F;

-            }

-         }

-         else {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               rgba[i][rDst] = ((p      ) & 0x1f) * rs;

-               rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;

-               rgba[i][bDst] = ((p >> 11)       ) * bs;

-               rgba[i][aDst] = 1.0F;

-            }

-         }

-         break;

-      case GL_UNSIGNED_SHORT_4_4_4_4:

-         if (!intFormat) {

-            rs = gs = bs = as = 1.0F / 15.0F;

-         }

-         if (swapBytes) {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               SWAP2BYTE(p);

-               rgba[i][rDst] = ((p >> 12)      ) * rs;

-               rgba[i][gDst] = ((p >>  8) & 0xf) * gs;

-               rgba[i][bDst] = ((p >>  4) & 0xf) * bs;

-               rgba[i][aDst] = ((p      ) & 0xf) * as;

-            }

-         }

-         else {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               rgba[i][rDst] = ((p >> 12)      ) * rs;

-               rgba[i][gDst] = ((p >>  8) & 0xf) * gs;

-               rgba[i][bDst] = ((p >>  4) & 0xf) * bs;

-               rgba[i][aDst] = ((p      ) & 0xf) * as;

-            }

-         }

-         break;

-      case GL_UNSIGNED_SHORT_4_4_4_4_REV:

-         if (!intFormat) {

-            rs = gs = bs = as = 1.0F / 15.0F;

-         }

-         if (swapBytes) {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               SWAP2BYTE(p);

-               rgba[i][rDst] = ((p      ) & 0xf) * rs;

-               rgba[i][gDst] = ((p >>  4) & 0xf) * gs;

-               rgba[i][bDst] = ((p >>  8) & 0xf) * bs;

-               rgba[i][aDst] = ((p >> 12)      ) * as;

-            }

-         }

-         else {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               rgba[i][rDst] = ((p      ) & 0xf) * rs;

-               rgba[i][gDst] = ((p >>  4) & 0xf) * gs;

-               rgba[i][bDst] = ((p >>  8) & 0xf) * bs;

-               rgba[i][aDst] = ((p >> 12)      ) * as;

-            }

-         }

-         break;

-      case GL_UNSIGNED_SHORT_5_5_5_1:

-         if (!intFormat) {

-            rs = gs = bs = 1.0F / 31.0F;

-         }

-         if (swapBytes) {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               SWAP2BYTE(p);

-               rgba[i][rDst] = ((p >> 11)       ) * rs;

-               rgba[i][gDst] = ((p >>  6) & 0x1f) * gs;

-               rgba[i][bDst] = ((p >>  1) & 0x1f) * bs;

-               rgba[i][aDst] = ((p      ) & 0x1)  * as;

-            }

-         }

-         else {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               rgba[i][rDst] = ((p >> 11)       ) * rs;

-               rgba[i][gDst] = ((p >>  6) & 0x1f) * gs;

-               rgba[i][bDst] = ((p >>  1) & 0x1f) * bs;

-               rgba[i][aDst] = ((p      ) & 0x1)  * as;

-            }

-         }

-         break;

-      case GL_UNSIGNED_SHORT_1_5_5_5_REV:

-         if (!intFormat) {

-            rs = gs = bs = 1.0F / 31.0F;

-         }

-         if (swapBytes) {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               SWAP2BYTE(p);

-               rgba[i][rDst] = ((p      ) & 0x1f) * rs;

-               rgba[i][gDst] = ((p >>  5) & 0x1f) * gs;

-               rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;

-               rgba[i][aDst] = ((p >> 15)       ) * as;

-            }

-         }

-         else {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               rgba[i][rDst] = ((p      ) & 0x1f) * rs;

-               rgba[i][gDst] = ((p >>  5) & 0x1f) * gs;

-               rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;

-               rgba[i][aDst] = ((p >> 15)       ) * as;

-            }

-         }

-         break;

-      case GL_UNSIGNED_INT_8_8_8_8:

-         if (swapBytes) {

-            const GLuint *uisrc = (const GLuint *) src;

-            GLuint i;

-            if (intFormat) {

-               for (i = 0; i < n; i ++) {

-                  GLuint p = uisrc[i];

-                  rgba[i][rDst] = (GLfloat) ((p      ) & 0xff);

-                  rgba[i][gDst] = (GLfloat) ((p >>  8) & 0xff);

-                  rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);

-                  rgba[i][aDst] = (GLfloat) ((p >> 24)       );

-               }

-            }

-            else {

-               for (i = 0; i < n; i ++) {

-                  GLuint p = uisrc[i];

-                  rgba[i][rDst] = UBYTE_TO_FLOAT((p      ) & 0xff);

-                  rgba[i][gDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);

-                  rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);

-                  rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24)       );

-               }

-            }

-         }

-         else {

-            const GLuint *uisrc = (const GLuint *) src;

-            GLuint i;

-            if (intFormat) {

-               for (i = 0; i < n; i ++) {

-                  GLuint p = uisrc[i];

-                  rgba[i][rDst] = (GLfloat) ((p >> 24)       );

-                  rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);

-                  rgba[i][bDst] = (GLfloat) ((p >>  8) & 0xff);

-                  rgba[i][aDst] = (GLfloat) ((p      ) & 0xff);

-               }

-            }

-            else {

-               for (i = 0; i < n; i ++) {

-                  GLuint p = uisrc[i];

-                  rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24)       );

-                  rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);

-                  rgba[i][bDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);

-                  rgba[i][aDst] = UBYTE_TO_FLOAT((p      ) & 0xff);

-               }

-            }

-         }

-         break;

-      case GL_UNSIGNED_INT_8_8_8_8_REV:

-         if (swapBytes) {

-            const GLuint *uisrc = (const GLuint *) src;

-            GLuint i;

-            if (intFormat) {

-               for (i = 0; i < n; i ++) {

-                  GLuint p = uisrc[i];

-                  rgba[i][rDst] = (GLfloat) ((p >> 24)       );

-                  rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);

-                  rgba[i][bDst] = (GLfloat) ((p >>  8) & 0xff);

-                  rgba[i][aDst] = (GLfloat) ((p      ) & 0xff);

-               }

-            }

-            else {

-               for (i = 0; i < n; i ++) {

-                  GLuint p = uisrc[i];

-                  rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24)       );

-                  rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);

-                  rgba[i][bDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);

-                  rgba[i][aDst] = UBYTE_TO_FLOAT((p      ) & 0xff);

-               }

-            }

-         }

-         else {

-            const GLuint *uisrc = (const GLuint *) src;

-            GLuint i;

-            if (intFormat) {

-               for (i = 0; i < n; i ++) {

-                  GLuint p = uisrc[i];

-                  rgba[i][rDst] = (GLfloat) ((p      ) & 0xff);

-                  rgba[i][gDst] = (GLfloat) ((p >>  8) & 0xff);

-                  rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);

-                  rgba[i][aDst] = (GLfloat) ((p >> 24)       );

-               }

-            }

-            else {

-               for (i = 0; i < n; i ++) {

-                  GLuint p = uisrc[i];

-                  rgba[i][rDst] = UBYTE_TO_FLOAT((p      ) & 0xff);

-                  rgba[i][gDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);

-                  rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);

-                  rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24)       );

-               }

-            }

-         }

-         break;

-      case GL_UNSIGNED_INT_10_10_10_2:

-         if (!intFormat) {

-            rs = 1.0F / 1023.0F;

-            gs = 1.0F / 1023.0F;

-            bs = 1.0F / 1023.0F;

-            as = 1.0F / 3.0F;

-         }

-         if (swapBytes) {

-            const GLuint *uisrc = (const GLuint *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLuint p = uisrc[i];

-               SWAP4BYTE(p);

-               rgba[i][rDst] = ((p >> 22)        ) * rs;

-               rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;

-               rgba[i][bDst] = ((p >>  2) & 0x3ff) * bs;

-               rgba[i][aDst] = ((p      ) & 0x3  ) * as;

-            }

-         }

-         else {

-            const GLuint *uisrc = (const GLuint *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLuint p = uisrc[i];

-               rgba[i][rDst] = ((p >> 22)        ) * rs;

-               rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;

-               rgba[i][bDst] = ((p >>  2) & 0x3ff) * bs;

-               rgba[i][aDst] = ((p      ) & 0x3  ) * as;

-            }

-         }

-         break;

-      case GL_UNSIGNED_INT_2_10_10_10_REV:

-         if (!intFormat) {

-            rs = 1.0F / 1023.0F;

-            gs = 1.0F / 1023.0F;

-            bs = 1.0F / 1023.0F;

-            as = 1.0F / 3.0F;

-         }

-         if (swapBytes) {

-            const GLuint *uisrc = (const GLuint *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLuint p = uisrc[i];

-               SWAP4BYTE(p);

-               rgba[i][rDst] = ((p      ) & 0x3ff) * rs;

-               rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;

-               rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;

-               rgba[i][aDst] = ((p >> 30)        ) * as;

-            }

-         }

-         else {

-            const GLuint *uisrc = (const GLuint *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLuint p = uisrc[i];

-               rgba[i][rDst] = ((p      ) & 0x3ff) * rs;

-               rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;

-               rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;

-               rgba[i][aDst] = ((p >> 30)        ) * as;

-            }

-         }

-         break;

-      default:

-         _mesa_problem(NULL, "bad srcType in extract float data");

-         break;

-   }

-#undef PROCESS

-}

-

-

-static INLINE GLuint

-clamp_byte_to_uint(GLbyte b)

-{

-   return b < 0 ? 0 : b;

-}

-

-

-static INLINE GLuint

-clamp_short_to_uint(GLshort s)

-{

-   return s < 0 ? 0 : s;

-}

-

-

-static INLINE GLuint

-clamp_int_to_uint(GLint i)

-{

-   return i < 0 ? 0 : i;

-}

-

-

-static INLINE GLuint

-clamp_float_to_uint(GLfloat f)

-{

-   return f < 0.0F ? 0 : IROUND(f);

-}

-

-

-static INLINE GLuint

-clamp_half_to_uint(GLhalfARB h)

-{

-   GLfloat f = _mesa_half_to_float(h);

-   return f < 0.0F ? 0 : IROUND(f);

-}

-

-

-/**

- * \sa extract_float_rgba()

- */

-static void

-extract_uint_rgba(GLuint n, GLuint rgba[][4],

-                  GLenum srcFormat, GLenum srcType, const GLvoid *src,

-                  GLboolean swapBytes)

-{

-   GLint rSrc, gSrc, bSrc, aSrc;

-   GLint stride;

-   GLint rDst, bDst, gDst, aDst;

-   GLboolean intFormat;

-

-   ASSERT(srcFormat == GL_RED ||

-          srcFormat == GL_GREEN ||

-          srcFormat == GL_BLUE ||

-          srcFormat == GL_ALPHA ||

-          srcFormat == GL_LUMINANCE ||

-          srcFormat == GL_LUMINANCE_ALPHA ||

-          srcFormat == GL_INTENSITY ||

-          srcFormat == GL_RG ||

-          srcFormat == GL_RGB ||

-          srcFormat == GL_BGR ||

-          srcFormat == GL_RGBA ||

-          srcFormat == GL_BGRA ||

-          srcFormat == GL_ABGR_EXT ||

-          srcFormat == GL_DU8DV8_ATI ||

-          srcFormat == GL_DUDV_ATI ||

-          srcFormat == GL_RED_INTEGER_EXT ||

-          srcFormat == GL_GREEN_INTEGER_EXT ||

-          srcFormat == GL_BLUE_INTEGER_EXT ||

-          srcFormat == GL_ALPHA_INTEGER_EXT ||

-          srcFormat == GL_RGB_INTEGER_EXT ||

-          srcFormat == GL_RGBA_INTEGER_EXT ||

-          srcFormat == GL_BGR_INTEGER_EXT ||

-          srcFormat == GL_BGRA_INTEGER_EXT ||

-          srcFormat == GL_LUMINANCE_INTEGER_EXT ||

-          srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);

-

-   ASSERT(srcType == GL_UNSIGNED_BYTE ||

-          srcType == GL_BYTE ||

-          srcType == GL_UNSIGNED_SHORT ||

-          srcType == GL_SHORT ||

-          srcType == GL_UNSIGNED_INT ||

-          srcType == GL_INT ||

-          srcType == GL_HALF_FLOAT_ARB ||

-          srcType == GL_FLOAT ||

-          srcType == GL_UNSIGNED_BYTE_3_3_2 ||

-          srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||

-          srcType == GL_UNSIGNED_SHORT_5_6_5 ||

-          srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||

-          srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||

-          srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||

-          srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||

-          srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||

-          srcType == GL_UNSIGNED_INT_8_8_8_8 ||

-          srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||

-          srcType == GL_UNSIGNED_INT_10_10_10_2 ||

-          srcType == GL_UNSIGNED_INT_2_10_10_10_REV);

-

-   get_component_mapping(srcFormat,

-                         &rSrc, &gSrc, &bSrc, &aSrc,

-                         &rDst, &gDst, &bDst, &aDst);

-

-   stride = _mesa_components_in_format(srcFormat);

-

-   intFormat = _mesa_is_integer_format(srcFormat);

-

-#define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT, TYPE, CONVERSION)	\

-   if ((SRC_INDEX) < 0) {						\

-      GLuint i;								\

-      for (i = 0; i < n; i++) {						\

-         rgba[i][DST_INDEX] = DEFAULT;					\

-      }									\

-   }									\

-   else if (swapBytes) {						\

-      const TYPE *s = (const TYPE *) src;				\

-      GLuint i;								\

-      for (i = 0; i < n; i++) {						\

-         TYPE value = s[SRC_INDEX];					\

-         if (sizeof(TYPE) == 2) {					\

-            SWAP2BYTE(value);						\

-         }								\

-         else if (sizeof(TYPE) == 4) {					\

-            SWAP4BYTE(value);						\

-         }								\

-         rgba[i][DST_INDEX] = CONVERSION(value);                        \

-         s += stride;							\

-      }									\

-   }									\

-   else {								\

-      const TYPE *s = (const TYPE *) src;				\

-      GLuint i;								\

-      for (i = 0; i < n; i++) {						\

-         rgba[i][DST_INDEX] = CONVERSION(s[SRC_INDEX]);			\

-         s += stride;							\

-      }									\

-   }

-

-   switch (srcType) {

-      case GL_UNSIGNED_BYTE:

-         PROCESS(rSrc, RCOMP, 0, GLubyte, (GLuint));

-         PROCESS(gSrc, GCOMP, 0, GLubyte, (GLuint));

-         PROCESS(bSrc, BCOMP, 0, GLubyte, (GLuint));

-         PROCESS(aSrc, ACOMP, 1, GLubyte, (GLuint));

-         break;

-      case GL_BYTE:

-         PROCESS(rSrc, RCOMP, 0, GLbyte, clamp_byte_to_uint);

-         PROCESS(gSrc, GCOMP, 0, GLbyte, clamp_byte_to_uint);

-         PROCESS(bSrc, BCOMP, 0, GLbyte, clamp_byte_to_uint);

-         PROCESS(aSrc, ACOMP, 1, GLbyte, clamp_byte_to_uint);

-         break;

-      case GL_UNSIGNED_SHORT:

-         PROCESS(rSrc, RCOMP, 0, GLushort, (GLuint));

-         PROCESS(gSrc, GCOMP, 0, GLushort, (GLuint));

-         PROCESS(bSrc, BCOMP, 0, GLushort, (GLuint));

-         PROCESS(aSrc, ACOMP, 1, GLushort, (GLuint));

-         break;

-      case GL_SHORT:

-         PROCESS(rSrc, RCOMP, 0, GLshort, clamp_short_to_uint);

-         PROCESS(gSrc, GCOMP, 0, GLshort, clamp_short_to_uint);

-         PROCESS(bSrc, BCOMP, 0, GLshort, clamp_short_to_uint);

-         PROCESS(aSrc, ACOMP, 1, GLshort, clamp_short_to_uint);

-         break;

-      case GL_UNSIGNED_INT:

-         PROCESS(rSrc, RCOMP, 0, GLuint, (GLuint));

-         PROCESS(gSrc, GCOMP, 0, GLuint, (GLuint));

-         PROCESS(bSrc, BCOMP, 0, GLuint, (GLuint));

-         PROCESS(aSrc, ACOMP, 1, GLuint, (GLuint));

-         break;

-      case GL_INT:

-         PROCESS(rSrc, RCOMP, 0, GLint, clamp_int_to_uint);

-         PROCESS(gSrc, GCOMP, 0, GLint, clamp_int_to_uint);

-         PROCESS(bSrc, BCOMP, 0, GLint, clamp_int_to_uint);

-         PROCESS(aSrc, ACOMP, 1, GLint, clamp_int_to_uint);

-         break;

-      case GL_FLOAT:

-         PROCESS(rSrc, RCOMP, 0, GLfloat, clamp_float_to_uint);

-         PROCESS(gSrc, GCOMP, 0, GLfloat, clamp_float_to_uint);

-         PROCESS(bSrc, BCOMP, 0, GLfloat, clamp_float_to_uint);

-         PROCESS(aSrc, ACOMP, 1, GLfloat, clamp_float_to_uint);

-         break;

-      case GL_HALF_FLOAT_ARB:

-         PROCESS(rSrc, RCOMP, 0, GLhalfARB, clamp_half_to_uint);

-         PROCESS(gSrc, GCOMP, 0, GLhalfARB, clamp_half_to_uint);

-         PROCESS(bSrc, BCOMP, 0, GLhalfARB, clamp_half_to_uint);

-         PROCESS(aSrc, ACOMP, 1, GLhalfARB, clamp_half_to_uint);

-         break;

-      case GL_UNSIGNED_BYTE_3_3_2:

-         {

-            const GLubyte *ubsrc = (const GLubyte *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLubyte p = ubsrc[i];

-               rgba[i][rDst] = ((p >> 5)      );

-               rgba[i][gDst] = ((p >> 2) & 0x7);

-               rgba[i][bDst] = ((p     ) & 0x3);

-               rgba[i][aDst] = 1;

-            }

-         }

-         break;

-      case GL_UNSIGNED_BYTE_2_3_3_REV:

-         {

-            const GLubyte *ubsrc = (const GLubyte *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLubyte p = ubsrc[i];

-               rgba[i][rDst] = ((p     ) & 0x7);

-               rgba[i][gDst] = ((p >> 3) & 0x7);

-               rgba[i][bDst] = ((p >> 6)      );

-               rgba[i][aDst] = 1;

-            }

-         }

-         break;

-      case GL_UNSIGNED_SHORT_5_6_5:

-         if (swapBytes) {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               SWAP2BYTE(p);

-               rgba[i][rDst] = ((p >> 11)       );

-               rgba[i][gDst] = ((p >>  5) & 0x3f);

-               rgba[i][bDst] = ((p      ) & 0x1f);

-               rgba[i][aDst] = 1;

-            }

-         }

-         else {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               rgba[i][rDst] = ((p >> 11)       );

-               rgba[i][gDst] = ((p >>  5) & 0x3f);

-               rgba[i][bDst] = ((p      ) & 0x1f);

-               rgba[i][aDst] = 1;

-            }

-         }

-         break;

-      case GL_UNSIGNED_SHORT_5_6_5_REV:

-         if (swapBytes) {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               SWAP2BYTE(p);

-               rgba[i][rDst] = ((p      ) & 0x1f);

-               rgba[i][gDst] = ((p >>  5) & 0x3f);

-               rgba[i][bDst] = ((p >> 11)       );

-               rgba[i][aDst] = 1;

-            }

-         }

-         else {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               rgba[i][rDst] = ((p      ) & 0x1f);

-               rgba[i][gDst] = ((p >>  5) & 0x3f);

-               rgba[i][bDst] = ((p >> 11)       );

-               rgba[i][aDst] = 1;

-            }

-         }

-         break;

-      case GL_UNSIGNED_SHORT_4_4_4_4:

-         if (swapBytes) {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               SWAP2BYTE(p);

-               rgba[i][rDst] = ((p >> 12)      );

-               rgba[i][gDst] = ((p >>  8) & 0xf);

-               rgba[i][bDst] = ((p >>  4) & 0xf);

-               rgba[i][aDst] = ((p      ) & 0xf);

-            }

-         }

-         else {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               rgba[i][rDst] = ((p >> 12)      );

-               rgba[i][gDst] = ((p >>  8) & 0xf);

-               rgba[i][bDst] = ((p >>  4) & 0xf);

-               rgba[i][aDst] = ((p      ) & 0xf);

-            }

-         }

-         break;

-      case GL_UNSIGNED_SHORT_4_4_4_4_REV:

-         if (swapBytes) {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               SWAP2BYTE(p);

-               rgba[i][rDst] = ((p      ) & 0xf);

-               rgba[i][gDst] = ((p >>  4) & 0xf);

-               rgba[i][bDst] = ((p >>  8) & 0xf);

-               rgba[i][aDst] = ((p >> 12)      );

-            }

-         }

-         else {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               rgba[i][rDst] = ((p      ) & 0xf);

-               rgba[i][gDst] = ((p >>  4) & 0xf);

-               rgba[i][bDst] = ((p >>  8) & 0xf);

-               rgba[i][aDst] = ((p >> 12)      );

-            }

-         }

-         break;

-      case GL_UNSIGNED_SHORT_5_5_5_1:

-         if (swapBytes) {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               SWAP2BYTE(p);

-               rgba[i][rDst] = ((p >> 11)       );

-               rgba[i][gDst] = ((p >>  6) & 0x1f);

-               rgba[i][bDst] = ((p >>  1) & 0x1f);

-               rgba[i][aDst] = ((p      ) & 0x1 );

-            }

-         }

-         else {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               rgba[i][rDst] = ((p >> 11)       );

-               rgba[i][gDst] = ((p >>  6) & 0x1f);

-               rgba[i][bDst] = ((p >>  1) & 0x1f);

-               rgba[i][aDst] = ((p      ) & 0x1 );

-            }

-         }

-         break;

-      case GL_UNSIGNED_SHORT_1_5_5_5_REV:

-         if (swapBytes) {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               SWAP2BYTE(p);

-               rgba[i][rDst] = ((p      ) & 0x1f);

-               rgba[i][gDst] = ((p >>  5) & 0x1f);

-               rgba[i][bDst] = ((p >> 10) & 0x1f);

-               rgba[i][aDst] = ((p >> 15)       );

-            }

-         }

-         else {

-            const GLushort *ussrc = (const GLushort *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLushort p = ussrc[i];

-               rgba[i][rDst] = ((p      ) & 0x1f);

-               rgba[i][gDst] = ((p >>  5) & 0x1f);

-               rgba[i][bDst] = ((p >> 10) & 0x1f);

-               rgba[i][aDst] = ((p >> 15)       );

-            }

-         }

-         break;

-      case GL_UNSIGNED_INT_8_8_8_8:

-         if (swapBytes) {

-            const GLuint *uisrc = (const GLuint *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLuint p = uisrc[i];

-               rgba[i][rDst] = ((p      ) & 0xff);

-               rgba[i][gDst] = ((p >>  8) & 0xff);

-               rgba[i][bDst] = ((p >> 16) & 0xff);

-               rgba[i][aDst] = ((p >> 24)       );

-            }

-         }

-         else {

-            const GLuint *uisrc = (const GLuint *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLuint p = uisrc[i];

-               rgba[i][rDst] = ((p >> 24)       );

-               rgba[i][gDst] = ((p >> 16) & 0xff);

-               rgba[i][bDst] = ((p >>  8) & 0xff);

-               rgba[i][aDst] = ((p      ) & 0xff);

-            }

-         }

-         break;

-      case GL_UNSIGNED_INT_8_8_8_8_REV:

-         if (swapBytes) {

-            const GLuint *uisrc = (const GLuint *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLuint p = uisrc[i];

-               rgba[i][rDst] = ((p >> 24)       );

-               rgba[i][gDst] = ((p >> 16) & 0xff);

-               rgba[i][bDst] = ((p >>  8) & 0xff);

-               rgba[i][aDst] = ((p      ) & 0xff);

-            }

-         }

-         else {

-            const GLuint *uisrc = (const GLuint *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLuint p = uisrc[i];

-               rgba[i][rDst] = ((p      ) & 0xff);

-               rgba[i][gDst] = ((p >>  8) & 0xff);

-               rgba[i][bDst] = ((p >> 16) & 0xff);

-               rgba[i][aDst] = ((p >> 24)       );

-            }

-         }

-         break;

-      case GL_UNSIGNED_INT_10_10_10_2:

-         if (swapBytes) {

-            const GLuint *uisrc = (const GLuint *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLuint p = uisrc[i];

-               SWAP4BYTE(p);

-               rgba[i][rDst] = ((p >> 22)        );

-               rgba[i][gDst] = ((p >> 12) & 0x3ff);

-               rgba[i][bDst] = ((p >>  2) & 0x3ff);

-               rgba[i][aDst] = ((p      ) & 0x3  );

-            }

-         }

-         else {

-            const GLuint *uisrc = (const GLuint *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLuint p = uisrc[i];

-               rgba[i][rDst] = ((p >> 22)        );

-               rgba[i][gDst] = ((p >> 12) & 0x3ff);

-               rgba[i][bDst] = ((p >>  2) & 0x3ff);

-               rgba[i][aDst] = ((p      ) & 0x3  );

-            }

-         }

-         break;

-      case GL_UNSIGNED_INT_2_10_10_10_REV:

-         if (swapBytes) {

-            const GLuint *uisrc = (const GLuint *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLuint p = uisrc[i];

-               SWAP4BYTE(p);

-               rgba[i][rDst] = ((p      ) & 0x3ff);

-               rgba[i][gDst] = ((p >> 10) & 0x3ff);

-               rgba[i][bDst] = ((p >> 20) & 0x3ff);

-               rgba[i][aDst] = ((p >> 30)        );

-            }

-         }

-         else {

-            const GLuint *uisrc = (const GLuint *) src;

-            GLuint i;

-            for (i = 0; i < n; i ++) {

-               GLuint p = uisrc[i];

-               rgba[i][rDst] = ((p      ) & 0x3ff);

-               rgba[i][gDst] = ((p >> 10) & 0x3ff);

-               rgba[i][bDst] = ((p >> 20) & 0x3ff);

-               rgba[i][aDst] = ((p >> 30)        );

-            }

-         }

-         break;

-      default:

-         _mesa_problem(NULL, "bad srcType in extract uint data");

-         break;

-   }

-#undef PROCESS

-}

-

-

-

-/*

- * Unpack a row of color image data from a client buffer according to

- * the pixel unpacking parameters.

- * Return GLchan values in the specified dest image format.

- * This is used by glDrawPixels and glTexImage?D().

- * \param ctx - the context

- *         n - number of pixels in the span

- *         dstFormat - format of destination color array

- *         dest - the destination color array

- *         srcFormat - source image format

- *         srcType - source image  data type

- *         source - source image pointer

- *         srcPacking - pixel unpacking parameters

- *         transferOps - bitmask of IMAGE_*_BIT values of operations to apply

- *

- * XXX perhaps expand this to process whole images someday.

- */

-void

-_mesa_unpack_color_span_chan( struct gl_context *ctx,

-                              GLuint n, GLenum dstFormat, GLchan dest[],

-                              GLenum srcFormat, GLenum srcType,

-                              const GLvoid *source,

-                              const struct gl_pixelstore_attrib *srcPacking,

-                              GLbitfield transferOps )

-{

-   ASSERT(dstFormat == GL_ALPHA ||

-          dstFormat == GL_LUMINANCE ||

-          dstFormat == GL_LUMINANCE_ALPHA ||

-          dstFormat == GL_INTENSITY ||

-          dstFormat == GL_RED ||

-          dstFormat == GL_RG ||

-          dstFormat == GL_RGB ||

-          dstFormat == GL_RGBA ||

-          dstFormat == GL_COLOR_INDEX);

-

-   ASSERT(srcFormat == GL_RED ||

-          srcFormat == GL_GREEN ||

-          srcFormat == GL_BLUE ||

-          srcFormat == GL_ALPHA ||

-          srcFormat == GL_LUMINANCE ||

-          srcFormat == GL_LUMINANCE_ALPHA ||

-          srcFormat == GL_INTENSITY ||

-          srcFormat == GL_RG ||

-          srcFormat == GL_RGB ||

-          srcFormat == GL_BGR ||

-          srcFormat == GL_RGBA ||

-          srcFormat == GL_BGRA ||

-          srcFormat == GL_ABGR_EXT ||

-          srcFormat == GL_COLOR_INDEX);

-

-   ASSERT(srcType == GL_BITMAP ||

-          srcType == GL_UNSIGNED_BYTE ||

-          srcType == GL_BYTE ||

-          srcType == GL_UNSIGNED_SHORT ||

-          srcType == GL_SHORT ||

-          srcType == GL_UNSIGNED_INT ||

-          srcType == GL_INT ||

-          srcType == GL_HALF_FLOAT_ARB ||

-          srcType == GL_FLOAT ||

-          srcType == GL_UNSIGNED_BYTE_3_3_2 ||

-          srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||

-          srcType == GL_UNSIGNED_SHORT_5_6_5 ||

-          srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||

-          srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||

-          srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||

-          srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||

-          srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||

-          srcType == GL_UNSIGNED_INT_8_8_8_8 ||

-          srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||

-          srcType == GL_UNSIGNED_INT_10_10_10_2 ||

-          srcType == GL_UNSIGNED_INT_2_10_10_10_REV);

-

-   /* Try simple cases first */

-   if (transferOps == 0) {

-      if (srcType == CHAN_TYPE) {

-         if (dstFormat == GL_RGBA) {

-            if (srcFormat == GL_RGBA) {

-               memcpy( dest, source, n * 4 * sizeof(GLchan) );

-               return;

-            }

-            else if (srcFormat == GL_RGB) {

-               GLuint i;

-               const GLchan *src = (const GLchan *) source;

-               GLchan *dst = dest;

-               for (i = 0; i < n; i++) {

-                  dst[0] = src[0];

-                  dst[1] = src[1];

-                  dst[2] = src[2];

-                  dst[3] = CHAN_MAX;

-                  src += 3;

-                  dst += 4;

-               }

-               return;

-            }

-         }

-         else if (dstFormat == GL_RGB) {

-            if (srcFormat == GL_RGB) {

-               memcpy( dest, source, n * 3 * sizeof(GLchan) );

-               return;

-            }

-            else if (srcFormat == GL_RGBA) {

-               GLuint i;

-               const GLchan *src = (const GLchan *) source;

-               GLchan *dst = dest;

-               for (i = 0; i < n; i++) {

-                  dst[0] = src[0];

-                  dst[1] = src[1];

-                  dst[2] = src[2];

-                  src += 4;

-                  dst += 3;

-               }

-               return;

-            }

-         }

-         else if (dstFormat == srcFormat) {

-            GLint comps = _mesa_components_in_format(srcFormat);

-            assert(comps > 0);

-            memcpy( dest, source, n * comps * sizeof(GLchan) );

-            return;

-         }

-      }

-      /*

-       * Common situation, loading 8bit RGBA/RGB source images

-       * into 16/32 bit destination. (OSMesa16/32)

-       */

-      else if (srcType == GL_UNSIGNED_BYTE) {

-         if (dstFormat == GL_RGBA) {

-            if (srcFormat == GL_RGB) {

-               GLuint i;

-               const GLubyte *src = (const GLubyte *) source;

-               GLchan *dst = dest;

-               for (i = 0; i < n; i++) {

-                  dst[0] = UBYTE_TO_CHAN(src[0]);

-                  dst[1] = UBYTE_TO_CHAN(src[1]);

-                  dst[2] = UBYTE_TO_CHAN(src[2]);

-                  dst[3] = CHAN_MAX;

-                  src += 3;

-                  dst += 4;

-               }

-               return;

-            }

-            else if (srcFormat == GL_RGBA) {

-               GLuint i;

-               const GLubyte *src = (const GLubyte *) source;

-               GLchan *dst = dest;

-               for (i = 0; i < n; i++) {

-                  dst[0] = UBYTE_TO_CHAN(src[0]);

-                  dst[1] = UBYTE_TO_CHAN(src[1]);

-                  dst[2] = UBYTE_TO_CHAN(src[2]);

-                  dst[3] = UBYTE_TO_CHAN(src[3]);

-                  src += 4;

-                  dst += 4;

-               }

-               return;

-             }

-         }

-         else if (dstFormat == GL_RGB) {

-            if (srcFormat == GL_RGB) {

-               GLuint i;

-               const GLubyte *src = (const GLubyte *) source;

-               GLchan *dst = dest;

-               for (i = 0; i < n; i++) {

-                  dst[0] = UBYTE_TO_CHAN(src[0]);

-                  dst[1] = UBYTE_TO_CHAN(src[1]);

-                  dst[2] = UBYTE_TO_CHAN(src[2]);

-                  src += 3;

-                  dst += 3;

-               }

-               return;

-            }

-            else if (srcFormat == GL_RGBA) {

-               GLuint i;

-               const GLubyte *src = (const GLubyte *) source;

-               GLchan *dst = dest;

-               for (i = 0; i < n; i++) {

-                  dst[0] = UBYTE_TO_CHAN(src[0]);

-                  dst[1] = UBYTE_TO_CHAN(src[1]);

-                  dst[2] = UBYTE_TO_CHAN(src[2]);

-                  src += 4;

-                  dst += 3;

-               }

-               return;

-            }

-         }

-      }

-   }

-

-

-   /* general solution begins here */

-   {

-      GLint dstComponents;

-      GLint rDst, gDst, bDst, aDst, lDst, iDst;

-      GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));

-

-      if (!rgba) {

-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");

-         return;

-      }

-

-      dstComponents = _mesa_components_in_format( dstFormat );

-      /* source & dest image formats should have been error checked by now */

-      assert(dstComponents > 0);

-

-      /*

-       * Extract image data and convert to RGBA floats

-       */

-      if (srcFormat == GL_COLOR_INDEX) {

-         GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));

-

-         if (!indexes) {

-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");

-            return;

-         }

-

-         extract_uint_indexes(n, indexes, srcFormat, srcType, source,

-                              srcPacking);

-

-         if (dstFormat == GL_COLOR_INDEX) {

-            GLuint i;

-            _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);

-            /* convert to GLchan and return */

-            for (i = 0; i < n; i++) {

-               dest[i] = (GLchan) (indexes[i] & 0xff);

-            }

-            free(indexes);

-            free(rgba);

-            return;

-         }

-         else {

-            /* Convert indexes to RGBA */

-            if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {

-               _mesa_shift_and_offset_ci(ctx, n, indexes);

-            }

-            _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);

-         }

-

-         /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting

-          * with color indexes.

-          */

-         transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);

-

-         free(indexes);

-      }

-      else {

-         /* non-color index data */

-         extract_float_rgba(n, rgba, srcFormat, srcType, source,

-                            srcPacking->SwapBytes);

-      }

-

-      /* Need to clamp if returning GLubytes or GLushorts */

-#if CHAN_TYPE != GL_FLOAT

-      transferOps |= IMAGE_CLAMP_BIT;

-#endif

-

-      if (transferOps) {

-         _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);

-      }

-

-      get_component_indexes(dstFormat,

-                            &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);

-

-      /* Now return the GLchan data in the requested dstFormat */

-      if (rDst >= 0) {

-         GLchan *dst = dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            CLAMPED_FLOAT_TO_CHAN(dst[rDst], rgba[i][RCOMP]);

-            dst += dstComponents;

-         }

-      }

-

-      if (gDst >= 0) {

-         GLchan *dst = dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            CLAMPED_FLOAT_TO_CHAN(dst[gDst], rgba[i][GCOMP]);

-            dst += dstComponents;

-         }

-      }

-

-      if (bDst >= 0) {

-         GLchan *dst = dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            CLAMPED_FLOAT_TO_CHAN(dst[bDst], rgba[i][BCOMP]);

-            dst += dstComponents;

-         }

-      }

-

-      if (aDst >= 0) {

-         GLchan *dst = dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            CLAMPED_FLOAT_TO_CHAN(dst[aDst], rgba[i][ACOMP]);

-            dst += dstComponents;

-         }

-      }

-

-      if (iDst >= 0) {

-         GLchan *dst = dest;

-         GLuint i;

-         assert(iDst == 0);

-         assert(dstComponents == 1);

-         for (i = 0; i < n; i++) {

-            /* Intensity comes from red channel */

-            CLAMPED_FLOAT_TO_CHAN(dst[i], rgba[i][RCOMP]);

-         }

-      }

-

-      if (lDst >= 0) {

-         GLchan *dst = dest;

-         GLuint i;

-         assert(lDst == 0);

-         for (i = 0; i < n; i++) {

-            /* Luminance comes from red channel */

-            CLAMPED_FLOAT_TO_CHAN(dst[0], rgba[i][RCOMP]);

-            dst += dstComponents;

-         }

-      }

-

-      free(rgba);

-   }

-}

-

-

-/**

- * Same as _mesa_unpack_color_span_chan(), but return GLfloat data

- * instead of GLchan.

- */

-void

-_mesa_unpack_color_span_float( struct gl_context *ctx,

-                               GLuint n, GLenum dstFormat, GLfloat dest[],

-                               GLenum srcFormat, GLenum srcType,

-                               const GLvoid *source,

-                               const struct gl_pixelstore_attrib *srcPacking,

-                               GLbitfield transferOps )

-{

-   ASSERT(dstFormat == GL_ALPHA ||

-          dstFormat == GL_LUMINANCE ||

-          dstFormat == GL_LUMINANCE_ALPHA ||

-          dstFormat == GL_INTENSITY ||

-          dstFormat == GL_RED ||

-          dstFormat == GL_RG ||

-          dstFormat == GL_RGB ||

-          dstFormat == GL_RGBA ||

-          dstFormat == GL_COLOR_INDEX);

-

-   ASSERT(srcFormat == GL_RED ||

-          srcFormat == GL_GREEN ||

-          srcFormat == GL_BLUE ||

-          srcFormat == GL_ALPHA ||

-          srcFormat == GL_LUMINANCE ||

-          srcFormat == GL_LUMINANCE_ALPHA ||

-          srcFormat == GL_INTENSITY ||

-          srcFormat == GL_RG ||

-          srcFormat == GL_RGB ||

-          srcFormat == GL_BGR ||

-          srcFormat == GL_RGBA ||

-          srcFormat == GL_BGRA ||

-          srcFormat == GL_ABGR_EXT ||

-          srcFormat == GL_RED_INTEGER_EXT ||

-          srcFormat == GL_GREEN_INTEGER_EXT ||

-          srcFormat == GL_BLUE_INTEGER_EXT ||

-          srcFormat == GL_ALPHA_INTEGER_EXT ||

-          srcFormat == GL_RGB_INTEGER_EXT ||

-          srcFormat == GL_RGBA_INTEGER_EXT ||

-          srcFormat == GL_BGR_INTEGER_EXT ||

-          srcFormat == GL_BGRA_INTEGER_EXT ||

-          srcFormat == GL_LUMINANCE_INTEGER_EXT ||

-          srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT ||

-          srcFormat == GL_COLOR_INDEX);

-

-   ASSERT(srcType == GL_BITMAP ||

-          srcType == GL_UNSIGNED_BYTE ||

-          srcType == GL_BYTE ||

-          srcType == GL_UNSIGNED_SHORT ||

-          srcType == GL_SHORT ||

-          srcType == GL_UNSIGNED_INT ||

-          srcType == GL_INT ||

-          srcType == GL_HALF_FLOAT_ARB ||

-          srcType == GL_FLOAT ||

-          srcType == GL_UNSIGNED_BYTE_3_3_2 ||

-          srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||

-          srcType == GL_UNSIGNED_SHORT_5_6_5 ||

-          srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||

-          srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||

-          srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||

-          srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||

-          srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||

-          srcType == GL_UNSIGNED_INT_8_8_8_8 ||

-          srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||

-          srcType == GL_UNSIGNED_INT_10_10_10_2 ||

-          srcType == GL_UNSIGNED_INT_2_10_10_10_REV);

-

-   /* general solution, no special cases, yet */

-   {

-      GLint dstComponents;

-      GLint rDst, gDst, bDst, aDst, lDst, iDst;

-      GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));

-

-      if (!rgba) {

-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");

-         return;

-      }

-

-      dstComponents = _mesa_components_in_format( dstFormat );

-      /* source & dest image formats should have been error checked by now */

-      assert(dstComponents > 0);

-

-      /*

-       * Extract image data and convert to RGBA floats

-       */

-      if (srcFormat == GL_COLOR_INDEX) {

-         GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));

-

-         if (!indexes) {

-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");

-            free(rgba);

-            return;

-         }

-

-         extract_uint_indexes(n, indexes, srcFormat, srcType, source,

-                              srcPacking);

-

-         if (dstFormat == GL_COLOR_INDEX) {

-            GLuint i;

-            _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);

-            /* convert to GLchan and return */

-            for (i = 0; i < n; i++) {

-               dest[i] = (GLchan) (indexes[i] & 0xff);

-            }

-            free(indexes);

-            free(rgba);

-            return;

-         }

-         else {

-            /* Convert indexes to RGBA */

-            if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {

-               _mesa_shift_and_offset_ci(ctx, n, indexes);

-            }

-            _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);

-         }

-

-         /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting

-          * with color indexes.

-          */

-         transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);

-

-         free(indexes);

-      }

-      else {

-         /* non-color index data */

-         extract_float_rgba(n, rgba, srcFormat, srcType, source,

-                            srcPacking->SwapBytes);

-      }

-

-      if (transferOps) {

-         _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);

-      }

-

-      get_component_indexes(dstFormat,

-                            &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);

-

-      /* Now pack results in the requested dstFormat */

-      if (rDst >= 0) {

-         GLfloat *dst = dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[rDst] = rgba[i][RCOMP];

-            dst += dstComponents;

-         }

-      }

-

-      if (gDst >= 0) {

-         GLfloat *dst = dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[gDst] = rgba[i][GCOMP];

-            dst += dstComponents;

-         }

-      }

-

-      if (bDst >= 0) {

-         GLfloat *dst = dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[bDst] = rgba[i][BCOMP];

-            dst += dstComponents;

-         }

-      }

-

-      if (aDst >= 0) {

-         GLfloat *dst = dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[aDst] = rgba[i][ACOMP];

-            dst += dstComponents;

-         }

-      }

-

-      if (iDst >= 0) {

-         GLfloat *dst = dest;

-         GLuint i;

-         assert(iDst == 0);

-         assert(dstComponents == 1);

-         for (i = 0; i < n; i++) {

-            /* Intensity comes from red channel */

-            dst[i] = rgba[i][RCOMP];

-         }

-      }

-

-      if (lDst >= 0) {

-         GLfloat *dst = dest;

-         GLuint i;

-         assert(lDst == 0);

-         for (i = 0; i < n; i++) {

-            /* Luminance comes from red channel */

-            dst[0] = rgba[i][RCOMP];

-            dst += dstComponents;

-         }

-      }

-

-      free(rgba);

-   }

-}

-

-

-/**

- * Same as _mesa_unpack_color_span_chan(), but return GLuint data

- * instead of GLchan.

- * No pixel transfer ops are applied.

- */

-void

-_mesa_unpack_color_span_uint(struct gl_context *ctx,

-                             GLuint n, GLenum dstFormat, GLuint *dest,

-                             GLenum srcFormat, GLenum srcType,

-                             const GLvoid *source,

-                             const struct gl_pixelstore_attrib *srcPacking)

-{

-   GLuint (*rgba)[4] = (GLuint (*)[4]) malloc(n * 4 * sizeof(GLfloat));

-

-   if (!rgba) {

-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");

-      return;

-   }

-

-   ASSERT(dstFormat == GL_ALPHA ||

-          dstFormat == GL_LUMINANCE ||

-          dstFormat == GL_LUMINANCE_ALPHA ||

-          dstFormat == GL_INTENSITY ||

-          dstFormat == GL_RED ||

-          dstFormat == GL_RG ||

-          dstFormat == GL_RGB ||

-          dstFormat == GL_RGBA);

-

-   ASSERT(srcFormat == GL_RED ||

-          srcFormat == GL_GREEN ||

-          srcFormat == GL_BLUE ||

-          srcFormat == GL_ALPHA ||

-          srcFormat == GL_LUMINANCE ||

-          srcFormat == GL_LUMINANCE_ALPHA ||

-          srcFormat == GL_INTENSITY ||

-          srcFormat == GL_RG ||

-          srcFormat == GL_RGB ||

-          srcFormat == GL_BGR ||

-          srcFormat == GL_RGBA ||

-          srcFormat == GL_BGRA ||

-          srcFormat == GL_ABGR_EXT ||

-          srcFormat == GL_RED_INTEGER_EXT ||

-          srcFormat == GL_GREEN_INTEGER_EXT ||

-          srcFormat == GL_BLUE_INTEGER_EXT ||

-          srcFormat == GL_ALPHA_INTEGER_EXT ||

-          srcFormat == GL_RGB_INTEGER_EXT ||

-          srcFormat == GL_RGBA_INTEGER_EXT ||

-          srcFormat == GL_BGR_INTEGER_EXT ||

-          srcFormat == GL_BGRA_INTEGER_EXT ||

-          srcFormat == GL_LUMINANCE_INTEGER_EXT ||

-          srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);

-

-   ASSERT(srcType == GL_UNSIGNED_BYTE ||

-          srcType == GL_BYTE ||

-          srcType == GL_UNSIGNED_SHORT ||

-          srcType == GL_SHORT ||

-          srcType == GL_UNSIGNED_INT ||

-          srcType == GL_INT ||

-          srcType == GL_HALF_FLOAT_ARB ||

-          srcType == GL_FLOAT ||

-          srcType == GL_UNSIGNED_BYTE_3_3_2 ||

-          srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||

-          srcType == GL_UNSIGNED_SHORT_5_6_5 ||

-          srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||

-          srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||

-          srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||

-          srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||

-          srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||

-          srcType == GL_UNSIGNED_INT_8_8_8_8 ||

-          srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||

-          srcType == GL_UNSIGNED_INT_10_10_10_2 ||

-          srcType == GL_UNSIGNED_INT_2_10_10_10_REV);

-

-

-   /* Extract image data as uint[4] pixels */

-   extract_uint_rgba(n, rgba, srcFormat, srcType, source,

-                     srcPacking->SwapBytes);

-

-   if (dstFormat == GL_RGBA) {

-      /* simple case */

-      memcpy(dest, rgba, 4 * sizeof(GLuint) * n);

-   }

-   else {

-      /* general case */

-      GLint rDst, gDst, bDst, aDst, lDst, iDst;

-      GLint dstComponents = _mesa_components_in_format( dstFormat );

-

-      assert(dstComponents > 0);

-

-      get_component_indexes(dstFormat,

-                            &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);

-

-      /* Now pack values in the requested dest format */

-      if (rDst >= 0) {

-         GLuint *dst = dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[rDst] = rgba[i][RCOMP];

-            dst += dstComponents;

-         }

-      }

-

-      if (gDst >= 0) {

-         GLuint *dst = dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[gDst] = rgba[i][GCOMP];

-            dst += dstComponents;

-         }

-      }

-

-      if (bDst >= 0) {

-         GLuint *dst = dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[bDst] = rgba[i][BCOMP];

-            dst += dstComponents;

-         }

-      }

-

-      if (aDst >= 0) {

-         GLuint *dst = dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[aDst] = rgba[i][ACOMP];

-            dst += dstComponents;

-         }

-      }

-

-      if (iDst >= 0) {

-         GLuint *dst = dest;

-         GLuint i;

-         assert(iDst == 0);

-         assert(dstComponents == 1);

-         for (i = 0; i < n; i++) {

-            /* Intensity comes from red channel */

-            dst[i] = rgba[i][RCOMP];

-         }

-      }

-

-      if (lDst >= 0) {

-         GLuint *dst = dest;

-         GLuint i;

-         assert(lDst == 0);

-         for (i = 0; i < n; i++) {

-            /* Luminance comes from red channel */

-            dst[0] = rgba[i][RCOMP];

-            dst += dstComponents;

-         }

-      }

-   }

-

-   free(rgba);

-}

-

-

-

-/**

- * Similar to _mesa_unpack_color_span_float(), but for dudv data instead of rgba,

- * directly return GLbyte data, no transfer ops apply.

- */

-void

-_mesa_unpack_dudv_span_byte( struct gl_context *ctx,

-                             GLuint n, GLenum dstFormat, GLbyte dest[],

-                             GLenum srcFormat, GLenum srcType,

-                             const GLvoid *source,

-                             const struct gl_pixelstore_attrib *srcPacking,

-                             GLbitfield transferOps )

-{

-   ASSERT(dstFormat == GL_DUDV_ATI);

-   ASSERT(srcFormat == GL_DUDV_ATI);

-

-   ASSERT(srcType == GL_UNSIGNED_BYTE ||

-          srcType == GL_BYTE ||

-          srcType == GL_UNSIGNED_SHORT ||

-          srcType == GL_SHORT ||

-          srcType == GL_UNSIGNED_INT ||

-          srcType == GL_INT ||

-          srcType == GL_HALF_FLOAT_ARB ||

-          srcType == GL_FLOAT);

-

-   /* general solution */

-   {

-      GLint dstComponents;

-      GLbyte *dst = dest;

-      GLuint i;

-      GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));

-

-      if (!rgba) {

-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");

-         return;

-      }

-

-      dstComponents = _mesa_components_in_format( dstFormat );

-      /* source & dest image formats should have been error checked by now */

-      assert(dstComponents > 0);

-

-      /*

-       * Extract image data and convert to RGBA floats

-       */

-      extract_float_rgba(n, rgba, srcFormat, srcType, source,

-                         srcPacking->SwapBytes);

-

-

-      /* Now determine which color channels we need to produce.

-       * And determine the dest index (offset) within each color tuple.

-       */

-

-      /* Now pack results in the requested dstFormat */

-      for (i = 0; i < n; i++) {

-         /* not sure - need clamp[-1,1] here? */

-         dst[0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);

-         dst[1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);

-         dst += dstComponents;

-      }

-

-      free(rgba);

-   }

-}

-

-/*

- * Unpack a row of color index data from a client buffer according to

- * the pixel unpacking parameters.

- * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.

- *

- * Args:  ctx - the context

- *        n - number of pixels

- *        dstType - destination data type

- *        dest - destination array

- *        srcType - source pixel type

- *        source - source data pointer

- *        srcPacking - pixel unpacking parameters

- *        transferOps - the pixel transfer operations to apply

- */

-void

-_mesa_unpack_index_span( struct gl_context *ctx, GLuint n,

-                         GLenum dstType, GLvoid *dest,

-                         GLenum srcType, const GLvoid *source,

-                         const struct gl_pixelstore_attrib *srcPacking,

-                         GLbitfield transferOps )

-{

-   ASSERT(srcType == GL_BITMAP ||

-          srcType == GL_UNSIGNED_BYTE ||

-          srcType == GL_BYTE ||

-          srcType == GL_UNSIGNED_SHORT ||

-          srcType == GL_SHORT ||

-          srcType == GL_UNSIGNED_INT ||

-          srcType == GL_INT ||

-          srcType == GL_HALF_FLOAT_ARB ||

-          srcType == GL_FLOAT);

-

-   ASSERT(dstType == GL_UNSIGNED_BYTE ||

-          dstType == GL_UNSIGNED_SHORT ||

-          dstType == GL_UNSIGNED_INT);

-

-

-   transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);

-

-   /*

-    * Try simple cases first

-    */

-   if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE

-       && dstType == GL_UNSIGNED_BYTE) {

-      memcpy(dest, source, n * sizeof(GLubyte));

-   }

-   else if (transferOps == 0 && srcType == GL_UNSIGNED_INT

-            && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {

-      memcpy(dest, source, n * sizeof(GLuint));

-   }

-   else {

-      /*

-       * general solution

-       */

-      GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));

-

-      if (!indexes) {

-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");

-         return;

-      }

-

-      extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,

-                           srcPacking);

-

-      if (transferOps)

-         _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);

-

-      /* convert to dest type */

-      switch (dstType) {

-         case GL_UNSIGNED_BYTE:

-            {

-               GLubyte *dst = (GLubyte *) dest;

-               GLuint i;

-               for (i = 0; i < n; i++) {

-                  dst[i] = (GLubyte) (indexes[i] & 0xff);

-               }

-            }

-            break;

-         case GL_UNSIGNED_SHORT:

-            {

-               GLuint *dst = (GLuint *) dest;

-               GLuint i;

-               for (i = 0; i < n; i++) {

-                  dst[i] = (GLushort) (indexes[i] & 0xffff);

-               }

-            }

-            break;

-         case GL_UNSIGNED_INT:

-            memcpy(dest, indexes, n * sizeof(GLuint));

-            break;

-         default:

-            _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");

-      }

-

-      free(indexes);

-   }

-}

-

-

-void

-_mesa_pack_index_span( struct gl_context *ctx, GLuint n,

-                       GLenum dstType, GLvoid *dest, const GLuint *source,

-                       const struct gl_pixelstore_attrib *dstPacking,

-                       GLbitfield transferOps )

-{

-   GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));

-

-   if (!indexes) {

-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");

-      return;

-   }

-

-   transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);

-

-   if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {

-      /* make a copy of input */

-      memcpy(indexes, source, n * sizeof(GLuint));

-      _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);

-      source = indexes;

-   }

-

-   switch (dstType) {

-   case GL_UNSIGNED_BYTE:

-      {

-         GLubyte *dst = (GLubyte *) dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            *dst++ = (GLubyte) source[i];

-         }

-      }

-      break;

-   case GL_BYTE:

-      {

-         GLbyte *dst = (GLbyte *) dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[i] = (GLbyte) source[i];

-         }

-      }

-      break;

-   case GL_UNSIGNED_SHORT:

-      {

-         GLushort *dst = (GLushort *) dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[i] = (GLushort) source[i];

-         }

-         if (dstPacking->SwapBytes) {

-            _mesa_swap2( (GLushort *) dst, n );

-         }

-      }

-      break;

-   case GL_SHORT:

-      {

-         GLshort *dst = (GLshort *) dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[i] = (GLshort) source[i];

-         }

-         if (dstPacking->SwapBytes) {

-            _mesa_swap2( (GLushort *) dst, n );

-         }

-      }

-      break;

-   case GL_UNSIGNED_INT:

-      {

-         GLuint *dst = (GLuint *) dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[i] = (GLuint) source[i];

-         }

-         if (dstPacking->SwapBytes) {

-            _mesa_swap4( (GLuint *) dst, n );

-         }

-      }

-      break;

-   case GL_INT:

-      {

-         GLint *dst = (GLint *) dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[i] = (GLint) source[i];

-         }

-         if (dstPacking->SwapBytes) {

-            _mesa_swap4( (GLuint *) dst, n );

-         }

-      }

-      break;

-   case GL_FLOAT:

-      {

-         GLfloat *dst = (GLfloat *) dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[i] = (GLfloat) source[i];

-         }

-         if (dstPacking->SwapBytes) {

-            _mesa_swap4( (GLuint *) dst, n );

-         }

-      }

-      break;

-   case GL_HALF_FLOAT_ARB:

-      {

-         GLhalfARB *dst = (GLhalfARB *) dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[i] = _mesa_float_to_half((GLfloat) source[i]);

-         }

-         if (dstPacking->SwapBytes) {

-            _mesa_swap2( (GLushort *) dst, n );

-         }

-      }

-      break;

-   default:

-      _mesa_problem(ctx, "bad type in _mesa_pack_index_span");

-   }

-

-   free(indexes);

-}

-

-

-/*

- * Unpack a row of stencil data from a client buffer according to

- * the pixel unpacking parameters.

- * This is (or will be) used by glDrawPixels

- *

- * Args:  ctx - the context

- *        n - number of pixels

- *        dstType - destination data type

- *        dest - destination array

- *        srcType - source pixel type

- *        source - source data pointer

- *        srcPacking - pixel unpacking parameters

- *        transferOps - apply offset/bias/lookup ops?

- */

-void

-_mesa_unpack_stencil_span( struct gl_context *ctx, GLuint n,

-                           GLenum dstType, GLvoid *dest,

-                           GLenum srcType, const GLvoid *source,

-                           const struct gl_pixelstore_attrib *srcPacking,

-                           GLbitfield transferOps )

-{

-   ASSERT(srcType == GL_BITMAP ||

-          srcType == GL_UNSIGNED_BYTE ||

-          srcType == GL_BYTE ||

-          srcType == GL_UNSIGNED_SHORT ||

-          srcType == GL_SHORT ||

-          srcType == GL_UNSIGNED_INT ||

-          srcType == GL_INT ||

-          srcType == GL_UNSIGNED_INT_24_8_EXT ||

-          srcType == GL_HALF_FLOAT_ARB ||

-          srcType == GL_FLOAT);

-

-   ASSERT(dstType == GL_UNSIGNED_BYTE ||

-          dstType == GL_UNSIGNED_SHORT ||

-          dstType == GL_UNSIGNED_INT);

-

-   /* only shift and offset apply to stencil */

-   transferOps &= IMAGE_SHIFT_OFFSET_BIT;

-

-   /*

-    * Try simple cases first

-    */

-   if (transferOps == 0 &&

-       !ctx->Pixel.MapStencilFlag &&

-       srcType == GL_UNSIGNED_BYTE &&

-       dstType == GL_UNSIGNED_BYTE) {

-      memcpy(dest, source, n * sizeof(GLubyte));

-   }

-   else if (transferOps == 0 &&

-            !ctx->Pixel.MapStencilFlag &&

-            srcType == GL_UNSIGNED_INT &&

-            dstType == GL_UNSIGNED_INT &&

-            !srcPacking->SwapBytes) {

-      memcpy(dest, source, n * sizeof(GLuint));

-   }

-   else {

-      /*

-       * general solution

-       */

-      GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));

-

-      if (!indexes) {

-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil unpacking");

-         return;

-      }

-

-      extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source,

-                           srcPacking);

-

-      if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {

-         /* shift and offset indexes */

-         _mesa_shift_and_offset_ci(ctx, n, indexes);

-      }

-

-      if (ctx->Pixel.MapStencilFlag) {

-         /* Apply stencil lookup table */

-         const GLuint mask = ctx->PixelMaps.StoS.Size - 1;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            indexes[i] = (GLuint)ctx->PixelMaps.StoS.Map[ indexes[i] & mask ];

-         }

-      }

-

-      /* convert to dest type */

-      switch (dstType) {

-         case GL_UNSIGNED_BYTE:

-            {

-               GLubyte *dst = (GLubyte *) dest;

-               GLuint i;

-               for (i = 0; i < n; i++) {

-                  dst[i] = (GLubyte) (indexes[i] & 0xff);

-               }

-            }

-            break;

-         case GL_UNSIGNED_SHORT:

-            {

-               GLuint *dst = (GLuint *) dest;

-               GLuint i;

-               for (i = 0; i < n; i++) {

-                  dst[i] = (GLushort) (indexes[i] & 0xffff);

-               }

-            }

-            break;

-         case GL_UNSIGNED_INT:

-            memcpy(dest, indexes, n * sizeof(GLuint));

-            break;

-         default:

-            _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");

-      }

-

-      free(indexes);

-   }

-}

-

-

-void

-_mesa_pack_stencil_span( struct gl_context *ctx, GLuint n,

-                         GLenum dstType, GLvoid *dest, const GLstencil *source,

-                         const struct gl_pixelstore_attrib *dstPacking )

-{

-   GLstencil *stencil = (GLstencil *) malloc(n * sizeof(GLstencil));

-

-   if (!stencil) {

-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil packing");

-      return;

-   }

-

-   if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||

-       ctx->Pixel.MapStencilFlag) {

-      /* make a copy of input */

-      memcpy(stencil, source, n * sizeof(GLstencil));

-      _mesa_apply_stencil_transfer_ops(ctx, n, stencil);

-      source = stencil;

-   }

-

-   switch (dstType) {

-   case GL_UNSIGNED_BYTE:

-      if (sizeof(GLstencil) == 1) {

-         memcpy( dest, source, n );

-      }

-      else {

-         GLubyte *dst = (GLubyte *) dest;

-         GLuint i;

-         for (i=0;i<n;i++) {

-            dst[i] = (GLubyte) source[i];

-         }

-      }

-      break;

-   case GL_BYTE:

-      {

-         GLbyte *dst = (GLbyte *) dest;

-         GLuint i;

-         for (i=0;i<n;i++) {

-            dst[i] = (GLbyte) (source[i] & 0x7f);

-         }

-      }

-      break;

-   case GL_UNSIGNED_SHORT:

-      {

-         GLushort *dst = (GLushort *) dest;

-         GLuint i;

-         for (i=0;i<n;i++) {

-            dst[i] = (GLushort) source[i];

-         }

-         if (dstPacking->SwapBytes) {

-            _mesa_swap2( (GLushort *) dst, n );

-         }

-      }

-      break;

-   case GL_SHORT:

-      {

-         GLshort *dst = (GLshort *) dest;

-         GLuint i;

-         for (i=0;i<n;i++) {

-            dst[i] = (GLshort) source[i];

-         }

-         if (dstPacking->SwapBytes) {

-            _mesa_swap2( (GLushort *) dst, n );

-         }

-      }

-      break;

-   case GL_UNSIGNED_INT:

-      {

-         GLuint *dst = (GLuint *) dest;

-         GLuint i;

-         for (i=0;i<n;i++) {

-            dst[i] = (GLuint) source[i];

-         }

-         if (dstPacking->SwapBytes) {

-            _mesa_swap4( (GLuint *) dst, n );

-         }

-      }

-      break;

-   case GL_INT:

-      {

-         GLint *dst = (GLint *) dest;

-         GLuint i;

-         for (i=0;i<n;i++) {

-            dst[i] = (GLint) source[i];

-         }

-         if (dstPacking->SwapBytes) {

-            _mesa_swap4( (GLuint *) dst, n );

-         }

-      }

-      break;

-   case GL_FLOAT:

-      {

-         GLfloat *dst = (GLfloat *) dest;

-         GLuint i;

-         for (i=0;i<n;i++) {

-            dst[i] = (GLfloat) source[i];

-         }

-         if (dstPacking->SwapBytes) {

-            _mesa_swap4( (GLuint *) dst, n );

-         }

-      }

-      break;

-   case GL_HALF_FLOAT_ARB:

-      {

-         GLhalfARB *dst = (GLhalfARB *) dest;

-         GLuint i;

-         for (i=0;i<n;i++) {

-            dst[i] = _mesa_float_to_half( (float) source[i] );

-         }

-         if (dstPacking->SwapBytes) {

-            _mesa_swap2( (GLushort *) dst, n );

-         }

-      }

-      break;

-   case GL_BITMAP:

-      if (dstPacking->LsbFirst) {

-         GLubyte *dst = (GLubyte *) dest;

-         GLint shift = 0;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            if (shift == 0)

-               *dst = 0;

-            *dst |= ((source[i] != 0) << shift);

-            shift++;

-            if (shift == 8) {

-               shift = 0;

-               dst++;

-            }

-         }

-      }

-      else {

-         GLubyte *dst = (GLubyte *) dest;

-         GLint shift = 7;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            if (shift == 7)

-               *dst = 0;

-            *dst |= ((source[i] != 0) << shift);

-            shift--;

-            if (shift < 0) {

-               shift = 7;

-               dst++;

-            }

-         }

-      }

-      break;

-   default:

-      _mesa_problem(ctx, "bad type in _mesa_pack_index_span");

-   }

-

-   free(stencil);

-}

-

-#define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT)                              \

-    do {                                                                \

-        GLuint i;                                                       \

-        const GLTYPE *src = (const GLTYPE *)source;                     \

-        for (i = 0; i < n; i++) {                                       \

-            GLTYPE value = src[i];                                      \

-            if (srcPacking->SwapBytes) {                                \

-                if (sizeof(GLTYPE) == 2) {                              \

-                    SWAP2BYTE(value);                                   \

-                } else if (sizeof(GLTYPE) == 4) {                       \

-                    SWAP4BYTE(value);                                   \

-                }                                                       \

-            }                                                           \

-            depthValues[i] = GLTYPE2FLOAT(value);                       \

-        }                                                               \

-    } while (0)

-

-

-/**

- * Unpack a row of depth/z values from memory, returning GLushort, GLuint

- * or GLfloat values.

- * The glPixelTransfer (scale/bias) params will be applied.

- *

- * \param dstType  one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT

- * \param depthMax  max value for returned GLushort or GLuint values

- *                  (ignored for GLfloat).

- */

-void

-_mesa_unpack_depth_span( struct gl_context *ctx, GLuint n,

-                         GLenum dstType, GLvoid *dest, GLuint depthMax,

-                         GLenum srcType, const GLvoid *source,

-                         const struct gl_pixelstore_attrib *srcPacking )

-{

-   GLfloat *depthTemp, *depthValues;

-   GLboolean needClamp = GL_FALSE;

-

-   /* Look for special cases first.

-    * Not only are these faster, they're less prone to numeric conversion

-    * problems.  Otherwise, converting from an int type to a float then

-    * back to an int type can introduce errors that will show up as

-    * artifacts in things like depth peeling which uses glCopyTexImage.

-    */

-   if (ctx->Pixel.DepthScale == 1.0 && ctx->Pixel.DepthBias == 0.0) {

-      if (srcType == GL_UNSIGNED_INT && dstType == GL_UNSIGNED_SHORT) {

-         const GLuint *src = (const GLuint *) source;

-         GLushort *dst = (GLushort *) dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[i] = src[i] >> 16;

-         }

-         return;

-      }

-      if (srcType == GL_UNSIGNED_SHORT

-          && dstType == GL_UNSIGNED_INT

-          && depthMax == 0xffffffff) {

-         const GLushort *src = (const GLushort *) source;

-         GLuint *dst = (GLuint *) dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[i] = src[i] | (src[i] << 16);

-         }

-         return;

-      }

-      if (srcType == GL_UNSIGNED_INT_24_8

-          && dstType == GL_UNSIGNED_INT

-          && depthMax == 0xffffff) {

-         const GLuint *src = (const GLuint *) source;

-         GLuint *dst = (GLuint *) dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[i] = src[i] >> 8;

-         }

-         return;

-      }

-      /* XXX may want to add additional cases here someday */

-   }

-

-   /* general case path follows */

-

-   depthTemp = (GLfloat *) malloc(n * sizeof(GLfloat));

-   if (!depthTemp) {

-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");

-      return;

-   }

-

-   if (dstType == GL_FLOAT) {

-      depthValues = (GLfloat *) dest;

-   }

-   else {

-      depthValues = depthTemp;

-   }

-

-   /* Convert incoming values to GLfloat.  Some conversions will require

-    * clamping, below.

-    */

-   switch (srcType) {

-      case GL_BYTE:

-         DEPTH_VALUES(GLbyte, BYTE_TO_FLOAT);

-         needClamp = GL_TRUE;

-         break;

-      case GL_UNSIGNED_BYTE:

-         DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT);

-         break;

-      case GL_SHORT:

-         DEPTH_VALUES(GLshort, SHORT_TO_FLOAT);

-         needClamp = GL_TRUE;

-         break;

-      case GL_UNSIGNED_SHORT:

-         DEPTH_VALUES(GLushort, USHORT_TO_FLOAT);

-         break;

-      case GL_INT:

-         DEPTH_VALUES(GLint, INT_TO_FLOAT);

-         needClamp = GL_TRUE;

-         break;

-      case GL_UNSIGNED_INT:

-         DEPTH_VALUES(GLuint, UINT_TO_FLOAT);

-         break;

-      case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */

-         if (dstType == GL_UNSIGNED_INT_24_8_EXT &&

-             depthMax == 0xffffff &&

-             ctx->Pixel.DepthScale == 1.0 &&

-             ctx->Pixel.DepthBias == 0.0) {

-            const GLuint *src = (const GLuint *) source;

-            GLuint *zValues = (GLuint *) dest;

-            GLuint i;

-            for (i = 0; i < n; i++) {

-                GLuint value = src[i];

-                if (srcPacking->SwapBytes) {

-                    SWAP4BYTE(value);

-                }

-                zValues[i] = value & 0xffffff00;

-            }

-            return;

-         }

-         else {

-            const GLuint *src = (const GLuint *) source;

-            const GLfloat scale = 1.0f / 0xffffff;

-            GLuint i;

-            for (i = 0; i < n; i++) {

-                GLuint value = src[i];

-                if (srcPacking->SwapBytes) {

-                    SWAP4BYTE(value);

-                }

-                depthValues[i] = (value >> 8) * scale;

-            }

-         }

-         break;

-      case GL_FLOAT:

-         DEPTH_VALUES(GLfloat, 1*);

-         needClamp = GL_TRUE;

-         break;

-      case GL_HALF_FLOAT_ARB:

-         {

-            GLuint i;

-            const GLhalfARB *src = (const GLhalfARB *) source;

-            for (i = 0; i < n; i++) {

-               GLhalfARB value = src[i];

-               if (srcPacking->SwapBytes) {

-                  SWAP2BYTE(value);

-               }

-               depthValues[i] = _mesa_half_to_float(value);

-            }

-            needClamp = GL_TRUE;

-         }

-         break;

-      default:

-         _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");

-         free(depthTemp);

-         return;

-   }

-

-   /* apply depth scale and bias */

-   {

-      const GLfloat scale = ctx->Pixel.DepthScale;

-      const GLfloat bias = ctx->Pixel.DepthBias;

-      if (scale != 1.0 || bias != 0.0) {

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            depthValues[i] = depthValues[i] * scale + bias;

-         }

-         needClamp = GL_TRUE;

-      }

-   }

-

-   /* clamp to [0, 1] */

-   if (needClamp) {

-      GLuint i;

-      for (i = 0; i < n; i++) {

-         depthValues[i] = (GLfloat)CLAMP(depthValues[i], 0.0, 1.0);

-      }

-   }

-

-   /*

-    * Convert values to dstType

-    */

-   if (dstType == GL_UNSIGNED_INT) {

-      GLuint *zValues = (GLuint *) dest;

-      GLuint i;

-      if (depthMax <= 0xffffff) {

-         /* no overflow worries */

-         for (i = 0; i < n; i++) {

-            zValues[i] = (GLuint) (depthValues[i] * (GLfloat) depthMax);

-         }

-      }

-      else {

-         /* need to use double precision to prevent overflow problems */

-         for (i = 0; i < n; i++) {

-            GLdouble z = depthValues[i] * (GLfloat) depthMax;

-            if (z >= (GLdouble) 0xffffffff)

-               zValues[i] = 0xffffffff;

-            else

-               zValues[i] = (GLuint) z;

-         }

-      }

-   }

-   else if (dstType == GL_UNSIGNED_SHORT) {

-      GLushort *zValues = (GLushort *) dest;

-      GLuint i;

-      ASSERT(depthMax <= 0xffff);

-      for (i = 0; i < n; i++) {

-         zValues[i] = (GLushort) (depthValues[i] * (GLfloat) depthMax);

-      }

-   }

-   else {

-      ASSERT(dstType == GL_FLOAT);

-      /*ASSERT(depthMax == 1.0F);*/

-   }

-

-   free(depthTemp);

-}

-

-

-/*

- * Pack an array of depth values.  The values are floats in [0,1].

- */

-void

-_mesa_pack_depth_span( struct gl_context *ctx, GLuint n, GLvoid *dest,

-                       GLenum dstType, const GLfloat *depthSpan,

-                       const struct gl_pixelstore_attrib *dstPacking )

-{

-   GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));

-   if (!depthCopy) {

-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");

-      return;

-   }

-

-   if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {

-      memcpy(depthCopy, depthSpan, n * sizeof(GLfloat));

-      _mesa_scale_and_bias_depth(ctx, n, depthCopy);

-      depthSpan = depthCopy;

-   }

-

-   switch (dstType) {

-   case GL_UNSIGNED_BYTE:

-      {

-         GLubyte *dst = (GLubyte *) dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );

-         }

-      }

-      break;

-   case GL_BYTE:

-      {

-         GLbyte *dst = (GLbyte *) dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[i] = FLOAT_TO_BYTE( depthSpan[i] );

-         }

-      }

-      break;

-   case GL_UNSIGNED_SHORT:

-      {

-         GLushort *dst = (GLushort *) dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]);

-         }

-         if (dstPacking->SwapBytes) {

-            _mesa_swap2( (GLushort *) dst, n );

-         }

-      }

-      break;

-   case GL_SHORT:

-      {

-         GLshort *dst = (GLshort *) dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[i] = FLOAT_TO_SHORT( depthSpan[i] );

-         }

-         if (dstPacking->SwapBytes) {

-            _mesa_swap2( (GLushort *) dst, n );

-         }

-      }

-      break;

-   case GL_UNSIGNED_INT:

-      {

-         GLuint *dst = (GLuint *) dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[i] = FLOAT_TO_UINT( depthSpan[i] );

-         }

-         if (dstPacking->SwapBytes) {

-            _mesa_swap4( (GLuint *) dst, n );

-         }

-      }

-      break;

-   case GL_INT:

-      {

-         GLint *dst = (GLint *) dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[i] = FLOAT_TO_INT( depthSpan[i] );

-         }

-         if (dstPacking->SwapBytes) {

-            _mesa_swap4( (GLuint *) dst, n );

-         }

-      }

-      break;

-   case GL_FLOAT:

-      {

-         GLfloat *dst = (GLfloat *) dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[i] = depthSpan[i];

-         }

-         if (dstPacking->SwapBytes) {

-            _mesa_swap4( (GLuint *) dst, n );

-         }

-      }

-      break;

-   case GL_HALF_FLOAT_ARB:

-      {

-         GLhalfARB *dst = (GLhalfARB *) dest;

-         GLuint i;

-         for (i = 0; i < n; i++) {

-            dst[i] = _mesa_float_to_half(depthSpan[i]);

-         }

-         if (dstPacking->SwapBytes) {

-            _mesa_swap2( (GLushort *) dst, n );

-         }

-      }

-      break;

-   default:

-      _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");

-   }

-

-   free(depthCopy);

-}

-

-

-

-/**

- * Pack depth and stencil values as GL_DEPTH_STENCIL/GL_UNSIGNED_INT_24_8.

- */

-void

-_mesa_pack_depth_stencil_span(struct gl_context *ctx, GLuint n, GLuint *dest,

-                              const GLfloat *depthVals,

-                              const GLstencil *stencilVals,

-                              const struct gl_pixelstore_attrib *dstPacking)

-{

-   GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));

-   GLstencil *stencilCopy = (GLstencil *) malloc(n * sizeof(GLstencil));

-   GLuint i;

-

-   if (!depthCopy || !stencilCopy) {

-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");

-      free(depthCopy);

-      free(stencilCopy);

-      return;

-   }

-

-   if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {

-      memcpy(depthCopy, depthVals, n * sizeof(GLfloat));

-      _mesa_scale_and_bias_depth(ctx, n, depthCopy);

-      depthVals = depthCopy;

-   }

-

-   if (ctx->Pixel.IndexShift ||

-       ctx->Pixel.IndexOffset ||

-       ctx->Pixel.MapStencilFlag) {

-      memcpy(stencilCopy, stencilVals, n * sizeof(GLstencil));

-      _mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy);

-      stencilVals = stencilCopy;

-   }

-

-   for (i = 0; i < n; i++) {

-      GLuint z = (GLuint) (depthVals[i] * 0xffffff);

-      dest[i] = (z << 8) | (stencilVals[i] & 0xff);

-   }

-

-   if (dstPacking->SwapBytes) {

-      _mesa_swap4(dest, n);

-   }

-

-   free(depthCopy);

-   free(stencilCopy);

-}

-

-

-

-

-/**

- * Unpack image data.  Apply byte swapping, byte flipping (bitmap).

- * Return all image data in a contiguous block.  This is used when we

- * compile glDrawPixels, glTexImage, etc into a display list.  We

- * need a copy of the data in a standard format.

- */

-void *

-_mesa_unpack_image( GLuint dimensions,

-                    GLsizei width, GLsizei height, GLsizei depth,

-                    GLenum format, GLenum type, const GLvoid *pixels,

-                    const struct gl_pixelstore_attrib *unpack )

-{

-   GLint bytesPerRow, compsPerRow;

-   GLboolean flipBytes, swap2, swap4;

-

-   if (!pixels)

-      return NULL;  /* not necessarily an error */

-

-   if (width <= 0 || height <= 0 || depth <= 0)

-      return NULL;  /* generate error later */

-

-   if (type == GL_BITMAP) {

-      bytesPerRow = (width + 7) >> 3;

-      flipBytes = unpack->LsbFirst;

-      swap2 = swap4 = GL_FALSE;

-      compsPerRow = 0;

-   }

-   else {

-      const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);

-      GLint components = _mesa_components_in_format(format);

-      GLint bytesPerComp;

-

-      if (_mesa_type_is_packed(type))

-          components = 1;

-

-      if (bytesPerPixel <= 0 || components <= 0)

-         return NULL;   /* bad format or type.  generate error later */

-      bytesPerRow = bytesPerPixel * width;

-      bytesPerComp = bytesPerPixel / components;

-      flipBytes = GL_FALSE;

-      swap2 = (bytesPerComp == 2) && unpack->SwapBytes;

-      swap4 = (bytesPerComp == 4) && unpack->SwapBytes;

-      compsPerRow = components * width;

-      assert(compsPerRow >= width);

-   }

-

-   {

-      GLubyte *destBuffer

-         = (GLubyte *) malloc(bytesPerRow * height * depth);

-      GLubyte *dst;

-      GLint img, row;

-      if (!destBuffer)

-         return NULL;   /* generate GL_OUT_OF_MEMORY later */

-

-      dst = destBuffer;

-      for (img = 0; img < depth; img++) {

-         for (row = 0; row < height; row++) {

-            const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels,

-                               width, height, format, type, img, row, 0);

-

-            if ((type == GL_BITMAP) && (unpack->SkipPixels & 0x7)) {

-               GLint i;

-               flipBytes = GL_FALSE;

-               if (unpack->LsbFirst) {

-                  GLubyte srcMask = 1 << (unpack->SkipPixels & 0x7);

-                  GLubyte dstMask = 128;

-                  const GLubyte *s = src;

-                  GLubyte *d = dst;

-                  *d = 0;

-                  for (i = 0; i < width; i++) {

-                     if (*s & srcMask) {

-                        *d |= dstMask;

-                     }      

-                     if (srcMask == 128) {

-                        srcMask = 1;

-                        s++;

-                     }

-                     else {

-                        srcMask = srcMask << 1;

-                     }

-                     if (dstMask == 1) {

-                        dstMask = 128;

-                        d++;

-                        *d = 0;

-                     }

-                     else {

-                        dstMask = dstMask >> 1;

-                     }

-                  }

-               }

-               else {

-                  GLubyte srcMask = 128 >> (unpack->SkipPixels & 0x7);

-                  GLubyte dstMask = 128;

-                  const GLubyte *s = src;

-                  GLubyte *d = dst;

-                  *d = 0;

-                  for (i = 0; i < width; i++) {

-                     if (*s & srcMask) {

-                        *d |= dstMask;

-                     }

-                     if (srcMask == 1) {

-                        srcMask = 128;

-                        s++;

-                     }

-                     else {

-                        srcMask = srcMask >> 1;

-                     }

-                     if (dstMask == 1) {

-                        dstMask = 128;

-                        d++;

-                        *d = 0;

-                     }

-                     else {

-                        dstMask = dstMask >> 1;

-                     }      

-                  }

-               }

-            }

-            else {

-               memcpy(dst, src, bytesPerRow);

-            }

-

-            /* byte flipping/swapping */

-            if (flipBytes) {

-               flip_bytes((GLubyte *) dst, bytesPerRow);

-            }

-            else if (swap2) {

-               _mesa_swap2((GLushort*) dst, compsPerRow);

-            }

-            else if (swap4) {

-               _mesa_swap4((GLuint*) dst, compsPerRow);

-            }

-            dst += bytesPerRow;

-         }

-      }

-      return destBuffer;

-   }

-}

-

+/*
+ * Mesa 3-D graphics library
+ *
+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009-2010  VMware, Inc.  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
+ * THEA AUTHORS 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.
+ */
+
+
+/**
+ * \file pack.c
+ * Image and pixel span packing and unpacking.
+ */
+
+
+#include "glheader.h"
+#include "colormac.h"
+#include "enums.h"
+#include "image.h"
+#include "imports.h"
+#include "mtypes.h"
+#include "pack.h"
+#include "pixeltransfer.h"
+#include "imports.h"
+
+
+/**
+ * NOTE:
+ * Normally, BYTE_TO_FLOAT(0) returns 0.00392  That causes problems when
+ * we later convert the float to a packed integer value (such as for
+ * GL_RGB5_A1) because we'll wind up with a non-zero value.
+ *
+ * We redefine the macros here so zero is handled correctly.
+ */
+#undef BYTE_TO_FLOAT
+#define BYTE_TO_FLOAT(B)    ((B) == 0 ? 0.0F : ((2.0F * (B) + 1.0F) * (1.0F/255.0F)))
+
+#undef SHORT_TO_FLOAT
+#define SHORT_TO_FLOAT(S)   ((S) == 0 ? 0.0F : ((2.0F * (S) + 1.0F) * (1.0F/65535.0F)))
+
+
+
+/** Compute ceiling of integer quotient of A divided by B. */
+#define CEILING( A, B )  ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 )
+
+
+/**
+ * Flip the 8 bits in each byte of the given array.
+ *
+ * \param p array.
+ * \param n number of bytes.
+ *
+ * \todo try this trick to flip bytes someday:
+ * \code
+ *  v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);
+ *  v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);
+ *  v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f);
+ * \endcode
+ */
+static void
+flip_bytes( GLubyte *p, GLuint n )
+{
+   GLuint i, a, b;
+   for (i = 0; i < n; i++) {
+      b = (GLuint) p[i];        /* words are often faster than bytes */
+      a = ((b & 0x01) << 7) |
+	  ((b & 0x02) << 5) |
+	  ((b & 0x04) << 3) |
+	  ((b & 0x08) << 1) |
+	  ((b & 0x10) >> 1) |
+	  ((b & 0x20) >> 3) |
+	  ((b & 0x40) >> 5) |
+	  ((b & 0x80) >> 7);
+      p[i] = (GLubyte) a;
+   }
+}
+
+
+
+/*
+ * Unpack a 32x32 pixel polygon stipple from user memory using the
+ * current pixel unpack settings.
+ */
+void
+_mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32],
+                              const struct gl_pixelstore_attrib *unpacking )
+{
+   GLubyte *ptrn = (GLubyte *) _mesa_unpack_bitmap(32, 32, pattern, unpacking);
+   if (ptrn) {
+      /* Convert pattern from GLubytes to GLuints and handle big/little
+       * endian differences
+       */
+      GLubyte *p = ptrn;
+      GLint i;
+      for (i = 0; i < 32; i++) {
+         dest[i] = (p[0] << 24)
+                 | (p[1] << 16)
+                 | (p[2] <<  8)
+                 | (p[3]      );
+         p += 4;
+      }
+      free(ptrn);
+   }
+}
+
+
+/*
+ * Pack polygon stipple into user memory given current pixel packing
+ * settings.
+ */
+void
+_mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest,
+                            const struct gl_pixelstore_attrib *packing )
+{
+   /* Convert pattern from GLuints to GLubytes to handle big/little
+    * endian differences.
+    */
+   GLubyte ptrn[32*4];
+   GLint i;
+   for (i = 0; i < 32; i++) {
+      ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff);
+      ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff);
+      ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff);
+      ptrn[i * 4 + 3] = (GLubyte) ((pattern[i]      ) & 0xff);
+   }
+
+   _mesa_pack_bitmap(32, 32, ptrn, dest, packing);
+}
+
+
+/*
+ * Unpack bitmap data.  Resulting data will be in most-significant-bit-first
+ * order with row alignment = 1 byte.
+ */
+GLvoid *
+_mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
+                     const struct gl_pixelstore_attrib *packing )
+{
+   GLint bytes, row, width_in_bytes;
+   GLubyte *buffer, *dst;
+
+   if (!pixels)
+      return NULL;
+
+   /* Alloc dest storage */
+   bytes = ((width + 7) / 8 * height);
+   buffer = (GLubyte *) malloc( bytes );
+   if (!buffer)
+      return NULL;
+
+   width_in_bytes = CEILING( width, 8 );
+   dst = buffer;
+   for (row = 0; row < height; row++) {
+      const GLubyte *src = (const GLubyte *)
+         _mesa_image_address2d(packing, pixels, width, height,
+                               GL_COLOR_INDEX, GL_BITMAP, row, 0);
+      if (!src) {
+         free(buffer);
+         return NULL;
+      }
+
+      if ((packing->SkipPixels & 7) == 0) {
+         memcpy( dst, src, width_in_bytes );
+         if (packing->LsbFirst) {
+            flip_bytes( dst, width_in_bytes );
+         }
+      }
+      else {
+         /* handling SkipPixels is a bit tricky (no pun intended!) */
+         GLint i;
+         if (packing->LsbFirst) {
+            GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
+            GLubyte dstMask = 128;
+            const GLubyte *s = src;
+            GLubyte *d = dst;
+            *d = 0;
+            for (i = 0; i < width; i++) {
+               if (*s & srcMask) {
+                  *d |= dstMask;
+               }
+               if (srcMask == 128) {
+                  srcMask = 1;
+                  s++;
+               }
+               else {
+                  srcMask = srcMask << 1;
+               }
+               if (dstMask == 1) {
+                  dstMask = 128;
+                  d++;
+                  *d = 0;
+               }
+               else {
+                  dstMask = dstMask >> 1;
+               }
+            }
+         }
+         else {
+            GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
+            GLubyte dstMask = 128;
+            const GLubyte *s = src;
+            GLubyte *d = dst;
+            *d = 0;
+            for (i = 0; i < width; i++) {
+               if (*s & srcMask) {
+                  *d |= dstMask;
+               }
+               if (srcMask == 1) {
+                  srcMask = 128;
+                  s++;
+               }
+               else {
+                  srcMask = srcMask >> 1;
+               }
+               if (dstMask == 1) {
+                  dstMask = 128;
+                  d++;
+                  *d = 0;
+               }
+               else {
+                  dstMask = dstMask >> 1;
+               }
+            }
+         }
+      }
+      dst += width_in_bytes;
+   }
+
+   return buffer;
+}
+
+
+/*
+ * Pack bitmap data.
+ */
+void
+_mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
+                   GLubyte *dest, const struct gl_pixelstore_attrib *packing )
+{
+   GLint row, width_in_bytes;
+   const GLubyte *src;
+
+   if (!source)
+      return;
+
+   width_in_bytes = CEILING( width, 8 );
+   src = source;
+   for (row = 0; row < height; row++) {
+      GLubyte *dst = (GLubyte *) _mesa_image_address2d(packing, dest,
+                       width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);
+      if (!dst)
+         return;
+
+      if ((packing->SkipPixels & 7) == 0) {
+         memcpy( dst, src, width_in_bytes );
+         if (packing->LsbFirst) {
+            flip_bytes( dst, width_in_bytes );
+         }
+      }
+      else {
+         /* handling SkipPixels is a bit tricky (no pun intended!) */
+         GLint i;
+         if (packing->LsbFirst) {
+            GLubyte srcMask = 128;
+            GLubyte dstMask = 1 << (packing->SkipPixels & 0x7);
+            const GLubyte *s = src;
+            GLubyte *d = dst;
+            *d = 0;
+            for (i = 0; i < width; i++) {
+               if (*s & srcMask) {
+                  *d |= dstMask;
+               }
+               if (srcMask == 1) {
+                  srcMask = 128;
+                  s++;
+               }
+               else {
+                  srcMask = srcMask >> 1;
+               }
+               if (dstMask == 128) {
+                  dstMask = 1;
+                  d++;
+                  *d = 0;
+               }
+               else {
+                  dstMask = dstMask << 1;
+               }
+            }
+         }
+         else {
+            GLubyte srcMask = 128;
+            GLubyte dstMask = 128 >> (packing->SkipPixels & 0x7);
+            const GLubyte *s = src;
+            GLubyte *d = dst;
+            *d = 0;
+            for (i = 0; i < width; i++) {
+               if (*s & srcMask) {
+                  *d |= dstMask;
+               }
+               if (srcMask == 1) {
+                  srcMask = 128;
+                  s++;
+               }
+               else {
+                  srcMask = srcMask >> 1;
+               }
+               if (dstMask == 1) {
+                  dstMask = 128;
+                  d++;
+                  *d = 0;
+               }
+               else {
+                  dstMask = dstMask >> 1;
+               }
+            }
+         }
+      }
+      src += width_in_bytes;
+   }
+}
+
+
+/**
+ * Get indexes of color components for a basic color format, such as
+ * GL_RGBA, GL_RED, GL_LUMINANCE_ALPHA, etc.  Return -1 for indexes
+ * that do not apply.
+ */
+static void
+get_component_indexes(GLenum format,
+                      GLint *redIndex,
+                      GLint *greenIndex,
+                      GLint *blueIndex,
+                      GLint *alphaIndex,
+                      GLint *luminanceIndex,
+                      GLint *intensityIndex)
+{
+   *redIndex = -1;
+   *greenIndex = -1;
+   *blueIndex = -1;
+   *alphaIndex = -1;
+   *luminanceIndex = -1;
+   *intensityIndex = -1;
+
+   switch (format) {
+   case GL_LUMINANCE:
+   case GL_LUMINANCE_INTEGER_EXT:
+      *luminanceIndex = 0;
+      break;
+   case GL_LUMINANCE_ALPHA:
+   case GL_LUMINANCE_ALPHA_INTEGER_EXT:
+      *luminanceIndex = 0;
+      *alphaIndex = 1;
+      break;
+   case GL_INTENSITY:
+      *intensityIndex = 0;
+      break;
+   case GL_RED:
+   case GL_RED_INTEGER_EXT:
+      *redIndex = 0;
+      break;
+   case GL_GREEN:
+   case GL_GREEN_INTEGER_EXT:
+      *greenIndex = 0;
+      break;
+   case GL_BLUE:
+   case GL_BLUE_INTEGER_EXT:
+      *blueIndex = 0;
+      break;
+   case GL_ALPHA:
+   case GL_ALPHA_INTEGER_EXT:
+      *alphaIndex = 0;
+      break;
+   case GL_RG:
+   case GL_RG_INTEGER:
+      *redIndex = 0;
+      *greenIndex = 1;
+      break;
+   case GL_RGB:
+   case GL_RGB_INTEGER_EXT:
+      *redIndex = 0;
+      *greenIndex = 1;
+      *blueIndex = 2;
+      break;
+   case GL_BGR:
+   case GL_BGR_INTEGER_EXT:
+      *blueIndex = 0;
+      *greenIndex = 1;
+      *redIndex = 2;
+      break;
+   case GL_RGBA:
+   case GL_RGBA_INTEGER_EXT:
+      *redIndex = 0;
+      *greenIndex = 1;
+      *blueIndex = 2;
+      *alphaIndex = 3;
+      break;
+   case GL_BGRA:
+   case GL_BGRA_INTEGER:
+      *redIndex = 2;
+      *greenIndex = 1;
+      *blueIndex = 0;
+      *alphaIndex = 3;
+      break;
+   case GL_ABGR_EXT:
+      *redIndex = 3;
+      *greenIndex = 2;
+      *blueIndex = 1;
+      *alphaIndex = 0;
+      break;
+   case GL_DU8DV8_ATI:
+   case GL_DUDV_ATI:
+      *redIndex = 0;
+      *greenIndex = 1;
+      break;
+   default:
+      assert(0 && "bad format in get_component_indexes()");
+   }
+}
+
+
+
+/**
+ * For small integer types, return the min and max possible values.
+ * Used for clamping floats to unscaled integer types.
+ * \return GL_TRUE if type is handled, GL_FALSE otherwise.
+ */
+static GLboolean
+get_type_min_max(GLenum type, GLfloat *min, GLfloat *max)
+{
+   switch (type) {
+   case GL_BYTE:
+      *min = -128.0;
+      *max = 127.0;
+      return GL_TRUE;
+   case GL_UNSIGNED_BYTE:
+      *min = 0.0;
+      *max = 255.0;
+      return GL_TRUE;
+   case GL_SHORT:
+      *min = -32768.0;
+      *max = 32767.0;
+      return GL_TRUE;
+   case GL_UNSIGNED_SHORT:
+      *min = 0.0;
+      *max = 65535.0;
+      return GL_TRUE;
+   default:
+      return GL_FALSE;
+   }
+}
+
+
+
+/**
+ * Used to pack an array [][4] of RGBA float colors as specified
+ * by the dstFormat, dstType and dstPacking.  Used by glReadPixels.
+ * Historically, the RGBA values were in [0,1] and rescaled to fit
+ * into GLubytes, etc.  But with new integer formats, the RGBA values
+ * may have any value and we don't always rescale when converting to
+ * integers.
+ *
+ * Note: the rgba values will be modified by this function when any pixel
+ * transfer ops are enabled.
+ */
+void
+_mesa_pack_rgba_span_float(struct gl_context *ctx, GLuint n, GLfloat rgba[][4],
+                           GLenum dstFormat, GLenum dstType,
+                           GLvoid *dstAddr,
+                           const struct gl_pixelstore_attrib *dstPacking,
+                           GLbitfield transferOps)
+{
+   GLfloat *luminance;
+   const GLint comps = _mesa_components_in_format(dstFormat);
+   const GLboolean intDstFormat = _mesa_is_integer_format(dstFormat);
+   GLuint i;
+
+   if (dstFormat == GL_LUMINANCE ||
+       dstFormat == GL_LUMINANCE_ALPHA ||
+       dstFormat == GL_LUMINANCE_INTEGER_EXT ||
+       dstFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT) {
+      luminance = (GLfloat *) malloc(n * sizeof(GLfloat));
+      if (!luminance) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
+         return;
+      }
+   }
+   else {
+      luminance = NULL;
+   }
+
+   if (transferOps) {
+      _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
+   }
+
+   /*
+    * Component clamping (besides clamping to [0,1] in
+    * _mesa_apply_rgba_transfer_ops()).
+    */
+   if (intDstFormat) {
+      /* clamping to dest type's min/max values */
+      GLfloat min, max;
+      if (get_type_min_max(dstType, &min, &max)) {
+         for (i = 0; i < n; i++) {
+            rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], min, max);
+            rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], min, max);
+            rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], min, max);
+            rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], min, max);
+         }
+      }
+   }
+   else if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) {
+      /* compute luminance values */
+      if (transferOps & IMAGE_CLAMP_BIT) {
+         for (i = 0; i < n; i++) {
+            GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
+            luminance[i] = CLAMP(sum, 0.0F, 1.0F);
+         }
+      }
+      else {
+         for (i = 0; i < n; i++) {
+            luminance[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
+         }
+      }
+   }
+
+   /*
+    * Pack/store the pixels.  Ugh!  Lots of cases!!!
+    */
+   switch (dstType) {
+      case GL_UNSIGNED_BYTE:
+         {
+            GLubyte *dst = (GLubyte *) dstAddr;
+            switch (dstFormat) {
+               case GL_RED:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
+                  break;
+               case GL_GREEN:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
+                  break;
+               case GL_BLUE:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
+                  break;
+               case GL_ALPHA:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
+                  break;
+               case GL_LUMINANCE:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_UBYTE(luminance[i]);
+                  break;
+               case GL_LUMINANCE_ALPHA:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]);
+                     dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
+                  }
+                  break;
+               case GL_RG:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
+                     dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
+                  }
+                  break;
+               case GL_RGB:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
+                     dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
+                     dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
+                  }
+                  break;
+               case GL_RGBA:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
+                     dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
+                     dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
+                     dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
+                  }
+                  break;
+               case GL_BGR:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
+                     dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
+                     dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
+                  }
+                  break;
+               case GL_BGRA:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
+                     dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
+                     dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
+                     dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
+                  }
+                  break;
+               case GL_ABGR_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
+                     dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
+                     dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
+                     dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
+                  }
+                  break;
+               case GL_RED_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLubyte) rgba[i][RCOMP];
+                  }
+                  break;
+               case GL_GREEN_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLubyte) rgba[i][GCOMP];
+                  }
+                  break;
+               case GL_BLUE_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLubyte) rgba[i][BCOMP];
+                  }
+                  break;
+               case GL_ALPHA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLubyte) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_RGB_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = (GLubyte) rgba[i][RCOMP];
+                     dst[i*3+1] = (GLubyte) rgba[i][GCOMP];
+                     dst[i*3+2] = (GLubyte) rgba[i][BCOMP];
+                  }
+                  break;
+               case GL_RGBA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = (GLubyte) rgba[i][RCOMP];
+                     dst[i*4+1] = (GLubyte) rgba[i][GCOMP];
+                     dst[i*4+2] = (GLubyte) rgba[i][BCOMP];
+                     dst[i*4+3] = (GLubyte) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_BGR_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = (GLubyte) rgba[i][BCOMP];
+                     dst[i*3+1] = (GLubyte) rgba[i][GCOMP];
+                     dst[i*3+2] = (GLubyte) rgba[i][RCOMP];
+                  }
+                  break;
+               case GL_BGRA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = (GLubyte) rgba[i][BCOMP];
+                     dst[i*4+1] = (GLubyte) rgba[i][GCOMP];
+                     dst[i*4+2] = (GLubyte) rgba[i][RCOMP];
+                     dst[i*4+3] = (GLubyte) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_LUMINANCE_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = (GLubyte) (rgba[i][RCOMP] +
+                                             rgba[i][GCOMP] +
+                                             rgba[i][BCOMP]);
+                     dst[i*2+1] = (GLubyte) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_LUMINANCE_ALPHA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLubyte) (rgba[i][RCOMP] +
+                                         rgba[i][GCOMP] +
+                                         rgba[i][BCOMP]);
+                  }
+                  break;
+               case GL_DUDV_ATI:
+               case GL_DU8DV8_ATI:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
+                     dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
+                  }
+                  break;
+               default:
+                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
+            }
+         }
+         break;
+      case GL_BYTE:
+         {
+            GLbyte *dst = (GLbyte *) dstAddr;
+            switch (dstFormat) {
+               case GL_RED:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
+                  break;
+               case GL_GREEN:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
+                  break;
+               case GL_BLUE:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
+                  break;
+               case GL_ALPHA:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
+                  break;
+               case GL_LUMINANCE:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_BYTE(luminance[i]);
+                  break;
+               case GL_LUMINANCE_ALPHA:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]);
+                     dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
+                  }
+                  break;
+               case GL_RG:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
+                     dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
+                  }
+                  break;
+               case GL_RGB:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
+                     dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
+                     dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
+                  }
+                  break;
+               case GL_RGBA:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
+                     dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
+                     dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
+                     dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
+                  }
+                  break;
+               case GL_BGR:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
+                     dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
+                     dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
+                  }
+                  break;
+               case GL_BGRA:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
+                     dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
+                     dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
+                     dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
+                  }
+		  break;
+               case GL_ABGR_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
+                     dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
+                     dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
+                     dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
+                  }
+                  break;
+               case GL_RED_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLbyte) rgba[i][RCOMP];
+                  }
+                  break;
+               case GL_GREEN_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLbyte) rgba[i][GCOMP];
+                  }
+                  break;
+               case GL_BLUE_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLbyte) rgba[i][BCOMP];
+                  }
+                  break;
+               case GL_ALPHA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLbyte) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_RGB_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = (GLbyte) rgba[i][RCOMP];
+                     dst[i*3+1] = (GLbyte) rgba[i][GCOMP];
+                     dst[i*3+2] = (GLbyte) rgba[i][BCOMP];
+                  }
+                  break;
+               case GL_RGBA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = (GLbyte) rgba[i][RCOMP];
+                     dst[i*4+1] = (GLbyte) rgba[i][GCOMP];
+                     dst[i*4+2] = (GLbyte) rgba[i][BCOMP];
+                     dst[i*4+3] = (GLbyte) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_BGR_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = (GLbyte) rgba[i][BCOMP];
+                     dst[i*3+1] = (GLbyte) rgba[i][GCOMP];
+                     dst[i*3+2] = (GLbyte) rgba[i][RCOMP];
+                  }
+                  break;
+               case GL_BGRA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = (GLbyte) rgba[i][BCOMP];
+                     dst[i*4+1] = (GLbyte) rgba[i][GCOMP];
+                     dst[i*4+2] = (GLbyte) rgba[i][RCOMP];
+                     dst[i*4+3] = (GLbyte) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_LUMINANCE_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = (GLbyte) (rgba[i][RCOMP] +
+                                            rgba[i][GCOMP] +
+                                            rgba[i][BCOMP]);
+                     dst[i*2+1] = (GLbyte) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_LUMINANCE_ALPHA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLbyte) (rgba[i][RCOMP] +
+                                        rgba[i][GCOMP] +
+                                        rgba[i][BCOMP]);
+                  }
+                  break;
+               case GL_DUDV_ATI:
+               case GL_DU8DV8_ATI:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
+                     dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
+                  }
+                  break;
+               default:
+                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT:
+         {
+            GLushort *dst = (GLushort *) dstAddr;
+            switch (dstFormat) {
+               case GL_RED:
+                  for (i=0;i<n;i++)
+                     CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][RCOMP]);
+                  break;
+               case GL_GREEN:
+                  for (i=0;i<n;i++)
+                     CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][GCOMP]);
+                  break;
+               case GL_BLUE:
+                  for (i=0;i<n;i++)
+                     CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][BCOMP]);
+                  break;
+               case GL_ALPHA:
+                  for (i=0;i<n;i++)
+                     CLAMPED_FLOAT_TO_USHORT(dst[i], rgba[i][ACOMP]);
+                  break;
+               case GL_LUMINANCE:
+                  for (i=0;i<n;i++)
+                     UNCLAMPED_FLOAT_TO_USHORT(dst[i], luminance[i]);
+                  break;
+               case GL_LUMINANCE_ALPHA:
+                  for (i=0;i<n;i++) {
+                     UNCLAMPED_FLOAT_TO_USHORT(dst[i*2+0], luminance[i]);
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][ACOMP]);
+                  }
+                  break;
+               case GL_RG:
+                  for (i=0;i<n;i++) {
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*2+0], rgba[i][RCOMP]);
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*2+1], rgba[i][GCOMP]);
+                  }
+                  break;
+               case GL_RGB:
+                  for (i=0;i<n;i++) {
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][RCOMP]);
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][BCOMP]);
+                  }
+                  break;
+               case GL_RGBA:
+                  for (i=0;i<n;i++) {
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][RCOMP]);
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][BCOMP]);
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
+                  }
+                  break;
+               case GL_BGR:
+                  for (i=0;i<n;i++) {
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*3+0], rgba[i][BCOMP]);
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*3+1], rgba[i][GCOMP]);
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*3+2], rgba[i][RCOMP]);
+                  }
+                  break;
+               case GL_BGRA:
+                  for (i=0;i<n;i++) {
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][BCOMP]);
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][GCOMP]);
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][RCOMP]);
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][ACOMP]);
+                  }
+                  break;
+               case GL_ABGR_EXT:
+                  for (i=0;i<n;i++) {
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+0], rgba[i][ACOMP]);
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+1], rgba[i][BCOMP]);
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+2], rgba[i][GCOMP]);
+                     CLAMPED_FLOAT_TO_USHORT(dst[i*4+3], rgba[i][RCOMP]);
+                  }
+                  break;
+               case GL_RED_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLushort) rgba[i][RCOMP];
+                  }
+                  break;
+               case GL_GREEN_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLushort) rgba[i][GCOMP];
+                  }
+                  break;
+               case GL_BLUE_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLushort) rgba[i][BCOMP];
+                  }
+                  break;
+               case GL_ALPHA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLushort) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_RGB_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = (GLushort) rgba[i][RCOMP];
+                     dst[i*3+1] = (GLushort) rgba[i][GCOMP];
+                     dst[i*3+2] = (GLushort) rgba[i][BCOMP];
+                  }
+                  break;
+               case GL_RGBA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = (GLushort) rgba[i][RCOMP];
+                     dst[i*4+1] = (GLushort) rgba[i][GCOMP];
+                     dst[i*4+2] = (GLushort) rgba[i][BCOMP];
+                     dst[i*4+3] = (GLushort) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_BGR_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = (GLushort) rgba[i][BCOMP];
+                     dst[i*3+1] = (GLushort) rgba[i][GCOMP];
+                     dst[i*3+2] = (GLushort) rgba[i][RCOMP];
+                  }
+                  break;
+               case GL_BGRA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = (GLushort) rgba[i][BCOMP];
+                     dst[i*4+1] = (GLushort) rgba[i][GCOMP];
+                     dst[i*4+2] = (GLushort) rgba[i][RCOMP];
+                     dst[i*4+3] = (GLushort) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_LUMINANCE_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = (GLushort) (rgba[i][RCOMP] +
+                                              rgba[i][GCOMP] +
+                                              rgba[i][BCOMP]);
+                     dst[i*2+1] = (GLushort) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_LUMINANCE_ALPHA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLushort) (rgba[i][RCOMP] +
+                                          rgba[i][GCOMP] +
+                                          rgba[i][BCOMP]);
+                  }
+                  break;
+               case GL_DUDV_ATI:
+               case GL_DU8DV8_ATI:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
+                     dst[i*2+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
+                  }
+                  break;
+               default:
+                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
+            }
+         }
+         break;
+      case GL_SHORT:
+         {
+            GLshort *dst = (GLshort *) dstAddr;
+            switch (dstFormat) {
+               case GL_RED:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
+                  break;
+               case GL_GREEN:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
+                  break;
+               case GL_BLUE:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
+                  break;
+               case GL_ALPHA:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
+                  break;
+               case GL_LUMINANCE:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_SHORT(luminance[i]);
+                  break;
+               case GL_LUMINANCE_ALPHA:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]);
+                     dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
+                  }
+                  break;
+               case GL_RG:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
+                     dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
+                  }
+                  break;
+               case GL_RGB:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
+                     dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
+                     dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
+                  }
+                  break;
+               case GL_RGBA:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
+                     dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
+                     dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
+                     dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
+                  }
+                  break;
+               case GL_BGR:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
+                     dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
+                     dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
+                  }
+                  break;
+               case GL_BGRA:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
+                     dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
+                     dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
+                     dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
+                  }
+		  break;
+               case GL_ABGR_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
+                     dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
+                     dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
+                     dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
+                  }
+                  break;
+               case GL_RED_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLshort) rgba[i][RCOMP];
+                  }
+                  break;
+               case GL_GREEN_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLshort) rgba[i][GCOMP];
+                  }
+                  break;
+               case GL_BLUE_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLshort) rgba[i][BCOMP];
+                  }
+                  break;
+               case GL_ALPHA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLshort) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_RGB_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = (GLshort) rgba[i][RCOMP];
+                     dst[i*3+1] = (GLshort) rgba[i][GCOMP];
+                     dst[i*3+2] = (GLshort) rgba[i][BCOMP];
+                  }
+                  break;
+               case GL_RGBA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = (GLshort) rgba[i][RCOMP];
+                     dst[i*4+1] = (GLshort) rgba[i][GCOMP];
+                     dst[i*4+2] = (GLshort) rgba[i][BCOMP];
+                     dst[i*4+3] = (GLshort) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_BGR_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = (GLshort) rgba[i][BCOMP];
+                     dst[i*3+1] = (GLshort) rgba[i][GCOMP];
+                     dst[i*3+2] = (GLshort) rgba[i][RCOMP];
+                  }
+                  break;
+               case GL_BGRA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = (GLshort) rgba[i][BCOMP];
+                     dst[i*4+1] = (GLshort) rgba[i][GCOMP];
+                     dst[i*4+2] = (GLshort) rgba[i][RCOMP];
+                     dst[i*4+3] = (GLshort) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_LUMINANCE_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = (GLshort) (rgba[i][RCOMP] +
+                                             rgba[i][GCOMP] +
+                                             rgba[i][BCOMP]);
+                     dst[i*2+1] = (GLshort) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_LUMINANCE_ALPHA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLshort) (rgba[i][RCOMP] +
+                                         rgba[i][GCOMP] +
+                                         rgba[i][BCOMP]);
+                  }
+                  break;
+               case GL_DUDV_ATI:
+               case GL_DU8DV8_ATI:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
+                     dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
+                  }
+                  break;
+               default:
+                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT:
+         {
+            GLuint *dst = (GLuint *) dstAddr;
+            switch (dstFormat) {
+               case GL_RED:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]);
+                  break;
+               case GL_GREEN:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]);
+                  break;
+               case GL_BLUE:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]);
+                  break;
+               case GL_ALPHA:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]);
+                  break;
+               case GL_LUMINANCE:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_UINT(luminance[i]);
+                  break;
+               case GL_LUMINANCE_ALPHA:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_UINT(luminance[i]);
+                     dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]);
+                  }
+                  break;
+               case GL_RG:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
+                     dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
+                  }
+                  break;
+               case GL_RGB:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
+                     dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
+                     dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
+                  }
+                  break;
+               case GL_RGBA:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
+                     dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
+                     dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
+                     dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
+                  }
+                  break;
+               case GL_BGR:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
+                     dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
+                     dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
+                  }
+                  break;
+               case GL_BGRA:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
+                     dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
+                     dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
+                     dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
+                  }
+                  break;
+               case GL_ABGR_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]);
+                     dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]);
+                     dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]);
+                     dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]);
+                  }
+                  break;
+               case GL_RED_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLuint) rgba[i][RCOMP];
+                  }
+                  break;
+               case GL_GREEN_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLuint) rgba[i][GCOMP];
+                  }
+                  break;
+               case GL_BLUE_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLuint) rgba[i][BCOMP];
+                  }
+                  break;
+               case GL_ALPHA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLuint) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_RGB_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = (GLuint) rgba[i][RCOMP];
+                     dst[i*3+1] = (GLuint) rgba[i][GCOMP];
+                     dst[i*3+2] = (GLuint) rgba[i][BCOMP];
+                  }
+                  break;
+               case GL_RGBA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = (GLuint) rgba[i][RCOMP];
+                     dst[i*4+1] = (GLuint) rgba[i][GCOMP];
+                     dst[i*4+2] = (GLuint) rgba[i][BCOMP];
+                     dst[i*4+3] = (GLuint) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_BGR_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = (GLuint) rgba[i][BCOMP];
+                     dst[i*3+1] = (GLuint) rgba[i][GCOMP];
+                     dst[i*3+2] = (GLuint) rgba[i][RCOMP];
+                  }
+                  break;
+               case GL_BGRA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = (GLuint) rgba[i][BCOMP];
+                     dst[i*4+1] = (GLuint) rgba[i][GCOMP];
+                     dst[i*4+2] = (GLuint) rgba[i][RCOMP];
+                     dst[i*4+3] = (GLuint) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_LUMINANCE_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = (GLuint) (rgba[i][RCOMP] +
+                                            rgba[i][GCOMP] +
+                                            rgba[i][BCOMP]);
+                     dst[i*2+1] = (GLuint) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_LUMINANCE_ALPHA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLuint) (rgba[i][RCOMP] +
+                                        rgba[i][GCOMP] +
+                                        rgba[i][BCOMP]);
+                  }
+                  break;
+               case GL_DUDV_ATI:
+               case GL_DU8DV8_ATI:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
+                     dst[i*2+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
+                  }
+                  break;
+               default:
+                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
+            }
+         }
+         break;
+      case GL_INT:
+         {
+            GLint *dst = (GLint *) dstAddr;
+            switch (dstFormat) {
+               case GL_RED:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]);
+                  break;
+               case GL_GREEN:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]);
+                  break;
+               case GL_BLUE:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]);
+                  break;
+               case GL_ALPHA:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]);
+                  break;
+               case GL_LUMINANCE:
+                  for (i=0;i<n;i++)
+                     dst[i] = FLOAT_TO_INT(luminance[i]);
+                  break;
+               case GL_LUMINANCE_ALPHA:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_INT(luminance[i]);
+                     dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]);
+                  }
+                  break;
+               case GL_RG:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
+                     dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
+                  }
+                  break;
+               case GL_RGB:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
+                     dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
+                     dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
+                  }
+                  break;
+               case GL_RGBA:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
+                     dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
+                     dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
+                     dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
+                  }
+                  break;
+               case GL_BGR:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
+                     dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
+                     dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
+                  }
+                  break;
+               case GL_BGRA:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
+                     dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
+                     dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
+                     dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
+                  }
+                  break;
+               case GL_ABGR_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]);
+                     dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]);
+                     dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]);
+                     dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]);
+                  }
+                  break;
+               case GL_DUDV_ATI:
+               case GL_DU8DV8_ATI:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
+                     dst[i*2+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
+                  }
+                  break;
+               case GL_RED_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLint) rgba[i][RCOMP];
+                  }
+                  break;
+               case GL_GREEN_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLint) rgba[i][GCOMP];
+                  }
+                  break;
+               case GL_BLUE_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLint) rgba[i][BCOMP];
+                  }
+                  break;
+               case GL_ALPHA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLint) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_RGB_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = (GLint) rgba[i][RCOMP];
+                     dst[i*3+1] = (GLint) rgba[i][GCOMP];
+                     dst[i*3+2] = (GLint) rgba[i][BCOMP];
+                  }
+                  break;
+               case GL_RGBA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = (GLint) rgba[i][RCOMP];
+                     dst[i*4+1] = (GLint) rgba[i][GCOMP];
+                     dst[i*4+2] = (GLint) rgba[i][BCOMP];
+                     dst[i*4+3] = (GLint) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_BGR_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = (GLint) rgba[i][BCOMP];
+                     dst[i*3+1] = (GLint) rgba[i][GCOMP];
+                     dst[i*3+2] = (GLint) rgba[i][RCOMP];
+                  }
+                  break;
+               case GL_BGRA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = (GLint) rgba[i][BCOMP];
+                     dst[i*4+1] = (GLint) rgba[i][GCOMP];
+                     dst[i*4+2] = (GLint) rgba[i][RCOMP];
+                     dst[i*4+3] = (GLint) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_LUMINANCE_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = (GLint) (rgba[i][RCOMP] +
+                                           rgba[i][GCOMP] +
+                                           rgba[i][BCOMP]);
+                     dst[i*2+1] = (GLint) rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_LUMINANCE_ALPHA_INTEGER_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i] = (GLint) (rgba[i][RCOMP] +
+                                       rgba[i][GCOMP] +
+                                       rgba[i][BCOMP]);
+                  }
+                  break;
+               default:
+                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
+            }
+         }
+         break;
+      case GL_FLOAT:
+         {
+            GLfloat *dst = (GLfloat *) dstAddr;
+            switch (dstFormat) {
+               case GL_RED:
+                  for (i=0;i<n;i++)
+                     dst[i] = rgba[i][RCOMP];
+                  break;
+               case GL_GREEN:
+                  for (i=0;i<n;i++)
+                     dst[i] = rgba[i][GCOMP];
+                  break;
+               case GL_BLUE:
+                  for (i=0;i<n;i++)
+                     dst[i] = rgba[i][BCOMP];
+                  break;
+               case GL_ALPHA:
+                  for (i=0;i<n;i++)
+                     dst[i] = rgba[i][ACOMP];
+                  break;
+               case GL_LUMINANCE:
+                  for (i=0;i<n;i++)
+                     dst[i] = luminance[i];
+                  break;
+               case GL_LUMINANCE_ALPHA:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = luminance[i];
+                     dst[i*2+1] = rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_RG:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = rgba[i][RCOMP];
+                     dst[i*2+1] = rgba[i][GCOMP];
+                  }
+                  break;
+               case GL_RGB:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = rgba[i][RCOMP];
+                     dst[i*3+1] = rgba[i][GCOMP];
+                     dst[i*3+2] = rgba[i][BCOMP];
+                  }
+                  break;
+               case GL_RGBA:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = rgba[i][RCOMP];
+                     dst[i*4+1] = rgba[i][GCOMP];
+                     dst[i*4+2] = rgba[i][BCOMP];
+                     dst[i*4+3] = rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_BGR:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = rgba[i][BCOMP];
+                     dst[i*3+1] = rgba[i][GCOMP];
+                     dst[i*3+2] = rgba[i][RCOMP];
+                  }
+                  break;
+               case GL_BGRA:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = rgba[i][BCOMP];
+                     dst[i*4+1] = rgba[i][GCOMP];
+                     dst[i*4+2] = rgba[i][RCOMP];
+                     dst[i*4+3] = rgba[i][ACOMP];
+                  }
+                  break;
+               case GL_ABGR_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = rgba[i][ACOMP];
+                     dst[i*4+1] = rgba[i][BCOMP];
+                     dst[i*4+2] = rgba[i][GCOMP];
+                     dst[i*4+3] = rgba[i][RCOMP];
+                  }
+                  break;
+               case GL_DUDV_ATI:
+               case GL_DU8DV8_ATI:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = rgba[i][RCOMP];
+                     dst[i*2+1] = rgba[i][GCOMP];
+                  }
+                  break;
+               default:
+                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
+            }
+         }
+         break;
+      case GL_HALF_FLOAT_ARB:
+         {
+            GLhalfARB *dst = (GLhalfARB *) dstAddr;
+            switch (dstFormat) {
+               case GL_RED:
+                  for (i=0;i<n;i++)
+                     dst[i] = _mesa_float_to_half(rgba[i][RCOMP]);
+                  break;
+               case GL_GREEN:
+                  for (i=0;i<n;i++)
+                     dst[i] = _mesa_float_to_half(rgba[i][GCOMP]);
+                  break;
+               case GL_BLUE:
+                  for (i=0;i<n;i++)
+                     dst[i] = _mesa_float_to_half(rgba[i][BCOMP]);
+                  break;
+               case GL_ALPHA:
+                  for (i=0;i<n;i++)
+                     dst[i] = _mesa_float_to_half(rgba[i][ACOMP]);
+                  break;
+               case GL_LUMINANCE:
+                  for (i=0;i<n;i++)
+                     dst[i] = _mesa_float_to_half(luminance[i]);
+                  break;
+               case GL_LUMINANCE_ALPHA:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = _mesa_float_to_half(luminance[i]);
+                     dst[i*2+1] = _mesa_float_to_half(rgba[i][ACOMP]);
+                  }
+                  break;
+               case GL_RG:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);
+                     dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);
+                  }
+                  break;
+               case GL_RGB:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = _mesa_float_to_half(rgba[i][RCOMP]);
+                     dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
+                     dst[i*3+2] = _mesa_float_to_half(rgba[i][BCOMP]);
+                  }
+                  break;
+               case GL_RGBA:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = _mesa_float_to_half(rgba[i][RCOMP]);
+                     dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
+                     dst[i*4+2] = _mesa_float_to_half(rgba[i][BCOMP]);
+                     dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
+                  }
+                  break;
+               case GL_BGR:
+                  for (i=0;i<n;i++) {
+                     dst[i*3+0] = _mesa_float_to_half(rgba[i][BCOMP]);
+                     dst[i*3+1] = _mesa_float_to_half(rgba[i][GCOMP]);
+                     dst[i*3+2] = _mesa_float_to_half(rgba[i][RCOMP]);
+                  }
+                  break;
+               case GL_BGRA:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = _mesa_float_to_half(rgba[i][BCOMP]);
+                     dst[i*4+1] = _mesa_float_to_half(rgba[i][GCOMP]);
+                     dst[i*4+2] = _mesa_float_to_half(rgba[i][RCOMP]);
+                     dst[i*4+3] = _mesa_float_to_half(rgba[i][ACOMP]);
+                  }
+                  break;
+               case GL_ABGR_EXT:
+                  for (i=0;i<n;i++) {
+                     dst[i*4+0] = _mesa_float_to_half(rgba[i][ACOMP]);
+                     dst[i*4+1] = _mesa_float_to_half(rgba[i][BCOMP]);
+                     dst[i*4+2] = _mesa_float_to_half(rgba[i][GCOMP]);
+                     dst[i*4+3] = _mesa_float_to_half(rgba[i][RCOMP]);
+                  }
+                  break;
+               case GL_DUDV_ATI:
+               case GL_DU8DV8_ATI:
+                  for (i=0;i<n;i++) {
+                     dst[i*2+0] = _mesa_float_to_half(rgba[i][RCOMP]);
+                     dst[i*2+1] = _mesa_float_to_half(rgba[i][GCOMP]);
+                  }
+                  break;
+               default:
+                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
+            }
+         }
+         break;
+      case GL_UNSIGNED_BYTE_3_3_2:
+         if (dstFormat == GL_RGB) {
+            GLubyte *dst = (GLubyte *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][RCOMP] * 7.0F) << 5)
+                      | (IROUND(rgba[i][GCOMP] * 7.0F) << 2)
+                      | (IROUND(rgba[i][BCOMP] * 3.0F)     );
+            }
+         }
+         break;
+      case GL_UNSIGNED_BYTE_2_3_3_REV:
+         if (dstFormat == GL_RGB) {
+            GLubyte *dst = (GLubyte *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][RCOMP] * 7.0F)     )
+                      | (IROUND(rgba[i][GCOMP] * 7.0F) << 3)
+                      | (IROUND(rgba[i][BCOMP] * 3.0F) << 6);
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_5_6_5:
+         if (dstFormat == GL_RGB) {
+            GLushort *dst = (GLushort *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11)
+                      | (IROUND(rgba[i][GCOMP] * 63.0F) <<  5)
+                      | (IROUND(rgba[i][BCOMP] * 31.0F)      );
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_5_6_5_REV:
+         if (dstFormat == GL_RGB) {
+            GLushort *dst = (GLushort *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F)      )
+                      | (IROUND(rgba[i][GCOMP] * 63.0F) <<  5)
+                      | (IROUND(rgba[i][BCOMP] * 31.0F) << 11);
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_4_4_4_4:
+         if (dstFormat == GL_RGBA) {
+            GLushort *dst = (GLushort *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][RCOMP] * 15.0F) << 12)
+                      | (IROUND(rgba[i][GCOMP] * 15.0F) <<  8)
+                      | (IROUND(rgba[i][BCOMP] * 15.0F) <<  4)
+                      | (IROUND(rgba[i][ACOMP] * 15.0F)      );
+            }
+         }
+         else if (dstFormat == GL_BGRA) {
+            GLushort *dst = (GLushort *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F) << 12)
+                      | (IROUND(rgba[i][GCOMP] * 15.0F) <<  8)
+                      | (IROUND(rgba[i][RCOMP] * 15.0F) <<  4)
+                      | (IROUND(rgba[i][ACOMP] * 15.0F)      );
+            }
+         }
+         else if (dstFormat == GL_ABGR_EXT) {
+            GLushort *dst = (GLushort *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F) << 12)
+                      | (IROUND(rgba[i][BCOMP] * 15.0F) <<  8)
+                      | (IROUND(rgba[i][GCOMP] * 15.0F) <<  4)
+                      | (IROUND(rgba[i][RCOMP] * 15.0F)      );
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
+         if (dstFormat == GL_RGBA) {
+            GLushort *dst = (GLushort *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][RCOMP] * 15.0F)      )
+                      | (IROUND(rgba[i][GCOMP] * 15.0F) <<  4)
+                      | (IROUND(rgba[i][BCOMP] * 15.0F) <<  8)
+                      | (IROUND(rgba[i][ACOMP] * 15.0F) << 12);
+            }
+         }
+         else if (dstFormat == GL_BGRA) {
+            GLushort *dst = (GLushort *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][BCOMP] * 15.0F)      )
+                      | (IROUND(rgba[i][GCOMP] * 15.0F) <<  4)
+                      | (IROUND(rgba[i][RCOMP] * 15.0F) <<  8)
+                      | (IROUND(rgba[i][ACOMP] * 15.0F) << 12);
+            }
+         }
+         else if (dstFormat == GL_ABGR_EXT) {
+            GLushort *dst = (GLushort *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][ACOMP] * 15.0F)      )
+                      | (IROUND(rgba[i][BCOMP] * 15.0F) <<  4)
+                      | (IROUND(rgba[i][GCOMP] * 15.0F) <<  8)
+                      | (IROUND(rgba[i][RCOMP] * 15.0F) << 12);
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_5_5_5_1:
+         if (dstFormat == GL_RGBA) {
+            GLushort *dst = (GLushort *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F) << 11)
+                      | (IROUND(rgba[i][GCOMP] * 31.0F) <<  6)
+                      | (IROUND(rgba[i][BCOMP] * 31.0F) <<  1)
+                      | (IROUND(rgba[i][ACOMP] *  1.0F)      );
+            }
+         }
+         else if (dstFormat == GL_BGRA) {
+            GLushort *dst = (GLushort *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F) << 11)
+                      | (IROUND(rgba[i][GCOMP] * 31.0F) <<  6)
+                      | (IROUND(rgba[i][RCOMP] * 31.0F) <<  1)
+                      | (IROUND(rgba[i][ACOMP] *  1.0F)      );
+            }
+         }
+         else if (dstFormat == GL_ABGR_EXT) {
+            GLushort *dst = (GLushort *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F) << 11)
+                      | (IROUND(rgba[i][BCOMP] * 31.0F) <<  6)
+                      | (IROUND(rgba[i][GCOMP] * 31.0F) <<  1)
+                      | (IROUND(rgba[i][RCOMP] *  1.0F)      );
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
+         if (dstFormat == GL_RGBA) {
+            GLushort *dst = (GLushort *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][RCOMP] * 31.0F)      )
+                      | (IROUND(rgba[i][GCOMP] * 31.0F) <<  5)
+                      | (IROUND(rgba[i][BCOMP] * 31.0F) << 10)
+                      | (IROUND(rgba[i][ACOMP] *  1.0F) << 15);
+            }
+         }
+         else if (dstFormat == GL_BGRA) {
+            GLushort *dst = (GLushort *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][BCOMP] * 31.0F)      )
+                      | (IROUND(rgba[i][GCOMP] * 31.0F) <<  5)
+                      | (IROUND(rgba[i][RCOMP] * 31.0F) << 10)
+                      | (IROUND(rgba[i][ACOMP] *  1.0F) << 15);
+            }
+         }
+         else if (dstFormat == GL_ABGR_EXT) {
+            GLushort *dst = (GLushort *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][ACOMP] * 31.0F)      )
+                      | (IROUND(rgba[i][BCOMP] * 31.0F) <<  5)
+                      | (IROUND(rgba[i][GCOMP] * 31.0F) << 10)
+                      | (IROUND(rgba[i][RCOMP] *  1.0F) << 15);
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT_8_8_8_8:
+         if (dstFormat == GL_RGBA) {
+            GLuint *dst = (GLuint *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][RCOMP] * 255.F) << 24)
+                      | (IROUND(rgba[i][GCOMP] * 255.F) << 16)
+                      | (IROUND(rgba[i][BCOMP] * 255.F) <<  8)
+                      | (IROUND(rgba[i][ACOMP] * 255.F)      );
+            }
+         }
+         else if (dstFormat == GL_BGRA) {
+            GLuint *dst = (GLuint *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][BCOMP] * 255.F) << 24)
+                      | (IROUND(rgba[i][GCOMP] * 255.F) << 16)
+                      | (IROUND(rgba[i][RCOMP] * 255.F) <<  8)
+                      | (IROUND(rgba[i][ACOMP] * 255.F)      );
+            }
+         }
+         else if (dstFormat == GL_ABGR_EXT) {
+            GLuint *dst = (GLuint *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][ACOMP] * 255.F) << 24)
+                      | (IROUND(rgba[i][BCOMP] * 255.F) << 16)
+                      | (IROUND(rgba[i][GCOMP] * 255.F) <<  8)
+                      | (IROUND(rgba[i][RCOMP] * 255.F)      );
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT_8_8_8_8_REV:
+         if (dstFormat == GL_RGBA) {
+            GLuint *dst = (GLuint *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][RCOMP] * 255.0F)      )
+                      | (IROUND(rgba[i][GCOMP] * 255.0F) <<  8)
+                      | (IROUND(rgba[i][BCOMP] * 255.0F) << 16)
+                      | (IROUND(rgba[i][ACOMP] * 255.0F) << 24);
+            }
+         }
+         else if (dstFormat == GL_BGRA) {
+            GLuint *dst = (GLuint *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][BCOMP] * 255.0F)      )
+                      | (IROUND(rgba[i][GCOMP] * 255.0F) <<  8)
+                      | (IROUND(rgba[i][RCOMP] * 255.0F) << 16)
+                      | (IROUND(rgba[i][ACOMP] * 255.0F) << 24);
+            }
+         }
+         else if (dstFormat == GL_ABGR_EXT) {
+            GLuint *dst = (GLuint *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][ACOMP] * 255.0F)      )
+                      | (IROUND(rgba[i][BCOMP] * 255.0F) <<  8)
+                      | (IROUND(rgba[i][GCOMP] * 255.0F) << 16)
+                      | (IROUND(rgba[i][RCOMP] * 255.0F) << 24);
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT_10_10_10_2:
+         if (dstFormat == GL_RGBA) {
+            GLuint *dst = (GLuint *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][RCOMP] * 1023.0F) << 22)
+                      | (IROUND(rgba[i][GCOMP] * 1023.0F) << 12)
+                      | (IROUND(rgba[i][BCOMP] * 1023.0F) <<  2)
+                      | (IROUND(rgba[i][ACOMP] *    3.0F)      );
+            }
+         }
+         else if (dstFormat == GL_BGRA) {
+            GLuint *dst = (GLuint *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F) << 22)
+                      | (IROUND(rgba[i][GCOMP] * 1023.0F) << 12)
+                      | (IROUND(rgba[i][RCOMP] * 1023.0F) <<  2)
+                      | (IROUND(rgba[i][ACOMP] *    3.0F)      );
+            }
+         }
+         else if (dstFormat == GL_ABGR_EXT) {
+            GLuint *dst = (GLuint *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F) << 22)
+                      | (IROUND(rgba[i][BCOMP] * 1023.0F) << 12)
+                      | (IROUND(rgba[i][GCOMP] * 1023.0F) <<  2)
+                      | (IROUND(rgba[i][RCOMP] *    3.0F)      );
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT_2_10_10_10_REV:
+         if (dstFormat == GL_RGBA) {
+            GLuint *dst = (GLuint *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][RCOMP] * 1023.0F)      )
+                      | (IROUND(rgba[i][GCOMP] * 1023.0F) << 10)
+                      | (IROUND(rgba[i][BCOMP] * 1023.0F) << 20)
+                      | (IROUND(rgba[i][ACOMP] *    3.0F) << 30);
+            }
+         }
+         else if (dstFormat == GL_BGRA) {
+            GLuint *dst = (GLuint *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][BCOMP] * 1023.0F)      )
+                      | (IROUND(rgba[i][GCOMP] * 1023.0F) << 10)
+                      | (IROUND(rgba[i][RCOMP] * 1023.0F) << 20)
+                      | (IROUND(rgba[i][ACOMP] *    3.0F) << 30);
+            }
+         }
+         else if (dstFormat == GL_ABGR_EXT) {
+            GLuint *dst = (GLuint *) dstAddr;
+            for (i=0;i<n;i++) {
+               dst[i] = (IROUND(rgba[i][ACOMP] * 1023.0F)      )
+                      | (IROUND(rgba[i][BCOMP] * 1023.0F) << 10)
+                      | (IROUND(rgba[i][GCOMP] * 1023.0F) << 20)
+                      | (IROUND(rgba[i][RCOMP] *    3.0F) << 30);
+            }
+         }
+         break;
+      default:
+         _mesa_problem(ctx, "bad type in _mesa_pack_rgba_span_float");
+         return;
+   }
+
+   if (dstPacking->SwapBytes) {
+      GLint swapSize = _mesa_sizeof_packed_type(dstType);
+      if (swapSize == 2) {
+         if (dstPacking->SwapBytes) {
+            _mesa_swap2((GLushort *) dstAddr, n * comps);
+         }
+      }
+      else if (swapSize == 4) {
+         if (dstPacking->SwapBytes) {
+            _mesa_swap4((GLuint *) dstAddr, n * comps);
+         }
+      }
+   }
+
+   free(luminance);
+}
+
+
+
+#define SWAP2BYTE(VALUE)			\
+   {						\
+      GLubyte *bytes = (GLubyte *) &(VALUE);	\
+      GLubyte tmp = bytes[0];			\
+      bytes[0] = bytes[1];			\
+      bytes[1] = tmp;				\
+   }
+
+#define SWAP4BYTE(VALUE)			\
+   {						\
+      GLubyte *bytes = (GLubyte *) &(VALUE);	\
+      GLubyte tmp = bytes[0];			\
+      bytes[0] = bytes[3];			\
+      bytes[3] = tmp;				\
+      tmp = bytes[1];				\
+      bytes[1] = bytes[2];			\
+      bytes[2] = tmp;				\
+   }
+
+
+static void
+extract_uint_indexes(GLuint n, GLuint indexes[],
+                     GLenum srcFormat, GLenum srcType, const GLvoid *src,
+                     const struct gl_pixelstore_attrib *unpack )
+{
+   ASSERT(srcFormat == GL_COLOR_INDEX || srcFormat == GL_STENCIL_INDEX);
+
+   ASSERT(srcType == GL_BITMAP ||
+          srcType == GL_UNSIGNED_BYTE ||
+          srcType == GL_BYTE ||
+          srcType == GL_UNSIGNED_SHORT ||
+          srcType == GL_SHORT ||
+          srcType == GL_UNSIGNED_INT ||
+          srcType == GL_INT ||
+          srcType == GL_UNSIGNED_INT_24_8_EXT ||
+          srcType == GL_HALF_FLOAT_ARB ||
+          srcType == GL_FLOAT);
+
+   switch (srcType) {
+      case GL_BITMAP:
+         {
+            GLubyte *ubsrc = (GLubyte *) src;
+            if (unpack->LsbFirst) {
+               GLubyte mask = 1 << (unpack->SkipPixels & 0x7);
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  indexes[i] = (*ubsrc & mask) ? 1 : 0;
+                  if (mask == 128) {
+                     mask = 1;
+                     ubsrc++;
+                  }
+                  else {
+                     mask = mask << 1;
+                  }
+               }
+            }
+            else {
+               GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  indexes[i] = (*ubsrc & mask) ? 1 : 0;
+                  if (mask == 1) {
+                     mask = 128;
+                     ubsrc++;
+                  }
+                  else {
+                     mask = mask >> 1;
+                  }
+               }
+            }
+         }
+         break;
+      case GL_UNSIGNED_BYTE:
+         {
+            GLuint i;
+            const GLubyte *s = (const GLubyte *) src;
+            for (i = 0; i < n; i++)
+               indexes[i] = s[i];
+         }
+         break;
+      case GL_BYTE:
+         {
+            GLuint i;
+            const GLbyte *s = (const GLbyte *) src;
+            for (i = 0; i < n; i++)
+               indexes[i] = s[i];
+         }
+         break;
+      case GL_UNSIGNED_SHORT:
+         {
+            GLuint i;
+            const GLushort *s = (const GLushort *) src;
+            if (unpack->SwapBytes) {
+               for (i = 0; i < n; i++) {
+                  GLushort value = s[i];
+                  SWAP2BYTE(value);
+                  indexes[i] = value;
+               }
+            }
+            else {
+               for (i = 0; i < n; i++)
+                  indexes[i] = s[i];
+            }
+         }
+         break;
+      case GL_SHORT:
+         {
+            GLuint i;
+            const GLshort *s = (const GLshort *) src;
+            if (unpack->SwapBytes) {
+               for (i = 0; i < n; i++) {
+                  GLshort value = s[i];
+                  SWAP2BYTE(value);
+                  indexes[i] = value;
+               }
+            }
+            else {
+               for (i = 0; i < n; i++)
+                  indexes[i] = s[i];
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT:
+         {
+            GLuint i;
+            const GLuint *s = (const GLuint *) src;
+            if (unpack->SwapBytes) {
+               for (i = 0; i < n; i++) {
+                  GLuint value = s[i];
+                  SWAP4BYTE(value);
+                  indexes[i] = value;
+               }
+            }
+            else {
+               for (i = 0; i < n; i++)
+                  indexes[i] = s[i];
+            }
+         }
+         break;
+      case GL_INT:
+         {
+            GLuint i;
+            const GLint *s = (const GLint *) src;
+            if (unpack->SwapBytes) {
+               for (i = 0; i < n; i++) {
+                  GLint value = s[i];
+                  SWAP4BYTE(value);
+                  indexes[i] = value;
+               }
+            }
+            else {
+               for (i = 0; i < n; i++)
+                  indexes[i] = s[i];
+            }
+         }
+         break;
+      case GL_FLOAT:
+         {
+            GLuint i;
+            const GLfloat *s = (const GLfloat *) src;
+            if (unpack->SwapBytes) {
+               for (i = 0; i < n; i++) {
+                  GLfloat value = s[i];
+                  SWAP4BYTE(value);
+                  indexes[i] = (GLuint) value;
+               }
+            }
+            else {
+               for (i = 0; i < n; i++)
+                  indexes[i] = (GLuint) s[i];
+            }
+         }
+         break;
+      case GL_HALF_FLOAT_ARB:
+         {
+            GLuint i;
+            const GLhalfARB *s = (const GLhalfARB *) src;
+            if (unpack->SwapBytes) {
+               for (i = 0; i < n; i++) {
+                  GLhalfARB value = s[i];
+                  SWAP2BYTE(value);
+                  indexes[i] = (GLuint) _mesa_half_to_float(value);
+               }
+            }
+            else {
+               for (i = 0; i < n; i++)
+                  indexes[i] = (GLuint) _mesa_half_to_float(s[i]);
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT_24_8_EXT:
+         {
+            GLuint i;
+            const GLuint *s = (const GLuint *) src;
+            if (unpack->SwapBytes) {
+               for (i = 0; i < n; i++) {
+                  GLuint value = s[i];
+                  SWAP4BYTE(value);
+                  indexes[i] = value & 0xff;  /* lower 8 bits */
+               }
+            }
+            else {
+               for (i = 0; i < n; i++)
+                  indexes[i] = s[i] & 0xff;  /* lower 8 bits */
+            }
+         }
+         break;
+
+      default:
+         _mesa_problem(NULL, "bad srcType in extract_uint_indexes");
+         return;
+   }
+}
+
+
+/**
+ * Return source/dest RGBA indexes for unpacking pixels.
+ */
+static void
+get_component_mapping(GLenum format,
+                      GLint *rSrc,
+                      GLint *gSrc,
+                      GLint *bSrc,
+                      GLint *aSrc,
+                      GLint *rDst,
+                      GLint *gDst,
+                      GLint *bDst,
+                      GLint *aDst)
+{
+   switch (format) {
+   case GL_RED:
+   case GL_RED_INTEGER_EXT:
+      *rSrc = 0;
+      *gSrc = *bSrc = *aSrc = -1;
+      break;
+   case GL_GREEN:
+   case GL_GREEN_INTEGER_EXT:
+      *gSrc = 0;
+      *rSrc = *bSrc = *aSrc = -1;
+      break;
+      case GL_BLUE:
+   case GL_BLUE_INTEGER_EXT:
+      *bSrc = 0;
+      *rSrc = *gSrc = *aSrc = -1;
+      break;
+   case GL_ALPHA:
+   case GL_ALPHA_INTEGER_EXT:
+      *rSrc = *gSrc = *bSrc = -1;
+      *aSrc = 0;
+      break;
+   case GL_LUMINANCE:
+   case GL_LUMINANCE_INTEGER_EXT:
+      *rSrc = *gSrc = *bSrc = 0;
+      *aSrc = -1;
+      break;
+   case GL_LUMINANCE_ALPHA:
+   case GL_LUMINANCE_ALPHA_INTEGER_EXT:
+      *rSrc = *gSrc = *bSrc = 0;
+      *aSrc = 1;
+      break;
+   case GL_INTENSITY:
+      *rSrc = *gSrc = *bSrc = *aSrc = 0;
+      break;
+   case GL_RG:
+   case GL_RG_INTEGER:
+      *rSrc = 0;
+      *gSrc = 1;
+      *bSrc = -1;
+      *aSrc = -1;
+      *rDst = 0;
+      *gDst = 1;
+      *bDst = 2;
+      *aDst = 3;
+      break;
+   case GL_RGB:
+   case GL_RGB_INTEGER:
+      *rSrc = 0;
+      *gSrc = 1;
+      *bSrc = 2;
+      *aSrc = -1;
+      *rDst = 0;
+      *gDst = 1;
+      *bDst = 2;
+      *aDst = 3;
+      break;
+   case GL_BGR:
+      *rSrc = 2;
+      *gSrc = 1;
+      *bSrc = 0;
+      *aSrc = -1;
+      *rDst = 2;
+      *gDst = 1;
+      *bDst = 0;
+      *aDst = 3;
+      break;
+   case GL_RGBA:
+   case GL_RGBA_INTEGER:
+      *rSrc = 0;
+      *gSrc = 1;
+      *bSrc = 2;
+      *aSrc = 3;
+      *rDst = 0;
+      *gDst = 1;
+      *bDst = 2;
+      *aDst = 3;
+      break;
+   case GL_BGRA:
+      *rSrc = 2;
+      *gSrc = 1;
+      *bSrc = 0;
+      *aSrc = 3;
+      *rDst = 2;
+      *gDst = 1;
+      *bDst = 0;
+      *aDst = 3;
+      break;
+   case GL_ABGR_EXT:
+      *rSrc = 3;
+      *gSrc = 2;
+      *bSrc = 1;
+      *aSrc = 0;
+      *rDst = 3;
+      *gDst = 2;
+      *bDst = 1;
+      *aDst = 0;
+      break;
+   case GL_DU8DV8_ATI:
+   case GL_DUDV_ATI:
+      *rSrc = 0;
+      *gSrc = 1;
+      *bSrc = -1;
+      *aSrc = -1;
+      break;
+   default:
+      _mesa_problem(NULL, "bad srcFormat %s in get_component_mapping",
+                    _mesa_lookup_enum_by_nr(format));
+      return;
+   }
+}
+
+
+
+/*
+ * This function extracts floating point RGBA values from arbitrary
+ * image data.  srcFormat and srcType are the format and type parameters
+ * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
+ *
+ * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
+ * implements the "Conversion to floating point", "Conversion to RGB",
+ * and "Final Expansion to RGBA" operations.
+ *
+ * Args:  n - number of pixels
+ *        rgba - output colors
+ *        srcFormat - format of incoming data
+ *        srcType - data type of incoming data
+ *        src - source data pointer
+ *        swapBytes - perform byteswapping of incoming data?
+ */
+static void
+extract_float_rgba(GLuint n, GLfloat rgba[][4],
+                   GLenum srcFormat, GLenum srcType, const GLvoid *src,
+                   GLboolean swapBytes)
+{
+   GLint rSrc, gSrc, bSrc, aSrc;
+   GLint stride;
+   GLint rDst, bDst, gDst, aDst;
+   GLboolean intFormat;
+   GLfloat rs = 1.0f, gs = 1.0f, bs = 1.0f, as = 1.0f; /* scale factors */
+
+   ASSERT(srcFormat == GL_RED ||
+          srcFormat == GL_GREEN ||
+          srcFormat == GL_BLUE ||
+          srcFormat == GL_ALPHA ||
+          srcFormat == GL_LUMINANCE ||
+          srcFormat == GL_LUMINANCE_ALPHA ||
+          srcFormat == GL_INTENSITY ||
+          srcFormat == GL_RG ||
+          srcFormat == GL_RGB ||
+          srcFormat == GL_BGR ||
+          srcFormat == GL_RGBA ||
+          srcFormat == GL_BGRA ||
+          srcFormat == GL_ABGR_EXT ||
+          srcFormat == GL_DU8DV8_ATI ||
+          srcFormat == GL_DUDV_ATI ||
+          srcFormat == GL_RED_INTEGER_EXT ||
+          srcFormat == GL_GREEN_INTEGER_EXT ||
+          srcFormat == GL_BLUE_INTEGER_EXT ||
+          srcFormat == GL_ALPHA_INTEGER_EXT ||
+          srcFormat == GL_RGB_INTEGER_EXT ||
+          srcFormat == GL_RGBA_INTEGER_EXT ||
+          srcFormat == GL_BGR_INTEGER_EXT ||
+          srcFormat == GL_BGRA_INTEGER_EXT ||
+          srcFormat == GL_LUMINANCE_INTEGER_EXT ||
+          srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
+
+   ASSERT(srcType == GL_UNSIGNED_BYTE ||
+          srcType == GL_BYTE ||
+          srcType == GL_UNSIGNED_SHORT ||
+          srcType == GL_SHORT ||
+          srcType == GL_UNSIGNED_INT ||
+          srcType == GL_INT ||
+          srcType == GL_HALF_FLOAT_ARB ||
+          srcType == GL_FLOAT ||
+          srcType == GL_UNSIGNED_BYTE_3_3_2 ||
+          srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
+          srcType == GL_UNSIGNED_SHORT_5_6_5 ||
+          srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
+          srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
+          srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
+          srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
+          srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
+          srcType == GL_UNSIGNED_INT_8_8_8_8 ||
+          srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
+          srcType == GL_UNSIGNED_INT_10_10_10_2 ||
+          srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
+
+   get_component_mapping(srcFormat,
+                         &rSrc, &gSrc, &bSrc, &aSrc,
+                         &rDst, &gDst, &bDst, &aDst);
+
+   stride = _mesa_components_in_format(srcFormat);
+
+   intFormat = _mesa_is_integer_format(srcFormat);
+
+#define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT_FLT, DEFAULT_INT, TYPE, CONVERSION) \
+   if ((SRC_INDEX) < 0) {						\
+      GLuint i;								\
+      if (intFormat) {							\
+         for (i = 0; i < n; i++) {					\
+            rgba[i][DST_INDEX] = DEFAULT_INT;				\
+         }								\
+      }									\
+      else {								\
+         for (i = 0; i < n; i++) {					\
+            rgba[i][DST_INDEX] = DEFAULT_FLT;				\
+         }								\
+      }									\
+   }									\
+   else if (swapBytes) {						\
+      const TYPE *s = (const TYPE *) src;				\
+      GLuint i;								\
+      for (i = 0; i < n; i++) {						\
+         TYPE value = s[SRC_INDEX];					\
+         if (sizeof(TYPE) == 2) {					\
+            SWAP2BYTE(value);						\
+         }								\
+         else if (sizeof(TYPE) == 4) {					\
+            SWAP4BYTE(value);						\
+         }								\
+         if (intFormat)							\
+            rgba[i][DST_INDEX] = (GLfloat) value;			\
+         else								\
+            rgba[i][DST_INDEX] = (GLfloat) CONVERSION(value);		\
+         s += stride;							\
+      }									\
+   }									\
+   else {								\
+      const TYPE *s = (const TYPE *) src;				\
+      GLuint i;								\
+      if (intFormat) {							\
+         for (i = 0; i < n; i++) {					\
+            rgba[i][DST_INDEX] = (GLfloat) s[SRC_INDEX];		\
+            s += stride;						\
+         }								\
+      }									\
+      else {								\
+         for (i = 0; i < n; i++) {					\
+            rgba[i][DST_INDEX] = (GLfloat) CONVERSION(s[SRC_INDEX]);	\
+            s += stride;						\
+         }								\
+      }									\
+   }
+
+   switch (srcType) {
+      case GL_UNSIGNED_BYTE:
+         PROCESS(rSrc, RCOMP, 0.0F,   0, GLubyte, UBYTE_TO_FLOAT);
+         PROCESS(gSrc, GCOMP, 0.0F,   0, GLubyte, UBYTE_TO_FLOAT);
+         PROCESS(bSrc, BCOMP, 0.0F,   0, GLubyte, UBYTE_TO_FLOAT);
+         PROCESS(aSrc, ACOMP, 1.0F, 255, GLubyte, UBYTE_TO_FLOAT);
+         break;
+      case GL_BYTE:
+         PROCESS(rSrc, RCOMP, 0.0F,   0, GLbyte, BYTE_TO_FLOAT);
+         PROCESS(gSrc, GCOMP, 0.0F,   0, GLbyte, BYTE_TO_FLOAT);
+         PROCESS(bSrc, BCOMP, 0.0F,   0, GLbyte, BYTE_TO_FLOAT);
+         PROCESS(aSrc, ACOMP, 1.0F, 127, GLbyte, BYTE_TO_FLOAT);
+         break;
+      case GL_UNSIGNED_SHORT:
+         PROCESS(rSrc, RCOMP, 0.0F,      0, GLushort, USHORT_TO_FLOAT);
+         PROCESS(gSrc, GCOMP, 0.0F,      0, GLushort, USHORT_TO_FLOAT);
+         PROCESS(bSrc, BCOMP, 0.0F,      0, GLushort, USHORT_TO_FLOAT);
+         PROCESS(aSrc, ACOMP, 1.0F, 0xffff, GLushort, USHORT_TO_FLOAT);
+         break;
+      case GL_SHORT:
+         PROCESS(rSrc, RCOMP, 0.0F,     0, GLshort, SHORT_TO_FLOAT);
+         PROCESS(gSrc, GCOMP, 0.0F,     0, GLshort, SHORT_TO_FLOAT);
+         PROCESS(bSrc, BCOMP, 0.0F,     0, GLshort, SHORT_TO_FLOAT);
+         PROCESS(aSrc, ACOMP, 1.0F, 32767, GLshort, SHORT_TO_FLOAT);
+         break;
+      case GL_UNSIGNED_INT:
+         PROCESS(rSrc, RCOMP, 0.0F,          0, GLuint, UINT_TO_FLOAT);
+         PROCESS(gSrc, GCOMP, 0.0F,          0, GLuint, UINT_TO_FLOAT);
+         PROCESS(bSrc, BCOMP, 0.0F,          0, GLuint, UINT_TO_FLOAT);
+         PROCESS(aSrc, ACOMP, 1.0F, 0xffffffff, GLuint, UINT_TO_FLOAT);
+         break;
+      case GL_INT:
+         PROCESS(rSrc, RCOMP, 0.0F,          0, GLint, INT_TO_FLOAT);
+         PROCESS(gSrc, GCOMP, 0.0F,          0, GLint, INT_TO_FLOAT);
+         PROCESS(bSrc, BCOMP, 0.0F,          0, GLint, INT_TO_FLOAT);
+         PROCESS(aSrc, ACOMP, 1.0F, 2147483647, GLint, INT_TO_FLOAT);
+         break;
+      case GL_FLOAT:
+         PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
+         PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
+         PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLfloat, (GLfloat));
+         PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLfloat, (GLfloat));
+         break;
+      case GL_HALF_FLOAT_ARB:
+         PROCESS(rSrc, RCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
+         PROCESS(gSrc, GCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
+         PROCESS(bSrc, BCOMP, 0.0F, 0.0F, GLhalfARB, _mesa_half_to_float);
+         PROCESS(aSrc, ACOMP, 1.0F, 1.0F, GLhalfARB, _mesa_half_to_float);
+         break;
+      case GL_UNSIGNED_BYTE_3_3_2:
+         {
+            const GLubyte *ubsrc = (const GLubyte *) src;
+            GLuint i;
+            if (!intFormat) {
+               rs = 1.0F / 7.0F;
+               gs = 1.0F / 7.0F;
+               bs = 1.0F / 3.0F;
+            }
+            for (i = 0; i < n; i ++) {
+               GLubyte p = ubsrc[i];
+               rgba[i][rDst] = ((p >> 5)      ) * rs;
+               rgba[i][gDst] = ((p >> 2) & 0x7) * gs;
+               rgba[i][bDst] = ((p     ) & 0x3) * bs;
+               rgba[i][aDst] = 1.0F;
+            }
+         }
+         break;
+      case GL_UNSIGNED_BYTE_2_3_3_REV:
+         {
+            const GLubyte *ubsrc = (const GLubyte *) src;
+            GLuint i;
+            if (!intFormat) {
+               rs = 1.0F / 7.0F;
+               gs = 1.0F / 7.0F;
+               bs = 1.0F / 3.0F;
+            }
+            for (i = 0; i < n; i ++) {
+               GLubyte p = ubsrc[i];
+               rgba[i][rDst] = ((p     ) & 0x7) * rs;
+               rgba[i][gDst] = ((p >> 3) & 0x7) * gs;
+               rgba[i][bDst] = ((p >> 6)      ) * bs;
+               rgba[i][aDst] = 1.0F;
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_5_6_5:
+         if (!intFormat) {
+            rs = 1.0F / 31.0F;
+            gs = 1.0F / 63.0F;
+            bs = 1.0F / 31.0F;
+         }
+         if (swapBytes) {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               SWAP2BYTE(p);
+               rgba[i][rDst] = ((p >> 11)       ) * rs;
+               rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;
+               rgba[i][bDst] = ((p      ) & 0x1f) * bs;
+               rgba[i][aDst] = 1.0F;
+            }
+         }
+         else {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               rgba[i][rDst] = ((p >> 11)       ) * rs;
+               rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;
+               rgba[i][bDst] = ((p      ) & 0x1f) * bs;
+               rgba[i][aDst] = 1.0F;
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_5_6_5_REV:
+         if (!intFormat) {
+            rs = 1.0F / 31.0F;
+            gs = 1.0F / 63.0F;
+            bs = 1.0F / 31.0F;
+         }
+         if (swapBytes) {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               SWAP2BYTE(p);
+               rgba[i][rDst] = ((p      ) & 0x1f) * rs;
+               rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;
+               rgba[i][bDst] = ((p >> 11)       ) * bs;
+               rgba[i][aDst] = 1.0F;
+            }
+         }
+         else {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               rgba[i][rDst] = ((p      ) & 0x1f) * rs;
+               rgba[i][gDst] = ((p >>  5) & 0x3f) * gs;
+               rgba[i][bDst] = ((p >> 11)       ) * bs;
+               rgba[i][aDst] = 1.0F;
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_4_4_4_4:
+         if (!intFormat) {
+            rs = gs = bs = as = 1.0F / 15.0F;
+         }
+         if (swapBytes) {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               SWAP2BYTE(p);
+               rgba[i][rDst] = ((p >> 12)      ) * rs;
+               rgba[i][gDst] = ((p >>  8) & 0xf) * gs;
+               rgba[i][bDst] = ((p >>  4) & 0xf) * bs;
+               rgba[i][aDst] = ((p      ) & 0xf) * as;
+            }
+         }
+         else {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               rgba[i][rDst] = ((p >> 12)      ) * rs;
+               rgba[i][gDst] = ((p >>  8) & 0xf) * gs;
+               rgba[i][bDst] = ((p >>  4) & 0xf) * bs;
+               rgba[i][aDst] = ((p      ) & 0xf) * as;
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
+         if (!intFormat) {
+            rs = gs = bs = as = 1.0F / 15.0F;
+         }
+         if (swapBytes) {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               SWAP2BYTE(p);
+               rgba[i][rDst] = ((p      ) & 0xf) * rs;
+               rgba[i][gDst] = ((p >>  4) & 0xf) * gs;
+               rgba[i][bDst] = ((p >>  8) & 0xf) * bs;
+               rgba[i][aDst] = ((p >> 12)      ) * as;
+            }
+         }
+         else {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               rgba[i][rDst] = ((p      ) & 0xf) * rs;
+               rgba[i][gDst] = ((p >>  4) & 0xf) * gs;
+               rgba[i][bDst] = ((p >>  8) & 0xf) * bs;
+               rgba[i][aDst] = ((p >> 12)      ) * as;
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_5_5_5_1:
+         if (!intFormat) {
+            rs = gs = bs = 1.0F / 31.0F;
+         }
+         if (swapBytes) {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               SWAP2BYTE(p);
+               rgba[i][rDst] = ((p >> 11)       ) * rs;
+               rgba[i][gDst] = ((p >>  6) & 0x1f) * gs;
+               rgba[i][bDst] = ((p >>  1) & 0x1f) * bs;
+               rgba[i][aDst] = ((p      ) & 0x1)  * as;
+            }
+         }
+         else {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               rgba[i][rDst] = ((p >> 11)       ) * rs;
+               rgba[i][gDst] = ((p >>  6) & 0x1f) * gs;
+               rgba[i][bDst] = ((p >>  1) & 0x1f) * bs;
+               rgba[i][aDst] = ((p      ) & 0x1)  * as;
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
+         if (!intFormat) {
+            rs = gs = bs = 1.0F / 31.0F;
+         }
+         if (swapBytes) {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               SWAP2BYTE(p);
+               rgba[i][rDst] = ((p      ) & 0x1f) * rs;
+               rgba[i][gDst] = ((p >>  5) & 0x1f) * gs;
+               rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
+               rgba[i][aDst] = ((p >> 15)       ) * as;
+            }
+         }
+         else {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               rgba[i][rDst] = ((p      ) & 0x1f) * rs;
+               rgba[i][gDst] = ((p >>  5) & 0x1f) * gs;
+               rgba[i][bDst] = ((p >> 10) & 0x1f) * bs;
+               rgba[i][aDst] = ((p >> 15)       ) * as;
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT_8_8_8_8:
+         if (swapBytes) {
+            const GLuint *uisrc = (const GLuint *) src;
+            GLuint i;
+            if (intFormat) {
+               for (i = 0; i < n; i ++) {
+                  GLuint p = uisrc[i];
+                  rgba[i][rDst] = (GLfloat) ((p      ) & 0xff);
+                  rgba[i][gDst] = (GLfloat) ((p >>  8) & 0xff);
+                  rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
+                  rgba[i][aDst] = (GLfloat) ((p >> 24)       );
+               }
+            }
+            else {
+               for (i = 0; i < n; i ++) {
+                  GLuint p = uisrc[i];
+                  rgba[i][rDst] = UBYTE_TO_FLOAT((p      ) & 0xff);
+                  rgba[i][gDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
+                  rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
+                  rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24)       );
+               }
+            }
+         }
+         else {
+            const GLuint *uisrc = (const GLuint *) src;
+            GLuint i;
+            if (intFormat) {
+               for (i = 0; i < n; i ++) {
+                  GLuint p = uisrc[i];
+                  rgba[i][rDst] = (GLfloat) ((p >> 24)       );
+                  rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
+                  rgba[i][bDst] = (GLfloat) ((p >>  8) & 0xff);
+                  rgba[i][aDst] = (GLfloat) ((p      ) & 0xff);
+               }
+            }
+            else {
+               for (i = 0; i < n; i ++) {
+                  GLuint p = uisrc[i];
+                  rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24)       );
+                  rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
+                  rgba[i][bDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
+                  rgba[i][aDst] = UBYTE_TO_FLOAT((p      ) & 0xff);
+               }
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT_8_8_8_8_REV:
+         if (swapBytes) {
+            const GLuint *uisrc = (const GLuint *) src;
+            GLuint i;
+            if (intFormat) {
+               for (i = 0; i < n; i ++) {
+                  GLuint p = uisrc[i];
+                  rgba[i][rDst] = (GLfloat) ((p >> 24)       );
+                  rgba[i][gDst] = (GLfloat) ((p >> 16) & 0xff);
+                  rgba[i][bDst] = (GLfloat) ((p >>  8) & 0xff);
+                  rgba[i][aDst] = (GLfloat) ((p      ) & 0xff);
+               }
+            }
+            else {
+               for (i = 0; i < n; i ++) {
+                  GLuint p = uisrc[i];
+                  rgba[i][rDst] = UBYTE_TO_FLOAT((p >> 24)       );
+                  rgba[i][gDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
+                  rgba[i][bDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
+                  rgba[i][aDst] = UBYTE_TO_FLOAT((p      ) & 0xff);
+               }
+            }
+         }
+         else {
+            const GLuint *uisrc = (const GLuint *) src;
+            GLuint i;
+            if (intFormat) {
+               for (i = 0; i < n; i ++) {
+                  GLuint p = uisrc[i];
+                  rgba[i][rDst] = (GLfloat) ((p      ) & 0xff);
+                  rgba[i][gDst] = (GLfloat) ((p >>  8) & 0xff);
+                  rgba[i][bDst] = (GLfloat) ((p >> 16) & 0xff);
+                  rgba[i][aDst] = (GLfloat) ((p >> 24)       );
+               }
+            }
+            else {
+               for (i = 0; i < n; i ++) {
+                  GLuint p = uisrc[i];
+                  rgba[i][rDst] = UBYTE_TO_FLOAT((p      ) & 0xff);
+                  rgba[i][gDst] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
+                  rgba[i][bDst] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
+                  rgba[i][aDst] = UBYTE_TO_FLOAT((p >> 24)       );
+               }
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT_10_10_10_2:
+         if (!intFormat) {
+            rs = 1.0F / 1023.0F;
+            gs = 1.0F / 1023.0F;
+            bs = 1.0F / 1023.0F;
+            as = 1.0F / 3.0F;
+         }
+         if (swapBytes) {
+            const GLuint *uisrc = (const GLuint *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLuint p = uisrc[i];
+               SWAP4BYTE(p);
+               rgba[i][rDst] = ((p >> 22)        ) * rs;
+               rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
+               rgba[i][bDst] = ((p >>  2) & 0x3ff) * bs;
+               rgba[i][aDst] = ((p      ) & 0x3  ) * as;
+            }
+         }
+         else {
+            const GLuint *uisrc = (const GLuint *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLuint p = uisrc[i];
+               rgba[i][rDst] = ((p >> 22)        ) * rs;
+               rgba[i][gDst] = ((p >> 12) & 0x3ff) * gs;
+               rgba[i][bDst] = ((p >>  2) & 0x3ff) * bs;
+               rgba[i][aDst] = ((p      ) & 0x3  ) * as;
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT_2_10_10_10_REV:
+         if (!intFormat) {
+            rs = 1.0F / 1023.0F;
+            gs = 1.0F / 1023.0F;
+            bs = 1.0F / 1023.0F;
+            as = 1.0F / 3.0F;
+         }
+         if (swapBytes) {
+            const GLuint *uisrc = (const GLuint *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLuint p = uisrc[i];
+               SWAP4BYTE(p);
+               rgba[i][rDst] = ((p      ) & 0x3ff) * rs;
+               rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
+               rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
+               rgba[i][aDst] = ((p >> 30)        ) * as;
+            }
+         }
+         else {
+            const GLuint *uisrc = (const GLuint *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLuint p = uisrc[i];
+               rgba[i][rDst] = ((p      ) & 0x3ff) * rs;
+               rgba[i][gDst] = ((p >> 10) & 0x3ff) * gs;
+               rgba[i][bDst] = ((p >> 20) & 0x3ff) * bs;
+               rgba[i][aDst] = ((p >> 30)        ) * as;
+            }
+         }
+         break;
+      default:
+         _mesa_problem(NULL, "bad srcType in extract float data");
+         break;
+   }
+#undef PROCESS
+}
+
+
+static INLINE GLuint
+clamp_byte_to_uint(GLbyte b)
+{
+   return b < 0 ? 0 : b;
+}
+
+
+static INLINE GLuint
+clamp_short_to_uint(GLshort s)
+{
+   return s < 0 ? 0 : s;
+}
+
+
+static INLINE GLuint
+clamp_int_to_uint(GLint i)
+{
+   return i < 0 ? 0 : i;
+}
+
+
+static INLINE GLuint
+clamp_float_to_uint(GLfloat f)
+{
+   return f < 0.0F ? 0 : IROUND(f);
+}
+
+
+static INLINE GLuint
+clamp_half_to_uint(GLhalfARB h)
+{
+   GLfloat f = _mesa_half_to_float(h);
+   return f < 0.0F ? 0 : IROUND(f);
+}
+
+
+/**
+ * \sa extract_float_rgba()
+ */
+static void
+extract_uint_rgba(GLuint n, GLuint rgba[][4],
+                  GLenum srcFormat, GLenum srcType, const GLvoid *src,
+                  GLboolean swapBytes)
+{
+   GLint rSrc, gSrc, bSrc, aSrc;
+   GLint stride;
+   GLint rDst, bDst, gDst, aDst;
+   GLboolean intFormat;
+
+   ASSERT(srcFormat == GL_RED ||
+          srcFormat == GL_GREEN ||
+          srcFormat == GL_BLUE ||
+          srcFormat == GL_ALPHA ||
+          srcFormat == GL_LUMINANCE ||
+          srcFormat == GL_LUMINANCE_ALPHA ||
+          srcFormat == GL_INTENSITY ||
+          srcFormat == GL_RG ||
+          srcFormat == GL_RGB ||
+          srcFormat == GL_BGR ||
+          srcFormat == GL_RGBA ||
+          srcFormat == GL_BGRA ||
+          srcFormat == GL_ABGR_EXT ||
+          srcFormat == GL_DU8DV8_ATI ||
+          srcFormat == GL_DUDV_ATI ||
+          srcFormat == GL_RED_INTEGER_EXT ||
+          srcFormat == GL_GREEN_INTEGER_EXT ||
+          srcFormat == GL_BLUE_INTEGER_EXT ||
+          srcFormat == GL_ALPHA_INTEGER_EXT ||
+          srcFormat == GL_RGB_INTEGER_EXT ||
+          srcFormat == GL_RGBA_INTEGER_EXT ||
+          srcFormat == GL_BGR_INTEGER_EXT ||
+          srcFormat == GL_BGRA_INTEGER_EXT ||
+          srcFormat == GL_LUMINANCE_INTEGER_EXT ||
+          srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
+
+   ASSERT(srcType == GL_UNSIGNED_BYTE ||
+          srcType == GL_BYTE ||
+          srcType == GL_UNSIGNED_SHORT ||
+          srcType == GL_SHORT ||
+          srcType == GL_UNSIGNED_INT ||
+          srcType == GL_INT ||
+          srcType == GL_HALF_FLOAT_ARB ||
+          srcType == GL_FLOAT ||
+          srcType == GL_UNSIGNED_BYTE_3_3_2 ||
+          srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
+          srcType == GL_UNSIGNED_SHORT_5_6_5 ||
+          srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
+          srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
+          srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
+          srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
+          srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
+          srcType == GL_UNSIGNED_INT_8_8_8_8 ||
+          srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
+          srcType == GL_UNSIGNED_INT_10_10_10_2 ||
+          srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
+
+   get_component_mapping(srcFormat,
+                         &rSrc, &gSrc, &bSrc, &aSrc,
+                         &rDst, &gDst, &bDst, &aDst);
+
+   stride = _mesa_components_in_format(srcFormat);
+
+   intFormat = _mesa_is_integer_format(srcFormat);
+
+#define PROCESS(SRC_INDEX, DST_INDEX, DEFAULT, TYPE, CONVERSION)	\
+   if ((SRC_INDEX) < 0) {						\
+      GLuint i;								\
+      for (i = 0; i < n; i++) {						\
+         rgba[i][DST_INDEX] = DEFAULT;					\
+      }									\
+   }									\
+   else if (swapBytes) {						\
+      const TYPE *s = (const TYPE *) src;				\
+      GLuint i;								\
+      for (i = 0; i < n; i++) {						\
+         TYPE value = s[SRC_INDEX];					\
+         if (sizeof(TYPE) == 2) {					\
+            SWAP2BYTE(value);						\
+         }								\
+         else if (sizeof(TYPE) == 4) {					\
+            SWAP4BYTE(value);						\
+         }								\
+         rgba[i][DST_INDEX] = CONVERSION(value);                        \
+         s += stride;							\
+      }									\
+   }									\
+   else {								\
+      const TYPE *s = (const TYPE *) src;				\
+      GLuint i;								\
+      for (i = 0; i < n; i++) {						\
+         rgba[i][DST_INDEX] = CONVERSION(s[SRC_INDEX]);			\
+         s += stride;							\
+      }									\
+   }
+
+   switch (srcType) {
+      case GL_UNSIGNED_BYTE:
+         PROCESS(rSrc, RCOMP, 0, GLubyte, (GLuint));
+         PROCESS(gSrc, GCOMP, 0, GLubyte, (GLuint));
+         PROCESS(bSrc, BCOMP, 0, GLubyte, (GLuint));
+         PROCESS(aSrc, ACOMP, 1, GLubyte, (GLuint));
+         break;
+      case GL_BYTE:
+         PROCESS(rSrc, RCOMP, 0, GLbyte, clamp_byte_to_uint);
+         PROCESS(gSrc, GCOMP, 0, GLbyte, clamp_byte_to_uint);
+         PROCESS(bSrc, BCOMP, 0, GLbyte, clamp_byte_to_uint);
+         PROCESS(aSrc, ACOMP, 1, GLbyte, clamp_byte_to_uint);
+         break;
+      case GL_UNSIGNED_SHORT:
+         PROCESS(rSrc, RCOMP, 0, GLushort, (GLuint));
+         PROCESS(gSrc, GCOMP, 0, GLushort, (GLuint));
+         PROCESS(bSrc, BCOMP, 0, GLushort, (GLuint));
+         PROCESS(aSrc, ACOMP, 1, GLushort, (GLuint));
+         break;
+      case GL_SHORT:
+         PROCESS(rSrc, RCOMP, 0, GLshort, clamp_short_to_uint);
+         PROCESS(gSrc, GCOMP, 0, GLshort, clamp_short_to_uint);
+         PROCESS(bSrc, BCOMP, 0, GLshort, clamp_short_to_uint);
+         PROCESS(aSrc, ACOMP, 1, GLshort, clamp_short_to_uint);
+         break;
+      case GL_UNSIGNED_INT:
+         PROCESS(rSrc, RCOMP, 0, GLuint, (GLuint));
+         PROCESS(gSrc, GCOMP, 0, GLuint, (GLuint));
+         PROCESS(bSrc, BCOMP, 0, GLuint, (GLuint));
+         PROCESS(aSrc, ACOMP, 1, GLuint, (GLuint));
+         break;
+      case GL_INT:
+         PROCESS(rSrc, RCOMP, 0, GLint, clamp_int_to_uint);
+         PROCESS(gSrc, GCOMP, 0, GLint, clamp_int_to_uint);
+         PROCESS(bSrc, BCOMP, 0, GLint, clamp_int_to_uint);
+         PROCESS(aSrc, ACOMP, 1, GLint, clamp_int_to_uint);
+         break;
+      case GL_FLOAT:
+         PROCESS(rSrc, RCOMP, 0, GLfloat, clamp_float_to_uint);
+         PROCESS(gSrc, GCOMP, 0, GLfloat, clamp_float_to_uint);
+         PROCESS(bSrc, BCOMP, 0, GLfloat, clamp_float_to_uint);
+         PROCESS(aSrc, ACOMP, 1, GLfloat, clamp_float_to_uint);
+         break;
+      case GL_HALF_FLOAT_ARB:
+         PROCESS(rSrc, RCOMP, 0, GLhalfARB, clamp_half_to_uint);
+         PROCESS(gSrc, GCOMP, 0, GLhalfARB, clamp_half_to_uint);
+         PROCESS(bSrc, BCOMP, 0, GLhalfARB, clamp_half_to_uint);
+         PROCESS(aSrc, ACOMP, 1, GLhalfARB, clamp_half_to_uint);
+         break;
+      case GL_UNSIGNED_BYTE_3_3_2:
+         {
+            const GLubyte *ubsrc = (const GLubyte *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLubyte p = ubsrc[i];
+               rgba[i][rDst] = ((p >> 5)      );
+               rgba[i][gDst] = ((p >> 2) & 0x7);
+               rgba[i][bDst] = ((p     ) & 0x3);
+               rgba[i][aDst] = 1;
+            }
+         }
+         break;
+      case GL_UNSIGNED_BYTE_2_3_3_REV:
+         {
+            const GLubyte *ubsrc = (const GLubyte *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLubyte p = ubsrc[i];
+               rgba[i][rDst] = ((p     ) & 0x7);
+               rgba[i][gDst] = ((p >> 3) & 0x7);
+               rgba[i][bDst] = ((p >> 6)      );
+               rgba[i][aDst] = 1;
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_5_6_5:
+         if (swapBytes) {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               SWAP2BYTE(p);
+               rgba[i][rDst] = ((p >> 11)       );
+               rgba[i][gDst] = ((p >>  5) & 0x3f);
+               rgba[i][bDst] = ((p      ) & 0x1f);
+               rgba[i][aDst] = 1;
+            }
+         }
+         else {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               rgba[i][rDst] = ((p >> 11)       );
+               rgba[i][gDst] = ((p >>  5) & 0x3f);
+               rgba[i][bDst] = ((p      ) & 0x1f);
+               rgba[i][aDst] = 1;
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_5_6_5_REV:
+         if (swapBytes) {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               SWAP2BYTE(p);
+               rgba[i][rDst] = ((p      ) & 0x1f);
+               rgba[i][gDst] = ((p >>  5) & 0x3f);
+               rgba[i][bDst] = ((p >> 11)       );
+               rgba[i][aDst] = 1;
+            }
+         }
+         else {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               rgba[i][rDst] = ((p      ) & 0x1f);
+               rgba[i][gDst] = ((p >>  5) & 0x3f);
+               rgba[i][bDst] = ((p >> 11)       );
+               rgba[i][aDst] = 1;
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_4_4_4_4:
+         if (swapBytes) {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               SWAP2BYTE(p);
+               rgba[i][rDst] = ((p >> 12)      );
+               rgba[i][gDst] = ((p >>  8) & 0xf);
+               rgba[i][bDst] = ((p >>  4) & 0xf);
+               rgba[i][aDst] = ((p      ) & 0xf);
+            }
+         }
+         else {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               rgba[i][rDst] = ((p >> 12)      );
+               rgba[i][gDst] = ((p >>  8) & 0xf);
+               rgba[i][bDst] = ((p >>  4) & 0xf);
+               rgba[i][aDst] = ((p      ) & 0xf);
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
+         if (swapBytes) {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               SWAP2BYTE(p);
+               rgba[i][rDst] = ((p      ) & 0xf);
+               rgba[i][gDst] = ((p >>  4) & 0xf);
+               rgba[i][bDst] = ((p >>  8) & 0xf);
+               rgba[i][aDst] = ((p >> 12)      );
+            }
+         }
+         else {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               rgba[i][rDst] = ((p      ) & 0xf);
+               rgba[i][gDst] = ((p >>  4) & 0xf);
+               rgba[i][bDst] = ((p >>  8) & 0xf);
+               rgba[i][aDst] = ((p >> 12)      );
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_5_5_5_1:
+         if (swapBytes) {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               SWAP2BYTE(p);
+               rgba[i][rDst] = ((p >> 11)       );
+               rgba[i][gDst] = ((p >>  6) & 0x1f);
+               rgba[i][bDst] = ((p >>  1) & 0x1f);
+               rgba[i][aDst] = ((p      ) & 0x1 );
+            }
+         }
+         else {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               rgba[i][rDst] = ((p >> 11)       );
+               rgba[i][gDst] = ((p >>  6) & 0x1f);
+               rgba[i][bDst] = ((p >>  1) & 0x1f);
+               rgba[i][aDst] = ((p      ) & 0x1 );
+            }
+         }
+         break;
+      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
+         if (swapBytes) {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               SWAP2BYTE(p);
+               rgba[i][rDst] = ((p      ) & 0x1f);
+               rgba[i][gDst] = ((p >>  5) & 0x1f);
+               rgba[i][bDst] = ((p >> 10) & 0x1f);
+               rgba[i][aDst] = ((p >> 15)       );
+            }
+         }
+         else {
+            const GLushort *ussrc = (const GLushort *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLushort p = ussrc[i];
+               rgba[i][rDst] = ((p      ) & 0x1f);
+               rgba[i][gDst] = ((p >>  5) & 0x1f);
+               rgba[i][bDst] = ((p >> 10) & 0x1f);
+               rgba[i][aDst] = ((p >> 15)       );
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT_8_8_8_8:
+         if (swapBytes) {
+            const GLuint *uisrc = (const GLuint *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLuint p = uisrc[i];
+               rgba[i][rDst] = ((p      ) & 0xff);
+               rgba[i][gDst] = ((p >>  8) & 0xff);
+               rgba[i][bDst] = ((p >> 16) & 0xff);
+               rgba[i][aDst] = ((p >> 24)       );
+            }
+         }
+         else {
+            const GLuint *uisrc = (const GLuint *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLuint p = uisrc[i];
+               rgba[i][rDst] = ((p >> 24)       );
+               rgba[i][gDst] = ((p >> 16) & 0xff);
+               rgba[i][bDst] = ((p >>  8) & 0xff);
+               rgba[i][aDst] = ((p      ) & 0xff);
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT_8_8_8_8_REV:
+         if (swapBytes) {
+            const GLuint *uisrc = (const GLuint *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLuint p = uisrc[i];
+               rgba[i][rDst] = ((p >> 24)       );
+               rgba[i][gDst] = ((p >> 16) & 0xff);
+               rgba[i][bDst] = ((p >>  8) & 0xff);
+               rgba[i][aDst] = ((p      ) & 0xff);
+            }
+         }
+         else {
+            const GLuint *uisrc = (const GLuint *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLuint p = uisrc[i];
+               rgba[i][rDst] = ((p      ) & 0xff);
+               rgba[i][gDst] = ((p >>  8) & 0xff);
+               rgba[i][bDst] = ((p >> 16) & 0xff);
+               rgba[i][aDst] = ((p >> 24)       );
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT_10_10_10_2:
+         if (swapBytes) {
+            const GLuint *uisrc = (const GLuint *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLuint p = uisrc[i];
+               SWAP4BYTE(p);
+               rgba[i][rDst] = ((p >> 22)        );
+               rgba[i][gDst] = ((p >> 12) & 0x3ff);
+               rgba[i][bDst] = ((p >>  2) & 0x3ff);
+               rgba[i][aDst] = ((p      ) & 0x3  );
+            }
+         }
+         else {
+            const GLuint *uisrc = (const GLuint *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLuint p = uisrc[i];
+               rgba[i][rDst] = ((p >> 22)        );
+               rgba[i][gDst] = ((p >> 12) & 0x3ff);
+               rgba[i][bDst] = ((p >>  2) & 0x3ff);
+               rgba[i][aDst] = ((p      ) & 0x3  );
+            }
+         }
+         break;
+      case GL_UNSIGNED_INT_2_10_10_10_REV:
+         if (swapBytes) {
+            const GLuint *uisrc = (const GLuint *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLuint p = uisrc[i];
+               SWAP4BYTE(p);
+               rgba[i][rDst] = ((p      ) & 0x3ff);
+               rgba[i][gDst] = ((p >> 10) & 0x3ff);
+               rgba[i][bDst] = ((p >> 20) & 0x3ff);
+               rgba[i][aDst] = ((p >> 30)        );
+            }
+         }
+         else {
+            const GLuint *uisrc = (const GLuint *) src;
+            GLuint i;
+            for (i = 0; i < n; i ++) {
+               GLuint p = uisrc[i];
+               rgba[i][rDst] = ((p      ) & 0x3ff);
+               rgba[i][gDst] = ((p >> 10) & 0x3ff);
+               rgba[i][bDst] = ((p >> 20) & 0x3ff);
+               rgba[i][aDst] = ((p >> 30)        );
+            }
+         }
+         break;
+      default:
+         _mesa_problem(NULL, "bad srcType in extract uint data");
+         break;
+   }
+#undef PROCESS
+}
+
+
+
+/*
+ * Unpack a row of color image data from a client buffer according to
+ * the pixel unpacking parameters.
+ * Return GLchan values in the specified dest image format.
+ * This is used by glDrawPixels and glTexImage?D().
+ * \param ctx - the context
+ *         n - number of pixels in the span
+ *         dstFormat - format of destination color array
+ *         dest - the destination color array
+ *         srcFormat - source image format
+ *         srcType - source image  data type
+ *         source - source image pointer
+ *         srcPacking - pixel unpacking parameters
+ *         transferOps - bitmask of IMAGE_*_BIT values of operations to apply
+ *
+ * XXX perhaps expand this to process whole images someday.
+ */
+void
+_mesa_unpack_color_span_chan( struct gl_context *ctx,
+                              GLuint n, GLenum dstFormat, GLchan dest[],
+                              GLenum srcFormat, GLenum srcType,
+                              const GLvoid *source,
+                              const struct gl_pixelstore_attrib *srcPacking,
+                              GLbitfield transferOps )
+{
+   ASSERT(dstFormat == GL_ALPHA ||
+          dstFormat == GL_LUMINANCE ||
+          dstFormat == GL_LUMINANCE_ALPHA ||
+          dstFormat == GL_INTENSITY ||
+          dstFormat == GL_RED ||
+          dstFormat == GL_RG ||
+          dstFormat == GL_RGB ||
+          dstFormat == GL_RGBA ||
+          dstFormat == GL_COLOR_INDEX);
+
+   ASSERT(srcFormat == GL_RED ||
+          srcFormat == GL_GREEN ||
+          srcFormat == GL_BLUE ||
+          srcFormat == GL_ALPHA ||
+          srcFormat == GL_LUMINANCE ||
+          srcFormat == GL_LUMINANCE_ALPHA ||
+          srcFormat == GL_INTENSITY ||
+          srcFormat == GL_RG ||
+          srcFormat == GL_RGB ||
+          srcFormat == GL_BGR ||
+          srcFormat == GL_RGBA ||
+          srcFormat == GL_BGRA ||
+          srcFormat == GL_ABGR_EXT ||
+          srcFormat == GL_COLOR_INDEX);
+
+   ASSERT(srcType == GL_BITMAP ||
+          srcType == GL_UNSIGNED_BYTE ||
+          srcType == GL_BYTE ||
+          srcType == GL_UNSIGNED_SHORT ||
+          srcType == GL_SHORT ||
+          srcType == GL_UNSIGNED_INT ||
+          srcType == GL_INT ||
+          srcType == GL_HALF_FLOAT_ARB ||
+          srcType == GL_FLOAT ||
+          srcType == GL_UNSIGNED_BYTE_3_3_2 ||
+          srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
+          srcType == GL_UNSIGNED_SHORT_5_6_5 ||
+          srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
+          srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
+          srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
+          srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
+          srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
+          srcType == GL_UNSIGNED_INT_8_8_8_8 ||
+          srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
+          srcType == GL_UNSIGNED_INT_10_10_10_2 ||
+          srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
+
+   /* Try simple cases first */
+   if (transferOps == 0) {
+      if (srcType == CHAN_TYPE) {
+         if (dstFormat == GL_RGBA) {
+            if (srcFormat == GL_RGBA) {
+               memcpy( dest, source, n * 4 * sizeof(GLchan) );
+               return;
+            }
+            else if (srcFormat == GL_RGB) {
+               GLuint i;
+               const GLchan *src = (const GLchan *) source;
+               GLchan *dst = dest;
+               for (i = 0; i < n; i++) {
+                  dst[0] = src[0];
+                  dst[1] = src[1];
+                  dst[2] = src[2];
+                  dst[3] = CHAN_MAX;
+                  src += 3;
+                  dst += 4;
+               }
+               return;
+            }
+         }
+         else if (dstFormat == GL_RGB) {
+            if (srcFormat == GL_RGB) {
+               memcpy( dest, source, n * 3 * sizeof(GLchan) );
+               return;
+            }
+            else if (srcFormat == GL_RGBA) {
+               GLuint i;
+               const GLchan *src = (const GLchan *) source;
+               GLchan *dst = dest;
+               for (i = 0; i < n; i++) {
+                  dst[0] = src[0];
+                  dst[1] = src[1];
+                  dst[2] = src[2];
+                  src += 4;
+                  dst += 3;
+               }
+               return;
+            }
+         }
+         else if (dstFormat == srcFormat) {
+            GLint comps = _mesa_components_in_format(srcFormat);
+            assert(comps > 0);
+            memcpy( dest, source, n * comps * sizeof(GLchan) );
+            return;
+         }
+      }
+      /*
+       * Common situation, loading 8bit RGBA/RGB source images
+       * into 16/32 bit destination. (OSMesa16/32)
+       */
+      else if (srcType == GL_UNSIGNED_BYTE) {
+         if (dstFormat == GL_RGBA) {
+            if (srcFormat == GL_RGB) {
+               GLuint i;
+               const GLubyte *src = (const GLubyte *) source;
+               GLchan *dst = dest;
+               for (i = 0; i < n; i++) {
+                  dst[0] = UBYTE_TO_CHAN(src[0]);
+                  dst[1] = UBYTE_TO_CHAN(src[1]);
+                  dst[2] = UBYTE_TO_CHAN(src[2]);
+                  dst[3] = CHAN_MAX;
+                  src += 3;
+                  dst += 4;
+               }
+               return;
+            }
+            else if (srcFormat == GL_RGBA) {
+               GLuint i;
+               const GLubyte *src = (const GLubyte *) source;
+               GLchan *dst = dest;
+               for (i = 0; i < n; i++) {
+                  dst[0] = UBYTE_TO_CHAN(src[0]);
+                  dst[1] = UBYTE_TO_CHAN(src[1]);
+                  dst[2] = UBYTE_TO_CHAN(src[2]);
+                  dst[3] = UBYTE_TO_CHAN(src[3]);
+                  src += 4;
+                  dst += 4;
+               }
+               return;
+             }
+         }
+         else if (dstFormat == GL_RGB) {
+            if (srcFormat == GL_RGB) {
+               GLuint i;
+               const GLubyte *src = (const GLubyte *) source;
+               GLchan *dst = dest;
+               for (i = 0; i < n; i++) {
+                  dst[0] = UBYTE_TO_CHAN(src[0]);
+                  dst[1] = UBYTE_TO_CHAN(src[1]);
+                  dst[2] = UBYTE_TO_CHAN(src[2]);
+                  src += 3;
+                  dst += 3;
+               }
+               return;
+            }
+            else if (srcFormat == GL_RGBA) {
+               GLuint i;
+               const GLubyte *src = (const GLubyte *) source;
+               GLchan *dst = dest;
+               for (i = 0; i < n; i++) {
+                  dst[0] = UBYTE_TO_CHAN(src[0]);
+                  dst[1] = UBYTE_TO_CHAN(src[1]);
+                  dst[2] = UBYTE_TO_CHAN(src[2]);
+                  src += 4;
+                  dst += 3;
+               }
+               return;
+            }
+         }
+      }
+   }
+
+
+   /* general solution begins here */
+   {
+      GLint dstComponents;
+      GLint rDst, gDst, bDst, aDst, lDst, iDst;
+      GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
+
+      if (!rgba) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
+         return;
+      }
+
+      dstComponents = _mesa_components_in_format( dstFormat );
+      /* source & dest image formats should have been error checked by now */
+      assert(dstComponents > 0);
+
+      /*
+       * Extract image data and convert to RGBA floats
+       */
+      if (srcFormat == GL_COLOR_INDEX) {
+         GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
+
+         if (!indexes) {
+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
+            return;
+         }
+
+         extract_uint_indexes(n, indexes, srcFormat, srcType, source,
+                              srcPacking);
+
+         if (dstFormat == GL_COLOR_INDEX) {
+            GLuint i;
+            _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
+            /* convert to GLchan and return */
+            for (i = 0; i < n; i++) {
+               dest[i] = (GLchan) (indexes[i] & 0xff);
+            }
+            free(indexes);
+            free(rgba);
+            return;
+         }
+         else {
+            /* Convert indexes to RGBA */
+            if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
+               _mesa_shift_and_offset_ci(ctx, n, indexes);
+            }
+            _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
+         }
+
+         /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
+          * with color indexes.
+          */
+         transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
+
+         free(indexes);
+      }
+      else {
+         /* non-color index data */
+         extract_float_rgba(n, rgba, srcFormat, srcType, source,
+                            srcPacking->SwapBytes);
+      }
+
+      /* Need to clamp if returning GLubytes or GLushorts */
+#if CHAN_TYPE != GL_FLOAT
+      transferOps |= IMAGE_CLAMP_BIT;
+#endif
+
+      if (transferOps) {
+         _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
+      }
+
+      get_component_indexes(dstFormat,
+                            &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
+
+      /* Now return the GLchan data in the requested dstFormat */
+      if (rDst >= 0) {
+         GLchan *dst = dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            CLAMPED_FLOAT_TO_CHAN(dst[rDst], rgba[i][RCOMP]);
+            dst += dstComponents;
+         }
+      }
+
+      if (gDst >= 0) {
+         GLchan *dst = dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            CLAMPED_FLOAT_TO_CHAN(dst[gDst], rgba[i][GCOMP]);
+            dst += dstComponents;
+         }
+      }
+
+      if (bDst >= 0) {
+         GLchan *dst = dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            CLAMPED_FLOAT_TO_CHAN(dst[bDst], rgba[i][BCOMP]);
+            dst += dstComponents;
+         }
+      }
+
+      if (aDst >= 0) {
+         GLchan *dst = dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            CLAMPED_FLOAT_TO_CHAN(dst[aDst], rgba[i][ACOMP]);
+            dst += dstComponents;
+         }
+      }
+
+      if (iDst >= 0) {
+         GLchan *dst = dest;
+         GLuint i;
+         assert(iDst == 0);
+         assert(dstComponents == 1);
+         for (i = 0; i < n; i++) {
+            /* Intensity comes from red channel */
+            CLAMPED_FLOAT_TO_CHAN(dst[i], rgba[i][RCOMP]);
+         }
+      }
+
+      if (lDst >= 0) {
+         GLchan *dst = dest;
+         GLuint i;
+         assert(lDst == 0);
+         for (i = 0; i < n; i++) {
+            /* Luminance comes from red channel */
+            CLAMPED_FLOAT_TO_CHAN(dst[0], rgba[i][RCOMP]);
+            dst += dstComponents;
+         }
+      }
+
+      free(rgba);
+   }
+}
+
+
+/**
+ * Same as _mesa_unpack_color_span_chan(), but return GLfloat data
+ * instead of GLchan.
+ */
+void
+_mesa_unpack_color_span_float( struct gl_context *ctx,
+                               GLuint n, GLenum dstFormat, GLfloat dest[],
+                               GLenum srcFormat, GLenum srcType,
+                               const GLvoid *source,
+                               const struct gl_pixelstore_attrib *srcPacking,
+                               GLbitfield transferOps )
+{
+   ASSERT(dstFormat == GL_ALPHA ||
+          dstFormat == GL_LUMINANCE ||
+          dstFormat == GL_LUMINANCE_ALPHA ||
+          dstFormat == GL_INTENSITY ||
+          dstFormat == GL_RED ||
+          dstFormat == GL_RG ||
+          dstFormat == GL_RGB ||
+          dstFormat == GL_RGBA ||
+          dstFormat == GL_COLOR_INDEX);
+
+   ASSERT(srcFormat == GL_RED ||
+          srcFormat == GL_GREEN ||
+          srcFormat == GL_BLUE ||
+          srcFormat == GL_ALPHA ||
+          srcFormat == GL_LUMINANCE ||
+          srcFormat == GL_LUMINANCE_ALPHA ||
+          srcFormat == GL_INTENSITY ||
+          srcFormat == GL_RG ||
+          srcFormat == GL_RGB ||
+          srcFormat == GL_BGR ||
+          srcFormat == GL_RGBA ||
+          srcFormat == GL_BGRA ||
+          srcFormat == GL_ABGR_EXT ||
+          srcFormat == GL_RED_INTEGER_EXT ||
+          srcFormat == GL_GREEN_INTEGER_EXT ||
+          srcFormat == GL_BLUE_INTEGER_EXT ||
+          srcFormat == GL_ALPHA_INTEGER_EXT ||
+          srcFormat == GL_RGB_INTEGER_EXT ||
+          srcFormat == GL_RGBA_INTEGER_EXT ||
+          srcFormat == GL_BGR_INTEGER_EXT ||
+          srcFormat == GL_BGRA_INTEGER_EXT ||
+          srcFormat == GL_LUMINANCE_INTEGER_EXT ||
+          srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT ||
+          srcFormat == GL_COLOR_INDEX);
+
+   ASSERT(srcType == GL_BITMAP ||
+          srcType == GL_UNSIGNED_BYTE ||
+          srcType == GL_BYTE ||
+          srcType == GL_UNSIGNED_SHORT ||
+          srcType == GL_SHORT ||
+          srcType == GL_UNSIGNED_INT ||
+          srcType == GL_INT ||
+          srcType == GL_HALF_FLOAT_ARB ||
+          srcType == GL_FLOAT ||
+          srcType == GL_UNSIGNED_BYTE_3_3_2 ||
+          srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
+          srcType == GL_UNSIGNED_SHORT_5_6_5 ||
+          srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
+          srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
+          srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
+          srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
+          srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
+          srcType == GL_UNSIGNED_INT_8_8_8_8 ||
+          srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
+          srcType == GL_UNSIGNED_INT_10_10_10_2 ||
+          srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
+
+   /* general solution, no special cases, yet */
+   {
+      GLint dstComponents;
+      GLint rDst, gDst, bDst, aDst, lDst, iDst;
+      GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
+
+      if (!rgba) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
+         return;
+      }
+
+      dstComponents = _mesa_components_in_format( dstFormat );
+      /* source & dest image formats should have been error checked by now */
+      assert(dstComponents > 0);
+
+      /*
+       * Extract image data and convert to RGBA floats
+       */
+      if (srcFormat == GL_COLOR_INDEX) {
+         GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
+
+         if (!indexes) {
+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
+            free(rgba);
+            return;
+         }
+
+         extract_uint_indexes(n, indexes, srcFormat, srcType, source,
+                              srcPacking);
+
+         if (dstFormat == GL_COLOR_INDEX) {
+            GLuint i;
+            _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
+            /* convert to GLchan and return */
+            for (i = 0; i < n; i++) {
+               dest[i] = (GLchan) (indexes[i] & 0xff);
+            }
+            free(indexes);
+            free(rgba);
+            return;
+         }
+         else {
+            /* Convert indexes to RGBA */
+            if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
+               _mesa_shift_and_offset_ci(ctx, n, indexes);
+            }
+            _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
+         }
+
+         /* Don't do RGBA scale/bias or RGBA->RGBA mapping if starting
+          * with color indexes.
+          */
+         transferOps &= ~(IMAGE_SCALE_BIAS_BIT | IMAGE_MAP_COLOR_BIT);
+
+         free(indexes);
+      }
+      else {
+         /* non-color index data */
+         extract_float_rgba(n, rgba, srcFormat, srcType, source,
+                            srcPacking->SwapBytes);
+      }
+
+      if (transferOps) {
+         _mesa_apply_rgba_transfer_ops(ctx, transferOps, n, rgba);
+      }
+
+      get_component_indexes(dstFormat,
+                            &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
+
+      /* Now pack results in the requested dstFormat */
+      if (rDst >= 0) {
+         GLfloat *dst = dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[rDst] = rgba[i][RCOMP];
+            dst += dstComponents;
+         }
+      }
+
+      if (gDst >= 0) {
+         GLfloat *dst = dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[gDst] = rgba[i][GCOMP];
+            dst += dstComponents;
+         }
+      }
+
+      if (bDst >= 0) {
+         GLfloat *dst = dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[bDst] = rgba[i][BCOMP];
+            dst += dstComponents;
+         }
+      }
+
+      if (aDst >= 0) {
+         GLfloat *dst = dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[aDst] = rgba[i][ACOMP];
+            dst += dstComponents;
+         }
+      }
+
+      if (iDst >= 0) {
+         GLfloat *dst = dest;
+         GLuint i;
+         assert(iDst == 0);
+         assert(dstComponents == 1);
+         for (i = 0; i < n; i++) {
+            /* Intensity comes from red channel */
+            dst[i] = rgba[i][RCOMP];
+         }
+      }
+
+      if (lDst >= 0) {
+         GLfloat *dst = dest;
+         GLuint i;
+         assert(lDst == 0);
+         for (i = 0; i < n; i++) {
+            /* Luminance comes from red channel */
+            dst[0] = rgba[i][RCOMP];
+            dst += dstComponents;
+         }
+      }
+
+      free(rgba);
+   }
+}
+
+
+/**
+ * Same as _mesa_unpack_color_span_chan(), but return GLuint data
+ * instead of GLchan.
+ * No pixel transfer ops are applied.
+ */
+void
+_mesa_unpack_color_span_uint(struct gl_context *ctx,
+                             GLuint n, GLenum dstFormat, GLuint *dest,
+                             GLenum srcFormat, GLenum srcType,
+                             const GLvoid *source,
+                             const struct gl_pixelstore_attrib *srcPacking)
+{
+   GLuint (*rgba)[4] = (GLuint (*)[4]) malloc(n * 4 * sizeof(GLfloat));
+
+   if (!rgba) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
+      return;
+   }
+
+   ASSERT(dstFormat == GL_ALPHA ||
+          dstFormat == GL_LUMINANCE ||
+          dstFormat == GL_LUMINANCE_ALPHA ||
+          dstFormat == GL_INTENSITY ||
+          dstFormat == GL_RED ||
+          dstFormat == GL_RG ||
+          dstFormat == GL_RGB ||
+          dstFormat == GL_RGBA);
+
+   ASSERT(srcFormat == GL_RED ||
+          srcFormat == GL_GREEN ||
+          srcFormat == GL_BLUE ||
+          srcFormat == GL_ALPHA ||
+          srcFormat == GL_LUMINANCE ||
+          srcFormat == GL_LUMINANCE_ALPHA ||
+          srcFormat == GL_INTENSITY ||
+          srcFormat == GL_RG ||
+          srcFormat == GL_RGB ||
+          srcFormat == GL_BGR ||
+          srcFormat == GL_RGBA ||
+          srcFormat == GL_BGRA ||
+          srcFormat == GL_ABGR_EXT ||
+          srcFormat == GL_RED_INTEGER_EXT ||
+          srcFormat == GL_GREEN_INTEGER_EXT ||
+          srcFormat == GL_BLUE_INTEGER_EXT ||
+          srcFormat == GL_ALPHA_INTEGER_EXT ||
+          srcFormat == GL_RGB_INTEGER_EXT ||
+          srcFormat == GL_RGBA_INTEGER_EXT ||
+          srcFormat == GL_BGR_INTEGER_EXT ||
+          srcFormat == GL_BGRA_INTEGER_EXT ||
+          srcFormat == GL_LUMINANCE_INTEGER_EXT ||
+          srcFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT);
+
+   ASSERT(srcType == GL_UNSIGNED_BYTE ||
+          srcType == GL_BYTE ||
+          srcType == GL_UNSIGNED_SHORT ||
+          srcType == GL_SHORT ||
+          srcType == GL_UNSIGNED_INT ||
+          srcType == GL_INT ||
+          srcType == GL_HALF_FLOAT_ARB ||
+          srcType == GL_FLOAT ||
+          srcType == GL_UNSIGNED_BYTE_3_3_2 ||
+          srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
+          srcType == GL_UNSIGNED_SHORT_5_6_5 ||
+          srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
+          srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
+          srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
+          srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
+          srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
+          srcType == GL_UNSIGNED_INT_8_8_8_8 ||
+          srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
+          srcType == GL_UNSIGNED_INT_10_10_10_2 ||
+          srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
+
+
+   /* Extract image data as uint[4] pixels */
+   extract_uint_rgba(n, rgba, srcFormat, srcType, source,
+                     srcPacking->SwapBytes);
+
+   if (dstFormat == GL_RGBA) {
+      /* simple case */
+      memcpy(dest, rgba, 4 * sizeof(GLuint) * n);
+   }
+   else {
+      /* general case */
+      GLint rDst, gDst, bDst, aDst, lDst, iDst;
+      GLint dstComponents = _mesa_components_in_format( dstFormat );
+
+      assert(dstComponents > 0);
+
+      get_component_indexes(dstFormat,
+                            &rDst, &gDst, &bDst, &aDst, &lDst, &iDst);
+
+      /* Now pack values in the requested dest format */
+      if (rDst >= 0) {
+         GLuint *dst = dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[rDst] = rgba[i][RCOMP];
+            dst += dstComponents;
+         }
+      }
+
+      if (gDst >= 0) {
+         GLuint *dst = dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[gDst] = rgba[i][GCOMP];
+            dst += dstComponents;
+         }
+      }
+
+      if (bDst >= 0) {
+         GLuint *dst = dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[bDst] = rgba[i][BCOMP];
+            dst += dstComponents;
+         }
+      }
+
+      if (aDst >= 0) {
+         GLuint *dst = dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[aDst] = rgba[i][ACOMP];
+            dst += dstComponents;
+         }
+      }
+
+      if (iDst >= 0) {
+         GLuint *dst = dest;
+         GLuint i;
+         assert(iDst == 0);
+         assert(dstComponents == 1);
+         for (i = 0; i < n; i++) {
+            /* Intensity comes from red channel */
+            dst[i] = rgba[i][RCOMP];
+         }
+      }
+
+      if (lDst >= 0) {
+         GLuint *dst = dest;
+         GLuint i;
+         assert(lDst == 0);
+         for (i = 0; i < n; i++) {
+            /* Luminance comes from red channel */
+            dst[0] = rgba[i][RCOMP];
+            dst += dstComponents;
+         }
+      }
+   }
+
+   free(rgba);
+}
+
+
+
+/**
+ * Similar to _mesa_unpack_color_span_float(), but for dudv data instead of rgba,
+ * directly return GLbyte data, no transfer ops apply.
+ */
+void
+_mesa_unpack_dudv_span_byte( struct gl_context *ctx,
+                             GLuint n, GLenum dstFormat, GLbyte dest[],
+                             GLenum srcFormat, GLenum srcType,
+                             const GLvoid *source,
+                             const struct gl_pixelstore_attrib *srcPacking,
+                             GLbitfield transferOps )
+{
+   ASSERT(dstFormat == GL_DUDV_ATI);
+   ASSERT(srcFormat == GL_DUDV_ATI);
+
+   ASSERT(srcType == GL_UNSIGNED_BYTE ||
+          srcType == GL_BYTE ||
+          srcType == GL_UNSIGNED_SHORT ||
+          srcType == GL_SHORT ||
+          srcType == GL_UNSIGNED_INT ||
+          srcType == GL_INT ||
+          srcType == GL_HALF_FLOAT_ARB ||
+          srcType == GL_FLOAT);
+
+   /* general solution */
+   {
+      GLint dstComponents;
+      GLbyte *dst = dest;
+      GLuint i;
+      GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
+
+      if (!rgba) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
+         return;
+      }
+
+      dstComponents = _mesa_components_in_format( dstFormat );
+      /* source & dest image formats should have been error checked by now */
+      assert(dstComponents > 0);
+
+      /*
+       * Extract image data and convert to RGBA floats
+       */
+      extract_float_rgba(n, rgba, srcFormat, srcType, source,
+                         srcPacking->SwapBytes);
+
+
+      /* Now determine which color channels we need to produce.
+       * And determine the dest index (offset) within each color tuple.
+       */
+
+      /* Now pack results in the requested dstFormat */
+      for (i = 0; i < n; i++) {
+         /* not sure - need clamp[-1,1] here? */
+         dst[0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
+         dst[1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
+         dst += dstComponents;
+      }
+
+      free(rgba);
+   }
+}
+
+/*
+ * Unpack a row of color index data from a client buffer according to
+ * the pixel unpacking parameters.
+ * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
+ *
+ * Args:  ctx - the context
+ *        n - number of pixels
+ *        dstType - destination data type
+ *        dest - destination array
+ *        srcType - source pixel type
+ *        source - source data pointer
+ *        srcPacking - pixel unpacking parameters
+ *        transferOps - the pixel transfer operations to apply
+ */
+void
+_mesa_unpack_index_span( struct gl_context *ctx, GLuint n,
+                         GLenum dstType, GLvoid *dest,
+                         GLenum srcType, const GLvoid *source,
+                         const struct gl_pixelstore_attrib *srcPacking,
+                         GLbitfield transferOps )
+{
+   ASSERT(srcType == GL_BITMAP ||
+          srcType == GL_UNSIGNED_BYTE ||
+          srcType == GL_BYTE ||
+          srcType == GL_UNSIGNED_SHORT ||
+          srcType == GL_SHORT ||
+          srcType == GL_UNSIGNED_INT ||
+          srcType == GL_INT ||
+          srcType == GL_HALF_FLOAT_ARB ||
+          srcType == GL_FLOAT);
+
+   ASSERT(dstType == GL_UNSIGNED_BYTE ||
+          dstType == GL_UNSIGNED_SHORT ||
+          dstType == GL_UNSIGNED_INT);
+
+
+   transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
+
+   /*
+    * Try simple cases first
+    */
+   if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
+       && dstType == GL_UNSIGNED_BYTE) {
+      memcpy(dest, source, n * sizeof(GLubyte));
+   }
+   else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
+            && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
+      memcpy(dest, source, n * sizeof(GLuint));
+   }
+   else {
+      /*
+       * general solution
+       */
+      GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
+
+      if (!indexes) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
+         return;
+      }
+
+      extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
+                           srcPacking);
+
+      if (transferOps)
+         _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
+
+      /* convert to dest type */
+      switch (dstType) {
+         case GL_UNSIGNED_BYTE:
+            {
+               GLubyte *dst = (GLubyte *) dest;
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  dst[i] = (GLubyte) (indexes[i] & 0xff);
+               }
+            }
+            break;
+         case GL_UNSIGNED_SHORT:
+            {
+               GLuint *dst = (GLuint *) dest;
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  dst[i] = (GLushort) (indexes[i] & 0xffff);
+               }
+            }
+            break;
+         case GL_UNSIGNED_INT:
+            memcpy(dest, indexes, n * sizeof(GLuint));
+            break;
+         default:
+            _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
+      }
+
+      free(indexes);
+   }
+}
+
+
+void
+_mesa_pack_index_span( struct gl_context *ctx, GLuint n,
+                       GLenum dstType, GLvoid *dest, const GLuint *source,
+                       const struct gl_pixelstore_attrib *dstPacking,
+                       GLbitfield transferOps )
+{
+   GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
+
+   if (!indexes) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
+      return;
+   }
+
+   transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
+
+   if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
+      /* make a copy of input */
+      memcpy(indexes, source, n * sizeof(GLuint));
+      _mesa_apply_ci_transfer_ops(ctx, transferOps, n, indexes);
+      source = indexes;
+   }
+
+   switch (dstType) {
+   case GL_UNSIGNED_BYTE:
+      {
+         GLubyte *dst = (GLubyte *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            *dst++ = (GLubyte) source[i];
+         }
+      }
+      break;
+   case GL_BYTE:
+      {
+         GLbyte *dst = (GLbyte *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = (GLbyte) source[i];
+         }
+      }
+      break;
+   case GL_UNSIGNED_SHORT:
+      {
+         GLushort *dst = (GLushort *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = (GLushort) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap2( (GLushort *) dst, n );
+         }
+      }
+      break;
+   case GL_SHORT:
+      {
+         GLshort *dst = (GLshort *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = (GLshort) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap2( (GLushort *) dst, n );
+         }
+      }
+      break;
+   case GL_UNSIGNED_INT:
+      {
+         GLuint *dst = (GLuint *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = (GLuint) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap4( (GLuint *) dst, n );
+         }
+      }
+      break;
+   case GL_INT:
+      {
+         GLint *dst = (GLint *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = (GLint) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap4( (GLuint *) dst, n );
+         }
+      }
+      break;
+   case GL_FLOAT:
+      {
+         GLfloat *dst = (GLfloat *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = (GLfloat) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap4( (GLuint *) dst, n );
+         }
+      }
+      break;
+   case GL_HALF_FLOAT_ARB:
+      {
+         GLhalfARB *dst = (GLhalfARB *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = _mesa_float_to_half((GLfloat) source[i]);
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap2( (GLushort *) dst, n );
+         }
+      }
+      break;
+   default:
+      _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
+   }
+
+   free(indexes);
+}
+
+
+/*
+ * Unpack a row of stencil data from a client buffer according to
+ * the pixel unpacking parameters.
+ * This is (or will be) used by glDrawPixels
+ *
+ * Args:  ctx - the context
+ *        n - number of pixels
+ *        dstType - destination data type
+ *        dest - destination array
+ *        srcType - source pixel type
+ *        source - source data pointer
+ *        srcPacking - pixel unpacking parameters
+ *        transferOps - apply offset/bias/lookup ops?
+ */
+void
+_mesa_unpack_stencil_span( struct gl_context *ctx, GLuint n,
+                           GLenum dstType, GLvoid *dest,
+                           GLenum srcType, const GLvoid *source,
+                           const struct gl_pixelstore_attrib *srcPacking,
+                           GLbitfield transferOps )
+{
+   ASSERT(srcType == GL_BITMAP ||
+          srcType == GL_UNSIGNED_BYTE ||
+          srcType == GL_BYTE ||
+          srcType == GL_UNSIGNED_SHORT ||
+          srcType == GL_SHORT ||
+          srcType == GL_UNSIGNED_INT ||
+          srcType == GL_INT ||
+          srcType == GL_UNSIGNED_INT_24_8_EXT ||
+          srcType == GL_HALF_FLOAT_ARB ||
+          srcType == GL_FLOAT);
+
+   ASSERT(dstType == GL_UNSIGNED_BYTE ||
+          dstType == GL_UNSIGNED_SHORT ||
+          dstType == GL_UNSIGNED_INT);
+
+   /* only shift and offset apply to stencil */
+   transferOps &= IMAGE_SHIFT_OFFSET_BIT;
+
+   /*
+    * Try simple cases first
+    */
+   if (transferOps == 0 &&
+       !ctx->Pixel.MapStencilFlag &&
+       srcType == GL_UNSIGNED_BYTE &&
+       dstType == GL_UNSIGNED_BYTE) {
+      memcpy(dest, source, n * sizeof(GLubyte));
+   }
+   else if (transferOps == 0 &&
+            !ctx->Pixel.MapStencilFlag &&
+            srcType == GL_UNSIGNED_INT &&
+            dstType == GL_UNSIGNED_INT &&
+            !srcPacking->SwapBytes) {
+      memcpy(dest, source, n * sizeof(GLuint));
+   }
+   else {
+      /*
+       * general solution
+       */
+      GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
+
+      if (!indexes) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil unpacking");
+         return;
+      }
+
+      extract_uint_indexes(n, indexes, GL_STENCIL_INDEX, srcType, source,
+                           srcPacking);
+
+      if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
+         /* shift and offset indexes */
+         _mesa_shift_and_offset_ci(ctx, n, indexes);
+      }
+
+      if (ctx->Pixel.MapStencilFlag) {
+         /* Apply stencil lookup table */
+         const GLuint mask = ctx->PixelMaps.StoS.Size - 1;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            indexes[i] = (GLuint)ctx->PixelMaps.StoS.Map[ indexes[i] & mask ];
+         }
+      }
+
+      /* convert to dest type */
+      switch (dstType) {
+         case GL_UNSIGNED_BYTE:
+            {
+               GLubyte *dst = (GLubyte *) dest;
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  dst[i] = (GLubyte) (indexes[i] & 0xff);
+               }
+            }
+            break;
+         case GL_UNSIGNED_SHORT:
+            {
+               GLuint *dst = (GLuint *) dest;
+               GLuint i;
+               for (i = 0; i < n; i++) {
+                  dst[i] = (GLushort) (indexes[i] & 0xffff);
+               }
+            }
+            break;
+         case GL_UNSIGNED_INT:
+            memcpy(dest, indexes, n * sizeof(GLuint));
+            break;
+         default:
+            _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
+      }
+
+      free(indexes);
+   }
+}
+
+
+void
+_mesa_pack_stencil_span( struct gl_context *ctx, GLuint n,
+                         GLenum dstType, GLvoid *dest, const GLstencil *source,
+                         const struct gl_pixelstore_attrib *dstPacking )
+{
+   GLstencil *stencil = (GLstencil *) malloc(n * sizeof(GLstencil));
+
+   if (!stencil) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil packing");
+      return;
+   }
+
+   if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
+       ctx->Pixel.MapStencilFlag) {
+      /* make a copy of input */
+      memcpy(stencil, source, n * sizeof(GLstencil));
+      _mesa_apply_stencil_transfer_ops(ctx, n, stencil);
+      source = stencil;
+   }
+
+   switch (dstType) {
+   case GL_UNSIGNED_BYTE:
+      if (sizeof(GLstencil) == 1) {
+         memcpy( dest, source, n );
+      }
+      else {
+         GLubyte *dst = (GLubyte *) dest;
+         GLuint i;
+         for (i=0;i<n;i++) {
+            dst[i] = (GLubyte) source[i];
+         }
+      }
+      break;
+   case GL_BYTE:
+      {
+         GLbyte *dst = (GLbyte *) dest;
+         GLuint i;
+         for (i=0;i<n;i++) {
+            dst[i] = (GLbyte) (source[i] & 0x7f);
+         }
+      }
+      break;
+   case GL_UNSIGNED_SHORT:
+      {
+         GLushort *dst = (GLushort *) dest;
+         GLuint i;
+         for (i=0;i<n;i++) {
+            dst[i] = (GLushort) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap2( (GLushort *) dst, n );
+         }
+      }
+      break;
+   case GL_SHORT:
+      {
+         GLshort *dst = (GLshort *) dest;
+         GLuint i;
+         for (i=0;i<n;i++) {
+            dst[i] = (GLshort) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap2( (GLushort *) dst, n );
+         }
+      }
+      break;
+   case GL_UNSIGNED_INT:
+      {
+         GLuint *dst = (GLuint *) dest;
+         GLuint i;
+         for (i=0;i<n;i++) {
+            dst[i] = (GLuint) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap4( (GLuint *) dst, n );
+         }
+      }
+      break;
+   case GL_INT:
+      {
+         GLint *dst = (GLint *) dest;
+         GLuint i;
+         for (i=0;i<n;i++) {
+            dst[i] = (GLint) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap4( (GLuint *) dst, n );
+         }
+      }
+      break;
+   case GL_FLOAT:
+      {
+         GLfloat *dst = (GLfloat *) dest;
+         GLuint i;
+         for (i=0;i<n;i++) {
+            dst[i] = (GLfloat) source[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap4( (GLuint *) dst, n );
+         }
+      }
+      break;
+   case GL_HALF_FLOAT_ARB:
+      {
+         GLhalfARB *dst = (GLhalfARB *) dest;
+         GLuint i;
+         for (i=0;i<n;i++) {
+            dst[i] = _mesa_float_to_half( (float) source[i] );
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap2( (GLushort *) dst, n );
+         }
+      }
+      break;
+   case GL_BITMAP:
+      if (dstPacking->LsbFirst) {
+         GLubyte *dst = (GLubyte *) dest;
+         GLint shift = 0;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            if (shift == 0)
+               *dst = 0;
+            *dst |= ((source[i] != 0) << shift);
+            shift++;
+            if (shift == 8) {
+               shift = 0;
+               dst++;
+            }
+         }
+      }
+      else {
+         GLubyte *dst = (GLubyte *) dest;
+         GLint shift = 7;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            if (shift == 7)
+               *dst = 0;
+            *dst |= ((source[i] != 0) << shift);
+            shift--;
+            if (shift < 0) {
+               shift = 7;
+               dst++;
+            }
+         }
+      }
+      break;
+   default:
+      _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
+   }
+
+   free(stencil);
+}
+
+#define DEPTH_VALUES(GLTYPE, GLTYPE2FLOAT)                              \
+    do {                                                                \
+        GLuint i;                                                       \
+        const GLTYPE *src = (const GLTYPE *)source;                     \
+        for (i = 0; i < n; i++) {                                       \
+            GLTYPE value = src[i];                                      \
+            if (srcPacking->SwapBytes) {                                \
+                if (sizeof(GLTYPE) == 2) {                              \
+                    SWAP2BYTE(value);                                   \
+                } else if (sizeof(GLTYPE) == 4) {                       \
+                    SWAP4BYTE(value);                                   \
+                }                                                       \
+            }                                                           \
+            depthValues[i] = GLTYPE2FLOAT(value);                       \
+        }                                                               \
+    } while (0)
+
+
+/**
+ * Unpack a row of depth/z values from memory, returning GLushort, GLuint
+ * or GLfloat values.
+ * The glPixelTransfer (scale/bias) params will be applied.
+ *
+ * \param dstType  one of GL_UNSIGNED_SHORT, GL_UNSIGNED_INT, GL_FLOAT
+ * \param depthMax  max value for returned GLushort or GLuint values
+ *                  (ignored for GLfloat).
+ */
+void
+_mesa_unpack_depth_span( struct gl_context *ctx, GLuint n,
+                         GLenum dstType, GLvoid *dest, GLuint depthMax,
+                         GLenum srcType, const GLvoid *source,
+                         const struct gl_pixelstore_attrib *srcPacking )
+{
+   GLfloat *depthTemp, *depthValues;
+   GLboolean needClamp = GL_FALSE;
+
+   /* Look for special cases first.
+    * Not only are these faster, they're less prone to numeric conversion
+    * problems.  Otherwise, converting from an int type to a float then
+    * back to an int type can introduce errors that will show up as
+    * artifacts in things like depth peeling which uses glCopyTexImage.
+    */
+   if (ctx->Pixel.DepthScale == 1.0 && ctx->Pixel.DepthBias == 0.0) {
+      if (srcType == GL_UNSIGNED_INT && dstType == GL_UNSIGNED_SHORT) {
+         const GLuint *src = (const GLuint *) source;
+         GLushort *dst = (GLushort *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = src[i] >> 16;
+         }
+         return;
+      }
+      if (srcType == GL_UNSIGNED_SHORT
+          && dstType == GL_UNSIGNED_INT
+          && depthMax == 0xffffffff) {
+         const GLushort *src = (const GLushort *) source;
+         GLuint *dst = (GLuint *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = src[i] | (src[i] << 16);
+         }
+         return;
+      }
+      if (srcType == GL_UNSIGNED_INT_24_8
+          && dstType == GL_UNSIGNED_INT
+          && depthMax == 0xffffff) {
+         const GLuint *src = (const GLuint *) source;
+         GLuint *dst = (GLuint *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = src[i] >> 8;
+         }
+         return;
+      }
+      /* XXX may want to add additional cases here someday */
+   }
+
+   /* general case path follows */
+
+   depthTemp = (GLfloat *) malloc(n * sizeof(GLfloat));
+   if (!depthTemp) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
+      return;
+   }
+
+   if (dstType == GL_FLOAT) {
+      depthValues = (GLfloat *) dest;
+   }
+   else {
+      depthValues = depthTemp;
+   }
+
+   /* Convert incoming values to GLfloat.  Some conversions will require
+    * clamping, below.
+    */
+   switch (srcType) {
+      case GL_BYTE:
+         DEPTH_VALUES(GLbyte, BYTE_TO_FLOAT);
+         needClamp = GL_TRUE;
+         break;
+      case GL_UNSIGNED_BYTE:
+         DEPTH_VALUES(GLubyte, UBYTE_TO_FLOAT);
+         break;
+      case GL_SHORT:
+         DEPTH_VALUES(GLshort, SHORT_TO_FLOAT);
+         needClamp = GL_TRUE;
+         break;
+      case GL_UNSIGNED_SHORT:
+         DEPTH_VALUES(GLushort, USHORT_TO_FLOAT);
+         break;
+      case GL_INT:
+         DEPTH_VALUES(GLint, INT_TO_FLOAT);
+         needClamp = GL_TRUE;
+         break;
+      case GL_UNSIGNED_INT:
+         DEPTH_VALUES(GLuint, UINT_TO_FLOAT);
+         break;
+      case GL_UNSIGNED_INT_24_8_EXT: /* GL_EXT_packed_depth_stencil */
+         if (dstType == GL_UNSIGNED_INT_24_8_EXT &&
+             depthMax == 0xffffff &&
+             ctx->Pixel.DepthScale == 1.0 &&
+             ctx->Pixel.DepthBias == 0.0) {
+            const GLuint *src = (const GLuint *) source;
+            GLuint *zValues = (GLuint *) dest;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+                GLuint value = src[i];
+                if (srcPacking->SwapBytes) {
+                    SWAP4BYTE(value);
+                }
+                zValues[i] = value & 0xffffff00;
+            }
+            return;
+         }
+         else {
+            const GLuint *src = (const GLuint *) source;
+            const GLfloat scale = 1.0f / 0xffffff;
+            GLuint i;
+            for (i = 0; i < n; i++) {
+                GLuint value = src[i];
+                if (srcPacking->SwapBytes) {
+                    SWAP4BYTE(value);
+                }
+                depthValues[i] = (value >> 8) * scale;
+            }
+         }
+         break;
+      case GL_FLOAT:
+         DEPTH_VALUES(GLfloat, 1*);
+         needClamp = GL_TRUE;
+         break;
+      case GL_HALF_FLOAT_ARB:
+         {
+            GLuint i;
+            const GLhalfARB *src = (const GLhalfARB *) source;
+            for (i = 0; i < n; i++) {
+               GLhalfARB value = src[i];
+               if (srcPacking->SwapBytes) {
+                  SWAP2BYTE(value);
+               }
+               depthValues[i] = _mesa_half_to_float(value);
+            }
+            needClamp = GL_TRUE;
+         }
+         break;
+      default:
+         _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
+         free(depthTemp);
+         return;
+   }
+
+   /* apply depth scale and bias */
+   {
+      const GLfloat scale = ctx->Pixel.DepthScale;
+      const GLfloat bias = ctx->Pixel.DepthBias;
+      if (scale != 1.0 || bias != 0.0) {
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            depthValues[i] = depthValues[i] * scale + bias;
+         }
+         needClamp = GL_TRUE;
+      }
+   }
+
+   /* clamp to [0, 1] */
+   if (needClamp) {
+      GLuint i;
+      for (i = 0; i < n; i++) {
+         depthValues[i] = (GLfloat)CLAMP(depthValues[i], 0.0, 1.0);
+      }
+   }
+
+   /*
+    * Convert values to dstType
+    */
+   if (dstType == GL_UNSIGNED_INT) {
+      GLuint *zValues = (GLuint *) dest;
+      GLuint i;
+      if (depthMax <= 0xffffff) {
+         /* no overflow worries */
+         for (i = 0; i < n; i++) {
+            zValues[i] = (GLuint) (depthValues[i] * (GLfloat) depthMax);
+         }
+      }
+      else {
+         /* need to use double precision to prevent overflow problems */
+         for (i = 0; i < n; i++) {
+            GLdouble z = depthValues[i] * (GLfloat) depthMax;
+            if (z >= (GLdouble) 0xffffffff)
+               zValues[i] = 0xffffffff;
+            else
+               zValues[i] = (GLuint) z;
+         }
+      }
+   }
+   else if (dstType == GL_UNSIGNED_SHORT) {
+      GLushort *zValues = (GLushort *) dest;
+      GLuint i;
+      ASSERT(depthMax <= 0xffff);
+      for (i = 0; i < n; i++) {
+         zValues[i] = (GLushort) (depthValues[i] * (GLfloat) depthMax);
+      }
+   }
+   else {
+      ASSERT(dstType == GL_FLOAT);
+      /*ASSERT(depthMax == 1.0F);*/
+   }
+
+   free(depthTemp);
+}
+
+
+/*
+ * Pack an array of depth values.  The values are floats in [0,1].
+ */
+void
+_mesa_pack_depth_span( struct gl_context *ctx, GLuint n, GLvoid *dest,
+                       GLenum dstType, const GLfloat *depthSpan,
+                       const struct gl_pixelstore_attrib *dstPacking )
+{
+   GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
+   if (!depthCopy) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
+      return;
+   }
+
+   if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
+      memcpy(depthCopy, depthSpan, n * sizeof(GLfloat));
+      _mesa_scale_and_bias_depth(ctx, n, depthCopy);
+      depthSpan = depthCopy;
+   }
+
+   switch (dstType) {
+   case GL_UNSIGNED_BYTE:
+      {
+         GLubyte *dst = (GLubyte *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
+         }
+      }
+      break;
+   case GL_BYTE:
+      {
+         GLbyte *dst = (GLbyte *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
+         }
+      }
+      break;
+   case GL_UNSIGNED_SHORT:
+      {
+         GLushort *dst = (GLushort *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            CLAMPED_FLOAT_TO_USHORT(dst[i], depthSpan[i]);
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap2( (GLushort *) dst, n );
+         }
+      }
+      break;
+   case GL_SHORT:
+      {
+         GLshort *dst = (GLshort *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap2( (GLushort *) dst, n );
+         }
+      }
+      break;
+   case GL_UNSIGNED_INT:
+      {
+         GLuint *dst = (GLuint *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = FLOAT_TO_UINT( depthSpan[i] );
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap4( (GLuint *) dst, n );
+         }
+      }
+      break;
+   case GL_INT:
+      {
+         GLint *dst = (GLint *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = FLOAT_TO_INT( depthSpan[i] );
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap4( (GLuint *) dst, n );
+         }
+      }
+      break;
+   case GL_FLOAT:
+      {
+         GLfloat *dst = (GLfloat *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = depthSpan[i];
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap4( (GLuint *) dst, n );
+         }
+      }
+      break;
+   case GL_HALF_FLOAT_ARB:
+      {
+         GLhalfARB *dst = (GLhalfARB *) dest;
+         GLuint i;
+         for (i = 0; i < n; i++) {
+            dst[i] = _mesa_float_to_half(depthSpan[i]);
+         }
+         if (dstPacking->SwapBytes) {
+            _mesa_swap2( (GLushort *) dst, n );
+         }
+      }
+      break;
+   default:
+      _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
+   }
+
+   free(depthCopy);
+}
+
+
+
+/**
+ * Pack depth and stencil values as GL_DEPTH_STENCIL/GL_UNSIGNED_INT_24_8.
+ */
+void
+_mesa_pack_depth_stencil_span(struct gl_context *ctx, GLuint n, GLuint *dest,
+                              const GLfloat *depthVals,
+                              const GLstencil *stencilVals,
+                              const struct gl_pixelstore_attrib *dstPacking)
+{
+   GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
+   GLstencil *stencilCopy = (GLstencil *) malloc(n * sizeof(GLstencil));
+   GLuint i;
+
+   if (!depthCopy || !stencilCopy) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
+      free(depthCopy);
+      free(stencilCopy);
+      return;
+   }
+
+   if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
+      memcpy(depthCopy, depthVals, n * sizeof(GLfloat));
+      _mesa_scale_and_bias_depth(ctx, n, depthCopy);
+      depthVals = depthCopy;
+   }
+
+   if (ctx->Pixel.IndexShift ||
+       ctx->Pixel.IndexOffset ||
+       ctx->Pixel.MapStencilFlag) {
+      memcpy(stencilCopy, stencilVals, n * sizeof(GLstencil));
+      _mesa_apply_stencil_transfer_ops(ctx, n, stencilCopy);
+      stencilVals = stencilCopy;
+   }
+
+   for (i = 0; i < n; i++) {
+      GLuint z = (GLuint) (depthVals[i] * 0xffffff);
+      dest[i] = (z << 8) | (stencilVals[i] & 0xff);
+   }
+
+   if (dstPacking->SwapBytes) {
+      _mesa_swap4(dest, n);
+   }
+
+   free(depthCopy);
+   free(stencilCopy);
+}
+
+
+
+
+/**
+ * Unpack image data.  Apply byte swapping, byte flipping (bitmap).
+ * Return all image data in a contiguous block.  This is used when we
+ * compile glDrawPixels, glTexImage, etc into a display list.  We
+ * need a copy of the data in a standard format.
+ */
+void *
+_mesa_unpack_image( GLuint dimensions,
+                    GLsizei width, GLsizei height, GLsizei depth,
+                    GLenum format, GLenum type, const GLvoid *pixels,
+                    const struct gl_pixelstore_attrib *unpack )
+{
+   GLint bytesPerRow, compsPerRow;
+   GLboolean flipBytes, swap2, swap4;
+
+   if (!pixels)
+      return NULL;  /* not necessarily an error */
+
+   if (width <= 0 || height <= 0 || depth <= 0)
+      return NULL;  /* generate error later */
+
+   if (type == GL_BITMAP) {
+      bytesPerRow = (width + 7) >> 3;
+      flipBytes = unpack->LsbFirst;
+      swap2 = swap4 = GL_FALSE;
+      compsPerRow = 0;
+   }
+   else {
+      const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
+      GLint components = _mesa_components_in_format(format);
+      GLint bytesPerComp;
+
+      if (_mesa_type_is_packed(type))
+          components = 1;
+
+      if (bytesPerPixel <= 0 || components <= 0)
+         return NULL;   /* bad format or type.  generate error later */
+      bytesPerRow = bytesPerPixel * width;
+      bytesPerComp = bytesPerPixel / components;
+      flipBytes = GL_FALSE;
+      swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
+      swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
+      compsPerRow = components * width;
+      assert(compsPerRow >= width);
+   }
+
+   {
+      GLubyte *destBuffer
+         = (GLubyte *) malloc(bytesPerRow * height * depth);
+      GLubyte *dst;
+      GLint img, row;
+      if (!destBuffer)
+         return NULL;   /* generate GL_OUT_OF_MEMORY later */
+
+      dst = destBuffer;
+      for (img = 0; img < depth; img++) {
+         for (row = 0; row < height; row++) {
+            const GLvoid *src = _mesa_image_address(dimensions, unpack, pixels,
+                               width, height, format, type, img, row, 0);
+
+            if ((type == GL_BITMAP) && (unpack->SkipPixels & 0x7)) {
+               GLint i;
+               flipBytes = GL_FALSE;
+               if (unpack->LsbFirst) {
+                  GLubyte srcMask = 1 << (unpack->SkipPixels & 0x7);
+                  GLubyte dstMask = 128;
+                  const GLubyte *s = src;
+                  GLubyte *d = dst;
+                  *d = 0;
+                  for (i = 0; i < width; i++) {
+                     if (*s & srcMask) {
+                        *d |= dstMask;
+                     }      
+                     if (srcMask == 128) {
+                        srcMask = 1;
+                        s++;
+                     }
+                     else {
+                        srcMask = srcMask << 1;
+                     }
+                     if (dstMask == 1) {
+                        dstMask = 128;
+                        d++;
+                        *d = 0;
+                     }
+                     else {
+                        dstMask = dstMask >> 1;
+                     }
+                  }
+               }
+               else {
+                  GLubyte srcMask = 128 >> (unpack->SkipPixels & 0x7);
+                  GLubyte dstMask = 128;
+                  const GLubyte *s = src;
+                  GLubyte *d = dst;
+                  *d = 0;
+                  for (i = 0; i < width; i++) {
+                     if (*s & srcMask) {
+                        *d |= dstMask;
+                     }
+                     if (srcMask == 1) {
+                        srcMask = 128;
+                        s++;
+                     }
+                     else {
+                        srcMask = srcMask >> 1;
+                     }
+                     if (dstMask == 1) {
+                        dstMask = 128;
+                        d++;
+                        *d = 0;
+                     }
+                     else {
+                        dstMask = dstMask >> 1;
+                     }      
+                  }
+               }
+            }
+            else {
+               memcpy(dst, src, bytesPerRow);
+            }
+
+            /* byte flipping/swapping */
+            if (flipBytes) {
+               flip_bytes((GLubyte *) dst, bytesPerRow);
+            }
+            else if (swap2) {
+               _mesa_swap2((GLushort*) dst, compsPerRow);
+            }
+            else if (swap4) {
+               _mesa_swap4((GLuint*) dst, compsPerRow);
+            }
+            dst += bytesPerRow;
+         }
+      }
+      return destBuffer;
+   }
+}
+
diff --git a/mesalib/src/mesa/main/remap_helper.h b/mesalib/src/mesa/main/remap_helper.h
index a2cbc2bc0..637905ab4 100644
--- a/mesalib/src/mesa/main/remap_helper.h
+++ b/mesalib/src/mesa/main/remap_helper.h
@@ -1,6587 +1,6599 @@
-/* DO NOT EDIT - This file generated automatically by remap_helper.py (from Mesa) script */

-

-/*

- * Copyright (C) 2009 Chia-I Wu <olv@0xlab.org>

- * 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

- * Chia-I Wu,

- * 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 "main/dispatch.h"

-#include "main/remap.h"

-

-/* this is internal to remap.c */

-#ifdef need_MESA_remap_table

-

-static const char _mesa_function_pool[] =

-   /* _mesa_function_pool[0]: MapGrid1d (offset 224) */

-   "idd\0"

-   "glMapGrid1d\0"

-   "\0"

-   /* _mesa_function_pool[17]: UniformMatrix3fvARB (will be remapped) */

-   "iiip\0"

-   "glUniformMatrix3fv\0"

-   "glUniformMatrix3fvARB\0"

-   "\0"

-   /* _mesa_function_pool[64]: MapGrid1f (offset 225) */

-   "iff\0"

-   "glMapGrid1f\0"

-   "\0"

-   /* _mesa_function_pool[81]: VertexAttribI2iEXT (will be remapped) */

-   "iii\0"

-   "glVertexAttribI2iEXT\0"

-   "glVertexAttribI2i\0"

-   "\0"

-   /* _mesa_function_pool[125]: RasterPos4i (offset 82) */

-   "iiii\0"

-   "glRasterPos4i\0"

-   "\0"

-   /* _mesa_function_pool[145]: RasterPos4d (offset 78) */

-   "dddd\0"

-   "glRasterPos4d\0"

-   "\0"

-   /* _mesa_function_pool[165]: NewList (dynamic) */

-   "ii\0"

-   "glNewList\0"

-   "\0"

-   /* _mesa_function_pool[179]: RasterPos4f (offset 80) */

-   "ffff\0"

-   "glRasterPos4f\0"

-   "\0"

-   /* _mesa_function_pool[199]: LoadIdentity (offset 290) */

-   "\0"

-   "glLoadIdentity\0"

-   "\0"

-   /* _mesa_function_pool[216]: GetCombinerOutputParameterfvNV (will be remapped) */

-   "iiip\0"

-   "glGetCombinerOutputParameterfvNV\0"

-   "\0"

-   /* _mesa_function_pool[255]: SampleCoverageARB (will be remapped) */

-   "fi\0"

-   "glSampleCoverage\0"

-   "glSampleCoverageARB\0"

-   "\0"

-   /* _mesa_function_pool[296]: ConvolutionFilter1D (offset 348) */

-   "iiiiip\0"

-   "glConvolutionFilter1D\0"

-   "glConvolutionFilter1DEXT\0"

-   "\0"

-   /* _mesa_function_pool[351]: BeginQueryARB (will be remapped) */

-   "ii\0"

-   "glBeginQuery\0"

-   "glBeginQueryARB\0"

-   "\0"

-   /* _mesa_function_pool[384]: RasterPos3dv (offset 71) */

-   "p\0"

-   "glRasterPos3dv\0"

-   "\0"

-   /* _mesa_function_pool[402]: PointParameteriNV (will be remapped) */

-   "ii\0"

-   "glPointParameteri\0"

-   "glPointParameteriNV\0"

-   "\0"

-   /* _mesa_function_pool[444]: GetProgramiv (will be remapped) */

-   "iip\0"

-   "glGetProgramiv\0"

-   "\0"

-   /* _mesa_function_pool[464]: MultiTexCoord3sARB (offset 398) */

-   "iiii\0"

-   "glMultiTexCoord3s\0"

-   "glMultiTexCoord3sARB\0"

-   "\0"

-   /* _mesa_function_pool[509]: SecondaryColor3iEXT (will be remapped) */

-   "iii\0"

-   "glSecondaryColor3i\0"

-   "glSecondaryColor3iEXT\0"

-   "\0"

-   /* _mesa_function_pool[555]: WindowPos3fMESA (will be remapped) */

-   "fff\0"

-   "glWindowPos3f\0"

-   "glWindowPos3fARB\0"

-   "glWindowPos3fMESA\0"

-   "\0"

-   /* _mesa_function_pool[609]: TexCoord1iv (offset 99) */

-   "p\0"

-   "glTexCoord1iv\0"

-   "\0"

-   /* _mesa_function_pool[626]: TexCoord4sv (offset 125) */

-   "p\0"

-   "glTexCoord4sv\0"

-   "\0"

-   /* _mesa_function_pool[643]: RasterPos4s (offset 84) */

-   "iiii\0"

-   "glRasterPos4s\0"

-   "\0"

-   /* _mesa_function_pool[663]: PixelTexGenParameterfvSGIS (will be remapped) */

-   "ip\0"

-   "glPixelTexGenParameterfvSGIS\0"

-   "\0"

-   /* _mesa_function_pool[696]: ActiveTextureARB (offset 374) */

-   "i\0"

-   "glActiveTexture\0"

-   "glActiveTextureARB\0"

-   "\0"

-   /* _mesa_function_pool[734]: BlitFramebufferEXT (will be remapped) */

-   "iiiiiiiiii\0"

-   "glBlitFramebuffer\0"

-   "glBlitFramebufferEXT\0"

-   "\0"

-   /* _mesa_function_pool[785]: TexCoord1f (offset 96) */

-   "f\0"

-   "glTexCoord1f\0"

-   "\0"

-   /* _mesa_function_pool[801]: TexCoord1d (offset 94) */

-   "d\0"

-   "glTexCoord1d\0"

-   "\0"

-   /* _mesa_function_pool[817]: VertexAttrib4ubvNV (will be remapped) */

-   "ip\0"

-   "glVertexAttrib4ubvNV\0"

-   "\0"

-   /* _mesa_function_pool[842]: TexCoord1i (offset 98) */

-   "i\0"

-   "glTexCoord1i\0"

-   "\0"

-   /* _mesa_function_pool[858]: GetProgramNamedParameterdvNV (will be remapped) */

-   "iipp\0"

-   "glGetProgramNamedParameterdvNV\0"

-   "\0"

-   /* _mesa_function_pool[895]: Histogram (offset 367) */

-   "iiii\0"

-   "glHistogram\0"

-   "glHistogramEXT\0"

-   "\0"

-   /* _mesa_function_pool[928]: TexCoord1s (offset 100) */

-   "i\0"

-   "glTexCoord1s\0"

-   "\0"

-   /* _mesa_function_pool[944]: GetMapfv (offset 267) */

-   "iip\0"

-   "glGetMapfv\0"

-   "\0"

-   /* _mesa_function_pool[960]: EvalCoord1f (offset 230) */

-   "f\0"

-   "glEvalCoord1f\0"

-   "\0"

-   /* _mesa_function_pool[977]: FramebufferTexture (will be remapped) */

-   "iiii\0"

-   "glFramebufferTexture\0"

-   "\0"

-   /* _mesa_function_pool[1004]: VertexAttribI1ivEXT (will be remapped) */

-   "ip\0"

-   "glVertexAttribI1ivEXT\0"

-   "glVertexAttribI1iv\0"

-   "\0"

-   /* _mesa_function_pool[1049]: TexImage4DSGIS (dynamic) */

-   "iiiiiiiiiip\0"

-   "glTexImage4DSGIS\0"

-   "\0"

-   /* _mesa_function_pool[1079]: PolygonStipple (offset 175) */

-   "p\0"

-   "glPolygonStipple\0"

-   "\0"

-   /* _mesa_function_pool[1099]: WindowPos2dvMESA (will be remapped) */

-   "p\0"

-   "glWindowPos2dv\0"

-   "glWindowPos2dvARB\0"

-   "glWindowPos2dvMESA\0"

-   "\0"

-   /* _mesa_function_pool[1154]: ReplacementCodeuiColor3fVertex3fvSUN (dynamic) */

-   "ppp\0"

-   "glReplacementCodeuiColor3fVertex3fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[1198]: BlendEquationSeparateEXT (will be remapped) */

-   "ii\0"

-   "glBlendEquationSeparate\0"

-   "glBlendEquationSeparateEXT\0"

-   "glBlendEquationSeparateATI\0"

-   "\0"

-   /* _mesa_function_pool[1280]: ListParameterfSGIX (dynamic) */

-   "iif\0"

-   "glListParameterfSGIX\0"

-   "\0"

-   /* _mesa_function_pool[1306]: SecondaryColor3bEXT (will be remapped) */

-   "iii\0"

-   "glSecondaryColor3b\0"

-   "glSecondaryColor3bEXT\0"

-   "\0"

-   /* _mesa_function_pool[1352]: TexCoord4fColor4fNormal3fVertex4fvSUN (dynamic) */

-   "pppp\0"

-   "glTexCoord4fColor4fNormal3fVertex4fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[1398]: GetPixelMapfv (offset 271) */

-   "ip\0"

-   "glGetPixelMapfv\0"

-   "\0"

-   /* _mesa_function_pool[1418]: Color3uiv (offset 22) */

-   "p\0"

-   "glColor3uiv\0"

-   "\0"

-   /* _mesa_function_pool[1433]: IsEnabled (offset 286) */

-   "i\0"

-   "glIsEnabled\0"

-   "\0"

-   /* _mesa_function_pool[1448]: VertexAttrib4svNV (will be remapped) */

-   "ip\0"

-   "glVertexAttrib4svNV\0"

-   "\0"

-   /* _mesa_function_pool[1472]: EvalCoord2fv (offset 235) */

-   "p\0"

-   "glEvalCoord2fv\0"

-   "\0"

-   /* _mesa_function_pool[1490]: GetBufferSubDataARB (will be remapped) */

-   "iiip\0"

-   "glGetBufferSubData\0"

-   "glGetBufferSubDataARB\0"

-   "\0"

-   /* _mesa_function_pool[1537]: BufferSubDataARB (will be remapped) */

-   "iiip\0"

-   "glBufferSubData\0"

-   "glBufferSubDataARB\0"

-   "\0"

-   /* _mesa_function_pool[1578]: TexCoord2fColor4ubVertex3fvSUN (dynamic) */

-   "ppp\0"

-   "glTexCoord2fColor4ubVertex3fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[1616]: AttachShader (will be remapped) */

-   "ii\0"

-   "glAttachShader\0"

-   "\0"

-   /* _mesa_function_pool[1635]: VertexAttrib2fARB (will be remapped) */

-   "iff\0"

-   "glVertexAttrib2f\0"

-   "glVertexAttrib2fARB\0"

-   "\0"

-   /* _mesa_function_pool[1677]: GetDebugLogLengthMESA (dynamic) */

-   "iii\0"

-   "glGetDebugLogLengthMESA\0"

-   "\0"

-   /* _mesa_function_pool[1706]: GetMapiv (offset 268) */

-   "iip\0"

-   "glGetMapiv\0"

-   "\0"

-   /* _mesa_function_pool[1722]: VertexAttrib3fARB (will be remapped) */

-   "ifff\0"

-   "glVertexAttrib3f\0"

-   "glVertexAttrib3fARB\0"

-   "\0"

-   /* _mesa_function_pool[1765]: Indexubv (offset 316) */

-   "p\0"

-   "glIndexubv\0"

-   "\0"

-   /* _mesa_function_pool[1779]: GetQueryivARB (will be remapped) */

-   "iip\0"

-   "glGetQueryiv\0"

-   "glGetQueryivARB\0"

-   "\0"

-   /* _mesa_function_pool[1813]: TexImage3D (offset 371) */

-   "iiiiiiiiip\0"

-   "glTexImage3D\0"

-   "glTexImage3DEXT\0"

-   "\0"

-   /* _mesa_function_pool[1854]: BindFragDataLocationEXT (will be remapped) */

-   "iip\0"

-   "glBindFragDataLocationEXT\0"

-   "glBindFragDataLocation\0"

-   "\0"

-   /* _mesa_function_pool[1908]: ReplacementCodeuiVertex3fvSUN (dynamic) */

-   "pp\0"

-   "glReplacementCodeuiVertex3fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[1944]: EdgeFlagPointer (offset 312) */

-   "ip\0"

-   "glEdgeFlagPointer\0"

-   "\0"

-   /* _mesa_function_pool[1966]: Color3ubv (offset 20) */

-   "p\0"

-   "glColor3ubv\0"

-   "\0"

-   /* _mesa_function_pool[1981]: GetQueryObjectivARB (will be remapped) */

-   "iip\0"

-   "glGetQueryObjectiv\0"

-   "glGetQueryObjectivARB\0"

-   "\0"

-   /* _mesa_function_pool[2027]: Vertex3dv (offset 135) */

-   "p\0"

-   "glVertex3dv\0"

-   "\0"

-   /* _mesa_function_pool[2042]: ReplacementCodeuiTexCoord2fVertex3fvSUN (dynamic) */

-   "ppp\0"

-   "glReplacementCodeuiTexCoord2fVertex3fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[2089]: CompressedTexSubImage2DARB (will be remapped) */

-   "iiiiiiiip\0"

-   "glCompressedTexSubImage2D\0"

-   "glCompressedTexSubImage2DARB\0"

-   "\0"

-   /* _mesa_function_pool[2155]: CombinerOutputNV (will be remapped) */

-   "iiiiiiiiii\0"

-   "glCombinerOutputNV\0"

-   "\0"

-   /* _mesa_function_pool[2186]: VertexAttribs3fvNV (will be remapped) */

-   "iip\0"

-   "glVertexAttribs3fvNV\0"

-   "\0"

-   /* _mesa_function_pool[2212]: Uniform2fARB (will be remapped) */

-   "iff\0"

-   "glUniform2f\0"

-   "glUniform2fARB\0"

-   "\0"

-   /* _mesa_function_pool[2244]: LightModeliv (offset 166) */

-   "ip\0"

-   "glLightModeliv\0"

-   "\0"

-   /* _mesa_function_pool[2263]: VertexAttrib1svARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib1sv\0"

-   "glVertexAttrib1svARB\0"

-   "\0"

-   /* _mesa_function_pool[2306]: VertexAttribs1dvNV (will be remapped) */

-   "iip\0"

-   "glVertexAttribs1dvNV\0"

-   "\0"

-   /* _mesa_function_pool[2332]: Uniform2ivARB (will be remapped) */

-   "iip\0"

-   "glUniform2iv\0"

-   "glUniform2ivARB\0"

-   "\0"

-   /* _mesa_function_pool[2366]: GetImageTransformParameterfvHP (dynamic) */

-   "iip\0"

-   "glGetImageTransformParameterfvHP\0"

-   "\0"

-   /* _mesa_function_pool[2404]: Normal3bv (offset 53) */

-   "p\0"

-   "glNormal3bv\0"

-   "\0"

-   /* _mesa_function_pool[2419]: TexGeniv (offset 193) */

-   "iip\0"

-   "glTexGeniv\0"

-   "\0"

-   /* _mesa_function_pool[2435]: WeightubvARB (dynamic) */

-   "ip\0"

-   "glWeightubvARB\0"

-   "\0"

-   /* _mesa_function_pool[2454]: VertexAttrib1fvNV (will be remapped) */

-   "ip\0"

-   "glVertexAttrib1fvNV\0"

-   "\0"

-   /* _mesa_function_pool[2478]: Vertex3iv (offset 139) */

-   "p\0"

-   "glVertex3iv\0"

-   "\0"

-   /* _mesa_function_pool[2493]: CopyConvolutionFilter1D (offset 354) */

-   "iiiii\0"

-   "glCopyConvolutionFilter1D\0"

-   "glCopyConvolutionFilter1DEXT\0"

-   "\0"

-   /* _mesa_function_pool[2555]: VertexAttribI1uiEXT (will be remapped) */

-   "ii\0"

-   "glVertexAttribI1uiEXT\0"

-   "glVertexAttribI1ui\0"

-   "\0"

-   /* _mesa_function_pool[2600]: ReplacementCodeuiNormal3fVertex3fSUN (dynamic) */

-   "iffffff\0"

-   "glReplacementCodeuiNormal3fVertex3fSUN\0"

-   "\0"

-   /* _mesa_function_pool[2648]: DeleteSync (will be remapped) */

-   "i\0"

-   "glDeleteSync\0"

-   "\0"

-   /* _mesa_function_pool[2664]: FragmentMaterialfvSGIX (dynamic) */

-   "iip\0"

-   "glFragmentMaterialfvSGIX\0"

-   "\0"

-   /* _mesa_function_pool[2694]: BlendColor (offset 336) */

-   "ffff\0"

-   "glBlendColor\0"

-   "glBlendColorEXT\0"

-   "\0"

-   /* _mesa_function_pool[2729]: UniformMatrix4fvARB (will be remapped) */

-   "iiip\0"

-   "glUniformMatrix4fv\0"

-   "glUniformMatrix4fvARB\0"

-   "\0"

-   /* _mesa_function_pool[2776]: DeleteVertexArraysAPPLE (will be remapped) */

-   "ip\0"

-   "glDeleteVertexArrays\0"

-   "glDeleteVertexArraysAPPLE\0"

-   "\0"

-   /* _mesa_function_pool[2827]: TexBuffer (will be remapped) */

-   "iii\0"

-   "glTexBuffer\0"

-   "\0"

-   /* _mesa_function_pool[2844]: ReadInstrumentsSGIX (dynamic) */

-   "i\0"

-   "glReadInstrumentsSGIX\0"

-   "\0"

-   /* _mesa_function_pool[2869]: CallLists (offset 3) */

-   "iip\0"

-   "glCallLists\0"

-   "\0"

-   /* _mesa_function_pool[2886]: UniformMatrix2x4fv (will be remapped) */

-   "iiip\0"

-   "glUniformMatrix2x4fv\0"

-   "\0"

-   /* _mesa_function_pool[2913]: Color4ubVertex3fvSUN (dynamic) */

-   "pp\0"

-   "glColor4ubVertex3fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[2940]: Normal3iv (offset 59) */

-   "p\0"

-   "glNormal3iv\0"

-   "\0"

-   /* _mesa_function_pool[2955]: PassThrough (offset 199) */

-   "f\0"

-   "glPassThrough\0"

-   "\0"

-   /* _mesa_function_pool[2972]: GetVertexAttribIivEXT (will be remapped) */

-   "iip\0"

-   "glGetVertexAttribIivEXT\0"

-   "glGetVertexAttribIiv\0"

-   "\0"

-   /* _mesa_function_pool[3022]: TexParameterIivEXT (will be remapped) */

-   "iip\0"

-   "glTexParameterIivEXT\0"

-   "glTexParameterIiv\0"

-   "\0"

-   /* _mesa_function_pool[3066]: FramebufferTextureLayerEXT (will be remapped) */

-   "iiiii\0"

-   "glFramebufferTextureLayer\0"

-   "glFramebufferTextureLayerEXT\0"

-   "\0"

-   /* _mesa_function_pool[3128]: GetListParameterfvSGIX (dynamic) */

-   "iip\0"

-   "glGetListParameterfvSGIX\0"

-   "\0"

-   /* _mesa_function_pool[3158]: Viewport (offset 305) */

-   "iiii\0"

-   "glViewport\0"

-   "\0"

-   /* _mesa_function_pool[3175]: VertexAttrib4NusvARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib4Nusv\0"

-   "glVertexAttrib4NusvARB\0"

-   "\0"

-   /* _mesa_function_pool[3222]: WindowPos4svMESA (will be remapped) */

-   "p\0"

-   "glWindowPos4svMESA\0"

-   "\0"

-   /* _mesa_function_pool[3244]: CreateProgramObjectARB (will be remapped) */

-   "\0"

-   "glCreateProgramObjectARB\0"

-   "\0"

-   /* _mesa_function_pool[3271]: DeleteTransformFeedbacks (will be remapped) */

-   "ip\0"

-   "glDeleteTransformFeedbacks\0"

-   "\0"

-   /* _mesa_function_pool[3302]: UniformMatrix4x3fv (will be remapped) */

-   "iiip\0"

-   "glUniformMatrix4x3fv\0"

-   "\0"

-   /* _mesa_function_pool[3329]: PrioritizeTextures (offset 331) */

-   "ipp\0"

-   "glPrioritizeTextures\0"

-   "glPrioritizeTexturesEXT\0"

-   "\0"

-   /* _mesa_function_pool[3379]: VertexAttribI3uiEXT (will be remapped) */

-   "iiii\0"

-   "glVertexAttribI3uiEXT\0"

-   "glVertexAttribI3ui\0"

-   "\0"

-   /* _mesa_function_pool[3426]: AsyncMarkerSGIX (dynamic) */

-   "i\0"

-   "glAsyncMarkerSGIX\0"

-   "\0"

-   /* _mesa_function_pool[3447]: GlobalAlphaFactorubSUN (dynamic) */

-   "i\0"

-   "glGlobalAlphaFactorubSUN\0"

-   "\0"

-   /* _mesa_function_pool[3475]: ClearColorIuiEXT (will be remapped) */

-   "iiii\0"

-   "glClearColorIuiEXT\0"

-   "\0"

-   /* _mesa_function_pool[3500]: ClearDebugLogMESA (dynamic) */

-   "iii\0"

-   "glClearDebugLogMESA\0"

-   "\0"

-   /* _mesa_function_pool[3525]: Uniform4uiEXT (will be remapped) */

-   "iiiii\0"

-   "glUniform4uiEXT\0"

-   "glUniform4ui\0"

-   "\0"

-   /* _mesa_function_pool[3561]: ResetHistogram (offset 369) */

-   "i\0"

-   "glResetHistogram\0"

-   "glResetHistogramEXT\0"

-   "\0"

-   /* _mesa_function_pool[3601]: GetProgramNamedParameterfvNV (will be remapped) */

-   "iipp\0"

-   "glGetProgramNamedParameterfvNV\0"

-   "\0"

-   /* _mesa_function_pool[3638]: PointParameterfEXT (will be remapped) */

-   "if\0"

-   "glPointParameterf\0"

-   "glPointParameterfARB\0"

-   "glPointParameterfEXT\0"

-   "glPointParameterfSGIS\0"

-   "\0"

-   /* _mesa_function_pool[3724]: LoadIdentityDeformationMapSGIX (dynamic) */

-   "i\0"

-   "glLoadIdentityDeformationMapSGIX\0"

-   "\0"

-   /* _mesa_function_pool[3760]: GenFencesNV (will be remapped) */

-   "ip\0"

-   "glGenFencesNV\0"

-   "\0"

-   /* _mesa_function_pool[3778]: ImageTransformParameterfHP (dynamic) */

-   "iif\0"

-   "glImageTransformParameterfHP\0"

-   "\0"

-   /* _mesa_function_pool[3812]: MatrixIndexusvARB (dynamic) */

-   "ip\0"

-   "glMatrixIndexusvARB\0"

-   "\0"

-   /* _mesa_function_pool[3836]: DrawElementsBaseVertex (will be remapped) */

-   "iiipi\0"

-   "glDrawElementsBaseVertex\0"

-   "\0"

-   /* _mesa_function_pool[3868]: DisableVertexAttribArrayARB (will be remapped) */

-   "i\0"

-   "glDisableVertexAttribArray\0"

-   "glDisableVertexAttribArrayARB\0"

-   "\0"

-   /* _mesa_function_pool[3928]: TexCoord2sv (offset 109) */

-   "p\0"

-   "glTexCoord2sv\0"

-   "\0"

-   /* _mesa_function_pool[3945]: Vertex4dv (offset 143) */

-   "p\0"

-   "glVertex4dv\0"

-   "\0"

-   /* _mesa_function_pool[3960]: StencilMaskSeparate (will be remapped) */

-   "ii\0"

-   "glStencilMaskSeparate\0"

-   "\0"

-   /* _mesa_function_pool[3986]: ProgramLocalParameter4dARB (will be remapped) */

-   "iidddd\0"

-   "glProgramLocalParameter4dARB\0"

-   "\0"

-   /* _mesa_function_pool[4023]: CompressedTexImage3DARB (will be remapped) */

-   "iiiiiiiip\0"

-   "glCompressedTexImage3D\0"

-   "glCompressedTexImage3DARB\0"

-   "\0"

-   /* _mesa_function_pool[4083]: Color3sv (offset 18) */

-   "p\0"

-   "glColor3sv\0"

-   "\0"

-   /* _mesa_function_pool[4097]: GetConvolutionParameteriv (offset 358) */

-   "iip\0"

-   "glGetConvolutionParameteriv\0"

-   "glGetConvolutionParameterivEXT\0"

-   "\0"

-   /* _mesa_function_pool[4161]: VertexAttrib1fARB (will be remapped) */

-   "if\0"

-   "glVertexAttrib1f\0"

-   "glVertexAttrib1fARB\0"

-   "\0"

-   /* _mesa_function_pool[4202]: Vertex2dv (offset 127) */

-   "p\0"

-   "glVertex2dv\0"

-   "\0"

-   /* _mesa_function_pool[4217]: TestFenceNV (will be remapped) */

-   "i\0"

-   "glTestFenceNV\0"

-   "\0"

-   /* _mesa_function_pool[4234]: MultiTexCoord1fvARB (offset 379) */

-   "ip\0"

-   "glMultiTexCoord1fv\0"

-   "glMultiTexCoord1fvARB\0"

-   "\0"

-   /* _mesa_function_pool[4279]: TexCoord3iv (offset 115) */

-   "p\0"

-   "glTexCoord3iv\0"

-   "\0"

-   /* _mesa_function_pool[4296]: Uniform2uivEXT (will be remapped) */

-   "iip\0"

-   "glUniform2uivEXT\0"

-   "glUniform2uiv\0"

-   "\0"

-   /* _mesa_function_pool[4332]: ColorFragmentOp2ATI (will be remapped) */

-   "iiiiiiiiii\0"

-   "glColorFragmentOp2ATI\0"

-   "\0"

-   /* _mesa_function_pool[4366]: SecondaryColorPointerListIBM (dynamic) */

-   "iiipi\0"

-   "glSecondaryColorPointerListIBM\0"

-   "\0"

-   /* _mesa_function_pool[4404]: GetPixelTexGenParameterivSGIS (will be remapped) */

-   "ip\0"

-   "glGetPixelTexGenParameterivSGIS\0"

-   "\0"

-   /* _mesa_function_pool[4440]: Color3fv (offset 14) */

-   "p\0"

-   "glColor3fv\0"

-   "\0"

-   /* _mesa_function_pool[4454]: VertexAttrib4fNV (will be remapped) */

-   "iffff\0"

-   "glVertexAttrib4fNV\0"

-   "\0"

-   /* _mesa_function_pool[4480]: ReplacementCodeubSUN (dynamic) */

-   "i\0"

-   "glReplacementCodeubSUN\0"

-   "\0"

-   /* _mesa_function_pool[4506]: FinishAsyncSGIX (dynamic) */

-   "p\0"

-   "glFinishAsyncSGIX\0"

-   "\0"

-   /* _mesa_function_pool[4527]: GetDebugLogMESA (dynamic) */

-   "iiiipp\0"

-   "glGetDebugLogMESA\0"

-   "\0"

-   /* _mesa_function_pool[4553]: FogCoorddEXT (will be remapped) */

-   "d\0"

-   "glFogCoordd\0"

-   "glFogCoorddEXT\0"

-   "\0"

-   /* _mesa_function_pool[4583]: BeginConditionalRenderNV (will be remapped) */

-   "ii\0"

-   "glBeginConditionalRenderNV\0"

-   "glBeginConditionalRender\0"

-   "\0"

-   /* _mesa_function_pool[4639]: Color4ubVertex3fSUN (dynamic) */

-   "iiiifff\0"

-   "glColor4ubVertex3fSUN\0"

-   "\0"

-   /* _mesa_function_pool[4670]: FogCoordfEXT (will be remapped) */

-   "f\0"

-   "glFogCoordf\0"

-   "glFogCoordfEXT\0"

-   "\0"

-   /* _mesa_function_pool[4700]: PointSize (offset 173) */

-   "f\0"

-   "glPointSize\0"

-   "\0"

-   /* _mesa_function_pool[4715]: VertexAttribI2uivEXT (will be remapped) */

-   "ip\0"

-   "glVertexAttribI2uivEXT\0"

-   "glVertexAttribI2uiv\0"

-   "\0"

-   /* _mesa_function_pool[4762]: TexCoord2fVertex3fSUN (dynamic) */

-   "fffff\0"

-   "glTexCoord2fVertex3fSUN\0"

-   "\0"

-   /* _mesa_function_pool[4793]: PopName (offset 200) */

-   "\0"

-   "glPopName\0"

-   "\0"

-   /* _mesa_function_pool[4805]: GlobalAlphaFactoriSUN (dynamic) */

-   "i\0"

-   "glGlobalAlphaFactoriSUN\0"

-   "\0"

-   /* _mesa_function_pool[4832]: VertexAttrib2dNV (will be remapped) */

-   "idd\0"

-   "glVertexAttrib2dNV\0"

-   "\0"

-   /* _mesa_function_pool[4856]: GetProgramInfoLog (will be remapped) */

-   "iipp\0"

-   "glGetProgramInfoLog\0"

-   "\0"

-   /* _mesa_function_pool[4882]: VertexAttrib4NbvARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib4Nbv\0"

-   "glVertexAttrib4NbvARB\0"

-   "\0"

-   /* _mesa_function_pool[4927]: GetActiveAttribARB (will be remapped) */

-   "iiipppp\0"

-   "glGetActiveAttrib\0"

-   "glGetActiveAttribARB\0"

-   "\0"

-   /* _mesa_function_pool[4975]: Vertex4sv (offset 149) */

-   "p\0"

-   "glVertex4sv\0"

-   "\0"

-   /* _mesa_function_pool[4990]: VertexAttrib4ubNV (will be remapped) */

-   "iiiii\0"

-   "glVertexAttrib4ubNV\0"

-   "\0"

-   /* _mesa_function_pool[5017]: ClampColor (will be remapped) */

-   "ii\0"

-   "glClampColor\0"

-   "\0"

-   /* _mesa_function_pool[5034]: TextureRangeAPPLE (will be remapped) */

-   "iip\0"

-   "glTextureRangeAPPLE\0"

-   "\0"

-   /* _mesa_function_pool[5059]: GetTexEnvfv (offset 276) */

-   "iip\0"

-   "glGetTexEnvfv\0"

-   "\0"

-   /* _mesa_function_pool[5078]: BindTransformFeedback (will be remapped) */

-   "ii\0"

-   "glBindTransformFeedback\0"

-   "\0"

-   /* _mesa_function_pool[5106]: TexCoord2fColor4fNormal3fVertex3fSUN (dynamic) */

-   "ffffffffffff\0"

-   "glTexCoord2fColor4fNormal3fVertex3fSUN\0"

-   "\0"

-   /* _mesa_function_pool[5159]: Indexub (offset 315) */

-   "i\0"

-   "glIndexub\0"

-   "\0"

-   /* _mesa_function_pool[5172]: ColorMaskIndexedEXT (will be remapped) */

-   "iiiii\0"

-   "glColorMaskIndexedEXT\0"

-   "glColorMaski\0"

-   "\0"

-   /* _mesa_function_pool[5214]: TexEnvi (offset 186) */

-   "iii\0"

-   "glTexEnvi\0"

-   "\0"

-   /* _mesa_function_pool[5229]: GetClipPlane (offset 259) */

-   "ip\0"

-   "glGetClipPlane\0"

-   "\0"

-   /* _mesa_function_pool[5248]: CombinerParameterfvNV (will be remapped) */

-   "ip\0"

-   "glCombinerParameterfvNV\0"

-   "\0"

-   /* _mesa_function_pool[5276]: VertexAttribs3dvNV (will be remapped) */

-   "iip\0"

-   "glVertexAttribs3dvNV\0"

-   "\0"

-   /* _mesa_function_pool[5302]: VertexAttribI2uiEXT (will be remapped) */

-   "iii\0"

-   "glVertexAttribI2uiEXT\0"

-   "glVertexAttribI2ui\0"

-   "\0"

-   /* _mesa_function_pool[5348]: VertexAttribs4fvNV (will be remapped) */

-   "iip\0"

-   "glVertexAttribs4fvNV\0"

-   "\0"

-   /* _mesa_function_pool[5374]: VertexArrayRangeNV (will be remapped) */

-   "ip\0"

-   "glVertexArrayRangeNV\0"

-   "\0"

-   /* _mesa_function_pool[5399]: FragmentLightiSGIX (dynamic) */

-   "iii\0"

-   "glFragmentLightiSGIX\0"

-   "\0"

-   /* _mesa_function_pool[5425]: PolygonOffsetEXT (will be remapped) */

-   "ff\0"

-   "glPolygonOffsetEXT\0"

-   "\0"

-   /* _mesa_function_pool[5448]: VertexAttribI4uivEXT (will be remapped) */

-   "ip\0"

-   "glVertexAttribI4uivEXT\0"

-   "glVertexAttribI4uiv\0"

-   "\0"

-   /* _mesa_function_pool[5495]: PollAsyncSGIX (dynamic) */

-   "p\0"

-   "glPollAsyncSGIX\0"

-   "\0"

-   /* _mesa_function_pool[5514]: DeleteFragmentShaderATI (will be remapped) */

-   "i\0"

-   "glDeleteFragmentShaderATI\0"

-   "\0"

-   /* _mesa_function_pool[5543]: Scaled (offset 301) */

-   "ddd\0"

-   "glScaled\0"

-   "\0"

-   /* _mesa_function_pool[5557]: ResumeTransformFeedback (will be remapped) */

-   "\0"

-   "glResumeTransformFeedback\0"

-   "\0"

-   /* _mesa_function_pool[5585]: Scalef (offset 302) */

-   "fff\0"

-   "glScalef\0"

-   "\0"

-   /* _mesa_function_pool[5599]: TexCoord2fNormal3fVertex3fvSUN (dynamic) */

-   "ppp\0"

-   "glTexCoord2fNormal3fVertex3fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[5637]: MultTransposeMatrixdARB (will be remapped) */

-   "p\0"

-   "glMultTransposeMatrixd\0"

-   "glMultTransposeMatrixdARB\0"

-   "\0"

-   /* _mesa_function_pool[5689]: ObjectUnpurgeableAPPLE (will be remapped) */

-   "iii\0"

-   "glObjectUnpurgeableAPPLE\0"

-   "\0"

-   /* _mesa_function_pool[5719]: AlphaFunc (offset 240) */

-   "if\0"

-   "glAlphaFunc\0"

-   "\0"

-   /* _mesa_function_pool[5735]: WindowPos2svMESA (will be remapped) */

-   "p\0"

-   "glWindowPos2sv\0"

-   "glWindowPos2svARB\0"

-   "glWindowPos2svMESA\0"

-   "\0"

-   /* _mesa_function_pool[5790]: EdgeFlag (offset 41) */

-   "i\0"

-   "glEdgeFlag\0"

-   "\0"

-   /* _mesa_function_pool[5804]: TexCoord2iv (offset 107) */

-   "p\0"

-   "glTexCoord2iv\0"

-   "\0"

-   /* _mesa_function_pool[5821]: CompressedTexImage1DARB (will be remapped) */

-   "iiiiiip\0"

-   "glCompressedTexImage1D\0"

-   "glCompressedTexImage1DARB\0"

-   "\0"

-   /* _mesa_function_pool[5879]: Rotated (offset 299) */

-   "dddd\0"

-   "glRotated\0"

-   "\0"

-   /* _mesa_function_pool[5895]: GetTexParameterIuivEXT (will be remapped) */

-   "iip\0"

-   "glGetTexParameterIuivEXT\0"

-   "glGetTexParameterIuiv\0"

-   "\0"

-   /* _mesa_function_pool[5947]: VertexAttrib2sNV (will be remapped) */

-   "iii\0"

-   "glVertexAttrib2sNV\0"

-   "\0"

-   /* _mesa_function_pool[5971]: ReadPixels (offset 256) */

-   "iiiiiip\0"

-   "glReadPixels\0"

-   "\0"

-   /* _mesa_function_pool[5993]: EdgeFlagv (offset 42) */

-   "p\0"

-   "glEdgeFlagv\0"

-   "\0"

-   /* _mesa_function_pool[6008]: NormalPointerListIBM (dynamic) */

-   "iipi\0"

-   "glNormalPointerListIBM\0"

-   "\0"

-   /* _mesa_function_pool[6037]: IndexPointerEXT (will be remapped) */

-   "iiip\0"

-   "glIndexPointerEXT\0"

-   "\0"

-   /* _mesa_function_pool[6061]: Color4iv (offset 32) */

-   "p\0"

-   "glColor4iv\0"

-   "\0"

-   /* _mesa_function_pool[6075]: TexParameterf (offset 178) */

-   "iif\0"

-   "glTexParameterf\0"

-   "\0"

-   /* _mesa_function_pool[6096]: TexParameteri (offset 180) */

-   "iii\0"

-   "glTexParameteri\0"

-   "\0"

-   /* _mesa_function_pool[6117]: NormalPointerEXT (will be remapped) */

-   "iiip\0"

-   "glNormalPointerEXT\0"

-   "\0"

-   /* _mesa_function_pool[6142]: MultiTexCoord3dARB (offset 392) */

-   "iddd\0"

-   "glMultiTexCoord3d\0"

-   "glMultiTexCoord3dARB\0"

-   "\0"

-   /* _mesa_function_pool[6187]: MultiTexCoord2iARB (offset 388) */

-   "iii\0"

-   "glMultiTexCoord2i\0"

-   "glMultiTexCoord2iARB\0"

-   "\0"

-   /* _mesa_function_pool[6231]: DrawPixels (offset 257) */

-   "iiiip\0"

-   "glDrawPixels\0"

-   "\0"

-   /* _mesa_function_pool[6251]: ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN (dynamic) */

-   "iffffffff\0"

-   "glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN\0"

-   "\0"

-   /* _mesa_function_pool[6311]: MultiTexCoord2svARB (offset 391) */

-   "ip\0"

-   "glMultiTexCoord2sv\0"

-   "glMultiTexCoord2svARB\0"

-   "\0"

-   /* _mesa_function_pool[6356]: ReplacementCodeubvSUN (dynamic) */

-   "p\0"

-   "glReplacementCodeubvSUN\0"

-   "\0"

-   /* _mesa_function_pool[6383]: Uniform3iARB (will be remapped) */

-   "iiii\0"

-   "glUniform3i\0"

-   "glUniform3iARB\0"

-   "\0"

-   /* _mesa_function_pool[6416]: DrawTransformFeedback (will be remapped) */

-   "ii\0"

-   "glDrawTransformFeedback\0"

-   "\0"

-   /* _mesa_function_pool[6444]: DrawElementsInstancedARB (will be remapped) */

-   "iiipi\0"

-   "glDrawElementsInstancedARB\0"

-   "glDrawElementsInstancedEXT\0"

-   "glDrawElementsInstanced\0"

-   "\0"

-   /* _mesa_function_pool[6529]: GetShaderInfoLog (will be remapped) */

-   "iipp\0"

-   "glGetShaderInfoLog\0"

-   "\0"

-   /* _mesa_function_pool[6554]: WeightivARB (dynamic) */

-   "ip\0"

-   "glWeightivARB\0"

-   "\0"

-   /* _mesa_function_pool[6572]: PollInstrumentsSGIX (dynamic) */

-   "p\0"

-   "glPollInstrumentsSGIX\0"

-   "\0"

-   /* _mesa_function_pool[6597]: GlobalAlphaFactordSUN (dynamic) */

-   "d\0"

-   "glGlobalAlphaFactordSUN\0"

-   "\0"

-   /* _mesa_function_pool[6624]: GetFinalCombinerInputParameterfvNV (will be remapped) */

-   "iip\0"

-   "glGetFinalCombinerInputParameterfvNV\0"

-   "\0"

-   /* _mesa_function_pool[6666]: GenerateMipmapEXT (will be remapped) */

-   "i\0"

-   "glGenerateMipmap\0"

-   "glGenerateMipmapEXT\0"

-   "\0"

-   /* _mesa_function_pool[6706]: GenLists (offset 5) */

-   "i\0"

-   "glGenLists\0"

-   "\0"

-   /* _mesa_function_pool[6720]: DepthRangef (will be remapped) */

-   "ff\0"

-   "glDepthRangef\0"

-   "\0"

-   /* _mesa_function_pool[6738]: GetMapAttribParameterivNV (dynamic) */

-   "iiip\0"

-   "glGetMapAttribParameterivNV\0"

-   "\0"

-   /* _mesa_function_pool[6772]: CreateShaderObjectARB (will be remapped) */

-   "i\0"

-   "glCreateShaderObjectARB\0"

-   "\0"

-   /* _mesa_function_pool[6799]: GetSharpenTexFuncSGIS (dynamic) */

-   "ip\0"

-   "glGetSharpenTexFuncSGIS\0"

-   "\0"

-   /* _mesa_function_pool[6827]: BufferDataARB (will be remapped) */

-   "iipi\0"

-   "glBufferData\0"

-   "glBufferDataARB\0"

-   "\0"

-   /* _mesa_function_pool[6862]: FlushVertexArrayRangeNV (will be remapped) */

-   "\0"

-   "glFlushVertexArrayRangeNV\0"

-   "\0"

-   /* _mesa_function_pool[6890]: MapGrid2d (offset 226) */

-   "iddidd\0"

-   "glMapGrid2d\0"

-   "\0"

-   /* _mesa_function_pool[6910]: MapGrid2f (offset 227) */

-   "iffiff\0"

-   "glMapGrid2f\0"

-   "\0"

-   /* _mesa_function_pool[6930]: SampleMapATI (will be remapped) */

-   "iii\0"

-   "glSampleMapATI\0"

-   "\0"

-   /* _mesa_function_pool[6950]: VertexPointerEXT (will be remapped) */

-   "iiiip\0"

-   "glVertexPointerEXT\0"

-   "\0"

-   /* _mesa_function_pool[6976]: GetTexFilterFuncSGIS (dynamic) */

-   "iip\0"

-   "glGetTexFilterFuncSGIS\0"

-   "\0"

-   /* _mesa_function_pool[7004]: Scissor (offset 176) */

-   "iiii\0"

-   "glScissor\0"

-   "\0"

-   /* _mesa_function_pool[7020]: Fogf (offset 153) */

-   "if\0"

-   "glFogf\0"

-   "\0"

-   /* _mesa_function_pool[7031]: ReplacementCodeuiColor4ubVertex3fvSUN (dynamic) */

-   "ppp\0"

-   "glReplacementCodeuiColor4ubVertex3fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[7076]: TexSubImage1D (offset 332) */

-   "iiiiiip\0"

-   "glTexSubImage1D\0"

-   "glTexSubImage1DEXT\0"

-   "\0"

-   /* _mesa_function_pool[7120]: VertexAttrib1sARB (will be remapped) */

-   "ii\0"

-   "glVertexAttrib1s\0"

-   "glVertexAttrib1sARB\0"

-   "\0"

-   /* _mesa_function_pool[7161]: FenceSync (will be remapped) */

-   "ii\0"

-   "glFenceSync\0"

-   "\0"

-   /* _mesa_function_pool[7177]: Color4usv (offset 40) */

-   "p\0"

-   "glColor4usv\0"

-   "\0"

-   /* _mesa_function_pool[7192]: Fogi (offset 155) */

-   "ii\0"

-   "glFogi\0"

-   "\0"

-   /* _mesa_function_pool[7203]: DepthRange (offset 288) */

-   "dd\0"

-   "glDepthRange\0"

-   "\0"

-   /* _mesa_function_pool[7220]: RasterPos3iv (offset 75) */

-   "p\0"

-   "glRasterPos3iv\0"

-   "\0"

-   /* _mesa_function_pool[7238]: FinalCombinerInputNV (will be remapped) */

-   "iiii\0"

-   "glFinalCombinerInputNV\0"

-   "\0"

-   /* _mesa_function_pool[7267]: TexCoord2i (offset 106) */

-   "ii\0"

-   "glTexCoord2i\0"

-   "\0"

-   /* _mesa_function_pool[7284]: PixelMapfv (offset 251) */

-   "iip\0"

-   "glPixelMapfv\0"

-   "\0"

-   /* _mesa_function_pool[7302]: Color4ui (offset 37) */

-   "iiii\0"

-   "glColor4ui\0"

-   "\0"

-   /* _mesa_function_pool[7319]: RasterPos3s (offset 76) */

-   "iii\0"

-   "glRasterPos3s\0"

-   "\0"

-   /* _mesa_function_pool[7338]: Color3usv (offset 24) */

-   "p\0"

-   "glColor3usv\0"

-   "\0"

-   /* _mesa_function_pool[7353]: FlushRasterSGIX (dynamic) */

-   "\0"

-   "glFlushRasterSGIX\0"

-   "\0"

-   /* _mesa_function_pool[7373]: TexCoord2f (offset 104) */

-   "ff\0"

-   "glTexCoord2f\0"

-   "\0"

-   /* _mesa_function_pool[7390]: ReplacementCodeuiTexCoord2fVertex3fSUN (dynamic) */

-   "ifffff\0"

-   "glReplacementCodeuiTexCoord2fVertex3fSUN\0"

-   "\0"

-   /* _mesa_function_pool[7439]: TexCoord2d (offset 102) */

-   "dd\0"

-   "glTexCoord2d\0"

-   "\0"

-   /* _mesa_function_pool[7456]: RasterPos3d (offset 70) */

-   "ddd\0"

-   "glRasterPos3d\0"

-   "\0"

-   /* _mesa_function_pool[7475]: RasterPos3f (offset 72) */

-   "fff\0"

-   "glRasterPos3f\0"

-   "\0"

-   /* _mesa_function_pool[7494]: Uniform1fARB (will be remapped) */

-   "if\0"

-   "glUniform1f\0"

-   "glUniform1fARB\0"

-   "\0"

-   /* _mesa_function_pool[7525]: AreTexturesResident (offset 322) */

-   "ipp\0"

-   "glAreTexturesResident\0"

-   "glAreTexturesResidentEXT\0"

-   "\0"

-   /* _mesa_function_pool[7577]: TexCoord2s (offset 108) */

-   "ii\0"

-   "glTexCoord2s\0"

-   "\0"

-   /* _mesa_function_pool[7594]: StencilOpSeparate (will be remapped) */

-   "iiii\0"

-   "glStencilOpSeparate\0"

-   "glStencilOpSeparateATI\0"

-   "\0"

-   /* _mesa_function_pool[7643]: ColorTableParameteriv (offset 341) */

-   "iip\0"

-   "glColorTableParameteriv\0"

-   "glColorTableParameterivSGI\0"

-   "\0"

-   /* _mesa_function_pool[7699]: FogCoordPointerListIBM (dynamic) */

-   "iipi\0"

-   "glFogCoordPointerListIBM\0"

-   "\0"

-   /* _mesa_function_pool[7730]: WindowPos3dMESA (will be remapped) */

-   "ddd\0"

-   "glWindowPos3d\0"

-   "glWindowPos3dARB\0"

-   "glWindowPos3dMESA\0"

-   "\0"

-   /* _mesa_function_pool[7784]: Color4us (offset 39) */

-   "iiii\0"

-   "glColor4us\0"

-   "\0"

-   /* _mesa_function_pool[7801]: PointParameterfvEXT (will be remapped) */

-   "ip\0"

-   "glPointParameterfv\0"

-   "glPointParameterfvARB\0"

-   "glPointParameterfvEXT\0"

-   "glPointParameterfvSGIS\0"

-   "\0"

-   /* _mesa_function_pool[7891]: Color3bv (offset 10) */

-   "p\0"

-   "glColor3bv\0"

-   "\0"

-   /* _mesa_function_pool[7905]: WindowPos2fvMESA (will be remapped) */

-   "p\0"

-   "glWindowPos2fv\0"

-   "glWindowPos2fvARB\0"

-   "glWindowPos2fvMESA\0"

-   "\0"

-   /* _mesa_function_pool[7960]: SecondaryColor3bvEXT (will be remapped) */

-   "p\0"

-   "glSecondaryColor3bv\0"

-   "glSecondaryColor3bvEXT\0"

-   "\0"

-   /* _mesa_function_pool[8006]: VertexPointerListIBM (dynamic) */

-   "iiipi\0"

-   "glVertexPointerListIBM\0"

-   "\0"

-   /* _mesa_function_pool[8036]: GetProgramLocalParameterfvARB (will be remapped) */

-   "iip\0"

-   "glGetProgramLocalParameterfvARB\0"

-   "\0"

-   /* _mesa_function_pool[8073]: FragmentMaterialfSGIX (dynamic) */

-   "iif\0"

-   "glFragmentMaterialfSGIX\0"

-   "\0"

-   /* _mesa_function_pool[8102]: TexCoord2fNormal3fVertex3fSUN (dynamic) */

-   "ffffffff\0"

-   "glTexCoord2fNormal3fVertex3fSUN\0"

-   "\0"

-   /* _mesa_function_pool[8144]: RenderbufferStorageEXT (will be remapped) */

-   "iiii\0"

-   "glRenderbufferStorage\0"

-   "glRenderbufferStorageEXT\0"

-   "\0"

-   /* _mesa_function_pool[8197]: IsFenceNV (will be remapped) */

-   "i\0"

-   "glIsFenceNV\0"

-   "\0"

-   /* _mesa_function_pool[8212]: AttachObjectARB (will be remapped) */

-   "ii\0"

-   "glAttachObjectARB\0"

-   "\0"

-   /* _mesa_function_pool[8234]: GetFragmentLightivSGIX (dynamic) */

-   "iip\0"

-   "glGetFragmentLightivSGIX\0"

-   "\0"

-   /* _mesa_function_pool[8264]: UniformMatrix2fvARB (will be remapped) */

-   "iiip\0"

-   "glUniformMatrix2fv\0"

-   "glUniformMatrix2fvARB\0"

-   "\0"

-   /* _mesa_function_pool[8311]: MultiTexCoord2fARB (offset 386) */

-   "iff\0"

-   "glMultiTexCoord2f\0"

-   "glMultiTexCoord2fARB\0"

-   "\0"

-   /* _mesa_function_pool[8355]: ColorTable (offset 339) */

-   "iiiiip\0"

-   "glColorTable\0"

-   "glColorTableSGI\0"

-   "glColorTableEXT\0"

-   "\0"

-   /* _mesa_function_pool[8408]: IndexPointer (offset 314) */

-   "iip\0"

-   "glIndexPointer\0"

-   "\0"

-   /* _mesa_function_pool[8428]: Accum (offset 213) */

-   "if\0"

-   "glAccum\0"

-   "\0"

-   /* _mesa_function_pool[8440]: GetTexImage (offset 281) */

-   "iiiip\0"

-   "glGetTexImage\0"

-   "\0"

-   /* _mesa_function_pool[8461]: MapControlPointsNV (dynamic) */

-   "iiiiiiiip\0"

-   "glMapControlPointsNV\0"

-   "\0"

-   /* _mesa_function_pool[8493]: ConvolutionFilter2D (offset 349) */

-   "iiiiiip\0"

-   "glConvolutionFilter2D\0"

-   "glConvolutionFilter2DEXT\0"

-   "\0"

-   /* _mesa_function_pool[8549]: Finish (offset 216) */

-   "\0"

-   "glFinish\0"

-   "\0"

-   /* _mesa_function_pool[8560]: MapParameterfvNV (dynamic) */

-   "iip\0"

-   "glMapParameterfvNV\0"

-   "\0"

-   /* _mesa_function_pool[8584]: ClearStencil (offset 207) */

-   "i\0"

-   "glClearStencil\0"

-   "\0"

-   /* _mesa_function_pool[8602]: VertexAttrib3dvARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib3dv\0"

-   "glVertexAttrib3dvARB\0"

-   "\0"

-   /* _mesa_function_pool[8645]: Uniform4uivEXT (will be remapped) */

-   "iip\0"

-   "glUniform4uivEXT\0"

-   "glUniform4uiv\0"

-   "\0"

-   /* _mesa_function_pool[8681]: HintPGI (dynamic) */

-   "ii\0"

-   "glHintPGI\0"

-   "\0"

-   /* _mesa_function_pool[8695]: ConvolutionParameteriv (offset 353) */

-   "iip\0"

-   "glConvolutionParameteriv\0"

-   "glConvolutionParameterivEXT\0"

-   "\0"

-   /* _mesa_function_pool[8753]: Color4s (offset 33) */

-   "iiii\0"

-   "glColor4s\0"

-   "\0"

-   /* _mesa_function_pool[8769]: InterleavedArrays (offset 317) */

-   "iip\0"

-   "glInterleavedArrays\0"

-   "\0"

-   /* _mesa_function_pool[8794]: RasterPos2fv (offset 65) */

-   "p\0"

-   "glRasterPos2fv\0"

-   "\0"

-   /* _mesa_function_pool[8812]: TexCoord1fv (offset 97) */

-   "p\0"

-   "glTexCoord1fv\0"

-   "\0"

-   /* _mesa_function_pool[8829]: Vertex2d (offset 126) */

-   "dd\0"

-   "glVertex2d\0"

-   "\0"

-   /* _mesa_function_pool[8844]: CullParameterdvEXT (dynamic) */

-   "ip\0"

-   "glCullParameterdvEXT\0"

-   "\0"

-   /* _mesa_function_pool[8869]: ProgramNamedParameter4fNV (will be remapped) */

-   "iipffff\0"

-   "glProgramNamedParameter4fNV\0"

-   "\0"

-   /* _mesa_function_pool[8906]: Color3fVertex3fSUN (dynamic) */

-   "ffffff\0"

-   "glColor3fVertex3fSUN\0"

-   "\0"

-   /* _mesa_function_pool[8935]: ProgramEnvParameter4fvARB (will be remapped) */

-   "iip\0"

-   "glProgramEnvParameter4fvARB\0"

-   "glProgramParameter4fvNV\0"

-   "\0"

-   /* _mesa_function_pool[8992]: Color4i (offset 31) */

-   "iiii\0"

-   "glColor4i\0"

-   "\0"

-   /* _mesa_function_pool[9008]: Color4f (offset 29) */

-   "ffff\0"

-   "glColor4f\0"

-   "\0"

-   /* _mesa_function_pool[9024]: RasterPos4fv (offset 81) */

-   "p\0"

-   "glRasterPos4fv\0"

-   "\0"

-   /* _mesa_function_pool[9042]: Color4d (offset 27) */

-   "dddd\0"

-   "glColor4d\0"

-   "\0"

-   /* _mesa_function_pool[9058]: ClearIndex (offset 205) */

-   "f\0"

-   "glClearIndex\0"

-   "\0"

-   /* _mesa_function_pool[9074]: Color4b (offset 25) */

-   "iiii\0"

-   "glColor4b\0"

-   "\0"

-   /* _mesa_function_pool[9090]: LoadMatrixd (offset 292) */

-   "p\0"

-   "glLoadMatrixd\0"

-   "\0"

-   /* _mesa_function_pool[9107]: FragmentLightModeliSGIX (dynamic) */

-   "ii\0"

-   "glFragmentLightModeliSGIX\0"

-   "\0"

-   /* _mesa_function_pool[9137]: RasterPos2dv (offset 63) */

-   "p\0"

-   "glRasterPos2dv\0"

-   "\0"

-   /* _mesa_function_pool[9155]: ConvolutionParameterfv (offset 351) */

-   "iip\0"

-   "glConvolutionParameterfv\0"

-   "glConvolutionParameterfvEXT\0"

-   "\0"

-   /* _mesa_function_pool[9213]: TbufferMask3DFX (dynamic) */

-   "i\0"

-   "glTbufferMask3DFX\0"

-   "\0"

-   /* _mesa_function_pool[9234]: GetTexGendv (offset 278) */

-   "iip\0"

-   "glGetTexGendv\0"

-   "\0"

-   /* _mesa_function_pool[9253]: GetVertexAttribfvNV (will be remapped) */

-   "iip\0"

-   "glGetVertexAttribfvNV\0"

-   "\0"

-   /* _mesa_function_pool[9280]: BeginTransformFeedbackEXT (will be remapped) */

-   "i\0"

-   "glBeginTransformFeedbackEXT\0"

-   "glBeginTransformFeedback\0"

-   "\0"

-   /* _mesa_function_pool[9336]: LoadProgramNV (will be remapped) */

-   "iiip\0"

-   "glLoadProgramNV\0"

-   "\0"

-   /* _mesa_function_pool[9358]: WaitSync (will be remapped) */

-   "iii\0"

-   "glWaitSync\0"

-   "\0"

-   /* _mesa_function_pool[9374]: EndList (offset 1) */

-   "\0"

-   "glEndList\0"

-   "\0"

-   /* _mesa_function_pool[9386]: VertexAttrib4fvNV (will be remapped) */

-   "ip\0"

-   "glVertexAttrib4fvNV\0"

-   "\0"

-   /* _mesa_function_pool[9410]: GetAttachedObjectsARB (will be remapped) */

-   "iipp\0"

-   "glGetAttachedObjectsARB\0"

-   "\0"

-   /* _mesa_function_pool[9440]: Uniform3fvARB (will be remapped) */

-   "iip\0"

-   "glUniform3fv\0"

-   "glUniform3fvARB\0"

-   "\0"

-   /* _mesa_function_pool[9474]: EvalCoord1fv (offset 231) */

-   "p\0"

-   "glEvalCoord1fv\0"

-   "\0"

-   /* _mesa_function_pool[9492]: DrawRangeElements (offset 338) */

-   "iiiiip\0"

-   "glDrawRangeElements\0"

-   "glDrawRangeElementsEXT\0"

-   "\0"

-   /* _mesa_function_pool[9543]: EvalMesh2 (offset 238) */

-   "iiiii\0"

-   "glEvalMesh2\0"

-   "\0"

-   /* _mesa_function_pool[9562]: Vertex4fv (offset 145) */

-   "p\0"

-   "glVertex4fv\0"

-   "\0"

-   /* _mesa_function_pool[9577]: GenTransformFeedbacks (will be remapped) */

-   "ip\0"

-   "glGenTransformFeedbacks\0"

-   "\0"

-   /* _mesa_function_pool[9605]: SpriteParameterfvSGIX (dynamic) */

-   "ip\0"

-   "glSpriteParameterfvSGIX\0"

-   "\0"

-   /* _mesa_function_pool[9633]: CheckFramebufferStatusEXT (will be remapped) */

-   "i\0"

-   "glCheckFramebufferStatus\0"

-   "glCheckFramebufferStatusEXT\0"

-   "\0"

-   /* _mesa_function_pool[9689]: GlobalAlphaFactoruiSUN (dynamic) */

-   "i\0"

-   "glGlobalAlphaFactoruiSUN\0"

-   "\0"

-   /* _mesa_function_pool[9717]: GetHandleARB (will be remapped) */

-   "i\0"

-   "glGetHandleARB\0"

-   "\0"

-   /* _mesa_function_pool[9735]: GetVertexAttribivARB (will be remapped) */

-   "iip\0"

-   "glGetVertexAttribiv\0"

-   "glGetVertexAttribivARB\0"

-   "\0"

-   /* _mesa_function_pool[9783]: BlendFunciARB (will be remapped) */

-   "iii\0"

-   "glBlendFunciARB\0"

-   "\0"

-   /* _mesa_function_pool[9804]: GetCombinerInputParameterfvNV (will be remapped) */

-   "iiiip\0"

-   "glGetCombinerInputParameterfvNV\0"

-   "\0"

-   /* _mesa_function_pool[9843]: GetTexParameterIivEXT (will be remapped) */

-   "iip\0"

-   "glGetTexParameterIivEXT\0"

-   "glGetTexParameterIiv\0"

-   "\0"

-   /* _mesa_function_pool[9893]: CreateProgram (will be remapped) */

-   "\0"

-   "glCreateProgram\0"

-   "\0"

-   /* _mesa_function_pool[9911]: LoadTransposeMatrixdARB (will be remapped) */

-   "p\0"

-   "glLoadTransposeMatrixd\0"

-   "glLoadTransposeMatrixdARB\0"

-   "\0"

-   /* _mesa_function_pool[9963]: ReleaseShaderCompiler (will be remapped) */

-   "\0"

-   "glReleaseShaderCompiler\0"

-   "\0"

-   /* _mesa_function_pool[9989]: GetMinmax (offset 364) */

-   "iiiip\0"

-   "glGetMinmax\0"

-   "glGetMinmaxEXT\0"

-   "\0"

-   /* _mesa_function_pool[10023]: StencilFuncSeparate (will be remapped) */

-   "iiii\0"

-   "glStencilFuncSeparate\0"

-   "\0"

-   /* _mesa_function_pool[10051]: SecondaryColor3sEXT (will be remapped) */

-   "iii\0"

-   "glSecondaryColor3s\0"

-   "glSecondaryColor3sEXT\0"

-   "\0"

-   /* _mesa_function_pool[10097]: Color3fVertex3fvSUN (dynamic) */

-   "pp\0"

-   "glColor3fVertex3fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[10123]: GetInteger64i_v (will be remapped) */

-   "iip\0"

-   "glGetInteger64i_v\0"

-   "\0"

-   /* _mesa_function_pool[10146]: Normal3fv (offset 57) */

-   "p\0"

-   "glNormal3fv\0"

-   "\0"

-   /* _mesa_function_pool[10161]: GlobalAlphaFactorbSUN (dynamic) */

-   "i\0"

-   "glGlobalAlphaFactorbSUN\0"

-   "\0"

-   /* _mesa_function_pool[10188]: Color3us (offset 23) */

-   "iii\0"

-   "glColor3us\0"

-   "\0"

-   /* _mesa_function_pool[10204]: ImageTransformParameterfvHP (dynamic) */

-   "iip\0"

-   "glImageTransformParameterfvHP\0"

-   "\0"

-   /* _mesa_function_pool[10239]: VertexAttrib4ivARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib4iv\0"

-   "glVertexAttrib4ivARB\0"

-   "\0"

-   /* _mesa_function_pool[10282]: End (offset 43) */

-   "\0"

-   "glEnd\0"

-   "\0"

-   /* _mesa_function_pool[10290]: VertexAttrib3fNV (will be remapped) */

-   "ifff\0"

-   "glVertexAttrib3fNV\0"

-   "\0"

-   /* _mesa_function_pool[10315]: VertexAttribs2dvNV (will be remapped) */

-   "iip\0"

-   "glVertexAttribs2dvNV\0"

-   "\0"

-   /* _mesa_function_pool[10341]: GetQueryObjectui64vEXT (will be remapped) */

-   "iip\0"

-   "glGetQueryObjectui64vEXT\0"

-   "\0"

-   /* _mesa_function_pool[10371]: MultiTexCoord3fvARB (offset 395) */

-   "ip\0"

-   "glMultiTexCoord3fv\0"

-   "glMultiTexCoord3fvARB\0"

-   "\0"

-   /* _mesa_function_pool[10416]: SecondaryColor3dEXT (will be remapped) */

-   "ddd\0"

-   "glSecondaryColor3d\0"

-   "glSecondaryColor3dEXT\0"

-   "\0"

-   /* _mesa_function_pool[10462]: Color3ub (offset 19) */

-   "iii\0"

-   "glColor3ub\0"

-   "\0"

-   /* _mesa_function_pool[10478]: GetProgramParameterfvNV (will be remapped) */

-   "iiip\0"

-   "glGetProgramParameterfvNV\0"

-   "\0"

-   /* _mesa_function_pool[10510]: TangentPointerEXT (dynamic) */

-   "iip\0"

-   "glTangentPointerEXT\0"

-   "\0"

-   /* _mesa_function_pool[10535]: Color4fNormal3fVertex3fvSUN (dynamic) */

-   "ppp\0"

-   "glColor4fNormal3fVertex3fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[10570]: GetInstrumentsSGIX (dynamic) */

-   "\0"

-   "glGetInstrumentsSGIX\0"

-   "\0"

-   /* _mesa_function_pool[10593]: GetUniformuivEXT (will be remapped) */

-   "iip\0"

-   "glGetUniformuivEXT\0"

-   "glGetUniformuiv\0"

-   "\0"

-   /* _mesa_function_pool[10633]: Color3ui (offset 21) */

-   "iii\0"

-   "glColor3ui\0"

-   "\0"

-   /* _mesa_function_pool[10649]: EvalMapsNV (dynamic) */

-   "ii\0"

-   "glEvalMapsNV\0"

-   "\0"

-   /* _mesa_function_pool[10666]: TexSubImage2D (offset 333) */

-   "iiiiiiiip\0"

-   "glTexSubImage2D\0"

-   "glTexSubImage2DEXT\0"

-   "\0"

-   /* _mesa_function_pool[10712]: FragmentLightivSGIX (dynamic) */

-   "iip\0"

-   "glFragmentLightivSGIX\0"

-   "\0"

-   /* _mesa_function_pool[10739]: GetTexParameterPointervAPPLE (will be remapped) */

-   "iip\0"

-   "glGetTexParameterPointervAPPLE\0"

-   "\0"

-   /* _mesa_function_pool[10775]: TexGenfv (offset 191) */

-   "iip\0"

-   "glTexGenfv\0"

-   "\0"

-   /* _mesa_function_pool[10791]: GetTransformFeedbackVaryingEXT (will be remapped) */

-   "iiipppp\0"

-   "glGetTransformFeedbackVaryingEXT\0"

-   "glGetTransformFeedbackVarying\0"

-   "\0"

-   /* _mesa_function_pool[10863]: VertexAttrib4bvARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib4bv\0"

-   "glVertexAttrib4bvARB\0"

-   "\0"

-   /* _mesa_function_pool[10906]: ShaderBinary (will be remapped) */

-   "ipipi\0"

-   "glShaderBinary\0"

-   "\0"

-   /* _mesa_function_pool[10928]: GetIntegerIndexedvEXT (will be remapped) */

-   "iip\0"

-   "glGetIntegerIndexedvEXT\0"

-   "glGetIntegeri_v\0"

-   "\0"

-   /* _mesa_function_pool[10973]: MultiTexCoord4sARB (offset 406) */

-   "iiiii\0"

-   "glMultiTexCoord4s\0"

-   "glMultiTexCoord4sARB\0"

-   "\0"

-   /* _mesa_function_pool[11019]: GetFragmentMaterialivSGIX (dynamic) */

-   "iip\0"

-   "glGetFragmentMaterialivSGIX\0"

-   "\0"

-   /* _mesa_function_pool[11052]: WindowPos4dMESA (will be remapped) */

-   "dddd\0"

-   "glWindowPos4dMESA\0"

-   "\0"

-   /* _mesa_function_pool[11076]: WeightPointerARB (dynamic) */

-   "iiip\0"

-   "glWeightPointerARB\0"

-   "\0"

-   /* _mesa_function_pool[11101]: WindowPos2dMESA (will be remapped) */

-   "dd\0"

-   "glWindowPos2d\0"

-   "glWindowPos2dARB\0"

-   "glWindowPos2dMESA\0"

-   "\0"

-   /* _mesa_function_pool[11154]: FramebufferTexture3DEXT (will be remapped) */

-   "iiiiii\0"

-   "glFramebufferTexture3D\0"

-   "glFramebufferTexture3DEXT\0"

-   "\0"

-   /* _mesa_function_pool[11211]: BlendEquation (offset 337) */

-   "i\0"

-   "glBlendEquation\0"

-   "glBlendEquationEXT\0"

-   "\0"

-   /* _mesa_function_pool[11249]: VertexAttrib3dNV (will be remapped) */

-   "iddd\0"

-   "glVertexAttrib3dNV\0"

-   "\0"

-   /* _mesa_function_pool[11274]: VertexAttrib3dARB (will be remapped) */

-   "iddd\0"

-   "glVertexAttrib3d\0"

-   "glVertexAttrib3dARB\0"

-   "\0"

-   /* _mesa_function_pool[11317]: VertexAttribI4usvEXT (will be remapped) */

-   "ip\0"

-   "glVertexAttribI4usvEXT\0"

-   "glVertexAttribI4usv\0"

-   "\0"

-   /* _mesa_function_pool[11364]: ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN (dynamic) */

-   "ppppp\0"

-   "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[11428]: VertexAttrib4fARB (will be remapped) */

-   "iffff\0"

-   "glVertexAttrib4f\0"

-   "glVertexAttrib4fARB\0"

-   "\0"

-   /* _mesa_function_pool[11472]: GetError (offset 261) */

-   "\0"

-   "glGetError\0"

-   "\0"

-   /* _mesa_function_pool[11485]: IndexFuncEXT (dynamic) */

-   "if\0"

-   "glIndexFuncEXT\0"

-   "\0"

-   /* _mesa_function_pool[11504]: TexCoord3dv (offset 111) */

-   "p\0"

-   "glTexCoord3dv\0"

-   "\0"

-   /* _mesa_function_pool[11521]: Indexdv (offset 45) */

-   "p\0"

-   "glIndexdv\0"

-   "\0"

-   /* _mesa_function_pool[11534]: FramebufferTexture2DEXT (will be remapped) */

-   "iiiii\0"

-   "glFramebufferTexture2D\0"

-   "glFramebufferTexture2DEXT\0"

-   "\0"

-   /* _mesa_function_pool[11590]: Normal3s (offset 60) */

-   "iii\0"

-   "glNormal3s\0"

-   "\0"

-   /* _mesa_function_pool[11606]: GetObjectParameterivAPPLE (will be remapped) */

-   "iiip\0"

-   "glGetObjectParameterivAPPLE\0"

-   "\0"

-   /* _mesa_function_pool[11640]: PushName (offset 201) */

-   "i\0"

-   "glPushName\0"

-   "\0"

-   /* _mesa_function_pool[11654]: MultiTexCoord2dvARB (offset 385) */

-   "ip\0"

-   "glMultiTexCoord2dv\0"

-   "glMultiTexCoord2dvARB\0"

-   "\0"

-   /* _mesa_function_pool[11699]: CullParameterfvEXT (dynamic) */

-   "ip\0"

-   "glCullParameterfvEXT\0"

-   "\0"

-   /* _mesa_function_pool[11724]: Normal3i (offset 58) */

-   "iii\0"

-   "glNormal3i\0"

-   "\0"

-   /* _mesa_function_pool[11740]: ProgramNamedParameter4fvNV (will be remapped) */

-   "iipp\0"

-   "glProgramNamedParameter4fvNV\0"

-   "\0"

-   /* _mesa_function_pool[11775]: SecondaryColorPointerEXT (will be remapped) */

-   "iiip\0"

-   "glSecondaryColorPointer\0"

-   "glSecondaryColorPointerEXT\0"

-   "\0"

-   /* _mesa_function_pool[11832]: VertexAttrib4fvARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib4fv\0"

-   "glVertexAttrib4fvARB\0"

-   "\0"

-   /* _mesa_function_pool[11875]: ColorPointerListIBM (dynamic) */

-   "iiipi\0"

-   "glColorPointerListIBM\0"

-   "\0"

-   /* _mesa_function_pool[11904]: GetActiveUniformARB (will be remapped) */

-   "iiipppp\0"

-   "glGetActiveUniform\0"

-   "glGetActiveUniformARB\0"

-   "\0"

-   /* _mesa_function_pool[11954]: ImageTransformParameteriHP (dynamic) */

-   "iii\0"

-   "glImageTransformParameteriHP\0"

-   "\0"

-   /* _mesa_function_pool[11988]: Normal3b (offset 52) */

-   "iii\0"

-   "glNormal3b\0"

-   "\0"

-   /* _mesa_function_pool[12004]: Normal3d (offset 54) */

-   "ddd\0"

-   "glNormal3d\0"

-   "\0"

-   /* _mesa_function_pool[12020]: Uniform1uiEXT (will be remapped) */

-   "ii\0"

-   "glUniform1uiEXT\0"

-   "glUniform1ui\0"

-   "\0"

-   /* _mesa_function_pool[12053]: Normal3f (offset 56) */

-   "fff\0"

-   "glNormal3f\0"

-   "\0"

-   /* _mesa_function_pool[12069]: MultiTexCoord1svARB (offset 383) */

-   "ip\0"

-   "glMultiTexCoord1sv\0"

-   "glMultiTexCoord1svARB\0"

-   "\0"

-   /* _mesa_function_pool[12114]: Indexi (offset 48) */

-   "i\0"

-   "glIndexi\0"

-   "\0"

-   /* _mesa_function_pool[12126]: EGLImageTargetTexture2DOES (will be remapped) */

-   "ip\0"

-   "glEGLImageTargetTexture2DOES\0"

-   "\0"

-   /* _mesa_function_pool[12159]: EndQueryARB (will be remapped) */

-   "i\0"

-   "glEndQuery\0"

-   "glEndQueryARB\0"

-   "\0"

-   /* _mesa_function_pool[12187]: DeleteFencesNV (will be remapped) */

-   "ip\0"

-   "glDeleteFencesNV\0"

-   "\0"

-   /* _mesa_function_pool[12208]: DeformationMap3dSGIX (dynamic) */

-   "iddiiddiiddiip\0"

-   "glDeformationMap3dSGIX\0"

-   "\0"

-   /* _mesa_function_pool[12247]: BindBufferRangeEXT (will be remapped) */

-   "iiiii\0"

-   "glBindBufferRangeEXT\0"

-   "glBindBufferRange\0"

-   "\0"

-   /* _mesa_function_pool[12293]: DepthMask (offset 211) */

-   "i\0"

-   "glDepthMask\0"

-   "\0"

-   /* _mesa_function_pool[12308]: IsShader (will be remapped) */

-   "i\0"

-   "glIsShader\0"

-   "\0"

-   /* _mesa_function_pool[12322]: Indexf (offset 46) */

-   "f\0"

-   "glIndexf\0"

-   "\0"

-   /* _mesa_function_pool[12334]: GetImageTransformParameterivHP (dynamic) */

-   "iip\0"

-   "glGetImageTransformParameterivHP\0"

-   "\0"

-   /* _mesa_function_pool[12372]: Indexd (offset 44) */

-   "d\0"

-   "glIndexd\0"

-   "\0"

-   /* _mesa_function_pool[12384]: GetMaterialiv (offset 270) */

-   "iip\0"

-   "glGetMaterialiv\0"

-   "\0"

-   /* _mesa_function_pool[12405]: StencilOp (offset 244) */

-   "iii\0"

-   "glStencilOp\0"

-   "\0"

-   /* _mesa_function_pool[12422]: WindowPos4ivMESA (will be remapped) */

-   "p\0"

-   "glWindowPos4ivMESA\0"

-   "\0"

-   /* _mesa_function_pool[12444]: FramebufferTextureLayer (dynamic) */

-   "iiiii\0"

-   "glFramebufferTextureLayerARB\0"

-   "\0"

-   /* _mesa_function_pool[12480]: MultiTexCoord3svARB (offset 399) */

-   "ip\0"

-   "glMultiTexCoord3sv\0"

-   "glMultiTexCoord3svARB\0"

-   "\0"

-   /* _mesa_function_pool[12525]: TexEnvfv (offset 185) */

-   "iip\0"

-   "glTexEnvfv\0"

-   "\0"

-   /* _mesa_function_pool[12541]: MultiTexCoord4iARB (offset 404) */

-   "iiiii\0"

-   "glMultiTexCoord4i\0"

-   "glMultiTexCoord4iARB\0"

-   "\0"

-   /* _mesa_function_pool[12587]: Indexs (offset 50) */

-   "i\0"

-   "glIndexs\0"

-   "\0"

-   /* _mesa_function_pool[12599]: Binormal3ivEXT (dynamic) */

-   "p\0"

-   "glBinormal3ivEXT\0"

-   "\0"

-   /* _mesa_function_pool[12619]: ResizeBuffersMESA (will be remapped) */

-   "\0"

-   "glResizeBuffersMESA\0"

-   "\0"

-   /* _mesa_function_pool[12641]: BlendFuncSeparateiARB (will be remapped) */

-   "iiiii\0"

-   "glBlendFuncSeparateiARB\0"

-   "\0"

-   /* _mesa_function_pool[12672]: GetUniformivARB (will be remapped) */

-   "iip\0"

-   "glGetUniformiv\0"

-   "glGetUniformivARB\0"

-   "\0"

-   /* _mesa_function_pool[12710]: PixelTexGenParameteriSGIS (will be remapped) */

-   "ii\0"

-   "glPixelTexGenParameteriSGIS\0"

-   "\0"

-   /* _mesa_function_pool[12742]: VertexPointervINTEL (dynamic) */

-   "iip\0"

-   "glVertexPointervINTEL\0"

-   "\0"

-   /* _mesa_function_pool[12769]: Vertex2i (offset 130) */

-   "ii\0"

-   "glVertex2i\0"

-   "\0"

-   /* _mesa_function_pool[12784]: LoadMatrixf (offset 291) */

-   "p\0"

-   "glLoadMatrixf\0"

-   "\0"

-   /* _mesa_function_pool[12801]: VertexAttribI1uivEXT (will be remapped) */

-   "ip\0"

-   "glVertexAttribI1uivEXT\0"

-   "glVertexAttribI1uiv\0"

-   "\0"

-   /* _mesa_function_pool[12848]: Vertex2f (offset 128) */

-   "ff\0"

-   "glVertex2f\0"

-   "\0"

-   /* _mesa_function_pool[12863]: ReplacementCodeuiColor4fNormal3fVertex3fvSUN (dynamic) */

-   "pppp\0"

-   "glReplacementCodeuiColor4fNormal3fVertex3fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[12916]: Color4bv (offset 26) */

-   "p\0"

-   "glColor4bv\0"

-   "\0"

-   /* _mesa_function_pool[12930]: VertexPointer (offset 321) */

-   "iiip\0"

-   "glVertexPointer\0"

-   "\0"

-   /* _mesa_function_pool[12952]: SecondaryColor3uiEXT (will be remapped) */

-   "iii\0"

-   "glSecondaryColor3ui\0"

-   "glSecondaryColor3uiEXT\0"

-   "\0"

-   /* _mesa_function_pool[13000]: StartInstrumentsSGIX (dynamic) */

-   "\0"

-   "glStartInstrumentsSGIX\0"

-   "\0"

-   /* _mesa_function_pool[13025]: SecondaryColor3usvEXT (will be remapped) */

-   "p\0"

-   "glSecondaryColor3usv\0"

-   "glSecondaryColor3usvEXT\0"

-   "\0"

-   /* _mesa_function_pool[13073]: VertexAttrib2fvNV (will be remapped) */

-   "ip\0"

-   "glVertexAttrib2fvNV\0"

-   "\0"

-   /* _mesa_function_pool[13097]: ProgramLocalParameter4dvARB (will be remapped) */

-   "iip\0"

-   "glProgramLocalParameter4dvARB\0"

-   "\0"

-   /* _mesa_function_pool[13132]: DeleteLists (offset 4) */

-   "ii\0"

-   "glDeleteLists\0"

-   "\0"

-   /* _mesa_function_pool[13150]: LogicOp (offset 242) */

-   "i\0"

-   "glLogicOp\0"

-   "\0"

-   /* _mesa_function_pool[13163]: MatrixIndexuivARB (dynamic) */

-   "ip\0"

-   "glMatrixIndexuivARB\0"

-   "\0"

-   /* _mesa_function_pool[13187]: Vertex2s (offset 132) */

-   "ii\0"

-   "glVertex2s\0"

-   "\0"

-   /* _mesa_function_pool[13202]: RenderbufferStorageMultisample (will be remapped) */

-   "iiiii\0"

-   "glRenderbufferStorageMultisample\0"

-   "glRenderbufferStorageMultisampleEXT\0"

-   "\0"

-   /* _mesa_function_pool[13278]: TexCoord4fv (offset 121) */

-   "p\0"

-   "glTexCoord4fv\0"

-   "\0"

-   /* _mesa_function_pool[13295]: Tangent3sEXT (dynamic) */

-   "iii\0"

-   "glTangent3sEXT\0"

-   "\0"

-   /* _mesa_function_pool[13315]: GlobalAlphaFactorfSUN (dynamic) */

-   "f\0"

-   "glGlobalAlphaFactorfSUN\0"

-   "\0"

-   /* _mesa_function_pool[13342]: MultiTexCoord3iARB (offset 396) */

-   "iiii\0"

-   "glMultiTexCoord3i\0"

-   "glMultiTexCoord3iARB\0"

-   "\0"

-   /* _mesa_function_pool[13387]: IsProgram (will be remapped) */

-   "i\0"

-   "glIsProgram\0"

-   "\0"

-   /* _mesa_function_pool[13402]: TexCoordPointerListIBM (dynamic) */

-   "iiipi\0"

-   "glTexCoordPointerListIBM\0"

-   "\0"

-   /* _mesa_function_pool[13434]: VertexAttribI4svEXT (will be remapped) */

-   "ip\0"

-   "glVertexAttribI4svEXT\0"

-   "glVertexAttribI4sv\0"

-   "\0"

-   /* _mesa_function_pool[13479]: GlobalAlphaFactorusSUN (dynamic) */

-   "i\0"

-   "glGlobalAlphaFactorusSUN\0"

-   "\0"

-   /* _mesa_function_pool[13507]: VertexAttrib2dvNV (will be remapped) */

-   "ip\0"

-   "glVertexAttrib2dvNV\0"

-   "\0"

-   /* _mesa_function_pool[13531]: FramebufferRenderbufferEXT (will be remapped) */

-   "iiii\0"

-   "glFramebufferRenderbuffer\0"

-   "glFramebufferRenderbufferEXT\0"

-   "\0"

-   /* _mesa_function_pool[13592]: ClearBufferuiv (will be remapped) */

-   "iip\0"

-   "glClearBufferuiv\0"

-   "\0"

-   /* _mesa_function_pool[13614]: VertexAttrib1dvNV (will be remapped) */

-   "ip\0"

-   "glVertexAttrib1dvNV\0"

-   "\0"

-   /* _mesa_function_pool[13638]: GenTextures (offset 328) */

-   "ip\0"

-   "glGenTextures\0"

-   "glGenTexturesEXT\0"

-   "\0"

-   /* _mesa_function_pool[13673]: FramebufferTextureARB (will be remapped) */

-   "iiii\0"

-   "glFramebufferTextureARB\0"

-   "\0"

-   /* _mesa_function_pool[13703]: SetFenceNV (will be remapped) */

-   "ii\0"

-   "glSetFenceNV\0"

-   "\0"

-   /* _mesa_function_pool[13720]: FramebufferTexture1DEXT (will be remapped) */

-   "iiiii\0"

-   "glFramebufferTexture1D\0"

-   "glFramebufferTexture1DEXT\0"

-   "\0"

-   /* _mesa_function_pool[13776]: GetCombinerOutputParameterivNV (will be remapped) */

-   "iiip\0"

-   "glGetCombinerOutputParameterivNV\0"

-   "\0"

-   /* _mesa_function_pool[13815]: PixelTexGenParameterivSGIS (will be remapped) */

-   "ip\0"

-   "glPixelTexGenParameterivSGIS\0"

-   "\0"

-   /* _mesa_function_pool[13848]: TextureNormalEXT (dynamic) */

-   "i\0"

-   "glTextureNormalEXT\0"

-   "\0"

-   /* _mesa_function_pool[13870]: IndexPointerListIBM (dynamic) */

-   "iipi\0"

-   "glIndexPointerListIBM\0"

-   "\0"

-   /* _mesa_function_pool[13898]: WeightfvARB (dynamic) */

-   "ip\0"

-   "glWeightfvARB\0"

-   "\0"

-   /* _mesa_function_pool[13916]: RasterPos2sv (offset 69) */

-   "p\0"

-   "glRasterPos2sv\0"

-   "\0"

-   /* _mesa_function_pool[13934]: Color4ubv (offset 36) */

-   "p\0"

-   "glColor4ubv\0"

-   "\0"

-   /* _mesa_function_pool[13949]: DrawBuffer (offset 202) */

-   "i\0"

-   "glDrawBuffer\0"

-   "\0"

-   /* _mesa_function_pool[13965]: TexCoord2fv (offset 105) */

-   "p\0"

-   "glTexCoord2fv\0"

-   "\0"

-   /* _mesa_function_pool[13982]: WindowPos4fMESA (will be remapped) */

-   "ffff\0"

-   "glWindowPos4fMESA\0"

-   "\0"

-   /* _mesa_function_pool[14006]: TexCoord1sv (offset 101) */

-   "p\0"

-   "glTexCoord1sv\0"

-   "\0"

-   /* _mesa_function_pool[14023]: WindowPos3dvMESA (will be remapped) */

-   "p\0"

-   "glWindowPos3dv\0"

-   "glWindowPos3dvARB\0"

-   "glWindowPos3dvMESA\0"

-   "\0"

-   /* _mesa_function_pool[14078]: DepthFunc (offset 245) */

-   "i\0"

-   "glDepthFunc\0"

-   "\0"

-   /* _mesa_function_pool[14093]: PixelMapusv (offset 253) */

-   "iip\0"

-   "glPixelMapusv\0"

-   "\0"

-   /* _mesa_function_pool[14112]: GetQueryObjecti64vEXT (will be remapped) */

-   "iip\0"

-   "glGetQueryObjecti64vEXT\0"

-   "\0"

-   /* _mesa_function_pool[14141]: MultiTexCoord1dARB (offset 376) */

-   "id\0"

-   "glMultiTexCoord1d\0"

-   "glMultiTexCoord1dARB\0"

-   "\0"

-   /* _mesa_function_pool[14184]: PointParameterivNV (will be remapped) */

-   "ip\0"

-   "glPointParameteriv\0"

-   "glPointParameterivNV\0"

-   "\0"

-   /* _mesa_function_pool[14228]: BlendFunc (offset 241) */

-   "ii\0"

-   "glBlendFunc\0"

-   "\0"

-   /* _mesa_function_pool[14244]: EndTransformFeedbackEXT (will be remapped) */

-   "\0"

-   "glEndTransformFeedbackEXT\0"

-   "glEndTransformFeedback\0"

-   "\0"

-   /* _mesa_function_pool[14295]: Uniform2fvARB (will be remapped) */

-   "iip\0"

-   "glUniform2fv\0"

-   "glUniform2fvARB\0"

-   "\0"

-   /* _mesa_function_pool[14329]: BufferParameteriAPPLE (will be remapped) */

-   "iii\0"

-   "glBufferParameteriAPPLE\0"

-   "\0"

-   /* _mesa_function_pool[14358]: MultiTexCoord3dvARB (offset 393) */

-   "ip\0"

-   "glMultiTexCoord3dv\0"

-   "glMultiTexCoord3dvARB\0"

-   "\0"

-   /* _mesa_function_pool[14403]: ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (dynamic) */

-   "pppp\0"

-   "glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[14459]: DeleteObjectARB (will be remapped) */

-   "i\0"

-   "glDeleteObjectARB\0"

-   "\0"

-   /* _mesa_function_pool[14480]: GetShaderPrecisionFormat (will be remapped) */

-   "iipp\0"

-   "glGetShaderPrecisionFormat\0"

-   "\0"

-   /* _mesa_function_pool[14513]: MatrixIndexPointerARB (dynamic) */

-   "iiip\0"

-   "glMatrixIndexPointerARB\0"

-   "\0"

-   /* _mesa_function_pool[14543]: ProgramNamedParameter4dvNV (will be remapped) */

-   "iipp\0"

-   "glProgramNamedParameter4dvNV\0"

-   "\0"

-   /* _mesa_function_pool[14578]: Tangent3fvEXT (dynamic) */

-   "p\0"

-   "glTangent3fvEXT\0"

-   "\0"

-   /* _mesa_function_pool[14597]: Flush (offset 217) */

-   "\0"

-   "glFlush\0"

-   "\0"

-   /* _mesa_function_pool[14607]: Color4uiv (offset 38) */

-   "p\0"

-   "glColor4uiv\0"

-   "\0"

-   /* _mesa_function_pool[14622]: VertexAttribI4iEXT (will be remapped) */

-   "iiiii\0"

-   "glVertexAttribI4iEXT\0"

-   "glVertexAttribI4i\0"

-   "\0"

-   /* _mesa_function_pool[14668]: GenVertexArrays (will be remapped) */

-   "ip\0"

-   "glGenVertexArrays\0"

-   "\0"

-   /* _mesa_function_pool[14690]: Uniform3uivEXT (will be remapped) */

-   "iip\0"

-   "glUniform3uivEXT\0"

-   "glUniform3uiv\0"

-   "\0"

-   /* _mesa_function_pool[14726]: RasterPos3sv (offset 77) */

-   "p\0"

-   "glRasterPos3sv\0"

-   "\0"

-   /* _mesa_function_pool[14744]: BindFramebufferEXT (will be remapped) */

-   "ii\0"

-   "glBindFramebuffer\0"

-   "glBindFramebufferEXT\0"

-   "\0"

-   /* _mesa_function_pool[14787]: ReferencePlaneSGIX (dynamic) */

-   "p\0"

-   "glReferencePlaneSGIX\0"

-   "\0"

-   /* _mesa_function_pool[14811]: PushAttrib (offset 219) */

-   "i\0"

-   "glPushAttrib\0"

-   "\0"

-   /* _mesa_function_pool[14827]: RasterPos2i (offset 66) */

-   "ii\0"

-   "glRasterPos2i\0"

-   "\0"

-   /* _mesa_function_pool[14845]: ValidateProgramARB (will be remapped) */

-   "i\0"

-   "glValidateProgram\0"

-   "glValidateProgramARB\0"

-   "\0"

-   /* _mesa_function_pool[14887]: TexParameteriv (offset 181) */

-   "iip\0"

-   "glTexParameteriv\0"

-   "\0"

-   /* _mesa_function_pool[14909]: UnlockArraysEXT (will be remapped) */

-   "\0"

-   "glUnlockArraysEXT\0"

-   "\0"

-   /* _mesa_function_pool[14929]: TexCoord2fColor3fVertex3fSUN (dynamic) */

-   "ffffffff\0"

-   "glTexCoord2fColor3fVertex3fSUN\0"

-   "\0"

-   /* _mesa_function_pool[14970]: WindowPos3fvMESA (will be remapped) */

-   "p\0"

-   "glWindowPos3fv\0"

-   "glWindowPos3fvARB\0"

-   "glWindowPos3fvMESA\0"

-   "\0"

-   /* _mesa_function_pool[15025]: RasterPos2f (offset 64) */

-   "ff\0"

-   "glRasterPos2f\0"

-   "\0"

-   /* _mesa_function_pool[15043]: VertexAttrib1svNV (will be remapped) */

-   "ip\0"

-   "glVertexAttrib1svNV\0"

-   "\0"

-   /* _mesa_function_pool[15067]: RasterPos2d (offset 62) */

-   "dd\0"

-   "glRasterPos2d\0"

-   "\0"

-   /* _mesa_function_pool[15085]: RasterPos3fv (offset 73) */

-   "p\0"

-   "glRasterPos3fv\0"

-   "\0"

-   /* _mesa_function_pool[15103]: CopyTexSubImage3D (offset 373) */

-   "iiiiiiiii\0"

-   "glCopyTexSubImage3D\0"

-   "glCopyTexSubImage3DEXT\0"

-   "\0"

-   /* _mesa_function_pool[15157]: VertexAttrib2dARB (will be remapped) */

-   "idd\0"

-   "glVertexAttrib2d\0"

-   "glVertexAttrib2dARB\0"

-   "\0"

-   /* _mesa_function_pool[15199]: Color4ub (offset 35) */

-   "iiii\0"

-   "glColor4ub\0"

-   "\0"

-   /* _mesa_function_pool[15216]: GetInteger64v (will be remapped) */

-   "ip\0"

-   "glGetInteger64v\0"

-   "\0"

-   /* _mesa_function_pool[15236]: TextureColorMaskSGIS (dynamic) */

-   "iiii\0"

-   "glTextureColorMaskSGIS\0"

-   "\0"

-   /* _mesa_function_pool[15265]: RasterPos2s (offset 68) */

-   "ii\0"

-   "glRasterPos2s\0"

-   "\0"

-   /* _mesa_function_pool[15283]: GetColorTable (offset 343) */

-   "iiip\0"

-   "glGetColorTable\0"

-   "glGetColorTableSGI\0"

-   "glGetColorTableEXT\0"

-   "\0"

-   /* _mesa_function_pool[15343]: SelectBuffer (offset 195) */

-   "ip\0"

-   "glSelectBuffer\0"

-   "\0"

-   /* _mesa_function_pool[15362]: Indexiv (offset 49) */

-   "p\0"

-   "glIndexiv\0"

-   "\0"

-   /* _mesa_function_pool[15375]: TexCoord3i (offset 114) */

-   "iii\0"

-   "glTexCoord3i\0"

-   "\0"

-   /* _mesa_function_pool[15393]: CopyColorTable (offset 342) */

-   "iiiii\0"

-   "glCopyColorTable\0"

-   "glCopyColorTableSGI\0"

-   "\0"

-   /* _mesa_function_pool[15437]: GetHistogramParameterfv (offset 362) */

-   "iip\0"

-   "glGetHistogramParameterfv\0"

-   "glGetHistogramParameterfvEXT\0"

-   "\0"

-   /* _mesa_function_pool[15497]: Frustum (offset 289) */

-   "dddddd\0"

-   "glFrustum\0"

-   "\0"

-   /* _mesa_function_pool[15515]: GetString (offset 275) */

-   "i\0"

-   "glGetString\0"

-   "\0"

-   /* _mesa_function_pool[15530]: ColorPointervINTEL (dynamic) */

-   "iip\0"

-   "glColorPointervINTEL\0"

-   "\0"

-   /* _mesa_function_pool[15556]: TexEnvf (offset 184) */

-   "iif\0"

-   "glTexEnvf\0"

-   "\0"

-   /* _mesa_function_pool[15571]: TexCoord3d (offset 110) */

-   "ddd\0"

-   "glTexCoord3d\0"

-   "\0"

-   /* _mesa_function_pool[15589]: AlphaFragmentOp1ATI (will be remapped) */

-   "iiiiii\0"

-   "glAlphaFragmentOp1ATI\0"

-   "\0"

-   /* _mesa_function_pool[15619]: TexCoord3f (offset 112) */

-   "fff\0"

-   "glTexCoord3f\0"

-   "\0"

-   /* _mesa_function_pool[15637]: MultiTexCoord3ivARB (offset 397) */

-   "ip\0"

-   "glMultiTexCoord3iv\0"

-   "glMultiTexCoord3ivARB\0"

-   "\0"

-   /* _mesa_function_pool[15682]: MultiTexCoord2sARB (offset 390) */

-   "iii\0"

-   "glMultiTexCoord2s\0"

-   "glMultiTexCoord2sARB\0"

-   "\0"

-   /* _mesa_function_pool[15726]: VertexAttrib1dvARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib1dv\0"

-   "glVertexAttrib1dvARB\0"

-   "\0"

-   /* _mesa_function_pool[15769]: DeleteTextures (offset 327) */

-   "ip\0"

-   "glDeleteTextures\0"

-   "glDeleteTexturesEXT\0"

-   "\0"

-   /* _mesa_function_pool[15810]: TexCoordPointerEXT (will be remapped) */

-   "iiiip\0"

-   "glTexCoordPointerEXT\0"

-   "\0"

-   /* _mesa_function_pool[15838]: TexSubImage4DSGIS (dynamic) */

-   "iiiiiiiiiiiip\0"

-   "glTexSubImage4DSGIS\0"

-   "\0"

-   /* _mesa_function_pool[15873]: TexCoord3s (offset 116) */

-   "iii\0"

-   "glTexCoord3s\0"

-   "\0"

-   /* _mesa_function_pool[15891]: GetTexLevelParameteriv (offset 285) */

-   "iiip\0"

-   "glGetTexLevelParameteriv\0"

-   "\0"

-   /* _mesa_function_pool[15922]: CombinerStageParameterfvNV (dynamic) */

-   "iip\0"

-   "glCombinerStageParameterfvNV\0"

-   "\0"

-   /* _mesa_function_pool[15956]: StopInstrumentsSGIX (dynamic) */

-   "i\0"

-   "glStopInstrumentsSGIX\0"

-   "\0"

-   /* _mesa_function_pool[15981]: TexCoord4fColor4fNormal3fVertex4fSUN (dynamic) */

-   "fffffffffffffff\0"

-   "glTexCoord4fColor4fNormal3fVertex4fSUN\0"

-   "\0"

-   /* _mesa_function_pool[16037]: ClearAccum (offset 204) */

-   "ffff\0"

-   "glClearAccum\0"

-   "\0"

-   /* _mesa_function_pool[16056]: DeformSGIX (dynamic) */

-   "i\0"

-   "glDeformSGIX\0"

-   "\0"

-   /* _mesa_function_pool[16072]: GetVertexAttribfvARB (will be remapped) */

-   "iip\0"

-   "glGetVertexAttribfv\0"

-   "glGetVertexAttribfvARB\0"

-   "\0"

-   /* _mesa_function_pool[16120]: SecondaryColor3ivEXT (will be remapped) */

-   "p\0"

-   "glSecondaryColor3iv\0"

-   "glSecondaryColor3ivEXT\0"

-   "\0"

-   /* _mesa_function_pool[16166]: TexCoord4iv (offset 123) */

-   "p\0"

-   "glTexCoord4iv\0"

-   "\0"

-   /* _mesa_function_pool[16183]: VertexAttribI4uiEXT (will be remapped) */

-   "iiiii\0"

-   "glVertexAttribI4uiEXT\0"

-   "glVertexAttribI4ui\0"

-   "\0"

-   /* _mesa_function_pool[16231]: GetFragmentMaterialfvSGIX (dynamic) */

-   "iip\0"

-   "glGetFragmentMaterialfvSGIX\0"

-   "\0"

-   /* _mesa_function_pool[16264]: UniformMatrix4x2fv (will be remapped) */

-   "iiip\0"

-   "glUniformMatrix4x2fv\0"

-   "\0"

-   /* _mesa_function_pool[16291]: GetDetailTexFuncSGIS (dynamic) */

-   "ip\0"

-   "glGetDetailTexFuncSGIS\0"

-   "\0"

-   /* _mesa_function_pool[16318]: GetCombinerStageParameterfvNV (dynamic) */

-   "iip\0"

-   "glGetCombinerStageParameterfvNV\0"

-   "\0"

-   /* _mesa_function_pool[16355]: PolygonOffset (offset 319) */

-   "ff\0"

-   "glPolygonOffset\0"

-   "\0"

-   /* _mesa_function_pool[16375]: BindVertexArray (will be remapped) */

-   "i\0"

-   "glBindVertexArray\0"

-   "\0"

-   /* _mesa_function_pool[16396]: Color4ubVertex2fvSUN (dynamic) */

-   "pp\0"

-   "glColor4ubVertex2fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[16423]: Rectd (offset 86) */

-   "dddd\0"

-   "glRectd\0"

-   "\0"

-   /* _mesa_function_pool[16437]: TexFilterFuncSGIS (dynamic) */

-   "iiip\0"

-   "glTexFilterFuncSGIS\0"

-   "\0"

-   /* _mesa_function_pool[16463]: TextureBarrierNV (will be remapped) */

-   "\0"

-   "glTextureBarrierNV\0"

-   "\0"

-   /* _mesa_function_pool[16484]: VertexAttribI4ubvEXT (will be remapped) */

-   "ip\0"

-   "glVertexAttribI4ubvEXT\0"

-   "glVertexAttribI4ubv\0"

-   "\0"

-   /* _mesa_function_pool[16531]: GetAttribLocationARB (will be remapped) */

-   "ip\0"

-   "glGetAttribLocation\0"

-   "glGetAttribLocationARB\0"

-   "\0"

-   /* _mesa_function_pool[16578]: RasterPos3i (offset 74) */

-   "iii\0"

-   "glRasterPos3i\0"

-   "\0"

-   /* _mesa_function_pool[16597]: VertexAttrib4ubvARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib4ubv\0"

-   "glVertexAttrib4ubvARB\0"

-   "\0"

-   /* _mesa_function_pool[16642]: DetailTexFuncSGIS (dynamic) */

-   "iip\0"

-   "glDetailTexFuncSGIS\0"

-   "\0"

-   /* _mesa_function_pool[16667]: Normal3fVertex3fSUN (dynamic) */

-   "ffffff\0"

-   "glNormal3fVertex3fSUN\0"

-   "\0"

-   /* _mesa_function_pool[16697]: CopyTexImage2D (offset 324) */

-   "iiiiiiii\0"

-   "glCopyTexImage2D\0"

-   "glCopyTexImage2DEXT\0"

-   "\0"

-   /* _mesa_function_pool[16744]: GetBufferPointervARB (will be remapped) */

-   "iip\0"

-   "glGetBufferPointerv\0"

-   "glGetBufferPointervARB\0"

-   "\0"

-   /* _mesa_function_pool[16792]: ProgramEnvParameter4fARB (will be remapped) */

-   "iiffff\0"

-   "glProgramEnvParameter4fARB\0"

-   "glProgramParameter4fNV\0"

-   "\0"

-   /* _mesa_function_pool[16850]: Uniform3ivARB (will be remapped) */

-   "iip\0"

-   "glUniform3iv\0"

-   "glUniform3ivARB\0"

-   "\0"

-   /* _mesa_function_pool[16884]: Lightfv (offset 160) */

-   "iip\0"

-   "glLightfv\0"

-   "\0"

-   /* _mesa_function_pool[16899]: PrimitiveRestartIndexNV (will be remapped) */

-   "i\0"

-   "glPrimitiveRestartIndexNV\0"

-   "glPrimitiveRestartIndex\0"

-   "\0"

-   /* _mesa_function_pool[16952]: ClearDepth (offset 208) */

-   "d\0"

-   "glClearDepth\0"

-   "\0"

-   /* _mesa_function_pool[16968]: GetFenceivNV (will be remapped) */

-   "iip\0"

-   "glGetFenceivNV\0"

-   "\0"

-   /* _mesa_function_pool[16988]: WindowPos4dvMESA (will be remapped) */

-   "p\0"

-   "glWindowPos4dvMESA\0"

-   "\0"

-   /* _mesa_function_pool[17010]: ColorSubTable (offset 346) */

-   "iiiiip\0"

-   "glColorSubTable\0"

-   "glColorSubTableEXT\0"

-   "\0"

-   /* _mesa_function_pool[17053]: Color4fv (offset 30) */

-   "p\0"

-   "glColor4fv\0"

-   "\0"

-   /* _mesa_function_pool[17067]: MultiTexCoord4ivARB (offset 405) */

-   "ip\0"

-   "glMultiTexCoord4iv\0"

-   "glMultiTexCoord4ivARB\0"

-   "\0"

-   /* _mesa_function_pool[17112]: ProgramLocalParameters4fvEXT (will be remapped) */

-   "iiip\0"

-   "glProgramLocalParameters4fvEXT\0"

-   "\0"

-   /* _mesa_function_pool[17149]: ColorPointer (offset 308) */

-   "iiip\0"

-   "glColorPointer\0"

-   "\0"

-   /* _mesa_function_pool[17170]: Rects (offset 92) */

-   "iiii\0"

-   "glRects\0"

-   "\0"

-   /* _mesa_function_pool[17184]: GetMapAttribParameterfvNV (dynamic) */

-   "iiip\0"

-   "glGetMapAttribParameterfvNV\0"

-   "\0"

-   /* _mesa_function_pool[17218]: CreateShaderProgramEXT (will be remapped) */

-   "ip\0"

-   "glCreateShaderProgramEXT\0"

-   "\0"

-   /* _mesa_function_pool[17247]: ActiveProgramEXT (will be remapped) */

-   "i\0"

-   "glActiveProgramEXT\0"

-   "\0"

-   /* _mesa_function_pool[17269]: Lightiv (offset 162) */

-   "iip\0"

-   "glLightiv\0"

-   "\0"

-   /* _mesa_function_pool[17284]: VertexAttrib4sARB (will be remapped) */

-   "iiiii\0"

-   "glVertexAttrib4s\0"

-   "glVertexAttrib4sARB\0"

-   "\0"

-   /* _mesa_function_pool[17328]: GetQueryObjectuivARB (will be remapped) */

-   "iip\0"

-   "glGetQueryObjectuiv\0"

-   "glGetQueryObjectuivARB\0"

-   "\0"

-   /* _mesa_function_pool[17376]: GetTexParameteriv (offset 283) */

-   "iip\0"

-   "glGetTexParameteriv\0"

-   "\0"

-   /* _mesa_function_pool[17401]: MapParameterivNV (dynamic) */

-   "iip\0"

-   "glMapParameterivNV\0"

-   "\0"

-   /* _mesa_function_pool[17425]: GenRenderbuffersEXT (will be remapped) */

-   "ip\0"

-   "glGenRenderbuffers\0"

-   "glGenRenderbuffersEXT\0"

-   "\0"

-   /* _mesa_function_pool[17470]: ClearBufferfv (will be remapped) */

-   "iip\0"

-   "glClearBufferfv\0"

-   "\0"

-   /* _mesa_function_pool[17491]: VertexAttrib2dvARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib2dv\0"

-   "glVertexAttrib2dvARB\0"

-   "\0"

-   /* _mesa_function_pool[17534]: EdgeFlagPointerEXT (will be remapped) */

-   "iip\0"

-   "glEdgeFlagPointerEXT\0"

-   "\0"

-   /* _mesa_function_pool[17560]: VertexAttribs2svNV (will be remapped) */

-   "iip\0"

-   "glVertexAttribs2svNV\0"

-   "\0"

-   /* _mesa_function_pool[17586]: WeightbvARB (dynamic) */

-   "ip\0"

-   "glWeightbvARB\0"

-   "\0"

-   /* _mesa_function_pool[17604]: VertexAttrib2fvARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib2fv\0"

-   "glVertexAttrib2fvARB\0"

-   "\0"

-   /* _mesa_function_pool[17647]: GetBufferParameterivARB (will be remapped) */

-   "iip\0"

-   "glGetBufferParameteriv\0"

-   "glGetBufferParameterivARB\0"

-   "\0"

-   /* _mesa_function_pool[17701]: Rectdv (offset 87) */

-   "pp\0"

-   "glRectdv\0"

-   "\0"

-   /* _mesa_function_pool[17714]: ListParameteriSGIX (dynamic) */

-   "iii\0"

-   "glListParameteriSGIX\0"

-   "\0"

-   /* _mesa_function_pool[17740]: BlendEquationiARB (will be remapped) */

-   "ii\0"

-   "glBlendEquationiARB\0"

-   "\0"

-   /* _mesa_function_pool[17764]: ReplacementCodeuiColor4fNormal3fVertex3fSUN (dynamic) */

-   "iffffffffff\0"

-   "glReplacementCodeuiColor4fNormal3fVertex3fSUN\0"

-   "\0"

-   /* _mesa_function_pool[17823]: InstrumentsBufferSGIX (dynamic) */

-   "ip\0"

-   "glInstrumentsBufferSGIX\0"

-   "\0"

-   /* _mesa_function_pool[17851]: VertexAttrib4NivARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib4Niv\0"

-   "glVertexAttrib4NivARB\0"

-   "\0"

-   /* _mesa_function_pool[17896]: DrawArraysInstancedARB (will be remapped) */

-   "iiii\0"

-   "glDrawArraysInstancedARB\0"

-   "glDrawArraysInstancedEXT\0"

-   "glDrawArraysInstanced\0"

-   "\0"

-   /* _mesa_function_pool[17974]: GetAttachedShaders (will be remapped) */

-   "iipp\0"

-   "glGetAttachedShaders\0"

-   "\0"

-   /* _mesa_function_pool[18001]: GenVertexArraysAPPLE (will be remapped) */

-   "ip\0"

-   "glGenVertexArraysAPPLE\0"

-   "\0"

-   /* _mesa_function_pool[18028]: ClearBufferfi (will be remapped) */

-   "iifi\0"

-   "glClearBufferfi\0"

-   "\0"

-   /* _mesa_function_pool[18050]: Materialiv (offset 172) */

-   "iip\0"

-   "glMaterialiv\0"

-   "\0"

-   /* _mesa_function_pool[18068]: PushClientAttrib (offset 335) */

-   "i\0"

-   "glPushClientAttrib\0"

-   "\0"

-   /* _mesa_function_pool[18090]: ProgramEnvParameters4fvEXT (will be remapped) */

-   "iiip\0"

-   "glProgramEnvParameters4fvEXT\0"

-   "\0"

-   /* _mesa_function_pool[18125]: TexCoord2fColor4fNormal3fVertex3fvSUN (dynamic) */

-   "pppp\0"

-   "glTexCoord2fColor4fNormal3fVertex3fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[18171]: WindowPos2iMESA (will be remapped) */

-   "ii\0"

-   "glWindowPos2i\0"

-   "glWindowPos2iARB\0"

-   "glWindowPos2iMESA\0"

-   "\0"

-   /* _mesa_function_pool[18224]: SampleMaskSGIS (will be remapped) */

-   "fi\0"

-   "glSampleMaskSGIS\0"

-   "glSampleMaskEXT\0"

-   "\0"

-   /* _mesa_function_pool[18261]: SecondaryColor3fvEXT (will be remapped) */

-   "p\0"

-   "glSecondaryColor3fv\0"

-   "glSecondaryColor3fvEXT\0"

-   "\0"

-   /* _mesa_function_pool[18307]: PolygonMode (offset 174) */

-   "ii\0"

-   "glPolygonMode\0"

-   "\0"

-   /* _mesa_function_pool[18325]: CompressedTexSubImage1DARB (will be remapped) */

-   "iiiiiip\0"

-   "glCompressedTexSubImage1D\0"

-   "glCompressedTexSubImage1DARB\0"

-   "\0"

-   /* _mesa_function_pool[18389]: VertexAttribI1iEXT (will be remapped) */

-   "ii\0"

-   "glVertexAttribI1iEXT\0"

-   "glVertexAttribI1i\0"

-   "\0"

-   /* _mesa_function_pool[18432]: GetVertexAttribivNV (will be remapped) */

-   "iip\0"

-   "glGetVertexAttribivNV\0"

-   "\0"

-   /* _mesa_function_pool[18459]: GetProgramStringARB (will be remapped) */

-   "iip\0"

-   "glGetProgramStringARB\0"

-   "\0"

-   /* _mesa_function_pool[18486]: VertexAttribIPointerEXT (will be remapped) */

-   "iiiip\0"

-   "glVertexAttribIPointerEXT\0"

-   "glVertexAttribIPointer\0"

-   "\0"

-   /* _mesa_function_pool[18542]: TexBumpParameterfvATI (will be remapped) */

-   "ip\0"

-   "glTexBumpParameterfvATI\0"

-   "\0"

-   /* _mesa_function_pool[18570]: CompileShaderARB (will be remapped) */

-   "i\0"

-   "glCompileShader\0"

-   "glCompileShaderARB\0"

-   "\0"

-   /* _mesa_function_pool[18608]: DeleteShader (will be remapped) */

-   "i\0"

-   "glDeleteShader\0"

-   "\0"

-   /* _mesa_function_pool[18626]: DisableClientState (offset 309) */

-   "i\0"

-   "glDisableClientState\0"

-   "\0"

-   /* _mesa_function_pool[18650]: TexGeni (offset 192) */

-   "iii\0"

-   "glTexGeni\0"

-   "\0"

-   /* _mesa_function_pool[18665]: TexGenf (offset 190) */

-   "iif\0"

-   "glTexGenf\0"

-   "\0"

-   /* _mesa_function_pool[18680]: Uniform3fARB (will be remapped) */

-   "ifff\0"

-   "glUniform3f\0"

-   "glUniform3fARB\0"

-   "\0"

-   /* _mesa_function_pool[18713]: TexGend (offset 188) */

-   "iid\0"

-   "glTexGend\0"

-   "\0"

-   /* _mesa_function_pool[18728]: ListParameterfvSGIX (dynamic) */

-   "iip\0"

-   "glListParameterfvSGIX\0"

-   "\0"

-   /* _mesa_function_pool[18755]: GetPolygonStipple (offset 274) */

-   "p\0"

-   "glGetPolygonStipple\0"

-   "\0"

-   /* _mesa_function_pool[18778]: Tangent3dvEXT (dynamic) */

-   "p\0"

-   "glTangent3dvEXT\0"

-   "\0"

-   /* _mesa_function_pool[18797]: BindBufferOffsetEXT (will be remapped) */

-   "iiii\0"

-   "glBindBufferOffsetEXT\0"

-   "\0"

-   /* _mesa_function_pool[18825]: WindowPos3sMESA (will be remapped) */

-   "iii\0"

-   "glWindowPos3s\0"

-   "glWindowPos3sARB\0"

-   "glWindowPos3sMESA\0"

-   "\0"

-   /* _mesa_function_pool[18879]: VertexAttrib2svNV (will be remapped) */

-   "ip\0"

-   "glVertexAttrib2svNV\0"

-   "\0"

-   /* _mesa_function_pool[18903]: DisableIndexedEXT (will be remapped) */

-   "ii\0"

-   "glDisableIndexedEXT\0"

-   "glDisablei\0"

-   "\0"

-   /* _mesa_function_pool[18938]: BindBufferBaseEXT (will be remapped) */

-   "iii\0"

-   "glBindBufferBaseEXT\0"

-   "glBindBufferBase\0"

-   "\0"

-   /* _mesa_function_pool[18980]: TexCoord2fVertex3fvSUN (dynamic) */

-   "pp\0"

-   "glTexCoord2fVertex3fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[19009]: WindowPos4sMESA (will be remapped) */

-   "iiii\0"

-   "glWindowPos4sMESA\0"

-   "\0"

-   /* _mesa_function_pool[19033]: VertexAttrib4NuivARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib4Nuiv\0"

-   "glVertexAttrib4NuivARB\0"

-   "\0"

-   /* _mesa_function_pool[19080]: ClientActiveTextureARB (offset 375) */

-   "i\0"

-   "glClientActiveTexture\0"

-   "glClientActiveTextureARB\0"

-   "\0"

-   /* _mesa_function_pool[19130]: PixelTexGenSGIX (will be remapped) */

-   "i\0"

-   "glPixelTexGenSGIX\0"

-   "\0"

-   /* _mesa_function_pool[19151]: ReplacementCodeusvSUN (dynamic) */

-   "p\0"

-   "glReplacementCodeusvSUN\0"

-   "\0"

-   /* _mesa_function_pool[19178]: Uniform4fARB (will be remapped) */

-   "iffff\0"

-   "glUniform4f\0"

-   "glUniform4fARB\0"

-   "\0"

-   /* _mesa_function_pool[19212]: Color4sv (offset 34) */

-   "p\0"

-   "glColor4sv\0"

-   "\0"

-   /* _mesa_function_pool[19226]: FlushMappedBufferRange (will be remapped) */

-   "iii\0"

-   "glFlushMappedBufferRange\0"

-   "\0"

-   /* _mesa_function_pool[19256]: IsProgramNV (will be remapped) */

-   "i\0"

-   "glIsProgramARB\0"

-   "glIsProgramNV\0"

-   "\0"

-   /* _mesa_function_pool[19288]: FlushMappedBufferRangeAPPLE (will be remapped) */

-   "iii\0"

-   "glFlushMappedBufferRangeAPPLE\0"

-   "\0"

-   /* _mesa_function_pool[19323]: PixelZoom (offset 246) */

-   "ff\0"

-   "glPixelZoom\0"

-   "\0"

-   /* _mesa_function_pool[19339]: ReplacementCodePointerSUN (dynamic) */

-   "iip\0"

-   "glReplacementCodePointerSUN\0"

-   "\0"

-   /* _mesa_function_pool[19372]: ProgramEnvParameter4dARB (will be remapped) */

-   "iidddd\0"

-   "glProgramEnvParameter4dARB\0"

-   "glProgramParameter4dNV\0"

-   "\0"

-   /* _mesa_function_pool[19430]: ColorTableParameterfv (offset 340) */

-   "iip\0"

-   "glColorTableParameterfv\0"

-   "glColorTableParameterfvSGI\0"

-   "\0"

-   /* _mesa_function_pool[19486]: FragmentLightModelfSGIX (dynamic) */

-   "if\0"

-   "glFragmentLightModelfSGIX\0"

-   "\0"

-   /* _mesa_function_pool[19516]: Binormal3bvEXT (dynamic) */

-   "p\0"

-   "glBinormal3bvEXT\0"

-   "\0"

-   /* _mesa_function_pool[19536]: PixelMapuiv (offset 252) */

-   "iip\0"

-   "glPixelMapuiv\0"

-   "\0"

-   /* _mesa_function_pool[19555]: Color3dv (offset 12) */

-   "p\0"

-   "glColor3dv\0"

-   "\0"

-   /* _mesa_function_pool[19569]: IsTexture (offset 330) */

-   "i\0"

-   "glIsTexture\0"

-   "glIsTextureEXT\0"

-   "\0"

-   /* _mesa_function_pool[19599]: VertexWeightfvEXT (dynamic) */

-   "p\0"

-   "glVertexWeightfvEXT\0"

-   "\0"

-   /* _mesa_function_pool[19622]: VertexAttrib1dARB (will be remapped) */

-   "id\0"

-   "glVertexAttrib1d\0"

-   "glVertexAttrib1dARB\0"

-   "\0"

-   /* _mesa_function_pool[19663]: ImageTransformParameterivHP (dynamic) */

-   "iip\0"

-   "glImageTransformParameterivHP\0"

-   "\0"

-   /* _mesa_function_pool[19698]: TexCoord4i (offset 122) */

-   "iiii\0"

-   "glTexCoord4i\0"

-   "\0"

-   /* _mesa_function_pool[19717]: DeleteQueriesARB (will be remapped) */

-   "ip\0"

-   "glDeleteQueries\0"

-   "glDeleteQueriesARB\0"

-   "\0"

-   /* _mesa_function_pool[19756]: Color4ubVertex2fSUN (dynamic) */

-   "iiiiff\0"

-   "glColor4ubVertex2fSUN\0"

-   "\0"

-   /* _mesa_function_pool[19786]: FragmentColorMaterialSGIX (dynamic) */

-   "ii\0"

-   "glFragmentColorMaterialSGIX\0"

-   "\0"

-   /* _mesa_function_pool[19818]: CurrentPaletteMatrixARB (dynamic) */

-   "i\0"

-   "glCurrentPaletteMatrixARB\0"

-   "\0"

-   /* _mesa_function_pool[19847]: GetMapdv (offset 266) */

-   "iip\0"

-   "glGetMapdv\0"

-   "\0"

-   /* _mesa_function_pool[19863]: ObjectPurgeableAPPLE (will be remapped) */

-   "iii\0"

-   "glObjectPurgeableAPPLE\0"

-   "\0"

-   /* _mesa_function_pool[19891]: GetStringi (will be remapped) */

-   "ii\0"

-   "glGetStringi\0"

-   "\0"

-   /* _mesa_function_pool[19908]: SamplePatternSGIS (will be remapped) */

-   "i\0"

-   "glSamplePatternSGIS\0"

-   "glSamplePatternEXT\0"

-   "\0"

-   /* _mesa_function_pool[19950]: PixelStoref (offset 249) */

-   "if\0"

-   "glPixelStoref\0"

-   "\0"

-   /* _mesa_function_pool[19968]: IsQueryARB (will be remapped) */

-   "i\0"

-   "glIsQuery\0"

-   "glIsQueryARB\0"

-   "\0"

-   /* _mesa_function_pool[19994]: ReplacementCodeuiColor4ubVertex3fSUN (dynamic) */

-   "iiiiifff\0"

-   "glReplacementCodeuiColor4ubVertex3fSUN\0"

-   "\0"

-   /* _mesa_function_pool[20043]: PixelStorei (offset 250) */

-   "ii\0"

-   "glPixelStorei\0"

-   "\0"

-   /* _mesa_function_pool[20061]: VertexAttrib4usvARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib4usv\0"

-   "glVertexAttrib4usvARB\0"

-   "\0"

-   /* _mesa_function_pool[20106]: LinkProgramARB (will be remapped) */

-   "i\0"

-   "glLinkProgram\0"

-   "glLinkProgramARB\0"

-   "\0"

-   /* _mesa_function_pool[20140]: VertexAttrib2fNV (will be remapped) */

-   "iff\0"

-   "glVertexAttrib2fNV\0"

-   "\0"

-   /* _mesa_function_pool[20164]: ShaderSourceARB (will be remapped) */

-   "iipp\0"

-   "glShaderSource\0"

-   "glShaderSourceARB\0"

-   "\0"

-   /* _mesa_function_pool[20203]: FragmentMaterialiSGIX (dynamic) */

-   "iii\0"

-   "glFragmentMaterialiSGIX\0"

-   "\0"

-   /* _mesa_function_pool[20232]: EvalCoord2dv (offset 233) */

-   "p\0"

-   "glEvalCoord2dv\0"

-   "\0"

-   /* _mesa_function_pool[20250]: VertexAttrib3svARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib3sv\0"

-   "glVertexAttrib3svARB\0"

-   "\0"

-   /* _mesa_function_pool[20293]: ColorMaterial (offset 151) */

-   "ii\0"

-   "glColorMaterial\0"

-   "\0"

-   /* _mesa_function_pool[20313]: CompressedTexSubImage3DARB (will be remapped) */

-   "iiiiiiiiiip\0"

-   "glCompressedTexSubImage3D\0"

-   "glCompressedTexSubImage3DARB\0"

-   "\0"

-   /* _mesa_function_pool[20381]: WindowPos2ivMESA (will be remapped) */

-   "p\0"

-   "glWindowPos2iv\0"

-   "glWindowPos2ivARB\0"

-   "glWindowPos2ivMESA\0"

-   "\0"

-   /* _mesa_function_pool[20436]: IsFramebufferEXT (will be remapped) */

-   "i\0"

-   "glIsFramebuffer\0"

-   "glIsFramebufferEXT\0"

-   "\0"

-   /* _mesa_function_pool[20474]: Uniform4ivARB (will be remapped) */

-   "iip\0"

-   "glUniform4iv\0"

-   "glUniform4ivARB\0"

-   "\0"

-   /* _mesa_function_pool[20508]: GetVertexAttribdvARB (will be remapped) */

-   "iip\0"

-   "glGetVertexAttribdv\0"

-   "glGetVertexAttribdvARB\0"

-   "\0"

-   /* _mesa_function_pool[20556]: TexBumpParameterivATI (will be remapped) */

-   "ip\0"

-   "glTexBumpParameterivATI\0"

-   "\0"

-   /* _mesa_function_pool[20584]: GetSeparableFilter (offset 359) */

-   "iiippp\0"

-   "glGetSeparableFilter\0"

-   "glGetSeparableFilterEXT\0"

-   "\0"

-   /* _mesa_function_pool[20637]: Binormal3dEXT (dynamic) */

-   "ddd\0"

-   "glBinormal3dEXT\0"

-   "\0"

-   /* _mesa_function_pool[20658]: SpriteParameteriSGIX (dynamic) */

-   "ii\0"

-   "glSpriteParameteriSGIX\0"

-   "\0"

-   /* _mesa_function_pool[20685]: RequestResidentProgramsNV (will be remapped) */

-   "ip\0"

-   "glRequestResidentProgramsNV\0"

-   "\0"

-   /* _mesa_function_pool[20717]: TagSampleBufferSGIX (dynamic) */

-   "\0"

-   "glTagSampleBufferSGIX\0"

-   "\0"

-   /* _mesa_function_pool[20741]: TransformFeedbackVaryingsEXT (will be remapped) */

-   "iipi\0"

-   "glTransformFeedbackVaryingsEXT\0"

-   "glTransformFeedbackVaryings\0"

-   "\0"

-   /* _mesa_function_pool[20806]: FeedbackBuffer (offset 194) */

-   "iip\0"

-   "glFeedbackBuffer\0"

-   "\0"

-   /* _mesa_function_pool[20828]: RasterPos2iv (offset 67) */

-   "p\0"

-   "glRasterPos2iv\0"

-   "\0"

-   /* _mesa_function_pool[20846]: TexImage1D (offset 182) */

-   "iiiiiiip\0"

-   "glTexImage1D\0"

-   "\0"

-   /* _mesa_function_pool[20869]: ListParameterivSGIX (dynamic) */

-   "iip\0"

-   "glListParameterivSGIX\0"

-   "\0"

-   /* _mesa_function_pool[20896]: MultiDrawElementsEXT (will be remapped) */

-   "ipipi\0"

-   "glMultiDrawElements\0"

-   "glMultiDrawElementsEXT\0"

-   "\0"

-   /* _mesa_function_pool[20946]: Color3s (offset 17) */

-   "iii\0"

-   "glColor3s\0"

-   "\0"

-   /* _mesa_function_pool[20961]: Uniform1ivARB (will be remapped) */

-   "iip\0"

-   "glUniform1iv\0"

-   "glUniform1ivARB\0"

-   "\0"

-   /* _mesa_function_pool[20995]: WindowPos2sMESA (will be remapped) */

-   "ii\0"

-   "glWindowPos2s\0"

-   "glWindowPos2sARB\0"

-   "glWindowPos2sMESA\0"

-   "\0"

-   /* _mesa_function_pool[21048]: WeightusvARB (dynamic) */

-   "ip\0"

-   "glWeightusvARB\0"

-   "\0"

-   /* _mesa_function_pool[21067]: TexCoordPointer (offset 320) */

-   "iiip\0"

-   "glTexCoordPointer\0"

-   "\0"

-   /* _mesa_function_pool[21091]: FogCoordPointerEXT (will be remapped) */

-   "iip\0"

-   "glFogCoordPointer\0"

-   "glFogCoordPointerEXT\0"

-   "\0"

-   /* _mesa_function_pool[21135]: IndexMaterialEXT (dynamic) */

-   "ii\0"

-   "glIndexMaterialEXT\0"

-   "\0"

-   /* _mesa_function_pool[21158]: Color3i (offset 15) */

-   "iii\0"

-   "glColor3i\0"

-   "\0"

-   /* _mesa_function_pool[21173]: FrontFace (offset 157) */

-   "i\0"

-   "glFrontFace\0"

-   "\0"

-   /* _mesa_function_pool[21188]: EvalCoord2d (offset 232) */

-   "dd\0"

-   "glEvalCoord2d\0"

-   "\0"

-   /* _mesa_function_pool[21206]: SecondaryColor3ubvEXT (will be remapped) */

-   "p\0"

-   "glSecondaryColor3ubv\0"

-   "glSecondaryColor3ubvEXT\0"

-   "\0"

-   /* _mesa_function_pool[21254]: EvalCoord2f (offset 234) */

-   "ff\0"

-   "glEvalCoord2f\0"

-   "\0"

-   /* _mesa_function_pool[21272]: VertexAttrib4dvARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib4dv\0"

-   "glVertexAttrib4dvARB\0"

-   "\0"

-   /* _mesa_function_pool[21315]: BindAttribLocationARB (will be remapped) */

-   "iip\0"

-   "glBindAttribLocation\0"

-   "glBindAttribLocationARB\0"

-   "\0"

-   /* _mesa_function_pool[21365]: Color3b (offset 9) */

-   "iii\0"

-   "glColor3b\0"

-   "\0"

-   /* _mesa_function_pool[21380]: MultiTexCoord2dARB (offset 384) */

-   "idd\0"

-   "glMultiTexCoord2d\0"

-   "glMultiTexCoord2dARB\0"

-   "\0"

-   /* _mesa_function_pool[21424]: ExecuteProgramNV (will be remapped) */

-   "iip\0"

-   "glExecuteProgramNV\0"

-   "\0"

-   /* _mesa_function_pool[21448]: Color3f (offset 13) */

-   "fff\0"

-   "glColor3f\0"

-   "\0"

-   /* _mesa_function_pool[21463]: LightEnviSGIX (dynamic) */

-   "ii\0"

-   "glLightEnviSGIX\0"

-   "\0"

-   /* _mesa_function_pool[21483]: Color3d (offset 11) */

-   "ddd\0"

-   "glColor3d\0"

-   "\0"

-   /* _mesa_function_pool[21498]: Normal3dv (offset 55) */

-   "p\0"

-   "glNormal3dv\0"

-   "\0"

-   /* _mesa_function_pool[21513]: Lightf (offset 159) */

-   "iif\0"

-   "glLightf\0"

-   "\0"

-   /* _mesa_function_pool[21527]: ReplacementCodeuiSUN (dynamic) */

-   "i\0"

-   "glReplacementCodeuiSUN\0"

-   "\0"

-   /* _mesa_function_pool[21553]: MatrixMode (offset 293) */

-   "i\0"

-   "glMatrixMode\0"

-   "\0"

-   /* _mesa_function_pool[21569]: GetPixelMapusv (offset 273) */

-   "ip\0"

-   "glGetPixelMapusv\0"

-   "\0"

-   /* _mesa_function_pool[21590]: Lighti (offset 161) */

-   "iii\0"

-   "glLighti\0"

-   "\0"

-   /* _mesa_function_pool[21604]: VertexAttribPointerNV (will be remapped) */

-   "iiiip\0"

-   "glVertexAttribPointerNV\0"

-   "\0"

-   /* _mesa_function_pool[21635]: ClearDepthf (will be remapped) */

-   "f\0"

-   "glClearDepthf\0"

-   "\0"

-   /* _mesa_function_pool[21652]: GetBooleanIndexedvEXT (will be remapped) */

-   "iip\0"

-   "glGetBooleanIndexedvEXT\0"

-   "glGetBooleani_v\0"

-   "\0"

-   /* _mesa_function_pool[21697]: GetFramebufferAttachmentParameterivEXT (will be remapped) */

-   "iiip\0"

-   "glGetFramebufferAttachmentParameteriv\0"

-   "glGetFramebufferAttachmentParameterivEXT\0"

-   "\0"

-   /* _mesa_function_pool[21782]: PixelTransformParameterfEXT (dynamic) */

-   "iif\0"

-   "glPixelTransformParameterfEXT\0"

-   "\0"

-   /* _mesa_function_pool[21817]: MultiTexCoord4dvARB (offset 401) */

-   "ip\0"

-   "glMultiTexCoord4dv\0"

-   "glMultiTexCoord4dvARB\0"

-   "\0"

-   /* _mesa_function_pool[21862]: PixelTransformParameteriEXT (dynamic) */

-   "iii\0"

-   "glPixelTransformParameteriEXT\0"

-   "\0"

-   /* _mesa_function_pool[21897]: GetDoublev (offset 260) */

-   "ip\0"

-   "glGetDoublev\0"

-   "\0"

-   /* _mesa_function_pool[21914]: MultMatrixd (offset 295) */

-   "p\0"

-   "glMultMatrixd\0"

-   "\0"

-   /* _mesa_function_pool[21931]: MultMatrixf (offset 294) */

-   "p\0"

-   "glMultMatrixf\0"

-   "\0"

-   /* _mesa_function_pool[21948]: VertexAttribI4bvEXT (will be remapped) */

-   "ip\0"

-   "glVertexAttribI4bvEXT\0"

-   "glVertexAttribI4bv\0"

-   "\0"

-   /* _mesa_function_pool[21993]: TexCoord2fColor4ubVertex3fSUN (dynamic) */

-   "ffiiiifff\0"

-   "glTexCoord2fColor4ubVertex3fSUN\0"

-   "\0"

-   /* _mesa_function_pool[22036]: Uniform1iARB (will be remapped) */

-   "ii\0"

-   "glUniform1i\0"

-   "glUniform1iARB\0"

-   "\0"

-   /* _mesa_function_pool[22067]: VertexAttribPointerARB (will be remapped) */

-   "iiiiip\0"

-   "glVertexAttribPointer\0"

-   "glVertexAttribPointerARB\0"

-   "\0"

-   /* _mesa_function_pool[22122]: VertexAttrib3sNV (will be remapped) */

-   "iiii\0"

-   "glVertexAttrib3sNV\0"

-   "\0"

-   /* _mesa_function_pool[22147]: SharpenTexFuncSGIS (dynamic) */

-   "iip\0"

-   "glSharpenTexFuncSGIS\0"

-   "\0"

-   /* _mesa_function_pool[22173]: MultiTexCoord4fvARB (offset 403) */

-   "ip\0"

-   "glMultiTexCoord4fv\0"

-   "glMultiTexCoord4fvARB\0"

-   "\0"

-   /* _mesa_function_pool[22218]: Uniform2uiEXT (will be remapped) */

-   "iii\0"

-   "glUniform2uiEXT\0"

-   "glUniform2ui\0"

-   "\0"

-   /* _mesa_function_pool[22252]: UniformMatrix2x3fv (will be remapped) */

-   "iiip\0"

-   "glUniformMatrix2x3fv\0"

-   "\0"

-   /* _mesa_function_pool[22279]: TrackMatrixNV (will be remapped) */

-   "iiii\0"

-   "glTrackMatrixNV\0"

-   "\0"

-   /* _mesa_function_pool[22301]: CombinerParameteriNV (will be remapped) */

-   "ii\0"

-   "glCombinerParameteriNV\0"

-   "\0"

-   /* _mesa_function_pool[22328]: DeleteAsyncMarkersSGIX (dynamic) */

-   "ii\0"

-   "glDeleteAsyncMarkersSGIX\0"

-   "\0"

-   /* _mesa_function_pool[22357]: ReplacementCodeusSUN (dynamic) */

-   "i\0"

-   "glReplacementCodeusSUN\0"

-   "\0"

-   /* _mesa_function_pool[22383]: IsAsyncMarkerSGIX (dynamic) */

-   "i\0"

-   "glIsAsyncMarkerSGIX\0"

-   "\0"

-   /* _mesa_function_pool[22406]: FrameZoomSGIX (dynamic) */

-   "i\0"

-   "glFrameZoomSGIX\0"

-   "\0"

-   /* _mesa_function_pool[22425]: Normal3fVertex3fvSUN (dynamic) */

-   "pp\0"

-   "glNormal3fVertex3fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[22452]: RasterPos4sv (offset 85) */

-   "p\0"

-   "glRasterPos4sv\0"

-   "\0"

-   /* _mesa_function_pool[22470]: VertexAttrib4NsvARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib4Nsv\0"

-   "glVertexAttrib4NsvARB\0"

-   "\0"

-   /* _mesa_function_pool[22515]: VertexAttrib3fvARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib3fv\0"

-   "glVertexAttrib3fvARB\0"

-   "\0"

-   /* _mesa_function_pool[22558]: ClearColor (offset 206) */

-   "ffff\0"

-   "glClearColor\0"

-   "\0"

-   /* _mesa_function_pool[22577]: GetSynciv (will be remapped) */

-   "iiipp\0"

-   "glGetSynciv\0"

-   "\0"

-   /* _mesa_function_pool[22596]: ClearColorIiEXT (will be remapped) */

-   "iiii\0"

-   "glClearColorIiEXT\0"

-   "\0"

-   /* _mesa_function_pool[22620]: DeleteFramebuffersEXT (will be remapped) */

-   "ip\0"

-   "glDeleteFramebuffers\0"

-   "glDeleteFramebuffersEXT\0"

-   "\0"

-   /* _mesa_function_pool[22669]: GlobalAlphaFactorsSUN (dynamic) */

-   "i\0"

-   "glGlobalAlphaFactorsSUN\0"

-   "\0"

-   /* _mesa_function_pool[22696]: IsEnabledIndexedEXT (will be remapped) */

-   "ii\0"

-   "glIsEnabledIndexedEXT\0"

-   "glIsEnabledi\0"

-   "\0"

-   /* _mesa_function_pool[22735]: TexEnviv (offset 187) */

-   "iip\0"

-   "glTexEnviv\0"

-   "\0"

-   /* _mesa_function_pool[22751]: TexSubImage3D (offset 372) */

-   "iiiiiiiiiip\0"

-   "glTexSubImage3D\0"

-   "glTexSubImage3DEXT\0"

-   "\0"

-   /* _mesa_function_pool[22799]: Tangent3fEXT (dynamic) */

-   "fff\0"

-   "glTangent3fEXT\0"

-   "\0"

-   /* _mesa_function_pool[22819]: SecondaryColor3uivEXT (will be remapped) */

-   "p\0"

-   "glSecondaryColor3uiv\0"

-   "glSecondaryColor3uivEXT\0"

-   "\0"

-   /* _mesa_function_pool[22867]: MatrixIndexubvARB (dynamic) */

-   "ip\0"

-   "glMatrixIndexubvARB\0"

-   "\0"

-   /* _mesa_function_pool[22891]: Color4fNormal3fVertex3fSUN (dynamic) */

-   "ffffffffff\0"

-   "glColor4fNormal3fVertex3fSUN\0"

-   "\0"

-   /* _mesa_function_pool[22932]: PixelTexGenParameterfSGIS (will be remapped) */

-   "if\0"

-   "glPixelTexGenParameterfSGIS\0"

-   "\0"

-   /* _mesa_function_pool[22964]: CreateShader (will be remapped) */

-   "i\0"

-   "glCreateShader\0"

-   "\0"

-   /* _mesa_function_pool[22982]: GetColorTableParameterfv (offset 344) */

-   "iip\0"

-   "glGetColorTableParameterfv\0"

-   "glGetColorTableParameterfvSGI\0"

-   "glGetColorTableParameterfvEXT\0"

-   "\0"

-   /* _mesa_function_pool[23074]: FragmentLightModelfvSGIX (dynamic) */

-   "ip\0"

-   "glFragmentLightModelfvSGIX\0"

-   "\0"

-   /* _mesa_function_pool[23105]: Bitmap (offset 8) */

-   "iiffffp\0"

-   "glBitmap\0"

-   "\0"

-   /* _mesa_function_pool[23123]: MultiTexCoord3fARB (offset 394) */

-   "ifff\0"

-   "glMultiTexCoord3f\0"

-   "glMultiTexCoord3fARB\0"

-   "\0"

-   /* _mesa_function_pool[23168]: GetTexLevelParameterfv (offset 284) */

-   "iiip\0"

-   "glGetTexLevelParameterfv\0"

-   "\0"

-   /* _mesa_function_pool[23199]: GetPixelTexGenParameterfvSGIS (will be remapped) */

-   "ip\0"

-   "glGetPixelTexGenParameterfvSGIS\0"

-   "\0"

-   /* _mesa_function_pool[23235]: GenFramebuffersEXT (will be remapped) */

-   "ip\0"

-   "glGenFramebuffers\0"

-   "glGenFramebuffersEXT\0"

-   "\0"

-   /* _mesa_function_pool[23278]: VertexAttribDivisor (will be remapped) */

-   "ii\0"

-   "glVertexAttribDivisor\0"

-   "\0"

-   /* _mesa_function_pool[23304]: GetProgramParameterdvNV (will be remapped) */

-   "iiip\0"

-   "glGetProgramParameterdvNV\0"

-   "\0"

-   /* _mesa_function_pool[23336]: Vertex2sv (offset 133) */

-   "p\0"

-   "glVertex2sv\0"

-   "\0"

-   /* _mesa_function_pool[23351]: GetIntegerv (offset 263) */

-   "ip\0"

-   "glGetIntegerv\0"

-   "\0"

-   /* _mesa_function_pool[23369]: IsVertexArrayAPPLE (will be remapped) */

-   "i\0"

-   "glIsVertexArray\0"

-   "glIsVertexArrayAPPLE\0"

-   "\0"

-   /* _mesa_function_pool[23409]: FragmentLightfvSGIX (dynamic) */

-   "iip\0"

-   "glFragmentLightfvSGIX\0"

-   "\0"

-   /* _mesa_function_pool[23436]: VertexAttribDivisorARB (will be remapped) */

-   "ii\0"

-   "glVertexAttribDivisorARB\0"

-   "\0"

-   /* _mesa_function_pool[23465]: DetachShader (will be remapped) */

-   "ii\0"

-   "glDetachShader\0"

-   "\0"

-   /* _mesa_function_pool[23484]: VertexAttrib4NubARB (will be remapped) */

-   "iiiii\0"

-   "glVertexAttrib4Nub\0"

-   "glVertexAttrib4NubARB\0"

-   "\0"

-   /* _mesa_function_pool[23532]: GetProgramEnvParameterfvARB (will be remapped) */

-   "iip\0"

-   "glGetProgramEnvParameterfvARB\0"

-   "\0"

-   /* _mesa_function_pool[23567]: GetTrackMatrixivNV (will be remapped) */

-   "iiip\0"

-   "glGetTrackMatrixivNV\0"

-   "\0"

-   /* _mesa_function_pool[23594]: VertexAttrib3svNV (will be remapped) */

-   "ip\0"

-   "glVertexAttrib3svNV\0"

-   "\0"

-   /* _mesa_function_pool[23618]: Uniform4fvARB (will be remapped) */

-   "iip\0"

-   "glUniform4fv\0"

-   "glUniform4fvARB\0"

-   "\0"

-   /* _mesa_function_pool[23652]: MultTransposeMatrixfARB (will be remapped) */

-   "p\0"

-   "glMultTransposeMatrixf\0"

-   "glMultTransposeMatrixfARB\0"

-   "\0"

-   /* _mesa_function_pool[23704]: GetTexEnviv (offset 277) */

-   "iip\0"

-   "glGetTexEnviv\0"

-   "\0"

-   /* _mesa_function_pool[23723]: ColorFragmentOp1ATI (will be remapped) */

-   "iiiiiii\0"

-   "glColorFragmentOp1ATI\0"

-   "\0"

-   /* _mesa_function_pool[23754]: GetUniformfvARB (will be remapped) */

-   "iip\0"

-   "glGetUniformfv\0"

-   "glGetUniformfvARB\0"

-   "\0"

-   /* _mesa_function_pool[23792]: EGLImageTargetRenderbufferStorageOES (will be remapped) */

-   "ip\0"

-   "glEGLImageTargetRenderbufferStorageOES\0"

-   "\0"

-   /* _mesa_function_pool[23835]: VertexAttribI2ivEXT (will be remapped) */

-   "ip\0"

-   "glVertexAttribI2ivEXT\0"

-   "glVertexAttribI2iv\0"

-   "\0"

-   /* _mesa_function_pool[23880]: PopClientAttrib (offset 334) */

-   "\0"

-   "glPopClientAttrib\0"

-   "\0"

-   /* _mesa_function_pool[23900]: ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN (dynamic) */

-   "iffffffffffff\0"

-   "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN\0"

-   "\0"

-   /* _mesa_function_pool[23971]: DetachObjectARB (will be remapped) */

-   "ii\0"

-   "glDetachObjectARB\0"

-   "\0"

-   /* _mesa_function_pool[23993]: VertexBlendARB (dynamic) */

-   "i\0"

-   "glVertexBlendARB\0"

-   "\0"

-   /* _mesa_function_pool[24013]: WindowPos3iMESA (will be remapped) */

-   "iii\0"

-   "glWindowPos3i\0"

-   "glWindowPos3iARB\0"

-   "glWindowPos3iMESA\0"

-   "\0"

-   /* _mesa_function_pool[24067]: SeparableFilter2D (offset 360) */

-   "iiiiiipp\0"

-   "glSeparableFilter2D\0"

-   "glSeparableFilter2DEXT\0"

-   "\0"

-   /* _mesa_function_pool[24120]: ProgramParameteriARB (will be remapped) */

-   "iii\0"

-   "glProgramParameteriARB\0"

-   "\0"

-   /* _mesa_function_pool[24148]: Map1d (offset 220) */

-   "iddiip\0"

-   "glMap1d\0"

-   "\0"

-   /* _mesa_function_pool[24164]: Map1f (offset 221) */

-   "iffiip\0"

-   "glMap1f\0"

-   "\0"

-   /* _mesa_function_pool[24180]: CompressedTexImage2DARB (will be remapped) */

-   "iiiiiiip\0"

-   "glCompressedTexImage2D\0"

-   "glCompressedTexImage2DARB\0"

-   "\0"

-   /* _mesa_function_pool[24239]: ArrayElement (offset 306) */

-   "i\0"

-   "glArrayElement\0"

-   "glArrayElementEXT\0"

-   "\0"

-   /* _mesa_function_pool[24275]: TexImage2D (offset 183) */

-   "iiiiiiiip\0"

-   "glTexImage2D\0"

-   "\0"

-   /* _mesa_function_pool[24299]: DepthBoundsEXT (will be remapped) */

-   "dd\0"

-   "glDepthBoundsEXT\0"

-   "\0"

-   /* _mesa_function_pool[24320]: ProgramParameters4fvNV (will be remapped) */

-   "iiip\0"

-   "glProgramParameters4fvNV\0"

-   "\0"

-   /* _mesa_function_pool[24351]: DeformationMap3fSGIX (dynamic) */

-   "iffiiffiiffiip\0"

-   "glDeformationMap3fSGIX\0"

-   "\0"

-   /* _mesa_function_pool[24390]: GetProgramivNV (will be remapped) */

-   "iip\0"

-   "glGetProgramivNV\0"

-   "\0"

-   /* _mesa_function_pool[24412]: GetFragDataLocationEXT (will be remapped) */

-   "ip\0"

-   "glGetFragDataLocationEXT\0"

-   "glGetFragDataLocation\0"

-   "\0"

-   /* _mesa_function_pool[24463]: GetMinmaxParameteriv (offset 366) */

-   "iip\0"

-   "glGetMinmaxParameteriv\0"

-   "glGetMinmaxParameterivEXT\0"

-   "\0"

-   /* _mesa_function_pool[24517]: PixelTransferf (offset 247) */

-   "if\0"

-   "glPixelTransferf\0"

-   "\0"

-   /* _mesa_function_pool[24538]: CopyTexImage1D (offset 323) */

-   "iiiiiii\0"

-   "glCopyTexImage1D\0"

-   "glCopyTexImage1DEXT\0"

-   "\0"

-   /* _mesa_function_pool[24584]: PushMatrix (offset 298) */

-   "\0"

-   "glPushMatrix\0"

-   "\0"

-   /* _mesa_function_pool[24599]: Fogiv (offset 156) */

-   "ip\0"

-   "glFogiv\0"

-   "\0"

-   /* _mesa_function_pool[24611]: TexCoord1dv (offset 95) */

-   "p\0"

-   "glTexCoord1dv\0"

-   "\0"

-   /* _mesa_function_pool[24628]: AlphaFragmentOp3ATI (will be remapped) */

-   "iiiiiiiiiiii\0"

-   "glAlphaFragmentOp3ATI\0"

-   "\0"

-   /* _mesa_function_pool[24664]: PixelTransferi (offset 248) */

-   "ii\0"

-   "glPixelTransferi\0"

-   "\0"

-   /* _mesa_function_pool[24685]: GetVertexAttribdvNV (will be remapped) */

-   "iip\0"

-   "glGetVertexAttribdvNV\0"

-   "\0"

-   /* _mesa_function_pool[24712]: VertexAttrib3fvNV (will be remapped) */

-   "ip\0"

-   "glVertexAttrib3fvNV\0"

-   "\0"

-   /* _mesa_function_pool[24736]: Rotatef (offset 300) */

-   "ffff\0"

-   "glRotatef\0"

-   "\0"

-   /* _mesa_function_pool[24752]: GetFinalCombinerInputParameterivNV (will be remapped) */

-   "iip\0"

-   "glGetFinalCombinerInputParameterivNV\0"

-   "\0"

-   /* _mesa_function_pool[24794]: Vertex3i (offset 138) */

-   "iii\0"

-   "glVertex3i\0"

-   "\0"

-   /* _mesa_function_pool[24810]: Vertex3f (offset 136) */

-   "fff\0"

-   "glVertex3f\0"

-   "\0"

-   /* _mesa_function_pool[24826]: Clear (offset 203) */

-   "i\0"

-   "glClear\0"

-   "\0"

-   /* _mesa_function_pool[24837]: Vertex3d (offset 134) */

-   "ddd\0"

-   "glVertex3d\0"

-   "\0"

-   /* _mesa_function_pool[24853]: GetMapParameterivNV (dynamic) */

-   "iip\0"

-   "glGetMapParameterivNV\0"

-   "\0"

-   /* _mesa_function_pool[24880]: Uniform4iARB (will be remapped) */

-   "iiiii\0"

-   "glUniform4i\0"

-   "glUniform4iARB\0"

-   "\0"

-   /* _mesa_function_pool[24914]: ReadBuffer (offset 254) */

-   "i\0"

-   "glReadBuffer\0"

-   "\0"

-   /* _mesa_function_pool[24930]: ConvolutionParameteri (offset 352) */

-   "iii\0"

-   "glConvolutionParameteri\0"

-   "glConvolutionParameteriEXT\0"

-   "\0"

-   /* _mesa_function_pool[24986]: Ortho (offset 296) */

-   "dddddd\0"

-   "glOrtho\0"

-   "\0"

-   /* _mesa_function_pool[25002]: Binormal3sEXT (dynamic) */

-   "iii\0"

-   "glBinormal3sEXT\0"

-   "\0"

-   /* _mesa_function_pool[25023]: ListBase (offset 6) */

-   "i\0"

-   "glListBase\0"

-   "\0"

-   /* _mesa_function_pool[25037]: Vertex3s (offset 140) */

-   "iii\0"

-   "glVertex3s\0"

-   "\0"

-   /* _mesa_function_pool[25053]: ConvolutionParameterf (offset 350) */

-   "iif\0"

-   "glConvolutionParameterf\0"

-   "glConvolutionParameterfEXT\0"

-   "\0"

-   /* _mesa_function_pool[25109]: GetColorTableParameteriv (offset 345) */

-   "iip\0"

-   "glGetColorTableParameteriv\0"

-   "glGetColorTableParameterivSGI\0"

-   "glGetColorTableParameterivEXT\0"

-   "\0"

-   /* _mesa_function_pool[25201]: ProgramEnvParameter4dvARB (will be remapped) */

-   "iip\0"

-   "glProgramEnvParameter4dvARB\0"

-   "glProgramParameter4dvNV\0"

-   "\0"

-   /* _mesa_function_pool[25258]: ShadeModel (offset 177) */

-   "i\0"

-   "glShadeModel\0"

-   "\0"

-   /* _mesa_function_pool[25274]: VertexAttribs2fvNV (will be remapped) */

-   "iip\0"

-   "glVertexAttribs2fvNV\0"

-   "\0"

-   /* _mesa_function_pool[25300]: Rectiv (offset 91) */

-   "pp\0"

-   "glRectiv\0"

-   "\0"

-   /* _mesa_function_pool[25313]: UseProgramObjectARB (will be remapped) */

-   "i\0"

-   "glUseProgram\0"

-   "glUseProgramObjectARB\0"

-   "\0"

-   /* _mesa_function_pool[25351]: GetMapParameterfvNV (dynamic) */

-   "iip\0"

-   "glGetMapParameterfvNV\0"

-   "\0"

-   /* _mesa_function_pool[25378]: EndConditionalRenderNV (will be remapped) */

-   "\0"

-   "glEndConditionalRenderNV\0"

-   "glEndConditionalRender\0"

-   "\0"

-   /* _mesa_function_pool[25428]: PassTexCoordATI (will be remapped) */

-   "iii\0"

-   "glPassTexCoordATI\0"

-   "\0"

-   /* _mesa_function_pool[25451]: DeleteProgram (will be remapped) */

-   "i\0"

-   "glDeleteProgram\0"

-   "\0"

-   /* _mesa_function_pool[25470]: Tangent3ivEXT (dynamic) */

-   "p\0"

-   "glTangent3ivEXT\0"

-   "\0"

-   /* _mesa_function_pool[25489]: Tangent3dEXT (dynamic) */

-   "ddd\0"

-   "glTangent3dEXT\0"

-   "\0"

-   /* _mesa_function_pool[25509]: SecondaryColor3dvEXT (will be remapped) */

-   "p\0"

-   "glSecondaryColor3dv\0"

-   "glSecondaryColor3dvEXT\0"

-   "\0"

-   /* _mesa_function_pool[25555]: AlphaFragmentOp2ATI (will be remapped) */

-   "iiiiiiiii\0"

-   "glAlphaFragmentOp2ATI\0"

-   "\0"

-   /* _mesa_function_pool[25588]: Vertex2fv (offset 129) */

-   "p\0"

-   "glVertex2fv\0"

-   "\0"

-   /* _mesa_function_pool[25603]: MultiDrawArraysEXT (will be remapped) */

-   "ippi\0"

-   "glMultiDrawArrays\0"

-   "glMultiDrawArraysEXT\0"

-   "\0"

-   /* _mesa_function_pool[25648]: BindRenderbufferEXT (will be remapped) */

-   "ii\0"

-   "glBindRenderbuffer\0"

-   "glBindRenderbufferEXT\0"

-   "\0"

-   /* _mesa_function_pool[25693]: MultiTexCoord4dARB (offset 400) */

-   "idddd\0"

-   "glMultiTexCoord4d\0"

-   "glMultiTexCoord4dARB\0"

-   "\0"

-   /* _mesa_function_pool[25739]: FramebufferTextureFaceARB (will be remapped) */

-   "iiiii\0"

-   "glFramebufferTextureFaceARB\0"

-   "\0"

-   /* _mesa_function_pool[25774]: Vertex3sv (offset 141) */

-   "p\0"

-   "glVertex3sv\0"

-   "\0"

-   /* _mesa_function_pool[25789]: SecondaryColor3usEXT (will be remapped) */

-   "iii\0"

-   "glSecondaryColor3us\0"

-   "glSecondaryColor3usEXT\0"

-   "\0"

-   /* _mesa_function_pool[25837]: ProgramLocalParameter4fvARB (will be remapped) */

-   "iip\0"

-   "glProgramLocalParameter4fvARB\0"

-   "\0"

-   /* _mesa_function_pool[25872]: DeleteProgramsNV (will be remapped) */

-   "ip\0"

-   "glDeleteProgramsARB\0"

-   "glDeleteProgramsNV\0"

-   "\0"

-   /* _mesa_function_pool[25915]: EvalMesh1 (offset 236) */

-   "iii\0"

-   "glEvalMesh1\0"

-   "\0"

-   /* _mesa_function_pool[25932]: PauseTransformFeedback (will be remapped) */

-   "\0"

-   "glPauseTransformFeedback\0"

-   "\0"

-   /* _mesa_function_pool[25959]: MultiTexCoord1sARB (offset 382) */

-   "ii\0"

-   "glMultiTexCoord1s\0"

-   "glMultiTexCoord1sARB\0"

-   "\0"

-   /* _mesa_function_pool[26002]: ReplacementCodeuiColor3fVertex3fSUN (dynamic) */

-   "iffffff\0"

-   "glReplacementCodeuiColor3fVertex3fSUN\0"

-   "\0"

-   /* _mesa_function_pool[26049]: GetVertexAttribPointervNV (will be remapped) */

-   "iip\0"

-   "glGetVertexAttribPointerv\0"

-   "glGetVertexAttribPointervARB\0"

-   "glGetVertexAttribPointervNV\0"

-   "\0"

-   /* _mesa_function_pool[26137]: VertexAttribs1fvNV (will be remapped) */

-   "iip\0"

-   "glVertexAttribs1fvNV\0"

-   "\0"

-   /* _mesa_function_pool[26163]: MultiTexCoord1dvARB (offset 377) */

-   "ip\0"

-   "glMultiTexCoord1dv\0"

-   "glMultiTexCoord1dvARB\0"

-   "\0"

-   /* _mesa_function_pool[26208]: Uniform2iARB (will be remapped) */

-   "iii\0"

-   "glUniform2i\0"

-   "glUniform2iARB\0"

-   "\0"

-   /* _mesa_function_pool[26240]: Vertex2iv (offset 131) */

-   "p\0"

-   "glVertex2iv\0"

-   "\0"

-   /* _mesa_function_pool[26255]: GetProgramStringNV (will be remapped) */

-   "iip\0"

-   "glGetProgramStringNV\0"

-   "\0"

-   /* _mesa_function_pool[26281]: ColorPointerEXT (will be remapped) */

-   "iiiip\0"

-   "glColorPointerEXT\0"

-   "\0"

-   /* _mesa_function_pool[26306]: LineWidth (offset 168) */

-   "f\0"

-   "glLineWidth\0"

-   "\0"

-   /* _mesa_function_pool[26321]: MapBufferARB (will be remapped) */

-   "ii\0"

-   "glMapBuffer\0"

-   "glMapBufferARB\0"

-   "\0"

-   /* _mesa_function_pool[26352]: MultiDrawElementsBaseVertex (will be remapped) */

-   "ipipip\0"

-   "glMultiDrawElementsBaseVertex\0"

-   "\0"

-   /* _mesa_function_pool[26390]: TexParameterIuivEXT (will be remapped) */

-   "iip\0"

-   "glTexParameterIuivEXT\0"

-   "glTexParameterIuiv\0"

-   "\0"

-   /* _mesa_function_pool[26436]: Binormal3svEXT (dynamic) */

-   "p\0"

-   "glBinormal3svEXT\0"

-   "\0"

-   /* _mesa_function_pool[26456]: ApplyTextureEXT (dynamic) */

-   "i\0"

-   "glApplyTextureEXT\0"

-   "\0"

-   /* _mesa_function_pool[26477]: GetBufferParameteri64v (will be remapped) */

-   "iip\0"

-   "glGetBufferParameteri64v\0"

-   "\0"

-   /* _mesa_function_pool[26507]: TexGendv (offset 189) */

-   "iip\0"

-   "glTexGendv\0"

-   "\0"

-   /* _mesa_function_pool[26523]: VertexAttribI3iEXT (will be remapped) */

-   "iiii\0"

-   "glVertexAttribI3iEXT\0"

-   "glVertexAttribI3i\0"

-   "\0"

-   /* _mesa_function_pool[26568]: EnableIndexedEXT (will be remapped) */

-   "ii\0"

-   "glEnableIndexedEXT\0"

-   "glEnablei\0"

-   "\0"

-   /* _mesa_function_pool[26601]: TextureMaterialEXT (dynamic) */

-   "ii\0"

-   "glTextureMaterialEXT\0"

-   "\0"

-   /* _mesa_function_pool[26626]: TextureLightEXT (dynamic) */

-   "i\0"

-   "glTextureLightEXT\0"

-   "\0"

-   /* _mesa_function_pool[26647]: ResetMinmax (offset 370) */

-   "i\0"

-   "glResetMinmax\0"

-   "glResetMinmaxEXT\0"

-   "\0"

-   /* _mesa_function_pool[26681]: SpriteParameterfSGIX (dynamic) */

-   "if\0"

-   "glSpriteParameterfSGIX\0"

-   "\0"

-   /* _mesa_function_pool[26708]: EnableClientState (offset 313) */

-   "i\0"

-   "glEnableClientState\0"

-   "\0"

-   /* _mesa_function_pool[26731]: VertexAttrib4sNV (will be remapped) */

-   "iiiii\0"

-   "glVertexAttrib4sNV\0"

-   "\0"

-   /* _mesa_function_pool[26757]: GetConvolutionParameterfv (offset 357) */

-   "iip\0"

-   "glGetConvolutionParameterfv\0"

-   "glGetConvolutionParameterfvEXT\0"

-   "\0"

-   /* _mesa_function_pool[26821]: VertexAttribs4dvNV (will be remapped) */

-   "iip\0"

-   "glVertexAttribs4dvNV\0"

-   "\0"

-   /* _mesa_function_pool[26847]: MultiModeDrawArraysIBM (will be remapped) */

-   "pppii\0"

-   "glMultiModeDrawArraysIBM\0"

-   "\0"

-   /* _mesa_function_pool[26879]: VertexAttrib4dARB (will be remapped) */

-   "idddd\0"

-   "glVertexAttrib4d\0"

-   "glVertexAttrib4dARB\0"

-   "\0"

-   /* _mesa_function_pool[26923]: GetTexBumpParameterfvATI (will be remapped) */

-   "ip\0"

-   "glGetTexBumpParameterfvATI\0"

-   "\0"

-   /* _mesa_function_pool[26954]: ProgramNamedParameter4dNV (will be remapped) */

-   "iipdddd\0"

-   "glProgramNamedParameter4dNV\0"

-   "\0"

-   /* _mesa_function_pool[26991]: GetMaterialfv (offset 269) */

-   "iip\0"

-   "glGetMaterialfv\0"

-   "\0"

-   /* _mesa_function_pool[27012]: VertexWeightfEXT (dynamic) */

-   "f\0"

-   "glVertexWeightfEXT\0"

-   "\0"

-   /* _mesa_function_pool[27034]: SetFragmentShaderConstantATI (will be remapped) */

-   "ip\0"

-   "glSetFragmentShaderConstantATI\0"

-   "\0"

-   /* _mesa_function_pool[27069]: Binormal3fEXT (dynamic) */

-   "fff\0"

-   "glBinormal3fEXT\0"

-   "\0"

-   /* _mesa_function_pool[27090]: CallList (offset 2) */

-   "i\0"

-   "glCallList\0"

-   "\0"

-   /* _mesa_function_pool[27104]: Materialfv (offset 170) */

-   "iip\0"

-   "glMaterialfv\0"

-   "\0"

-   /* _mesa_function_pool[27122]: TexCoord3fv (offset 113) */

-   "p\0"

-   "glTexCoord3fv\0"

-   "\0"

-   /* _mesa_function_pool[27139]: FogCoordfvEXT (will be remapped) */

-   "p\0"

-   "glFogCoordfv\0"

-   "glFogCoordfvEXT\0"

-   "\0"

-   /* _mesa_function_pool[27171]: MultiTexCoord1ivARB (offset 381) */

-   "ip\0"

-   "glMultiTexCoord1iv\0"

-   "glMultiTexCoord1ivARB\0"

-   "\0"

-   /* _mesa_function_pool[27216]: SecondaryColor3ubEXT (will be remapped) */

-   "iii\0"

-   "glSecondaryColor3ub\0"

-   "glSecondaryColor3ubEXT\0"

-   "\0"

-   /* _mesa_function_pool[27264]: MultiTexCoord2ivARB (offset 389) */

-   "ip\0"

-   "glMultiTexCoord2iv\0"

-   "glMultiTexCoord2ivARB\0"

-   "\0"

-   /* _mesa_function_pool[27309]: FogFuncSGIS (dynamic) */

-   "ip\0"

-   "glFogFuncSGIS\0"

-   "\0"

-   /* _mesa_function_pool[27327]: CopyTexSubImage2D (offset 326) */

-   "iiiiiiii\0"

-   "glCopyTexSubImage2D\0"

-   "glCopyTexSubImage2DEXT\0"

-   "\0"

-   /* _mesa_function_pool[27380]: GetObjectParameterivARB (will be remapped) */

-   "iip\0"

-   "glGetObjectParameterivARB\0"

-   "\0"

-   /* _mesa_function_pool[27411]: Color3iv (offset 16) */

-   "p\0"

-   "glColor3iv\0"

-   "\0"

-   /* _mesa_function_pool[27425]: TexCoord4fVertex4fSUN (dynamic) */

-   "ffffffff\0"

-   "glTexCoord4fVertex4fSUN\0"

-   "\0"

-   /* _mesa_function_pool[27459]: DrawElements (offset 311) */

-   "iiip\0"

-   "glDrawElements\0"

-   "\0"

-   /* _mesa_function_pool[27480]: BindVertexArrayAPPLE (will be remapped) */

-   "i\0"

-   "glBindVertexArrayAPPLE\0"

-   "\0"

-   /* _mesa_function_pool[27506]: GetProgramLocalParameterdvARB (will be remapped) */

-   "iip\0"

-   "glGetProgramLocalParameterdvARB\0"

-   "\0"

-   /* _mesa_function_pool[27543]: GetHistogramParameteriv (offset 363) */

-   "iip\0"

-   "glGetHistogramParameteriv\0"

-   "glGetHistogramParameterivEXT\0"

-   "\0"

-   /* _mesa_function_pool[27603]: MultiTexCoord1iARB (offset 380) */

-   "ii\0"

-   "glMultiTexCoord1i\0"

-   "glMultiTexCoord1iARB\0"

-   "\0"

-   /* _mesa_function_pool[27646]: GetConvolutionFilter (offset 356) */

-   "iiip\0"

-   "glGetConvolutionFilter\0"

-   "glGetConvolutionFilterEXT\0"

-   "\0"

-   /* _mesa_function_pool[27701]: GetProgramivARB (will be remapped) */

-   "iip\0"

-   "glGetProgramivARB\0"

-   "\0"

-   /* _mesa_function_pool[27724]: BlendFuncSeparateEXT (will be remapped) */

-   "iiii\0"

-   "glBlendFuncSeparate\0"

-   "glBlendFuncSeparateEXT\0"

-   "glBlendFuncSeparateINGR\0"

-   "\0"

-   /* _mesa_function_pool[27797]: MapBufferRange (will be remapped) */

-   "iiii\0"

-   "glMapBufferRange\0"

-   "\0"

-   /* _mesa_function_pool[27820]: ProgramParameters4dvNV (will be remapped) */

-   "iiip\0"

-   "glProgramParameters4dvNV\0"

-   "\0"

-   /* _mesa_function_pool[27851]: TexCoord2fColor3fVertex3fvSUN (dynamic) */

-   "ppp\0"

-   "glTexCoord2fColor3fVertex3fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[27888]: EvalPoint2 (offset 239) */

-   "ii\0"

-   "glEvalPoint2\0"

-   "\0"

-   /* _mesa_function_pool[27905]: Uniform1uivEXT (will be remapped) */

-   "iip\0"

-   "glUniform1uivEXT\0"

-   "glUniform1uiv\0"

-   "\0"

-   /* _mesa_function_pool[27941]: EvalPoint1 (offset 237) */

-   "i\0"

-   "glEvalPoint1\0"

-   "\0"

-   /* _mesa_function_pool[27957]: Binormal3dvEXT (dynamic) */

-   "p\0"

-   "glBinormal3dvEXT\0"

-   "\0"

-   /* _mesa_function_pool[27977]: PopMatrix (offset 297) */

-   "\0"

-   "glPopMatrix\0"

-   "\0"

-   /* _mesa_function_pool[27991]: GetVertexAttribIuivEXT (will be remapped) */

-   "iip\0"

-   "glGetVertexAttribIuivEXT\0"

-   "glGetVertexAttribIuiv\0"

-   "\0"

-   /* _mesa_function_pool[28043]: FinishFenceNV (will be remapped) */

-   "i\0"

-   "glFinishFenceNV\0"

-   "\0"

-   /* _mesa_function_pool[28062]: GetFogFuncSGIS (dynamic) */

-   "p\0"

-   "glGetFogFuncSGIS\0"

-   "\0"

-   /* _mesa_function_pool[28082]: GetUniformLocationARB (will be remapped) */

-   "ip\0"

-   "glGetUniformLocation\0"

-   "glGetUniformLocationARB\0"

-   "\0"

-   /* _mesa_function_pool[28131]: SecondaryColor3fEXT (will be remapped) */

-   "fff\0"

-   "glSecondaryColor3f\0"

-   "glSecondaryColor3fEXT\0"

-   "\0"

-   /* _mesa_function_pool[28177]: GetTexGeniv (offset 280) */

-   "iip\0"

-   "glGetTexGeniv\0"

-   "\0"

-   /* _mesa_function_pool[28196]: CombinerInputNV (will be remapped) */

-   "iiiiii\0"

-   "glCombinerInputNV\0"

-   "\0"

-   /* _mesa_function_pool[28222]: VertexAttrib3sARB (will be remapped) */

-   "iiii\0"

-   "glVertexAttrib3s\0"

-   "glVertexAttrib3sARB\0"

-   "\0"

-   /* _mesa_function_pool[28265]: IsTransformFeedback (will be remapped) */

-   "i\0"

-   "glIsTransformFeedback\0"

-   "\0"

-   /* _mesa_function_pool[28290]: ReplacementCodeuiNormal3fVertex3fvSUN (dynamic) */

-   "ppp\0"

-   "glReplacementCodeuiNormal3fVertex3fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[28335]: Map2d (offset 222) */

-   "iddiiddiip\0"

-   "glMap2d\0"

-   "\0"

-   /* _mesa_function_pool[28355]: Map2f (offset 223) */

-   "iffiiffiip\0"

-   "glMap2f\0"

-   "\0"

-   /* _mesa_function_pool[28375]: ProgramStringARB (will be remapped) */

-   "iiip\0"

-   "glProgramStringARB\0"

-   "\0"

-   /* _mesa_function_pool[28400]: Vertex4s (offset 148) */

-   "iiii\0"

-   "glVertex4s\0"

-   "\0"

-   /* _mesa_function_pool[28417]: TexCoord4fVertex4fvSUN (dynamic) */

-   "pp\0"

-   "glTexCoord4fVertex4fvSUN\0"

-   "\0"

-   /* _mesa_function_pool[28446]: FragmentLightModelivSGIX (dynamic) */

-   "ip\0"

-   "glFragmentLightModelivSGIX\0"

-   "\0"

-   /* _mesa_function_pool[28477]: VertexAttrib1fNV (will be remapped) */

-   "if\0"

-   "glVertexAttrib1fNV\0"

-   "\0"

-   /* _mesa_function_pool[28500]: Vertex4f (offset 144) */

-   "ffff\0"

-   "glVertex4f\0"

-   "\0"

-   /* _mesa_function_pool[28517]: EvalCoord1d (offset 228) */

-   "d\0"

-   "glEvalCoord1d\0"

-   "\0"

-   /* _mesa_function_pool[28534]: Vertex4d (offset 142) */

-   "dddd\0"

-   "glVertex4d\0"

-   "\0"

-   /* _mesa_function_pool[28551]: RasterPos4dv (offset 79) */

-   "p\0"

-   "glRasterPos4dv\0"

-   "\0"

-   /* _mesa_function_pool[28569]: UseShaderProgramEXT (will be remapped) */

-   "ii\0"

-   "glUseShaderProgramEXT\0"

-   "\0"

-   /* _mesa_function_pool[28595]: FragmentLightfSGIX (dynamic) */

-   "iif\0"

-   "glFragmentLightfSGIX\0"

-   "\0"

-   /* _mesa_function_pool[28621]: GetCompressedTexImageARB (will be remapped) */

-   "iip\0"

-   "glGetCompressedTexImage\0"

-   "glGetCompressedTexImageARB\0"

-   "\0"

-   /* _mesa_function_pool[28677]: GetTexGenfv (offset 279) */

-   "iip\0"

-   "glGetTexGenfv\0"

-   "\0"

-   /* _mesa_function_pool[28696]: Vertex4i (offset 146) */

-   "iiii\0"

-   "glVertex4i\0"

-   "\0"

-   /* _mesa_function_pool[28713]: VertexWeightPointerEXT (dynamic) */

-   "iiip\0"

-   "glVertexWeightPointerEXT\0"

-   "\0"

-   /* _mesa_function_pool[28744]: GetHistogram (offset 361) */

-   "iiiip\0"

-   "glGetHistogram\0"

-   "glGetHistogramEXT\0"

-   "\0"

-   /* _mesa_function_pool[28784]: ActiveStencilFaceEXT (will be remapped) */

-   "i\0"

-   "glActiveStencilFaceEXT\0"

-   "\0"

-   /* _mesa_function_pool[28810]: StencilFuncSeparateATI (will be remapped) */

-   "iiii\0"

-   "glStencilFuncSeparateATI\0"

-   "\0"

-   /* _mesa_function_pool[28841]: Materialf (offset 169) */

-   "iif\0"

-   "glMaterialf\0"

-   "\0"

-   /* _mesa_function_pool[28858]: GetShaderSourceARB (will be remapped) */

-   "iipp\0"

-   "glGetShaderSource\0"

-   "glGetShaderSourceARB\0"

-   "\0"

-   /* _mesa_function_pool[28903]: IglooInterfaceSGIX (dynamic) */

-   "ip\0"

-   "glIglooInterfaceSGIX\0"

-   "\0"

-   /* _mesa_function_pool[28928]: Materiali (offset 171) */

-   "iii\0"

-   "glMateriali\0"

-   "\0"

-   /* _mesa_function_pool[28945]: VertexAttrib4dNV (will be remapped) */

-   "idddd\0"

-   "glVertexAttrib4dNV\0"

-   "\0"

-   /* _mesa_function_pool[28971]: MultiModeDrawElementsIBM (will be remapped) */

-   "ppipii\0"

-   "glMultiModeDrawElementsIBM\0"

-   "\0"

-   /* _mesa_function_pool[29006]: Indexsv (offset 51) */

-   "p\0"

-   "glIndexsv\0"

-   "\0"

-   /* _mesa_function_pool[29019]: MultiTexCoord4svARB (offset 407) */

-   "ip\0"

-   "glMultiTexCoord4sv\0"

-   "glMultiTexCoord4svARB\0"

-   "\0"

-   /* _mesa_function_pool[29064]: LightModelfv (offset 164) */

-   "ip\0"

-   "glLightModelfv\0"

-   "\0"

-   /* _mesa_function_pool[29083]: TexCoord2dv (offset 103) */

-   "p\0"

-   "glTexCoord2dv\0"

-   "\0"

-   /* _mesa_function_pool[29100]: GenQueriesARB (will be remapped) */

-   "ip\0"

-   "glGenQueries\0"

-   "glGenQueriesARB\0"

-   "\0"

-   /* _mesa_function_pool[29133]: EvalCoord1dv (offset 229) */

-   "p\0"

-   "glEvalCoord1dv\0"

-   "\0"

-   /* _mesa_function_pool[29151]: ReplacementCodeuiVertex3fSUN (dynamic) */

-   "ifff\0"

-   "glReplacementCodeuiVertex3fSUN\0"

-   "\0"

-   /* _mesa_function_pool[29188]: Translated (offset 303) */

-   "ddd\0"

-   "glTranslated\0"

-   "\0"

-   /* _mesa_function_pool[29206]: Translatef (offset 304) */

-   "fff\0"

-   "glTranslatef\0"

-   "\0"

-   /* _mesa_function_pool[29224]: Uniform3uiEXT (will be remapped) */

-   "iiii\0"

-   "glUniform3uiEXT\0"

-   "glUniform3ui\0"

-   "\0"

-   /* _mesa_function_pool[29259]: StencilMask (offset 209) */

-   "i\0"

-   "glStencilMask\0"

-   "\0"

-   /* _mesa_function_pool[29276]: Tangent3iEXT (dynamic) */

-   "iii\0"

-   "glTangent3iEXT\0"

-   "\0"

-   /* _mesa_function_pool[29296]: GetLightiv (offset 265) */

-   "iip\0"

-   "glGetLightiv\0"

-   "\0"

-   /* _mesa_function_pool[29314]: DrawMeshArraysSUN (dynamic) */

-   "iiii\0"

-   "glDrawMeshArraysSUN\0"

-   "\0"

-   /* _mesa_function_pool[29340]: IsList (offset 287) */

-   "i\0"

-   "glIsList\0"

-   "\0"

-   /* _mesa_function_pool[29352]: IsSync (will be remapped) */

-   "i\0"

-   "glIsSync\0"

-   "\0"

-   /* _mesa_function_pool[29364]: RenderMode (offset 196) */

-   "i\0"

-   "glRenderMode\0"

-   "\0"

-   /* _mesa_function_pool[29380]: GetMapControlPointsNV (dynamic) */

-   "iiiiiip\0"

-   "glGetMapControlPointsNV\0"

-   "\0"

-   /* _mesa_function_pool[29413]: DrawBuffersARB (will be remapped) */

-   "ip\0"

-   "glDrawBuffers\0"

-   "glDrawBuffersARB\0"

-   "glDrawBuffersATI\0"

-   "\0"

-   /* _mesa_function_pool[29465]: ClearBufferiv (will be remapped) */

-   "iip\0"

-   "glClearBufferiv\0"

-   "\0"

-   /* _mesa_function_pool[29486]: ProgramLocalParameter4fARB (will be remapped) */

-   "iiffff\0"

-   "glProgramLocalParameter4fARB\0"

-   "\0"

-   /* _mesa_function_pool[29523]: SpriteParameterivSGIX (dynamic) */

-   "ip\0"

-   "glSpriteParameterivSGIX\0"

-   "\0"

-   /* _mesa_function_pool[29551]: ProvokingVertexEXT (will be remapped) */

-   "i\0"

-   "glProvokingVertexEXT\0"

-   "glProvokingVertex\0"

-   "\0"

-   /* _mesa_function_pool[29593]: MultiTexCoord1fARB (offset 378) */

-   "if\0"

-   "glMultiTexCoord1f\0"

-   "glMultiTexCoord1fARB\0"

-   "\0"

-   /* _mesa_function_pool[29636]: LoadName (offset 198) */

-   "i\0"

-   "glLoadName\0"

-   "\0"

-   /* _mesa_function_pool[29650]: VertexAttribs4ubvNV (will be remapped) */

-   "iip\0"

-   "glVertexAttribs4ubvNV\0"

-   "\0"

-   /* _mesa_function_pool[29677]: WeightsvARB (dynamic) */

-   "ip\0"

-   "glWeightsvARB\0"

-   "\0"

-   /* _mesa_function_pool[29695]: Uniform1fvARB (will be remapped) */

-   "iip\0"

-   "glUniform1fv\0"

-   "glUniform1fvARB\0"

-   "\0"

-   /* _mesa_function_pool[29729]: CopyTexSubImage1D (offset 325) */

-   "iiiiii\0"

-   "glCopyTexSubImage1D\0"

-   "glCopyTexSubImage1DEXT\0"

-   "\0"

-   /* _mesa_function_pool[29780]: CullFace (offset 152) */

-   "i\0"

-   "glCullFace\0"

-   "\0"

-   /* _mesa_function_pool[29794]: BindTexture (offset 307) */

-   "ii\0"

-   "glBindTexture\0"

-   "glBindTextureEXT\0"

-   "\0"

-   /* _mesa_function_pool[29829]: BeginFragmentShaderATI (will be remapped) */

-   "\0"

-   "glBeginFragmentShaderATI\0"

-   "\0"

-   /* _mesa_function_pool[29856]: MultiTexCoord4fARB (offset 402) */

-   "iffff\0"

-   "glMultiTexCoord4f\0"

-   "glMultiTexCoord4fARB\0"

-   "\0"

-   /* _mesa_function_pool[29902]: VertexAttribs3svNV (will be remapped) */

-   "iip\0"

-   "glVertexAttribs3svNV\0"

-   "\0"

-   /* _mesa_function_pool[29928]: StencilFunc (offset 243) */

-   "iii\0"

-   "glStencilFunc\0"

-   "\0"

-   /* _mesa_function_pool[29947]: CopyPixels (offset 255) */

-   "iiiii\0"

-   "glCopyPixels\0"

-   "\0"

-   /* _mesa_function_pool[29967]: Rectsv (offset 93) */

-   "pp\0"

-   "glRectsv\0"

-   "\0"

-   /* _mesa_function_pool[29980]: ReplacementCodeuivSUN (dynamic) */

-   "p\0"

-   "glReplacementCodeuivSUN\0"

-   "\0"

-   /* _mesa_function_pool[30007]: EnableVertexAttribArrayARB (will be remapped) */

-   "i\0"

-   "glEnableVertexAttribArray\0"

-   "glEnableVertexAttribArrayARB\0"

-   "\0"

-   /* _mesa_function_pool[30065]: NormalPointervINTEL (dynamic) */

-   "ip\0"

-   "glNormalPointervINTEL\0"

-   "\0"

-   /* _mesa_function_pool[30091]: CopyConvolutionFilter2D (offset 355) */

-   "iiiiii\0"

-   "glCopyConvolutionFilter2D\0"

-   "glCopyConvolutionFilter2DEXT\0"

-   "\0"

-   /* _mesa_function_pool[30154]: WindowPos3ivMESA (will be remapped) */

-   "p\0"

-   "glWindowPos3iv\0"

-   "glWindowPos3ivARB\0"

-   "glWindowPos3ivMESA\0"

-   "\0"

-   /* _mesa_function_pool[30209]: CopyBufferSubData (will be remapped) */

-   "iiiii\0"

-   "glCopyBufferSubData\0"

-   "\0"

-   /* _mesa_function_pool[30236]: NormalPointer (offset 318) */

-   "iip\0"

-   "glNormalPointer\0"

-   "\0"

-   /* _mesa_function_pool[30257]: TexParameterfv (offset 179) */

-   "iip\0"

-   "glTexParameterfv\0"

-   "\0"

-   /* _mesa_function_pool[30279]: IsBufferARB (will be remapped) */

-   "i\0"

-   "glIsBuffer\0"

-   "glIsBufferARB\0"

-   "\0"

-   /* _mesa_function_pool[30307]: WindowPos4iMESA (will be remapped) */

-   "iiii\0"

-   "glWindowPos4iMESA\0"

-   "\0"

-   /* _mesa_function_pool[30331]: VertexAttrib4uivARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib4uiv\0"

-   "glVertexAttrib4uivARB\0"

-   "\0"

-   /* _mesa_function_pool[30376]: Tangent3bvEXT (dynamic) */

-   "p\0"

-   "glTangent3bvEXT\0"

-   "\0"

-   /* _mesa_function_pool[30395]: VertexAttribI3uivEXT (will be remapped) */

-   "ip\0"

-   "glVertexAttribI3uivEXT\0"

-   "glVertexAttribI3uiv\0"

-   "\0"

-   /* _mesa_function_pool[30442]: UniformMatrix3x4fv (will be remapped) */

-   "iiip\0"

-   "glUniformMatrix3x4fv\0"

-   "\0"

-   /* _mesa_function_pool[30469]: ClipPlane (offset 150) */

-   "ip\0"

-   "glClipPlane\0"

-   "\0"

-   /* _mesa_function_pool[30485]: Recti (offset 90) */

-   "iiii\0"

-   "glRecti\0"

-   "\0"

-   /* _mesa_function_pool[30499]: VertexAttribI3ivEXT (will be remapped) */

-   "ip\0"

-   "glVertexAttribI3ivEXT\0"

-   "glVertexAttribI3iv\0"

-   "\0"

-   /* _mesa_function_pool[30544]: DrawRangeElementsBaseVertex (will be remapped) */

-   "iiiiipi\0"

-   "glDrawRangeElementsBaseVertex\0"

-   "\0"

-   /* _mesa_function_pool[30583]: TexCoordPointervINTEL (dynamic) */

-   "iip\0"

-   "glTexCoordPointervINTEL\0"

-   "\0"

-   /* _mesa_function_pool[30612]: DeleteBuffersARB (will be remapped) */

-   "ip\0"

-   "glDeleteBuffers\0"

-   "glDeleteBuffersARB\0"

-   "\0"

-   /* _mesa_function_pool[30651]: PixelTransformParameterfvEXT (dynamic) */

-   "iip\0"

-   "glPixelTransformParameterfvEXT\0"

-   "\0"

-   /* _mesa_function_pool[30687]: PrimitiveRestartNV (will be remapped) */

-   "\0"

-   "glPrimitiveRestartNV\0"

-   "\0"

-   /* _mesa_function_pool[30710]: WindowPos4fvMESA (will be remapped) */

-   "p\0"

-   "glWindowPos4fvMESA\0"

-   "\0"

-   /* _mesa_function_pool[30732]: GetPixelMapuiv (offset 272) */

-   "ip\0"

-   "glGetPixelMapuiv\0"

-   "\0"

-   /* _mesa_function_pool[30753]: Rectf (offset 88) */

-   "ffff\0"

-   "glRectf\0"

-   "\0"

-   /* _mesa_function_pool[30767]: VertexAttrib1sNV (will be remapped) */

-   "ii\0"

-   "glVertexAttrib1sNV\0"

-   "\0"

-   /* _mesa_function_pool[30790]: Indexfv (offset 47) */

-   "p\0"

-   "glIndexfv\0"

-   "\0"

-   /* _mesa_function_pool[30803]: SecondaryColor3svEXT (will be remapped) */

-   "p\0"

-   "glSecondaryColor3sv\0"

-   "glSecondaryColor3svEXT\0"

-   "\0"

-   /* _mesa_function_pool[30849]: LoadTransposeMatrixfARB (will be remapped) */

-   "p\0"

-   "glLoadTransposeMatrixf\0"

-   "glLoadTransposeMatrixfARB\0"

-   "\0"

-   /* _mesa_function_pool[30901]: GetPointerv (offset 329) */

-   "ip\0"

-   "glGetPointerv\0"

-   "glGetPointervEXT\0"

-   "\0"

-   /* _mesa_function_pool[30936]: Tangent3bEXT (dynamic) */

-   "iii\0"

-   "glTangent3bEXT\0"

-   "\0"

-   /* _mesa_function_pool[30956]: CombinerParameterfNV (will be remapped) */

-   "if\0"

-   "glCombinerParameterfNV\0"

-   "\0"

-   /* _mesa_function_pool[30983]: IndexMask (offset 212) */

-   "i\0"

-   "glIndexMask\0"

-   "\0"

-   /* _mesa_function_pool[30998]: BindProgramNV (will be remapped) */

-   "ii\0"

-   "glBindProgramARB\0"

-   "glBindProgramNV\0"

-   "\0"

-   /* _mesa_function_pool[31035]: VertexAttrib4svARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib4sv\0"

-   "glVertexAttrib4svARB\0"

-   "\0"

-   /* _mesa_function_pool[31078]: GetFloatv (offset 262) */

-   "ip\0"

-   "glGetFloatv\0"

-   "\0"

-   /* _mesa_function_pool[31094]: CreateDebugObjectMESA (dynamic) */

-   "\0"

-   "glCreateDebugObjectMESA\0"

-   "\0"

-   /* _mesa_function_pool[31120]: GetShaderiv (will be remapped) */

-   "iip\0"

-   "glGetShaderiv\0"

-   "\0"

-   /* _mesa_function_pool[31139]: ClientWaitSync (will be remapped) */

-   "iii\0"

-   "glClientWaitSync\0"

-   "\0"

-   /* _mesa_function_pool[31161]: TexCoord4s (offset 124) */

-   "iiii\0"

-   "glTexCoord4s\0"

-   "\0"

-   /* _mesa_function_pool[31180]: TexCoord3sv (offset 117) */

-   "p\0"

-   "glTexCoord3sv\0"

-   "\0"

-   /* _mesa_function_pool[31197]: BindFragmentShaderATI (will be remapped) */

-   "i\0"

-   "glBindFragmentShaderATI\0"

-   "\0"

-   /* _mesa_function_pool[31224]: PopAttrib (offset 218) */

-   "\0"

-   "glPopAttrib\0"

-   "\0"

-   /* _mesa_function_pool[31238]: Fogfv (offset 154) */

-   "ip\0"

-   "glFogfv\0"

-   "\0"

-   /* _mesa_function_pool[31250]: UnmapBufferARB (will be remapped) */

-   "i\0"

-   "glUnmapBuffer\0"

-   "glUnmapBufferARB\0"

-   "\0"

-   /* _mesa_function_pool[31284]: InitNames (offset 197) */

-   "\0"

-   "glInitNames\0"

-   "\0"

-   /* _mesa_function_pool[31298]: Normal3sv (offset 61) */

-   "p\0"

-   "glNormal3sv\0"

-   "\0"

-   /* _mesa_function_pool[31313]: Minmax (offset 368) */

-   "iii\0"

-   "glMinmax\0"

-   "glMinmaxEXT\0"

-   "\0"

-   /* _mesa_function_pool[31339]: TexCoord4d (offset 118) */

-   "dddd\0"

-   "glTexCoord4d\0"

-   "\0"

-   /* _mesa_function_pool[31358]: TexCoord4f (offset 120) */

-   "ffff\0"

-   "glTexCoord4f\0"

-   "\0"

-   /* _mesa_function_pool[31377]: FogCoorddvEXT (will be remapped) */

-   "p\0"

-   "glFogCoorddv\0"

-   "glFogCoorddvEXT\0"

-   "\0"

-   /* _mesa_function_pool[31409]: FinishTextureSUNX (dynamic) */

-   "\0"

-   "glFinishTextureSUNX\0"

-   "\0"

-   /* _mesa_function_pool[31431]: GetFragmentLightfvSGIX (dynamic) */

-   "iip\0"

-   "glGetFragmentLightfvSGIX\0"

-   "\0"

-   /* _mesa_function_pool[31461]: Binormal3fvEXT (dynamic) */

-   "p\0"

-   "glBinormal3fvEXT\0"

-   "\0"

-   /* _mesa_function_pool[31481]: GetBooleanv (offset 258) */

-   "ip\0"

-   "glGetBooleanv\0"

-   "\0"

-   /* _mesa_function_pool[31499]: ColorFragmentOp3ATI (will be remapped) */

-   "iiiiiiiiiiiii\0"

-   "glColorFragmentOp3ATI\0"

-   "\0"

-   /* _mesa_function_pool[31536]: Hint (offset 158) */

-   "ii\0"

-   "glHint\0"

-   "\0"

-   /* _mesa_function_pool[31547]: Color4dv (offset 28) */

-   "p\0"

-   "glColor4dv\0"

-   "\0"

-   /* _mesa_function_pool[31561]: VertexAttrib2svARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib2sv\0"

-   "glVertexAttrib2svARB\0"

-   "\0"

-   /* _mesa_function_pool[31604]: AreProgramsResidentNV (will be remapped) */

-   "ipp\0"

-   "glAreProgramsResidentNV\0"

-   "\0"

-   /* _mesa_function_pool[31633]: WindowPos3svMESA (will be remapped) */

-   "p\0"

-   "glWindowPos3sv\0"

-   "glWindowPos3svARB\0"

-   "glWindowPos3svMESA\0"

-   "\0"

-   /* _mesa_function_pool[31688]: CopyColorSubTable (offset 347) */

-   "iiiii\0"

-   "glCopyColorSubTable\0"

-   "glCopyColorSubTableEXT\0"

-   "\0"

-   /* _mesa_function_pool[31738]: WeightdvARB (dynamic) */

-   "ip\0"

-   "glWeightdvARB\0"

-   "\0"

-   /* _mesa_function_pool[31756]: DeleteRenderbuffersEXT (will be remapped) */

-   "ip\0"

-   "glDeleteRenderbuffers\0"

-   "glDeleteRenderbuffersEXT\0"

-   "\0"

-   /* _mesa_function_pool[31807]: VertexAttrib4NubvARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib4Nubv\0"

-   "glVertexAttrib4NubvARB\0"

-   "\0"

-   /* _mesa_function_pool[31854]: VertexAttrib3dvNV (will be remapped) */

-   "ip\0"

-   "glVertexAttrib3dvNV\0"

-   "\0"

-   /* _mesa_function_pool[31878]: GetObjectParameterfvARB (will be remapped) */

-   "iip\0"

-   "glGetObjectParameterfvARB\0"

-   "\0"

-   /* _mesa_function_pool[31909]: Vertex4iv (offset 147) */

-   "p\0"

-   "glVertex4iv\0"

-   "\0"

-   /* _mesa_function_pool[31924]: GetProgramEnvParameterdvARB (will be remapped) */

-   "iip\0"

-   "glGetProgramEnvParameterdvARB\0"

-   "\0"

-   /* _mesa_function_pool[31959]: TexCoord4dv (offset 119) */

-   "p\0"

-   "glTexCoord4dv\0"

-   "\0"

-   /* _mesa_function_pool[31976]: LockArraysEXT (will be remapped) */

-   "ii\0"

-   "glLockArraysEXT\0"

-   "\0"

-   /* _mesa_function_pool[31996]: Begin (offset 7) */

-   "i\0"

-   "glBegin\0"

-   "\0"

-   /* _mesa_function_pool[32007]: LightModeli (offset 165) */

-   "ii\0"

-   "glLightModeli\0"

-   "\0"

-   /* _mesa_function_pool[32025]: VertexAttribI4ivEXT (will be remapped) */

-   "ip\0"

-   "glVertexAttribI4ivEXT\0"

-   "glVertexAttribI4iv\0"

-   "\0"

-   /* _mesa_function_pool[32070]: Rectfv (offset 89) */

-   "pp\0"

-   "glRectfv\0"

-   "\0"

-   /* _mesa_function_pool[32083]: BlendEquationSeparateiARB (will be remapped) */

-   "iii\0"

-   "glBlendEquationSeparateiARB\0"

-   "\0"

-   /* _mesa_function_pool[32116]: LightModelf (offset 163) */

-   "if\0"

-   "glLightModelf\0"

-   "\0"

-   /* _mesa_function_pool[32134]: GetTexParameterfv (offset 282) */

-   "iip\0"

-   "glGetTexParameterfv\0"

-   "\0"

-   /* _mesa_function_pool[32159]: GetLightfv (offset 264) */

-   "iip\0"

-   "glGetLightfv\0"

-   "\0"

-   /* _mesa_function_pool[32177]: PixelTransformParameterivEXT (dynamic) */

-   "iip\0"

-   "glPixelTransformParameterivEXT\0"

-   "\0"

-   /* _mesa_function_pool[32213]: BinormalPointerEXT (dynamic) */

-   "iip\0"

-   "glBinormalPointerEXT\0"

-   "\0"

-   /* _mesa_function_pool[32239]: VertexAttrib1dNV (will be remapped) */

-   "id\0"

-   "glVertexAttrib1dNV\0"

-   "\0"

-   /* _mesa_function_pool[32262]: GetCombinerInputParameterivNV (will be remapped) */

-   "iiiip\0"

-   "glGetCombinerInputParameterivNV\0"

-   "\0"

-   /* _mesa_function_pool[32301]: Disable (offset 214) */

-   "i\0"

-   "glDisable\0"

-   "\0"

-   /* _mesa_function_pool[32314]: MultiTexCoord2fvARB (offset 387) */

-   "ip\0"

-   "glMultiTexCoord2fv\0"

-   "glMultiTexCoord2fvARB\0"

-   "\0"

-   /* _mesa_function_pool[32359]: GetRenderbufferParameterivEXT (will be remapped) */

-   "iip\0"

-   "glGetRenderbufferParameteriv\0"

-   "glGetRenderbufferParameterivEXT\0"

-   "\0"

-   /* _mesa_function_pool[32425]: CombinerParameterivNV (will be remapped) */

-   "ip\0"

-   "glCombinerParameterivNV\0"

-   "\0"

-   /* _mesa_function_pool[32453]: GenFragmentShadersATI (will be remapped) */

-   "i\0"

-   "glGenFragmentShadersATI\0"

-   "\0"

-   /* _mesa_function_pool[32480]: DrawArrays (offset 310) */

-   "iii\0"

-   "glDrawArrays\0"

-   "glDrawArraysEXT\0"

-   "\0"

-   /* _mesa_function_pool[32514]: WeightuivARB (dynamic) */

-   "ip\0"

-   "glWeightuivARB\0"

-   "\0"

-   /* _mesa_function_pool[32533]: VertexAttrib2sARB (will be remapped) */

-   "iii\0"

-   "glVertexAttrib2s\0"

-   "glVertexAttrib2sARB\0"

-   "\0"

-   /* _mesa_function_pool[32575]: ColorMask (offset 210) */

-   "iiii\0"

-   "glColorMask\0"

-   "\0"

-   /* _mesa_function_pool[32593]: GenAsyncMarkersSGIX (dynamic) */

-   "i\0"

-   "glGenAsyncMarkersSGIX\0"

-   "\0"

-   /* _mesa_function_pool[32618]: Tangent3svEXT (dynamic) */

-   "p\0"

-   "glTangent3svEXT\0"

-   "\0"

-   /* _mesa_function_pool[32637]: GetListParameterivSGIX (dynamic) */

-   "iip\0"

-   "glGetListParameterivSGIX\0"

-   "\0"

-   /* _mesa_function_pool[32667]: BindBufferARB (will be remapped) */

-   "ii\0"

-   "glBindBuffer\0"

-   "glBindBufferARB\0"

-   "\0"

-   /* _mesa_function_pool[32700]: GetInfoLogARB (will be remapped) */

-   "iipp\0"

-   "glGetInfoLogARB\0"

-   "\0"

-   /* _mesa_function_pool[32722]: RasterPos4iv (offset 83) */

-   "p\0"

-   "glRasterPos4iv\0"

-   "\0"

-   /* _mesa_function_pool[32740]: Enable (offset 215) */

-   "i\0"

-   "glEnable\0"

-   "\0"

-   /* _mesa_function_pool[32752]: LineStipple (offset 167) */

-   "ii\0"

-   "glLineStipple\0"

-   "\0"

-   /* _mesa_function_pool[32770]: VertexAttribs4svNV (will be remapped) */

-   "iip\0"

-   "glVertexAttribs4svNV\0"

-   "\0"

-   /* _mesa_function_pool[32796]: EdgeFlagPointerListIBM (dynamic) */

-   "ipi\0"

-   "glEdgeFlagPointerListIBM\0"

-   "\0"

-   /* _mesa_function_pool[32826]: UniformMatrix3x2fv (will be remapped) */

-   "iiip\0"

-   "glUniformMatrix3x2fv\0"

-   "\0"

-   /* _mesa_function_pool[32853]: GetMinmaxParameterfv (offset 365) */

-   "iip\0"

-   "glGetMinmaxParameterfv\0"

-   "glGetMinmaxParameterfvEXT\0"

-   "\0"

-   /* _mesa_function_pool[32907]: VertexAttrib1fvARB (will be remapped) */

-   "ip\0"

-   "glVertexAttrib1fv\0"

-   "glVertexAttrib1fvARB\0"

-   "\0"

-   /* _mesa_function_pool[32950]: GenBuffersARB (will be remapped) */

-   "ip\0"

-   "glGenBuffers\0"

-   "glGenBuffersARB\0"

-   "\0"

-   /* _mesa_function_pool[32983]: VertexAttribs1svNV (will be remapped) */

-   "iip\0"

-   "glVertexAttribs1svNV\0"

-   "\0"

-   /* _mesa_function_pool[33009]: Vertex3fv (offset 137) */

-   "p\0"

-   "glVertex3fv\0"

-   "\0"

-   /* _mesa_function_pool[33024]: GetTexBumpParameterivATI (will be remapped) */

-   "ip\0"

-   "glGetTexBumpParameterivATI\0"

-   "\0"

-   /* _mesa_function_pool[33055]: Binormal3bEXT (dynamic) */

-   "iii\0"

-   "glBinormal3bEXT\0"

-   "\0"

-   /* _mesa_function_pool[33076]: FragmentMaterialivSGIX (dynamic) */

-   "iip\0"

-   "glFragmentMaterialivSGIX\0"

-   "\0"

-   /* _mesa_function_pool[33106]: IsRenderbufferEXT (will be remapped) */

-   "i\0"

-   "glIsRenderbuffer\0"

-   "glIsRenderbufferEXT\0"

-   "\0"

-   /* _mesa_function_pool[33146]: GenProgramsNV (will be remapped) */

-   "ip\0"

-   "glGenProgramsARB\0"

-   "glGenProgramsNV\0"

-   "\0"

-   /* _mesa_function_pool[33183]: VertexAttrib4dvNV (will be remapped) */

-   "ip\0"

-   "glVertexAttrib4dvNV\0"

-   "\0"

-   /* _mesa_function_pool[33207]: EndFragmentShaderATI (will be remapped) */

-   "\0"

-   "glEndFragmentShaderATI\0"

-   "\0"

-   /* _mesa_function_pool[33232]: Binormal3iEXT (dynamic) */

-   "iii\0"

-   "glBinormal3iEXT\0"

-   "\0"

-   /* _mesa_function_pool[33253]: WindowPos2fMESA (will be remapped) */

-   "ff\0"

-   "glWindowPos2f\0"

-   "glWindowPos2fARB\0"

-   "glWindowPos2fMESA\0"

-   "\0"

-   ;

-

-/* these functions need to be remapped */

-static const struct gl_function_pool_remap MESA_remap_table_functions[] = {

-   {  1616, AttachShader_remap_index },

-   {  9893, CreateProgram_remap_index },

-   { 22964, CreateShader_remap_index },

-   { 25451, DeleteProgram_remap_index },

-   { 18608, DeleteShader_remap_index },

-   { 23465, DetachShader_remap_index },

-   { 17974, GetAttachedShaders_remap_index },

-   {  4856, GetProgramInfoLog_remap_index },

-   {   444, GetProgramiv_remap_index },

-   {  6529, GetShaderInfoLog_remap_index },

-   { 31120, GetShaderiv_remap_index },

-   { 13387, IsProgram_remap_index },

-   { 12308, IsShader_remap_index },

-   { 10023, StencilFuncSeparate_remap_index },

-   {  3960, StencilMaskSeparate_remap_index },

-   {  7594, StencilOpSeparate_remap_index },

-   { 22252, UniformMatrix2x3fv_remap_index },

-   {  2886, UniformMatrix2x4fv_remap_index },

-   { 32826, UniformMatrix3x2fv_remap_index },

-   { 30442, UniformMatrix3x4fv_remap_index },

-   { 16264, UniformMatrix4x2fv_remap_index },

-   {  3302, UniformMatrix4x3fv_remap_index },

-   {  5017, ClampColor_remap_index },

-   { 18028, ClearBufferfi_remap_index },

-   { 17470, ClearBufferfv_remap_index },

-   { 29465, ClearBufferiv_remap_index },

-   { 13592, ClearBufferuiv_remap_index },

-   { 19891, GetStringi_remap_index },

-   {  2827, TexBuffer_remap_index },

-   {   977, FramebufferTexture_remap_index },

-   { 26477, GetBufferParameteri64v_remap_index },

-   { 10123, GetInteger64i_v_remap_index },

-   { 23278, VertexAttribDivisor_remap_index },

-   {  9911, LoadTransposeMatrixdARB_remap_index },

-   { 30849, LoadTransposeMatrixfARB_remap_index },

-   {  5637, MultTransposeMatrixdARB_remap_index },

-   { 23652, MultTransposeMatrixfARB_remap_index },

-   {   255, SampleCoverageARB_remap_index },

-   {  5821, CompressedTexImage1DARB_remap_index },

-   { 24180, CompressedTexImage2DARB_remap_index },

-   {  4023, CompressedTexImage3DARB_remap_index },

-   { 18325, CompressedTexSubImage1DARB_remap_index },

-   {  2089, CompressedTexSubImage2DARB_remap_index },

-   { 20313, CompressedTexSubImage3DARB_remap_index },

-   { 28621, GetCompressedTexImageARB_remap_index },

-   {  3868, DisableVertexAttribArrayARB_remap_index },

-   { 30007, EnableVertexAttribArrayARB_remap_index },

-   { 31924, GetProgramEnvParameterdvARB_remap_index },

-   { 23532, GetProgramEnvParameterfvARB_remap_index },

-   { 27506, GetProgramLocalParameterdvARB_remap_index },

-   {  8036, GetProgramLocalParameterfvARB_remap_index },

-   { 18459, GetProgramStringARB_remap_index },

-   { 27701, GetProgramivARB_remap_index },

-   { 20508, GetVertexAttribdvARB_remap_index },

-   { 16072, GetVertexAttribfvARB_remap_index },

-   {  9735, GetVertexAttribivARB_remap_index },

-   { 19372, ProgramEnvParameter4dARB_remap_index },

-   { 25201, ProgramEnvParameter4dvARB_remap_index },

-   { 16792, ProgramEnvParameter4fARB_remap_index },

-   {  8935, ProgramEnvParameter4fvARB_remap_index },

-   {  3986, ProgramLocalParameter4dARB_remap_index },

-   { 13097, ProgramLocalParameter4dvARB_remap_index },

-   { 29486, ProgramLocalParameter4fARB_remap_index },

-   { 25837, ProgramLocalParameter4fvARB_remap_index },

-   { 28375, ProgramStringARB_remap_index },

-   { 19622, VertexAttrib1dARB_remap_index },

-   { 15726, VertexAttrib1dvARB_remap_index },

-   {  4161, VertexAttrib1fARB_remap_index },

-   { 32907, VertexAttrib1fvARB_remap_index },

-   {  7120, VertexAttrib1sARB_remap_index },

-   {  2263, VertexAttrib1svARB_remap_index },

-   { 15157, VertexAttrib2dARB_remap_index },

-   { 17491, VertexAttrib2dvARB_remap_index },

-   {  1635, VertexAttrib2fARB_remap_index },

-   { 17604, VertexAttrib2fvARB_remap_index },

-   { 32533, VertexAttrib2sARB_remap_index },

-   { 31561, VertexAttrib2svARB_remap_index },

-   { 11274, VertexAttrib3dARB_remap_index },

-   {  8602, VertexAttrib3dvARB_remap_index },

-   {  1722, VertexAttrib3fARB_remap_index },

-   { 22515, VertexAttrib3fvARB_remap_index },

-   { 28222, VertexAttrib3sARB_remap_index },

-   { 20250, VertexAttrib3svARB_remap_index },

-   {  4882, VertexAttrib4NbvARB_remap_index },

-   { 17851, VertexAttrib4NivARB_remap_index },

-   { 22470, VertexAttrib4NsvARB_remap_index },

-   { 23484, VertexAttrib4NubARB_remap_index },

-   { 31807, VertexAttrib4NubvARB_remap_index },

-   { 19033, VertexAttrib4NuivARB_remap_index },

-   {  3175, VertexAttrib4NusvARB_remap_index },

-   { 10863, VertexAttrib4bvARB_remap_index },

-   { 26879, VertexAttrib4dARB_remap_index },

-   { 21272, VertexAttrib4dvARB_remap_index },

-   { 11428, VertexAttrib4fARB_remap_index },

-   { 11832, VertexAttrib4fvARB_remap_index },

-   { 10239, VertexAttrib4ivARB_remap_index },

-   { 17284, VertexAttrib4sARB_remap_index },

-   { 31035, VertexAttrib4svARB_remap_index },

-   { 16597, VertexAttrib4ubvARB_remap_index },

-   { 30331, VertexAttrib4uivARB_remap_index },

-   { 20061, VertexAttrib4usvARB_remap_index },

-   { 22067, VertexAttribPointerARB_remap_index },

-   { 32667, BindBufferARB_remap_index },

-   {  6827, BufferDataARB_remap_index },

-   {  1537, BufferSubDataARB_remap_index },

-   { 30612, DeleteBuffersARB_remap_index },

-   { 32950, GenBuffersARB_remap_index },

-   { 17647, GetBufferParameterivARB_remap_index },

-   { 16744, GetBufferPointervARB_remap_index },

-   {  1490, GetBufferSubDataARB_remap_index },

-   { 30279, IsBufferARB_remap_index },

-   { 26321, MapBufferARB_remap_index },

-   { 31250, UnmapBufferARB_remap_index },

-   {   351, BeginQueryARB_remap_index },

-   { 19717, DeleteQueriesARB_remap_index },

-   { 12159, EndQueryARB_remap_index },

-   { 29100, GenQueriesARB_remap_index },

-   {  1981, GetQueryObjectivARB_remap_index },

-   { 17328, GetQueryObjectuivARB_remap_index },

-   {  1779, GetQueryivARB_remap_index },

-   { 19968, IsQueryARB_remap_index },

-   {  8212, AttachObjectARB_remap_index },

-   { 18570, CompileShaderARB_remap_index },

-   {  3244, CreateProgramObjectARB_remap_index },

-   {  6772, CreateShaderObjectARB_remap_index },

-   { 14459, DeleteObjectARB_remap_index },

-   { 23971, DetachObjectARB_remap_index },

-   { 11904, GetActiveUniformARB_remap_index },

-   {  9410, GetAttachedObjectsARB_remap_index },

-   {  9717, GetHandleARB_remap_index },

-   { 32700, GetInfoLogARB_remap_index },

-   { 31878, GetObjectParameterfvARB_remap_index },

-   { 27380, GetObjectParameterivARB_remap_index },

-   { 28858, GetShaderSourceARB_remap_index },

-   { 28082, GetUniformLocationARB_remap_index },

-   { 23754, GetUniformfvARB_remap_index },

-   { 12672, GetUniformivARB_remap_index },

-   { 20106, LinkProgramARB_remap_index },

-   { 20164, ShaderSourceARB_remap_index },

-   {  7494, Uniform1fARB_remap_index },

-   { 29695, Uniform1fvARB_remap_index },

-   { 22036, Uniform1iARB_remap_index },

-   { 20961, Uniform1ivARB_remap_index },

-   {  2212, Uniform2fARB_remap_index },

-   { 14295, Uniform2fvARB_remap_index },

-   { 26208, Uniform2iARB_remap_index },

-   {  2332, Uniform2ivARB_remap_index },

-   { 18680, Uniform3fARB_remap_index },

-   {  9440, Uniform3fvARB_remap_index },

-   {  6383, Uniform3iARB_remap_index },

-   { 16850, Uniform3ivARB_remap_index },

-   { 19178, Uniform4fARB_remap_index },

-   { 23618, Uniform4fvARB_remap_index },

-   { 24880, Uniform4iARB_remap_index },

-   { 20474, Uniform4ivARB_remap_index },

-   {  8264, UniformMatrix2fvARB_remap_index },

-   {    17, UniformMatrix3fvARB_remap_index },

-   {  2729, UniformMatrix4fvARB_remap_index },

-   { 25313, UseProgramObjectARB_remap_index },

-   { 14845, ValidateProgramARB_remap_index },

-   { 21315, BindAttribLocationARB_remap_index },

-   {  4927, GetActiveAttribARB_remap_index },

-   { 16531, GetAttribLocationARB_remap_index },

-   { 29413, DrawBuffersARB_remap_index },

-   { 17896, DrawArraysInstancedARB_remap_index },

-   {  6444, DrawElementsInstancedARB_remap_index },

-   { 13202, RenderbufferStorageMultisample_remap_index },

-   { 13673, FramebufferTextureARB_remap_index },

-   { 25739, FramebufferTextureFaceARB_remap_index },

-   { 24120, ProgramParameteriARB_remap_index },

-   { 23436, VertexAttribDivisorARB_remap_index },

-   { 19226, FlushMappedBufferRange_remap_index },

-   { 27797, MapBufferRange_remap_index },

-   { 16375, BindVertexArray_remap_index },

-   { 14668, GenVertexArrays_remap_index },

-   { 30209, CopyBufferSubData_remap_index },

-   { 31139, ClientWaitSync_remap_index },

-   {  2648, DeleteSync_remap_index },

-   {  7161, FenceSync_remap_index },

-   { 15216, GetInteger64v_remap_index },

-   { 22577, GetSynciv_remap_index },

-   { 29352, IsSync_remap_index },

-   {  9358, WaitSync_remap_index },

-   {  3836, DrawElementsBaseVertex_remap_index },

-   { 30544, DrawRangeElementsBaseVertex_remap_index },

-   { 26352, MultiDrawElementsBaseVertex_remap_index },

-   { 32083, BlendEquationSeparateiARB_remap_index },

-   { 17740, BlendEquationiARB_remap_index },

-   { 12641, BlendFuncSeparateiARB_remap_index },

-   {  9783, BlendFunciARB_remap_index },

-   {  5078, BindTransformFeedback_remap_index },

-   {  3271, DeleteTransformFeedbacks_remap_index },

-   {  6416, DrawTransformFeedback_remap_index },

-   {  9577, GenTransformFeedbacks_remap_index },

-   { 28265, IsTransformFeedback_remap_index },

-   { 25932, PauseTransformFeedback_remap_index },

-   {  5557, ResumeTransformFeedback_remap_index },

-   { 21635, ClearDepthf_remap_index },

-   {  6720, DepthRangef_remap_index },

-   { 14480, GetShaderPrecisionFormat_remap_index },

-   {  9963, ReleaseShaderCompiler_remap_index },

-   { 10906, ShaderBinary_remap_index },

-   {  5425, PolygonOffsetEXT_remap_index },

-   { 23199, GetPixelTexGenParameterfvSGIS_remap_index },

-   {  4404, GetPixelTexGenParameterivSGIS_remap_index },

-   { 22932, PixelTexGenParameterfSGIS_remap_index },

-   {   663, PixelTexGenParameterfvSGIS_remap_index },

-   { 12710, PixelTexGenParameteriSGIS_remap_index },

-   { 13815, PixelTexGenParameterivSGIS_remap_index },

-   { 18224, SampleMaskSGIS_remap_index },

-   { 19908, SamplePatternSGIS_remap_index },

-   { 26281, ColorPointerEXT_remap_index },

-   { 17534, EdgeFlagPointerEXT_remap_index },

-   {  6037, IndexPointerEXT_remap_index },

-   {  6117, NormalPointerEXT_remap_index },

-   { 15810, TexCoordPointerEXT_remap_index },

-   {  6950, VertexPointerEXT_remap_index },

-   {  3638, PointParameterfEXT_remap_index },

-   {  7801, PointParameterfvEXT_remap_index },

-   { 31976, LockArraysEXT_remap_index },

-   { 14909, UnlockArraysEXT_remap_index },

-   {  1306, SecondaryColor3bEXT_remap_index },

-   {  7960, SecondaryColor3bvEXT_remap_index },

-   { 10416, SecondaryColor3dEXT_remap_index },

-   { 25509, SecondaryColor3dvEXT_remap_index },

-   { 28131, SecondaryColor3fEXT_remap_index },

-   { 18261, SecondaryColor3fvEXT_remap_index },

-   {   509, SecondaryColor3iEXT_remap_index },

-   { 16120, SecondaryColor3ivEXT_remap_index },

-   { 10051, SecondaryColor3sEXT_remap_index },

-   { 30803, SecondaryColor3svEXT_remap_index },

-   { 27216, SecondaryColor3ubEXT_remap_index },

-   { 21206, SecondaryColor3ubvEXT_remap_index },

-   { 12952, SecondaryColor3uiEXT_remap_index },

-   { 22819, SecondaryColor3uivEXT_remap_index },

-   { 25789, SecondaryColor3usEXT_remap_index },

-   { 13025, SecondaryColor3usvEXT_remap_index },

-   { 11775, SecondaryColorPointerEXT_remap_index },

-   { 25603, MultiDrawArraysEXT_remap_index },

-   { 20896, MultiDrawElementsEXT_remap_index },

-   { 21091, FogCoordPointerEXT_remap_index },

-   {  4553, FogCoorddEXT_remap_index },

-   { 31377, FogCoorddvEXT_remap_index },

-   {  4670, FogCoordfEXT_remap_index },

-   { 27139, FogCoordfvEXT_remap_index },

-   { 19130, PixelTexGenSGIX_remap_index },

-   { 27724, BlendFuncSeparateEXT_remap_index },

-   {  6862, FlushVertexArrayRangeNV_remap_index },

-   {  5374, VertexArrayRangeNV_remap_index },

-   { 28196, CombinerInputNV_remap_index },

-   {  2155, CombinerOutputNV_remap_index },

-   { 30956, CombinerParameterfNV_remap_index },

-   {  5248, CombinerParameterfvNV_remap_index },

-   { 22301, CombinerParameteriNV_remap_index },

-   { 32425, CombinerParameterivNV_remap_index },

-   {  7238, FinalCombinerInputNV_remap_index },

-   {  9804, GetCombinerInputParameterfvNV_remap_index },

-   { 32262, GetCombinerInputParameterivNV_remap_index },

-   {   216, GetCombinerOutputParameterfvNV_remap_index },

-   { 13776, GetCombinerOutputParameterivNV_remap_index },

-   {  6624, GetFinalCombinerInputParameterfvNV_remap_index },

-   { 24752, GetFinalCombinerInputParameterivNV_remap_index },

-   { 12619, ResizeBuffersMESA_remap_index },

-   { 11101, WindowPos2dMESA_remap_index },

-   {  1099, WindowPos2dvMESA_remap_index },

-   { 33253, WindowPos2fMESA_remap_index },

-   {  7905, WindowPos2fvMESA_remap_index },

-   { 18171, WindowPos2iMESA_remap_index },

-   { 20381, WindowPos2ivMESA_remap_index },

-   { 20995, WindowPos2sMESA_remap_index },

-   {  5735, WindowPos2svMESA_remap_index },

-   {  7730, WindowPos3dMESA_remap_index },

-   { 14023, WindowPos3dvMESA_remap_index },

-   {   555, WindowPos3fMESA_remap_index },

-   { 14970, WindowPos3fvMESA_remap_index },

-   { 24013, WindowPos3iMESA_remap_index },

-   { 30154, WindowPos3ivMESA_remap_index },

-   { 18825, WindowPos3sMESA_remap_index },

-   { 31633, WindowPos3svMESA_remap_index },

-   { 11052, WindowPos4dMESA_remap_index },

-   { 16988, WindowPos4dvMESA_remap_index },

-   { 13982, WindowPos4fMESA_remap_index },

-   { 30710, WindowPos4fvMESA_remap_index },

-   { 30307, WindowPos4iMESA_remap_index },

-   { 12422, WindowPos4ivMESA_remap_index },

-   { 19009, WindowPos4sMESA_remap_index },

-   {  3222, WindowPos4svMESA_remap_index },

-   { 26847, MultiModeDrawArraysIBM_remap_index },

-   { 28971, MultiModeDrawElementsIBM_remap_index },

-   { 12187, DeleteFencesNV_remap_index },

-   { 28043, FinishFenceNV_remap_index },

-   {  3760, GenFencesNV_remap_index },

-   { 16968, GetFenceivNV_remap_index },

-   {  8197, IsFenceNV_remap_index },

-   { 13703, SetFenceNV_remap_index },

-   {  4217, TestFenceNV_remap_index },

-   { 31604, AreProgramsResidentNV_remap_index },

-   { 30998, BindProgramNV_remap_index },

-   { 25872, DeleteProgramsNV_remap_index },

-   { 21424, ExecuteProgramNV_remap_index },

-   { 33146, GenProgramsNV_remap_index },

-   { 23304, GetProgramParameterdvNV_remap_index },

-   { 10478, GetProgramParameterfvNV_remap_index },

-   { 26255, GetProgramStringNV_remap_index },

-   { 24390, GetProgramivNV_remap_index },

-   { 23567, GetTrackMatrixivNV_remap_index },

-   { 26049, GetVertexAttribPointervNV_remap_index },

-   { 24685, GetVertexAttribdvNV_remap_index },

-   {  9253, GetVertexAttribfvNV_remap_index },

-   { 18432, GetVertexAttribivNV_remap_index },

-   { 19256, IsProgramNV_remap_index },

-   {  9336, LoadProgramNV_remap_index },

-   { 27820, ProgramParameters4dvNV_remap_index },

-   { 24320, ProgramParameters4fvNV_remap_index },

-   { 20685, RequestResidentProgramsNV_remap_index },

-   { 22279, TrackMatrixNV_remap_index },

-   { 32239, VertexAttrib1dNV_remap_index },

-   { 13614, VertexAttrib1dvNV_remap_index },

-   { 28477, VertexAttrib1fNV_remap_index },

-   {  2454, VertexAttrib1fvNV_remap_index },

-   { 30767, VertexAttrib1sNV_remap_index },

-   { 15043, VertexAttrib1svNV_remap_index },

-   {  4832, VertexAttrib2dNV_remap_index },

-   { 13507, VertexAttrib2dvNV_remap_index },

-   { 20140, VertexAttrib2fNV_remap_index },

-   { 13073, VertexAttrib2fvNV_remap_index },

-   {  5947, VertexAttrib2sNV_remap_index },

-   { 18879, VertexAttrib2svNV_remap_index },

-   { 11249, VertexAttrib3dNV_remap_index },

-   { 31854, VertexAttrib3dvNV_remap_index },

-   { 10290, VertexAttrib3fNV_remap_index },

-   { 24712, VertexAttrib3fvNV_remap_index },

-   { 22122, VertexAttrib3sNV_remap_index },

-   { 23594, VertexAttrib3svNV_remap_index },

-   { 28945, VertexAttrib4dNV_remap_index },

-   { 33183, VertexAttrib4dvNV_remap_index },

-   {  4454, VertexAttrib4fNV_remap_index },

-   {  9386, VertexAttrib4fvNV_remap_index },

-   { 26731, VertexAttrib4sNV_remap_index },

-   {  1448, VertexAttrib4svNV_remap_index },

-   {  4990, VertexAttrib4ubNV_remap_index },

-   {   817, VertexAttrib4ubvNV_remap_index },

-   { 21604, VertexAttribPointerNV_remap_index },

-   {  2306, VertexAttribs1dvNV_remap_index },

-   { 26137, VertexAttribs1fvNV_remap_index },

-   { 32983, VertexAttribs1svNV_remap_index },

-   { 10315, VertexAttribs2dvNV_remap_index },

-   { 25274, VertexAttribs2fvNV_remap_index },

-   { 17560, VertexAttribs2svNV_remap_index },

-   {  5276, VertexAttribs3dvNV_remap_index },

-   {  2186, VertexAttribs3fvNV_remap_index },

-   { 29902, VertexAttribs3svNV_remap_index },

-   { 26821, VertexAttribs4dvNV_remap_index },

-   {  5348, VertexAttribs4fvNV_remap_index },

-   { 32770, VertexAttribs4svNV_remap_index },

-   { 29650, VertexAttribs4ubvNV_remap_index },

-   { 26923, GetTexBumpParameterfvATI_remap_index },

-   { 33024, GetTexBumpParameterivATI_remap_index },

-   { 18542, TexBumpParameterfvATI_remap_index },

-   { 20556, TexBumpParameterivATI_remap_index },

-   { 15589, AlphaFragmentOp1ATI_remap_index },

-   { 25555, AlphaFragmentOp2ATI_remap_index },

-   { 24628, AlphaFragmentOp3ATI_remap_index },

-   { 29829, BeginFragmentShaderATI_remap_index },

-   { 31197, BindFragmentShaderATI_remap_index },

-   { 23723, ColorFragmentOp1ATI_remap_index },

-   {  4332, ColorFragmentOp2ATI_remap_index },

-   { 31499, ColorFragmentOp3ATI_remap_index },

-   {  5514, DeleteFragmentShaderATI_remap_index },

-   { 33207, EndFragmentShaderATI_remap_index },

-   { 32453, GenFragmentShadersATI_remap_index },

-   { 25428, PassTexCoordATI_remap_index },

-   {  6930, SampleMapATI_remap_index },

-   { 27034, SetFragmentShaderConstantATI_remap_index },

-   {   402, PointParameteriNV_remap_index },

-   { 14184, PointParameterivNV_remap_index },

-   { 28784, ActiveStencilFaceEXT_remap_index },

-   { 27480, BindVertexArrayAPPLE_remap_index },

-   {  2776, DeleteVertexArraysAPPLE_remap_index },

-   { 18001, GenVertexArraysAPPLE_remap_index },

-   { 23369, IsVertexArrayAPPLE_remap_index },

-   {   858, GetProgramNamedParameterdvNV_remap_index },

-   {  3601, GetProgramNamedParameterfvNV_remap_index },

-   { 26954, ProgramNamedParameter4dNV_remap_index },

-   { 14543, ProgramNamedParameter4dvNV_remap_index },

-   {  8869, ProgramNamedParameter4fNV_remap_index },

-   { 11740, ProgramNamedParameter4fvNV_remap_index },

-   { 16899, PrimitiveRestartIndexNV_remap_index },

-   { 30687, PrimitiveRestartNV_remap_index },

-   { 24299, DepthBoundsEXT_remap_index },

-   {  1198, BlendEquationSeparateEXT_remap_index },

-   { 14744, BindFramebufferEXT_remap_index },

-   { 25648, BindRenderbufferEXT_remap_index },

-   {  9633, CheckFramebufferStatusEXT_remap_index },

-   { 22620, DeleteFramebuffersEXT_remap_index },

-   { 31756, DeleteRenderbuffersEXT_remap_index },

-   { 13531, FramebufferRenderbufferEXT_remap_index },

-   { 13720, FramebufferTexture1DEXT_remap_index },

-   { 11534, FramebufferTexture2DEXT_remap_index },

-   { 11154, FramebufferTexture3DEXT_remap_index },

-   { 23235, GenFramebuffersEXT_remap_index },

-   { 17425, GenRenderbuffersEXT_remap_index },

-   {  6666, GenerateMipmapEXT_remap_index },

-   { 21697, GetFramebufferAttachmentParameterivEXT_remap_index },

-   { 32359, GetRenderbufferParameterivEXT_remap_index },

-   { 20436, IsFramebufferEXT_remap_index },

-   { 33106, IsRenderbufferEXT_remap_index },

-   {  8144, RenderbufferStorageEXT_remap_index },

-   {   734, BlitFramebufferEXT_remap_index },

-   { 14329, BufferParameteriAPPLE_remap_index },

-   { 19288, FlushMappedBufferRangeAPPLE_remap_index },

-   {  1854, BindFragDataLocationEXT_remap_index },

-   { 24412, GetFragDataLocationEXT_remap_index },

-   { 10593, GetUniformuivEXT_remap_index },

-   {  2972, GetVertexAttribIivEXT_remap_index },

-   { 27991, GetVertexAttribIuivEXT_remap_index },

-   { 12020, Uniform1uiEXT_remap_index },

-   { 27905, Uniform1uivEXT_remap_index },

-   { 22218, Uniform2uiEXT_remap_index },

-   {  4296, Uniform2uivEXT_remap_index },

-   { 29224, Uniform3uiEXT_remap_index },

-   { 14690, Uniform3uivEXT_remap_index },

-   {  3525, Uniform4uiEXT_remap_index },

-   {  8645, Uniform4uivEXT_remap_index },

-   { 18389, VertexAttribI1iEXT_remap_index },

-   {  1004, VertexAttribI1ivEXT_remap_index },

-   {  2555, VertexAttribI1uiEXT_remap_index },

-   { 12801, VertexAttribI1uivEXT_remap_index },

-   {    81, VertexAttribI2iEXT_remap_index },

-   { 23835, VertexAttribI2ivEXT_remap_index },

-   {  5302, VertexAttribI2uiEXT_remap_index },

-   {  4715, VertexAttribI2uivEXT_remap_index },

-   { 26523, VertexAttribI3iEXT_remap_index },

-   { 30499, VertexAttribI3ivEXT_remap_index },

-   {  3379, VertexAttribI3uiEXT_remap_index },

-   { 30395, VertexAttribI3uivEXT_remap_index },

-   { 21948, VertexAttribI4bvEXT_remap_index },

-   { 14622, VertexAttribI4iEXT_remap_index },

-   { 32025, VertexAttribI4ivEXT_remap_index },

-   { 13434, VertexAttribI4svEXT_remap_index },

-   { 16484, VertexAttribI4ubvEXT_remap_index },

-   { 16183, VertexAttribI4uiEXT_remap_index },

-   {  5448, VertexAttribI4uivEXT_remap_index },

-   { 11317, VertexAttribI4usvEXT_remap_index },

-   { 18486, VertexAttribIPointerEXT_remap_index },

-   {  3066, FramebufferTextureLayerEXT_remap_index },

-   {  5172, ColorMaskIndexedEXT_remap_index },

-   { 18903, DisableIndexedEXT_remap_index },

-   { 26568, EnableIndexedEXT_remap_index },

-   { 21652, GetBooleanIndexedvEXT_remap_index },

-   { 10928, GetIntegerIndexedvEXT_remap_index },

-   { 22696, IsEnabledIndexedEXT_remap_index },

-   { 22596, ClearColorIiEXT_remap_index },

-   {  3475, ClearColorIuiEXT_remap_index },

-   {  9843, GetTexParameterIivEXT_remap_index },

-   {  5895, GetTexParameterIuivEXT_remap_index },

-   {  3022, TexParameterIivEXT_remap_index },

-   { 26390, TexParameterIuivEXT_remap_index },

-   {  4583, BeginConditionalRenderNV_remap_index },

-   { 25378, EndConditionalRenderNV_remap_index },

-   {  9280, BeginTransformFeedbackEXT_remap_index },

-   { 18938, BindBufferBaseEXT_remap_index },

-   { 18797, BindBufferOffsetEXT_remap_index },

-   { 12247, BindBufferRangeEXT_remap_index },

-   { 14244, EndTransformFeedbackEXT_remap_index },

-   { 10791, GetTransformFeedbackVaryingEXT_remap_index },

-   { 20741, TransformFeedbackVaryingsEXT_remap_index },

-   { 29551, ProvokingVertexEXT_remap_index },

-   { 10739, GetTexParameterPointervAPPLE_remap_index },

-   {  5034, TextureRangeAPPLE_remap_index },

-   { 11606, GetObjectParameterivAPPLE_remap_index },

-   { 19863, ObjectPurgeableAPPLE_remap_index },

-   {  5689, ObjectUnpurgeableAPPLE_remap_index },

-   { 17247, ActiveProgramEXT_remap_index },

-   { 17218, CreateShaderProgramEXT_remap_index },

-   { 28569, UseShaderProgramEXT_remap_index },

-   { 16463, TextureBarrierNV_remap_index },

-   { 28810, StencilFuncSeparateATI_remap_index },

-   { 18090, ProgramEnvParameters4fvEXT_remap_index },

-   { 17112, ProgramLocalParameters4fvEXT_remap_index },

-   { 14112, GetQueryObjecti64vEXT_remap_index },

-   { 10341, GetQueryObjectui64vEXT_remap_index },

-   { 23792, EGLImageTargetRenderbufferStorageOES_remap_index },

-   { 12126, EGLImageTargetTexture2DOES_remap_index },

-   {    -1, -1 }

-};

-

-/* these functions are in the ABI, but have alternative names */

-static const struct gl_function_remap MESA_alt_functions[] = {

-   /* from GL_EXT_blend_color */

-   {  2694, _gloffset_BlendColor },

-   /* from GL_EXT_blend_minmax */

-   { 11211, _gloffset_BlendEquation },

-   /* from GL_EXT_color_subtable */

-   { 17010, _gloffset_ColorSubTable },

-   { 31688, _gloffset_CopyColorSubTable },

-   /* from GL_EXT_convolution */

-   {   296, _gloffset_ConvolutionFilter1D },

-   {  2493, _gloffset_CopyConvolutionFilter1D },

-   {  4097, _gloffset_GetConvolutionParameteriv },

-   {  8493, _gloffset_ConvolutionFilter2D },

-   {  8695, _gloffset_ConvolutionParameteriv },

-   {  9155, _gloffset_ConvolutionParameterfv },

-   { 20584, _gloffset_GetSeparableFilter },

-   { 24067, _gloffset_SeparableFilter2D },

-   { 24930, _gloffset_ConvolutionParameteri },

-   { 25053, _gloffset_ConvolutionParameterf },

-   { 26757, _gloffset_GetConvolutionParameterfv },

-   { 27646, _gloffset_GetConvolutionFilter },

-   { 30091, _gloffset_CopyConvolutionFilter2D },

-   /* from GL_EXT_copy_texture */

-   { 15103, _gloffset_CopyTexSubImage3D },

-   { 16697, _gloffset_CopyTexImage2D },

-   { 24538, _gloffset_CopyTexImage1D },

-   { 27327, _gloffset_CopyTexSubImage2D },

-   { 29729, _gloffset_CopyTexSubImage1D },

-   /* from GL_EXT_draw_range_elements */

-   {  9492, _gloffset_DrawRangeElements },

-   /* from GL_EXT_histogram */

-   {   895, _gloffset_Histogram },

-   {  3561, _gloffset_ResetHistogram },

-   {  9989, _gloffset_GetMinmax },

-   { 15437, _gloffset_GetHistogramParameterfv },

-   { 24463, _gloffset_GetMinmaxParameteriv },

-   { 26647, _gloffset_ResetMinmax },

-   { 27543, _gloffset_GetHistogramParameteriv },

-   { 28744, _gloffset_GetHistogram },

-   { 31313, _gloffset_Minmax },

-   { 32853, _gloffset_GetMinmaxParameterfv },

-   /* from GL_EXT_paletted_texture */

-   {  8355, _gloffset_ColorTable },

-   { 15283, _gloffset_GetColorTable },

-   { 22982, _gloffset_GetColorTableParameterfv },

-   { 25109, _gloffset_GetColorTableParameteriv },

-   /* from GL_EXT_subtexture */

-   {  7076, _gloffset_TexSubImage1D },

-   { 10666, _gloffset_TexSubImage2D },

-   /* from GL_EXT_texture3D */

-   {  1813, _gloffset_TexImage3D },

-   { 22751, _gloffset_TexSubImage3D },

-   /* from GL_EXT_texture_object */

-   {  3329, _gloffset_PrioritizeTextures },

-   {  7525, _gloffset_AreTexturesResident },

-   { 13638, _gloffset_GenTextures },

-   { 15769, _gloffset_DeleteTextures },

-   { 19569, _gloffset_IsTexture },

-   { 29794, _gloffset_BindTexture },

-   /* from GL_EXT_vertex_array */

-   { 24239, _gloffset_ArrayElement },

-   { 30901, _gloffset_GetPointerv },

-   { 32480, _gloffset_DrawArrays },

-   /* from GL_SGI_color_table */

-   {  7643, _gloffset_ColorTableParameteriv },

-   {  8355, _gloffset_ColorTable },

-   { 15283, _gloffset_GetColorTable },

-   { 15393, _gloffset_CopyColorTable },

-   { 19430, _gloffset_ColorTableParameterfv },

-   { 22982, _gloffset_GetColorTableParameterfv },

-   { 25109, _gloffset_GetColorTableParameteriv },

-   /* from GL_VERSION_1_3 */

-   {   464, _gloffset_MultiTexCoord3sARB },

-   {   696, _gloffset_ActiveTextureARB },

-   {  4234, _gloffset_MultiTexCoord1fvARB },

-   {  6142, _gloffset_MultiTexCoord3dARB },

-   {  6187, _gloffset_MultiTexCoord2iARB },

-   {  6311, _gloffset_MultiTexCoord2svARB },

-   {  8311, _gloffset_MultiTexCoord2fARB },

-   { 10371, _gloffset_MultiTexCoord3fvARB },

-   { 10973, _gloffset_MultiTexCoord4sARB },

-   { 11654, _gloffset_MultiTexCoord2dvARB },

-   { 12069, _gloffset_MultiTexCoord1svARB },

-   { 12480, _gloffset_MultiTexCoord3svARB },

-   { 12541, _gloffset_MultiTexCoord4iARB },

-   { 13342, _gloffset_MultiTexCoord3iARB },

-   { 14141, _gloffset_MultiTexCoord1dARB },

-   { 14358, _gloffset_MultiTexCoord3dvARB },

-   { 15637, _gloffset_MultiTexCoord3ivARB },

-   { 15682, _gloffset_MultiTexCoord2sARB },

-   { 17067, _gloffset_MultiTexCoord4ivARB },

-   { 19080, _gloffset_ClientActiveTextureARB },

-   { 21380, _gloffset_MultiTexCoord2dARB },

-   { 21817, _gloffset_MultiTexCoord4dvARB },

-   { 22173, _gloffset_MultiTexCoord4fvARB },

-   { 23123, _gloffset_MultiTexCoord3fARB },

-   { 25693, _gloffset_MultiTexCoord4dARB },

-   { 25959, _gloffset_MultiTexCoord1sARB },

-   { 26163, _gloffset_MultiTexCoord1dvARB },

-   { 27171, _gloffset_MultiTexCoord1ivARB },

-   { 27264, _gloffset_MultiTexCoord2ivARB },

-   { 27603, _gloffset_MultiTexCoord1iARB },

-   { 29019, _gloffset_MultiTexCoord4svARB },

-   { 29593, _gloffset_MultiTexCoord1fARB },

-   { 29856, _gloffset_MultiTexCoord4fARB },

-   { 32314, _gloffset_MultiTexCoord2fvARB },

-   {    -1, -1 }

-};

-

-#endif /* need_MESA_remap_table */

-

-#if defined(need_GL_3DFX_tbuffer)

-static const struct gl_function_remap GL_3DFX_tbuffer_functions[] = {

-   {  9213, -1 }, /* TbufferMask3DFX */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_APPLE_flush_buffer_range)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_APPLE_flush_buffer_range_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_APPLE_object_purgeable)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_APPLE_object_purgeable_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_APPLE_texture_range)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_APPLE_texture_range_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_APPLE_vertex_array_object)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_APPLE_vertex_array_object_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_ES2_compatibility)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_ES2_compatibility_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_copy_buffer)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_copy_buffer_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_draw_buffers)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_draw_buffers_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_draw_buffers_blend)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_draw_buffers_blend_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_draw_elements_base_vertex)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_draw_elements_base_vertex_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_draw_instanced)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_draw_instanced_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_framebuffer_object)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_framebuffer_object_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_geometry_shader4)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_geometry_shader4_functions[] = {

-   { 12444, -1 }, /* FramebufferTextureLayer */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_instanced_arrays)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_instanced_arrays_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_map_buffer_range)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_map_buffer_range_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_matrix_palette)

-static const struct gl_function_remap GL_ARB_matrix_palette_functions[] = {

-   {  3812, -1 }, /* MatrixIndexusvARB */

-   { 13163, -1 }, /* MatrixIndexuivARB */

-   { 14513, -1 }, /* MatrixIndexPointerARB */

-   { 19818, -1 }, /* CurrentPaletteMatrixARB */

-   { 22867, -1 }, /* MatrixIndexubvARB */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_multisample)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_multisample_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_occlusion_query)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_occlusion_query_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_point_parameters)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_point_parameters_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_provoking_vertex)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_provoking_vertex_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_shader_objects)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_shader_objects_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_sync)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_sync_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_texture_compression)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_texture_compression_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_transform_feedback2)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_transform_feedback2_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_transpose_matrix)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_transpose_matrix_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_vertex_array_object)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_vertex_array_object_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_vertex_blend)

-static const struct gl_function_remap GL_ARB_vertex_blend_functions[] = {

-   {  2435, -1 }, /* WeightubvARB */

-   {  6554, -1 }, /* WeightivARB */

-   { 11076, -1 }, /* WeightPointerARB */

-   { 13898, -1 }, /* WeightfvARB */

-   { 17586, -1 }, /* WeightbvARB */

-   { 21048, -1 }, /* WeightusvARB */

-   { 23993, -1 }, /* VertexBlendARB */

-   { 29677, -1 }, /* WeightsvARB */

-   { 31738, -1 }, /* WeightdvARB */

-   { 32514, -1 }, /* WeightuivARB */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_vertex_buffer_object)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_vertex_buffer_object_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_vertex_program)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_vertex_program_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_vertex_shader)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_vertex_shader_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ARB_window_pos)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ARB_window_pos_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ATI_blend_equation_separate)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ATI_blend_equation_separate_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ATI_draw_buffers)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ATI_draw_buffers_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ATI_envmap_bumpmap)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ATI_envmap_bumpmap_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ATI_fragment_shader)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ATI_fragment_shader_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_ATI_separate_stencil)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_ATI_separate_stencil_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_blend_color)

-static const struct gl_function_remap GL_EXT_blend_color_functions[] = {

-   {  2694, _gloffset_BlendColor },

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_blend_equation_separate)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_blend_equation_separate_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_blend_func_separate)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_blend_func_separate_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_blend_minmax)

-static const struct gl_function_remap GL_EXT_blend_minmax_functions[] = {

-   { 11211, _gloffset_BlendEquation },

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_color_subtable)

-static const struct gl_function_remap GL_EXT_color_subtable_functions[] = {

-   { 17010, _gloffset_ColorSubTable },

-   { 31688, _gloffset_CopyColorSubTable },

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_compiled_vertex_array)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_compiled_vertex_array_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_convolution)

-static const struct gl_function_remap GL_EXT_convolution_functions[] = {

-   {   296, _gloffset_ConvolutionFilter1D },

-   {  2493, _gloffset_CopyConvolutionFilter1D },

-   {  4097, _gloffset_GetConvolutionParameteriv },

-   {  8493, _gloffset_ConvolutionFilter2D },

-   {  8695, _gloffset_ConvolutionParameteriv },

-   {  9155, _gloffset_ConvolutionParameterfv },

-   { 20584, _gloffset_GetSeparableFilter },

-   { 24067, _gloffset_SeparableFilter2D },

-   { 24930, _gloffset_ConvolutionParameteri },

-   { 25053, _gloffset_ConvolutionParameterf },

-   { 26757, _gloffset_GetConvolutionParameterfv },

-   { 27646, _gloffset_GetConvolutionFilter },

-   { 30091, _gloffset_CopyConvolutionFilter2D },

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_coordinate_frame)

-static const struct gl_function_remap GL_EXT_coordinate_frame_functions[] = {

-   { 10510, -1 }, /* TangentPointerEXT */

-   { 12599, -1 }, /* Binormal3ivEXT */

-   { 13295, -1 }, /* Tangent3sEXT */

-   { 14578, -1 }, /* Tangent3fvEXT */

-   { 18778, -1 }, /* Tangent3dvEXT */

-   { 19516, -1 }, /* Binormal3bvEXT */

-   { 20637, -1 }, /* Binormal3dEXT */

-   { 22799, -1 }, /* Tangent3fEXT */

-   { 25002, -1 }, /* Binormal3sEXT */

-   { 25470, -1 }, /* Tangent3ivEXT */

-   { 25489, -1 }, /* Tangent3dEXT */

-   { 26436, -1 }, /* Binormal3svEXT */

-   { 27069, -1 }, /* Binormal3fEXT */

-   { 27957, -1 }, /* Binormal3dvEXT */

-   { 29276, -1 }, /* Tangent3iEXT */

-   { 30376, -1 }, /* Tangent3bvEXT */

-   { 30936, -1 }, /* Tangent3bEXT */

-   { 31461, -1 }, /* Binormal3fvEXT */

-   { 32213, -1 }, /* BinormalPointerEXT */

-   { 32618, -1 }, /* Tangent3svEXT */

-   { 33055, -1 }, /* Binormal3bEXT */

-   { 33232, -1 }, /* Binormal3iEXT */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_copy_texture)

-static const struct gl_function_remap GL_EXT_copy_texture_functions[] = {

-   { 15103, _gloffset_CopyTexSubImage3D },

-   { 16697, _gloffset_CopyTexImage2D },

-   { 24538, _gloffset_CopyTexImage1D },

-   { 27327, _gloffset_CopyTexSubImage2D },

-   { 29729, _gloffset_CopyTexSubImage1D },

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_cull_vertex)

-static const struct gl_function_remap GL_EXT_cull_vertex_functions[] = {

-   {  8844, -1 }, /* CullParameterdvEXT */

-   { 11699, -1 }, /* CullParameterfvEXT */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_depth_bounds_test)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_depth_bounds_test_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_draw_buffers2)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_draw_buffers2_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_draw_instanced)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_draw_instanced_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_draw_range_elements)

-static const struct gl_function_remap GL_EXT_draw_range_elements_functions[] = {

-   {  9492, _gloffset_DrawRangeElements },

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_fog_coord)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_fog_coord_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_framebuffer_blit)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_framebuffer_blit_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_framebuffer_multisample)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_framebuffer_multisample_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_framebuffer_object)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_framebuffer_object_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_gpu_program_parameters)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_gpu_program_parameters_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_gpu_shader4)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_gpu_shader4_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_histogram)

-static const struct gl_function_remap GL_EXT_histogram_functions[] = {

-   {   895, _gloffset_Histogram },

-   {  3561, _gloffset_ResetHistogram },

-   {  9989, _gloffset_GetMinmax },

-   { 15437, _gloffset_GetHistogramParameterfv },

-   { 24463, _gloffset_GetMinmaxParameteriv },

-   { 26647, _gloffset_ResetMinmax },

-   { 27543, _gloffset_GetHistogramParameteriv },

-   { 28744, _gloffset_GetHistogram },

-   { 31313, _gloffset_Minmax },

-   { 32853, _gloffset_GetMinmaxParameterfv },

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_index_func)

-static const struct gl_function_remap GL_EXT_index_func_functions[] = {

-   { 11485, -1 }, /* IndexFuncEXT */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_index_material)

-static const struct gl_function_remap GL_EXT_index_material_functions[] = {

-   { 21135, -1 }, /* IndexMaterialEXT */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_light_texture)

-static const struct gl_function_remap GL_EXT_light_texture_functions[] = {

-   { 26456, -1 }, /* ApplyTextureEXT */

-   { 26601, -1 }, /* TextureMaterialEXT */

-   { 26626, -1 }, /* TextureLightEXT */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_multi_draw_arrays)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_multi_draw_arrays_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_multisample)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_multisample_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_paletted_texture)

-static const struct gl_function_remap GL_EXT_paletted_texture_functions[] = {

-   {  8355, _gloffset_ColorTable },

-   { 15283, _gloffset_GetColorTable },

-   { 22982, _gloffset_GetColorTableParameterfv },

-   { 25109, _gloffset_GetColorTableParameteriv },

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_pixel_transform)

-static const struct gl_function_remap GL_EXT_pixel_transform_functions[] = {

-   { 21782, -1 }, /* PixelTransformParameterfEXT */

-   { 21862, -1 }, /* PixelTransformParameteriEXT */

-   { 30651, -1 }, /* PixelTransformParameterfvEXT */

-   { 32177, -1 }, /* PixelTransformParameterivEXT */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_point_parameters)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_point_parameters_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_polygon_offset)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_polygon_offset_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_provoking_vertex)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_provoking_vertex_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_secondary_color)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_secondary_color_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_separate_shader_objects)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_separate_shader_objects_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_stencil_two_side)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_stencil_two_side_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_subtexture)

-static const struct gl_function_remap GL_EXT_subtexture_functions[] = {

-   {  7076, _gloffset_TexSubImage1D },

-   { 10666, _gloffset_TexSubImage2D },

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_texture3D)

-static const struct gl_function_remap GL_EXT_texture3D_functions[] = {

-   {  1813, _gloffset_TexImage3D },

-   { 22751, _gloffset_TexSubImage3D },

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_texture_array)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_texture_array_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_texture_integer)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_texture_integer_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_texture_object)

-static const struct gl_function_remap GL_EXT_texture_object_functions[] = {

-   {  3329, _gloffset_PrioritizeTextures },

-   {  7525, _gloffset_AreTexturesResident },

-   { 13638, _gloffset_GenTextures },

-   { 15769, _gloffset_DeleteTextures },

-   { 19569, _gloffset_IsTexture },

-   { 29794, _gloffset_BindTexture },

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_texture_perturb_normal)

-static const struct gl_function_remap GL_EXT_texture_perturb_normal_functions[] = {

-   { 13848, -1 }, /* TextureNormalEXT */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_timer_query)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_timer_query_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_transform_feedback)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_transform_feedback_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_vertex_array)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_EXT_vertex_array_functions[] = {

-   { 24239, _gloffset_ArrayElement },

-   { 30901, _gloffset_GetPointerv },

-   { 32480, _gloffset_DrawArrays },

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_EXT_vertex_weighting)

-static const struct gl_function_remap GL_EXT_vertex_weighting_functions[] = {

-   { 19599, -1 }, /* VertexWeightfvEXT */

-   { 27012, -1 }, /* VertexWeightfEXT */

-   { 28713, -1 }, /* VertexWeightPointerEXT */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_HP_image_transform)

-static const struct gl_function_remap GL_HP_image_transform_functions[] = {

-   {  2366, -1 }, /* GetImageTransformParameterfvHP */

-   {  3778, -1 }, /* ImageTransformParameterfHP */

-   { 10204, -1 }, /* ImageTransformParameterfvHP */

-   { 11954, -1 }, /* ImageTransformParameteriHP */

-   { 12334, -1 }, /* GetImageTransformParameterivHP */

-   { 19663, -1 }, /* ImageTransformParameterivHP */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_IBM_multimode_draw_arrays)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_IBM_multimode_draw_arrays_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_IBM_vertex_array_lists)

-static const struct gl_function_remap GL_IBM_vertex_array_lists_functions[] = {

-   {  4366, -1 }, /* SecondaryColorPointerListIBM */

-   {  6008, -1 }, /* NormalPointerListIBM */

-   {  7699, -1 }, /* FogCoordPointerListIBM */

-   {  8006, -1 }, /* VertexPointerListIBM */

-   { 11875, -1 }, /* ColorPointerListIBM */

-   { 13402, -1 }, /* TexCoordPointerListIBM */

-   { 13870, -1 }, /* IndexPointerListIBM */

-   { 32796, -1 }, /* EdgeFlagPointerListIBM */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_INGR_blend_func_separate)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_INGR_blend_func_separate_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_INTEL_parallel_arrays)

-static const struct gl_function_remap GL_INTEL_parallel_arrays_functions[] = {

-   { 12742, -1 }, /* VertexPointervINTEL */

-   { 15530, -1 }, /* ColorPointervINTEL */

-   { 30065, -1 }, /* NormalPointervINTEL */

-   { 30583, -1 }, /* TexCoordPointervINTEL */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_MESA_resize_buffers)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_MESA_resize_buffers_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_MESA_shader_debug)

-static const struct gl_function_remap GL_MESA_shader_debug_functions[] = {

-   {  1677, -1 }, /* GetDebugLogLengthMESA */

-   {  3500, -1 }, /* ClearDebugLogMESA */

-   {  4527, -1 }, /* GetDebugLogMESA */

-   { 31094, -1 }, /* CreateDebugObjectMESA */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_MESA_window_pos)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_MESA_window_pos_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_NV_condtitional_render)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_NV_condtitional_render_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_NV_evaluators)

-static const struct gl_function_remap GL_NV_evaluators_functions[] = {

-   {  6738, -1 }, /* GetMapAttribParameterivNV */

-   {  8461, -1 }, /* MapControlPointsNV */

-   {  8560, -1 }, /* MapParameterfvNV */

-   { 10649, -1 }, /* EvalMapsNV */

-   { 17184, -1 }, /* GetMapAttribParameterfvNV */

-   { 17401, -1 }, /* MapParameterivNV */

-   { 24853, -1 }, /* GetMapParameterivNV */

-   { 25351, -1 }, /* GetMapParameterfvNV */

-   { 29380, -1 }, /* GetMapControlPointsNV */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_NV_fence)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_NV_fence_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_NV_fragment_program)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_NV_fragment_program_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_NV_point_sprite)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_NV_point_sprite_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_NV_primitive_restart)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_NV_primitive_restart_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_NV_register_combiners)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_NV_register_combiners_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_NV_register_combiners2)

-static const struct gl_function_remap GL_NV_register_combiners2_functions[] = {

-   { 15922, -1 }, /* CombinerStageParameterfvNV */

-   { 16318, -1 }, /* GetCombinerStageParameterfvNV */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_NV_texture_barrier)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_NV_texture_barrier_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_NV_vertex_array_range)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_NV_vertex_array_range_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_NV_vertex_program)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_NV_vertex_program_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_OES_EGL_image)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_OES_EGL_image_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_PGI_misc_hints)

-static const struct gl_function_remap GL_PGI_misc_hints_functions[] = {

-   {  8681, -1 }, /* HintPGI */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIS_detail_texture)

-static const struct gl_function_remap GL_SGIS_detail_texture_functions[] = {

-   { 16291, -1 }, /* GetDetailTexFuncSGIS */

-   { 16642, -1 }, /* DetailTexFuncSGIS */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIS_fog_function)

-static const struct gl_function_remap GL_SGIS_fog_function_functions[] = {

-   { 27309, -1 }, /* FogFuncSGIS */

-   { 28062, -1 }, /* GetFogFuncSGIS */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIS_multisample)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_SGIS_multisample_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIS_pixel_texture)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_SGIS_pixel_texture_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIS_point_parameters)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_SGIS_point_parameters_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIS_sharpen_texture)

-static const struct gl_function_remap GL_SGIS_sharpen_texture_functions[] = {

-   {  6799, -1 }, /* GetSharpenTexFuncSGIS */

-   { 22147, -1 }, /* SharpenTexFuncSGIS */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIS_texture4D)

-static const struct gl_function_remap GL_SGIS_texture4D_functions[] = {

-   {  1049, -1 }, /* TexImage4DSGIS */

-   { 15838, -1 }, /* TexSubImage4DSGIS */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIS_texture_color_mask)

-static const struct gl_function_remap GL_SGIS_texture_color_mask_functions[] = {

-   { 15236, -1 }, /* TextureColorMaskSGIS */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIS_texture_filter4)

-static const struct gl_function_remap GL_SGIS_texture_filter4_functions[] = {

-   {  6976, -1 }, /* GetTexFilterFuncSGIS */

-   { 16437, -1 }, /* TexFilterFuncSGIS */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIX_async)

-static const struct gl_function_remap GL_SGIX_async_functions[] = {

-   {  3426, -1 }, /* AsyncMarkerSGIX */

-   {  4506, -1 }, /* FinishAsyncSGIX */

-   {  5495, -1 }, /* PollAsyncSGIX */

-   { 22328, -1 }, /* DeleteAsyncMarkersSGIX */

-   { 22383, -1 }, /* IsAsyncMarkerSGIX */

-   { 32593, -1 }, /* GenAsyncMarkersSGIX */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIX_flush_raster)

-static const struct gl_function_remap GL_SGIX_flush_raster_functions[] = {

-   {  7353, -1 }, /* FlushRasterSGIX */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIX_fragment_lighting)

-static const struct gl_function_remap GL_SGIX_fragment_lighting_functions[] = {

-   {  2664, -1 }, /* FragmentMaterialfvSGIX */

-   {  5399, -1 }, /* FragmentLightiSGIX */

-   {  8073, -1 }, /* FragmentMaterialfSGIX */

-   {  8234, -1 }, /* GetFragmentLightivSGIX */

-   {  9107, -1 }, /* FragmentLightModeliSGIX */

-   { 10712, -1 }, /* FragmentLightivSGIX */

-   { 11019, -1 }, /* GetFragmentMaterialivSGIX */

-   { 16231, -1 }, /* GetFragmentMaterialfvSGIX */

-   { 19486, -1 }, /* FragmentLightModelfSGIX */

-   { 19786, -1 }, /* FragmentColorMaterialSGIX */

-   { 20203, -1 }, /* FragmentMaterialiSGIX */

-   { 21463, -1 }, /* LightEnviSGIX */

-   { 23074, -1 }, /* FragmentLightModelfvSGIX */

-   { 23409, -1 }, /* FragmentLightfvSGIX */

-   { 28446, -1 }, /* FragmentLightModelivSGIX */

-   { 28595, -1 }, /* FragmentLightfSGIX */

-   { 31431, -1 }, /* GetFragmentLightfvSGIX */

-   { 33076, -1 }, /* FragmentMaterialivSGIX */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIX_framezoom)

-static const struct gl_function_remap GL_SGIX_framezoom_functions[] = {

-   { 22406, -1 }, /* FrameZoomSGIX */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIX_igloo_interface)

-static const struct gl_function_remap GL_SGIX_igloo_interface_functions[] = {

-   { 28903, -1 }, /* IglooInterfaceSGIX */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIX_instruments)

-static const struct gl_function_remap GL_SGIX_instruments_functions[] = {

-   {  2844, -1 }, /* ReadInstrumentsSGIX */

-   {  6572, -1 }, /* PollInstrumentsSGIX */

-   { 10570, -1 }, /* GetInstrumentsSGIX */

-   { 13000, -1 }, /* StartInstrumentsSGIX */

-   { 15956, -1 }, /* StopInstrumentsSGIX */

-   { 17823, -1 }, /* InstrumentsBufferSGIX */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIX_list_priority)

-static const struct gl_function_remap GL_SGIX_list_priority_functions[] = {

-   {  1280, -1 }, /* ListParameterfSGIX */

-   {  3128, -1 }, /* GetListParameterfvSGIX */

-   { 17714, -1 }, /* ListParameteriSGIX */

-   { 18728, -1 }, /* ListParameterfvSGIX */

-   { 20869, -1 }, /* ListParameterivSGIX */

-   { 32637, -1 }, /* GetListParameterivSGIX */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIX_pixel_texture)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_SGIX_pixel_texture_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIX_polynomial_ffd)

-static const struct gl_function_remap GL_SGIX_polynomial_ffd_functions[] = {

-   {  3724, -1 }, /* LoadIdentityDeformationMapSGIX */

-   { 12208, -1 }, /* DeformationMap3dSGIX */

-   { 16056, -1 }, /* DeformSGIX */

-   { 24351, -1 }, /* DeformationMap3fSGIX */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIX_reference_plane)

-static const struct gl_function_remap GL_SGIX_reference_plane_functions[] = {

-   { 14787, -1 }, /* ReferencePlaneSGIX */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIX_sprite)

-static const struct gl_function_remap GL_SGIX_sprite_functions[] = {

-   {  9605, -1 }, /* SpriteParameterfvSGIX */

-   { 20658, -1 }, /* SpriteParameteriSGIX */

-   { 26681, -1 }, /* SpriteParameterfSGIX */

-   { 29523, -1 }, /* SpriteParameterivSGIX */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGIX_tag_sample_buffer)

-static const struct gl_function_remap GL_SGIX_tag_sample_buffer_functions[] = {

-   { 20717, -1 }, /* TagSampleBufferSGIX */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SGI_color_table)

-static const struct gl_function_remap GL_SGI_color_table_functions[] = {

-   {  7643, _gloffset_ColorTableParameteriv },

-   {  8355, _gloffset_ColorTable },

-   { 15283, _gloffset_GetColorTable },

-   { 15393, _gloffset_CopyColorTable },

-   { 19430, _gloffset_ColorTableParameterfv },

-   { 22982, _gloffset_GetColorTableParameterfv },

-   { 25109, _gloffset_GetColorTableParameteriv },

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SUNX_constant_data)

-static const struct gl_function_remap GL_SUNX_constant_data_functions[] = {

-   { 31409, -1 }, /* FinishTextureSUNX */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SUN_global_alpha)

-static const struct gl_function_remap GL_SUN_global_alpha_functions[] = {

-   {  3447, -1 }, /* GlobalAlphaFactorubSUN */

-   {  4805, -1 }, /* GlobalAlphaFactoriSUN */

-   {  6597, -1 }, /* GlobalAlphaFactordSUN */

-   {  9689, -1 }, /* GlobalAlphaFactoruiSUN */

-   { 10161, -1 }, /* GlobalAlphaFactorbSUN */

-   { 13315, -1 }, /* GlobalAlphaFactorfSUN */

-   { 13479, -1 }, /* GlobalAlphaFactorusSUN */

-   { 22669, -1 }, /* GlobalAlphaFactorsSUN */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SUN_mesh_array)

-static const struct gl_function_remap GL_SUN_mesh_array_functions[] = {

-   { 29314, -1 }, /* DrawMeshArraysSUN */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SUN_triangle_list)

-static const struct gl_function_remap GL_SUN_triangle_list_functions[] = {

-   {  4480, -1 }, /* ReplacementCodeubSUN */

-   {  6356, -1 }, /* ReplacementCodeubvSUN */

-   { 19151, -1 }, /* ReplacementCodeusvSUN */

-   { 19339, -1 }, /* ReplacementCodePointerSUN */

-   { 21527, -1 }, /* ReplacementCodeuiSUN */

-   { 22357, -1 }, /* ReplacementCodeusSUN */

-   { 29980, -1 }, /* ReplacementCodeuivSUN */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_SUN_vertex)

-static const struct gl_function_remap GL_SUN_vertex_functions[] = {

-   {  1154, -1 }, /* ReplacementCodeuiColor3fVertex3fvSUN */

-   {  1352, -1 }, /* TexCoord4fColor4fNormal3fVertex4fvSUN */

-   {  1578, -1 }, /* TexCoord2fColor4ubVertex3fvSUN */

-   {  1908, -1 }, /* ReplacementCodeuiVertex3fvSUN */

-   {  2042, -1 }, /* ReplacementCodeuiTexCoord2fVertex3fvSUN */

-   {  2600, -1 }, /* ReplacementCodeuiNormal3fVertex3fSUN */

-   {  2913, -1 }, /* Color4ubVertex3fvSUN */

-   {  4639, -1 }, /* Color4ubVertex3fSUN */

-   {  4762, -1 }, /* TexCoord2fVertex3fSUN */

-   {  5106, -1 }, /* TexCoord2fColor4fNormal3fVertex3fSUN */

-   {  5599, -1 }, /* TexCoord2fNormal3fVertex3fvSUN */

-   {  6251, -1 }, /* ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN */

-   {  7031, -1 }, /* ReplacementCodeuiColor4ubVertex3fvSUN */

-   {  7390, -1 }, /* ReplacementCodeuiTexCoord2fVertex3fSUN */

-   {  8102, -1 }, /* TexCoord2fNormal3fVertex3fSUN */

-   {  8906, -1 }, /* Color3fVertex3fSUN */

-   { 10097, -1 }, /* Color3fVertex3fvSUN */

-   { 10535, -1 }, /* Color4fNormal3fVertex3fvSUN */

-   { 11364, -1 }, /* ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN */

-   { 12863, -1 }, /* ReplacementCodeuiColor4fNormal3fVertex3fvSUN */

-   { 14403, -1 }, /* ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN */

-   { 14929, -1 }, /* TexCoord2fColor3fVertex3fSUN */

-   { 15981, -1 }, /* TexCoord4fColor4fNormal3fVertex4fSUN */

-   { 16396, -1 }, /* Color4ubVertex2fvSUN */

-   { 16667, -1 }, /* Normal3fVertex3fSUN */

-   { 17764, -1 }, /* ReplacementCodeuiColor4fNormal3fVertex3fSUN */

-   { 18125, -1 }, /* TexCoord2fColor4fNormal3fVertex3fvSUN */

-   { 18980, -1 }, /* TexCoord2fVertex3fvSUN */

-   { 19756, -1 }, /* Color4ubVertex2fSUN */

-   { 19994, -1 }, /* ReplacementCodeuiColor4ubVertex3fSUN */

-   { 21993, -1 }, /* TexCoord2fColor4ubVertex3fSUN */

-   { 22425, -1 }, /* Normal3fVertex3fvSUN */

-   { 22891, -1 }, /* Color4fNormal3fVertex3fSUN */

-   { 23900, -1 }, /* ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN */

-   { 26002, -1 }, /* ReplacementCodeuiColor3fVertex3fSUN */

-   { 27425, -1 }, /* TexCoord4fVertex4fSUN */

-   { 27851, -1 }, /* TexCoord2fColor3fVertex3fvSUN */

-   { 28290, -1 }, /* ReplacementCodeuiNormal3fVertex3fvSUN */

-   { 28417, -1 }, /* TexCoord4fVertex4fvSUN */

-   { 29151, -1 }, /* ReplacementCodeuiVertex3fSUN */

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_VERSION_1_3)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_VERSION_1_3_functions[] = {

-   {   464, _gloffset_MultiTexCoord3sARB },

-   {   696, _gloffset_ActiveTextureARB },

-   {  4234, _gloffset_MultiTexCoord1fvARB },

-   {  6142, _gloffset_MultiTexCoord3dARB },

-   {  6187, _gloffset_MultiTexCoord2iARB },

-   {  6311, _gloffset_MultiTexCoord2svARB },

-   {  8311, _gloffset_MultiTexCoord2fARB },

-   { 10371, _gloffset_MultiTexCoord3fvARB },

-   { 10973, _gloffset_MultiTexCoord4sARB },

-   { 11654, _gloffset_MultiTexCoord2dvARB },

-   { 12069, _gloffset_MultiTexCoord1svARB },

-   { 12480, _gloffset_MultiTexCoord3svARB },

-   { 12541, _gloffset_MultiTexCoord4iARB },

-   { 13342, _gloffset_MultiTexCoord3iARB },

-   { 14141, _gloffset_MultiTexCoord1dARB },

-   { 14358, _gloffset_MultiTexCoord3dvARB },

-   { 15637, _gloffset_MultiTexCoord3ivARB },

-   { 15682, _gloffset_MultiTexCoord2sARB },

-   { 17067, _gloffset_MultiTexCoord4ivARB },

-   { 19080, _gloffset_ClientActiveTextureARB },

-   { 21380, _gloffset_MultiTexCoord2dARB },

-   { 21817, _gloffset_MultiTexCoord4dvARB },

-   { 22173, _gloffset_MultiTexCoord4fvARB },

-   { 23123, _gloffset_MultiTexCoord3fARB },

-   { 25693, _gloffset_MultiTexCoord4dARB },

-   { 25959, _gloffset_MultiTexCoord1sARB },

-   { 26163, _gloffset_MultiTexCoord1dvARB },

-   { 27171, _gloffset_MultiTexCoord1ivARB },

-   { 27264, _gloffset_MultiTexCoord2ivARB },

-   { 27603, _gloffset_MultiTexCoord1iARB },

-   { 29019, _gloffset_MultiTexCoord4svARB },

-   { 29593, _gloffset_MultiTexCoord1fARB },

-   { 29856, _gloffset_MultiTexCoord4fARB },

-   { 32314, _gloffset_MultiTexCoord2fvARB },

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_VERSION_1_4)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_VERSION_1_4_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_VERSION_1_5)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_VERSION_1_5_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_VERSION_2_0)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_VERSION_2_0_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_VERSION_2_1)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_VERSION_2_1_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_VERSION_3_0)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_VERSION_3_0_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_VERSION_3_1)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_VERSION_3_1_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_VERSION_3_2)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_VERSION_3_2_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

-#if defined(need_GL_VERSION_3_3)

-/* functions defined in MESA_remap_table_functions are excluded */

-static const struct gl_function_remap GL_VERSION_3_3_functions[] = {

-   {    -1, -1 }

-};

-#endif

-

+/* DO NOT EDIT - This file generated automatically by remap_helper.py (from Mesa) script */
+
+/*
+ * Copyright (C) 2009 Chia-I Wu <olv@0xlab.org>
+ * 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
+ * Chia-I Wu,
+ * 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 "main/dispatch.h"
+#include "main/remap.h"
+
+/* this is internal to remap.c */
+#ifdef need_MESA_remap_table
+
+static const char _mesa_function_pool[] =
+   /* _mesa_function_pool[0]: MapGrid1d (offset 224) */
+   "idd\0"
+   "glMapGrid1d\0"
+   "\0"
+   /* _mesa_function_pool[17]: UniformMatrix3fvARB (will be remapped) */
+   "iiip\0"
+   "glUniformMatrix3fv\0"
+   "glUniformMatrix3fvARB\0"
+   "\0"
+   /* _mesa_function_pool[64]: MapGrid1f (offset 225) */
+   "iff\0"
+   "glMapGrid1f\0"
+   "\0"
+   /* _mesa_function_pool[81]: VertexAttribI2iEXT (will be remapped) */
+   "iii\0"
+   "glVertexAttribI2iEXT\0"
+   "glVertexAttribI2i\0"
+   "\0"
+   /* _mesa_function_pool[125]: RasterPos4i (offset 82) */
+   "iiii\0"
+   "glRasterPos4i\0"
+   "\0"
+   /* _mesa_function_pool[145]: RasterPos4d (offset 78) */
+   "dddd\0"
+   "glRasterPos4d\0"
+   "\0"
+   /* _mesa_function_pool[165]: NewList (dynamic) */
+   "ii\0"
+   "glNewList\0"
+   "\0"
+   /* _mesa_function_pool[179]: RasterPos4f (offset 80) */
+   "ffff\0"
+   "glRasterPos4f\0"
+   "\0"
+   /* _mesa_function_pool[199]: LoadIdentity (offset 290) */
+   "\0"
+   "glLoadIdentity\0"
+   "\0"
+   /* _mesa_function_pool[216]: GetCombinerOutputParameterfvNV (will be remapped) */
+   "iiip\0"
+   "glGetCombinerOutputParameterfvNV\0"
+   "\0"
+   /* _mesa_function_pool[255]: SampleCoverageARB (will be remapped) */
+   "fi\0"
+   "glSampleCoverage\0"
+   "glSampleCoverageARB\0"
+   "\0"
+   /* _mesa_function_pool[296]: ConvolutionFilter1D (offset 348) */
+   "iiiiip\0"
+   "glConvolutionFilter1D\0"
+   "glConvolutionFilter1DEXT\0"
+   "\0"
+   /* _mesa_function_pool[351]: BeginQueryARB (will be remapped) */
+   "ii\0"
+   "glBeginQuery\0"
+   "glBeginQueryARB\0"
+   "\0"
+   /* _mesa_function_pool[384]: RasterPos3dv (offset 71) */
+   "p\0"
+   "glRasterPos3dv\0"
+   "\0"
+   /* _mesa_function_pool[402]: PointParameteriNV (will be remapped) */
+   "ii\0"
+   "glPointParameteri\0"
+   "glPointParameteriNV\0"
+   "\0"
+   /* _mesa_function_pool[444]: GetProgramiv (will be remapped) */
+   "iip\0"
+   "glGetProgramiv\0"
+   "\0"
+   /* _mesa_function_pool[464]: MultiTexCoord3sARB (offset 398) */
+   "iiii\0"
+   "glMultiTexCoord3s\0"
+   "glMultiTexCoord3sARB\0"
+   "\0"
+   /* _mesa_function_pool[509]: SecondaryColor3iEXT (will be remapped) */
+   "iii\0"
+   "glSecondaryColor3i\0"
+   "glSecondaryColor3iEXT\0"
+   "\0"
+   /* _mesa_function_pool[555]: WindowPos3fMESA (will be remapped) */
+   "fff\0"
+   "glWindowPos3f\0"
+   "glWindowPos3fARB\0"
+   "glWindowPos3fMESA\0"
+   "\0"
+   /* _mesa_function_pool[609]: TexCoord1iv (offset 99) */
+   "p\0"
+   "glTexCoord1iv\0"
+   "\0"
+   /* _mesa_function_pool[626]: TexCoord4sv (offset 125) */
+   "p\0"
+   "glTexCoord4sv\0"
+   "\0"
+   /* _mesa_function_pool[643]: RasterPos4s (offset 84) */
+   "iiii\0"
+   "glRasterPos4s\0"
+   "\0"
+   /* _mesa_function_pool[663]: PixelTexGenParameterfvSGIS (will be remapped) */
+   "ip\0"
+   "glPixelTexGenParameterfvSGIS\0"
+   "\0"
+   /* _mesa_function_pool[696]: ActiveTextureARB (offset 374) */
+   "i\0"
+   "glActiveTexture\0"
+   "glActiveTextureARB\0"
+   "\0"
+   /* _mesa_function_pool[734]: BlitFramebufferEXT (will be remapped) */
+   "iiiiiiiiii\0"
+   "glBlitFramebuffer\0"
+   "glBlitFramebufferEXT\0"
+   "\0"
+   /* _mesa_function_pool[785]: TexCoord1f (offset 96) */
+   "f\0"
+   "glTexCoord1f\0"
+   "\0"
+   /* _mesa_function_pool[801]: TexCoord1d (offset 94) */
+   "d\0"
+   "glTexCoord1d\0"
+   "\0"
+   /* _mesa_function_pool[817]: VertexAttrib4ubvNV (will be remapped) */
+   "ip\0"
+   "glVertexAttrib4ubvNV\0"
+   "\0"
+   /* _mesa_function_pool[842]: TexCoord1i (offset 98) */
+   "i\0"
+   "glTexCoord1i\0"
+   "\0"
+   /* _mesa_function_pool[858]: GetProgramNamedParameterdvNV (will be remapped) */
+   "iipp\0"
+   "glGetProgramNamedParameterdvNV\0"
+   "\0"
+   /* _mesa_function_pool[895]: Histogram (offset 367) */
+   "iiii\0"
+   "glHistogram\0"
+   "glHistogramEXT\0"
+   "\0"
+   /* _mesa_function_pool[928]: TexCoord1s (offset 100) */
+   "i\0"
+   "glTexCoord1s\0"
+   "\0"
+   /* _mesa_function_pool[944]: GetMapfv (offset 267) */
+   "iip\0"
+   "glGetMapfv\0"
+   "\0"
+   /* _mesa_function_pool[960]: EvalCoord1f (offset 230) */
+   "f\0"
+   "glEvalCoord1f\0"
+   "\0"
+   /* _mesa_function_pool[977]: FramebufferTexture (will be remapped) */
+   "iiii\0"
+   "glFramebufferTexture\0"
+   "\0"
+   /* _mesa_function_pool[1004]: VertexAttribI1ivEXT (will be remapped) */
+   "ip\0"
+   "glVertexAttribI1ivEXT\0"
+   "glVertexAttribI1iv\0"
+   "\0"
+   /* _mesa_function_pool[1049]: TexImage4DSGIS (dynamic) */
+   "iiiiiiiiiip\0"
+   "glTexImage4DSGIS\0"
+   "\0"
+   /* _mesa_function_pool[1079]: PolygonStipple (offset 175) */
+   "p\0"
+   "glPolygonStipple\0"
+   "\0"
+   /* _mesa_function_pool[1099]: WindowPos2dvMESA (will be remapped) */
+   "p\0"
+   "glWindowPos2dv\0"
+   "glWindowPos2dvARB\0"
+   "glWindowPos2dvMESA\0"
+   "\0"
+   /* _mesa_function_pool[1154]: ReplacementCodeuiColor3fVertex3fvSUN (dynamic) */
+   "ppp\0"
+   "glReplacementCodeuiColor3fVertex3fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[1198]: BlendEquationSeparateEXT (will be remapped) */
+   "ii\0"
+   "glBlendEquationSeparate\0"
+   "glBlendEquationSeparateEXT\0"
+   "glBlendEquationSeparateATI\0"
+   "\0"
+   /* _mesa_function_pool[1280]: ListParameterfSGIX (dynamic) */
+   "iif\0"
+   "glListParameterfSGIX\0"
+   "\0"
+   /* _mesa_function_pool[1306]: SecondaryColor3bEXT (will be remapped) */
+   "iii\0"
+   "glSecondaryColor3b\0"
+   "glSecondaryColor3bEXT\0"
+   "\0"
+   /* _mesa_function_pool[1352]: TexCoord4fColor4fNormal3fVertex4fvSUN (dynamic) */
+   "pppp\0"
+   "glTexCoord4fColor4fNormal3fVertex4fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[1398]: GetPixelMapfv (offset 271) */
+   "ip\0"
+   "glGetPixelMapfv\0"
+   "\0"
+   /* _mesa_function_pool[1418]: Color3uiv (offset 22) */
+   "p\0"
+   "glColor3uiv\0"
+   "\0"
+   /* _mesa_function_pool[1433]: IsEnabled (offset 286) */
+   "i\0"
+   "glIsEnabled\0"
+   "\0"
+   /* _mesa_function_pool[1448]: VertexAttrib4svNV (will be remapped) */
+   "ip\0"
+   "glVertexAttrib4svNV\0"
+   "\0"
+   /* _mesa_function_pool[1472]: EvalCoord2fv (offset 235) */
+   "p\0"
+   "glEvalCoord2fv\0"
+   "\0"
+   /* _mesa_function_pool[1490]: GetBufferSubDataARB (will be remapped) */
+   "iiip\0"
+   "glGetBufferSubData\0"
+   "glGetBufferSubDataARB\0"
+   "\0"
+   /* _mesa_function_pool[1537]: BufferSubDataARB (will be remapped) */
+   "iiip\0"
+   "glBufferSubData\0"
+   "glBufferSubDataARB\0"
+   "\0"
+   /* _mesa_function_pool[1578]: TexCoord2fColor4ubVertex3fvSUN (dynamic) */
+   "ppp\0"
+   "glTexCoord2fColor4ubVertex3fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[1616]: AttachShader (will be remapped) */
+   "ii\0"
+   "glAttachShader\0"
+   "\0"
+   /* _mesa_function_pool[1635]: VertexAttrib2fARB (will be remapped) */
+   "iff\0"
+   "glVertexAttrib2f\0"
+   "glVertexAttrib2fARB\0"
+   "\0"
+   /* _mesa_function_pool[1677]: GetDebugLogLengthMESA (dynamic) */
+   "iii\0"
+   "glGetDebugLogLengthMESA\0"
+   "\0"
+   /* _mesa_function_pool[1706]: GetMapiv (offset 268) */
+   "iip\0"
+   "glGetMapiv\0"
+   "\0"
+   /* _mesa_function_pool[1722]: VertexAttrib3fARB (will be remapped) */
+   "ifff\0"
+   "glVertexAttrib3f\0"
+   "glVertexAttrib3fARB\0"
+   "\0"
+   /* _mesa_function_pool[1765]: Indexubv (offset 316) */
+   "p\0"
+   "glIndexubv\0"
+   "\0"
+   /* _mesa_function_pool[1779]: GetQueryivARB (will be remapped) */
+   "iip\0"
+   "glGetQueryiv\0"
+   "glGetQueryivARB\0"
+   "\0"
+   /* _mesa_function_pool[1813]: TexImage3D (offset 371) */
+   "iiiiiiiiip\0"
+   "glTexImage3D\0"
+   "glTexImage3DEXT\0"
+   "\0"
+   /* _mesa_function_pool[1854]: BindFragDataLocationEXT (will be remapped) */
+   "iip\0"
+   "glBindFragDataLocationEXT\0"
+   "glBindFragDataLocation\0"
+   "\0"
+   /* _mesa_function_pool[1908]: ReplacementCodeuiVertex3fvSUN (dynamic) */
+   "pp\0"
+   "glReplacementCodeuiVertex3fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[1944]: EdgeFlagPointer (offset 312) */
+   "ip\0"
+   "glEdgeFlagPointer\0"
+   "\0"
+   /* _mesa_function_pool[1966]: Color3ubv (offset 20) */
+   "p\0"
+   "glColor3ubv\0"
+   "\0"
+   /* _mesa_function_pool[1981]: GetQueryObjectivARB (will be remapped) */
+   "iip\0"
+   "glGetQueryObjectiv\0"
+   "glGetQueryObjectivARB\0"
+   "\0"
+   /* _mesa_function_pool[2027]: Vertex3dv (offset 135) */
+   "p\0"
+   "glVertex3dv\0"
+   "\0"
+   /* _mesa_function_pool[2042]: ReplacementCodeuiTexCoord2fVertex3fvSUN (dynamic) */
+   "ppp\0"
+   "glReplacementCodeuiTexCoord2fVertex3fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[2089]: CompressedTexSubImage2DARB (will be remapped) */
+   "iiiiiiiip\0"
+   "glCompressedTexSubImage2D\0"
+   "glCompressedTexSubImage2DARB\0"
+   "\0"
+   /* _mesa_function_pool[2155]: CombinerOutputNV (will be remapped) */
+   "iiiiiiiiii\0"
+   "glCombinerOutputNV\0"
+   "\0"
+   /* _mesa_function_pool[2186]: VertexAttribs3fvNV (will be remapped) */
+   "iip\0"
+   "glVertexAttribs3fvNV\0"
+   "\0"
+   /* _mesa_function_pool[2212]: Uniform2fARB (will be remapped) */
+   "iff\0"
+   "glUniform2f\0"
+   "glUniform2fARB\0"
+   "\0"
+   /* _mesa_function_pool[2244]: LightModeliv (offset 166) */
+   "ip\0"
+   "glLightModeliv\0"
+   "\0"
+   /* _mesa_function_pool[2263]: VertexAttrib1svARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib1sv\0"
+   "glVertexAttrib1svARB\0"
+   "\0"
+   /* _mesa_function_pool[2306]: VertexAttribs1dvNV (will be remapped) */
+   "iip\0"
+   "glVertexAttribs1dvNV\0"
+   "\0"
+   /* _mesa_function_pool[2332]: Uniform2ivARB (will be remapped) */
+   "iip\0"
+   "glUniform2iv\0"
+   "glUniform2ivARB\0"
+   "\0"
+   /* _mesa_function_pool[2366]: GetImageTransformParameterfvHP (dynamic) */
+   "iip\0"
+   "glGetImageTransformParameterfvHP\0"
+   "\0"
+   /* _mesa_function_pool[2404]: Normal3bv (offset 53) */
+   "p\0"
+   "glNormal3bv\0"
+   "\0"
+   /* _mesa_function_pool[2419]: TexGeniv (offset 193) */
+   "iip\0"
+   "glTexGeniv\0"
+   "\0"
+   /* _mesa_function_pool[2435]: WeightubvARB (dynamic) */
+   "ip\0"
+   "glWeightubvARB\0"
+   "\0"
+   /* _mesa_function_pool[2454]: VertexAttrib1fvNV (will be remapped) */
+   "ip\0"
+   "glVertexAttrib1fvNV\0"
+   "\0"
+   /* _mesa_function_pool[2478]: Vertex3iv (offset 139) */
+   "p\0"
+   "glVertex3iv\0"
+   "\0"
+   /* _mesa_function_pool[2493]: CopyConvolutionFilter1D (offset 354) */
+   "iiiii\0"
+   "glCopyConvolutionFilter1D\0"
+   "glCopyConvolutionFilter1DEXT\0"
+   "\0"
+   /* _mesa_function_pool[2555]: VertexAttribI1uiEXT (will be remapped) */
+   "ii\0"
+   "glVertexAttribI1uiEXT\0"
+   "glVertexAttribI1ui\0"
+   "\0"
+   /* _mesa_function_pool[2600]: ReplacementCodeuiNormal3fVertex3fSUN (dynamic) */
+   "iffffff\0"
+   "glReplacementCodeuiNormal3fVertex3fSUN\0"
+   "\0"
+   /* _mesa_function_pool[2648]: DeleteSync (will be remapped) */
+   "i\0"
+   "glDeleteSync\0"
+   "\0"
+   /* _mesa_function_pool[2664]: FragmentMaterialfvSGIX (dynamic) */
+   "iip\0"
+   "glFragmentMaterialfvSGIX\0"
+   "\0"
+   /* _mesa_function_pool[2694]: BlendColor (offset 336) */
+   "ffff\0"
+   "glBlendColor\0"
+   "glBlendColorEXT\0"
+   "\0"
+   /* _mesa_function_pool[2729]: UniformMatrix4fvARB (will be remapped) */
+   "iiip\0"
+   "glUniformMatrix4fv\0"
+   "glUniformMatrix4fvARB\0"
+   "\0"
+   /* _mesa_function_pool[2776]: DeleteVertexArraysAPPLE (will be remapped) */
+   "ip\0"
+   "glDeleteVertexArrays\0"
+   "glDeleteVertexArraysAPPLE\0"
+   "\0"
+   /* _mesa_function_pool[2827]: TexBuffer (will be remapped) */
+   "iii\0"
+   "glTexBuffer\0"
+   "\0"
+   /* _mesa_function_pool[2844]: ReadInstrumentsSGIX (dynamic) */
+   "i\0"
+   "glReadInstrumentsSGIX\0"
+   "\0"
+   /* _mesa_function_pool[2869]: CallLists (offset 3) */
+   "iip\0"
+   "glCallLists\0"
+   "\0"
+   /* _mesa_function_pool[2886]: UniformMatrix2x4fv (will be remapped) */
+   "iiip\0"
+   "glUniformMatrix2x4fv\0"
+   "\0"
+   /* _mesa_function_pool[2913]: Color4ubVertex3fvSUN (dynamic) */
+   "pp\0"
+   "glColor4ubVertex3fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[2940]: Normal3iv (offset 59) */
+   "p\0"
+   "glNormal3iv\0"
+   "\0"
+   /* _mesa_function_pool[2955]: PassThrough (offset 199) */
+   "f\0"
+   "glPassThrough\0"
+   "\0"
+   /* _mesa_function_pool[2972]: GetVertexAttribIivEXT (will be remapped) */
+   "iip\0"
+   "glGetVertexAttribIivEXT\0"
+   "glGetVertexAttribIiv\0"
+   "\0"
+   /* _mesa_function_pool[3022]: TexParameterIivEXT (will be remapped) */
+   "iip\0"
+   "glTexParameterIivEXT\0"
+   "glTexParameterIiv\0"
+   "\0"
+   /* _mesa_function_pool[3066]: FramebufferTextureLayerEXT (will be remapped) */
+   "iiiii\0"
+   "glFramebufferTextureLayer\0"
+   "glFramebufferTextureLayerEXT\0"
+   "\0"
+   /* _mesa_function_pool[3128]: GetListParameterfvSGIX (dynamic) */
+   "iip\0"
+   "glGetListParameterfvSGIX\0"
+   "\0"
+   /* _mesa_function_pool[3158]: Viewport (offset 305) */
+   "iiii\0"
+   "glViewport\0"
+   "\0"
+   /* _mesa_function_pool[3175]: VertexAttrib4NusvARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib4Nusv\0"
+   "glVertexAttrib4NusvARB\0"
+   "\0"
+   /* _mesa_function_pool[3222]: WindowPos4svMESA (will be remapped) */
+   "p\0"
+   "glWindowPos4svMESA\0"
+   "\0"
+   /* _mesa_function_pool[3244]: CreateProgramObjectARB (will be remapped) */
+   "\0"
+   "glCreateProgramObjectARB\0"
+   "\0"
+   /* _mesa_function_pool[3271]: DeleteTransformFeedbacks (will be remapped) */
+   "ip\0"
+   "glDeleteTransformFeedbacks\0"
+   "\0"
+   /* _mesa_function_pool[3302]: UniformMatrix4x3fv (will be remapped) */
+   "iiip\0"
+   "glUniformMatrix4x3fv\0"
+   "\0"
+   /* _mesa_function_pool[3329]: PrioritizeTextures (offset 331) */
+   "ipp\0"
+   "glPrioritizeTextures\0"
+   "glPrioritizeTexturesEXT\0"
+   "\0"
+   /* _mesa_function_pool[3379]: VertexAttribI3uiEXT (will be remapped) */
+   "iiii\0"
+   "glVertexAttribI3uiEXT\0"
+   "glVertexAttribI3ui\0"
+   "\0"
+   /* _mesa_function_pool[3426]: AsyncMarkerSGIX (dynamic) */
+   "i\0"
+   "glAsyncMarkerSGIX\0"
+   "\0"
+   /* _mesa_function_pool[3447]: GlobalAlphaFactorubSUN (dynamic) */
+   "i\0"
+   "glGlobalAlphaFactorubSUN\0"
+   "\0"
+   /* _mesa_function_pool[3475]: ClearColorIuiEXT (will be remapped) */
+   "iiii\0"
+   "glClearColorIuiEXT\0"
+   "\0"
+   /* _mesa_function_pool[3500]: ClearDebugLogMESA (dynamic) */
+   "iii\0"
+   "glClearDebugLogMESA\0"
+   "\0"
+   /* _mesa_function_pool[3525]: Uniform4uiEXT (will be remapped) */
+   "iiiii\0"
+   "glUniform4uiEXT\0"
+   "glUniform4ui\0"
+   "\0"
+   /* _mesa_function_pool[3561]: ResetHistogram (offset 369) */
+   "i\0"
+   "glResetHistogram\0"
+   "glResetHistogramEXT\0"
+   "\0"
+   /* _mesa_function_pool[3601]: GetProgramNamedParameterfvNV (will be remapped) */
+   "iipp\0"
+   "glGetProgramNamedParameterfvNV\0"
+   "\0"
+   /* _mesa_function_pool[3638]: PointParameterfEXT (will be remapped) */
+   "if\0"
+   "glPointParameterf\0"
+   "glPointParameterfARB\0"
+   "glPointParameterfEXT\0"
+   "glPointParameterfSGIS\0"
+   "\0"
+   /* _mesa_function_pool[3724]: LoadIdentityDeformationMapSGIX (dynamic) */
+   "i\0"
+   "glLoadIdentityDeformationMapSGIX\0"
+   "\0"
+   /* _mesa_function_pool[3760]: GenFencesNV (will be remapped) */
+   "ip\0"
+   "glGenFencesNV\0"
+   "\0"
+   /* _mesa_function_pool[3778]: ImageTransformParameterfHP (dynamic) */
+   "iif\0"
+   "glImageTransformParameterfHP\0"
+   "\0"
+   /* _mesa_function_pool[3812]: MatrixIndexusvARB (dynamic) */
+   "ip\0"
+   "glMatrixIndexusvARB\0"
+   "\0"
+   /* _mesa_function_pool[3836]: DrawElementsBaseVertex (will be remapped) */
+   "iiipi\0"
+   "glDrawElementsBaseVertex\0"
+   "\0"
+   /* _mesa_function_pool[3868]: DisableVertexAttribArrayARB (will be remapped) */
+   "i\0"
+   "glDisableVertexAttribArray\0"
+   "glDisableVertexAttribArrayARB\0"
+   "\0"
+   /* _mesa_function_pool[3928]: TexCoord2sv (offset 109) */
+   "p\0"
+   "glTexCoord2sv\0"
+   "\0"
+   /* _mesa_function_pool[3945]: Vertex4dv (offset 143) */
+   "p\0"
+   "glVertex4dv\0"
+   "\0"
+   /* _mesa_function_pool[3960]: StencilMaskSeparate (will be remapped) */
+   "ii\0"
+   "glStencilMaskSeparate\0"
+   "\0"
+   /* _mesa_function_pool[3986]: ProgramLocalParameter4dARB (will be remapped) */
+   "iidddd\0"
+   "glProgramLocalParameter4dARB\0"
+   "\0"
+   /* _mesa_function_pool[4023]: CompressedTexImage3DARB (will be remapped) */
+   "iiiiiiiip\0"
+   "glCompressedTexImage3D\0"
+   "glCompressedTexImage3DARB\0"
+   "\0"
+   /* _mesa_function_pool[4083]: Color3sv (offset 18) */
+   "p\0"
+   "glColor3sv\0"
+   "\0"
+   /* _mesa_function_pool[4097]: GetConvolutionParameteriv (offset 358) */
+   "iip\0"
+   "glGetConvolutionParameteriv\0"
+   "glGetConvolutionParameterivEXT\0"
+   "\0"
+   /* _mesa_function_pool[4161]: VertexAttrib1fARB (will be remapped) */
+   "if\0"
+   "glVertexAttrib1f\0"
+   "glVertexAttrib1fARB\0"
+   "\0"
+   /* _mesa_function_pool[4202]: Vertex2dv (offset 127) */
+   "p\0"
+   "glVertex2dv\0"
+   "\0"
+   /* _mesa_function_pool[4217]: TestFenceNV (will be remapped) */
+   "i\0"
+   "glTestFenceNV\0"
+   "\0"
+   /* _mesa_function_pool[4234]: MultiTexCoord1fvARB (offset 379) */
+   "ip\0"
+   "glMultiTexCoord1fv\0"
+   "glMultiTexCoord1fvARB\0"
+   "\0"
+   /* _mesa_function_pool[4279]: TexCoord3iv (offset 115) */
+   "p\0"
+   "glTexCoord3iv\0"
+   "\0"
+   /* _mesa_function_pool[4296]: Uniform2uivEXT (will be remapped) */
+   "iip\0"
+   "glUniform2uivEXT\0"
+   "glUniform2uiv\0"
+   "\0"
+   /* _mesa_function_pool[4332]: ColorFragmentOp2ATI (will be remapped) */
+   "iiiiiiiiii\0"
+   "glColorFragmentOp2ATI\0"
+   "\0"
+   /* _mesa_function_pool[4366]: SecondaryColorPointerListIBM (dynamic) */
+   "iiipi\0"
+   "glSecondaryColorPointerListIBM\0"
+   "\0"
+   /* _mesa_function_pool[4404]: GetPixelTexGenParameterivSGIS (will be remapped) */
+   "ip\0"
+   "glGetPixelTexGenParameterivSGIS\0"
+   "\0"
+   /* _mesa_function_pool[4440]: Color3fv (offset 14) */
+   "p\0"
+   "glColor3fv\0"
+   "\0"
+   /* _mesa_function_pool[4454]: VertexAttrib4fNV (will be remapped) */
+   "iffff\0"
+   "glVertexAttrib4fNV\0"
+   "\0"
+   /* _mesa_function_pool[4480]: ReplacementCodeubSUN (dynamic) */
+   "i\0"
+   "glReplacementCodeubSUN\0"
+   "\0"
+   /* _mesa_function_pool[4506]: FinishAsyncSGIX (dynamic) */
+   "p\0"
+   "glFinishAsyncSGIX\0"
+   "\0"
+   /* _mesa_function_pool[4527]: GetDebugLogMESA (dynamic) */
+   "iiiipp\0"
+   "glGetDebugLogMESA\0"
+   "\0"
+   /* _mesa_function_pool[4553]: FogCoorddEXT (will be remapped) */
+   "d\0"
+   "glFogCoordd\0"
+   "glFogCoorddEXT\0"
+   "\0"
+   /* _mesa_function_pool[4583]: BeginConditionalRenderNV (will be remapped) */
+   "ii\0"
+   "glBeginConditionalRenderNV\0"
+   "glBeginConditionalRender\0"
+   "\0"
+   /* _mesa_function_pool[4639]: Color4ubVertex3fSUN (dynamic) */
+   "iiiifff\0"
+   "glColor4ubVertex3fSUN\0"
+   "\0"
+   /* _mesa_function_pool[4670]: FogCoordfEXT (will be remapped) */
+   "f\0"
+   "glFogCoordf\0"
+   "glFogCoordfEXT\0"
+   "\0"
+   /* _mesa_function_pool[4700]: PointSize (offset 173) */
+   "f\0"
+   "glPointSize\0"
+   "\0"
+   /* _mesa_function_pool[4715]: VertexAttribI2uivEXT (will be remapped) */
+   "ip\0"
+   "glVertexAttribI2uivEXT\0"
+   "glVertexAttribI2uiv\0"
+   "\0"
+   /* _mesa_function_pool[4762]: TexCoord2fVertex3fSUN (dynamic) */
+   "fffff\0"
+   "glTexCoord2fVertex3fSUN\0"
+   "\0"
+   /* _mesa_function_pool[4793]: PopName (offset 200) */
+   "\0"
+   "glPopName\0"
+   "\0"
+   /* _mesa_function_pool[4805]: GlobalAlphaFactoriSUN (dynamic) */
+   "i\0"
+   "glGlobalAlphaFactoriSUN\0"
+   "\0"
+   /* _mesa_function_pool[4832]: VertexAttrib2dNV (will be remapped) */
+   "idd\0"
+   "glVertexAttrib2dNV\0"
+   "\0"
+   /* _mesa_function_pool[4856]: GetProgramInfoLog (will be remapped) */
+   "iipp\0"
+   "glGetProgramInfoLog\0"
+   "\0"
+   /* _mesa_function_pool[4882]: VertexAttrib4NbvARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib4Nbv\0"
+   "glVertexAttrib4NbvARB\0"
+   "\0"
+   /* _mesa_function_pool[4927]: GetActiveAttribARB (will be remapped) */
+   "iiipppp\0"
+   "glGetActiveAttrib\0"
+   "glGetActiveAttribARB\0"
+   "\0"
+   /* _mesa_function_pool[4975]: Vertex4sv (offset 149) */
+   "p\0"
+   "glVertex4sv\0"
+   "\0"
+   /* _mesa_function_pool[4990]: VertexAttrib4ubNV (will be remapped) */
+   "iiiii\0"
+   "glVertexAttrib4ubNV\0"
+   "\0"
+   /* _mesa_function_pool[5017]: ClampColor (will be remapped) */
+   "ii\0"
+   "glClampColor\0"
+   "\0"
+   /* _mesa_function_pool[5034]: TextureRangeAPPLE (will be remapped) */
+   "iip\0"
+   "glTextureRangeAPPLE\0"
+   "\0"
+   /* _mesa_function_pool[5059]: GetTexEnvfv (offset 276) */
+   "iip\0"
+   "glGetTexEnvfv\0"
+   "\0"
+   /* _mesa_function_pool[5078]: BindTransformFeedback (will be remapped) */
+   "ii\0"
+   "glBindTransformFeedback\0"
+   "\0"
+   /* _mesa_function_pool[5106]: TexCoord2fColor4fNormal3fVertex3fSUN (dynamic) */
+   "ffffffffffff\0"
+   "glTexCoord2fColor4fNormal3fVertex3fSUN\0"
+   "\0"
+   /* _mesa_function_pool[5159]: Indexub (offset 315) */
+   "i\0"
+   "glIndexub\0"
+   "\0"
+   /* _mesa_function_pool[5172]: ColorMaskIndexedEXT (will be remapped) */
+   "iiiii\0"
+   "glColorMaskIndexedEXT\0"
+   "glColorMaski\0"
+   "\0"
+   /* _mesa_function_pool[5214]: TexEnvi (offset 186) */
+   "iii\0"
+   "glTexEnvi\0"
+   "\0"
+   /* _mesa_function_pool[5229]: GetClipPlane (offset 259) */
+   "ip\0"
+   "glGetClipPlane\0"
+   "\0"
+   /* _mesa_function_pool[5248]: CombinerParameterfvNV (will be remapped) */
+   "ip\0"
+   "glCombinerParameterfvNV\0"
+   "\0"
+   /* _mesa_function_pool[5276]: VertexAttribs3dvNV (will be remapped) */
+   "iip\0"
+   "glVertexAttribs3dvNV\0"
+   "\0"
+   /* _mesa_function_pool[5302]: VertexAttribI2uiEXT (will be remapped) */
+   "iii\0"
+   "glVertexAttribI2uiEXT\0"
+   "glVertexAttribI2ui\0"
+   "\0"
+   /* _mesa_function_pool[5348]: VertexAttribs4fvNV (will be remapped) */
+   "iip\0"
+   "glVertexAttribs4fvNV\0"
+   "\0"
+   /* _mesa_function_pool[5374]: VertexArrayRangeNV (will be remapped) */
+   "ip\0"
+   "glVertexArrayRangeNV\0"
+   "\0"
+   /* _mesa_function_pool[5399]: FragmentLightiSGIX (dynamic) */
+   "iii\0"
+   "glFragmentLightiSGIX\0"
+   "\0"
+   /* _mesa_function_pool[5425]: PolygonOffsetEXT (will be remapped) */
+   "ff\0"
+   "glPolygonOffsetEXT\0"
+   "\0"
+   /* _mesa_function_pool[5448]: VertexAttribI4uivEXT (will be remapped) */
+   "ip\0"
+   "glVertexAttribI4uivEXT\0"
+   "glVertexAttribI4uiv\0"
+   "\0"
+   /* _mesa_function_pool[5495]: PollAsyncSGIX (dynamic) */
+   "p\0"
+   "glPollAsyncSGIX\0"
+   "\0"
+   /* _mesa_function_pool[5514]: DeleteFragmentShaderATI (will be remapped) */
+   "i\0"
+   "glDeleteFragmentShaderATI\0"
+   "\0"
+   /* _mesa_function_pool[5543]: Scaled (offset 301) */
+   "ddd\0"
+   "glScaled\0"
+   "\0"
+   /* _mesa_function_pool[5557]: ResumeTransformFeedback (will be remapped) */
+   "\0"
+   "glResumeTransformFeedback\0"
+   "\0"
+   /* _mesa_function_pool[5585]: Scalef (offset 302) */
+   "fff\0"
+   "glScalef\0"
+   "\0"
+   /* _mesa_function_pool[5599]: TexCoord2fNormal3fVertex3fvSUN (dynamic) */
+   "ppp\0"
+   "glTexCoord2fNormal3fVertex3fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[5637]: MultTransposeMatrixdARB (will be remapped) */
+   "p\0"
+   "glMultTransposeMatrixd\0"
+   "glMultTransposeMatrixdARB\0"
+   "\0"
+   /* _mesa_function_pool[5689]: ObjectUnpurgeableAPPLE (will be remapped) */
+   "iii\0"
+   "glObjectUnpurgeableAPPLE\0"
+   "\0"
+   /* _mesa_function_pool[5719]: AlphaFunc (offset 240) */
+   "if\0"
+   "glAlphaFunc\0"
+   "\0"
+   /* _mesa_function_pool[5735]: WindowPos2svMESA (will be remapped) */
+   "p\0"
+   "glWindowPos2sv\0"
+   "glWindowPos2svARB\0"
+   "glWindowPos2svMESA\0"
+   "\0"
+   /* _mesa_function_pool[5790]: EdgeFlag (offset 41) */
+   "i\0"
+   "glEdgeFlag\0"
+   "\0"
+   /* _mesa_function_pool[5804]: TexCoord2iv (offset 107) */
+   "p\0"
+   "glTexCoord2iv\0"
+   "\0"
+   /* _mesa_function_pool[5821]: CompressedTexImage1DARB (will be remapped) */
+   "iiiiiip\0"
+   "glCompressedTexImage1D\0"
+   "glCompressedTexImage1DARB\0"
+   "\0"
+   /* _mesa_function_pool[5879]: Rotated (offset 299) */
+   "dddd\0"
+   "glRotated\0"
+   "\0"
+   /* _mesa_function_pool[5895]: GetTexParameterIuivEXT (will be remapped) */
+   "iip\0"
+   "glGetTexParameterIuivEXT\0"
+   "glGetTexParameterIuiv\0"
+   "\0"
+   /* _mesa_function_pool[5947]: VertexAttrib2sNV (will be remapped) */
+   "iii\0"
+   "glVertexAttrib2sNV\0"
+   "\0"
+   /* _mesa_function_pool[5971]: ReadPixels (offset 256) */
+   "iiiiiip\0"
+   "glReadPixels\0"
+   "\0"
+   /* _mesa_function_pool[5993]: EdgeFlagv (offset 42) */
+   "p\0"
+   "glEdgeFlagv\0"
+   "\0"
+   /* _mesa_function_pool[6008]: NormalPointerListIBM (dynamic) */
+   "iipi\0"
+   "glNormalPointerListIBM\0"
+   "\0"
+   /* _mesa_function_pool[6037]: IndexPointerEXT (will be remapped) */
+   "iiip\0"
+   "glIndexPointerEXT\0"
+   "\0"
+   /* _mesa_function_pool[6061]: Color4iv (offset 32) */
+   "p\0"
+   "glColor4iv\0"
+   "\0"
+   /* _mesa_function_pool[6075]: TexParameterf (offset 178) */
+   "iif\0"
+   "glTexParameterf\0"
+   "\0"
+   /* _mesa_function_pool[6096]: TexParameteri (offset 180) */
+   "iii\0"
+   "glTexParameteri\0"
+   "\0"
+   /* _mesa_function_pool[6117]: NormalPointerEXT (will be remapped) */
+   "iiip\0"
+   "glNormalPointerEXT\0"
+   "\0"
+   /* _mesa_function_pool[6142]: MultiTexCoord3dARB (offset 392) */
+   "iddd\0"
+   "glMultiTexCoord3d\0"
+   "glMultiTexCoord3dARB\0"
+   "\0"
+   /* _mesa_function_pool[6187]: MultiTexCoord2iARB (offset 388) */
+   "iii\0"
+   "glMultiTexCoord2i\0"
+   "glMultiTexCoord2iARB\0"
+   "\0"
+   /* _mesa_function_pool[6231]: DrawPixels (offset 257) */
+   "iiiip\0"
+   "glDrawPixels\0"
+   "\0"
+   /* _mesa_function_pool[6251]: ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN (dynamic) */
+   "iffffffff\0"
+   "glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN\0"
+   "\0"
+   /* _mesa_function_pool[6311]: MultiTexCoord2svARB (offset 391) */
+   "ip\0"
+   "glMultiTexCoord2sv\0"
+   "glMultiTexCoord2svARB\0"
+   "\0"
+   /* _mesa_function_pool[6356]: ReplacementCodeubvSUN (dynamic) */
+   "p\0"
+   "glReplacementCodeubvSUN\0"
+   "\0"
+   /* _mesa_function_pool[6383]: Uniform3iARB (will be remapped) */
+   "iiii\0"
+   "glUniform3i\0"
+   "glUniform3iARB\0"
+   "\0"
+   /* _mesa_function_pool[6416]: DrawTransformFeedback (will be remapped) */
+   "ii\0"
+   "glDrawTransformFeedback\0"
+   "\0"
+   /* _mesa_function_pool[6444]: DrawElementsInstancedARB (will be remapped) */
+   "iiipi\0"
+   "glDrawElementsInstancedARB\0"
+   "glDrawElementsInstancedEXT\0"
+   "glDrawElementsInstanced\0"
+   "\0"
+   /* _mesa_function_pool[6529]: GetShaderInfoLog (will be remapped) */
+   "iipp\0"
+   "glGetShaderInfoLog\0"
+   "\0"
+   /* _mesa_function_pool[6554]: WeightivARB (dynamic) */
+   "ip\0"
+   "glWeightivARB\0"
+   "\0"
+   /* _mesa_function_pool[6572]: PollInstrumentsSGIX (dynamic) */
+   "p\0"
+   "glPollInstrumentsSGIX\0"
+   "\0"
+   /* _mesa_function_pool[6597]: GlobalAlphaFactordSUN (dynamic) */
+   "d\0"
+   "glGlobalAlphaFactordSUN\0"
+   "\0"
+   /* _mesa_function_pool[6624]: GetFinalCombinerInputParameterfvNV (will be remapped) */
+   "iip\0"
+   "glGetFinalCombinerInputParameterfvNV\0"
+   "\0"
+   /* _mesa_function_pool[6666]: GenerateMipmapEXT (will be remapped) */
+   "i\0"
+   "glGenerateMipmap\0"
+   "glGenerateMipmapEXT\0"
+   "\0"
+   /* _mesa_function_pool[6706]: GenLists (offset 5) */
+   "i\0"
+   "glGenLists\0"
+   "\0"
+   /* _mesa_function_pool[6720]: DepthRangef (will be remapped) */
+   "ff\0"
+   "glDepthRangef\0"
+   "\0"
+   /* _mesa_function_pool[6738]: GetMapAttribParameterivNV (dynamic) */
+   "iiip\0"
+   "glGetMapAttribParameterivNV\0"
+   "\0"
+   /* _mesa_function_pool[6772]: CreateShaderObjectARB (will be remapped) */
+   "i\0"
+   "glCreateShaderObjectARB\0"
+   "\0"
+   /* _mesa_function_pool[6799]: GetSharpenTexFuncSGIS (dynamic) */
+   "ip\0"
+   "glGetSharpenTexFuncSGIS\0"
+   "\0"
+   /* _mesa_function_pool[6827]: BufferDataARB (will be remapped) */
+   "iipi\0"
+   "glBufferData\0"
+   "glBufferDataARB\0"
+   "\0"
+   /* _mesa_function_pool[6862]: FlushVertexArrayRangeNV (will be remapped) */
+   "\0"
+   "glFlushVertexArrayRangeNV\0"
+   "\0"
+   /* _mesa_function_pool[6890]: MapGrid2d (offset 226) */
+   "iddidd\0"
+   "glMapGrid2d\0"
+   "\0"
+   /* _mesa_function_pool[6910]: MapGrid2f (offset 227) */
+   "iffiff\0"
+   "glMapGrid2f\0"
+   "\0"
+   /* _mesa_function_pool[6930]: SampleMapATI (will be remapped) */
+   "iii\0"
+   "glSampleMapATI\0"
+   "\0"
+   /* _mesa_function_pool[6950]: VertexPointerEXT (will be remapped) */
+   "iiiip\0"
+   "glVertexPointerEXT\0"
+   "\0"
+   /* _mesa_function_pool[6976]: GetTexFilterFuncSGIS (dynamic) */
+   "iip\0"
+   "glGetTexFilterFuncSGIS\0"
+   "\0"
+   /* _mesa_function_pool[7004]: Scissor (offset 176) */
+   "iiii\0"
+   "glScissor\0"
+   "\0"
+   /* _mesa_function_pool[7020]: Fogf (offset 153) */
+   "if\0"
+   "glFogf\0"
+   "\0"
+   /* _mesa_function_pool[7031]: ReplacementCodeuiColor4ubVertex3fvSUN (dynamic) */
+   "ppp\0"
+   "glReplacementCodeuiColor4ubVertex3fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[7076]: TexSubImage1D (offset 332) */
+   "iiiiiip\0"
+   "glTexSubImage1D\0"
+   "glTexSubImage1DEXT\0"
+   "\0"
+   /* _mesa_function_pool[7120]: VertexAttrib1sARB (will be remapped) */
+   "ii\0"
+   "glVertexAttrib1s\0"
+   "glVertexAttrib1sARB\0"
+   "\0"
+   /* _mesa_function_pool[7161]: FenceSync (will be remapped) */
+   "ii\0"
+   "glFenceSync\0"
+   "\0"
+   /* _mesa_function_pool[7177]: Color4usv (offset 40) */
+   "p\0"
+   "glColor4usv\0"
+   "\0"
+   /* _mesa_function_pool[7192]: Fogi (offset 155) */
+   "ii\0"
+   "glFogi\0"
+   "\0"
+   /* _mesa_function_pool[7203]: DepthRange (offset 288) */
+   "dd\0"
+   "glDepthRange\0"
+   "\0"
+   /* _mesa_function_pool[7220]: RasterPos3iv (offset 75) */
+   "p\0"
+   "glRasterPos3iv\0"
+   "\0"
+   /* _mesa_function_pool[7238]: FinalCombinerInputNV (will be remapped) */
+   "iiii\0"
+   "glFinalCombinerInputNV\0"
+   "\0"
+   /* _mesa_function_pool[7267]: TexCoord2i (offset 106) */
+   "ii\0"
+   "glTexCoord2i\0"
+   "\0"
+   /* _mesa_function_pool[7284]: PixelMapfv (offset 251) */
+   "iip\0"
+   "glPixelMapfv\0"
+   "\0"
+   /* _mesa_function_pool[7302]: Color4ui (offset 37) */
+   "iiii\0"
+   "glColor4ui\0"
+   "\0"
+   /* _mesa_function_pool[7319]: RasterPos3s (offset 76) */
+   "iii\0"
+   "glRasterPos3s\0"
+   "\0"
+   /* _mesa_function_pool[7338]: Color3usv (offset 24) */
+   "p\0"
+   "glColor3usv\0"
+   "\0"
+   /* _mesa_function_pool[7353]: FlushRasterSGIX (dynamic) */
+   "\0"
+   "glFlushRasterSGIX\0"
+   "\0"
+   /* _mesa_function_pool[7373]: TexCoord2f (offset 104) */
+   "ff\0"
+   "glTexCoord2f\0"
+   "\0"
+   /* _mesa_function_pool[7390]: ReplacementCodeuiTexCoord2fVertex3fSUN (dynamic) */
+   "ifffff\0"
+   "glReplacementCodeuiTexCoord2fVertex3fSUN\0"
+   "\0"
+   /* _mesa_function_pool[7439]: TexCoord2d (offset 102) */
+   "dd\0"
+   "glTexCoord2d\0"
+   "\0"
+   /* _mesa_function_pool[7456]: RasterPos3d (offset 70) */
+   "ddd\0"
+   "glRasterPos3d\0"
+   "\0"
+   /* _mesa_function_pool[7475]: RasterPos3f (offset 72) */
+   "fff\0"
+   "glRasterPos3f\0"
+   "\0"
+   /* _mesa_function_pool[7494]: Uniform1fARB (will be remapped) */
+   "if\0"
+   "glUniform1f\0"
+   "glUniform1fARB\0"
+   "\0"
+   /* _mesa_function_pool[7525]: AreTexturesResident (offset 322) */
+   "ipp\0"
+   "glAreTexturesResident\0"
+   "glAreTexturesResidentEXT\0"
+   "\0"
+   /* _mesa_function_pool[7577]: TexCoord2s (offset 108) */
+   "ii\0"
+   "glTexCoord2s\0"
+   "\0"
+   /* _mesa_function_pool[7594]: StencilOpSeparate (will be remapped) */
+   "iiii\0"
+   "glStencilOpSeparate\0"
+   "glStencilOpSeparateATI\0"
+   "\0"
+   /* _mesa_function_pool[7643]: ColorTableParameteriv (offset 341) */
+   "iip\0"
+   "glColorTableParameteriv\0"
+   "glColorTableParameterivSGI\0"
+   "\0"
+   /* _mesa_function_pool[7699]: FogCoordPointerListIBM (dynamic) */
+   "iipi\0"
+   "glFogCoordPointerListIBM\0"
+   "\0"
+   /* _mesa_function_pool[7730]: WindowPos3dMESA (will be remapped) */
+   "ddd\0"
+   "glWindowPos3d\0"
+   "glWindowPos3dARB\0"
+   "glWindowPos3dMESA\0"
+   "\0"
+   /* _mesa_function_pool[7784]: Color4us (offset 39) */
+   "iiii\0"
+   "glColor4us\0"
+   "\0"
+   /* _mesa_function_pool[7801]: PointParameterfvEXT (will be remapped) */
+   "ip\0"
+   "glPointParameterfv\0"
+   "glPointParameterfvARB\0"
+   "glPointParameterfvEXT\0"
+   "glPointParameterfvSGIS\0"
+   "\0"
+   /* _mesa_function_pool[7891]: Color3bv (offset 10) */
+   "p\0"
+   "glColor3bv\0"
+   "\0"
+   /* _mesa_function_pool[7905]: WindowPos2fvMESA (will be remapped) */
+   "p\0"
+   "glWindowPos2fv\0"
+   "glWindowPos2fvARB\0"
+   "glWindowPos2fvMESA\0"
+   "\0"
+   /* _mesa_function_pool[7960]: SecondaryColor3bvEXT (will be remapped) */
+   "p\0"
+   "glSecondaryColor3bv\0"
+   "glSecondaryColor3bvEXT\0"
+   "\0"
+   /* _mesa_function_pool[8006]: VertexPointerListIBM (dynamic) */
+   "iiipi\0"
+   "glVertexPointerListIBM\0"
+   "\0"
+   /* _mesa_function_pool[8036]: GetProgramLocalParameterfvARB (will be remapped) */
+   "iip\0"
+   "glGetProgramLocalParameterfvARB\0"
+   "\0"
+   /* _mesa_function_pool[8073]: FragmentMaterialfSGIX (dynamic) */
+   "iif\0"
+   "glFragmentMaterialfSGIX\0"
+   "\0"
+   /* _mesa_function_pool[8102]: TexCoord2fNormal3fVertex3fSUN (dynamic) */
+   "ffffffff\0"
+   "glTexCoord2fNormal3fVertex3fSUN\0"
+   "\0"
+   /* _mesa_function_pool[8144]: RenderbufferStorageEXT (will be remapped) */
+   "iiii\0"
+   "glRenderbufferStorage\0"
+   "glRenderbufferStorageEXT\0"
+   "\0"
+   /* _mesa_function_pool[8197]: IsFenceNV (will be remapped) */
+   "i\0"
+   "glIsFenceNV\0"
+   "\0"
+   /* _mesa_function_pool[8212]: AttachObjectARB (will be remapped) */
+   "ii\0"
+   "glAttachObjectARB\0"
+   "\0"
+   /* _mesa_function_pool[8234]: GetFragmentLightivSGIX (dynamic) */
+   "iip\0"
+   "glGetFragmentLightivSGIX\0"
+   "\0"
+   /* _mesa_function_pool[8264]: UniformMatrix2fvARB (will be remapped) */
+   "iiip\0"
+   "glUniformMatrix2fv\0"
+   "glUniformMatrix2fvARB\0"
+   "\0"
+   /* _mesa_function_pool[8311]: MultiTexCoord2fARB (offset 386) */
+   "iff\0"
+   "glMultiTexCoord2f\0"
+   "glMultiTexCoord2fARB\0"
+   "\0"
+   /* _mesa_function_pool[8355]: ColorTable (offset 339) */
+   "iiiiip\0"
+   "glColorTable\0"
+   "glColorTableSGI\0"
+   "glColorTableEXT\0"
+   "\0"
+   /* _mesa_function_pool[8408]: IndexPointer (offset 314) */
+   "iip\0"
+   "glIndexPointer\0"
+   "\0"
+   /* _mesa_function_pool[8428]: Accum (offset 213) */
+   "if\0"
+   "glAccum\0"
+   "\0"
+   /* _mesa_function_pool[8440]: GetTexImage (offset 281) */
+   "iiiip\0"
+   "glGetTexImage\0"
+   "\0"
+   /* _mesa_function_pool[8461]: MapControlPointsNV (dynamic) */
+   "iiiiiiiip\0"
+   "glMapControlPointsNV\0"
+   "\0"
+   /* _mesa_function_pool[8493]: ConvolutionFilter2D (offset 349) */
+   "iiiiiip\0"
+   "glConvolutionFilter2D\0"
+   "glConvolutionFilter2DEXT\0"
+   "\0"
+   /* _mesa_function_pool[8549]: Finish (offset 216) */
+   "\0"
+   "glFinish\0"
+   "\0"
+   /* _mesa_function_pool[8560]: MapParameterfvNV (dynamic) */
+   "iip\0"
+   "glMapParameterfvNV\0"
+   "\0"
+   /* _mesa_function_pool[8584]: ClearStencil (offset 207) */
+   "i\0"
+   "glClearStencil\0"
+   "\0"
+   /* _mesa_function_pool[8602]: VertexAttrib3dvARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib3dv\0"
+   "glVertexAttrib3dvARB\0"
+   "\0"
+   /* _mesa_function_pool[8645]: Uniform4uivEXT (will be remapped) */
+   "iip\0"
+   "glUniform4uivEXT\0"
+   "glUniform4uiv\0"
+   "\0"
+   /* _mesa_function_pool[8681]: HintPGI (dynamic) */
+   "ii\0"
+   "glHintPGI\0"
+   "\0"
+   /* _mesa_function_pool[8695]: ConvolutionParameteriv (offset 353) */
+   "iip\0"
+   "glConvolutionParameteriv\0"
+   "glConvolutionParameterivEXT\0"
+   "\0"
+   /* _mesa_function_pool[8753]: Color4s (offset 33) */
+   "iiii\0"
+   "glColor4s\0"
+   "\0"
+   /* _mesa_function_pool[8769]: InterleavedArrays (offset 317) */
+   "iip\0"
+   "glInterleavedArrays\0"
+   "\0"
+   /* _mesa_function_pool[8794]: RasterPos2fv (offset 65) */
+   "p\0"
+   "glRasterPos2fv\0"
+   "\0"
+   /* _mesa_function_pool[8812]: TexCoord1fv (offset 97) */
+   "p\0"
+   "glTexCoord1fv\0"
+   "\0"
+   /* _mesa_function_pool[8829]: Vertex2d (offset 126) */
+   "dd\0"
+   "glVertex2d\0"
+   "\0"
+   /* _mesa_function_pool[8844]: CullParameterdvEXT (dynamic) */
+   "ip\0"
+   "glCullParameterdvEXT\0"
+   "\0"
+   /* _mesa_function_pool[8869]: ProgramNamedParameter4fNV (will be remapped) */
+   "iipffff\0"
+   "glProgramNamedParameter4fNV\0"
+   "\0"
+   /* _mesa_function_pool[8906]: Color3fVertex3fSUN (dynamic) */
+   "ffffff\0"
+   "glColor3fVertex3fSUN\0"
+   "\0"
+   /* _mesa_function_pool[8935]: ProgramEnvParameter4fvARB (will be remapped) */
+   "iip\0"
+   "glProgramEnvParameter4fvARB\0"
+   "glProgramParameter4fvNV\0"
+   "\0"
+   /* _mesa_function_pool[8992]: Color4i (offset 31) */
+   "iiii\0"
+   "glColor4i\0"
+   "\0"
+   /* _mesa_function_pool[9008]: Color4f (offset 29) */
+   "ffff\0"
+   "glColor4f\0"
+   "\0"
+   /* _mesa_function_pool[9024]: RasterPos4fv (offset 81) */
+   "p\0"
+   "glRasterPos4fv\0"
+   "\0"
+   /* _mesa_function_pool[9042]: Color4d (offset 27) */
+   "dddd\0"
+   "glColor4d\0"
+   "\0"
+   /* _mesa_function_pool[9058]: ClearIndex (offset 205) */
+   "f\0"
+   "glClearIndex\0"
+   "\0"
+   /* _mesa_function_pool[9074]: Color4b (offset 25) */
+   "iiii\0"
+   "glColor4b\0"
+   "\0"
+   /* _mesa_function_pool[9090]: LoadMatrixd (offset 292) */
+   "p\0"
+   "glLoadMatrixd\0"
+   "\0"
+   /* _mesa_function_pool[9107]: FragmentLightModeliSGIX (dynamic) */
+   "ii\0"
+   "glFragmentLightModeliSGIX\0"
+   "\0"
+   /* _mesa_function_pool[9137]: RasterPos2dv (offset 63) */
+   "p\0"
+   "glRasterPos2dv\0"
+   "\0"
+   /* _mesa_function_pool[9155]: ConvolutionParameterfv (offset 351) */
+   "iip\0"
+   "glConvolutionParameterfv\0"
+   "glConvolutionParameterfvEXT\0"
+   "\0"
+   /* _mesa_function_pool[9213]: TbufferMask3DFX (dynamic) */
+   "i\0"
+   "glTbufferMask3DFX\0"
+   "\0"
+   /* _mesa_function_pool[9234]: GetTexGendv (offset 278) */
+   "iip\0"
+   "glGetTexGendv\0"
+   "\0"
+   /* _mesa_function_pool[9253]: GetVertexAttribfvNV (will be remapped) */
+   "iip\0"
+   "glGetVertexAttribfvNV\0"
+   "\0"
+   /* _mesa_function_pool[9280]: BeginTransformFeedbackEXT (will be remapped) */
+   "i\0"
+   "glBeginTransformFeedbackEXT\0"
+   "glBeginTransformFeedback\0"
+   "\0"
+   /* _mesa_function_pool[9336]: LoadProgramNV (will be remapped) */
+   "iiip\0"
+   "glLoadProgramNV\0"
+   "\0"
+   /* _mesa_function_pool[9358]: WaitSync (will be remapped) */
+   "iii\0"
+   "glWaitSync\0"
+   "\0"
+   /* _mesa_function_pool[9374]: EndList (offset 1) */
+   "\0"
+   "glEndList\0"
+   "\0"
+   /* _mesa_function_pool[9386]: VertexAttrib4fvNV (will be remapped) */
+   "ip\0"
+   "glVertexAttrib4fvNV\0"
+   "\0"
+   /* _mesa_function_pool[9410]: GetAttachedObjectsARB (will be remapped) */
+   "iipp\0"
+   "glGetAttachedObjectsARB\0"
+   "\0"
+   /* _mesa_function_pool[9440]: Uniform3fvARB (will be remapped) */
+   "iip\0"
+   "glUniform3fv\0"
+   "glUniform3fvARB\0"
+   "\0"
+   /* _mesa_function_pool[9474]: EvalCoord1fv (offset 231) */
+   "p\0"
+   "glEvalCoord1fv\0"
+   "\0"
+   /* _mesa_function_pool[9492]: DrawRangeElements (offset 338) */
+   "iiiiip\0"
+   "glDrawRangeElements\0"
+   "glDrawRangeElementsEXT\0"
+   "\0"
+   /* _mesa_function_pool[9543]: EvalMesh2 (offset 238) */
+   "iiiii\0"
+   "glEvalMesh2\0"
+   "\0"
+   /* _mesa_function_pool[9562]: Vertex4fv (offset 145) */
+   "p\0"
+   "glVertex4fv\0"
+   "\0"
+   /* _mesa_function_pool[9577]: GenTransformFeedbacks (will be remapped) */
+   "ip\0"
+   "glGenTransformFeedbacks\0"
+   "\0"
+   /* _mesa_function_pool[9605]: SpriteParameterfvSGIX (dynamic) */
+   "ip\0"
+   "glSpriteParameterfvSGIX\0"
+   "\0"
+   /* _mesa_function_pool[9633]: CheckFramebufferStatusEXT (will be remapped) */
+   "i\0"
+   "glCheckFramebufferStatus\0"
+   "glCheckFramebufferStatusEXT\0"
+   "\0"
+   /* _mesa_function_pool[9689]: GlobalAlphaFactoruiSUN (dynamic) */
+   "i\0"
+   "glGlobalAlphaFactoruiSUN\0"
+   "\0"
+   /* _mesa_function_pool[9717]: GetHandleARB (will be remapped) */
+   "i\0"
+   "glGetHandleARB\0"
+   "\0"
+   /* _mesa_function_pool[9735]: GetVertexAttribivARB (will be remapped) */
+   "iip\0"
+   "glGetVertexAttribiv\0"
+   "glGetVertexAttribivARB\0"
+   "\0"
+   /* _mesa_function_pool[9783]: BlendFunciARB (will be remapped) */
+   "iii\0"
+   "glBlendFunciARB\0"
+   "\0"
+   /* _mesa_function_pool[9804]: GetCombinerInputParameterfvNV (will be remapped) */
+   "iiiip\0"
+   "glGetCombinerInputParameterfvNV\0"
+   "\0"
+   /* _mesa_function_pool[9843]: GetTexParameterIivEXT (will be remapped) */
+   "iip\0"
+   "glGetTexParameterIivEXT\0"
+   "glGetTexParameterIiv\0"
+   "\0"
+   /* _mesa_function_pool[9893]: CreateProgram (will be remapped) */
+   "\0"
+   "glCreateProgram\0"
+   "\0"
+   /* _mesa_function_pool[9911]: LoadTransposeMatrixdARB (will be remapped) */
+   "p\0"
+   "glLoadTransposeMatrixd\0"
+   "glLoadTransposeMatrixdARB\0"
+   "\0"
+   /* _mesa_function_pool[9963]: ReleaseShaderCompiler (will be remapped) */
+   "\0"
+   "glReleaseShaderCompiler\0"
+   "\0"
+   /* _mesa_function_pool[9989]: GetMinmax (offset 364) */
+   "iiiip\0"
+   "glGetMinmax\0"
+   "glGetMinmaxEXT\0"
+   "\0"
+   /* _mesa_function_pool[10023]: StencilFuncSeparate (will be remapped) */
+   "iiii\0"
+   "glStencilFuncSeparate\0"
+   "\0"
+   /* _mesa_function_pool[10051]: SecondaryColor3sEXT (will be remapped) */
+   "iii\0"
+   "glSecondaryColor3s\0"
+   "glSecondaryColor3sEXT\0"
+   "\0"
+   /* _mesa_function_pool[10097]: Color3fVertex3fvSUN (dynamic) */
+   "pp\0"
+   "glColor3fVertex3fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[10123]: GetInteger64i_v (will be remapped) */
+   "iip\0"
+   "glGetInteger64i_v\0"
+   "\0"
+   /* _mesa_function_pool[10146]: Normal3fv (offset 57) */
+   "p\0"
+   "glNormal3fv\0"
+   "\0"
+   /* _mesa_function_pool[10161]: GlobalAlphaFactorbSUN (dynamic) */
+   "i\0"
+   "glGlobalAlphaFactorbSUN\0"
+   "\0"
+   /* _mesa_function_pool[10188]: Color3us (offset 23) */
+   "iii\0"
+   "glColor3us\0"
+   "\0"
+   /* _mesa_function_pool[10204]: ImageTransformParameterfvHP (dynamic) */
+   "iip\0"
+   "glImageTransformParameterfvHP\0"
+   "\0"
+   /* _mesa_function_pool[10239]: VertexAttrib4ivARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib4iv\0"
+   "glVertexAttrib4ivARB\0"
+   "\0"
+   /* _mesa_function_pool[10282]: End (offset 43) */
+   "\0"
+   "glEnd\0"
+   "\0"
+   /* _mesa_function_pool[10290]: VertexAttrib3fNV (will be remapped) */
+   "ifff\0"
+   "glVertexAttrib3fNV\0"
+   "\0"
+   /* _mesa_function_pool[10315]: VertexAttribs2dvNV (will be remapped) */
+   "iip\0"
+   "glVertexAttribs2dvNV\0"
+   "\0"
+   /* _mesa_function_pool[10341]: GetQueryObjectui64vEXT (will be remapped) */
+   "iip\0"
+   "glGetQueryObjectui64vEXT\0"
+   "\0"
+   /* _mesa_function_pool[10371]: MultiTexCoord3fvARB (offset 395) */
+   "ip\0"
+   "glMultiTexCoord3fv\0"
+   "glMultiTexCoord3fvARB\0"
+   "\0"
+   /* _mesa_function_pool[10416]: SecondaryColor3dEXT (will be remapped) */
+   "ddd\0"
+   "glSecondaryColor3d\0"
+   "glSecondaryColor3dEXT\0"
+   "\0"
+   /* _mesa_function_pool[10462]: Color3ub (offset 19) */
+   "iii\0"
+   "glColor3ub\0"
+   "\0"
+   /* _mesa_function_pool[10478]: GetProgramParameterfvNV (will be remapped) */
+   "iiip\0"
+   "glGetProgramParameterfvNV\0"
+   "\0"
+   /* _mesa_function_pool[10510]: TangentPointerEXT (dynamic) */
+   "iip\0"
+   "glTangentPointerEXT\0"
+   "\0"
+   /* _mesa_function_pool[10535]: Color4fNormal3fVertex3fvSUN (dynamic) */
+   "ppp\0"
+   "glColor4fNormal3fVertex3fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[10570]: GetInstrumentsSGIX (dynamic) */
+   "\0"
+   "glGetInstrumentsSGIX\0"
+   "\0"
+   /* _mesa_function_pool[10593]: GetUniformuivEXT (will be remapped) */
+   "iip\0"
+   "glGetUniformuivEXT\0"
+   "glGetUniformuiv\0"
+   "\0"
+   /* _mesa_function_pool[10633]: Color3ui (offset 21) */
+   "iii\0"
+   "glColor3ui\0"
+   "\0"
+   /* _mesa_function_pool[10649]: EvalMapsNV (dynamic) */
+   "ii\0"
+   "glEvalMapsNV\0"
+   "\0"
+   /* _mesa_function_pool[10666]: TexSubImage2D (offset 333) */
+   "iiiiiiiip\0"
+   "glTexSubImage2D\0"
+   "glTexSubImage2DEXT\0"
+   "\0"
+   /* _mesa_function_pool[10712]: FragmentLightivSGIX (dynamic) */
+   "iip\0"
+   "glFragmentLightivSGIX\0"
+   "\0"
+   /* _mesa_function_pool[10739]: GetTexParameterPointervAPPLE (will be remapped) */
+   "iip\0"
+   "glGetTexParameterPointervAPPLE\0"
+   "\0"
+   /* _mesa_function_pool[10775]: TexGenfv (offset 191) */
+   "iip\0"
+   "glTexGenfv\0"
+   "\0"
+   /* _mesa_function_pool[10791]: GetTransformFeedbackVaryingEXT (will be remapped) */
+   "iiipppp\0"
+   "glGetTransformFeedbackVaryingEXT\0"
+   "glGetTransformFeedbackVarying\0"
+   "\0"
+   /* _mesa_function_pool[10863]: VertexAttrib4bvARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib4bv\0"
+   "glVertexAttrib4bvARB\0"
+   "\0"
+   /* _mesa_function_pool[10906]: ShaderBinary (will be remapped) */
+   "ipipi\0"
+   "glShaderBinary\0"
+   "\0"
+   /* _mesa_function_pool[10928]: GetIntegerIndexedvEXT (will be remapped) */
+   "iip\0"
+   "glGetIntegerIndexedvEXT\0"
+   "glGetIntegeri_v\0"
+   "\0"
+   /* _mesa_function_pool[10973]: MultiTexCoord4sARB (offset 406) */
+   "iiiii\0"
+   "glMultiTexCoord4s\0"
+   "glMultiTexCoord4sARB\0"
+   "\0"
+   /* _mesa_function_pool[11019]: GetFragmentMaterialivSGIX (dynamic) */
+   "iip\0"
+   "glGetFragmentMaterialivSGIX\0"
+   "\0"
+   /* _mesa_function_pool[11052]: WindowPos4dMESA (will be remapped) */
+   "dddd\0"
+   "glWindowPos4dMESA\0"
+   "\0"
+   /* _mesa_function_pool[11076]: WeightPointerARB (dynamic) */
+   "iiip\0"
+   "glWeightPointerARB\0"
+   "\0"
+   /* _mesa_function_pool[11101]: WindowPos2dMESA (will be remapped) */
+   "dd\0"
+   "glWindowPos2d\0"
+   "glWindowPos2dARB\0"
+   "glWindowPos2dMESA\0"
+   "\0"
+   /* _mesa_function_pool[11154]: FramebufferTexture3DEXT (will be remapped) */
+   "iiiiii\0"
+   "glFramebufferTexture3D\0"
+   "glFramebufferTexture3DEXT\0"
+   "\0"
+   /* _mesa_function_pool[11211]: BlendEquation (offset 337) */
+   "i\0"
+   "glBlendEquation\0"
+   "glBlendEquationEXT\0"
+   "\0"
+   /* _mesa_function_pool[11249]: VertexAttrib3dNV (will be remapped) */
+   "iddd\0"
+   "glVertexAttrib3dNV\0"
+   "\0"
+   /* _mesa_function_pool[11274]: VertexAttrib3dARB (will be remapped) */
+   "iddd\0"
+   "glVertexAttrib3d\0"
+   "glVertexAttrib3dARB\0"
+   "\0"
+   /* _mesa_function_pool[11317]: VertexAttribI4usvEXT (will be remapped) */
+   "ip\0"
+   "glVertexAttribI4usvEXT\0"
+   "glVertexAttribI4usv\0"
+   "\0"
+   /* _mesa_function_pool[11364]: ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN (dynamic) */
+   "ppppp\0"
+   "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[11428]: VertexAttrib4fARB (will be remapped) */
+   "iffff\0"
+   "glVertexAttrib4f\0"
+   "glVertexAttrib4fARB\0"
+   "\0"
+   /* _mesa_function_pool[11472]: GetError (offset 261) */
+   "\0"
+   "glGetError\0"
+   "\0"
+   /* _mesa_function_pool[11485]: IndexFuncEXT (dynamic) */
+   "if\0"
+   "glIndexFuncEXT\0"
+   "\0"
+   /* _mesa_function_pool[11504]: TexCoord3dv (offset 111) */
+   "p\0"
+   "glTexCoord3dv\0"
+   "\0"
+   /* _mesa_function_pool[11521]: Indexdv (offset 45) */
+   "p\0"
+   "glIndexdv\0"
+   "\0"
+   /* _mesa_function_pool[11534]: FramebufferTexture2DEXT (will be remapped) */
+   "iiiii\0"
+   "glFramebufferTexture2D\0"
+   "glFramebufferTexture2DEXT\0"
+   "\0"
+   /* _mesa_function_pool[11590]: Normal3s (offset 60) */
+   "iii\0"
+   "glNormal3s\0"
+   "\0"
+   /* _mesa_function_pool[11606]: GetObjectParameterivAPPLE (will be remapped) */
+   "iiip\0"
+   "glGetObjectParameterivAPPLE\0"
+   "\0"
+   /* _mesa_function_pool[11640]: PushName (offset 201) */
+   "i\0"
+   "glPushName\0"
+   "\0"
+   /* _mesa_function_pool[11654]: MultiTexCoord2dvARB (offset 385) */
+   "ip\0"
+   "glMultiTexCoord2dv\0"
+   "glMultiTexCoord2dvARB\0"
+   "\0"
+   /* _mesa_function_pool[11699]: CullParameterfvEXT (dynamic) */
+   "ip\0"
+   "glCullParameterfvEXT\0"
+   "\0"
+   /* _mesa_function_pool[11724]: Normal3i (offset 58) */
+   "iii\0"
+   "glNormal3i\0"
+   "\0"
+   /* _mesa_function_pool[11740]: ProgramNamedParameter4fvNV (will be remapped) */
+   "iipp\0"
+   "glProgramNamedParameter4fvNV\0"
+   "\0"
+   /* _mesa_function_pool[11775]: SecondaryColorPointerEXT (will be remapped) */
+   "iiip\0"
+   "glSecondaryColorPointer\0"
+   "glSecondaryColorPointerEXT\0"
+   "\0"
+   /* _mesa_function_pool[11832]: VertexAttrib4fvARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib4fv\0"
+   "glVertexAttrib4fvARB\0"
+   "\0"
+   /* _mesa_function_pool[11875]: ColorPointerListIBM (dynamic) */
+   "iiipi\0"
+   "glColorPointerListIBM\0"
+   "\0"
+   /* _mesa_function_pool[11904]: GetActiveUniformARB (will be remapped) */
+   "iiipppp\0"
+   "glGetActiveUniform\0"
+   "glGetActiveUniformARB\0"
+   "\0"
+   /* _mesa_function_pool[11954]: ImageTransformParameteriHP (dynamic) */
+   "iii\0"
+   "glImageTransformParameteriHP\0"
+   "\0"
+   /* _mesa_function_pool[11988]: Normal3b (offset 52) */
+   "iii\0"
+   "glNormal3b\0"
+   "\0"
+   /* _mesa_function_pool[12004]: Normal3d (offset 54) */
+   "ddd\0"
+   "glNormal3d\0"
+   "\0"
+   /* _mesa_function_pool[12020]: Uniform1uiEXT (will be remapped) */
+   "ii\0"
+   "glUniform1uiEXT\0"
+   "glUniform1ui\0"
+   "\0"
+   /* _mesa_function_pool[12053]: Normal3f (offset 56) */
+   "fff\0"
+   "glNormal3f\0"
+   "\0"
+   /* _mesa_function_pool[12069]: MultiTexCoord1svARB (offset 383) */
+   "ip\0"
+   "glMultiTexCoord1sv\0"
+   "glMultiTexCoord1svARB\0"
+   "\0"
+   /* _mesa_function_pool[12114]: Indexi (offset 48) */
+   "i\0"
+   "glIndexi\0"
+   "\0"
+   /* _mesa_function_pool[12126]: EGLImageTargetTexture2DOES (will be remapped) */
+   "ip\0"
+   "glEGLImageTargetTexture2DOES\0"
+   "\0"
+   /* _mesa_function_pool[12159]: EndQueryARB (will be remapped) */
+   "i\0"
+   "glEndQuery\0"
+   "glEndQueryARB\0"
+   "\0"
+   /* _mesa_function_pool[12187]: DeleteFencesNV (will be remapped) */
+   "ip\0"
+   "glDeleteFencesNV\0"
+   "\0"
+   /* _mesa_function_pool[12208]: DeformationMap3dSGIX (dynamic) */
+   "iddiiddiiddiip\0"
+   "glDeformationMap3dSGIX\0"
+   "\0"
+   /* _mesa_function_pool[12247]: BindBufferRangeEXT (will be remapped) */
+   "iiiii\0"
+   "glBindBufferRangeEXT\0"
+   "glBindBufferRange\0"
+   "\0"
+   /* _mesa_function_pool[12293]: DepthMask (offset 211) */
+   "i\0"
+   "glDepthMask\0"
+   "\0"
+   /* _mesa_function_pool[12308]: IsShader (will be remapped) */
+   "i\0"
+   "glIsShader\0"
+   "\0"
+   /* _mesa_function_pool[12322]: Indexf (offset 46) */
+   "f\0"
+   "glIndexf\0"
+   "\0"
+   /* _mesa_function_pool[12334]: GetImageTransformParameterivHP (dynamic) */
+   "iip\0"
+   "glGetImageTransformParameterivHP\0"
+   "\0"
+   /* _mesa_function_pool[12372]: Indexd (offset 44) */
+   "d\0"
+   "glIndexd\0"
+   "\0"
+   /* _mesa_function_pool[12384]: GetMaterialiv (offset 270) */
+   "iip\0"
+   "glGetMaterialiv\0"
+   "\0"
+   /* _mesa_function_pool[12405]: StencilOp (offset 244) */
+   "iii\0"
+   "glStencilOp\0"
+   "\0"
+   /* _mesa_function_pool[12422]: WindowPos4ivMESA (will be remapped) */
+   "p\0"
+   "glWindowPos4ivMESA\0"
+   "\0"
+   /* _mesa_function_pool[12444]: FramebufferTextureLayer (dynamic) */
+   "iiiii\0"
+   "glFramebufferTextureLayerARB\0"
+   "\0"
+   /* _mesa_function_pool[12480]: MultiTexCoord3svARB (offset 399) */
+   "ip\0"
+   "glMultiTexCoord3sv\0"
+   "glMultiTexCoord3svARB\0"
+   "\0"
+   /* _mesa_function_pool[12525]: TexEnvfv (offset 185) */
+   "iip\0"
+   "glTexEnvfv\0"
+   "\0"
+   /* _mesa_function_pool[12541]: MultiTexCoord4iARB (offset 404) */
+   "iiiii\0"
+   "glMultiTexCoord4i\0"
+   "glMultiTexCoord4iARB\0"
+   "\0"
+   /* _mesa_function_pool[12587]: Indexs (offset 50) */
+   "i\0"
+   "glIndexs\0"
+   "\0"
+   /* _mesa_function_pool[12599]: Binormal3ivEXT (dynamic) */
+   "p\0"
+   "glBinormal3ivEXT\0"
+   "\0"
+   /* _mesa_function_pool[12619]: ResizeBuffersMESA (will be remapped) */
+   "\0"
+   "glResizeBuffersMESA\0"
+   "\0"
+   /* _mesa_function_pool[12641]: BlendFuncSeparateiARB (will be remapped) */
+   "iiiii\0"
+   "glBlendFuncSeparateiARB\0"
+   "\0"
+   /* _mesa_function_pool[12672]: GetUniformivARB (will be remapped) */
+   "iip\0"
+   "glGetUniformiv\0"
+   "glGetUniformivARB\0"
+   "\0"
+   /* _mesa_function_pool[12710]: PixelTexGenParameteriSGIS (will be remapped) */
+   "ii\0"
+   "glPixelTexGenParameteriSGIS\0"
+   "\0"
+   /* _mesa_function_pool[12742]: VertexPointervINTEL (dynamic) */
+   "iip\0"
+   "glVertexPointervINTEL\0"
+   "\0"
+   /* _mesa_function_pool[12769]: Vertex2i (offset 130) */
+   "ii\0"
+   "glVertex2i\0"
+   "\0"
+   /* _mesa_function_pool[12784]: LoadMatrixf (offset 291) */
+   "p\0"
+   "glLoadMatrixf\0"
+   "\0"
+   /* _mesa_function_pool[12801]: VertexAttribI1uivEXT (will be remapped) */
+   "ip\0"
+   "glVertexAttribI1uivEXT\0"
+   "glVertexAttribI1uiv\0"
+   "\0"
+   /* _mesa_function_pool[12848]: Vertex2f (offset 128) */
+   "ff\0"
+   "glVertex2f\0"
+   "\0"
+   /* _mesa_function_pool[12863]: ReplacementCodeuiColor4fNormal3fVertex3fvSUN (dynamic) */
+   "pppp\0"
+   "glReplacementCodeuiColor4fNormal3fVertex3fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[12916]: Color4bv (offset 26) */
+   "p\0"
+   "glColor4bv\0"
+   "\0"
+   /* _mesa_function_pool[12930]: VertexPointer (offset 321) */
+   "iiip\0"
+   "glVertexPointer\0"
+   "\0"
+   /* _mesa_function_pool[12952]: SecondaryColor3uiEXT (will be remapped) */
+   "iii\0"
+   "glSecondaryColor3ui\0"
+   "glSecondaryColor3uiEXT\0"
+   "\0"
+   /* _mesa_function_pool[13000]: StartInstrumentsSGIX (dynamic) */
+   "\0"
+   "glStartInstrumentsSGIX\0"
+   "\0"
+   /* _mesa_function_pool[13025]: SecondaryColor3usvEXT (will be remapped) */
+   "p\0"
+   "glSecondaryColor3usv\0"
+   "glSecondaryColor3usvEXT\0"
+   "\0"
+   /* _mesa_function_pool[13073]: VertexAttrib2fvNV (will be remapped) */
+   "ip\0"
+   "glVertexAttrib2fvNV\0"
+   "\0"
+   /* _mesa_function_pool[13097]: ProgramLocalParameter4dvARB (will be remapped) */
+   "iip\0"
+   "glProgramLocalParameter4dvARB\0"
+   "\0"
+   /* _mesa_function_pool[13132]: DeleteLists (offset 4) */
+   "ii\0"
+   "glDeleteLists\0"
+   "\0"
+   /* _mesa_function_pool[13150]: LogicOp (offset 242) */
+   "i\0"
+   "glLogicOp\0"
+   "\0"
+   /* _mesa_function_pool[13163]: MatrixIndexuivARB (dynamic) */
+   "ip\0"
+   "glMatrixIndexuivARB\0"
+   "\0"
+   /* _mesa_function_pool[13187]: Vertex2s (offset 132) */
+   "ii\0"
+   "glVertex2s\0"
+   "\0"
+   /* _mesa_function_pool[13202]: RenderbufferStorageMultisample (will be remapped) */
+   "iiiii\0"
+   "glRenderbufferStorageMultisample\0"
+   "glRenderbufferStorageMultisampleEXT\0"
+   "\0"
+   /* _mesa_function_pool[13278]: TexCoord4fv (offset 121) */
+   "p\0"
+   "glTexCoord4fv\0"
+   "\0"
+   /* _mesa_function_pool[13295]: Tangent3sEXT (dynamic) */
+   "iii\0"
+   "glTangent3sEXT\0"
+   "\0"
+   /* _mesa_function_pool[13315]: GlobalAlphaFactorfSUN (dynamic) */
+   "f\0"
+   "glGlobalAlphaFactorfSUN\0"
+   "\0"
+   /* _mesa_function_pool[13342]: MultiTexCoord3iARB (offset 396) */
+   "iiii\0"
+   "glMultiTexCoord3i\0"
+   "glMultiTexCoord3iARB\0"
+   "\0"
+   /* _mesa_function_pool[13387]: IsProgram (will be remapped) */
+   "i\0"
+   "glIsProgram\0"
+   "\0"
+   /* _mesa_function_pool[13402]: TexCoordPointerListIBM (dynamic) */
+   "iiipi\0"
+   "glTexCoordPointerListIBM\0"
+   "\0"
+   /* _mesa_function_pool[13434]: VertexAttribI4svEXT (will be remapped) */
+   "ip\0"
+   "glVertexAttribI4svEXT\0"
+   "glVertexAttribI4sv\0"
+   "\0"
+   /* _mesa_function_pool[13479]: GlobalAlphaFactorusSUN (dynamic) */
+   "i\0"
+   "glGlobalAlphaFactorusSUN\0"
+   "\0"
+   /* _mesa_function_pool[13507]: VertexAttrib2dvNV (will be remapped) */
+   "ip\0"
+   "glVertexAttrib2dvNV\0"
+   "\0"
+   /* _mesa_function_pool[13531]: FramebufferRenderbufferEXT (will be remapped) */
+   "iiii\0"
+   "glFramebufferRenderbuffer\0"
+   "glFramebufferRenderbufferEXT\0"
+   "\0"
+   /* _mesa_function_pool[13592]: ClearBufferuiv (will be remapped) */
+   "iip\0"
+   "glClearBufferuiv\0"
+   "\0"
+   /* _mesa_function_pool[13614]: VertexAttrib1dvNV (will be remapped) */
+   "ip\0"
+   "glVertexAttrib1dvNV\0"
+   "\0"
+   /* _mesa_function_pool[13638]: GenTextures (offset 328) */
+   "ip\0"
+   "glGenTextures\0"
+   "glGenTexturesEXT\0"
+   "\0"
+   /* _mesa_function_pool[13673]: FramebufferTextureARB (will be remapped) */
+   "iiii\0"
+   "glFramebufferTextureARB\0"
+   "\0"
+   /* _mesa_function_pool[13703]: SetFenceNV (will be remapped) */
+   "ii\0"
+   "glSetFenceNV\0"
+   "\0"
+   /* _mesa_function_pool[13720]: FramebufferTexture1DEXT (will be remapped) */
+   "iiiii\0"
+   "glFramebufferTexture1D\0"
+   "glFramebufferTexture1DEXT\0"
+   "\0"
+   /* _mesa_function_pool[13776]: GetCombinerOutputParameterivNV (will be remapped) */
+   "iiip\0"
+   "glGetCombinerOutputParameterivNV\0"
+   "\0"
+   /* _mesa_function_pool[13815]: PixelTexGenParameterivSGIS (will be remapped) */
+   "ip\0"
+   "glPixelTexGenParameterivSGIS\0"
+   "\0"
+   /* _mesa_function_pool[13848]: TextureNormalEXT (dynamic) */
+   "i\0"
+   "glTextureNormalEXT\0"
+   "\0"
+   /* _mesa_function_pool[13870]: IndexPointerListIBM (dynamic) */
+   "iipi\0"
+   "glIndexPointerListIBM\0"
+   "\0"
+   /* _mesa_function_pool[13898]: WeightfvARB (dynamic) */
+   "ip\0"
+   "glWeightfvARB\0"
+   "\0"
+   /* _mesa_function_pool[13916]: RasterPos2sv (offset 69) */
+   "p\0"
+   "glRasterPos2sv\0"
+   "\0"
+   /* _mesa_function_pool[13934]: Color4ubv (offset 36) */
+   "p\0"
+   "glColor4ubv\0"
+   "\0"
+   /* _mesa_function_pool[13949]: DrawBuffer (offset 202) */
+   "i\0"
+   "glDrawBuffer\0"
+   "\0"
+   /* _mesa_function_pool[13965]: TexCoord2fv (offset 105) */
+   "p\0"
+   "glTexCoord2fv\0"
+   "\0"
+   /* _mesa_function_pool[13982]: WindowPos4fMESA (will be remapped) */
+   "ffff\0"
+   "glWindowPos4fMESA\0"
+   "\0"
+   /* _mesa_function_pool[14006]: TexCoord1sv (offset 101) */
+   "p\0"
+   "glTexCoord1sv\0"
+   "\0"
+   /* _mesa_function_pool[14023]: WindowPos3dvMESA (will be remapped) */
+   "p\0"
+   "glWindowPos3dv\0"
+   "glWindowPos3dvARB\0"
+   "glWindowPos3dvMESA\0"
+   "\0"
+   /* _mesa_function_pool[14078]: DepthFunc (offset 245) */
+   "i\0"
+   "glDepthFunc\0"
+   "\0"
+   /* _mesa_function_pool[14093]: PixelMapusv (offset 253) */
+   "iip\0"
+   "glPixelMapusv\0"
+   "\0"
+   /* _mesa_function_pool[14112]: GetQueryObjecti64vEXT (will be remapped) */
+   "iip\0"
+   "glGetQueryObjecti64vEXT\0"
+   "\0"
+   /* _mesa_function_pool[14141]: MultiTexCoord1dARB (offset 376) */
+   "id\0"
+   "glMultiTexCoord1d\0"
+   "glMultiTexCoord1dARB\0"
+   "\0"
+   /* _mesa_function_pool[14184]: PointParameterivNV (will be remapped) */
+   "ip\0"
+   "glPointParameteriv\0"
+   "glPointParameterivNV\0"
+   "\0"
+   /* _mesa_function_pool[14228]: BlendFunc (offset 241) */
+   "ii\0"
+   "glBlendFunc\0"
+   "\0"
+   /* _mesa_function_pool[14244]: EndTransformFeedbackEXT (will be remapped) */
+   "\0"
+   "glEndTransformFeedbackEXT\0"
+   "glEndTransformFeedback\0"
+   "\0"
+   /* _mesa_function_pool[14295]: Uniform2fvARB (will be remapped) */
+   "iip\0"
+   "glUniform2fv\0"
+   "glUniform2fvARB\0"
+   "\0"
+   /* _mesa_function_pool[14329]: BufferParameteriAPPLE (will be remapped) */
+   "iii\0"
+   "glBufferParameteriAPPLE\0"
+   "\0"
+   /* _mesa_function_pool[14358]: MultiTexCoord3dvARB (offset 393) */
+   "ip\0"
+   "glMultiTexCoord3dv\0"
+   "glMultiTexCoord3dvARB\0"
+   "\0"
+   /* _mesa_function_pool[14403]: ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (dynamic) */
+   "pppp\0"
+   "glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[14459]: DeleteObjectARB (will be remapped) */
+   "i\0"
+   "glDeleteObjectARB\0"
+   "\0"
+   /* _mesa_function_pool[14480]: GetShaderPrecisionFormat (will be remapped) */
+   "iipp\0"
+   "glGetShaderPrecisionFormat\0"
+   "\0"
+   /* _mesa_function_pool[14513]: MatrixIndexPointerARB (dynamic) */
+   "iiip\0"
+   "glMatrixIndexPointerARB\0"
+   "\0"
+   /* _mesa_function_pool[14543]: ProgramNamedParameter4dvNV (will be remapped) */
+   "iipp\0"
+   "glProgramNamedParameter4dvNV\0"
+   "\0"
+   /* _mesa_function_pool[14578]: Tangent3fvEXT (dynamic) */
+   "p\0"
+   "glTangent3fvEXT\0"
+   "\0"
+   /* _mesa_function_pool[14597]: Flush (offset 217) */
+   "\0"
+   "glFlush\0"
+   "\0"
+   /* _mesa_function_pool[14607]: Color4uiv (offset 38) */
+   "p\0"
+   "glColor4uiv\0"
+   "\0"
+   /* _mesa_function_pool[14622]: VertexAttribI4iEXT (will be remapped) */
+   "iiiii\0"
+   "glVertexAttribI4iEXT\0"
+   "glVertexAttribI4i\0"
+   "\0"
+   /* _mesa_function_pool[14668]: GenVertexArrays (will be remapped) */
+   "ip\0"
+   "glGenVertexArrays\0"
+   "\0"
+   /* _mesa_function_pool[14690]: Uniform3uivEXT (will be remapped) */
+   "iip\0"
+   "glUniform3uivEXT\0"
+   "glUniform3uiv\0"
+   "\0"
+   /* _mesa_function_pool[14726]: RasterPos3sv (offset 77) */
+   "p\0"
+   "glRasterPos3sv\0"
+   "\0"
+   /* _mesa_function_pool[14744]: BindFramebufferEXT (will be remapped) */
+   "ii\0"
+   "glBindFramebuffer\0"
+   "glBindFramebufferEXT\0"
+   "\0"
+   /* _mesa_function_pool[14787]: ReferencePlaneSGIX (dynamic) */
+   "p\0"
+   "glReferencePlaneSGIX\0"
+   "\0"
+   /* _mesa_function_pool[14811]: PushAttrib (offset 219) */
+   "i\0"
+   "glPushAttrib\0"
+   "\0"
+   /* _mesa_function_pool[14827]: RasterPos2i (offset 66) */
+   "ii\0"
+   "glRasterPos2i\0"
+   "\0"
+   /* _mesa_function_pool[14845]: ValidateProgramARB (will be remapped) */
+   "i\0"
+   "glValidateProgram\0"
+   "glValidateProgramARB\0"
+   "\0"
+   /* _mesa_function_pool[14887]: TexParameteriv (offset 181) */
+   "iip\0"
+   "glTexParameteriv\0"
+   "\0"
+   /* _mesa_function_pool[14909]: UnlockArraysEXT (will be remapped) */
+   "\0"
+   "glUnlockArraysEXT\0"
+   "\0"
+   /* _mesa_function_pool[14929]: TexCoord2fColor3fVertex3fSUN (dynamic) */
+   "ffffffff\0"
+   "glTexCoord2fColor3fVertex3fSUN\0"
+   "\0"
+   /* _mesa_function_pool[14970]: WindowPos3fvMESA (will be remapped) */
+   "p\0"
+   "glWindowPos3fv\0"
+   "glWindowPos3fvARB\0"
+   "glWindowPos3fvMESA\0"
+   "\0"
+   /* _mesa_function_pool[15025]: RasterPos2f (offset 64) */
+   "ff\0"
+   "glRasterPos2f\0"
+   "\0"
+   /* _mesa_function_pool[15043]: VertexAttrib1svNV (will be remapped) */
+   "ip\0"
+   "glVertexAttrib1svNV\0"
+   "\0"
+   /* _mesa_function_pool[15067]: RasterPos2d (offset 62) */
+   "dd\0"
+   "glRasterPos2d\0"
+   "\0"
+   /* _mesa_function_pool[15085]: RasterPos3fv (offset 73) */
+   "p\0"
+   "glRasterPos3fv\0"
+   "\0"
+   /* _mesa_function_pool[15103]: CopyTexSubImage3D (offset 373) */
+   "iiiiiiiii\0"
+   "glCopyTexSubImage3D\0"
+   "glCopyTexSubImage3DEXT\0"
+   "\0"
+   /* _mesa_function_pool[15157]: VertexAttrib2dARB (will be remapped) */
+   "idd\0"
+   "glVertexAttrib2d\0"
+   "glVertexAttrib2dARB\0"
+   "\0"
+   /* _mesa_function_pool[15199]: Color4ub (offset 35) */
+   "iiii\0"
+   "glColor4ub\0"
+   "\0"
+   /* _mesa_function_pool[15216]: GetInteger64v (will be remapped) */
+   "ip\0"
+   "glGetInteger64v\0"
+   "\0"
+   /* _mesa_function_pool[15236]: TextureColorMaskSGIS (dynamic) */
+   "iiii\0"
+   "glTextureColorMaskSGIS\0"
+   "\0"
+   /* _mesa_function_pool[15265]: RasterPos2s (offset 68) */
+   "ii\0"
+   "glRasterPos2s\0"
+   "\0"
+   /* _mesa_function_pool[15283]: GetColorTable (offset 343) */
+   "iiip\0"
+   "glGetColorTable\0"
+   "glGetColorTableSGI\0"
+   "glGetColorTableEXT\0"
+   "\0"
+   /* _mesa_function_pool[15343]: SelectBuffer (offset 195) */
+   "ip\0"
+   "glSelectBuffer\0"
+   "\0"
+   /* _mesa_function_pool[15362]: Indexiv (offset 49) */
+   "p\0"
+   "glIndexiv\0"
+   "\0"
+   /* _mesa_function_pool[15375]: TexCoord3i (offset 114) */
+   "iii\0"
+   "glTexCoord3i\0"
+   "\0"
+   /* _mesa_function_pool[15393]: CopyColorTable (offset 342) */
+   "iiiii\0"
+   "glCopyColorTable\0"
+   "glCopyColorTableSGI\0"
+   "\0"
+   /* _mesa_function_pool[15437]: GetHistogramParameterfv (offset 362) */
+   "iip\0"
+   "glGetHistogramParameterfv\0"
+   "glGetHistogramParameterfvEXT\0"
+   "\0"
+   /* _mesa_function_pool[15497]: Frustum (offset 289) */
+   "dddddd\0"
+   "glFrustum\0"
+   "\0"
+   /* _mesa_function_pool[15515]: GetString (offset 275) */
+   "i\0"
+   "glGetString\0"
+   "\0"
+   /* _mesa_function_pool[15530]: ColorPointervINTEL (dynamic) */
+   "iip\0"
+   "glColorPointervINTEL\0"
+   "\0"
+   /* _mesa_function_pool[15556]: TexEnvf (offset 184) */
+   "iif\0"
+   "glTexEnvf\0"
+   "\0"
+   /* _mesa_function_pool[15571]: TexCoord3d (offset 110) */
+   "ddd\0"
+   "glTexCoord3d\0"
+   "\0"
+   /* _mesa_function_pool[15589]: AlphaFragmentOp1ATI (will be remapped) */
+   "iiiiii\0"
+   "glAlphaFragmentOp1ATI\0"
+   "\0"
+   /* _mesa_function_pool[15619]: TexCoord3f (offset 112) */
+   "fff\0"
+   "glTexCoord3f\0"
+   "\0"
+   /* _mesa_function_pool[15637]: MultiTexCoord3ivARB (offset 397) */
+   "ip\0"
+   "glMultiTexCoord3iv\0"
+   "glMultiTexCoord3ivARB\0"
+   "\0"
+   /* _mesa_function_pool[15682]: MultiTexCoord2sARB (offset 390) */
+   "iii\0"
+   "glMultiTexCoord2s\0"
+   "glMultiTexCoord2sARB\0"
+   "\0"
+   /* _mesa_function_pool[15726]: VertexAttrib1dvARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib1dv\0"
+   "glVertexAttrib1dvARB\0"
+   "\0"
+   /* _mesa_function_pool[15769]: DeleteTextures (offset 327) */
+   "ip\0"
+   "glDeleteTextures\0"
+   "glDeleteTexturesEXT\0"
+   "\0"
+   /* _mesa_function_pool[15810]: TexCoordPointerEXT (will be remapped) */
+   "iiiip\0"
+   "glTexCoordPointerEXT\0"
+   "\0"
+   /* _mesa_function_pool[15838]: TexSubImage4DSGIS (dynamic) */
+   "iiiiiiiiiiiip\0"
+   "glTexSubImage4DSGIS\0"
+   "\0"
+   /* _mesa_function_pool[15873]: TexCoord3s (offset 116) */
+   "iii\0"
+   "glTexCoord3s\0"
+   "\0"
+   /* _mesa_function_pool[15891]: GetTexLevelParameteriv (offset 285) */
+   "iiip\0"
+   "glGetTexLevelParameteriv\0"
+   "\0"
+   /* _mesa_function_pool[15922]: CombinerStageParameterfvNV (dynamic) */
+   "iip\0"
+   "glCombinerStageParameterfvNV\0"
+   "\0"
+   /* _mesa_function_pool[15956]: StopInstrumentsSGIX (dynamic) */
+   "i\0"
+   "glStopInstrumentsSGIX\0"
+   "\0"
+   /* _mesa_function_pool[15981]: TexCoord4fColor4fNormal3fVertex4fSUN (dynamic) */
+   "fffffffffffffff\0"
+   "glTexCoord4fColor4fNormal3fVertex4fSUN\0"
+   "\0"
+   /* _mesa_function_pool[16037]: ClearAccum (offset 204) */
+   "ffff\0"
+   "glClearAccum\0"
+   "\0"
+   /* _mesa_function_pool[16056]: DeformSGIX (dynamic) */
+   "i\0"
+   "glDeformSGIX\0"
+   "\0"
+   /* _mesa_function_pool[16072]: GetVertexAttribfvARB (will be remapped) */
+   "iip\0"
+   "glGetVertexAttribfv\0"
+   "glGetVertexAttribfvARB\0"
+   "\0"
+   /* _mesa_function_pool[16120]: SecondaryColor3ivEXT (will be remapped) */
+   "p\0"
+   "glSecondaryColor3iv\0"
+   "glSecondaryColor3ivEXT\0"
+   "\0"
+   /* _mesa_function_pool[16166]: TexCoord4iv (offset 123) */
+   "p\0"
+   "glTexCoord4iv\0"
+   "\0"
+   /* _mesa_function_pool[16183]: VertexAttribI4uiEXT (will be remapped) */
+   "iiiii\0"
+   "glVertexAttribI4uiEXT\0"
+   "glVertexAttribI4ui\0"
+   "\0"
+   /* _mesa_function_pool[16231]: GetFragmentMaterialfvSGIX (dynamic) */
+   "iip\0"
+   "glGetFragmentMaterialfvSGIX\0"
+   "\0"
+   /* _mesa_function_pool[16264]: UniformMatrix4x2fv (will be remapped) */
+   "iiip\0"
+   "glUniformMatrix4x2fv\0"
+   "\0"
+   /* _mesa_function_pool[16291]: GetDetailTexFuncSGIS (dynamic) */
+   "ip\0"
+   "glGetDetailTexFuncSGIS\0"
+   "\0"
+   /* _mesa_function_pool[16318]: GetCombinerStageParameterfvNV (dynamic) */
+   "iip\0"
+   "glGetCombinerStageParameterfvNV\0"
+   "\0"
+   /* _mesa_function_pool[16355]: PolygonOffset (offset 319) */
+   "ff\0"
+   "glPolygonOffset\0"
+   "\0"
+   /* _mesa_function_pool[16375]: BindVertexArray (will be remapped) */
+   "i\0"
+   "glBindVertexArray\0"
+   "\0"
+   /* _mesa_function_pool[16396]: Color4ubVertex2fvSUN (dynamic) */
+   "pp\0"
+   "glColor4ubVertex2fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[16423]: Rectd (offset 86) */
+   "dddd\0"
+   "glRectd\0"
+   "\0"
+   /* _mesa_function_pool[16437]: TexFilterFuncSGIS (dynamic) */
+   "iiip\0"
+   "glTexFilterFuncSGIS\0"
+   "\0"
+   /* _mesa_function_pool[16463]: TextureBarrierNV (will be remapped) */
+   "\0"
+   "glTextureBarrierNV\0"
+   "\0"
+   /* _mesa_function_pool[16484]: VertexAttribI4ubvEXT (will be remapped) */
+   "ip\0"
+   "glVertexAttribI4ubvEXT\0"
+   "glVertexAttribI4ubv\0"
+   "\0"
+   /* _mesa_function_pool[16531]: GetAttribLocationARB (will be remapped) */
+   "ip\0"
+   "glGetAttribLocation\0"
+   "glGetAttribLocationARB\0"
+   "\0"
+   /* _mesa_function_pool[16578]: RasterPos3i (offset 74) */
+   "iii\0"
+   "glRasterPos3i\0"
+   "\0"
+   /* _mesa_function_pool[16597]: VertexAttrib4ubvARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib4ubv\0"
+   "glVertexAttrib4ubvARB\0"
+   "\0"
+   /* _mesa_function_pool[16642]: DetailTexFuncSGIS (dynamic) */
+   "iip\0"
+   "glDetailTexFuncSGIS\0"
+   "\0"
+   /* _mesa_function_pool[16667]: Normal3fVertex3fSUN (dynamic) */
+   "ffffff\0"
+   "glNormal3fVertex3fSUN\0"
+   "\0"
+   /* _mesa_function_pool[16697]: CopyTexImage2D (offset 324) */
+   "iiiiiiii\0"
+   "glCopyTexImage2D\0"
+   "glCopyTexImage2DEXT\0"
+   "\0"
+   /* _mesa_function_pool[16744]: GetBufferPointervARB (will be remapped) */
+   "iip\0"
+   "glGetBufferPointerv\0"
+   "glGetBufferPointervARB\0"
+   "\0"
+   /* _mesa_function_pool[16792]: ProgramEnvParameter4fARB (will be remapped) */
+   "iiffff\0"
+   "glProgramEnvParameter4fARB\0"
+   "glProgramParameter4fNV\0"
+   "\0"
+   /* _mesa_function_pool[16850]: Uniform3ivARB (will be remapped) */
+   "iip\0"
+   "glUniform3iv\0"
+   "glUniform3ivARB\0"
+   "\0"
+   /* _mesa_function_pool[16884]: Lightfv (offset 160) */
+   "iip\0"
+   "glLightfv\0"
+   "\0"
+   /* _mesa_function_pool[16899]: PrimitiveRestartIndexNV (will be remapped) */
+   "i\0"
+   "glPrimitiveRestartIndexNV\0"
+   "glPrimitiveRestartIndex\0"
+   "\0"
+   /* _mesa_function_pool[16952]: ClearDepth (offset 208) */
+   "d\0"
+   "glClearDepth\0"
+   "\0"
+   /* _mesa_function_pool[16968]: GetFenceivNV (will be remapped) */
+   "iip\0"
+   "glGetFenceivNV\0"
+   "\0"
+   /* _mesa_function_pool[16988]: WindowPos4dvMESA (will be remapped) */
+   "p\0"
+   "glWindowPos4dvMESA\0"
+   "\0"
+   /* _mesa_function_pool[17010]: ColorSubTable (offset 346) */
+   "iiiiip\0"
+   "glColorSubTable\0"
+   "glColorSubTableEXT\0"
+   "\0"
+   /* _mesa_function_pool[17053]: Color4fv (offset 30) */
+   "p\0"
+   "glColor4fv\0"
+   "\0"
+   /* _mesa_function_pool[17067]: MultiTexCoord4ivARB (offset 405) */
+   "ip\0"
+   "glMultiTexCoord4iv\0"
+   "glMultiTexCoord4ivARB\0"
+   "\0"
+   /* _mesa_function_pool[17112]: ProgramLocalParameters4fvEXT (will be remapped) */
+   "iiip\0"
+   "glProgramLocalParameters4fvEXT\0"
+   "\0"
+   /* _mesa_function_pool[17149]: ColorPointer (offset 308) */
+   "iiip\0"
+   "glColorPointer\0"
+   "\0"
+   /* _mesa_function_pool[17170]: Rects (offset 92) */
+   "iiii\0"
+   "glRects\0"
+   "\0"
+   /* _mesa_function_pool[17184]: GetMapAttribParameterfvNV (dynamic) */
+   "iiip\0"
+   "glGetMapAttribParameterfvNV\0"
+   "\0"
+   /* _mesa_function_pool[17218]: CreateShaderProgramEXT (will be remapped) */
+   "ip\0"
+   "glCreateShaderProgramEXT\0"
+   "\0"
+   /* _mesa_function_pool[17247]: ActiveProgramEXT (will be remapped) */
+   "i\0"
+   "glActiveProgramEXT\0"
+   "\0"
+   /* _mesa_function_pool[17269]: Lightiv (offset 162) */
+   "iip\0"
+   "glLightiv\0"
+   "\0"
+   /* _mesa_function_pool[17284]: VertexAttrib4sARB (will be remapped) */
+   "iiiii\0"
+   "glVertexAttrib4s\0"
+   "glVertexAttrib4sARB\0"
+   "\0"
+   /* _mesa_function_pool[17328]: GetQueryObjectuivARB (will be remapped) */
+   "iip\0"
+   "glGetQueryObjectuiv\0"
+   "glGetQueryObjectuivARB\0"
+   "\0"
+   /* _mesa_function_pool[17376]: GetTexParameteriv (offset 283) */
+   "iip\0"
+   "glGetTexParameteriv\0"
+   "\0"
+   /* _mesa_function_pool[17401]: MapParameterivNV (dynamic) */
+   "iip\0"
+   "glMapParameterivNV\0"
+   "\0"
+   /* _mesa_function_pool[17425]: GenRenderbuffersEXT (will be remapped) */
+   "ip\0"
+   "glGenRenderbuffers\0"
+   "glGenRenderbuffersEXT\0"
+   "\0"
+   /* _mesa_function_pool[17470]: ClearBufferfv (will be remapped) */
+   "iip\0"
+   "glClearBufferfv\0"
+   "\0"
+   /* _mesa_function_pool[17491]: VertexAttrib2dvARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib2dv\0"
+   "glVertexAttrib2dvARB\0"
+   "\0"
+   /* _mesa_function_pool[17534]: EdgeFlagPointerEXT (will be remapped) */
+   "iip\0"
+   "glEdgeFlagPointerEXT\0"
+   "\0"
+   /* _mesa_function_pool[17560]: VertexAttribs2svNV (will be remapped) */
+   "iip\0"
+   "glVertexAttribs2svNV\0"
+   "\0"
+   /* _mesa_function_pool[17586]: WeightbvARB (dynamic) */
+   "ip\0"
+   "glWeightbvARB\0"
+   "\0"
+   /* _mesa_function_pool[17604]: VertexAttrib2fvARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib2fv\0"
+   "glVertexAttrib2fvARB\0"
+   "\0"
+   /* _mesa_function_pool[17647]: GetBufferParameterivARB (will be remapped) */
+   "iip\0"
+   "glGetBufferParameteriv\0"
+   "glGetBufferParameterivARB\0"
+   "\0"
+   /* _mesa_function_pool[17701]: Rectdv (offset 87) */
+   "pp\0"
+   "glRectdv\0"
+   "\0"
+   /* _mesa_function_pool[17714]: ListParameteriSGIX (dynamic) */
+   "iii\0"
+   "glListParameteriSGIX\0"
+   "\0"
+   /* _mesa_function_pool[17740]: BlendEquationiARB (will be remapped) */
+   "ii\0"
+   "glBlendEquationiARB\0"
+   "\0"
+   /* _mesa_function_pool[17764]: ReplacementCodeuiColor4fNormal3fVertex3fSUN (dynamic) */
+   "iffffffffff\0"
+   "glReplacementCodeuiColor4fNormal3fVertex3fSUN\0"
+   "\0"
+   /* _mesa_function_pool[17823]: InstrumentsBufferSGIX (dynamic) */
+   "ip\0"
+   "glInstrumentsBufferSGIX\0"
+   "\0"
+   /* _mesa_function_pool[17851]: VertexAttrib4NivARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib4Niv\0"
+   "glVertexAttrib4NivARB\0"
+   "\0"
+   /* _mesa_function_pool[17896]: DrawArraysInstancedARB (will be remapped) */
+   "iiii\0"
+   "glDrawArraysInstancedARB\0"
+   "glDrawArraysInstancedEXT\0"
+   "glDrawArraysInstanced\0"
+   "\0"
+   /* _mesa_function_pool[17974]: GetAttachedShaders (will be remapped) */
+   "iipp\0"
+   "glGetAttachedShaders\0"
+   "\0"
+   /* _mesa_function_pool[18001]: GenVertexArraysAPPLE (will be remapped) */
+   "ip\0"
+   "glGenVertexArraysAPPLE\0"
+   "\0"
+   /* _mesa_function_pool[18028]: ClearBufferfi (will be remapped) */
+   "iifi\0"
+   "glClearBufferfi\0"
+   "\0"
+   /* _mesa_function_pool[18050]: Materialiv (offset 172) */
+   "iip\0"
+   "glMaterialiv\0"
+   "\0"
+   /* _mesa_function_pool[18068]: PushClientAttrib (offset 335) */
+   "i\0"
+   "glPushClientAttrib\0"
+   "\0"
+   /* _mesa_function_pool[18090]: ProgramEnvParameters4fvEXT (will be remapped) */
+   "iiip\0"
+   "glProgramEnvParameters4fvEXT\0"
+   "\0"
+   /* _mesa_function_pool[18125]: TexCoord2fColor4fNormal3fVertex3fvSUN (dynamic) */
+   "pppp\0"
+   "glTexCoord2fColor4fNormal3fVertex3fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[18171]: WindowPos2iMESA (will be remapped) */
+   "ii\0"
+   "glWindowPos2i\0"
+   "glWindowPos2iARB\0"
+   "glWindowPos2iMESA\0"
+   "\0"
+   /* _mesa_function_pool[18224]: SampleMaskSGIS (will be remapped) */
+   "fi\0"
+   "glSampleMaskSGIS\0"
+   "glSampleMaskEXT\0"
+   "\0"
+   /* _mesa_function_pool[18261]: SecondaryColor3fvEXT (will be remapped) */
+   "p\0"
+   "glSecondaryColor3fv\0"
+   "glSecondaryColor3fvEXT\0"
+   "\0"
+   /* _mesa_function_pool[18307]: PolygonMode (offset 174) */
+   "ii\0"
+   "glPolygonMode\0"
+   "\0"
+   /* _mesa_function_pool[18325]: CompressedTexSubImage1DARB (will be remapped) */
+   "iiiiiip\0"
+   "glCompressedTexSubImage1D\0"
+   "glCompressedTexSubImage1DARB\0"
+   "\0"
+   /* _mesa_function_pool[18389]: VertexAttribI1iEXT (will be remapped) */
+   "ii\0"
+   "glVertexAttribI1iEXT\0"
+   "glVertexAttribI1i\0"
+   "\0"
+   /* _mesa_function_pool[18432]: GetVertexAttribivNV (will be remapped) */
+   "iip\0"
+   "glGetVertexAttribivNV\0"
+   "\0"
+   /* _mesa_function_pool[18459]: GetProgramStringARB (will be remapped) */
+   "iip\0"
+   "glGetProgramStringARB\0"
+   "\0"
+   /* _mesa_function_pool[18486]: VertexAttribIPointerEXT (will be remapped) */
+   "iiiip\0"
+   "glVertexAttribIPointerEXT\0"
+   "glVertexAttribIPointer\0"
+   "\0"
+   /* _mesa_function_pool[18542]: TexBumpParameterfvATI (will be remapped) */
+   "ip\0"
+   "glTexBumpParameterfvATI\0"
+   "\0"
+   /* _mesa_function_pool[18570]: CompileShaderARB (will be remapped) */
+   "i\0"
+   "glCompileShader\0"
+   "glCompileShaderARB\0"
+   "\0"
+   /* _mesa_function_pool[18608]: DeleteShader (will be remapped) */
+   "i\0"
+   "glDeleteShader\0"
+   "\0"
+   /* _mesa_function_pool[18626]: DisableClientState (offset 309) */
+   "i\0"
+   "glDisableClientState\0"
+   "\0"
+   /* _mesa_function_pool[18650]: TexGeni (offset 192) */
+   "iii\0"
+   "glTexGeni\0"
+   "\0"
+   /* _mesa_function_pool[18665]: TexGenf (offset 190) */
+   "iif\0"
+   "glTexGenf\0"
+   "\0"
+   /* _mesa_function_pool[18680]: Uniform3fARB (will be remapped) */
+   "ifff\0"
+   "glUniform3f\0"
+   "glUniform3fARB\0"
+   "\0"
+   /* _mesa_function_pool[18713]: TexGend (offset 188) */
+   "iid\0"
+   "glTexGend\0"
+   "\0"
+   /* _mesa_function_pool[18728]: ListParameterfvSGIX (dynamic) */
+   "iip\0"
+   "glListParameterfvSGIX\0"
+   "\0"
+   /* _mesa_function_pool[18755]: GetPolygonStipple (offset 274) */
+   "p\0"
+   "glGetPolygonStipple\0"
+   "\0"
+   /* _mesa_function_pool[18778]: Tangent3dvEXT (dynamic) */
+   "p\0"
+   "glTangent3dvEXT\0"
+   "\0"
+   /* _mesa_function_pool[18797]: BindBufferOffsetEXT (will be remapped) */
+   "iiii\0"
+   "glBindBufferOffsetEXT\0"
+   "\0"
+   /* _mesa_function_pool[18825]: WindowPos3sMESA (will be remapped) */
+   "iii\0"
+   "glWindowPos3s\0"
+   "glWindowPos3sARB\0"
+   "glWindowPos3sMESA\0"
+   "\0"
+   /* _mesa_function_pool[18879]: VertexAttrib2svNV (will be remapped) */
+   "ip\0"
+   "glVertexAttrib2svNV\0"
+   "\0"
+   /* _mesa_function_pool[18903]: DisableIndexedEXT (will be remapped) */
+   "ii\0"
+   "glDisableIndexedEXT\0"
+   "glDisablei\0"
+   "\0"
+   /* _mesa_function_pool[18938]: BindBufferBaseEXT (will be remapped) */
+   "iii\0"
+   "glBindBufferBaseEXT\0"
+   "glBindBufferBase\0"
+   "\0"
+   /* _mesa_function_pool[18980]: TexCoord2fVertex3fvSUN (dynamic) */
+   "pp\0"
+   "glTexCoord2fVertex3fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[19009]: WindowPos4sMESA (will be remapped) */
+   "iiii\0"
+   "glWindowPos4sMESA\0"
+   "\0"
+   /* _mesa_function_pool[19033]: VertexAttrib4NuivARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib4Nuiv\0"
+   "glVertexAttrib4NuivARB\0"
+   "\0"
+   /* _mesa_function_pool[19080]: ClientActiveTextureARB (offset 375) */
+   "i\0"
+   "glClientActiveTexture\0"
+   "glClientActiveTextureARB\0"
+   "\0"
+   /* _mesa_function_pool[19130]: PixelTexGenSGIX (will be remapped) */
+   "i\0"
+   "glPixelTexGenSGIX\0"
+   "\0"
+   /* _mesa_function_pool[19151]: ReplacementCodeusvSUN (dynamic) */
+   "p\0"
+   "glReplacementCodeusvSUN\0"
+   "\0"
+   /* _mesa_function_pool[19178]: Uniform4fARB (will be remapped) */
+   "iffff\0"
+   "glUniform4f\0"
+   "glUniform4fARB\0"
+   "\0"
+   /* _mesa_function_pool[19212]: Color4sv (offset 34) */
+   "p\0"
+   "glColor4sv\0"
+   "\0"
+   /* _mesa_function_pool[19226]: FlushMappedBufferRange (will be remapped) */
+   "iii\0"
+   "glFlushMappedBufferRange\0"
+   "\0"
+   /* _mesa_function_pool[19256]: IsProgramNV (will be remapped) */
+   "i\0"
+   "glIsProgramARB\0"
+   "glIsProgramNV\0"
+   "\0"
+   /* _mesa_function_pool[19288]: FlushMappedBufferRangeAPPLE (will be remapped) */
+   "iii\0"
+   "glFlushMappedBufferRangeAPPLE\0"
+   "\0"
+   /* _mesa_function_pool[19323]: PixelZoom (offset 246) */
+   "ff\0"
+   "glPixelZoom\0"
+   "\0"
+   /* _mesa_function_pool[19339]: ReplacementCodePointerSUN (dynamic) */
+   "iip\0"
+   "glReplacementCodePointerSUN\0"
+   "\0"
+   /* _mesa_function_pool[19372]: ProgramEnvParameter4dARB (will be remapped) */
+   "iidddd\0"
+   "glProgramEnvParameter4dARB\0"
+   "glProgramParameter4dNV\0"
+   "\0"
+   /* _mesa_function_pool[19430]: ColorTableParameterfv (offset 340) */
+   "iip\0"
+   "glColorTableParameterfv\0"
+   "glColorTableParameterfvSGI\0"
+   "\0"
+   /* _mesa_function_pool[19486]: FragmentLightModelfSGIX (dynamic) */
+   "if\0"
+   "glFragmentLightModelfSGIX\0"
+   "\0"
+   /* _mesa_function_pool[19516]: Binormal3bvEXT (dynamic) */
+   "p\0"
+   "glBinormal3bvEXT\0"
+   "\0"
+   /* _mesa_function_pool[19536]: PixelMapuiv (offset 252) */
+   "iip\0"
+   "glPixelMapuiv\0"
+   "\0"
+   /* _mesa_function_pool[19555]: Color3dv (offset 12) */
+   "p\0"
+   "glColor3dv\0"
+   "\0"
+   /* _mesa_function_pool[19569]: IsTexture (offset 330) */
+   "i\0"
+   "glIsTexture\0"
+   "glIsTextureEXT\0"
+   "\0"
+   /* _mesa_function_pool[19599]: VertexWeightfvEXT (dynamic) */
+   "p\0"
+   "glVertexWeightfvEXT\0"
+   "\0"
+   /* _mesa_function_pool[19622]: VertexAttrib1dARB (will be remapped) */
+   "id\0"
+   "glVertexAttrib1d\0"
+   "glVertexAttrib1dARB\0"
+   "\0"
+   /* _mesa_function_pool[19663]: ImageTransformParameterivHP (dynamic) */
+   "iip\0"
+   "glImageTransformParameterivHP\0"
+   "\0"
+   /* _mesa_function_pool[19698]: TexCoord4i (offset 122) */
+   "iiii\0"
+   "glTexCoord4i\0"
+   "\0"
+   /* _mesa_function_pool[19717]: DeleteQueriesARB (will be remapped) */
+   "ip\0"
+   "glDeleteQueries\0"
+   "glDeleteQueriesARB\0"
+   "\0"
+   /* _mesa_function_pool[19756]: Color4ubVertex2fSUN (dynamic) */
+   "iiiiff\0"
+   "glColor4ubVertex2fSUN\0"
+   "\0"
+   /* _mesa_function_pool[19786]: FragmentColorMaterialSGIX (dynamic) */
+   "ii\0"
+   "glFragmentColorMaterialSGIX\0"
+   "\0"
+   /* _mesa_function_pool[19818]: CurrentPaletteMatrixARB (dynamic) */
+   "i\0"
+   "glCurrentPaletteMatrixARB\0"
+   "\0"
+   /* _mesa_function_pool[19847]: GetMapdv (offset 266) */
+   "iip\0"
+   "glGetMapdv\0"
+   "\0"
+   /* _mesa_function_pool[19863]: ObjectPurgeableAPPLE (will be remapped) */
+   "iii\0"
+   "glObjectPurgeableAPPLE\0"
+   "\0"
+   /* _mesa_function_pool[19891]: GetStringi (will be remapped) */
+   "ii\0"
+   "glGetStringi\0"
+   "\0"
+   /* _mesa_function_pool[19908]: SamplePatternSGIS (will be remapped) */
+   "i\0"
+   "glSamplePatternSGIS\0"
+   "glSamplePatternEXT\0"
+   "\0"
+   /* _mesa_function_pool[19950]: PixelStoref (offset 249) */
+   "if\0"
+   "glPixelStoref\0"
+   "\0"
+   /* _mesa_function_pool[19968]: IsQueryARB (will be remapped) */
+   "i\0"
+   "glIsQuery\0"
+   "glIsQueryARB\0"
+   "\0"
+   /* _mesa_function_pool[19994]: ReplacementCodeuiColor4ubVertex3fSUN (dynamic) */
+   "iiiiifff\0"
+   "glReplacementCodeuiColor4ubVertex3fSUN\0"
+   "\0"
+   /* _mesa_function_pool[20043]: PixelStorei (offset 250) */
+   "ii\0"
+   "glPixelStorei\0"
+   "\0"
+   /* _mesa_function_pool[20061]: VertexAttrib4usvARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib4usv\0"
+   "glVertexAttrib4usvARB\0"
+   "\0"
+   /* _mesa_function_pool[20106]: LinkProgramARB (will be remapped) */
+   "i\0"
+   "glLinkProgram\0"
+   "glLinkProgramARB\0"
+   "\0"
+   /* _mesa_function_pool[20140]: VertexAttrib2fNV (will be remapped) */
+   "iff\0"
+   "glVertexAttrib2fNV\0"
+   "\0"
+   /* _mesa_function_pool[20164]: ShaderSourceARB (will be remapped) */
+   "iipp\0"
+   "glShaderSource\0"
+   "glShaderSourceARB\0"
+   "\0"
+   /* _mesa_function_pool[20203]: FragmentMaterialiSGIX (dynamic) */
+   "iii\0"
+   "glFragmentMaterialiSGIX\0"
+   "\0"
+   /* _mesa_function_pool[20232]: EvalCoord2dv (offset 233) */
+   "p\0"
+   "glEvalCoord2dv\0"
+   "\0"
+   /* _mesa_function_pool[20250]: VertexAttrib3svARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib3sv\0"
+   "glVertexAttrib3svARB\0"
+   "\0"
+   /* _mesa_function_pool[20293]: ColorMaterial (offset 151) */
+   "ii\0"
+   "glColorMaterial\0"
+   "\0"
+   /* _mesa_function_pool[20313]: CompressedTexSubImage3DARB (will be remapped) */
+   "iiiiiiiiiip\0"
+   "glCompressedTexSubImage3D\0"
+   "glCompressedTexSubImage3DARB\0"
+   "\0"
+   /* _mesa_function_pool[20381]: WindowPos2ivMESA (will be remapped) */
+   "p\0"
+   "glWindowPos2iv\0"
+   "glWindowPos2ivARB\0"
+   "glWindowPos2ivMESA\0"
+   "\0"
+   /* _mesa_function_pool[20436]: IsFramebufferEXT (will be remapped) */
+   "i\0"
+   "glIsFramebuffer\0"
+   "glIsFramebufferEXT\0"
+   "\0"
+   /* _mesa_function_pool[20474]: Uniform4ivARB (will be remapped) */
+   "iip\0"
+   "glUniform4iv\0"
+   "glUniform4ivARB\0"
+   "\0"
+   /* _mesa_function_pool[20508]: GetVertexAttribdvARB (will be remapped) */
+   "iip\0"
+   "glGetVertexAttribdv\0"
+   "glGetVertexAttribdvARB\0"
+   "\0"
+   /* _mesa_function_pool[20556]: TexBumpParameterivATI (will be remapped) */
+   "ip\0"
+   "glTexBumpParameterivATI\0"
+   "\0"
+   /* _mesa_function_pool[20584]: GetSeparableFilter (offset 359) */
+   "iiippp\0"
+   "glGetSeparableFilter\0"
+   "glGetSeparableFilterEXT\0"
+   "\0"
+   /* _mesa_function_pool[20637]: Binormal3dEXT (dynamic) */
+   "ddd\0"
+   "glBinormal3dEXT\0"
+   "\0"
+   /* _mesa_function_pool[20658]: SpriteParameteriSGIX (dynamic) */
+   "ii\0"
+   "glSpriteParameteriSGIX\0"
+   "\0"
+   /* _mesa_function_pool[20685]: RequestResidentProgramsNV (will be remapped) */
+   "ip\0"
+   "glRequestResidentProgramsNV\0"
+   "\0"
+   /* _mesa_function_pool[20717]: TagSampleBufferSGIX (dynamic) */
+   "\0"
+   "glTagSampleBufferSGIX\0"
+   "\0"
+   /* _mesa_function_pool[20741]: TransformFeedbackVaryingsEXT (will be remapped) */
+   "iipi\0"
+   "glTransformFeedbackVaryingsEXT\0"
+   "glTransformFeedbackVaryings\0"
+   "\0"
+   /* _mesa_function_pool[20806]: FeedbackBuffer (offset 194) */
+   "iip\0"
+   "glFeedbackBuffer\0"
+   "\0"
+   /* _mesa_function_pool[20828]: RasterPos2iv (offset 67) */
+   "p\0"
+   "glRasterPos2iv\0"
+   "\0"
+   /* _mesa_function_pool[20846]: TexImage1D (offset 182) */
+   "iiiiiiip\0"
+   "glTexImage1D\0"
+   "\0"
+   /* _mesa_function_pool[20869]: ListParameterivSGIX (dynamic) */
+   "iip\0"
+   "glListParameterivSGIX\0"
+   "\0"
+   /* _mesa_function_pool[20896]: MultiDrawElementsEXT (will be remapped) */
+   "ipipi\0"
+   "glMultiDrawElements\0"
+   "glMultiDrawElementsEXT\0"
+   "\0"
+   /* _mesa_function_pool[20946]: Color3s (offset 17) */
+   "iii\0"
+   "glColor3s\0"
+   "\0"
+   /* _mesa_function_pool[20961]: Uniform1ivARB (will be remapped) */
+   "iip\0"
+   "glUniform1iv\0"
+   "glUniform1ivARB\0"
+   "\0"
+   /* _mesa_function_pool[20995]: WindowPos2sMESA (will be remapped) */
+   "ii\0"
+   "glWindowPos2s\0"
+   "glWindowPos2sARB\0"
+   "glWindowPos2sMESA\0"
+   "\0"
+   /* _mesa_function_pool[21048]: WeightusvARB (dynamic) */
+   "ip\0"
+   "glWeightusvARB\0"
+   "\0"
+   /* _mesa_function_pool[21067]: TexCoordPointer (offset 320) */
+   "iiip\0"
+   "glTexCoordPointer\0"
+   "\0"
+   /* _mesa_function_pool[21091]: FogCoordPointerEXT (will be remapped) */
+   "iip\0"
+   "glFogCoordPointer\0"
+   "glFogCoordPointerEXT\0"
+   "\0"
+   /* _mesa_function_pool[21135]: IndexMaterialEXT (dynamic) */
+   "ii\0"
+   "glIndexMaterialEXT\0"
+   "\0"
+   /* _mesa_function_pool[21158]: Color3i (offset 15) */
+   "iii\0"
+   "glColor3i\0"
+   "\0"
+   /* _mesa_function_pool[21173]: FrontFace (offset 157) */
+   "i\0"
+   "glFrontFace\0"
+   "\0"
+   /* _mesa_function_pool[21188]: EvalCoord2d (offset 232) */
+   "dd\0"
+   "glEvalCoord2d\0"
+   "\0"
+   /* _mesa_function_pool[21206]: SecondaryColor3ubvEXT (will be remapped) */
+   "p\0"
+   "glSecondaryColor3ubv\0"
+   "glSecondaryColor3ubvEXT\0"
+   "\0"
+   /* _mesa_function_pool[21254]: EvalCoord2f (offset 234) */
+   "ff\0"
+   "glEvalCoord2f\0"
+   "\0"
+   /* _mesa_function_pool[21272]: VertexAttrib4dvARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib4dv\0"
+   "glVertexAttrib4dvARB\0"
+   "\0"
+   /* _mesa_function_pool[21315]: BindAttribLocationARB (will be remapped) */
+   "iip\0"
+   "glBindAttribLocation\0"
+   "glBindAttribLocationARB\0"
+   "\0"
+   /* _mesa_function_pool[21365]: Color3b (offset 9) */
+   "iii\0"
+   "glColor3b\0"
+   "\0"
+   /* _mesa_function_pool[21380]: MultiTexCoord2dARB (offset 384) */
+   "idd\0"
+   "glMultiTexCoord2d\0"
+   "glMultiTexCoord2dARB\0"
+   "\0"
+   /* _mesa_function_pool[21424]: ExecuteProgramNV (will be remapped) */
+   "iip\0"
+   "glExecuteProgramNV\0"
+   "\0"
+   /* _mesa_function_pool[21448]: Color3f (offset 13) */
+   "fff\0"
+   "glColor3f\0"
+   "\0"
+   /* _mesa_function_pool[21463]: LightEnviSGIX (dynamic) */
+   "ii\0"
+   "glLightEnviSGIX\0"
+   "\0"
+   /* _mesa_function_pool[21483]: Color3d (offset 11) */
+   "ddd\0"
+   "glColor3d\0"
+   "\0"
+   /* _mesa_function_pool[21498]: Normal3dv (offset 55) */
+   "p\0"
+   "glNormal3dv\0"
+   "\0"
+   /* _mesa_function_pool[21513]: Lightf (offset 159) */
+   "iif\0"
+   "glLightf\0"
+   "\0"
+   /* _mesa_function_pool[21527]: ReplacementCodeuiSUN (dynamic) */
+   "i\0"
+   "glReplacementCodeuiSUN\0"
+   "\0"
+   /* _mesa_function_pool[21553]: MatrixMode (offset 293) */
+   "i\0"
+   "glMatrixMode\0"
+   "\0"
+   /* _mesa_function_pool[21569]: GetPixelMapusv (offset 273) */
+   "ip\0"
+   "glGetPixelMapusv\0"
+   "\0"
+   /* _mesa_function_pool[21590]: Lighti (offset 161) */
+   "iii\0"
+   "glLighti\0"
+   "\0"
+   /* _mesa_function_pool[21604]: VertexAttribPointerNV (will be remapped) */
+   "iiiip\0"
+   "glVertexAttribPointerNV\0"
+   "\0"
+   /* _mesa_function_pool[21635]: ClearDepthf (will be remapped) */
+   "f\0"
+   "glClearDepthf\0"
+   "\0"
+   /* _mesa_function_pool[21652]: GetBooleanIndexedvEXT (will be remapped) */
+   "iip\0"
+   "glGetBooleanIndexedvEXT\0"
+   "glGetBooleani_v\0"
+   "\0"
+   /* _mesa_function_pool[21697]: GetFramebufferAttachmentParameterivEXT (will be remapped) */
+   "iiip\0"
+   "glGetFramebufferAttachmentParameteriv\0"
+   "glGetFramebufferAttachmentParameterivEXT\0"
+   "\0"
+   /* _mesa_function_pool[21782]: PixelTransformParameterfEXT (dynamic) */
+   "iif\0"
+   "glPixelTransformParameterfEXT\0"
+   "\0"
+   /* _mesa_function_pool[21817]: MultiTexCoord4dvARB (offset 401) */
+   "ip\0"
+   "glMultiTexCoord4dv\0"
+   "glMultiTexCoord4dvARB\0"
+   "\0"
+   /* _mesa_function_pool[21862]: PixelTransformParameteriEXT (dynamic) */
+   "iii\0"
+   "glPixelTransformParameteriEXT\0"
+   "\0"
+   /* _mesa_function_pool[21897]: GetDoublev (offset 260) */
+   "ip\0"
+   "glGetDoublev\0"
+   "\0"
+   /* _mesa_function_pool[21914]: MultMatrixd (offset 295) */
+   "p\0"
+   "glMultMatrixd\0"
+   "\0"
+   /* _mesa_function_pool[21931]: MultMatrixf (offset 294) */
+   "p\0"
+   "glMultMatrixf\0"
+   "\0"
+   /* _mesa_function_pool[21948]: VertexAttribI4bvEXT (will be remapped) */
+   "ip\0"
+   "glVertexAttribI4bvEXT\0"
+   "glVertexAttribI4bv\0"
+   "\0"
+   /* _mesa_function_pool[21993]: TexCoord2fColor4ubVertex3fSUN (dynamic) */
+   "ffiiiifff\0"
+   "glTexCoord2fColor4ubVertex3fSUN\0"
+   "\0"
+   /* _mesa_function_pool[22036]: Uniform1iARB (will be remapped) */
+   "ii\0"
+   "glUniform1i\0"
+   "glUniform1iARB\0"
+   "\0"
+   /* _mesa_function_pool[22067]: VertexAttribPointerARB (will be remapped) */
+   "iiiiip\0"
+   "glVertexAttribPointer\0"
+   "glVertexAttribPointerARB\0"
+   "\0"
+   /* _mesa_function_pool[22122]: VertexAttrib3sNV (will be remapped) */
+   "iiii\0"
+   "glVertexAttrib3sNV\0"
+   "\0"
+   /* _mesa_function_pool[22147]: SharpenTexFuncSGIS (dynamic) */
+   "iip\0"
+   "glSharpenTexFuncSGIS\0"
+   "\0"
+   /* _mesa_function_pool[22173]: MultiTexCoord4fvARB (offset 403) */
+   "ip\0"
+   "glMultiTexCoord4fv\0"
+   "glMultiTexCoord4fvARB\0"
+   "\0"
+   /* _mesa_function_pool[22218]: Uniform2uiEXT (will be remapped) */
+   "iii\0"
+   "glUniform2uiEXT\0"
+   "glUniform2ui\0"
+   "\0"
+   /* _mesa_function_pool[22252]: UniformMatrix2x3fv (will be remapped) */
+   "iiip\0"
+   "glUniformMatrix2x3fv\0"
+   "\0"
+   /* _mesa_function_pool[22279]: TrackMatrixNV (will be remapped) */
+   "iiii\0"
+   "glTrackMatrixNV\0"
+   "\0"
+   /* _mesa_function_pool[22301]: CombinerParameteriNV (will be remapped) */
+   "ii\0"
+   "glCombinerParameteriNV\0"
+   "\0"
+   /* _mesa_function_pool[22328]: DeleteAsyncMarkersSGIX (dynamic) */
+   "ii\0"
+   "glDeleteAsyncMarkersSGIX\0"
+   "\0"
+   /* _mesa_function_pool[22357]: ReplacementCodeusSUN (dynamic) */
+   "i\0"
+   "glReplacementCodeusSUN\0"
+   "\0"
+   /* _mesa_function_pool[22383]: IsAsyncMarkerSGIX (dynamic) */
+   "i\0"
+   "glIsAsyncMarkerSGIX\0"
+   "\0"
+   /* _mesa_function_pool[22406]: FrameZoomSGIX (dynamic) */
+   "i\0"
+   "glFrameZoomSGIX\0"
+   "\0"
+   /* _mesa_function_pool[22425]: Normal3fVertex3fvSUN (dynamic) */
+   "pp\0"
+   "glNormal3fVertex3fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[22452]: RasterPos4sv (offset 85) */
+   "p\0"
+   "glRasterPos4sv\0"
+   "\0"
+   /* _mesa_function_pool[22470]: VertexAttrib4NsvARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib4Nsv\0"
+   "glVertexAttrib4NsvARB\0"
+   "\0"
+   /* _mesa_function_pool[22515]: VertexAttrib3fvARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib3fv\0"
+   "glVertexAttrib3fvARB\0"
+   "\0"
+   /* _mesa_function_pool[22558]: ClearColor (offset 206) */
+   "ffff\0"
+   "glClearColor\0"
+   "\0"
+   /* _mesa_function_pool[22577]: GetSynciv (will be remapped) */
+   "iiipp\0"
+   "glGetSynciv\0"
+   "\0"
+   /* _mesa_function_pool[22596]: ClearColorIiEXT (will be remapped) */
+   "iiii\0"
+   "glClearColorIiEXT\0"
+   "\0"
+   /* _mesa_function_pool[22620]: DeleteFramebuffersEXT (will be remapped) */
+   "ip\0"
+   "glDeleteFramebuffers\0"
+   "glDeleteFramebuffersEXT\0"
+   "\0"
+   /* _mesa_function_pool[22669]: GlobalAlphaFactorsSUN (dynamic) */
+   "i\0"
+   "glGlobalAlphaFactorsSUN\0"
+   "\0"
+   /* _mesa_function_pool[22696]: IsEnabledIndexedEXT (will be remapped) */
+   "ii\0"
+   "glIsEnabledIndexedEXT\0"
+   "glIsEnabledi\0"
+   "\0"
+   /* _mesa_function_pool[22735]: TexEnviv (offset 187) */
+   "iip\0"
+   "glTexEnviv\0"
+   "\0"
+   /* _mesa_function_pool[22751]: TexSubImage3D (offset 372) */
+   "iiiiiiiiiip\0"
+   "glTexSubImage3D\0"
+   "glTexSubImage3DEXT\0"
+   "\0"
+   /* _mesa_function_pool[22799]: Tangent3fEXT (dynamic) */
+   "fff\0"
+   "glTangent3fEXT\0"
+   "\0"
+   /* _mesa_function_pool[22819]: SecondaryColor3uivEXT (will be remapped) */
+   "p\0"
+   "glSecondaryColor3uiv\0"
+   "glSecondaryColor3uivEXT\0"
+   "\0"
+   /* _mesa_function_pool[22867]: MatrixIndexubvARB (dynamic) */
+   "ip\0"
+   "glMatrixIndexubvARB\0"
+   "\0"
+   /* _mesa_function_pool[22891]: Color4fNormal3fVertex3fSUN (dynamic) */
+   "ffffffffff\0"
+   "glColor4fNormal3fVertex3fSUN\0"
+   "\0"
+   /* _mesa_function_pool[22932]: PixelTexGenParameterfSGIS (will be remapped) */
+   "if\0"
+   "glPixelTexGenParameterfSGIS\0"
+   "\0"
+   /* _mesa_function_pool[22964]: CreateShader (will be remapped) */
+   "i\0"
+   "glCreateShader\0"
+   "\0"
+   /* _mesa_function_pool[22982]: GetColorTableParameterfv (offset 344) */
+   "iip\0"
+   "glGetColorTableParameterfv\0"
+   "glGetColorTableParameterfvSGI\0"
+   "glGetColorTableParameterfvEXT\0"
+   "\0"
+   /* _mesa_function_pool[23074]: FragmentLightModelfvSGIX (dynamic) */
+   "ip\0"
+   "glFragmentLightModelfvSGIX\0"
+   "\0"
+   /* _mesa_function_pool[23105]: Bitmap (offset 8) */
+   "iiffffp\0"
+   "glBitmap\0"
+   "\0"
+   /* _mesa_function_pool[23123]: MultiTexCoord3fARB (offset 394) */
+   "ifff\0"
+   "glMultiTexCoord3f\0"
+   "glMultiTexCoord3fARB\0"
+   "\0"
+   /* _mesa_function_pool[23168]: GetTexLevelParameterfv (offset 284) */
+   "iiip\0"
+   "glGetTexLevelParameterfv\0"
+   "\0"
+   /* _mesa_function_pool[23199]: GetPixelTexGenParameterfvSGIS (will be remapped) */
+   "ip\0"
+   "glGetPixelTexGenParameterfvSGIS\0"
+   "\0"
+   /* _mesa_function_pool[23235]: GenFramebuffersEXT (will be remapped) */
+   "ip\0"
+   "glGenFramebuffers\0"
+   "glGenFramebuffersEXT\0"
+   "\0"
+   /* _mesa_function_pool[23278]: VertexAttribDivisor (will be remapped) */
+   "ii\0"
+   "glVertexAttribDivisor\0"
+   "\0"
+   /* _mesa_function_pool[23304]: GetProgramParameterdvNV (will be remapped) */
+   "iiip\0"
+   "glGetProgramParameterdvNV\0"
+   "\0"
+   /* _mesa_function_pool[23336]: Vertex2sv (offset 133) */
+   "p\0"
+   "glVertex2sv\0"
+   "\0"
+   /* _mesa_function_pool[23351]: GetIntegerv (offset 263) */
+   "ip\0"
+   "glGetIntegerv\0"
+   "\0"
+   /* _mesa_function_pool[23369]: IsVertexArrayAPPLE (will be remapped) */
+   "i\0"
+   "glIsVertexArray\0"
+   "glIsVertexArrayAPPLE\0"
+   "\0"
+   /* _mesa_function_pool[23409]: FragmentLightfvSGIX (dynamic) */
+   "iip\0"
+   "glFragmentLightfvSGIX\0"
+   "\0"
+   /* _mesa_function_pool[23436]: VertexAttribDivisorARB (will be remapped) */
+   "ii\0"
+   "glVertexAttribDivisorARB\0"
+   "\0"
+   /* _mesa_function_pool[23465]: DetachShader (will be remapped) */
+   "ii\0"
+   "glDetachShader\0"
+   "\0"
+   /* _mesa_function_pool[23484]: VertexAttrib4NubARB (will be remapped) */
+   "iiiii\0"
+   "glVertexAttrib4Nub\0"
+   "glVertexAttrib4NubARB\0"
+   "\0"
+   /* _mesa_function_pool[23532]: GetProgramEnvParameterfvARB (will be remapped) */
+   "iip\0"
+   "glGetProgramEnvParameterfvARB\0"
+   "\0"
+   /* _mesa_function_pool[23567]: GetTrackMatrixivNV (will be remapped) */
+   "iiip\0"
+   "glGetTrackMatrixivNV\0"
+   "\0"
+   /* _mesa_function_pool[23594]: VertexAttrib3svNV (will be remapped) */
+   "ip\0"
+   "glVertexAttrib3svNV\0"
+   "\0"
+   /* _mesa_function_pool[23618]: Uniform4fvARB (will be remapped) */
+   "iip\0"
+   "glUniform4fv\0"
+   "glUniform4fvARB\0"
+   "\0"
+   /* _mesa_function_pool[23652]: MultTransposeMatrixfARB (will be remapped) */
+   "p\0"
+   "glMultTransposeMatrixf\0"
+   "glMultTransposeMatrixfARB\0"
+   "\0"
+   /* _mesa_function_pool[23704]: GetTexEnviv (offset 277) */
+   "iip\0"
+   "glGetTexEnviv\0"
+   "\0"
+   /* _mesa_function_pool[23723]: ColorFragmentOp1ATI (will be remapped) */
+   "iiiiiii\0"
+   "glColorFragmentOp1ATI\0"
+   "\0"
+   /* _mesa_function_pool[23754]: GetUniformfvARB (will be remapped) */
+   "iip\0"
+   "glGetUniformfv\0"
+   "glGetUniformfvARB\0"
+   "\0"
+   /* _mesa_function_pool[23792]: EGLImageTargetRenderbufferStorageOES (will be remapped) */
+   "ip\0"
+   "glEGLImageTargetRenderbufferStorageOES\0"
+   "\0"
+   /* _mesa_function_pool[23835]: VertexAttribI2ivEXT (will be remapped) */
+   "ip\0"
+   "glVertexAttribI2ivEXT\0"
+   "glVertexAttribI2iv\0"
+   "\0"
+   /* _mesa_function_pool[23880]: PopClientAttrib (offset 334) */
+   "\0"
+   "glPopClientAttrib\0"
+   "\0"
+   /* _mesa_function_pool[23900]: ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN (dynamic) */
+   "iffffffffffff\0"
+   "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN\0"
+   "\0"
+   /* _mesa_function_pool[23971]: DetachObjectARB (will be remapped) */
+   "ii\0"
+   "glDetachObjectARB\0"
+   "\0"
+   /* _mesa_function_pool[23993]: VertexBlendARB (dynamic) */
+   "i\0"
+   "glVertexBlendARB\0"
+   "\0"
+   /* _mesa_function_pool[24013]: WindowPos3iMESA (will be remapped) */
+   "iii\0"
+   "glWindowPos3i\0"
+   "glWindowPos3iARB\0"
+   "glWindowPos3iMESA\0"
+   "\0"
+   /* _mesa_function_pool[24067]: SeparableFilter2D (offset 360) */
+   "iiiiiipp\0"
+   "glSeparableFilter2D\0"
+   "glSeparableFilter2DEXT\0"
+   "\0"
+   /* _mesa_function_pool[24120]: ProgramParameteriARB (will be remapped) */
+   "iii\0"
+   "glProgramParameteriARB\0"
+   "\0"
+   /* _mesa_function_pool[24148]: Map1d (offset 220) */
+   "iddiip\0"
+   "glMap1d\0"
+   "\0"
+   /* _mesa_function_pool[24164]: Map1f (offset 221) */
+   "iffiip\0"
+   "glMap1f\0"
+   "\0"
+   /* _mesa_function_pool[24180]: CompressedTexImage2DARB (will be remapped) */
+   "iiiiiiip\0"
+   "glCompressedTexImage2D\0"
+   "glCompressedTexImage2DARB\0"
+   "\0"
+   /* _mesa_function_pool[24239]: ArrayElement (offset 306) */
+   "i\0"
+   "glArrayElement\0"
+   "glArrayElementEXT\0"
+   "\0"
+   /* _mesa_function_pool[24275]: TexImage2D (offset 183) */
+   "iiiiiiiip\0"
+   "glTexImage2D\0"
+   "\0"
+   /* _mesa_function_pool[24299]: DepthBoundsEXT (will be remapped) */
+   "dd\0"
+   "glDepthBoundsEXT\0"
+   "\0"
+   /* _mesa_function_pool[24320]: ProgramParameters4fvNV (will be remapped) */
+   "iiip\0"
+   "glProgramParameters4fvNV\0"
+   "\0"
+   /* _mesa_function_pool[24351]: DeformationMap3fSGIX (dynamic) */
+   "iffiiffiiffiip\0"
+   "glDeformationMap3fSGIX\0"
+   "\0"
+   /* _mesa_function_pool[24390]: GetProgramivNV (will be remapped) */
+   "iip\0"
+   "glGetProgramivNV\0"
+   "\0"
+   /* _mesa_function_pool[24412]: GetFragDataLocationEXT (will be remapped) */
+   "ip\0"
+   "glGetFragDataLocationEXT\0"
+   "glGetFragDataLocation\0"
+   "\0"
+   /* _mesa_function_pool[24463]: GetMinmaxParameteriv (offset 366) */
+   "iip\0"
+   "glGetMinmaxParameteriv\0"
+   "glGetMinmaxParameterivEXT\0"
+   "\0"
+   /* _mesa_function_pool[24517]: PixelTransferf (offset 247) */
+   "if\0"
+   "glPixelTransferf\0"
+   "\0"
+   /* _mesa_function_pool[24538]: CopyTexImage1D (offset 323) */
+   "iiiiiii\0"
+   "glCopyTexImage1D\0"
+   "glCopyTexImage1DEXT\0"
+   "\0"
+   /* _mesa_function_pool[24584]: PushMatrix (offset 298) */
+   "\0"
+   "glPushMatrix\0"
+   "\0"
+   /* _mesa_function_pool[24599]: Fogiv (offset 156) */
+   "ip\0"
+   "glFogiv\0"
+   "\0"
+   /* _mesa_function_pool[24611]: TexCoord1dv (offset 95) */
+   "p\0"
+   "glTexCoord1dv\0"
+   "\0"
+   /* _mesa_function_pool[24628]: AlphaFragmentOp3ATI (will be remapped) */
+   "iiiiiiiiiiii\0"
+   "glAlphaFragmentOp3ATI\0"
+   "\0"
+   /* _mesa_function_pool[24664]: PixelTransferi (offset 248) */
+   "ii\0"
+   "glPixelTransferi\0"
+   "\0"
+   /* _mesa_function_pool[24685]: GetVertexAttribdvNV (will be remapped) */
+   "iip\0"
+   "glGetVertexAttribdvNV\0"
+   "\0"
+   /* _mesa_function_pool[24712]: VertexAttrib3fvNV (will be remapped) */
+   "ip\0"
+   "glVertexAttrib3fvNV\0"
+   "\0"
+   /* _mesa_function_pool[24736]: Rotatef (offset 300) */
+   "ffff\0"
+   "glRotatef\0"
+   "\0"
+   /* _mesa_function_pool[24752]: GetFinalCombinerInputParameterivNV (will be remapped) */
+   "iip\0"
+   "glGetFinalCombinerInputParameterivNV\0"
+   "\0"
+   /* _mesa_function_pool[24794]: Vertex3i (offset 138) */
+   "iii\0"
+   "glVertex3i\0"
+   "\0"
+   /* _mesa_function_pool[24810]: Vertex3f (offset 136) */
+   "fff\0"
+   "glVertex3f\0"
+   "\0"
+   /* _mesa_function_pool[24826]: Clear (offset 203) */
+   "i\0"
+   "glClear\0"
+   "\0"
+   /* _mesa_function_pool[24837]: Vertex3d (offset 134) */
+   "ddd\0"
+   "glVertex3d\0"
+   "\0"
+   /* _mesa_function_pool[24853]: GetMapParameterivNV (dynamic) */
+   "iip\0"
+   "glGetMapParameterivNV\0"
+   "\0"
+   /* _mesa_function_pool[24880]: Uniform4iARB (will be remapped) */
+   "iiiii\0"
+   "glUniform4i\0"
+   "glUniform4iARB\0"
+   "\0"
+   /* _mesa_function_pool[24914]: ReadBuffer (offset 254) */
+   "i\0"
+   "glReadBuffer\0"
+   "\0"
+   /* _mesa_function_pool[24930]: ConvolutionParameteri (offset 352) */
+   "iii\0"
+   "glConvolutionParameteri\0"
+   "glConvolutionParameteriEXT\0"
+   "\0"
+   /* _mesa_function_pool[24986]: Ortho (offset 296) */
+   "dddddd\0"
+   "glOrtho\0"
+   "\0"
+   /* _mesa_function_pool[25002]: Binormal3sEXT (dynamic) */
+   "iii\0"
+   "glBinormal3sEXT\0"
+   "\0"
+   /* _mesa_function_pool[25023]: ListBase (offset 6) */
+   "i\0"
+   "glListBase\0"
+   "\0"
+   /* _mesa_function_pool[25037]: Vertex3s (offset 140) */
+   "iii\0"
+   "glVertex3s\0"
+   "\0"
+   /* _mesa_function_pool[25053]: ConvolutionParameterf (offset 350) */
+   "iif\0"
+   "glConvolutionParameterf\0"
+   "glConvolutionParameterfEXT\0"
+   "\0"
+   /* _mesa_function_pool[25109]: GetColorTableParameteriv (offset 345) */
+   "iip\0"
+   "glGetColorTableParameteriv\0"
+   "glGetColorTableParameterivSGI\0"
+   "glGetColorTableParameterivEXT\0"
+   "\0"
+   /* _mesa_function_pool[25201]: ProgramEnvParameter4dvARB (will be remapped) */
+   "iip\0"
+   "glProgramEnvParameter4dvARB\0"
+   "glProgramParameter4dvNV\0"
+   "\0"
+   /* _mesa_function_pool[25258]: ShadeModel (offset 177) */
+   "i\0"
+   "glShadeModel\0"
+   "\0"
+   /* _mesa_function_pool[25274]: VertexAttribs2fvNV (will be remapped) */
+   "iip\0"
+   "glVertexAttribs2fvNV\0"
+   "\0"
+   /* _mesa_function_pool[25300]: Rectiv (offset 91) */
+   "pp\0"
+   "glRectiv\0"
+   "\0"
+   /* _mesa_function_pool[25313]: UseProgramObjectARB (will be remapped) */
+   "i\0"
+   "glUseProgram\0"
+   "glUseProgramObjectARB\0"
+   "\0"
+   /* _mesa_function_pool[25351]: GetMapParameterfvNV (dynamic) */
+   "iip\0"
+   "glGetMapParameterfvNV\0"
+   "\0"
+   /* _mesa_function_pool[25378]: EndConditionalRenderNV (will be remapped) */
+   "\0"
+   "glEndConditionalRenderNV\0"
+   "glEndConditionalRender\0"
+   "\0"
+   /* _mesa_function_pool[25428]: PassTexCoordATI (will be remapped) */
+   "iii\0"
+   "glPassTexCoordATI\0"
+   "\0"
+   /* _mesa_function_pool[25451]: DeleteProgram (will be remapped) */
+   "i\0"
+   "glDeleteProgram\0"
+   "\0"
+   /* _mesa_function_pool[25470]: Tangent3ivEXT (dynamic) */
+   "p\0"
+   "glTangent3ivEXT\0"
+   "\0"
+   /* _mesa_function_pool[25489]: Tangent3dEXT (dynamic) */
+   "ddd\0"
+   "glTangent3dEXT\0"
+   "\0"
+   /* _mesa_function_pool[25509]: SecondaryColor3dvEXT (will be remapped) */
+   "p\0"
+   "glSecondaryColor3dv\0"
+   "glSecondaryColor3dvEXT\0"
+   "\0"
+   /* _mesa_function_pool[25555]: AlphaFragmentOp2ATI (will be remapped) */
+   "iiiiiiiii\0"
+   "glAlphaFragmentOp2ATI\0"
+   "\0"
+   /* _mesa_function_pool[25588]: Vertex2fv (offset 129) */
+   "p\0"
+   "glVertex2fv\0"
+   "\0"
+   /* _mesa_function_pool[25603]: MultiDrawArraysEXT (will be remapped) */
+   "ippi\0"
+   "glMultiDrawArrays\0"
+   "glMultiDrawArraysEXT\0"
+   "\0"
+   /* _mesa_function_pool[25648]: BindRenderbufferEXT (will be remapped) */
+   "ii\0"
+   "glBindRenderbuffer\0"
+   "glBindRenderbufferEXT\0"
+   "\0"
+   /* _mesa_function_pool[25693]: MultiTexCoord4dARB (offset 400) */
+   "idddd\0"
+   "glMultiTexCoord4d\0"
+   "glMultiTexCoord4dARB\0"
+   "\0"
+   /* _mesa_function_pool[25739]: FramebufferTextureFaceARB (will be remapped) */
+   "iiiii\0"
+   "glFramebufferTextureFaceARB\0"
+   "\0"
+   /* _mesa_function_pool[25774]: Vertex3sv (offset 141) */
+   "p\0"
+   "glVertex3sv\0"
+   "\0"
+   /* _mesa_function_pool[25789]: SecondaryColor3usEXT (will be remapped) */
+   "iii\0"
+   "glSecondaryColor3us\0"
+   "glSecondaryColor3usEXT\0"
+   "\0"
+   /* _mesa_function_pool[25837]: ProgramLocalParameter4fvARB (will be remapped) */
+   "iip\0"
+   "glProgramLocalParameter4fvARB\0"
+   "\0"
+   /* _mesa_function_pool[25872]: DeleteProgramsNV (will be remapped) */
+   "ip\0"
+   "glDeleteProgramsARB\0"
+   "glDeleteProgramsNV\0"
+   "\0"
+   /* _mesa_function_pool[25915]: EvalMesh1 (offset 236) */
+   "iii\0"
+   "glEvalMesh1\0"
+   "\0"
+   /* _mesa_function_pool[25932]: PauseTransformFeedback (will be remapped) */
+   "\0"
+   "glPauseTransformFeedback\0"
+   "\0"
+   /* _mesa_function_pool[25959]: MultiTexCoord1sARB (offset 382) */
+   "ii\0"
+   "glMultiTexCoord1s\0"
+   "glMultiTexCoord1sARB\0"
+   "\0"
+   /* _mesa_function_pool[26002]: ReplacementCodeuiColor3fVertex3fSUN (dynamic) */
+   "iffffff\0"
+   "glReplacementCodeuiColor3fVertex3fSUN\0"
+   "\0"
+   /* _mesa_function_pool[26049]: GetVertexAttribPointervNV (will be remapped) */
+   "iip\0"
+   "glGetVertexAttribPointerv\0"
+   "glGetVertexAttribPointervARB\0"
+   "glGetVertexAttribPointervNV\0"
+   "\0"
+   /* _mesa_function_pool[26137]: VertexAttribs1fvNV (will be remapped) */
+   "iip\0"
+   "glVertexAttribs1fvNV\0"
+   "\0"
+   /* _mesa_function_pool[26163]: MultiTexCoord1dvARB (offset 377) */
+   "ip\0"
+   "glMultiTexCoord1dv\0"
+   "glMultiTexCoord1dvARB\0"
+   "\0"
+   /* _mesa_function_pool[26208]: Uniform2iARB (will be remapped) */
+   "iii\0"
+   "glUniform2i\0"
+   "glUniform2iARB\0"
+   "\0"
+   /* _mesa_function_pool[26240]: Vertex2iv (offset 131) */
+   "p\0"
+   "glVertex2iv\0"
+   "\0"
+   /* _mesa_function_pool[26255]: GetProgramStringNV (will be remapped) */
+   "iip\0"
+   "glGetProgramStringNV\0"
+   "\0"
+   /* _mesa_function_pool[26281]: ColorPointerEXT (will be remapped) */
+   "iiiip\0"
+   "glColorPointerEXT\0"
+   "\0"
+   /* _mesa_function_pool[26306]: LineWidth (offset 168) */
+   "f\0"
+   "glLineWidth\0"
+   "\0"
+   /* _mesa_function_pool[26321]: MapBufferARB (will be remapped) */
+   "ii\0"
+   "glMapBuffer\0"
+   "glMapBufferARB\0"
+   "\0"
+   /* _mesa_function_pool[26352]: MultiDrawElementsBaseVertex (will be remapped) */
+   "ipipip\0"
+   "glMultiDrawElementsBaseVertex\0"
+   "\0"
+   /* _mesa_function_pool[26390]: TexParameterIuivEXT (will be remapped) */
+   "iip\0"
+   "glTexParameterIuivEXT\0"
+   "glTexParameterIuiv\0"
+   "\0"
+   /* _mesa_function_pool[26436]: Binormal3svEXT (dynamic) */
+   "p\0"
+   "glBinormal3svEXT\0"
+   "\0"
+   /* _mesa_function_pool[26456]: ApplyTextureEXT (dynamic) */
+   "i\0"
+   "glApplyTextureEXT\0"
+   "\0"
+   /* _mesa_function_pool[26477]: GetBufferParameteri64v (will be remapped) */
+   "iip\0"
+   "glGetBufferParameteri64v\0"
+   "\0"
+   /* _mesa_function_pool[26507]: TexGendv (offset 189) */
+   "iip\0"
+   "glTexGendv\0"
+   "\0"
+   /* _mesa_function_pool[26523]: VertexAttribI3iEXT (will be remapped) */
+   "iiii\0"
+   "glVertexAttribI3iEXT\0"
+   "glVertexAttribI3i\0"
+   "\0"
+   /* _mesa_function_pool[26568]: EnableIndexedEXT (will be remapped) */
+   "ii\0"
+   "glEnableIndexedEXT\0"
+   "glEnablei\0"
+   "\0"
+   /* _mesa_function_pool[26601]: TextureMaterialEXT (dynamic) */
+   "ii\0"
+   "glTextureMaterialEXT\0"
+   "\0"
+   /* _mesa_function_pool[26626]: TextureLightEXT (dynamic) */
+   "i\0"
+   "glTextureLightEXT\0"
+   "\0"
+   /* _mesa_function_pool[26647]: ResetMinmax (offset 370) */
+   "i\0"
+   "glResetMinmax\0"
+   "glResetMinmaxEXT\0"
+   "\0"
+   /* _mesa_function_pool[26681]: SpriteParameterfSGIX (dynamic) */
+   "if\0"
+   "glSpriteParameterfSGIX\0"
+   "\0"
+   /* _mesa_function_pool[26708]: EnableClientState (offset 313) */
+   "i\0"
+   "glEnableClientState\0"
+   "\0"
+   /* _mesa_function_pool[26731]: VertexAttrib4sNV (will be remapped) */
+   "iiiii\0"
+   "glVertexAttrib4sNV\0"
+   "\0"
+   /* _mesa_function_pool[26757]: GetConvolutionParameterfv (offset 357) */
+   "iip\0"
+   "glGetConvolutionParameterfv\0"
+   "glGetConvolutionParameterfvEXT\0"
+   "\0"
+   /* _mesa_function_pool[26821]: VertexAttribs4dvNV (will be remapped) */
+   "iip\0"
+   "glVertexAttribs4dvNV\0"
+   "\0"
+   /* _mesa_function_pool[26847]: MultiModeDrawArraysIBM (will be remapped) */
+   "pppii\0"
+   "glMultiModeDrawArraysIBM\0"
+   "\0"
+   /* _mesa_function_pool[26879]: VertexAttrib4dARB (will be remapped) */
+   "idddd\0"
+   "glVertexAttrib4d\0"
+   "glVertexAttrib4dARB\0"
+   "\0"
+   /* _mesa_function_pool[26923]: GetTexBumpParameterfvATI (will be remapped) */
+   "ip\0"
+   "glGetTexBumpParameterfvATI\0"
+   "\0"
+   /* _mesa_function_pool[26954]: ProgramNamedParameter4dNV (will be remapped) */
+   "iipdddd\0"
+   "glProgramNamedParameter4dNV\0"
+   "\0"
+   /* _mesa_function_pool[26991]: GetMaterialfv (offset 269) */
+   "iip\0"
+   "glGetMaterialfv\0"
+   "\0"
+   /* _mesa_function_pool[27012]: VertexWeightfEXT (dynamic) */
+   "f\0"
+   "glVertexWeightfEXT\0"
+   "\0"
+   /* _mesa_function_pool[27034]: SetFragmentShaderConstantATI (will be remapped) */
+   "ip\0"
+   "glSetFragmentShaderConstantATI\0"
+   "\0"
+   /* _mesa_function_pool[27069]: Binormal3fEXT (dynamic) */
+   "fff\0"
+   "glBinormal3fEXT\0"
+   "\0"
+   /* _mesa_function_pool[27090]: CallList (offset 2) */
+   "i\0"
+   "glCallList\0"
+   "\0"
+   /* _mesa_function_pool[27104]: Materialfv (offset 170) */
+   "iip\0"
+   "glMaterialfv\0"
+   "\0"
+   /* _mesa_function_pool[27122]: TexCoord3fv (offset 113) */
+   "p\0"
+   "glTexCoord3fv\0"
+   "\0"
+   /* _mesa_function_pool[27139]: FogCoordfvEXT (will be remapped) */
+   "p\0"
+   "glFogCoordfv\0"
+   "glFogCoordfvEXT\0"
+   "\0"
+   /* _mesa_function_pool[27171]: MultiTexCoord1ivARB (offset 381) */
+   "ip\0"
+   "glMultiTexCoord1iv\0"
+   "glMultiTexCoord1ivARB\0"
+   "\0"
+   /* _mesa_function_pool[27216]: SecondaryColor3ubEXT (will be remapped) */
+   "iii\0"
+   "glSecondaryColor3ub\0"
+   "glSecondaryColor3ubEXT\0"
+   "\0"
+   /* _mesa_function_pool[27264]: MultiTexCoord2ivARB (offset 389) */
+   "ip\0"
+   "glMultiTexCoord2iv\0"
+   "glMultiTexCoord2ivARB\0"
+   "\0"
+   /* _mesa_function_pool[27309]: FogFuncSGIS (dynamic) */
+   "ip\0"
+   "glFogFuncSGIS\0"
+   "\0"
+   /* _mesa_function_pool[27327]: CopyTexSubImage2D (offset 326) */
+   "iiiiiiii\0"
+   "glCopyTexSubImage2D\0"
+   "glCopyTexSubImage2DEXT\0"
+   "\0"
+   /* _mesa_function_pool[27380]: GetObjectParameterivARB (will be remapped) */
+   "iip\0"
+   "glGetObjectParameterivARB\0"
+   "\0"
+   /* _mesa_function_pool[27411]: Color3iv (offset 16) */
+   "p\0"
+   "glColor3iv\0"
+   "\0"
+   /* _mesa_function_pool[27425]: TexCoord4fVertex4fSUN (dynamic) */
+   "ffffffff\0"
+   "glTexCoord4fVertex4fSUN\0"
+   "\0"
+   /* _mesa_function_pool[27459]: DrawElements (offset 311) */
+   "iiip\0"
+   "glDrawElements\0"
+   "\0"
+   /* _mesa_function_pool[27480]: BindVertexArrayAPPLE (will be remapped) */
+   "i\0"
+   "glBindVertexArrayAPPLE\0"
+   "\0"
+   /* _mesa_function_pool[27506]: GetProgramLocalParameterdvARB (will be remapped) */
+   "iip\0"
+   "glGetProgramLocalParameterdvARB\0"
+   "\0"
+   /* _mesa_function_pool[27543]: GetHistogramParameteriv (offset 363) */
+   "iip\0"
+   "glGetHistogramParameteriv\0"
+   "glGetHistogramParameterivEXT\0"
+   "\0"
+   /* _mesa_function_pool[27603]: MultiTexCoord1iARB (offset 380) */
+   "ii\0"
+   "glMultiTexCoord1i\0"
+   "glMultiTexCoord1iARB\0"
+   "\0"
+   /* _mesa_function_pool[27646]: GetConvolutionFilter (offset 356) */
+   "iiip\0"
+   "glGetConvolutionFilter\0"
+   "glGetConvolutionFilterEXT\0"
+   "\0"
+   /* _mesa_function_pool[27701]: GetProgramivARB (will be remapped) */
+   "iip\0"
+   "glGetProgramivARB\0"
+   "\0"
+   /* _mesa_function_pool[27724]: BlendFuncSeparateEXT (will be remapped) */
+   "iiii\0"
+   "glBlendFuncSeparate\0"
+   "glBlendFuncSeparateEXT\0"
+   "glBlendFuncSeparateINGR\0"
+   "\0"
+   /* _mesa_function_pool[27797]: MapBufferRange (will be remapped) */
+   "iiii\0"
+   "glMapBufferRange\0"
+   "\0"
+   /* _mesa_function_pool[27820]: ProgramParameters4dvNV (will be remapped) */
+   "iiip\0"
+   "glProgramParameters4dvNV\0"
+   "\0"
+   /* _mesa_function_pool[27851]: TexCoord2fColor3fVertex3fvSUN (dynamic) */
+   "ppp\0"
+   "glTexCoord2fColor3fVertex3fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[27888]: EvalPoint2 (offset 239) */
+   "ii\0"
+   "glEvalPoint2\0"
+   "\0"
+   /* _mesa_function_pool[27905]: Uniform1uivEXT (will be remapped) */
+   "iip\0"
+   "glUniform1uivEXT\0"
+   "glUniform1uiv\0"
+   "\0"
+   /* _mesa_function_pool[27941]: EvalPoint1 (offset 237) */
+   "i\0"
+   "glEvalPoint1\0"
+   "\0"
+   /* _mesa_function_pool[27957]: Binormal3dvEXT (dynamic) */
+   "p\0"
+   "glBinormal3dvEXT\0"
+   "\0"
+   /* _mesa_function_pool[27977]: PopMatrix (offset 297) */
+   "\0"
+   "glPopMatrix\0"
+   "\0"
+   /* _mesa_function_pool[27991]: GetVertexAttribIuivEXT (will be remapped) */
+   "iip\0"
+   "glGetVertexAttribIuivEXT\0"
+   "glGetVertexAttribIuiv\0"
+   "\0"
+   /* _mesa_function_pool[28043]: FinishFenceNV (will be remapped) */
+   "i\0"
+   "glFinishFenceNV\0"
+   "\0"
+   /* _mesa_function_pool[28062]: GetFogFuncSGIS (dynamic) */
+   "p\0"
+   "glGetFogFuncSGIS\0"
+   "\0"
+   /* _mesa_function_pool[28082]: GetUniformLocationARB (will be remapped) */
+   "ip\0"
+   "glGetUniformLocation\0"
+   "glGetUniformLocationARB\0"
+   "\0"
+   /* _mesa_function_pool[28131]: SecondaryColor3fEXT (will be remapped) */
+   "fff\0"
+   "glSecondaryColor3f\0"
+   "glSecondaryColor3fEXT\0"
+   "\0"
+   /* _mesa_function_pool[28177]: GetTexGeniv (offset 280) */
+   "iip\0"
+   "glGetTexGeniv\0"
+   "\0"
+   /* _mesa_function_pool[28196]: CombinerInputNV (will be remapped) */
+   "iiiiii\0"
+   "glCombinerInputNV\0"
+   "\0"
+   /* _mesa_function_pool[28222]: VertexAttrib3sARB (will be remapped) */
+   "iiii\0"
+   "glVertexAttrib3s\0"
+   "glVertexAttrib3sARB\0"
+   "\0"
+   /* _mesa_function_pool[28265]: IsTransformFeedback (will be remapped) */
+   "i\0"
+   "glIsTransformFeedback\0"
+   "\0"
+   /* _mesa_function_pool[28290]: ReplacementCodeuiNormal3fVertex3fvSUN (dynamic) */
+   "ppp\0"
+   "glReplacementCodeuiNormal3fVertex3fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[28335]: Map2d (offset 222) */
+   "iddiiddiip\0"
+   "glMap2d\0"
+   "\0"
+   /* _mesa_function_pool[28355]: Map2f (offset 223) */
+   "iffiiffiip\0"
+   "glMap2f\0"
+   "\0"
+   /* _mesa_function_pool[28375]: ProgramStringARB (will be remapped) */
+   "iiip\0"
+   "glProgramStringARB\0"
+   "\0"
+   /* _mesa_function_pool[28400]: Vertex4s (offset 148) */
+   "iiii\0"
+   "glVertex4s\0"
+   "\0"
+   /* _mesa_function_pool[28417]: TexCoord4fVertex4fvSUN (dynamic) */
+   "pp\0"
+   "glTexCoord4fVertex4fvSUN\0"
+   "\0"
+   /* _mesa_function_pool[28446]: FragmentLightModelivSGIX (dynamic) */
+   "ip\0"
+   "glFragmentLightModelivSGIX\0"
+   "\0"
+   /* _mesa_function_pool[28477]: VertexAttrib1fNV (will be remapped) */
+   "if\0"
+   "glVertexAttrib1fNV\0"
+   "\0"
+   /* _mesa_function_pool[28500]: Vertex4f (offset 144) */
+   "ffff\0"
+   "glVertex4f\0"
+   "\0"
+   /* _mesa_function_pool[28517]: EvalCoord1d (offset 228) */
+   "d\0"
+   "glEvalCoord1d\0"
+   "\0"
+   /* _mesa_function_pool[28534]: Vertex4d (offset 142) */
+   "dddd\0"
+   "glVertex4d\0"
+   "\0"
+   /* _mesa_function_pool[28551]: RasterPos4dv (offset 79) */
+   "p\0"
+   "glRasterPos4dv\0"
+   "\0"
+   /* _mesa_function_pool[28569]: UseShaderProgramEXT (will be remapped) */
+   "ii\0"
+   "glUseShaderProgramEXT\0"
+   "\0"
+   /* _mesa_function_pool[28595]: FragmentLightfSGIX (dynamic) */
+   "iif\0"
+   "glFragmentLightfSGIX\0"
+   "\0"
+   /* _mesa_function_pool[28621]: GetCompressedTexImageARB (will be remapped) */
+   "iip\0"
+   "glGetCompressedTexImage\0"
+   "glGetCompressedTexImageARB\0"
+   "\0"
+   /* _mesa_function_pool[28677]: GetTexGenfv (offset 279) */
+   "iip\0"
+   "glGetTexGenfv\0"
+   "\0"
+   /* _mesa_function_pool[28696]: Vertex4i (offset 146) */
+   "iiii\0"
+   "glVertex4i\0"
+   "\0"
+   /* _mesa_function_pool[28713]: VertexWeightPointerEXT (dynamic) */
+   "iiip\0"
+   "glVertexWeightPointerEXT\0"
+   "\0"
+   /* _mesa_function_pool[28744]: GetHistogram (offset 361) */
+   "iiiip\0"
+   "glGetHistogram\0"
+   "glGetHistogramEXT\0"
+   "\0"
+   /* _mesa_function_pool[28784]: ActiveStencilFaceEXT (will be remapped) */
+   "i\0"
+   "glActiveStencilFaceEXT\0"
+   "\0"
+   /* _mesa_function_pool[28810]: StencilFuncSeparateATI (will be remapped) */
+   "iiii\0"
+   "glStencilFuncSeparateATI\0"
+   "\0"
+   /* _mesa_function_pool[28841]: Materialf (offset 169) */
+   "iif\0"
+   "glMaterialf\0"
+   "\0"
+   /* _mesa_function_pool[28858]: GetShaderSourceARB (will be remapped) */
+   "iipp\0"
+   "glGetShaderSource\0"
+   "glGetShaderSourceARB\0"
+   "\0"
+   /* _mesa_function_pool[28903]: IglooInterfaceSGIX (dynamic) */
+   "ip\0"
+   "glIglooInterfaceSGIX\0"
+   "\0"
+   /* _mesa_function_pool[28928]: Materiali (offset 171) */
+   "iii\0"
+   "glMateriali\0"
+   "\0"
+   /* _mesa_function_pool[28945]: VertexAttrib4dNV (will be remapped) */
+   "idddd\0"
+   "glVertexAttrib4dNV\0"
+   "\0"
+   /* _mesa_function_pool[28971]: MultiModeDrawElementsIBM (will be remapped) */
+   "ppipii\0"
+   "glMultiModeDrawElementsIBM\0"
+   "\0"
+   /* _mesa_function_pool[29006]: Indexsv (offset 51) */
+   "p\0"
+   "glIndexsv\0"
+   "\0"
+   /* _mesa_function_pool[29019]: MultiTexCoord4svARB (offset 407) */
+   "ip\0"
+   "glMultiTexCoord4sv\0"
+   "glMultiTexCoord4svARB\0"
+   "\0"
+   /* _mesa_function_pool[29064]: LightModelfv (offset 164) */
+   "ip\0"
+   "glLightModelfv\0"
+   "\0"
+   /* _mesa_function_pool[29083]: TexCoord2dv (offset 103) */
+   "p\0"
+   "glTexCoord2dv\0"
+   "\0"
+   /* _mesa_function_pool[29100]: GenQueriesARB (will be remapped) */
+   "ip\0"
+   "glGenQueries\0"
+   "glGenQueriesARB\0"
+   "\0"
+   /* _mesa_function_pool[29133]: EvalCoord1dv (offset 229) */
+   "p\0"
+   "glEvalCoord1dv\0"
+   "\0"
+   /* _mesa_function_pool[29151]: ReplacementCodeuiVertex3fSUN (dynamic) */
+   "ifff\0"
+   "glReplacementCodeuiVertex3fSUN\0"
+   "\0"
+   /* _mesa_function_pool[29188]: Translated (offset 303) */
+   "ddd\0"
+   "glTranslated\0"
+   "\0"
+   /* _mesa_function_pool[29206]: Translatef (offset 304) */
+   "fff\0"
+   "glTranslatef\0"
+   "\0"
+   /* _mesa_function_pool[29224]: Uniform3uiEXT (will be remapped) */
+   "iiii\0"
+   "glUniform3uiEXT\0"
+   "glUniform3ui\0"
+   "\0"
+   /* _mesa_function_pool[29259]: StencilMask (offset 209) */
+   "i\0"
+   "glStencilMask\0"
+   "\0"
+   /* _mesa_function_pool[29276]: Tangent3iEXT (dynamic) */
+   "iii\0"
+   "glTangent3iEXT\0"
+   "\0"
+   /* _mesa_function_pool[29296]: ClampColorARB (will be remapped) */
+   "ii\0"
+   "glClampColorARB\0"
+   "\0"
+   /* _mesa_function_pool[29316]: GetLightiv (offset 265) */
+   "iip\0"
+   "glGetLightiv\0"
+   "\0"
+   /* _mesa_function_pool[29334]: DrawMeshArraysSUN (dynamic) */
+   "iiii\0"
+   "glDrawMeshArraysSUN\0"
+   "\0"
+   /* _mesa_function_pool[29360]: IsList (offset 287) */
+   "i\0"
+   "glIsList\0"
+   "\0"
+   /* _mesa_function_pool[29372]: IsSync (will be remapped) */
+   "i\0"
+   "glIsSync\0"
+   "\0"
+   /* _mesa_function_pool[29384]: RenderMode (offset 196) */
+   "i\0"
+   "glRenderMode\0"
+   "\0"
+   /* _mesa_function_pool[29400]: GetMapControlPointsNV (dynamic) */
+   "iiiiiip\0"
+   "glGetMapControlPointsNV\0"
+   "\0"
+   /* _mesa_function_pool[29433]: DrawBuffersARB (will be remapped) */
+   "ip\0"
+   "glDrawBuffers\0"
+   "glDrawBuffersARB\0"
+   "glDrawBuffersATI\0"
+   "\0"
+   /* _mesa_function_pool[29485]: ClearBufferiv (will be remapped) */
+   "iip\0"
+   "glClearBufferiv\0"
+   "\0"
+   /* _mesa_function_pool[29506]: ProgramLocalParameter4fARB (will be remapped) */
+   "iiffff\0"
+   "glProgramLocalParameter4fARB\0"
+   "\0"
+   /* _mesa_function_pool[29543]: SpriteParameterivSGIX (dynamic) */
+   "ip\0"
+   "glSpriteParameterivSGIX\0"
+   "\0"
+   /* _mesa_function_pool[29571]: ProvokingVertexEXT (will be remapped) */
+   "i\0"
+   "glProvokingVertexEXT\0"
+   "glProvokingVertex\0"
+   "\0"
+   /* _mesa_function_pool[29613]: MultiTexCoord1fARB (offset 378) */
+   "if\0"
+   "glMultiTexCoord1f\0"
+   "glMultiTexCoord1fARB\0"
+   "\0"
+   /* _mesa_function_pool[29656]: LoadName (offset 198) */
+   "i\0"
+   "glLoadName\0"
+   "\0"
+   /* _mesa_function_pool[29670]: VertexAttribs4ubvNV (will be remapped) */
+   "iip\0"
+   "glVertexAttribs4ubvNV\0"
+   "\0"
+   /* _mesa_function_pool[29697]: WeightsvARB (dynamic) */
+   "ip\0"
+   "glWeightsvARB\0"
+   "\0"
+   /* _mesa_function_pool[29715]: Uniform1fvARB (will be remapped) */
+   "iip\0"
+   "glUniform1fv\0"
+   "glUniform1fvARB\0"
+   "\0"
+   /* _mesa_function_pool[29749]: CopyTexSubImage1D (offset 325) */
+   "iiiiii\0"
+   "glCopyTexSubImage1D\0"
+   "glCopyTexSubImage1DEXT\0"
+   "\0"
+   /* _mesa_function_pool[29800]: CullFace (offset 152) */
+   "i\0"
+   "glCullFace\0"
+   "\0"
+   /* _mesa_function_pool[29814]: BindTexture (offset 307) */
+   "ii\0"
+   "glBindTexture\0"
+   "glBindTextureEXT\0"
+   "\0"
+   /* _mesa_function_pool[29849]: BeginFragmentShaderATI (will be remapped) */
+   "\0"
+   "glBeginFragmentShaderATI\0"
+   "\0"
+   /* _mesa_function_pool[29876]: MultiTexCoord4fARB (offset 402) */
+   "iffff\0"
+   "glMultiTexCoord4f\0"
+   "glMultiTexCoord4fARB\0"
+   "\0"
+   /* _mesa_function_pool[29922]: VertexAttribs3svNV (will be remapped) */
+   "iip\0"
+   "glVertexAttribs3svNV\0"
+   "\0"
+   /* _mesa_function_pool[29948]: StencilFunc (offset 243) */
+   "iii\0"
+   "glStencilFunc\0"
+   "\0"
+   /* _mesa_function_pool[29967]: CopyPixels (offset 255) */
+   "iiiii\0"
+   "glCopyPixels\0"
+   "\0"
+   /* _mesa_function_pool[29987]: Rectsv (offset 93) */
+   "pp\0"
+   "glRectsv\0"
+   "\0"
+   /* _mesa_function_pool[30000]: ReplacementCodeuivSUN (dynamic) */
+   "p\0"
+   "glReplacementCodeuivSUN\0"
+   "\0"
+   /* _mesa_function_pool[30027]: EnableVertexAttribArrayARB (will be remapped) */
+   "i\0"
+   "glEnableVertexAttribArray\0"
+   "glEnableVertexAttribArrayARB\0"
+   "\0"
+   /* _mesa_function_pool[30085]: NormalPointervINTEL (dynamic) */
+   "ip\0"
+   "glNormalPointervINTEL\0"
+   "\0"
+   /* _mesa_function_pool[30111]: CopyConvolutionFilter2D (offset 355) */
+   "iiiiii\0"
+   "glCopyConvolutionFilter2D\0"
+   "glCopyConvolutionFilter2DEXT\0"
+   "\0"
+   /* _mesa_function_pool[30174]: WindowPos3ivMESA (will be remapped) */
+   "p\0"
+   "glWindowPos3iv\0"
+   "glWindowPos3ivARB\0"
+   "glWindowPos3ivMESA\0"
+   "\0"
+   /* _mesa_function_pool[30229]: CopyBufferSubData (will be remapped) */
+   "iiiii\0"
+   "glCopyBufferSubData\0"
+   "\0"
+   /* _mesa_function_pool[30256]: NormalPointer (offset 318) */
+   "iip\0"
+   "glNormalPointer\0"
+   "\0"
+   /* _mesa_function_pool[30277]: TexParameterfv (offset 179) */
+   "iip\0"
+   "glTexParameterfv\0"
+   "\0"
+   /* _mesa_function_pool[30299]: IsBufferARB (will be remapped) */
+   "i\0"
+   "glIsBuffer\0"
+   "glIsBufferARB\0"
+   "\0"
+   /* _mesa_function_pool[30327]: WindowPos4iMESA (will be remapped) */
+   "iiii\0"
+   "glWindowPos4iMESA\0"
+   "\0"
+   /* _mesa_function_pool[30351]: VertexAttrib4uivARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib4uiv\0"
+   "glVertexAttrib4uivARB\0"
+   "\0"
+   /* _mesa_function_pool[30396]: Tangent3bvEXT (dynamic) */
+   "p\0"
+   "glTangent3bvEXT\0"
+   "\0"
+   /* _mesa_function_pool[30415]: VertexAttribI3uivEXT (will be remapped) */
+   "ip\0"
+   "glVertexAttribI3uivEXT\0"
+   "glVertexAttribI3uiv\0"
+   "\0"
+   /* _mesa_function_pool[30462]: UniformMatrix3x4fv (will be remapped) */
+   "iiip\0"
+   "glUniformMatrix3x4fv\0"
+   "\0"
+   /* _mesa_function_pool[30489]: ClipPlane (offset 150) */
+   "ip\0"
+   "glClipPlane\0"
+   "\0"
+   /* _mesa_function_pool[30505]: Recti (offset 90) */
+   "iiii\0"
+   "glRecti\0"
+   "\0"
+   /* _mesa_function_pool[30519]: VertexAttribI3ivEXT (will be remapped) */
+   "ip\0"
+   "glVertexAttribI3ivEXT\0"
+   "glVertexAttribI3iv\0"
+   "\0"
+   /* _mesa_function_pool[30564]: DrawRangeElementsBaseVertex (will be remapped) */
+   "iiiiipi\0"
+   "glDrawRangeElementsBaseVertex\0"
+   "\0"
+   /* _mesa_function_pool[30603]: TexCoordPointervINTEL (dynamic) */
+   "iip\0"
+   "glTexCoordPointervINTEL\0"
+   "\0"
+   /* _mesa_function_pool[30632]: DeleteBuffersARB (will be remapped) */
+   "ip\0"
+   "glDeleteBuffers\0"
+   "glDeleteBuffersARB\0"
+   "\0"
+   /* _mesa_function_pool[30671]: PixelTransformParameterfvEXT (dynamic) */
+   "iip\0"
+   "glPixelTransformParameterfvEXT\0"
+   "\0"
+   /* _mesa_function_pool[30707]: PrimitiveRestartNV (will be remapped) */
+   "\0"
+   "glPrimitiveRestartNV\0"
+   "\0"
+   /* _mesa_function_pool[30730]: WindowPos4fvMESA (will be remapped) */
+   "p\0"
+   "glWindowPos4fvMESA\0"
+   "\0"
+   /* _mesa_function_pool[30752]: GetPixelMapuiv (offset 272) */
+   "ip\0"
+   "glGetPixelMapuiv\0"
+   "\0"
+   /* _mesa_function_pool[30773]: Rectf (offset 88) */
+   "ffff\0"
+   "glRectf\0"
+   "\0"
+   /* _mesa_function_pool[30787]: VertexAttrib1sNV (will be remapped) */
+   "ii\0"
+   "glVertexAttrib1sNV\0"
+   "\0"
+   /* _mesa_function_pool[30810]: Indexfv (offset 47) */
+   "p\0"
+   "glIndexfv\0"
+   "\0"
+   /* _mesa_function_pool[30823]: SecondaryColor3svEXT (will be remapped) */
+   "p\0"
+   "glSecondaryColor3sv\0"
+   "glSecondaryColor3svEXT\0"
+   "\0"
+   /* _mesa_function_pool[30869]: LoadTransposeMatrixfARB (will be remapped) */
+   "p\0"
+   "glLoadTransposeMatrixf\0"
+   "glLoadTransposeMatrixfARB\0"
+   "\0"
+   /* _mesa_function_pool[30921]: GetPointerv (offset 329) */
+   "ip\0"
+   "glGetPointerv\0"
+   "glGetPointervEXT\0"
+   "\0"
+   /* _mesa_function_pool[30956]: Tangent3bEXT (dynamic) */
+   "iii\0"
+   "glTangent3bEXT\0"
+   "\0"
+   /* _mesa_function_pool[30976]: CombinerParameterfNV (will be remapped) */
+   "if\0"
+   "glCombinerParameterfNV\0"
+   "\0"
+   /* _mesa_function_pool[31003]: IndexMask (offset 212) */
+   "i\0"
+   "glIndexMask\0"
+   "\0"
+   /* _mesa_function_pool[31018]: BindProgramNV (will be remapped) */
+   "ii\0"
+   "glBindProgramARB\0"
+   "glBindProgramNV\0"
+   "\0"
+   /* _mesa_function_pool[31055]: VertexAttrib4svARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib4sv\0"
+   "glVertexAttrib4svARB\0"
+   "\0"
+   /* _mesa_function_pool[31098]: GetFloatv (offset 262) */
+   "ip\0"
+   "glGetFloatv\0"
+   "\0"
+   /* _mesa_function_pool[31114]: CreateDebugObjectMESA (dynamic) */
+   "\0"
+   "glCreateDebugObjectMESA\0"
+   "\0"
+   /* _mesa_function_pool[31140]: GetShaderiv (will be remapped) */
+   "iip\0"
+   "glGetShaderiv\0"
+   "\0"
+   /* _mesa_function_pool[31159]: ClientWaitSync (will be remapped) */
+   "iii\0"
+   "glClientWaitSync\0"
+   "\0"
+   /* _mesa_function_pool[31181]: TexCoord4s (offset 124) */
+   "iiii\0"
+   "glTexCoord4s\0"
+   "\0"
+   /* _mesa_function_pool[31200]: TexCoord3sv (offset 117) */
+   "p\0"
+   "glTexCoord3sv\0"
+   "\0"
+   /* _mesa_function_pool[31217]: BindFragmentShaderATI (will be remapped) */
+   "i\0"
+   "glBindFragmentShaderATI\0"
+   "\0"
+   /* _mesa_function_pool[31244]: PopAttrib (offset 218) */
+   "\0"
+   "glPopAttrib\0"
+   "\0"
+   /* _mesa_function_pool[31258]: Fogfv (offset 154) */
+   "ip\0"
+   "glFogfv\0"
+   "\0"
+   /* _mesa_function_pool[31270]: UnmapBufferARB (will be remapped) */
+   "i\0"
+   "glUnmapBuffer\0"
+   "glUnmapBufferARB\0"
+   "\0"
+   /* _mesa_function_pool[31304]: InitNames (offset 197) */
+   "\0"
+   "glInitNames\0"
+   "\0"
+   /* _mesa_function_pool[31318]: Normal3sv (offset 61) */
+   "p\0"
+   "glNormal3sv\0"
+   "\0"
+   /* _mesa_function_pool[31333]: Minmax (offset 368) */
+   "iii\0"
+   "glMinmax\0"
+   "glMinmaxEXT\0"
+   "\0"
+   /* _mesa_function_pool[31359]: TexCoord4d (offset 118) */
+   "dddd\0"
+   "glTexCoord4d\0"
+   "\0"
+   /* _mesa_function_pool[31378]: TexCoord4f (offset 120) */
+   "ffff\0"
+   "glTexCoord4f\0"
+   "\0"
+   /* _mesa_function_pool[31397]: FogCoorddvEXT (will be remapped) */
+   "p\0"
+   "glFogCoorddv\0"
+   "glFogCoorddvEXT\0"
+   "\0"
+   /* _mesa_function_pool[31429]: FinishTextureSUNX (dynamic) */
+   "\0"
+   "glFinishTextureSUNX\0"
+   "\0"
+   /* _mesa_function_pool[31451]: GetFragmentLightfvSGIX (dynamic) */
+   "iip\0"
+   "glGetFragmentLightfvSGIX\0"
+   "\0"
+   /* _mesa_function_pool[31481]: Binormal3fvEXT (dynamic) */
+   "p\0"
+   "glBinormal3fvEXT\0"
+   "\0"
+   /* _mesa_function_pool[31501]: GetBooleanv (offset 258) */
+   "ip\0"
+   "glGetBooleanv\0"
+   "\0"
+   /* _mesa_function_pool[31519]: ColorFragmentOp3ATI (will be remapped) */
+   "iiiiiiiiiiiii\0"
+   "glColorFragmentOp3ATI\0"
+   "\0"
+   /* _mesa_function_pool[31556]: Hint (offset 158) */
+   "ii\0"
+   "glHint\0"
+   "\0"
+   /* _mesa_function_pool[31567]: Color4dv (offset 28) */
+   "p\0"
+   "glColor4dv\0"
+   "\0"
+   /* _mesa_function_pool[31581]: VertexAttrib2svARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib2sv\0"
+   "glVertexAttrib2svARB\0"
+   "\0"
+   /* _mesa_function_pool[31624]: AreProgramsResidentNV (will be remapped) */
+   "ipp\0"
+   "glAreProgramsResidentNV\0"
+   "\0"
+   /* _mesa_function_pool[31653]: WindowPos3svMESA (will be remapped) */
+   "p\0"
+   "glWindowPos3sv\0"
+   "glWindowPos3svARB\0"
+   "glWindowPos3svMESA\0"
+   "\0"
+   /* _mesa_function_pool[31708]: CopyColorSubTable (offset 347) */
+   "iiiii\0"
+   "glCopyColorSubTable\0"
+   "glCopyColorSubTableEXT\0"
+   "\0"
+   /* _mesa_function_pool[31758]: WeightdvARB (dynamic) */
+   "ip\0"
+   "glWeightdvARB\0"
+   "\0"
+   /* _mesa_function_pool[31776]: DeleteRenderbuffersEXT (will be remapped) */
+   "ip\0"
+   "glDeleteRenderbuffers\0"
+   "glDeleteRenderbuffersEXT\0"
+   "\0"
+   /* _mesa_function_pool[31827]: VertexAttrib4NubvARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib4Nubv\0"
+   "glVertexAttrib4NubvARB\0"
+   "\0"
+   /* _mesa_function_pool[31874]: VertexAttrib3dvNV (will be remapped) */
+   "ip\0"
+   "glVertexAttrib3dvNV\0"
+   "\0"
+   /* _mesa_function_pool[31898]: GetObjectParameterfvARB (will be remapped) */
+   "iip\0"
+   "glGetObjectParameterfvARB\0"
+   "\0"
+   /* _mesa_function_pool[31929]: Vertex4iv (offset 147) */
+   "p\0"
+   "glVertex4iv\0"
+   "\0"
+   /* _mesa_function_pool[31944]: GetProgramEnvParameterdvARB (will be remapped) */
+   "iip\0"
+   "glGetProgramEnvParameterdvARB\0"
+   "\0"
+   /* _mesa_function_pool[31979]: TexCoord4dv (offset 119) */
+   "p\0"
+   "glTexCoord4dv\0"
+   "\0"
+   /* _mesa_function_pool[31996]: LockArraysEXT (will be remapped) */
+   "ii\0"
+   "glLockArraysEXT\0"
+   "\0"
+   /* _mesa_function_pool[32016]: Begin (offset 7) */
+   "i\0"
+   "glBegin\0"
+   "\0"
+   /* _mesa_function_pool[32027]: LightModeli (offset 165) */
+   "ii\0"
+   "glLightModeli\0"
+   "\0"
+   /* _mesa_function_pool[32045]: VertexAttribI4ivEXT (will be remapped) */
+   "ip\0"
+   "glVertexAttribI4ivEXT\0"
+   "glVertexAttribI4iv\0"
+   "\0"
+   /* _mesa_function_pool[32090]: Rectfv (offset 89) */
+   "pp\0"
+   "glRectfv\0"
+   "\0"
+   /* _mesa_function_pool[32103]: BlendEquationSeparateiARB (will be remapped) */
+   "iii\0"
+   "glBlendEquationSeparateiARB\0"
+   "\0"
+   /* _mesa_function_pool[32136]: LightModelf (offset 163) */
+   "if\0"
+   "glLightModelf\0"
+   "\0"
+   /* _mesa_function_pool[32154]: GetTexParameterfv (offset 282) */
+   "iip\0"
+   "glGetTexParameterfv\0"
+   "\0"
+   /* _mesa_function_pool[32179]: GetLightfv (offset 264) */
+   "iip\0"
+   "glGetLightfv\0"
+   "\0"
+   /* _mesa_function_pool[32197]: PixelTransformParameterivEXT (dynamic) */
+   "iip\0"
+   "glPixelTransformParameterivEXT\0"
+   "\0"
+   /* _mesa_function_pool[32233]: BinormalPointerEXT (dynamic) */
+   "iip\0"
+   "glBinormalPointerEXT\0"
+   "\0"
+   /* _mesa_function_pool[32259]: VertexAttrib1dNV (will be remapped) */
+   "id\0"
+   "glVertexAttrib1dNV\0"
+   "\0"
+   /* _mesa_function_pool[32282]: GetCombinerInputParameterivNV (will be remapped) */
+   "iiiip\0"
+   "glGetCombinerInputParameterivNV\0"
+   "\0"
+   /* _mesa_function_pool[32321]: Disable (offset 214) */
+   "i\0"
+   "glDisable\0"
+   "\0"
+   /* _mesa_function_pool[32334]: MultiTexCoord2fvARB (offset 387) */
+   "ip\0"
+   "glMultiTexCoord2fv\0"
+   "glMultiTexCoord2fvARB\0"
+   "\0"
+   /* _mesa_function_pool[32379]: GetRenderbufferParameterivEXT (will be remapped) */
+   "iip\0"
+   "glGetRenderbufferParameteriv\0"
+   "glGetRenderbufferParameterivEXT\0"
+   "\0"
+   /* _mesa_function_pool[32445]: CombinerParameterivNV (will be remapped) */
+   "ip\0"
+   "glCombinerParameterivNV\0"
+   "\0"
+   /* _mesa_function_pool[32473]: GenFragmentShadersATI (will be remapped) */
+   "i\0"
+   "glGenFragmentShadersATI\0"
+   "\0"
+   /* _mesa_function_pool[32500]: DrawArrays (offset 310) */
+   "iii\0"
+   "glDrawArrays\0"
+   "glDrawArraysEXT\0"
+   "\0"
+   /* _mesa_function_pool[32534]: WeightuivARB (dynamic) */
+   "ip\0"
+   "glWeightuivARB\0"
+   "\0"
+   /* _mesa_function_pool[32553]: VertexAttrib2sARB (will be remapped) */
+   "iii\0"
+   "glVertexAttrib2s\0"
+   "glVertexAttrib2sARB\0"
+   "\0"
+   /* _mesa_function_pool[32595]: ColorMask (offset 210) */
+   "iiii\0"
+   "glColorMask\0"
+   "\0"
+   /* _mesa_function_pool[32613]: GenAsyncMarkersSGIX (dynamic) */
+   "i\0"
+   "glGenAsyncMarkersSGIX\0"
+   "\0"
+   /* _mesa_function_pool[32638]: Tangent3svEXT (dynamic) */
+   "p\0"
+   "glTangent3svEXT\0"
+   "\0"
+   /* _mesa_function_pool[32657]: GetListParameterivSGIX (dynamic) */
+   "iip\0"
+   "glGetListParameterivSGIX\0"
+   "\0"
+   /* _mesa_function_pool[32687]: BindBufferARB (will be remapped) */
+   "ii\0"
+   "glBindBuffer\0"
+   "glBindBufferARB\0"
+   "\0"
+   /* _mesa_function_pool[32720]: GetInfoLogARB (will be remapped) */
+   "iipp\0"
+   "glGetInfoLogARB\0"
+   "\0"
+   /* _mesa_function_pool[32742]: RasterPos4iv (offset 83) */
+   "p\0"
+   "glRasterPos4iv\0"
+   "\0"
+   /* _mesa_function_pool[32760]: Enable (offset 215) */
+   "i\0"
+   "glEnable\0"
+   "\0"
+   /* _mesa_function_pool[32772]: LineStipple (offset 167) */
+   "ii\0"
+   "glLineStipple\0"
+   "\0"
+   /* _mesa_function_pool[32790]: VertexAttribs4svNV (will be remapped) */
+   "iip\0"
+   "glVertexAttribs4svNV\0"
+   "\0"
+   /* _mesa_function_pool[32816]: EdgeFlagPointerListIBM (dynamic) */
+   "ipi\0"
+   "glEdgeFlagPointerListIBM\0"
+   "\0"
+   /* _mesa_function_pool[32846]: UniformMatrix3x2fv (will be remapped) */
+   "iiip\0"
+   "glUniformMatrix3x2fv\0"
+   "\0"
+   /* _mesa_function_pool[32873]: GetMinmaxParameterfv (offset 365) */
+   "iip\0"
+   "glGetMinmaxParameterfv\0"
+   "glGetMinmaxParameterfvEXT\0"
+   "\0"
+   /* _mesa_function_pool[32927]: VertexAttrib1fvARB (will be remapped) */
+   "ip\0"
+   "glVertexAttrib1fv\0"
+   "glVertexAttrib1fvARB\0"
+   "\0"
+   /* _mesa_function_pool[32970]: GenBuffersARB (will be remapped) */
+   "ip\0"
+   "glGenBuffers\0"
+   "glGenBuffersARB\0"
+   "\0"
+   /* _mesa_function_pool[33003]: VertexAttribs1svNV (will be remapped) */
+   "iip\0"
+   "glVertexAttribs1svNV\0"
+   "\0"
+   /* _mesa_function_pool[33029]: Vertex3fv (offset 137) */
+   "p\0"
+   "glVertex3fv\0"
+   "\0"
+   /* _mesa_function_pool[33044]: GetTexBumpParameterivATI (will be remapped) */
+   "ip\0"
+   "glGetTexBumpParameterivATI\0"
+   "\0"
+   /* _mesa_function_pool[33075]: Binormal3bEXT (dynamic) */
+   "iii\0"
+   "glBinormal3bEXT\0"
+   "\0"
+   /* _mesa_function_pool[33096]: FragmentMaterialivSGIX (dynamic) */
+   "iip\0"
+   "glFragmentMaterialivSGIX\0"
+   "\0"
+   /* _mesa_function_pool[33126]: IsRenderbufferEXT (will be remapped) */
+   "i\0"
+   "glIsRenderbuffer\0"
+   "glIsRenderbufferEXT\0"
+   "\0"
+   /* _mesa_function_pool[33166]: GenProgramsNV (will be remapped) */
+   "ip\0"
+   "glGenProgramsARB\0"
+   "glGenProgramsNV\0"
+   "\0"
+   /* _mesa_function_pool[33203]: VertexAttrib4dvNV (will be remapped) */
+   "ip\0"
+   "glVertexAttrib4dvNV\0"
+   "\0"
+   /* _mesa_function_pool[33227]: EndFragmentShaderATI (will be remapped) */
+   "\0"
+   "glEndFragmentShaderATI\0"
+   "\0"
+   /* _mesa_function_pool[33252]: Binormal3iEXT (dynamic) */
+   "iii\0"
+   "glBinormal3iEXT\0"
+   "\0"
+   /* _mesa_function_pool[33273]: WindowPos2fMESA (will be remapped) */
+   "ff\0"
+   "glWindowPos2f\0"
+   "glWindowPos2fARB\0"
+   "glWindowPos2fMESA\0"
+   "\0"
+   ;
+
+/* these functions need to be remapped */
+static const struct gl_function_pool_remap MESA_remap_table_functions[] = {
+   {  1616, AttachShader_remap_index },
+   {  9893, CreateProgram_remap_index },
+   { 22964, CreateShader_remap_index },
+   { 25451, DeleteProgram_remap_index },
+   { 18608, DeleteShader_remap_index },
+   { 23465, DetachShader_remap_index },
+   { 17974, GetAttachedShaders_remap_index },
+   {  4856, GetProgramInfoLog_remap_index },
+   {   444, GetProgramiv_remap_index },
+   {  6529, GetShaderInfoLog_remap_index },
+   { 31140, GetShaderiv_remap_index },
+   { 13387, IsProgram_remap_index },
+   { 12308, IsShader_remap_index },
+   { 10023, StencilFuncSeparate_remap_index },
+   {  3960, StencilMaskSeparate_remap_index },
+   {  7594, StencilOpSeparate_remap_index },
+   { 22252, UniformMatrix2x3fv_remap_index },
+   {  2886, UniformMatrix2x4fv_remap_index },
+   { 32846, UniformMatrix3x2fv_remap_index },
+   { 30462, UniformMatrix3x4fv_remap_index },
+   { 16264, UniformMatrix4x2fv_remap_index },
+   {  3302, UniformMatrix4x3fv_remap_index },
+   {  5017, ClampColor_remap_index },
+   { 18028, ClearBufferfi_remap_index },
+   { 17470, ClearBufferfv_remap_index },
+   { 29485, ClearBufferiv_remap_index },
+   { 13592, ClearBufferuiv_remap_index },
+   { 19891, GetStringi_remap_index },
+   {  2827, TexBuffer_remap_index },
+   {   977, FramebufferTexture_remap_index },
+   { 26477, GetBufferParameteri64v_remap_index },
+   { 10123, GetInteger64i_v_remap_index },
+   { 23278, VertexAttribDivisor_remap_index },
+   {  9911, LoadTransposeMatrixdARB_remap_index },
+   { 30869, LoadTransposeMatrixfARB_remap_index },
+   {  5637, MultTransposeMatrixdARB_remap_index },
+   { 23652, MultTransposeMatrixfARB_remap_index },
+   {   255, SampleCoverageARB_remap_index },
+   {  5821, CompressedTexImage1DARB_remap_index },
+   { 24180, CompressedTexImage2DARB_remap_index },
+   {  4023, CompressedTexImage3DARB_remap_index },
+   { 18325, CompressedTexSubImage1DARB_remap_index },
+   {  2089, CompressedTexSubImage2DARB_remap_index },
+   { 20313, CompressedTexSubImage3DARB_remap_index },
+   { 28621, GetCompressedTexImageARB_remap_index },
+   {  3868, DisableVertexAttribArrayARB_remap_index },
+   { 30027, EnableVertexAttribArrayARB_remap_index },
+   { 31944, GetProgramEnvParameterdvARB_remap_index },
+   { 23532, GetProgramEnvParameterfvARB_remap_index },
+   { 27506, GetProgramLocalParameterdvARB_remap_index },
+   {  8036, GetProgramLocalParameterfvARB_remap_index },
+   { 18459, GetProgramStringARB_remap_index },
+   { 27701, GetProgramivARB_remap_index },
+   { 20508, GetVertexAttribdvARB_remap_index },
+   { 16072, GetVertexAttribfvARB_remap_index },
+   {  9735, GetVertexAttribivARB_remap_index },
+   { 19372, ProgramEnvParameter4dARB_remap_index },
+   { 25201, ProgramEnvParameter4dvARB_remap_index },
+   { 16792, ProgramEnvParameter4fARB_remap_index },
+   {  8935, ProgramEnvParameter4fvARB_remap_index },
+   {  3986, ProgramLocalParameter4dARB_remap_index },
+   { 13097, ProgramLocalParameter4dvARB_remap_index },
+   { 29506, ProgramLocalParameter4fARB_remap_index },
+   { 25837, ProgramLocalParameter4fvARB_remap_index },
+   { 28375, ProgramStringARB_remap_index },
+   { 19622, VertexAttrib1dARB_remap_index },
+   { 15726, VertexAttrib1dvARB_remap_index },
+   {  4161, VertexAttrib1fARB_remap_index },
+   { 32927, VertexAttrib1fvARB_remap_index },
+   {  7120, VertexAttrib1sARB_remap_index },
+   {  2263, VertexAttrib1svARB_remap_index },
+   { 15157, VertexAttrib2dARB_remap_index },
+   { 17491, VertexAttrib2dvARB_remap_index },
+   {  1635, VertexAttrib2fARB_remap_index },
+   { 17604, VertexAttrib2fvARB_remap_index },
+   { 32553, VertexAttrib2sARB_remap_index },
+   { 31581, VertexAttrib2svARB_remap_index },
+   { 11274, VertexAttrib3dARB_remap_index },
+   {  8602, VertexAttrib3dvARB_remap_index },
+   {  1722, VertexAttrib3fARB_remap_index },
+   { 22515, VertexAttrib3fvARB_remap_index },
+   { 28222, VertexAttrib3sARB_remap_index },
+   { 20250, VertexAttrib3svARB_remap_index },
+   {  4882, VertexAttrib4NbvARB_remap_index },
+   { 17851, VertexAttrib4NivARB_remap_index },
+   { 22470, VertexAttrib4NsvARB_remap_index },
+   { 23484, VertexAttrib4NubARB_remap_index },
+   { 31827, VertexAttrib4NubvARB_remap_index },
+   { 19033, VertexAttrib4NuivARB_remap_index },
+   {  3175, VertexAttrib4NusvARB_remap_index },
+   { 10863, VertexAttrib4bvARB_remap_index },
+   { 26879, VertexAttrib4dARB_remap_index },
+   { 21272, VertexAttrib4dvARB_remap_index },
+   { 11428, VertexAttrib4fARB_remap_index },
+   { 11832, VertexAttrib4fvARB_remap_index },
+   { 10239, VertexAttrib4ivARB_remap_index },
+   { 17284, VertexAttrib4sARB_remap_index },
+   { 31055, VertexAttrib4svARB_remap_index },
+   { 16597, VertexAttrib4ubvARB_remap_index },
+   { 30351, VertexAttrib4uivARB_remap_index },
+   { 20061, VertexAttrib4usvARB_remap_index },
+   { 22067, VertexAttribPointerARB_remap_index },
+   { 32687, BindBufferARB_remap_index },
+   {  6827, BufferDataARB_remap_index },
+   {  1537, BufferSubDataARB_remap_index },
+   { 30632, DeleteBuffersARB_remap_index },
+   { 32970, GenBuffersARB_remap_index },
+   { 17647, GetBufferParameterivARB_remap_index },
+   { 16744, GetBufferPointervARB_remap_index },
+   {  1490, GetBufferSubDataARB_remap_index },
+   { 30299, IsBufferARB_remap_index },
+   { 26321, MapBufferARB_remap_index },
+   { 31270, UnmapBufferARB_remap_index },
+   {   351, BeginQueryARB_remap_index },
+   { 19717, DeleteQueriesARB_remap_index },
+   { 12159, EndQueryARB_remap_index },
+   { 29100, GenQueriesARB_remap_index },
+   {  1981, GetQueryObjectivARB_remap_index },
+   { 17328, GetQueryObjectuivARB_remap_index },
+   {  1779, GetQueryivARB_remap_index },
+   { 19968, IsQueryARB_remap_index },
+   {  8212, AttachObjectARB_remap_index },
+   { 18570, CompileShaderARB_remap_index },
+   {  3244, CreateProgramObjectARB_remap_index },
+   {  6772, CreateShaderObjectARB_remap_index },
+   { 14459, DeleteObjectARB_remap_index },
+   { 23971, DetachObjectARB_remap_index },
+   { 11904, GetActiveUniformARB_remap_index },
+   {  9410, GetAttachedObjectsARB_remap_index },
+   {  9717, GetHandleARB_remap_index },
+   { 32720, GetInfoLogARB_remap_index },
+   { 31898, GetObjectParameterfvARB_remap_index },
+   { 27380, GetObjectParameterivARB_remap_index },
+   { 28858, GetShaderSourceARB_remap_index },
+   { 28082, GetUniformLocationARB_remap_index },
+   { 23754, GetUniformfvARB_remap_index },
+   { 12672, GetUniformivARB_remap_index },
+   { 20106, LinkProgramARB_remap_index },
+   { 20164, ShaderSourceARB_remap_index },
+   {  7494, Uniform1fARB_remap_index },
+   { 29715, Uniform1fvARB_remap_index },
+   { 22036, Uniform1iARB_remap_index },
+   { 20961, Uniform1ivARB_remap_index },
+   {  2212, Uniform2fARB_remap_index },
+   { 14295, Uniform2fvARB_remap_index },
+   { 26208, Uniform2iARB_remap_index },
+   {  2332, Uniform2ivARB_remap_index },
+   { 18680, Uniform3fARB_remap_index },
+   {  9440, Uniform3fvARB_remap_index },
+   {  6383, Uniform3iARB_remap_index },
+   { 16850, Uniform3ivARB_remap_index },
+   { 19178, Uniform4fARB_remap_index },
+   { 23618, Uniform4fvARB_remap_index },
+   { 24880, Uniform4iARB_remap_index },
+   { 20474, Uniform4ivARB_remap_index },
+   {  8264, UniformMatrix2fvARB_remap_index },
+   {    17, UniformMatrix3fvARB_remap_index },
+   {  2729, UniformMatrix4fvARB_remap_index },
+   { 25313, UseProgramObjectARB_remap_index },
+   { 14845, ValidateProgramARB_remap_index },
+   { 21315, BindAttribLocationARB_remap_index },
+   {  4927, GetActiveAttribARB_remap_index },
+   { 16531, GetAttribLocationARB_remap_index },
+   { 29433, DrawBuffersARB_remap_index },
+   { 29296, ClampColorARB_remap_index },
+   { 17896, DrawArraysInstancedARB_remap_index },
+   {  6444, DrawElementsInstancedARB_remap_index },
+   { 13202, RenderbufferStorageMultisample_remap_index },
+   { 13673, FramebufferTextureARB_remap_index },
+   { 25739, FramebufferTextureFaceARB_remap_index },
+   { 24120, ProgramParameteriARB_remap_index },
+   { 23436, VertexAttribDivisorARB_remap_index },
+   { 19226, FlushMappedBufferRange_remap_index },
+   { 27797, MapBufferRange_remap_index },
+   { 16375, BindVertexArray_remap_index },
+   { 14668, GenVertexArrays_remap_index },
+   { 30229, CopyBufferSubData_remap_index },
+   { 31159, ClientWaitSync_remap_index },
+   {  2648, DeleteSync_remap_index },
+   {  7161, FenceSync_remap_index },
+   { 15216, GetInteger64v_remap_index },
+   { 22577, GetSynciv_remap_index },
+   { 29372, IsSync_remap_index },
+   {  9358, WaitSync_remap_index },
+   {  3836, DrawElementsBaseVertex_remap_index },
+   { 30564, DrawRangeElementsBaseVertex_remap_index },
+   { 26352, MultiDrawElementsBaseVertex_remap_index },
+   { 32103, BlendEquationSeparateiARB_remap_index },
+   { 17740, BlendEquationiARB_remap_index },
+   { 12641, BlendFuncSeparateiARB_remap_index },
+   {  9783, BlendFunciARB_remap_index },
+   {  5078, BindTransformFeedback_remap_index },
+   {  3271, DeleteTransformFeedbacks_remap_index },
+   {  6416, DrawTransformFeedback_remap_index },
+   {  9577, GenTransformFeedbacks_remap_index },
+   { 28265, IsTransformFeedback_remap_index },
+   { 25932, PauseTransformFeedback_remap_index },
+   {  5557, ResumeTransformFeedback_remap_index },
+   { 21635, ClearDepthf_remap_index },
+   {  6720, DepthRangef_remap_index },
+   { 14480, GetShaderPrecisionFormat_remap_index },
+   {  9963, ReleaseShaderCompiler_remap_index },
+   { 10906, ShaderBinary_remap_index },
+   {  5425, PolygonOffsetEXT_remap_index },
+   { 23199, GetPixelTexGenParameterfvSGIS_remap_index },
+   {  4404, GetPixelTexGenParameterivSGIS_remap_index },
+   { 22932, PixelTexGenParameterfSGIS_remap_index },
+   {   663, PixelTexGenParameterfvSGIS_remap_index },
+   { 12710, PixelTexGenParameteriSGIS_remap_index },
+   { 13815, PixelTexGenParameterivSGIS_remap_index },
+   { 18224, SampleMaskSGIS_remap_index },
+   { 19908, SamplePatternSGIS_remap_index },
+   { 26281, ColorPointerEXT_remap_index },
+   { 17534, EdgeFlagPointerEXT_remap_index },
+   {  6037, IndexPointerEXT_remap_index },
+   {  6117, NormalPointerEXT_remap_index },
+   { 15810, TexCoordPointerEXT_remap_index },
+   {  6950, VertexPointerEXT_remap_index },
+   {  3638, PointParameterfEXT_remap_index },
+   {  7801, PointParameterfvEXT_remap_index },
+   { 31996, LockArraysEXT_remap_index },
+   { 14909, UnlockArraysEXT_remap_index },
+   {  1306, SecondaryColor3bEXT_remap_index },
+   {  7960, SecondaryColor3bvEXT_remap_index },
+   { 10416, SecondaryColor3dEXT_remap_index },
+   { 25509, SecondaryColor3dvEXT_remap_index },
+   { 28131, SecondaryColor3fEXT_remap_index },
+   { 18261, SecondaryColor3fvEXT_remap_index },
+   {   509, SecondaryColor3iEXT_remap_index },
+   { 16120, SecondaryColor3ivEXT_remap_index },
+   { 10051, SecondaryColor3sEXT_remap_index },
+   { 30823, SecondaryColor3svEXT_remap_index },
+   { 27216, SecondaryColor3ubEXT_remap_index },
+   { 21206, SecondaryColor3ubvEXT_remap_index },
+   { 12952, SecondaryColor3uiEXT_remap_index },
+   { 22819, SecondaryColor3uivEXT_remap_index },
+   { 25789, SecondaryColor3usEXT_remap_index },
+   { 13025, SecondaryColor3usvEXT_remap_index },
+   { 11775, SecondaryColorPointerEXT_remap_index },
+   { 25603, MultiDrawArraysEXT_remap_index },
+   { 20896, MultiDrawElementsEXT_remap_index },
+   { 21091, FogCoordPointerEXT_remap_index },
+   {  4553, FogCoorddEXT_remap_index },
+   { 31397, FogCoorddvEXT_remap_index },
+   {  4670, FogCoordfEXT_remap_index },
+   { 27139, FogCoordfvEXT_remap_index },
+   { 19130, PixelTexGenSGIX_remap_index },
+   { 27724, BlendFuncSeparateEXT_remap_index },
+   {  6862, FlushVertexArrayRangeNV_remap_index },
+   {  5374, VertexArrayRangeNV_remap_index },
+   { 28196, CombinerInputNV_remap_index },
+   {  2155, CombinerOutputNV_remap_index },
+   { 30976, CombinerParameterfNV_remap_index },
+   {  5248, CombinerParameterfvNV_remap_index },
+   { 22301, CombinerParameteriNV_remap_index },
+   { 32445, CombinerParameterivNV_remap_index },
+   {  7238, FinalCombinerInputNV_remap_index },
+   {  9804, GetCombinerInputParameterfvNV_remap_index },
+   { 32282, GetCombinerInputParameterivNV_remap_index },
+   {   216, GetCombinerOutputParameterfvNV_remap_index },
+   { 13776, GetCombinerOutputParameterivNV_remap_index },
+   {  6624, GetFinalCombinerInputParameterfvNV_remap_index },
+   { 24752, GetFinalCombinerInputParameterivNV_remap_index },
+   { 12619, ResizeBuffersMESA_remap_index },
+   { 11101, WindowPos2dMESA_remap_index },
+   {  1099, WindowPos2dvMESA_remap_index },
+   { 33273, WindowPos2fMESA_remap_index },
+   {  7905, WindowPos2fvMESA_remap_index },
+   { 18171, WindowPos2iMESA_remap_index },
+   { 20381, WindowPos2ivMESA_remap_index },
+   { 20995, WindowPos2sMESA_remap_index },
+   {  5735, WindowPos2svMESA_remap_index },
+   {  7730, WindowPos3dMESA_remap_index },
+   { 14023, WindowPos3dvMESA_remap_index },
+   {   555, WindowPos3fMESA_remap_index },
+   { 14970, WindowPos3fvMESA_remap_index },
+   { 24013, WindowPos3iMESA_remap_index },
+   { 30174, WindowPos3ivMESA_remap_index },
+   { 18825, WindowPos3sMESA_remap_index },
+   { 31653, WindowPos3svMESA_remap_index },
+   { 11052, WindowPos4dMESA_remap_index },
+   { 16988, WindowPos4dvMESA_remap_index },
+   { 13982, WindowPos4fMESA_remap_index },
+   { 30730, WindowPos4fvMESA_remap_index },
+   { 30327, WindowPos4iMESA_remap_index },
+   { 12422, WindowPos4ivMESA_remap_index },
+   { 19009, WindowPos4sMESA_remap_index },
+   {  3222, WindowPos4svMESA_remap_index },
+   { 26847, MultiModeDrawArraysIBM_remap_index },
+   { 28971, MultiModeDrawElementsIBM_remap_index },
+   { 12187, DeleteFencesNV_remap_index },
+   { 28043, FinishFenceNV_remap_index },
+   {  3760, GenFencesNV_remap_index },
+   { 16968, GetFenceivNV_remap_index },
+   {  8197, IsFenceNV_remap_index },
+   { 13703, SetFenceNV_remap_index },
+   {  4217, TestFenceNV_remap_index },
+   { 31624, AreProgramsResidentNV_remap_index },
+   { 31018, BindProgramNV_remap_index },
+   { 25872, DeleteProgramsNV_remap_index },
+   { 21424, ExecuteProgramNV_remap_index },
+   { 33166, GenProgramsNV_remap_index },
+   { 23304, GetProgramParameterdvNV_remap_index },
+   { 10478, GetProgramParameterfvNV_remap_index },
+   { 26255, GetProgramStringNV_remap_index },
+   { 24390, GetProgramivNV_remap_index },
+   { 23567, GetTrackMatrixivNV_remap_index },
+   { 26049, GetVertexAttribPointervNV_remap_index },
+   { 24685, GetVertexAttribdvNV_remap_index },
+   {  9253, GetVertexAttribfvNV_remap_index },
+   { 18432, GetVertexAttribivNV_remap_index },
+   { 19256, IsProgramNV_remap_index },
+   {  9336, LoadProgramNV_remap_index },
+   { 27820, ProgramParameters4dvNV_remap_index },
+   { 24320, ProgramParameters4fvNV_remap_index },
+   { 20685, RequestResidentProgramsNV_remap_index },
+   { 22279, TrackMatrixNV_remap_index },
+   { 32259, VertexAttrib1dNV_remap_index },
+   { 13614, VertexAttrib1dvNV_remap_index },
+   { 28477, VertexAttrib1fNV_remap_index },
+   {  2454, VertexAttrib1fvNV_remap_index },
+   { 30787, VertexAttrib1sNV_remap_index },
+   { 15043, VertexAttrib1svNV_remap_index },
+   {  4832, VertexAttrib2dNV_remap_index },
+   { 13507, VertexAttrib2dvNV_remap_index },
+   { 20140, VertexAttrib2fNV_remap_index },
+   { 13073, VertexAttrib2fvNV_remap_index },
+   {  5947, VertexAttrib2sNV_remap_index },
+   { 18879, VertexAttrib2svNV_remap_index },
+   { 11249, VertexAttrib3dNV_remap_index },
+   { 31874, VertexAttrib3dvNV_remap_index },
+   { 10290, VertexAttrib3fNV_remap_index },
+   { 24712, VertexAttrib3fvNV_remap_index },
+   { 22122, VertexAttrib3sNV_remap_index },
+   { 23594, VertexAttrib3svNV_remap_index },
+   { 28945, VertexAttrib4dNV_remap_index },
+   { 33203, VertexAttrib4dvNV_remap_index },
+   {  4454, VertexAttrib4fNV_remap_index },
+   {  9386, VertexAttrib4fvNV_remap_index },
+   { 26731, VertexAttrib4sNV_remap_index },
+   {  1448, VertexAttrib4svNV_remap_index },
+   {  4990, VertexAttrib4ubNV_remap_index },
+   {   817, VertexAttrib4ubvNV_remap_index },
+   { 21604, VertexAttribPointerNV_remap_index },
+   {  2306, VertexAttribs1dvNV_remap_index },
+   { 26137, VertexAttribs1fvNV_remap_index },
+   { 33003, VertexAttribs1svNV_remap_index },
+   { 10315, VertexAttribs2dvNV_remap_index },
+   { 25274, VertexAttribs2fvNV_remap_index },
+   { 17560, VertexAttribs2svNV_remap_index },
+   {  5276, VertexAttribs3dvNV_remap_index },
+   {  2186, VertexAttribs3fvNV_remap_index },
+   { 29922, VertexAttribs3svNV_remap_index },
+   { 26821, VertexAttribs4dvNV_remap_index },
+   {  5348, VertexAttribs4fvNV_remap_index },
+   { 32790, VertexAttribs4svNV_remap_index },
+   { 29670, VertexAttribs4ubvNV_remap_index },
+   { 26923, GetTexBumpParameterfvATI_remap_index },
+   { 33044, GetTexBumpParameterivATI_remap_index },
+   { 18542, TexBumpParameterfvATI_remap_index },
+   { 20556, TexBumpParameterivATI_remap_index },
+   { 15589, AlphaFragmentOp1ATI_remap_index },
+   { 25555, AlphaFragmentOp2ATI_remap_index },
+   { 24628, AlphaFragmentOp3ATI_remap_index },
+   { 29849, BeginFragmentShaderATI_remap_index },
+   { 31217, BindFragmentShaderATI_remap_index },
+   { 23723, ColorFragmentOp1ATI_remap_index },
+   {  4332, ColorFragmentOp2ATI_remap_index },
+   { 31519, ColorFragmentOp3ATI_remap_index },
+   {  5514, DeleteFragmentShaderATI_remap_index },
+   { 33227, EndFragmentShaderATI_remap_index },
+   { 32473, GenFragmentShadersATI_remap_index },
+   { 25428, PassTexCoordATI_remap_index },
+   {  6930, SampleMapATI_remap_index },
+   { 27034, SetFragmentShaderConstantATI_remap_index },
+   {   402, PointParameteriNV_remap_index },
+   { 14184, PointParameterivNV_remap_index },
+   { 28784, ActiveStencilFaceEXT_remap_index },
+   { 27480, BindVertexArrayAPPLE_remap_index },
+   {  2776, DeleteVertexArraysAPPLE_remap_index },
+   { 18001, GenVertexArraysAPPLE_remap_index },
+   { 23369, IsVertexArrayAPPLE_remap_index },
+   {   858, GetProgramNamedParameterdvNV_remap_index },
+   {  3601, GetProgramNamedParameterfvNV_remap_index },
+   { 26954, ProgramNamedParameter4dNV_remap_index },
+   { 14543, ProgramNamedParameter4dvNV_remap_index },
+   {  8869, ProgramNamedParameter4fNV_remap_index },
+   { 11740, ProgramNamedParameter4fvNV_remap_index },
+   { 16899, PrimitiveRestartIndexNV_remap_index },
+   { 30707, PrimitiveRestartNV_remap_index },
+   { 24299, DepthBoundsEXT_remap_index },
+   {  1198, BlendEquationSeparateEXT_remap_index },
+   { 14744, BindFramebufferEXT_remap_index },
+   { 25648, BindRenderbufferEXT_remap_index },
+   {  9633, CheckFramebufferStatusEXT_remap_index },
+   { 22620, DeleteFramebuffersEXT_remap_index },
+   { 31776, DeleteRenderbuffersEXT_remap_index },
+   { 13531, FramebufferRenderbufferEXT_remap_index },
+   { 13720, FramebufferTexture1DEXT_remap_index },
+   { 11534, FramebufferTexture2DEXT_remap_index },
+   { 11154, FramebufferTexture3DEXT_remap_index },
+   { 23235, GenFramebuffersEXT_remap_index },
+   { 17425, GenRenderbuffersEXT_remap_index },
+   {  6666, GenerateMipmapEXT_remap_index },
+   { 21697, GetFramebufferAttachmentParameterivEXT_remap_index },
+   { 32379, GetRenderbufferParameterivEXT_remap_index },
+   { 20436, IsFramebufferEXT_remap_index },
+   { 33126, IsRenderbufferEXT_remap_index },
+   {  8144, RenderbufferStorageEXT_remap_index },
+   {   734, BlitFramebufferEXT_remap_index },
+   { 14329, BufferParameteriAPPLE_remap_index },
+   { 19288, FlushMappedBufferRangeAPPLE_remap_index },
+   {  1854, BindFragDataLocationEXT_remap_index },
+   { 24412, GetFragDataLocationEXT_remap_index },
+   { 10593, GetUniformuivEXT_remap_index },
+   {  2972, GetVertexAttribIivEXT_remap_index },
+   { 27991, GetVertexAttribIuivEXT_remap_index },
+   { 12020, Uniform1uiEXT_remap_index },
+   { 27905, Uniform1uivEXT_remap_index },
+   { 22218, Uniform2uiEXT_remap_index },
+   {  4296, Uniform2uivEXT_remap_index },
+   { 29224, Uniform3uiEXT_remap_index },
+   { 14690, Uniform3uivEXT_remap_index },
+   {  3525, Uniform4uiEXT_remap_index },
+   {  8645, Uniform4uivEXT_remap_index },
+   { 18389, VertexAttribI1iEXT_remap_index },
+   {  1004, VertexAttribI1ivEXT_remap_index },
+   {  2555, VertexAttribI1uiEXT_remap_index },
+   { 12801, VertexAttribI1uivEXT_remap_index },
+   {    81, VertexAttribI2iEXT_remap_index },
+   { 23835, VertexAttribI2ivEXT_remap_index },
+   {  5302, VertexAttribI2uiEXT_remap_index },
+   {  4715, VertexAttribI2uivEXT_remap_index },
+   { 26523, VertexAttribI3iEXT_remap_index },
+   { 30519, VertexAttribI3ivEXT_remap_index },
+   {  3379, VertexAttribI3uiEXT_remap_index },
+   { 30415, VertexAttribI3uivEXT_remap_index },
+   { 21948, VertexAttribI4bvEXT_remap_index },
+   { 14622, VertexAttribI4iEXT_remap_index },
+   { 32045, VertexAttribI4ivEXT_remap_index },
+   { 13434, VertexAttribI4svEXT_remap_index },
+   { 16484, VertexAttribI4ubvEXT_remap_index },
+   { 16183, VertexAttribI4uiEXT_remap_index },
+   {  5448, VertexAttribI4uivEXT_remap_index },
+   { 11317, VertexAttribI4usvEXT_remap_index },
+   { 18486, VertexAttribIPointerEXT_remap_index },
+   {  3066, FramebufferTextureLayerEXT_remap_index },
+   {  5172, ColorMaskIndexedEXT_remap_index },
+   { 18903, DisableIndexedEXT_remap_index },
+   { 26568, EnableIndexedEXT_remap_index },
+   { 21652, GetBooleanIndexedvEXT_remap_index },
+   { 10928, GetIntegerIndexedvEXT_remap_index },
+   { 22696, IsEnabledIndexedEXT_remap_index },
+   { 22596, ClearColorIiEXT_remap_index },
+   {  3475, ClearColorIuiEXT_remap_index },
+   {  9843, GetTexParameterIivEXT_remap_index },
+   {  5895, GetTexParameterIuivEXT_remap_index },
+   {  3022, TexParameterIivEXT_remap_index },
+   { 26390, TexParameterIuivEXT_remap_index },
+   {  4583, BeginConditionalRenderNV_remap_index },
+   { 25378, EndConditionalRenderNV_remap_index },
+   {  9280, BeginTransformFeedbackEXT_remap_index },
+   { 18938, BindBufferBaseEXT_remap_index },
+   { 18797, BindBufferOffsetEXT_remap_index },
+   { 12247, BindBufferRangeEXT_remap_index },
+   { 14244, EndTransformFeedbackEXT_remap_index },
+   { 10791, GetTransformFeedbackVaryingEXT_remap_index },
+   { 20741, TransformFeedbackVaryingsEXT_remap_index },
+   { 29571, ProvokingVertexEXT_remap_index },
+   { 10739, GetTexParameterPointervAPPLE_remap_index },
+   {  5034, TextureRangeAPPLE_remap_index },
+   { 11606, GetObjectParameterivAPPLE_remap_index },
+   { 19863, ObjectPurgeableAPPLE_remap_index },
+   {  5689, ObjectUnpurgeableAPPLE_remap_index },
+   { 17247, ActiveProgramEXT_remap_index },
+   { 17218, CreateShaderProgramEXT_remap_index },
+   { 28569, UseShaderProgramEXT_remap_index },
+   { 16463, TextureBarrierNV_remap_index },
+   { 28810, StencilFuncSeparateATI_remap_index },
+   { 18090, ProgramEnvParameters4fvEXT_remap_index },
+   { 17112, ProgramLocalParameters4fvEXT_remap_index },
+   { 14112, GetQueryObjecti64vEXT_remap_index },
+   { 10341, GetQueryObjectui64vEXT_remap_index },
+   { 23792, EGLImageTargetRenderbufferStorageOES_remap_index },
+   { 12126, EGLImageTargetTexture2DOES_remap_index },
+   {    -1, -1 }
+};
+
+/* these functions are in the ABI, but have alternative names */
+static const struct gl_function_remap MESA_alt_functions[] = {
+   /* from GL_EXT_blend_color */
+   {  2694, _gloffset_BlendColor },
+   /* from GL_EXT_blend_minmax */
+   { 11211, _gloffset_BlendEquation },
+   /* from GL_EXT_color_subtable */
+   { 17010, _gloffset_ColorSubTable },
+   { 31708, _gloffset_CopyColorSubTable },
+   /* from GL_EXT_convolution */
+   {   296, _gloffset_ConvolutionFilter1D },
+   {  2493, _gloffset_CopyConvolutionFilter1D },
+   {  4097, _gloffset_GetConvolutionParameteriv },
+   {  8493, _gloffset_ConvolutionFilter2D },
+   {  8695, _gloffset_ConvolutionParameteriv },
+   {  9155, _gloffset_ConvolutionParameterfv },
+   { 20584, _gloffset_GetSeparableFilter },
+   { 24067, _gloffset_SeparableFilter2D },
+   { 24930, _gloffset_ConvolutionParameteri },
+   { 25053, _gloffset_ConvolutionParameterf },
+   { 26757, _gloffset_GetConvolutionParameterfv },
+   { 27646, _gloffset_GetConvolutionFilter },
+   { 30111, _gloffset_CopyConvolutionFilter2D },
+   /* from GL_EXT_copy_texture */
+   { 15103, _gloffset_CopyTexSubImage3D },
+   { 16697, _gloffset_CopyTexImage2D },
+   { 24538, _gloffset_CopyTexImage1D },
+   { 27327, _gloffset_CopyTexSubImage2D },
+   { 29749, _gloffset_CopyTexSubImage1D },
+   /* from GL_EXT_draw_range_elements */
+   {  9492, _gloffset_DrawRangeElements },
+   /* from GL_EXT_histogram */
+   {   895, _gloffset_Histogram },
+   {  3561, _gloffset_ResetHistogram },
+   {  9989, _gloffset_GetMinmax },
+   { 15437, _gloffset_GetHistogramParameterfv },
+   { 24463, _gloffset_GetMinmaxParameteriv },
+   { 26647, _gloffset_ResetMinmax },
+   { 27543, _gloffset_GetHistogramParameteriv },
+   { 28744, _gloffset_GetHistogram },
+   { 31333, _gloffset_Minmax },
+   { 32873, _gloffset_GetMinmaxParameterfv },
+   /* from GL_EXT_paletted_texture */
+   {  8355, _gloffset_ColorTable },
+   { 15283, _gloffset_GetColorTable },
+   { 22982, _gloffset_GetColorTableParameterfv },
+   { 25109, _gloffset_GetColorTableParameteriv },
+   /* from GL_EXT_subtexture */
+   {  7076, _gloffset_TexSubImage1D },
+   { 10666, _gloffset_TexSubImage2D },
+   /* from GL_EXT_texture3D */
+   {  1813, _gloffset_TexImage3D },
+   { 22751, _gloffset_TexSubImage3D },
+   /* from GL_EXT_texture_object */
+   {  3329, _gloffset_PrioritizeTextures },
+   {  7525, _gloffset_AreTexturesResident },
+   { 13638, _gloffset_GenTextures },
+   { 15769, _gloffset_DeleteTextures },
+   { 19569, _gloffset_IsTexture },
+   { 29814, _gloffset_BindTexture },
+   /* from GL_EXT_vertex_array */
+   { 24239, _gloffset_ArrayElement },
+   { 30921, _gloffset_GetPointerv },
+   { 32500, _gloffset_DrawArrays },
+   /* from GL_SGI_color_table */
+   {  7643, _gloffset_ColorTableParameteriv },
+   {  8355, _gloffset_ColorTable },
+   { 15283, _gloffset_GetColorTable },
+   { 15393, _gloffset_CopyColorTable },
+   { 19430, _gloffset_ColorTableParameterfv },
+   { 22982, _gloffset_GetColorTableParameterfv },
+   { 25109, _gloffset_GetColorTableParameteriv },
+   /* from GL_VERSION_1_3 */
+   {   464, _gloffset_MultiTexCoord3sARB },
+   {   696, _gloffset_ActiveTextureARB },
+   {  4234, _gloffset_MultiTexCoord1fvARB },
+   {  6142, _gloffset_MultiTexCoord3dARB },
+   {  6187, _gloffset_MultiTexCoord2iARB },
+   {  6311, _gloffset_MultiTexCoord2svARB },
+   {  8311, _gloffset_MultiTexCoord2fARB },
+   { 10371, _gloffset_MultiTexCoord3fvARB },
+   { 10973, _gloffset_MultiTexCoord4sARB },
+   { 11654, _gloffset_MultiTexCoord2dvARB },
+   { 12069, _gloffset_MultiTexCoord1svARB },
+   { 12480, _gloffset_MultiTexCoord3svARB },
+   { 12541, _gloffset_MultiTexCoord4iARB },
+   { 13342, _gloffset_MultiTexCoord3iARB },
+   { 14141, _gloffset_MultiTexCoord1dARB },
+   { 14358, _gloffset_MultiTexCoord3dvARB },
+   { 15637, _gloffset_MultiTexCoord3ivARB },
+   { 15682, _gloffset_MultiTexCoord2sARB },
+   { 17067, _gloffset_MultiTexCoord4ivARB },
+   { 19080, _gloffset_ClientActiveTextureARB },
+   { 21380, _gloffset_MultiTexCoord2dARB },
+   { 21817, _gloffset_MultiTexCoord4dvARB },
+   { 22173, _gloffset_MultiTexCoord4fvARB },
+   { 23123, _gloffset_MultiTexCoord3fARB },
+   { 25693, _gloffset_MultiTexCoord4dARB },
+   { 25959, _gloffset_MultiTexCoord1sARB },
+   { 26163, _gloffset_MultiTexCoord1dvARB },
+   { 27171, _gloffset_MultiTexCoord1ivARB },
+   { 27264, _gloffset_MultiTexCoord2ivARB },
+   { 27603, _gloffset_MultiTexCoord1iARB },
+   { 29019, _gloffset_MultiTexCoord4svARB },
+   { 29613, _gloffset_MultiTexCoord1fARB },
+   { 29876, _gloffset_MultiTexCoord4fARB },
+   { 32334, _gloffset_MultiTexCoord2fvARB },
+   {    -1, -1 }
+};
+
+#endif /* need_MESA_remap_table */
+
+#if defined(need_GL_3DFX_tbuffer)
+static const struct gl_function_remap GL_3DFX_tbuffer_functions[] = {
+   {  9213, -1 }, /* TbufferMask3DFX */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_APPLE_flush_buffer_range)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_APPLE_flush_buffer_range_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_APPLE_object_purgeable)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_APPLE_object_purgeable_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_APPLE_texture_range)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_APPLE_texture_range_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_APPLE_vertex_array_object)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_APPLE_vertex_array_object_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_ES2_compatibility)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_ES2_compatibility_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_color_buffer_float)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_color_buffer_float_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_copy_buffer)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_copy_buffer_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_draw_buffers)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_draw_buffers_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_draw_buffers_blend)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_draw_buffers_blend_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_draw_elements_base_vertex)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_draw_elements_base_vertex_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_draw_instanced)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_draw_instanced_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_framebuffer_object)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_framebuffer_object_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_geometry_shader4)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_geometry_shader4_functions[] = {
+   { 12444, -1 }, /* FramebufferTextureLayer */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_instanced_arrays)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_instanced_arrays_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_map_buffer_range)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_map_buffer_range_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_matrix_palette)
+static const struct gl_function_remap GL_ARB_matrix_palette_functions[] = {
+   {  3812, -1 }, /* MatrixIndexusvARB */
+   { 13163, -1 }, /* MatrixIndexuivARB */
+   { 14513, -1 }, /* MatrixIndexPointerARB */
+   { 19818, -1 }, /* CurrentPaletteMatrixARB */
+   { 22867, -1 }, /* MatrixIndexubvARB */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_multisample)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_multisample_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_occlusion_query)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_occlusion_query_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_point_parameters)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_point_parameters_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_provoking_vertex)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_provoking_vertex_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_shader_objects)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_shader_objects_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_sync)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_sync_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_texture_compression)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_texture_compression_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_transform_feedback2)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_transform_feedback2_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_transpose_matrix)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_transpose_matrix_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_vertex_array_object)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_vertex_array_object_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_vertex_blend)
+static const struct gl_function_remap GL_ARB_vertex_blend_functions[] = {
+   {  2435, -1 }, /* WeightubvARB */
+   {  6554, -1 }, /* WeightivARB */
+   { 11076, -1 }, /* WeightPointerARB */
+   { 13898, -1 }, /* WeightfvARB */
+   { 17586, -1 }, /* WeightbvARB */
+   { 21048, -1 }, /* WeightusvARB */
+   { 23993, -1 }, /* VertexBlendARB */
+   { 29697, -1 }, /* WeightsvARB */
+   { 31758, -1 }, /* WeightdvARB */
+   { 32534, -1 }, /* WeightuivARB */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_vertex_buffer_object)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_vertex_buffer_object_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_vertex_program)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_vertex_program_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_vertex_shader)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_vertex_shader_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ARB_window_pos)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ARB_window_pos_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ATI_blend_equation_separate)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ATI_blend_equation_separate_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ATI_draw_buffers)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ATI_draw_buffers_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ATI_envmap_bumpmap)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ATI_envmap_bumpmap_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ATI_fragment_shader)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ATI_fragment_shader_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_ATI_separate_stencil)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_ATI_separate_stencil_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_blend_color)
+static const struct gl_function_remap GL_EXT_blend_color_functions[] = {
+   {  2694, _gloffset_BlendColor },
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_blend_equation_separate)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_blend_equation_separate_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_blend_func_separate)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_blend_func_separate_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_blend_minmax)
+static const struct gl_function_remap GL_EXT_blend_minmax_functions[] = {
+   { 11211, _gloffset_BlendEquation },
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_color_subtable)
+static const struct gl_function_remap GL_EXT_color_subtable_functions[] = {
+   { 17010, _gloffset_ColorSubTable },
+   { 31708, _gloffset_CopyColorSubTable },
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_compiled_vertex_array)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_compiled_vertex_array_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_convolution)
+static const struct gl_function_remap GL_EXT_convolution_functions[] = {
+   {   296, _gloffset_ConvolutionFilter1D },
+   {  2493, _gloffset_CopyConvolutionFilter1D },
+   {  4097, _gloffset_GetConvolutionParameteriv },
+   {  8493, _gloffset_ConvolutionFilter2D },
+   {  8695, _gloffset_ConvolutionParameteriv },
+   {  9155, _gloffset_ConvolutionParameterfv },
+   { 20584, _gloffset_GetSeparableFilter },
+   { 24067, _gloffset_SeparableFilter2D },
+   { 24930, _gloffset_ConvolutionParameteri },
+   { 25053, _gloffset_ConvolutionParameterf },
+   { 26757, _gloffset_GetConvolutionParameterfv },
+   { 27646, _gloffset_GetConvolutionFilter },
+   { 30111, _gloffset_CopyConvolutionFilter2D },
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_coordinate_frame)
+static const struct gl_function_remap GL_EXT_coordinate_frame_functions[] = {
+   { 10510, -1 }, /* TangentPointerEXT */
+   { 12599, -1 }, /* Binormal3ivEXT */
+   { 13295, -1 }, /* Tangent3sEXT */
+   { 14578, -1 }, /* Tangent3fvEXT */
+   { 18778, -1 }, /* Tangent3dvEXT */
+   { 19516, -1 }, /* Binormal3bvEXT */
+   { 20637, -1 }, /* Binormal3dEXT */
+   { 22799, -1 }, /* Tangent3fEXT */
+   { 25002, -1 }, /* Binormal3sEXT */
+   { 25470, -1 }, /* Tangent3ivEXT */
+   { 25489, -1 }, /* Tangent3dEXT */
+   { 26436, -1 }, /* Binormal3svEXT */
+   { 27069, -1 }, /* Binormal3fEXT */
+   { 27957, -1 }, /* Binormal3dvEXT */
+   { 29276, -1 }, /* Tangent3iEXT */
+   { 30396, -1 }, /* Tangent3bvEXT */
+   { 30956, -1 }, /* Tangent3bEXT */
+   { 31481, -1 }, /* Binormal3fvEXT */
+   { 32233, -1 }, /* BinormalPointerEXT */
+   { 32638, -1 }, /* Tangent3svEXT */
+   { 33075, -1 }, /* Binormal3bEXT */
+   { 33252, -1 }, /* Binormal3iEXT */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_copy_texture)
+static const struct gl_function_remap GL_EXT_copy_texture_functions[] = {
+   { 15103, _gloffset_CopyTexSubImage3D },
+   { 16697, _gloffset_CopyTexImage2D },
+   { 24538, _gloffset_CopyTexImage1D },
+   { 27327, _gloffset_CopyTexSubImage2D },
+   { 29749, _gloffset_CopyTexSubImage1D },
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_cull_vertex)
+static const struct gl_function_remap GL_EXT_cull_vertex_functions[] = {
+   {  8844, -1 }, /* CullParameterdvEXT */
+   { 11699, -1 }, /* CullParameterfvEXT */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_depth_bounds_test)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_depth_bounds_test_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_draw_buffers2)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_draw_buffers2_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_draw_instanced)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_draw_instanced_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_draw_range_elements)
+static const struct gl_function_remap GL_EXT_draw_range_elements_functions[] = {
+   {  9492, _gloffset_DrawRangeElements },
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_fog_coord)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_fog_coord_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_framebuffer_blit)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_framebuffer_blit_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_framebuffer_multisample)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_framebuffer_multisample_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_framebuffer_object)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_framebuffer_object_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_gpu_program_parameters)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_gpu_program_parameters_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_gpu_shader4)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_gpu_shader4_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_histogram)
+static const struct gl_function_remap GL_EXT_histogram_functions[] = {
+   {   895, _gloffset_Histogram },
+   {  3561, _gloffset_ResetHistogram },
+   {  9989, _gloffset_GetMinmax },
+   { 15437, _gloffset_GetHistogramParameterfv },
+   { 24463, _gloffset_GetMinmaxParameteriv },
+   { 26647, _gloffset_ResetMinmax },
+   { 27543, _gloffset_GetHistogramParameteriv },
+   { 28744, _gloffset_GetHistogram },
+   { 31333, _gloffset_Minmax },
+   { 32873, _gloffset_GetMinmaxParameterfv },
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_index_func)
+static const struct gl_function_remap GL_EXT_index_func_functions[] = {
+   { 11485, -1 }, /* IndexFuncEXT */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_index_material)
+static const struct gl_function_remap GL_EXT_index_material_functions[] = {
+   { 21135, -1 }, /* IndexMaterialEXT */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_light_texture)
+static const struct gl_function_remap GL_EXT_light_texture_functions[] = {
+   { 26456, -1 }, /* ApplyTextureEXT */
+   { 26601, -1 }, /* TextureMaterialEXT */
+   { 26626, -1 }, /* TextureLightEXT */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_multi_draw_arrays)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_multi_draw_arrays_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_multisample)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_multisample_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_paletted_texture)
+static const struct gl_function_remap GL_EXT_paletted_texture_functions[] = {
+   {  8355, _gloffset_ColorTable },
+   { 15283, _gloffset_GetColorTable },
+   { 22982, _gloffset_GetColorTableParameterfv },
+   { 25109, _gloffset_GetColorTableParameteriv },
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_pixel_transform)
+static const struct gl_function_remap GL_EXT_pixel_transform_functions[] = {
+   { 21782, -1 }, /* PixelTransformParameterfEXT */
+   { 21862, -1 }, /* PixelTransformParameteriEXT */
+   { 30671, -1 }, /* PixelTransformParameterfvEXT */
+   { 32197, -1 }, /* PixelTransformParameterivEXT */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_point_parameters)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_point_parameters_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_polygon_offset)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_polygon_offset_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_provoking_vertex)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_provoking_vertex_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_secondary_color)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_secondary_color_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_separate_shader_objects)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_separate_shader_objects_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_stencil_two_side)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_stencil_two_side_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_subtexture)
+static const struct gl_function_remap GL_EXT_subtexture_functions[] = {
+   {  7076, _gloffset_TexSubImage1D },
+   { 10666, _gloffset_TexSubImage2D },
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_texture3D)
+static const struct gl_function_remap GL_EXT_texture3D_functions[] = {
+   {  1813, _gloffset_TexImage3D },
+   { 22751, _gloffset_TexSubImage3D },
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_texture_array)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_texture_array_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_texture_integer)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_texture_integer_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_texture_object)
+static const struct gl_function_remap GL_EXT_texture_object_functions[] = {
+   {  3329, _gloffset_PrioritizeTextures },
+   {  7525, _gloffset_AreTexturesResident },
+   { 13638, _gloffset_GenTextures },
+   { 15769, _gloffset_DeleteTextures },
+   { 19569, _gloffset_IsTexture },
+   { 29814, _gloffset_BindTexture },
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_texture_perturb_normal)
+static const struct gl_function_remap GL_EXT_texture_perturb_normal_functions[] = {
+   { 13848, -1 }, /* TextureNormalEXT */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_timer_query)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_timer_query_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_transform_feedback)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_transform_feedback_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_vertex_array)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_EXT_vertex_array_functions[] = {
+   { 24239, _gloffset_ArrayElement },
+   { 30921, _gloffset_GetPointerv },
+   { 32500, _gloffset_DrawArrays },
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_EXT_vertex_weighting)
+static const struct gl_function_remap GL_EXT_vertex_weighting_functions[] = {
+   { 19599, -1 }, /* VertexWeightfvEXT */
+   { 27012, -1 }, /* VertexWeightfEXT */
+   { 28713, -1 }, /* VertexWeightPointerEXT */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_HP_image_transform)
+static const struct gl_function_remap GL_HP_image_transform_functions[] = {
+   {  2366, -1 }, /* GetImageTransformParameterfvHP */
+   {  3778, -1 }, /* ImageTransformParameterfHP */
+   { 10204, -1 }, /* ImageTransformParameterfvHP */
+   { 11954, -1 }, /* ImageTransformParameteriHP */
+   { 12334, -1 }, /* GetImageTransformParameterivHP */
+   { 19663, -1 }, /* ImageTransformParameterivHP */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_IBM_multimode_draw_arrays)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_IBM_multimode_draw_arrays_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_IBM_vertex_array_lists)
+static const struct gl_function_remap GL_IBM_vertex_array_lists_functions[] = {
+   {  4366, -1 }, /* SecondaryColorPointerListIBM */
+   {  6008, -1 }, /* NormalPointerListIBM */
+   {  7699, -1 }, /* FogCoordPointerListIBM */
+   {  8006, -1 }, /* VertexPointerListIBM */
+   { 11875, -1 }, /* ColorPointerListIBM */
+   { 13402, -1 }, /* TexCoordPointerListIBM */
+   { 13870, -1 }, /* IndexPointerListIBM */
+   { 32816, -1 }, /* EdgeFlagPointerListIBM */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_INGR_blend_func_separate)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_INGR_blend_func_separate_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_INTEL_parallel_arrays)
+static const struct gl_function_remap GL_INTEL_parallel_arrays_functions[] = {
+   { 12742, -1 }, /* VertexPointervINTEL */
+   { 15530, -1 }, /* ColorPointervINTEL */
+   { 30085, -1 }, /* NormalPointervINTEL */
+   { 30603, -1 }, /* TexCoordPointervINTEL */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_MESA_resize_buffers)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_MESA_resize_buffers_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_MESA_shader_debug)
+static const struct gl_function_remap GL_MESA_shader_debug_functions[] = {
+   {  1677, -1 }, /* GetDebugLogLengthMESA */
+   {  3500, -1 }, /* ClearDebugLogMESA */
+   {  4527, -1 }, /* GetDebugLogMESA */
+   { 31114, -1 }, /* CreateDebugObjectMESA */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_MESA_window_pos)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_MESA_window_pos_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_NV_condtitional_render)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_NV_condtitional_render_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_NV_evaluators)
+static const struct gl_function_remap GL_NV_evaluators_functions[] = {
+   {  6738, -1 }, /* GetMapAttribParameterivNV */
+   {  8461, -1 }, /* MapControlPointsNV */
+   {  8560, -1 }, /* MapParameterfvNV */
+   { 10649, -1 }, /* EvalMapsNV */
+   { 17184, -1 }, /* GetMapAttribParameterfvNV */
+   { 17401, -1 }, /* MapParameterivNV */
+   { 24853, -1 }, /* GetMapParameterivNV */
+   { 25351, -1 }, /* GetMapParameterfvNV */
+   { 29400, -1 }, /* GetMapControlPointsNV */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_NV_fence)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_NV_fence_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_NV_fragment_program)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_NV_fragment_program_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_NV_point_sprite)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_NV_point_sprite_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_NV_primitive_restart)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_NV_primitive_restart_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_NV_register_combiners)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_NV_register_combiners_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_NV_register_combiners2)
+static const struct gl_function_remap GL_NV_register_combiners2_functions[] = {
+   { 15922, -1 }, /* CombinerStageParameterfvNV */
+   { 16318, -1 }, /* GetCombinerStageParameterfvNV */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_NV_texture_barrier)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_NV_texture_barrier_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_NV_vertex_array_range)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_NV_vertex_array_range_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_NV_vertex_program)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_NV_vertex_program_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_OES_EGL_image)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_OES_EGL_image_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_PGI_misc_hints)
+static const struct gl_function_remap GL_PGI_misc_hints_functions[] = {
+   {  8681, -1 }, /* HintPGI */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIS_detail_texture)
+static const struct gl_function_remap GL_SGIS_detail_texture_functions[] = {
+   { 16291, -1 }, /* GetDetailTexFuncSGIS */
+   { 16642, -1 }, /* DetailTexFuncSGIS */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIS_fog_function)
+static const struct gl_function_remap GL_SGIS_fog_function_functions[] = {
+   { 27309, -1 }, /* FogFuncSGIS */
+   { 28062, -1 }, /* GetFogFuncSGIS */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIS_multisample)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_SGIS_multisample_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIS_pixel_texture)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_SGIS_pixel_texture_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIS_point_parameters)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_SGIS_point_parameters_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIS_sharpen_texture)
+static const struct gl_function_remap GL_SGIS_sharpen_texture_functions[] = {
+   {  6799, -1 }, /* GetSharpenTexFuncSGIS */
+   { 22147, -1 }, /* SharpenTexFuncSGIS */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIS_texture4D)
+static const struct gl_function_remap GL_SGIS_texture4D_functions[] = {
+   {  1049, -1 }, /* TexImage4DSGIS */
+   { 15838, -1 }, /* TexSubImage4DSGIS */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIS_texture_color_mask)
+static const struct gl_function_remap GL_SGIS_texture_color_mask_functions[] = {
+   { 15236, -1 }, /* TextureColorMaskSGIS */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIS_texture_filter4)
+static const struct gl_function_remap GL_SGIS_texture_filter4_functions[] = {
+   {  6976, -1 }, /* GetTexFilterFuncSGIS */
+   { 16437, -1 }, /* TexFilterFuncSGIS */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIX_async)
+static const struct gl_function_remap GL_SGIX_async_functions[] = {
+   {  3426, -1 }, /* AsyncMarkerSGIX */
+   {  4506, -1 }, /* FinishAsyncSGIX */
+   {  5495, -1 }, /* PollAsyncSGIX */
+   { 22328, -1 }, /* DeleteAsyncMarkersSGIX */
+   { 22383, -1 }, /* IsAsyncMarkerSGIX */
+   { 32613, -1 }, /* GenAsyncMarkersSGIX */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIX_flush_raster)
+static const struct gl_function_remap GL_SGIX_flush_raster_functions[] = {
+   {  7353, -1 }, /* FlushRasterSGIX */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIX_fragment_lighting)
+static const struct gl_function_remap GL_SGIX_fragment_lighting_functions[] = {
+   {  2664, -1 }, /* FragmentMaterialfvSGIX */
+   {  5399, -1 }, /* FragmentLightiSGIX */
+   {  8073, -1 }, /* FragmentMaterialfSGIX */
+   {  8234, -1 }, /* GetFragmentLightivSGIX */
+   {  9107, -1 }, /* FragmentLightModeliSGIX */
+   { 10712, -1 }, /* FragmentLightivSGIX */
+   { 11019, -1 }, /* GetFragmentMaterialivSGIX */
+   { 16231, -1 }, /* GetFragmentMaterialfvSGIX */
+   { 19486, -1 }, /* FragmentLightModelfSGIX */
+   { 19786, -1 }, /* FragmentColorMaterialSGIX */
+   { 20203, -1 }, /* FragmentMaterialiSGIX */
+   { 21463, -1 }, /* LightEnviSGIX */
+   { 23074, -1 }, /* FragmentLightModelfvSGIX */
+   { 23409, -1 }, /* FragmentLightfvSGIX */
+   { 28446, -1 }, /* FragmentLightModelivSGIX */
+   { 28595, -1 }, /* FragmentLightfSGIX */
+   { 31451, -1 }, /* GetFragmentLightfvSGIX */
+   { 33096, -1 }, /* FragmentMaterialivSGIX */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIX_framezoom)
+static const struct gl_function_remap GL_SGIX_framezoom_functions[] = {
+   { 22406, -1 }, /* FrameZoomSGIX */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIX_igloo_interface)
+static const struct gl_function_remap GL_SGIX_igloo_interface_functions[] = {
+   { 28903, -1 }, /* IglooInterfaceSGIX */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIX_instruments)
+static const struct gl_function_remap GL_SGIX_instruments_functions[] = {
+   {  2844, -1 }, /* ReadInstrumentsSGIX */
+   {  6572, -1 }, /* PollInstrumentsSGIX */
+   { 10570, -1 }, /* GetInstrumentsSGIX */
+   { 13000, -1 }, /* StartInstrumentsSGIX */
+   { 15956, -1 }, /* StopInstrumentsSGIX */
+   { 17823, -1 }, /* InstrumentsBufferSGIX */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIX_list_priority)
+static const struct gl_function_remap GL_SGIX_list_priority_functions[] = {
+   {  1280, -1 }, /* ListParameterfSGIX */
+   {  3128, -1 }, /* GetListParameterfvSGIX */
+   { 17714, -1 }, /* ListParameteriSGIX */
+   { 18728, -1 }, /* ListParameterfvSGIX */
+   { 20869, -1 }, /* ListParameterivSGIX */
+   { 32657, -1 }, /* GetListParameterivSGIX */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIX_pixel_texture)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_SGIX_pixel_texture_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIX_polynomial_ffd)
+static const struct gl_function_remap GL_SGIX_polynomial_ffd_functions[] = {
+   {  3724, -1 }, /* LoadIdentityDeformationMapSGIX */
+   { 12208, -1 }, /* DeformationMap3dSGIX */
+   { 16056, -1 }, /* DeformSGIX */
+   { 24351, -1 }, /* DeformationMap3fSGIX */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIX_reference_plane)
+static const struct gl_function_remap GL_SGIX_reference_plane_functions[] = {
+   { 14787, -1 }, /* ReferencePlaneSGIX */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIX_sprite)
+static const struct gl_function_remap GL_SGIX_sprite_functions[] = {
+   {  9605, -1 }, /* SpriteParameterfvSGIX */
+   { 20658, -1 }, /* SpriteParameteriSGIX */
+   { 26681, -1 }, /* SpriteParameterfSGIX */
+   { 29543, -1 }, /* SpriteParameterivSGIX */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGIX_tag_sample_buffer)
+static const struct gl_function_remap GL_SGIX_tag_sample_buffer_functions[] = {
+   { 20717, -1 }, /* TagSampleBufferSGIX */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SGI_color_table)
+static const struct gl_function_remap GL_SGI_color_table_functions[] = {
+   {  7643, _gloffset_ColorTableParameteriv },
+   {  8355, _gloffset_ColorTable },
+   { 15283, _gloffset_GetColorTable },
+   { 15393, _gloffset_CopyColorTable },
+   { 19430, _gloffset_ColorTableParameterfv },
+   { 22982, _gloffset_GetColorTableParameterfv },
+   { 25109, _gloffset_GetColorTableParameteriv },
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SUNX_constant_data)
+static const struct gl_function_remap GL_SUNX_constant_data_functions[] = {
+   { 31429, -1 }, /* FinishTextureSUNX */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SUN_global_alpha)
+static const struct gl_function_remap GL_SUN_global_alpha_functions[] = {
+   {  3447, -1 }, /* GlobalAlphaFactorubSUN */
+   {  4805, -1 }, /* GlobalAlphaFactoriSUN */
+   {  6597, -1 }, /* GlobalAlphaFactordSUN */
+   {  9689, -1 }, /* GlobalAlphaFactoruiSUN */
+   { 10161, -1 }, /* GlobalAlphaFactorbSUN */
+   { 13315, -1 }, /* GlobalAlphaFactorfSUN */
+   { 13479, -1 }, /* GlobalAlphaFactorusSUN */
+   { 22669, -1 }, /* GlobalAlphaFactorsSUN */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SUN_mesh_array)
+static const struct gl_function_remap GL_SUN_mesh_array_functions[] = {
+   { 29334, -1 }, /* DrawMeshArraysSUN */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SUN_triangle_list)
+static const struct gl_function_remap GL_SUN_triangle_list_functions[] = {
+   {  4480, -1 }, /* ReplacementCodeubSUN */
+   {  6356, -1 }, /* ReplacementCodeubvSUN */
+   { 19151, -1 }, /* ReplacementCodeusvSUN */
+   { 19339, -1 }, /* ReplacementCodePointerSUN */
+   { 21527, -1 }, /* ReplacementCodeuiSUN */
+   { 22357, -1 }, /* ReplacementCodeusSUN */
+   { 30000, -1 }, /* ReplacementCodeuivSUN */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_SUN_vertex)
+static const struct gl_function_remap GL_SUN_vertex_functions[] = {
+   {  1154, -1 }, /* ReplacementCodeuiColor3fVertex3fvSUN */
+   {  1352, -1 }, /* TexCoord4fColor4fNormal3fVertex4fvSUN */
+   {  1578, -1 }, /* TexCoord2fColor4ubVertex3fvSUN */
+   {  1908, -1 }, /* ReplacementCodeuiVertex3fvSUN */
+   {  2042, -1 }, /* ReplacementCodeuiTexCoord2fVertex3fvSUN */
+   {  2600, -1 }, /* ReplacementCodeuiNormal3fVertex3fSUN */
+   {  2913, -1 }, /* Color4ubVertex3fvSUN */
+   {  4639, -1 }, /* Color4ubVertex3fSUN */
+   {  4762, -1 }, /* TexCoord2fVertex3fSUN */
+   {  5106, -1 }, /* TexCoord2fColor4fNormal3fVertex3fSUN */
+   {  5599, -1 }, /* TexCoord2fNormal3fVertex3fvSUN */
+   {  6251, -1 }, /* ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN */
+   {  7031, -1 }, /* ReplacementCodeuiColor4ubVertex3fvSUN */
+   {  7390, -1 }, /* ReplacementCodeuiTexCoord2fVertex3fSUN */
+   {  8102, -1 }, /* TexCoord2fNormal3fVertex3fSUN */
+   {  8906, -1 }, /* Color3fVertex3fSUN */
+   { 10097, -1 }, /* Color3fVertex3fvSUN */
+   { 10535, -1 }, /* Color4fNormal3fVertex3fvSUN */
+   { 11364, -1 }, /* ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN */
+   { 12863, -1 }, /* ReplacementCodeuiColor4fNormal3fVertex3fvSUN */
+   { 14403, -1 }, /* ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN */
+   { 14929, -1 }, /* TexCoord2fColor3fVertex3fSUN */
+   { 15981, -1 }, /* TexCoord4fColor4fNormal3fVertex4fSUN */
+   { 16396, -1 }, /* Color4ubVertex2fvSUN */
+   { 16667, -1 }, /* Normal3fVertex3fSUN */
+   { 17764, -1 }, /* ReplacementCodeuiColor4fNormal3fVertex3fSUN */
+   { 18125, -1 }, /* TexCoord2fColor4fNormal3fVertex3fvSUN */
+   { 18980, -1 }, /* TexCoord2fVertex3fvSUN */
+   { 19756, -1 }, /* Color4ubVertex2fSUN */
+   { 19994, -1 }, /* ReplacementCodeuiColor4ubVertex3fSUN */
+   { 21993, -1 }, /* TexCoord2fColor4ubVertex3fSUN */
+   { 22425, -1 }, /* Normal3fVertex3fvSUN */
+   { 22891, -1 }, /* Color4fNormal3fVertex3fSUN */
+   { 23900, -1 }, /* ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN */
+   { 26002, -1 }, /* ReplacementCodeuiColor3fVertex3fSUN */
+   { 27425, -1 }, /* TexCoord4fVertex4fSUN */
+   { 27851, -1 }, /* TexCoord2fColor3fVertex3fvSUN */
+   { 28290, -1 }, /* ReplacementCodeuiNormal3fVertex3fvSUN */
+   { 28417, -1 }, /* TexCoord4fVertex4fvSUN */
+   { 29151, -1 }, /* ReplacementCodeuiVertex3fSUN */
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_VERSION_1_3)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_VERSION_1_3_functions[] = {
+   {   464, _gloffset_MultiTexCoord3sARB },
+   {   696, _gloffset_ActiveTextureARB },
+   {  4234, _gloffset_MultiTexCoord1fvARB },
+   {  6142, _gloffset_MultiTexCoord3dARB },
+   {  6187, _gloffset_MultiTexCoord2iARB },
+   {  6311, _gloffset_MultiTexCoord2svARB },
+   {  8311, _gloffset_MultiTexCoord2fARB },
+   { 10371, _gloffset_MultiTexCoord3fvARB },
+   { 10973, _gloffset_MultiTexCoord4sARB },
+   { 11654, _gloffset_MultiTexCoord2dvARB },
+   { 12069, _gloffset_MultiTexCoord1svARB },
+   { 12480, _gloffset_MultiTexCoord3svARB },
+   { 12541, _gloffset_MultiTexCoord4iARB },
+   { 13342, _gloffset_MultiTexCoord3iARB },
+   { 14141, _gloffset_MultiTexCoord1dARB },
+   { 14358, _gloffset_MultiTexCoord3dvARB },
+   { 15637, _gloffset_MultiTexCoord3ivARB },
+   { 15682, _gloffset_MultiTexCoord2sARB },
+   { 17067, _gloffset_MultiTexCoord4ivARB },
+   { 19080, _gloffset_ClientActiveTextureARB },
+   { 21380, _gloffset_MultiTexCoord2dARB },
+   { 21817, _gloffset_MultiTexCoord4dvARB },
+   { 22173, _gloffset_MultiTexCoord4fvARB },
+   { 23123, _gloffset_MultiTexCoord3fARB },
+   { 25693, _gloffset_MultiTexCoord4dARB },
+   { 25959, _gloffset_MultiTexCoord1sARB },
+   { 26163, _gloffset_MultiTexCoord1dvARB },
+   { 27171, _gloffset_MultiTexCoord1ivARB },
+   { 27264, _gloffset_MultiTexCoord2ivARB },
+   { 27603, _gloffset_MultiTexCoord1iARB },
+   { 29019, _gloffset_MultiTexCoord4svARB },
+   { 29613, _gloffset_MultiTexCoord1fARB },
+   { 29876, _gloffset_MultiTexCoord4fARB },
+   { 32334, _gloffset_MultiTexCoord2fvARB },
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_VERSION_1_4)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_VERSION_1_4_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_VERSION_1_5)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_VERSION_1_5_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_VERSION_2_0)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_VERSION_2_0_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_VERSION_2_1)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_VERSION_2_1_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_VERSION_3_0)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_VERSION_3_0_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_VERSION_3_1)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_VERSION_3_1_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_VERSION_3_2)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_VERSION_3_2_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
+#if defined(need_GL_VERSION_3_3)
+/* functions defined in MESA_remap_table_functions are excluded */
+static const struct gl_function_remap GL_VERSION_3_3_functions[] = {
+   {    -1, -1 }
+};
+#endif
+
diff --git a/mesalib/src/mesa/main/state.c b/mesalib/src/mesa/main/state.c
index 118ed1d28..1d1ae4737 100644
--- a/mesalib/src/mesa/main/state.c
+++ b/mesalib/src/mesa/main/state.c
@@ -445,6 +445,35 @@ update_color(struct gl_context *ctx)
    ctx->Color._LogicOpEnabled = _mesa_rgba_logicop_enabled(ctx);
 }
 
+static void
+update_clamp_fragment_color(struct gl_context *ctx)
+{
+   if(ctx->Color.ClampFragmentColor == GL_FIXED_ONLY_ARB)
+      ctx->Color._ClampFragmentColor = !ctx->DrawBuffer || !ctx->DrawBuffer->Visual.floatMode;
+   else
+      ctx->Color._ClampFragmentColor = ctx->Color.ClampFragmentColor;
+}
+
+static void
+update_clamp_vertex_color(struct gl_context *ctx)
+{
+   if(ctx->Light.ClampVertexColor == GL_FIXED_ONLY_ARB)
+      ctx->Light._ClampVertexColor = !ctx->DrawBuffer || !ctx->DrawBuffer->Visual.floatMode;
+   else
+      ctx->Light._ClampVertexColor = ctx->Light.ClampVertexColor;
+}
+
+static void
+update_clamp_read_color(struct gl_context *ctx)
+{
+   if(ctx->Color.ClampReadColor == GL_FIXED_ONLY_ARB)
+      ctx->Color._ClampReadColor = !ctx->ReadBuffer || !ctx->ReadBuffer->Visual.floatMode;
+   else
+      ctx->Color._ClampReadColor = ctx->Color.ClampReadColor;
+}
+
+
+
 
 /*
  * Check polygon state and set DD_TRI_CULL_FRONT_BACK and/or DD_TRI_OFFSET
@@ -565,7 +594,7 @@ _mesa_update_state_locked( struct gl_context *ctx )
    if (ctx->FragmentProgram._MaintainTexEnvProgram) {
       prog_flags |= (_NEW_BUFFERS | _NEW_TEXTURE | _NEW_FOG |
 		     _NEW_ARRAY | _NEW_LIGHT | _NEW_POINT | _NEW_RENDERMODE |
-		     _NEW_PROGRAM);
+		     _NEW_PROGRAM | _NEW_FRAG_CLAMP);
    }
    if (ctx->VertexProgram._MaintainTnlProgram) {
       prog_flags |= (_NEW_ARRAY | _NEW_TEXTURE | _NEW_TEXTURE_MATRIX |
@@ -599,6 +628,9 @@ _mesa_update_state_locked( struct gl_context *ctx )
    if (new_state & _NEW_LIGHT)
       _mesa_update_lighting( ctx );
 
+   if (new_state & (_NEW_LIGHT | _NEW_BUFFERS))
+      update_clamp_vertex_color(ctx);
+
    if (new_state & (_NEW_STENCIL | _NEW_BUFFERS))
       _mesa_update_stencil( ctx );
 
@@ -617,6 +649,12 @@ _mesa_update_state_locked( struct gl_context *ctx )
    if (new_state & _NEW_COLOR)
       update_color( ctx );
 
+   if (new_state & (_NEW_COLOR | _NEW_BUFFERS))
+      update_clamp_read_color(ctx);
+
+   if(new_state & (_NEW_FRAG_CLAMP | _NEW_BUFFERS))
+      update_clamp_fragment_color(ctx);
+
 #if 0
    if (new_state & (_NEW_POINT | _NEW_LINE | _NEW_POLYGON | _NEW_LIGHT
                     | _NEW_STENCIL | _DD_NEW_SEPARATE_SPECULAR))
diff --git a/mesalib/src/mesa/main/texenv.c b/mesalib/src/mesa/main/texenv.c
index 9caca7c11..9228e354a 100644
--- a/mesalib/src/mesa/main/texenv.c
+++ b/mesalib/src/mesa/main/texenv.c
@@ -1,1038 +1,1043 @@
-/*

- * Mesa 3-D graphics library

- * Version:  7.5

- *

- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

- * Copyright (C) 2009  VMware, Inc.  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.

- */

-

-/** 

- * \file texenv.c

- *

- * glTexEnv-related functions

- */

-

-

-#include "main/glheader.h"

-#include "main/context.h"

-#include "main/enums.h"

-#include "main/macros.h"

-#include "main/mtypes.h"

-#include "main/texenv.h"

-#include "main/texstate.h"

-

-

-#define TE_ERROR(errCode, msg, value)				\

-   _mesa_error(ctx, errCode, msg, _mesa_lookup_enum_by_nr(value));

-

-

-/** Set texture env mode */

-static void

-set_env_mode(struct gl_context *ctx,

-             struct gl_texture_unit *texUnit,

-             GLenum mode)

-{

-   GLboolean legal;

-

-   if (texUnit->EnvMode == mode)

-      return;

-

-   switch (mode) {

-   case GL_MODULATE:

-   case GL_BLEND:

-   case GL_DECAL:

-   case GL_REPLACE:

-      legal = GL_TRUE;

-      break;

-   case GL_REPLACE_EXT:

-      mode = GL_REPLACE; /* GL_REPLACE_EXT != GL_REPLACE */

-      legal = GL_TRUE;

-      break;

-   case GL_ADD:

-      legal = ctx->Extensions.EXT_texture_env_add;

-      break;

-   case GL_COMBINE:

-      legal = (ctx->Extensions.EXT_texture_env_combine ||

-               ctx->Extensions.ARB_texture_env_combine);

-      break;

-   case GL_COMBINE4_NV:

-      legal = ctx->Extensions.NV_texture_env_combine4;

-      break;

-   default:

-      legal = GL_FALSE;

-   }

-

-   if (legal) {

-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);

-      texUnit->EnvMode = mode;

-   }

-   else {

-      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);

-   }

-}

-

-

-static void

-set_env_color(struct gl_context *ctx,

-              struct gl_texture_unit *texUnit,

-              const GLfloat *color)

-{

-   GLfloat tmp[4];

-   tmp[0] = CLAMP(color[0], 0.0F, 1.0F);

-   tmp[1] = CLAMP(color[1], 0.0F, 1.0F);

-   tmp[2] = CLAMP(color[2], 0.0F, 1.0F);

-   tmp[3] = CLAMP(color[3], 0.0F, 1.0F);

-   if (TEST_EQ_4V(tmp, texUnit->EnvColor))

-      return;

-   FLUSH_VERTICES(ctx, _NEW_TEXTURE);

-   COPY_4FV(texUnit->EnvColor, tmp);

-}

-

-

-/** Set an RGB or A combiner mode/function */

-static void

-set_combiner_mode(struct gl_context *ctx,

-                  struct gl_texture_unit *texUnit,

-                  GLenum pname, GLenum mode)

-{

-   GLboolean legal;

-

-   if (!ctx->Extensions.EXT_texture_env_combine &&

-       !ctx->Extensions.ARB_texture_env_combine) {

-      _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");

-      return;

-   }

-

-   switch (mode) {

-   case GL_REPLACE:

-   case GL_MODULATE:

-   case GL_ADD:

-   case GL_ADD_SIGNED:

-   case GL_INTERPOLATE:

-      legal = GL_TRUE;

-      break;

-   case GL_SUBTRACT:

-      legal = ctx->Extensions.ARB_texture_env_combine;

-      break;

-   case GL_DOT3_RGB_EXT:

-   case GL_DOT3_RGBA_EXT:

-      legal = (ctx->Extensions.EXT_texture_env_dot3 &&

-               pname == GL_COMBINE_RGB);

-      break;

-   case GL_DOT3_RGB:

-   case GL_DOT3_RGBA:

-      legal = (ctx->Extensions.ARB_texture_env_dot3 &&

-               pname == GL_COMBINE_RGB);

-      break;

-   case GL_MODULATE_ADD_ATI:

-   case GL_MODULATE_SIGNED_ADD_ATI:

-   case GL_MODULATE_SUBTRACT_ATI:

-      legal = ctx->Extensions.ATI_texture_env_combine3;

-      break;

-   case GL_BUMP_ENVMAP_ATI:

-      legal = (ctx->Extensions.ATI_envmap_bumpmap &&

-               pname == GL_COMBINE_RGB);

-      break;

-   default:

-      legal = GL_FALSE;

-   }

-

-   if (!legal) {

-      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);

-      return;

-   }

-

-   switch (pname) {

-   case GL_COMBINE_RGB:

-      if (texUnit->Combine.ModeRGB == mode)

-         return;

-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);

-      texUnit->Combine.ModeRGB = mode;

-      break;

-

-   case GL_COMBINE_ALPHA:

-      if (texUnit->Combine.ModeA == mode)

-         return;

-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);

-      texUnit->Combine.ModeA = mode;

-      break;

-   default:

-      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);

-   }

-}

-

-

-

-/** Set an RGB or A combiner source term */

-static void

-set_combiner_source(struct gl_context *ctx,

-                    struct gl_texture_unit *texUnit,

-                    GLenum pname, GLenum param)

-{

-   GLuint term;

-   GLboolean alpha, legal;

-

-   if (!ctx->Extensions.EXT_texture_env_combine &&

-       !ctx->Extensions.ARB_texture_env_combine) {

-      _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");

-      return;

-   }

-

-   /*

-    * Translate pname to (term, alpha).

-    *

-    * The enums were given sequential values for a reason.

-    */

-   switch (pname) {

-   case GL_SOURCE0_RGB:

-   case GL_SOURCE1_RGB:

-   case GL_SOURCE2_RGB:

-   case GL_SOURCE3_RGB_NV:

-      term = pname - GL_SOURCE0_RGB;

-      alpha = GL_FALSE;

-      break;

-   case GL_SOURCE0_ALPHA:

-   case GL_SOURCE1_ALPHA:

-   case GL_SOURCE2_ALPHA:

-   case GL_SOURCE3_ALPHA_NV:

-      term = pname - GL_SOURCE0_ALPHA;

-      alpha = GL_TRUE;

-      break;

-   default:

-      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);

-      return;

-   }

-

-   if ((term == 3) && !ctx->Extensions.NV_texture_env_combine4) {

-      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);

-      return;

-   }

-

-   assert(term < MAX_COMBINER_TERMS);

-

-   /*

-    * Error-check param (the source term)

-    */

-   switch (param) {

-   case GL_TEXTURE:

-   case GL_CONSTANT:

-   case GL_PRIMARY_COLOR:

-   case GL_PREVIOUS:

-      legal = GL_TRUE;

-      break;

-   case GL_TEXTURE0:

-   case GL_TEXTURE1:

-   case GL_TEXTURE2:

-   case GL_TEXTURE3:

-   case GL_TEXTURE4:

-   case GL_TEXTURE5:

-   case GL_TEXTURE6:

-   case GL_TEXTURE7:

-      legal = (ctx->Extensions.ARB_texture_env_crossbar &&

-               param - GL_TEXTURE0 < ctx->Const.MaxTextureUnits);

-      break;

-   case GL_ZERO:

-      legal = (ctx->Extensions.ATI_texture_env_combine3 ||

-               ctx->Extensions.NV_texture_env_combine4);

-      break;

-   case GL_ONE:

-      legal = ctx->Extensions.ATI_texture_env_combine3;

-      break;

-   default:

-      legal = GL_FALSE;

-   }

-

-   if (!legal) {

-      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", param);

-      return;

-   }

-

-   FLUSH_VERTICES(ctx, _NEW_TEXTURE);

-

-   if (alpha)

-      texUnit->Combine.SourceA[term] = param;

-   else

-      texUnit->Combine.SourceRGB[term] = param;

-}

-

-

-/** Set an RGB or A combiner operand term */

-static void

-set_combiner_operand(struct gl_context *ctx,

-                     struct gl_texture_unit *texUnit,

-                     GLenum pname, GLenum param)

-{

-   GLuint term;

-   GLboolean alpha, legal;

-

-   if (!ctx->Extensions.EXT_texture_env_combine &&

-       !ctx->Extensions.ARB_texture_env_combine) {

-      _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");

-      return;

-   }

-

-   /* The enums were given sequential values for a reason.

-    */

-   switch (pname) {

-   case GL_OPERAND0_RGB:

-   case GL_OPERAND1_RGB:

-   case GL_OPERAND2_RGB:

-   case GL_OPERAND3_RGB_NV:

-      term = pname - GL_OPERAND0_RGB;

-      alpha = GL_FALSE;

-      break;

-   case GL_OPERAND0_ALPHA:

-   case GL_OPERAND1_ALPHA:

-   case GL_OPERAND2_ALPHA:

-   case GL_OPERAND3_ALPHA_NV:

-      term = pname - GL_OPERAND0_ALPHA;

-      alpha = GL_TRUE;

-      break;

-   default:

-      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);

-      return;

-   }

-

-   if ((term == 3) && !ctx->Extensions.NV_texture_env_combine4) {

-      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);

-      return;

-   }

-

-   assert(term < MAX_COMBINER_TERMS);

-

-   /*

-    * Error-check param (the source operand)

-    */

-   switch (param) {

-   case GL_SRC_COLOR:

-   case GL_ONE_MINUS_SRC_COLOR:

-      /* The color input can only be used with GL_OPERAND[01]_RGB in the EXT

-       * version.  In the ARB and NV versions they can be used for any RGB

-       * operand.

-       */

-      legal = !alpha

-	 && ((term < 2) || ctx->Extensions.ARB_texture_env_combine

-	     || ctx->Extensions.NV_texture_env_combine4);

-      break;

-   case GL_ONE_MINUS_SRC_ALPHA:

-      /* GL_ONE_MINUS_SRC_ALPHA can only be used with

-       * GL_OPERAND[01]_(RGB|ALPHA) in the EXT version.  In the ARB and NV

-       * versions it can be used for any operand.

-       */

-      legal = (term < 2) || ctx->Extensions.ARB_texture_env_combine

-	 || ctx->Extensions.NV_texture_env_combine4;

-      break;

-   case GL_SRC_ALPHA:

-      legal = GL_TRUE;

-      break;

-   default:

-      legal = GL_FALSE;

-   }

-

-   if (!legal) {

-      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", param);

-      return;

-   }

-

-   FLUSH_VERTICES(ctx, _NEW_TEXTURE);

-

-   if (alpha)

-      texUnit->Combine.OperandA[term] = param;

-   else

-      texUnit->Combine.OperandRGB[term] = param;

-}

-

-

-static void

-set_combiner_scale(struct gl_context *ctx,

-                   struct gl_texture_unit *texUnit,

-                   GLenum pname, GLfloat scale)

-{

-   GLuint shift;

-

-   if (!ctx->Extensions.EXT_texture_env_combine &&

-       !ctx->Extensions.ARB_texture_env_combine) {

-      _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");

-      return;

-   }

-

-   if (scale == 1.0F) {

-      shift = 0;

-   }

-   else if (scale == 2.0F) {

-      shift = 1;

-   }

-   else if (scale == 4.0F) {

-      shift = 2;

-   }

-   else {

-      _mesa_error( ctx, GL_INVALID_VALUE,

-                   "glTexEnv(GL_RGB_SCALE not 1, 2 or 4)" );

-      return;

-   }

-

-   switch (pname) {

-   case GL_RGB_SCALE:

-      if (texUnit->Combine.ScaleShiftRGB == shift)

-         return;

-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);

-      texUnit->Combine.ScaleShiftRGB = shift;

-      break;

-   case GL_ALPHA_SCALE:

-      if (texUnit->Combine.ScaleShiftA == shift)

-         return;

-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);

-      texUnit->Combine.ScaleShiftA = shift;

-      break;

-   default:

-      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);

-   }

-}

-

-

-

-void GLAPIENTRY

-_mesa_TexEnvfv( GLenum target, GLenum pname, const GLfloat *param )

-{

-   const GLint iparam0 = (GLint) param[0];

-   struct gl_texture_unit *texUnit;

-   GLuint maxUnit;

-

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   maxUnit = (target == GL_POINT_SPRITE_NV && pname == GL_COORD_REPLACE_NV)

-      ? ctx->Const.MaxTextureCoordUnits : ctx->Const.MaxTextureImageUnits;

-   if (ctx->Texture.CurrentUnit >= maxUnit) {

-      _mesa_error(ctx, GL_INVALID_OPERATION, "glTexEnvfv(current unit)");

-      return;

-   }

-

-   texUnit = _mesa_get_current_tex_unit(ctx);

-

-   if (target == GL_TEXTURE_ENV) {

-      switch (pname) {

-      case GL_TEXTURE_ENV_MODE:

-         set_env_mode(ctx, texUnit, (GLenum) iparam0);

-         break;

-      case GL_TEXTURE_ENV_COLOR:

-         set_env_color(ctx, texUnit, param);

-         break;

-      case GL_COMBINE_RGB:

-      case GL_COMBINE_ALPHA:

-         set_combiner_mode(ctx, texUnit, pname, (GLenum) iparam0);

-	 break;

-      case GL_SOURCE0_RGB:

-      case GL_SOURCE1_RGB:

-      case GL_SOURCE2_RGB:

-      case GL_SOURCE3_RGB_NV:

-      case GL_SOURCE0_ALPHA:

-      case GL_SOURCE1_ALPHA:

-      case GL_SOURCE2_ALPHA:

-      case GL_SOURCE3_ALPHA_NV:

-         set_combiner_source(ctx, texUnit, pname, (GLenum) iparam0);

-	 break;

-      case GL_OPERAND0_RGB:

-      case GL_OPERAND1_RGB:

-      case GL_OPERAND2_RGB:

-      case GL_OPERAND3_RGB_NV:

-      case GL_OPERAND0_ALPHA:

-      case GL_OPERAND1_ALPHA:

-      case GL_OPERAND2_ALPHA:

-      case GL_OPERAND3_ALPHA_NV:

-         set_combiner_operand(ctx, texUnit, pname, (GLenum) iparam0);

-	 break;

-      case GL_RGB_SCALE:

-      case GL_ALPHA_SCALE:

-         set_combiner_scale(ctx, texUnit, pname, param[0]);

-	 break;

-      case GL_BUMP_TARGET_ATI:

-         if (!ctx->Extensions.ATI_envmap_bumpmap) {

-	    _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname=0x%x)", pname );

-	    return;

-	 }

-	 if ((iparam0 < GL_TEXTURE0) ||

-             (iparam0 > GL_TEXTURE31)) {

-	    /* spec doesn't say this but it seems logical */

-	    _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(param=0x%x)", iparam0);

-	    return;

-	 }

-	 if (!((1 << (iparam0 - GL_TEXTURE0)) & ctx->Const.SupportedBumpUnits)) {

-	    _mesa_error( ctx, GL_INVALID_VALUE, "glTexEnv(param=0x%x)", iparam0);

-	    return;

-	 }

-	 else {

-	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);

-	    texUnit->BumpTarget = iparam0;

-	 }

-	 break;

-      default:

-	 _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname)" );

-	 return;

-      }

-   }

-   else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {

-      /* GL_EXT_texture_lod_bias */

-      if (!ctx->Extensions.EXT_texture_lod_bias) {

-	 _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(target=0x%x)", target );

-	 return;

-      }

-      if (pname == GL_TEXTURE_LOD_BIAS_EXT) {

-	 if (texUnit->LodBias == param[0])

-	    return;

-	 FLUSH_VERTICES(ctx, _NEW_TEXTURE);

-         texUnit->LodBias = param[0];

-      }

-      else {

-         TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);

-	 return;

-      }

-   }

-   else if (target == GL_POINT_SPRITE_NV) {

-      /* GL_ARB_point_sprite / GL_NV_point_sprite */

-      if (!ctx->Extensions.NV_point_sprite

-	  && !ctx->Extensions.ARB_point_sprite) {

-	 _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(target=0x%x)", target );

-	 return;

-      }

-      if (pname == GL_COORD_REPLACE_NV) {

-         if (iparam0 == GL_TRUE || iparam0 == GL_FALSE) {

-            /* It's kind of weird to set point state via glTexEnv,

-             * but that's what the spec calls for.

-             */

-            const GLboolean state = (GLboolean) iparam0;

-            if (ctx->Point.CoordReplace[ctx->Texture.CurrentUnit] == state)

-               return;

-            FLUSH_VERTICES(ctx, _NEW_POINT);

-            ctx->Point.CoordReplace[ctx->Texture.CurrentUnit] = state;

-         }

-         else {

-            _mesa_error( ctx, GL_INVALID_VALUE, "glTexEnv(param=0x%x)", iparam0);

-            return;

-         }

-      }

-      else {

-         _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname=0x%x)", pname );

-         return;

-      }

-   }

-   else {

-      _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(target=0x%x)",target );

-      return;

-   }

-

-   if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))

-      _mesa_debug(ctx, "glTexEnv %s %s %.1f(%s) ...\n",

-                  _mesa_lookup_enum_by_nr(target),

-                  _mesa_lookup_enum_by_nr(pname),

-                  *param,

-                  _mesa_lookup_enum_by_nr((GLenum) iparam0));

-

-   /* Tell device driver about the new texture environment */

-   if (ctx->Driver.TexEnv) {

-      (*ctx->Driver.TexEnv)( ctx, target, pname, param );

-   }

-}

-

-

-void GLAPIENTRY

-_mesa_TexEnvf( GLenum target, GLenum pname, GLfloat param )

-{

-   GLfloat p[4];

-   p[0] = param;

-   p[1] = p[2] = p[3] = 0.0;

-   _mesa_TexEnvfv( target, pname, p );

-}

-

-

-

-void GLAPIENTRY

-_mesa_TexEnvi( GLenum target, GLenum pname, GLint param )

-{

-   GLfloat p[4];

-   p[0] = (GLfloat) param;

-   p[1] = p[2] = p[3] = 0.0;

-   _mesa_TexEnvfv( target, pname, p );

-}

-

-

-void GLAPIENTRY

-_mesa_TexEnviv( GLenum target, GLenum pname, const GLint *param )

-{

-   GLfloat p[4];

-   if (pname == GL_TEXTURE_ENV_COLOR) {

-      p[0] = INT_TO_FLOAT( param[0] );

-      p[1] = INT_TO_FLOAT( param[1] );

-      p[2] = INT_TO_FLOAT( param[2] );

-      p[3] = INT_TO_FLOAT( param[3] );

-   }

-   else {

-      p[0] = (GLfloat) param[0];

-      p[1] = p[2] = p[3] = 0;  /* init to zero, just to be safe */

-   }

-   _mesa_TexEnvfv( target, pname, p );

-}

-

-

-

-/**

- * Helper for glGetTexEnvi/f()

- * \return  value of queried pname or -1 if error.

- */

-static GLint

-get_texenvi(struct gl_context *ctx, const struct gl_texture_unit *texUnit,

-            GLenum pname)

-{

-   switch (pname) {

-   case GL_TEXTURE_ENV_MODE:

-      return texUnit->EnvMode;

-      break;

-   case GL_COMBINE_RGB:

-      if (ctx->Extensions.EXT_texture_env_combine ||

-          ctx->Extensions.ARB_texture_env_combine) {

-         return texUnit->Combine.ModeRGB;

-      }

-      else {

-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");

-      }

-      break;

-   case GL_COMBINE_ALPHA:

-      if (ctx->Extensions.EXT_texture_env_combine ||

-          ctx->Extensions.ARB_texture_env_combine) {

-         return texUnit->Combine.ModeA;

-      }

-      else {

-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");

-      }

-      break;

-   case GL_SOURCE0_RGB:

-   case GL_SOURCE1_RGB:

-   case GL_SOURCE2_RGB:

-      if (ctx->Extensions.EXT_texture_env_combine ||

-          ctx->Extensions.ARB_texture_env_combine) {

-         const unsigned rgb_idx = pname - GL_SOURCE0_RGB;

-         return texUnit->Combine.SourceRGB[rgb_idx];

-      }

-      else {

-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");

-      }

-      break;

-   case GL_SOURCE3_RGB_NV:

-      if (ctx->Extensions.NV_texture_env_combine4) {

-         return texUnit->Combine.SourceRGB[3];

-      }

-      else {

-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");

-      }

-      break;

-   case GL_SOURCE0_ALPHA:

-   case GL_SOURCE1_ALPHA:

-   case GL_SOURCE2_ALPHA:

-      if (ctx->Extensions.EXT_texture_env_combine ||

-          ctx->Extensions.ARB_texture_env_combine) {

-         const unsigned alpha_idx = pname - GL_SOURCE0_ALPHA;

-         return texUnit->Combine.SourceA[alpha_idx];

-      }

-      else {

-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");

-      }

-      break;

-   case GL_SOURCE3_ALPHA_NV:

-      if (ctx->Extensions.NV_texture_env_combine4) {

-         return texUnit->Combine.SourceA[3];

-      }

-      else {

-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");

-      }

-      break;

-   case GL_OPERAND0_RGB:

-   case GL_OPERAND1_RGB:

-   case GL_OPERAND2_RGB:

-      if (ctx->Extensions.EXT_texture_env_combine ||

-          ctx->Extensions.ARB_texture_env_combine) {

-         const unsigned op_rgb = pname - GL_OPERAND0_RGB;

-         return texUnit->Combine.OperandRGB[op_rgb];

-      }

-      else {

-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");

-      }

-      break;

-   case GL_OPERAND3_RGB_NV:

-      if (ctx->Extensions.NV_texture_env_combine4) {

-         return texUnit->Combine.OperandRGB[3];

-      }

-      else {

-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");

-      }

-      break;

-   case GL_OPERAND0_ALPHA:

-   case GL_OPERAND1_ALPHA:

-   case GL_OPERAND2_ALPHA:

-      if (ctx->Extensions.EXT_texture_env_combine ||

-          ctx->Extensions.ARB_texture_env_combine) {

-         const unsigned op_alpha = pname - GL_OPERAND0_ALPHA;

-         return texUnit->Combine.OperandA[op_alpha];

-      }

-      else {

-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");

-      }

-      break;

-   case GL_OPERAND3_ALPHA_NV:

-      if (ctx->Extensions.NV_texture_env_combine4) {

-         return texUnit->Combine.OperandA[3];

-      }

-      else {

-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");

-      }

-      break;

-   case GL_RGB_SCALE:

-      if (ctx->Extensions.EXT_texture_env_combine ||

-          ctx->Extensions.ARB_texture_env_combine) {

-         return 1 << texUnit->Combine.ScaleShiftRGB;

-      }

-      else {

-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");

-      }

-      break;

-   case GL_ALPHA_SCALE:

-      if (ctx->Extensions.EXT_texture_env_combine ||

-          ctx->Extensions.ARB_texture_env_combine) {

-         return 1 << texUnit->Combine.ScaleShiftA;

-      }

-      else {

-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");

-      }

-      break;

-   case GL_BUMP_TARGET_ATI:

-      /* spec doesn't say so, but I think this should be queryable */

-      if (ctx->Extensions.ATI_envmap_bumpmap) {

-         return texUnit->BumpTarget;

-      }

-      else {

-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");

-      }

-      break;

-

-   default:

-      ;

-   }

-

-   return -1; /* error */

-}

-

-

-

-void GLAPIENTRY

-_mesa_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )

-{

-   GLuint maxUnit;

-   const struct gl_texture_unit *texUnit;

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   maxUnit = (target == GL_POINT_SPRITE_NV && pname == GL_COORD_REPLACE_NV)

-      ? ctx->Const.MaxTextureCoordUnits : ctx->Const.MaxTextureImageUnits;

-   if (ctx->Texture.CurrentUnit >= maxUnit) {

-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexEnvfv(current unit)");

-      return;

-   }

-

-   texUnit = _mesa_get_current_tex_unit(ctx);

-

-   if (target == GL_TEXTURE_ENV) {

-      if (pname == GL_TEXTURE_ENV_COLOR) {

-         COPY_4FV( params, texUnit->EnvColor );

-      }

-      else {

-         GLint val = get_texenvi(ctx, texUnit, pname);

-         if (val >= 0) {

-            *params = (GLfloat) val;

-         }

-      }

-   }

-   else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {

-      /* GL_EXT_texture_lod_bias */

-      if (!ctx->Extensions.EXT_texture_lod_bias) {

-	 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );

-	 return;

-      }

-      if (pname == GL_TEXTURE_LOD_BIAS_EXT) {

-         *params = texUnit->LodBias;

-      }

-      else {

-         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );

-	 return;

-      }

-   }

-   else if (target == GL_POINT_SPRITE_NV) {

-      /* GL_ARB_point_sprite / GL_NV_point_sprite */

-      if (!ctx->Extensions.NV_point_sprite

-	  && !ctx->Extensions.ARB_point_sprite) {

-         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );

-         return;

-      }

-      if (pname == GL_COORD_REPLACE_NV) {

-         *params = (GLfloat) ctx->Point.CoordReplace[ctx->Texture.CurrentUnit];

-      }

-      else {

-         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );

-         return;

-      }

-   }

-   else {

-      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );

-      return;

-   }

-}

-

-

-void GLAPIENTRY

-_mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params )

-{

-   GLuint maxUnit;

-   const struct gl_texture_unit *texUnit;

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   maxUnit = (target == GL_POINT_SPRITE_NV && pname == GL_COORD_REPLACE_NV)

-      ? ctx->Const.MaxTextureCoordUnits : ctx->Const.MaxTextureImageUnits;

-   if (ctx->Texture.CurrentUnit >= maxUnit) {

-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexEnviv(current unit)");

-      return;

-   }

-

-   texUnit = _mesa_get_current_tex_unit(ctx);

-

-   if (target == GL_TEXTURE_ENV) {

-      if (pname == GL_TEXTURE_ENV_COLOR) {

-         params[0] = FLOAT_TO_INT( texUnit->EnvColor[0] );

-         params[1] = FLOAT_TO_INT( texUnit->EnvColor[1] );

-         params[2] = FLOAT_TO_INT( texUnit->EnvColor[2] );

-         params[3] = FLOAT_TO_INT( texUnit->EnvColor[3] );

-      }

-      else {

-         GLint val = get_texenvi(ctx, texUnit, pname);

-         if (val >= 0) {

-            *params = val;

-         }

-      }

-   }

-   else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {

-      /* GL_EXT_texture_lod_bias */

-      if (!ctx->Extensions.EXT_texture_lod_bias) {

-	 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );

-	 return;

-      }

-      if (pname == GL_TEXTURE_LOD_BIAS_EXT) {

-         *params = (GLint) texUnit->LodBias;

-      }

-      else {

-         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );

-	 return;

-      }

-   }

-   else if (target == GL_POINT_SPRITE_NV) {

-      /* GL_ARB_point_sprite / GL_NV_point_sprite */

-      if (!ctx->Extensions.NV_point_sprite

-	  && !ctx->Extensions.ARB_point_sprite) {

-         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );

-         return;

-      }

-      if (pname == GL_COORD_REPLACE_NV) {

-         *params = (GLint) ctx->Point.CoordReplace[ctx->Texture.CurrentUnit];

-      }

-      else {

-         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );

-         return;

-      }

-   }

-   else {

-      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );

-      return;

-   }

-}

-

-

-/**

- * Why does ATI_envmap_bumpmap require new entrypoints? Should just

- * reuse TexEnv ones...

- */

-void GLAPIENTRY

-_mesa_TexBumpParameterivATI( GLenum pname, const GLint *param )

-{

-   GLfloat p[4];

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   if (!ctx->Extensions.ATI_envmap_bumpmap) {

-      /* This isn't an "official" error case, but let's tell the user

-       * that something's wrong.

-       */

-      _mesa_error(ctx, GL_INVALID_OPERATION, "glTexBumpParameterivATI");

-      return;

-   }

-

-   if (pname == GL_BUMP_ROT_MATRIX_ATI) {

-      /* hope that conversion is correct here */

-      p[0] = INT_TO_FLOAT( param[0] );

-      p[1] = INT_TO_FLOAT( param[1] );

-      p[2] = INT_TO_FLOAT( param[2] );

-      p[3] = INT_TO_FLOAT( param[3] );

-   }

-   else {

-      p[0] = (GLfloat) param[0];

-      p[1] = p[2] = p[3] = 0.0F;  /* init to zero, just to be safe */

-   }

-   _mesa_TexBumpParameterfvATI( pname, p );

-}

-

-

-void GLAPIENTRY

-_mesa_TexBumpParameterfvATI( GLenum pname, const GLfloat *param )

-{

-   struct gl_texture_unit *texUnit;

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   if (!ctx->Extensions.ATI_envmap_bumpmap) {

-      _mesa_error(ctx, GL_INVALID_OPERATION, "glTexBumpParameterfvATI");

-      return;

-   }

-

-   texUnit = _mesa_get_current_tex_unit(ctx);

-

-   if (pname == GL_BUMP_ROT_MATRIX_ATI) {

-      if (TEST_EQ_4V(param, texUnit->RotMatrix))

-         return;

-      FLUSH_VERTICES(ctx, _NEW_TEXTURE);

-      COPY_4FV(texUnit->RotMatrix, param);

-   }

-   else {

-      _mesa_error( ctx, GL_INVALID_ENUM, "glTexBumpParameter(pname)" );

-      return;

-   }

-   /* Drivers might want to know about this, instead of dedicated function

-      just shove it into TexEnv where it really belongs anyway */

-   if (ctx->Driver.TexEnv) {

-      (*ctx->Driver.TexEnv)( ctx, 0, pname, param );

-   }

-}

-

-

-void GLAPIENTRY

-_mesa_GetTexBumpParameterivATI( GLenum pname, GLint *param )

-{

-   const struct gl_texture_unit *texUnit;

-   GLuint i;

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   if (!ctx->Extensions.ATI_envmap_bumpmap) {

-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexBumpParameterivATI");

-      return;

-   }

-

-   texUnit = _mesa_get_current_tex_unit(ctx);

-

-   if (pname == GL_BUMP_ROT_MATRIX_SIZE_ATI) {

-      /* spec leaves open to support larger matrices.

-         Don't think anyone would ever want to use it

-         (and apps almost certainly would not understand it and

-         thus fail to submit matrices correctly) so hardcode this. */

-      *param = 4;

-   }

-   else if (pname == GL_BUMP_ROT_MATRIX_ATI) {

-      /* hope that conversion is correct here */

-      param[0] = FLOAT_TO_INT(texUnit->RotMatrix[0]);

-      param[1] = FLOAT_TO_INT(texUnit->RotMatrix[1]);

-      param[2] = FLOAT_TO_INT(texUnit->RotMatrix[2]);

-      param[3] = FLOAT_TO_INT(texUnit->RotMatrix[3]);

-   }

-   else if (pname == GL_BUMP_NUM_TEX_UNITS_ATI) {

-      GLint count = 0;

-      for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {

-         if (ctx->Const.SupportedBumpUnits & (1 << i)) {

-            count++;

-         }

-      }

-      *param = count;

-   }

-   else if (pname == GL_BUMP_TEX_UNITS_ATI) {

-      for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {

-         if (ctx->Const.SupportedBumpUnits & (1 << i)) {

-            *param++ = i + GL_TEXTURE0;

-         }

-      }

-   }

-   else {

-      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexBumpParameter(pname)" );

-      return;

-   }

-}

-

-

-void GLAPIENTRY

-_mesa_GetTexBumpParameterfvATI( GLenum pname, GLfloat *param )

-{

-   const struct gl_texture_unit *texUnit;

-   GLuint i;

-   GET_CURRENT_CONTEXT(ctx);

-   ASSERT_OUTSIDE_BEGIN_END(ctx);

-

-   if (!ctx->Extensions.ATI_envmap_bumpmap) {

-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexBumpParameterfvATI");

-      return;

-   }

-

-   texUnit = _mesa_get_current_tex_unit(ctx);

-

-   if (pname == GL_BUMP_ROT_MATRIX_SIZE_ATI) {

-      /* spec leaves open to support larger matrices.

-         Don't think anyone would ever want to use it

-         (and apps might not understand it) so hardcode this. */

-      *param = 4.0F;

-   }

-   else if (pname == GL_BUMP_ROT_MATRIX_ATI) {

-      param[0] = texUnit->RotMatrix[0];

-      param[1] = texUnit->RotMatrix[1];

-      param[2] = texUnit->RotMatrix[2];

-      param[3] = texUnit->RotMatrix[3];

-   }

-   else if (pname == GL_BUMP_NUM_TEX_UNITS_ATI) {

-      GLint count = 0;

-      for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {

-         if (ctx->Const.SupportedBumpUnits & (1 << i)) {

-            count++;

-         }

-      }

-      *param = (GLfloat) count;

-   }

-   else if (pname == GL_BUMP_TEX_UNITS_ATI) {

-      for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {

-         if (ctx->Const.SupportedBumpUnits & (1 << i)) {

-            *param++ = (GLfloat) (i + GL_TEXTURE0);

-         }

-      }

-   }

-   else {

-      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexBumpParameter(pname)" );

-      return;

-   }

-}

+/*
+ * Mesa 3-D graphics library
+ * Version:  7.5
+ *
+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009  VMware, Inc.  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.
+ */
+
+/** 
+ * \file texenv.c
+ *
+ * glTexEnv-related functions
+ */
+
+
+#include "main/glheader.h"
+#include "main/context.h"
+#include "main/enums.h"
+#include "main/macros.h"
+#include "main/mtypes.h"
+#include "main/state.h"
+#include "main/texenv.h"
+#include "main/texstate.h"
+
+
+#define TE_ERROR(errCode, msg, value)				\
+   _mesa_error(ctx, errCode, msg, _mesa_lookup_enum_by_nr(value));
+
+
+/** Set texture env mode */
+static void
+set_env_mode(struct gl_context *ctx,
+             struct gl_texture_unit *texUnit,
+             GLenum mode)
+{
+   GLboolean legal;
+
+   if (texUnit->EnvMode == mode)
+      return;
+
+   switch (mode) {
+   case GL_MODULATE:
+   case GL_BLEND:
+   case GL_DECAL:
+   case GL_REPLACE:
+      legal = GL_TRUE;
+      break;
+   case GL_REPLACE_EXT:
+      mode = GL_REPLACE; /* GL_REPLACE_EXT != GL_REPLACE */
+      legal = GL_TRUE;
+      break;
+   case GL_ADD:
+      legal = ctx->Extensions.EXT_texture_env_add;
+      break;
+   case GL_COMBINE:
+      legal = (ctx->Extensions.EXT_texture_env_combine ||
+               ctx->Extensions.ARB_texture_env_combine);
+      break;
+   case GL_COMBINE4_NV:
+      legal = ctx->Extensions.NV_texture_env_combine4;
+      break;
+   default:
+      legal = GL_FALSE;
+   }
+
+   if (legal) {
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      texUnit->EnvMode = mode;
+   }
+   else {
+      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
+   }
+}
+
+
+static void
+set_env_color(struct gl_context *ctx,
+              struct gl_texture_unit *texUnit,
+              const GLfloat *color)
+{
+   if (TEST_EQ_4V(color, texUnit->EnvColorUnclamped))
+      return;
+   FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+   COPY_4FV(texUnit->EnvColorUnclamped, color);
+   texUnit->EnvColor[0] = CLAMP(color[0], 0.0F, 1.0F);
+   texUnit->EnvColor[1] = CLAMP(color[1], 0.0F, 1.0F);
+   texUnit->EnvColor[2] = CLAMP(color[2], 0.0F, 1.0F);
+   texUnit->EnvColor[3] = CLAMP(color[3], 0.0F, 1.0F);
+}
+
+
+/** Set an RGB or A combiner mode/function */
+static void
+set_combiner_mode(struct gl_context *ctx,
+                  struct gl_texture_unit *texUnit,
+                  GLenum pname, GLenum mode)
+{
+   GLboolean legal;
+
+   if (!ctx->Extensions.EXT_texture_env_combine &&
+       !ctx->Extensions.ARB_texture_env_combine) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");
+      return;
+   }
+
+   switch (mode) {
+   case GL_REPLACE:
+   case GL_MODULATE:
+   case GL_ADD:
+   case GL_ADD_SIGNED:
+   case GL_INTERPOLATE:
+      legal = GL_TRUE;
+      break;
+   case GL_SUBTRACT:
+      legal = ctx->Extensions.ARB_texture_env_combine;
+      break;
+   case GL_DOT3_RGB_EXT:
+   case GL_DOT3_RGBA_EXT:
+      legal = (ctx->Extensions.EXT_texture_env_dot3 &&
+               pname == GL_COMBINE_RGB);
+      break;
+   case GL_DOT3_RGB:
+   case GL_DOT3_RGBA:
+      legal = (ctx->Extensions.ARB_texture_env_dot3 &&
+               pname == GL_COMBINE_RGB);
+      break;
+   case GL_MODULATE_ADD_ATI:
+   case GL_MODULATE_SIGNED_ADD_ATI:
+   case GL_MODULATE_SUBTRACT_ATI:
+      legal = ctx->Extensions.ATI_texture_env_combine3;
+      break;
+   case GL_BUMP_ENVMAP_ATI:
+      legal = (ctx->Extensions.ATI_envmap_bumpmap &&
+               pname == GL_COMBINE_RGB);
+      break;
+   default:
+      legal = GL_FALSE;
+   }
+
+   if (!legal) {
+      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
+      return;
+   }
+
+   switch (pname) {
+   case GL_COMBINE_RGB:
+      if (texUnit->Combine.ModeRGB == mode)
+         return;
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      texUnit->Combine.ModeRGB = mode;
+      break;
+
+   case GL_COMBINE_ALPHA:
+      if (texUnit->Combine.ModeA == mode)
+         return;
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      texUnit->Combine.ModeA = mode;
+      break;
+   default:
+      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+   }
+}
+
+
+
+/** Set an RGB or A combiner source term */
+static void
+set_combiner_source(struct gl_context *ctx,
+                    struct gl_texture_unit *texUnit,
+                    GLenum pname, GLenum param)
+{
+   GLuint term;
+   GLboolean alpha, legal;
+
+   if (!ctx->Extensions.EXT_texture_env_combine &&
+       !ctx->Extensions.ARB_texture_env_combine) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");
+      return;
+   }
+
+   /*
+    * Translate pname to (term, alpha).
+    *
+    * The enums were given sequential values for a reason.
+    */
+   switch (pname) {
+   case GL_SOURCE0_RGB:
+   case GL_SOURCE1_RGB:
+   case GL_SOURCE2_RGB:
+   case GL_SOURCE3_RGB_NV:
+      term = pname - GL_SOURCE0_RGB;
+      alpha = GL_FALSE;
+      break;
+   case GL_SOURCE0_ALPHA:
+   case GL_SOURCE1_ALPHA:
+   case GL_SOURCE2_ALPHA:
+   case GL_SOURCE3_ALPHA_NV:
+      term = pname - GL_SOURCE0_ALPHA;
+      alpha = GL_TRUE;
+      break;
+   default:
+      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+      return;
+   }
+
+   if ((term == 3) && !ctx->Extensions.NV_texture_env_combine4) {
+      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+      return;
+   }
+
+   assert(term < MAX_COMBINER_TERMS);
+
+   /*
+    * Error-check param (the source term)
+    */
+   switch (param) {
+   case GL_TEXTURE:
+   case GL_CONSTANT:
+   case GL_PRIMARY_COLOR:
+   case GL_PREVIOUS:
+      legal = GL_TRUE;
+      break;
+   case GL_TEXTURE0:
+   case GL_TEXTURE1:
+   case GL_TEXTURE2:
+   case GL_TEXTURE3:
+   case GL_TEXTURE4:
+   case GL_TEXTURE5:
+   case GL_TEXTURE6:
+   case GL_TEXTURE7:
+      legal = (ctx->Extensions.ARB_texture_env_crossbar &&
+               param - GL_TEXTURE0 < ctx->Const.MaxTextureUnits);
+      break;
+   case GL_ZERO:
+      legal = (ctx->Extensions.ATI_texture_env_combine3 ||
+               ctx->Extensions.NV_texture_env_combine4);
+      break;
+   case GL_ONE:
+      legal = ctx->Extensions.ATI_texture_env_combine3;
+      break;
+   default:
+      legal = GL_FALSE;
+   }
+
+   if (!legal) {
+      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", param);
+      return;
+   }
+
+   FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+
+   if (alpha)
+      texUnit->Combine.SourceA[term] = param;
+   else
+      texUnit->Combine.SourceRGB[term] = param;
+}
+
+
+/** Set an RGB or A combiner operand term */
+static void
+set_combiner_operand(struct gl_context *ctx,
+                     struct gl_texture_unit *texUnit,
+                     GLenum pname, GLenum param)
+{
+   GLuint term;
+   GLboolean alpha, legal;
+
+   if (!ctx->Extensions.EXT_texture_env_combine &&
+       !ctx->Extensions.ARB_texture_env_combine) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");
+      return;
+   }
+
+   /* The enums were given sequential values for a reason.
+    */
+   switch (pname) {
+   case GL_OPERAND0_RGB:
+   case GL_OPERAND1_RGB:
+   case GL_OPERAND2_RGB:
+   case GL_OPERAND3_RGB_NV:
+      term = pname - GL_OPERAND0_RGB;
+      alpha = GL_FALSE;
+      break;
+   case GL_OPERAND0_ALPHA:
+   case GL_OPERAND1_ALPHA:
+   case GL_OPERAND2_ALPHA:
+   case GL_OPERAND3_ALPHA_NV:
+      term = pname - GL_OPERAND0_ALPHA;
+      alpha = GL_TRUE;
+      break;
+   default:
+      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+      return;
+   }
+
+   if ((term == 3) && !ctx->Extensions.NV_texture_env_combine4) {
+      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+      return;
+   }
+
+   assert(term < MAX_COMBINER_TERMS);
+
+   /*
+    * Error-check param (the source operand)
+    */
+   switch (param) {
+   case GL_SRC_COLOR:
+   case GL_ONE_MINUS_SRC_COLOR:
+      /* The color input can only be used with GL_OPERAND[01]_RGB in the EXT
+       * version.  In the ARB and NV versions they can be used for any RGB
+       * operand.
+       */
+      legal = !alpha
+	 && ((term < 2) || ctx->Extensions.ARB_texture_env_combine
+	     || ctx->Extensions.NV_texture_env_combine4);
+      break;
+   case GL_ONE_MINUS_SRC_ALPHA:
+      /* GL_ONE_MINUS_SRC_ALPHA can only be used with
+       * GL_OPERAND[01]_(RGB|ALPHA) in the EXT version.  In the ARB and NV
+       * versions it can be used for any operand.
+       */
+      legal = (term < 2) || ctx->Extensions.ARB_texture_env_combine
+	 || ctx->Extensions.NV_texture_env_combine4;
+      break;
+   case GL_SRC_ALPHA:
+      legal = GL_TRUE;
+      break;
+   default:
+      legal = GL_FALSE;
+   }
+
+   if (!legal) {
+      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", param);
+      return;
+   }
+
+   FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+
+   if (alpha)
+      texUnit->Combine.OperandA[term] = param;
+   else
+      texUnit->Combine.OperandRGB[term] = param;
+}
+
+
+static void
+set_combiner_scale(struct gl_context *ctx,
+                   struct gl_texture_unit *texUnit,
+                   GLenum pname, GLfloat scale)
+{
+   GLuint shift;
+
+   if (!ctx->Extensions.EXT_texture_env_combine &&
+       !ctx->Extensions.ARB_texture_env_combine) {
+      _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)");
+      return;
+   }
+
+   if (scale == 1.0F) {
+      shift = 0;
+   }
+   else if (scale == 2.0F) {
+      shift = 1;
+   }
+   else if (scale == 4.0F) {
+      shift = 2;
+   }
+   else {
+      _mesa_error( ctx, GL_INVALID_VALUE,
+                   "glTexEnv(GL_RGB_SCALE not 1, 2 or 4)" );
+      return;
+   }
+
+   switch (pname) {
+   case GL_RGB_SCALE:
+      if (texUnit->Combine.ScaleShiftRGB == shift)
+         return;
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      texUnit->Combine.ScaleShiftRGB = shift;
+      break;
+   case GL_ALPHA_SCALE:
+      if (texUnit->Combine.ScaleShiftA == shift)
+         return;
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      texUnit->Combine.ScaleShiftA = shift;
+      break;
+   default:
+      TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+   }
+}
+
+
+
+void GLAPIENTRY
+_mesa_TexEnvfv( GLenum target, GLenum pname, const GLfloat *param )
+{
+   const GLint iparam0 = (GLint) param[0];
+   struct gl_texture_unit *texUnit;
+   GLuint maxUnit;
+
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   maxUnit = (target == GL_POINT_SPRITE_NV && pname == GL_COORD_REPLACE_NV)
+      ? ctx->Const.MaxTextureCoordUnits : ctx->Const.MaxTextureImageUnits;
+   if (ctx->Texture.CurrentUnit >= maxUnit) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glTexEnvfv(current unit)");
+      return;
+   }
+
+   texUnit = _mesa_get_current_tex_unit(ctx);
+
+   if (target == GL_TEXTURE_ENV) {
+      switch (pname) {
+      case GL_TEXTURE_ENV_MODE:
+         set_env_mode(ctx, texUnit, (GLenum) iparam0);
+         break;
+      case GL_TEXTURE_ENV_COLOR:
+         set_env_color(ctx, texUnit, param);
+         break;
+      case GL_COMBINE_RGB:
+      case GL_COMBINE_ALPHA:
+         set_combiner_mode(ctx, texUnit, pname, (GLenum) iparam0);
+	 break;
+      case GL_SOURCE0_RGB:
+      case GL_SOURCE1_RGB:
+      case GL_SOURCE2_RGB:
+      case GL_SOURCE3_RGB_NV:
+      case GL_SOURCE0_ALPHA:
+      case GL_SOURCE1_ALPHA:
+      case GL_SOURCE2_ALPHA:
+      case GL_SOURCE3_ALPHA_NV:
+         set_combiner_source(ctx, texUnit, pname, (GLenum) iparam0);
+	 break;
+      case GL_OPERAND0_RGB:
+      case GL_OPERAND1_RGB:
+      case GL_OPERAND2_RGB:
+      case GL_OPERAND3_RGB_NV:
+      case GL_OPERAND0_ALPHA:
+      case GL_OPERAND1_ALPHA:
+      case GL_OPERAND2_ALPHA:
+      case GL_OPERAND3_ALPHA_NV:
+         set_combiner_operand(ctx, texUnit, pname, (GLenum) iparam0);
+	 break;
+      case GL_RGB_SCALE:
+      case GL_ALPHA_SCALE:
+         set_combiner_scale(ctx, texUnit, pname, param[0]);
+	 break;
+      case GL_BUMP_TARGET_ATI:
+         if (!ctx->Extensions.ATI_envmap_bumpmap) {
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname=0x%x)", pname );
+	    return;
+	 }
+	 if ((iparam0 < GL_TEXTURE0) ||
+             (iparam0 > GL_TEXTURE31)) {
+	    /* spec doesn't say this but it seems logical */
+	    _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(param=0x%x)", iparam0);
+	    return;
+	 }
+	 if (!((1 << (iparam0 - GL_TEXTURE0)) & ctx->Const.SupportedBumpUnits)) {
+	    _mesa_error( ctx, GL_INVALID_VALUE, "glTexEnv(param=0x%x)", iparam0);
+	    return;
+	 }
+	 else {
+	    FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+	    texUnit->BumpTarget = iparam0;
+	 }
+	 break;
+      default:
+	 _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname)" );
+	 return;
+      }
+   }
+   else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {
+      /* GL_EXT_texture_lod_bias */
+      if (!ctx->Extensions.EXT_texture_lod_bias) {
+	 _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(target=0x%x)", target );
+	 return;
+      }
+      if (pname == GL_TEXTURE_LOD_BIAS_EXT) {
+	 if (texUnit->LodBias == param[0])
+	    return;
+	 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+         texUnit->LodBias = param[0];
+      }
+      else {
+         TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
+	 return;
+      }
+   }
+   else if (target == GL_POINT_SPRITE_NV) {
+      /* GL_ARB_point_sprite / GL_NV_point_sprite */
+      if (!ctx->Extensions.NV_point_sprite
+	  && !ctx->Extensions.ARB_point_sprite) {
+	 _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(target=0x%x)", target );
+	 return;
+      }
+      if (pname == GL_COORD_REPLACE_NV) {
+         if (iparam0 == GL_TRUE || iparam0 == GL_FALSE) {
+            /* It's kind of weird to set point state via glTexEnv,
+             * but that's what the spec calls for.
+             */
+            const GLboolean state = (GLboolean) iparam0;
+            if (ctx->Point.CoordReplace[ctx->Texture.CurrentUnit] == state)
+               return;
+            FLUSH_VERTICES(ctx, _NEW_POINT);
+            ctx->Point.CoordReplace[ctx->Texture.CurrentUnit] = state;
+         }
+         else {
+            _mesa_error( ctx, GL_INVALID_VALUE, "glTexEnv(param=0x%x)", iparam0);
+            return;
+         }
+      }
+      else {
+         _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname=0x%x)", pname );
+         return;
+      }
+   }
+   else {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(target=0x%x)",target );
+      return;
+   }
+
+   if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
+      _mesa_debug(ctx, "glTexEnv %s %s %.1f(%s) ...\n",
+                  _mesa_lookup_enum_by_nr(target),
+                  _mesa_lookup_enum_by_nr(pname),
+                  *param,
+                  _mesa_lookup_enum_by_nr((GLenum) iparam0));
+
+   /* Tell device driver about the new texture environment */
+   if (ctx->Driver.TexEnv) {
+      (*ctx->Driver.TexEnv)( ctx, target, pname, param );
+   }
+}
+
+
+void GLAPIENTRY
+_mesa_TexEnvf( GLenum target, GLenum pname, GLfloat param )
+{
+   GLfloat p[4];
+   p[0] = param;
+   p[1] = p[2] = p[3] = 0.0;
+   _mesa_TexEnvfv( target, pname, p );
+}
+
+
+
+void GLAPIENTRY
+_mesa_TexEnvi( GLenum target, GLenum pname, GLint param )
+{
+   GLfloat p[4];
+   p[0] = (GLfloat) param;
+   p[1] = p[2] = p[3] = 0.0;
+   _mesa_TexEnvfv( target, pname, p );
+}
+
+
+void GLAPIENTRY
+_mesa_TexEnviv( GLenum target, GLenum pname, const GLint *param )
+{
+   GLfloat p[4];
+   if (pname == GL_TEXTURE_ENV_COLOR) {
+      p[0] = INT_TO_FLOAT( param[0] );
+      p[1] = INT_TO_FLOAT( param[1] );
+      p[2] = INT_TO_FLOAT( param[2] );
+      p[3] = INT_TO_FLOAT( param[3] );
+   }
+   else {
+      p[0] = (GLfloat) param[0];
+      p[1] = p[2] = p[3] = 0;  /* init to zero, just to be safe */
+   }
+   _mesa_TexEnvfv( target, pname, p );
+}
+
+
+
+/**
+ * Helper for glGetTexEnvi/f()
+ * \return  value of queried pname or -1 if error.
+ */
+static GLint
+get_texenvi(struct gl_context *ctx, const struct gl_texture_unit *texUnit,
+            GLenum pname)
+{
+   switch (pname) {
+   case GL_TEXTURE_ENV_MODE:
+      return texUnit->EnvMode;
+      break;
+   case GL_COMBINE_RGB:
+      if (ctx->Extensions.EXT_texture_env_combine ||
+          ctx->Extensions.ARB_texture_env_combine) {
+         return texUnit->Combine.ModeRGB;
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_COMBINE_ALPHA:
+      if (ctx->Extensions.EXT_texture_env_combine ||
+          ctx->Extensions.ARB_texture_env_combine) {
+         return texUnit->Combine.ModeA;
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_SOURCE0_RGB:
+   case GL_SOURCE1_RGB:
+   case GL_SOURCE2_RGB:
+      if (ctx->Extensions.EXT_texture_env_combine ||
+          ctx->Extensions.ARB_texture_env_combine) {
+         const unsigned rgb_idx = pname - GL_SOURCE0_RGB;
+         return texUnit->Combine.SourceRGB[rgb_idx];
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_SOURCE3_RGB_NV:
+      if (ctx->Extensions.NV_texture_env_combine4) {
+         return texUnit->Combine.SourceRGB[3];
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_SOURCE0_ALPHA:
+   case GL_SOURCE1_ALPHA:
+   case GL_SOURCE2_ALPHA:
+      if (ctx->Extensions.EXT_texture_env_combine ||
+          ctx->Extensions.ARB_texture_env_combine) {
+         const unsigned alpha_idx = pname - GL_SOURCE0_ALPHA;
+         return texUnit->Combine.SourceA[alpha_idx];
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_SOURCE3_ALPHA_NV:
+      if (ctx->Extensions.NV_texture_env_combine4) {
+         return texUnit->Combine.SourceA[3];
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_OPERAND0_RGB:
+   case GL_OPERAND1_RGB:
+   case GL_OPERAND2_RGB:
+      if (ctx->Extensions.EXT_texture_env_combine ||
+          ctx->Extensions.ARB_texture_env_combine) {
+         const unsigned op_rgb = pname - GL_OPERAND0_RGB;
+         return texUnit->Combine.OperandRGB[op_rgb];
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_OPERAND3_RGB_NV:
+      if (ctx->Extensions.NV_texture_env_combine4) {
+         return texUnit->Combine.OperandRGB[3];
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_OPERAND0_ALPHA:
+   case GL_OPERAND1_ALPHA:
+   case GL_OPERAND2_ALPHA:
+      if (ctx->Extensions.EXT_texture_env_combine ||
+          ctx->Extensions.ARB_texture_env_combine) {
+         const unsigned op_alpha = pname - GL_OPERAND0_ALPHA;
+         return texUnit->Combine.OperandA[op_alpha];
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_OPERAND3_ALPHA_NV:
+      if (ctx->Extensions.NV_texture_env_combine4) {
+         return texUnit->Combine.OperandA[3];
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_RGB_SCALE:
+      if (ctx->Extensions.EXT_texture_env_combine ||
+          ctx->Extensions.ARB_texture_env_combine) {
+         return 1 << texUnit->Combine.ScaleShiftRGB;
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_ALPHA_SCALE:
+      if (ctx->Extensions.EXT_texture_env_combine ||
+          ctx->Extensions.ARB_texture_env_combine) {
+         return 1 << texUnit->Combine.ScaleShiftA;
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+   case GL_BUMP_TARGET_ATI:
+      /* spec doesn't say so, but I think this should be queryable */
+      if (ctx->Extensions.ATI_envmap_bumpmap) {
+         return texUnit->BumpTarget;
+      }
+      else {
+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
+      }
+      break;
+
+   default:
+      ;
+   }
+
+   return -1; /* error */
+}
+
+
+
+void GLAPIENTRY
+_mesa_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
+{
+   GLuint maxUnit;
+   const struct gl_texture_unit *texUnit;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   maxUnit = (target == GL_POINT_SPRITE_NV && pname == GL_COORD_REPLACE_NV)
+      ? ctx->Const.MaxTextureCoordUnits : ctx->Const.MaxTextureImageUnits;
+   if (ctx->Texture.CurrentUnit >= maxUnit) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexEnvfv(current unit)");
+      return;
+   }
+
+   texUnit = _mesa_get_current_tex_unit(ctx);
+
+   if (target == GL_TEXTURE_ENV) {
+      if (pname == GL_TEXTURE_ENV_COLOR) {
+         if(ctx->NewState & (_NEW_BUFFERS | _NEW_FRAG_CLAMP))
+            _mesa_update_state(ctx);
+         if(ctx->Color._ClampFragmentColor)
+            COPY_4FV( params, texUnit->EnvColor );
+         else
+            COPY_4FV( params, texUnit->EnvColorUnclamped );
+      }
+      else {
+         GLint val = get_texenvi(ctx, texUnit, pname);
+         if (val >= 0) {
+            *params = (GLfloat) val;
+         }
+      }
+   }
+   else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {
+      /* GL_EXT_texture_lod_bias */
+      if (!ctx->Extensions.EXT_texture_lod_bias) {
+	 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
+	 return;
+      }
+      if (pname == GL_TEXTURE_LOD_BIAS_EXT) {
+         *params = texUnit->LodBias;
+      }
+      else {
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
+	 return;
+      }
+   }
+   else if (target == GL_POINT_SPRITE_NV) {
+      /* GL_ARB_point_sprite / GL_NV_point_sprite */
+      if (!ctx->Extensions.NV_point_sprite
+	  && !ctx->Extensions.ARB_point_sprite) {
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
+         return;
+      }
+      if (pname == GL_COORD_REPLACE_NV) {
+         *params = (GLfloat) ctx->Point.CoordReplace[ctx->Texture.CurrentUnit];
+      }
+      else {
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
+         return;
+      }
+   }
+   else {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
+      return;
+   }
+}
+
+
+void GLAPIENTRY
+_mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params )
+{
+   GLuint maxUnit;
+   const struct gl_texture_unit *texUnit;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   maxUnit = (target == GL_POINT_SPRITE_NV && pname == GL_COORD_REPLACE_NV)
+      ? ctx->Const.MaxTextureCoordUnits : ctx->Const.MaxTextureImageUnits;
+   if (ctx->Texture.CurrentUnit >= maxUnit) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexEnviv(current unit)");
+      return;
+   }
+
+   texUnit = _mesa_get_current_tex_unit(ctx);
+
+   if (target == GL_TEXTURE_ENV) {
+      if (pname == GL_TEXTURE_ENV_COLOR) {
+         params[0] = FLOAT_TO_INT( texUnit->EnvColor[0] );
+         params[1] = FLOAT_TO_INT( texUnit->EnvColor[1] );
+         params[2] = FLOAT_TO_INT( texUnit->EnvColor[2] );
+         params[3] = FLOAT_TO_INT( texUnit->EnvColor[3] );
+      }
+      else {
+         GLint val = get_texenvi(ctx, texUnit, pname);
+         if (val >= 0) {
+            *params = val;
+         }
+      }
+   }
+   else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {
+      /* GL_EXT_texture_lod_bias */
+      if (!ctx->Extensions.EXT_texture_lod_bias) {
+	 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
+	 return;
+      }
+      if (pname == GL_TEXTURE_LOD_BIAS_EXT) {
+         *params = (GLint) texUnit->LodBias;
+      }
+      else {
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );
+	 return;
+      }
+   }
+   else if (target == GL_POINT_SPRITE_NV) {
+      /* GL_ARB_point_sprite / GL_NV_point_sprite */
+      if (!ctx->Extensions.NV_point_sprite
+	  && !ctx->Extensions.ARB_point_sprite) {
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
+         return;
+      }
+      if (pname == GL_COORD_REPLACE_NV) {
+         *params = (GLint) ctx->Point.CoordReplace[ctx->Texture.CurrentUnit];
+      }
+      else {
+         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );
+         return;
+      }
+   }
+   else {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
+      return;
+   }
+}
+
+
+/**
+ * Why does ATI_envmap_bumpmap require new entrypoints? Should just
+ * reuse TexEnv ones...
+ */
+void GLAPIENTRY
+_mesa_TexBumpParameterivATI( GLenum pname, const GLint *param )
+{
+   GLfloat p[4];
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (!ctx->Extensions.ATI_envmap_bumpmap) {
+      /* This isn't an "official" error case, but let's tell the user
+       * that something's wrong.
+       */
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glTexBumpParameterivATI");
+      return;
+   }
+
+   if (pname == GL_BUMP_ROT_MATRIX_ATI) {
+      /* hope that conversion is correct here */
+      p[0] = INT_TO_FLOAT( param[0] );
+      p[1] = INT_TO_FLOAT( param[1] );
+      p[2] = INT_TO_FLOAT( param[2] );
+      p[3] = INT_TO_FLOAT( param[3] );
+   }
+   else {
+      p[0] = (GLfloat) param[0];
+      p[1] = p[2] = p[3] = 0.0F;  /* init to zero, just to be safe */
+   }
+   _mesa_TexBumpParameterfvATI( pname, p );
+}
+
+
+void GLAPIENTRY
+_mesa_TexBumpParameterfvATI( GLenum pname, const GLfloat *param )
+{
+   struct gl_texture_unit *texUnit;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (!ctx->Extensions.ATI_envmap_bumpmap) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glTexBumpParameterfvATI");
+      return;
+   }
+
+   texUnit = _mesa_get_current_tex_unit(ctx);
+
+   if (pname == GL_BUMP_ROT_MATRIX_ATI) {
+      if (TEST_EQ_4V(param, texUnit->RotMatrix))
+         return;
+      FLUSH_VERTICES(ctx, _NEW_TEXTURE);
+      COPY_4FV(texUnit->RotMatrix, param);
+   }
+   else {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glTexBumpParameter(pname)" );
+      return;
+   }
+   /* Drivers might want to know about this, instead of dedicated function
+      just shove it into TexEnv where it really belongs anyway */
+   if (ctx->Driver.TexEnv) {
+      (*ctx->Driver.TexEnv)( ctx, 0, pname, param );
+   }
+}
+
+
+void GLAPIENTRY
+_mesa_GetTexBumpParameterivATI( GLenum pname, GLint *param )
+{
+   const struct gl_texture_unit *texUnit;
+   GLuint i;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (!ctx->Extensions.ATI_envmap_bumpmap) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexBumpParameterivATI");
+      return;
+   }
+
+   texUnit = _mesa_get_current_tex_unit(ctx);
+
+   if (pname == GL_BUMP_ROT_MATRIX_SIZE_ATI) {
+      /* spec leaves open to support larger matrices.
+         Don't think anyone would ever want to use it
+         (and apps almost certainly would not understand it and
+         thus fail to submit matrices correctly) so hardcode this. */
+      *param = 4;
+   }
+   else if (pname == GL_BUMP_ROT_MATRIX_ATI) {
+      /* hope that conversion is correct here */
+      param[0] = FLOAT_TO_INT(texUnit->RotMatrix[0]);
+      param[1] = FLOAT_TO_INT(texUnit->RotMatrix[1]);
+      param[2] = FLOAT_TO_INT(texUnit->RotMatrix[2]);
+      param[3] = FLOAT_TO_INT(texUnit->RotMatrix[3]);
+   }
+   else if (pname == GL_BUMP_NUM_TEX_UNITS_ATI) {
+      GLint count = 0;
+      for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
+         if (ctx->Const.SupportedBumpUnits & (1 << i)) {
+            count++;
+         }
+      }
+      *param = count;
+   }
+   else if (pname == GL_BUMP_TEX_UNITS_ATI) {
+      for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
+         if (ctx->Const.SupportedBumpUnits & (1 << i)) {
+            *param++ = i + GL_TEXTURE0;
+         }
+      }
+   }
+   else {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexBumpParameter(pname)" );
+      return;
+   }
+}
+
+
+void GLAPIENTRY
+_mesa_GetTexBumpParameterfvATI( GLenum pname, GLfloat *param )
+{
+   const struct gl_texture_unit *texUnit;
+   GLuint i;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+   if (!ctx->Extensions.ATI_envmap_bumpmap) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexBumpParameterfvATI");
+      return;
+   }
+
+   texUnit = _mesa_get_current_tex_unit(ctx);
+
+   if (pname == GL_BUMP_ROT_MATRIX_SIZE_ATI) {
+      /* spec leaves open to support larger matrices.
+         Don't think anyone would ever want to use it
+         (and apps might not understand it) so hardcode this. */
+      *param = 4.0F;
+   }
+   else if (pname == GL_BUMP_ROT_MATRIX_ATI) {
+      param[0] = texUnit->RotMatrix[0];
+      param[1] = texUnit->RotMatrix[1];
+      param[2] = texUnit->RotMatrix[2];
+      param[3] = texUnit->RotMatrix[3];
+   }
+   else if (pname == GL_BUMP_NUM_TEX_UNITS_ATI) {
+      GLint count = 0;
+      for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
+         if (ctx->Const.SupportedBumpUnits & (1 << i)) {
+            count++;
+         }
+      }
+      *param = (GLfloat) count;
+   }
+   else if (pname == GL_BUMP_TEX_UNITS_ATI) {
+      for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
+         if (ctx->Const.SupportedBumpUnits & (1 << i)) {
+            *param++ = (GLfloat) (i + GL_TEXTURE0);
+         }
+      }
+   }
+   else {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexBumpParameter(pname)" );
+      return;
+   }
+}
diff --git a/mesalib/src/mesa/main/texfetch.c b/mesalib/src/mesa/main/texfetch.c
index 988a7e054..b2181af29 100644
--- a/mesalib/src/mesa/main/texfetch.c
+++ b/mesalib/src/mesa/main/texfetch.c
@@ -696,11 +696,11 @@ texfetch_funcs[MESA_FORMAT_COUNT] =
       store_texel_signed_r8
    },
    {
-      MESA_FORMAT_SIGNED_RG88,
-      fetch_texel_1d_signed_rg88,
-      fetch_texel_2d_signed_rg88,
-      fetch_texel_3d_signed_rg88,
-      store_texel_signed_rg88
+      MESA_FORMAT_SIGNED_RG88_REV,
+      fetch_texel_1d_signed_rg88_rev,
+      fetch_texel_2d_signed_rg88_rev,
+      fetch_texel_3d_signed_rg88_rev,
+      store_texel_signed_rg88_rev
    },
    {
       MESA_FORMAT_SIGNED_RGBX8888,
@@ -724,18 +724,18 @@ texfetch_funcs[MESA_FORMAT_COUNT] =
       store_texel_signed_rgba8888_rev
    },
    {
-      MESA_FORMAT_SIGNED_R_16,
-      fetch_texel_1d_signed_r_16,
-      fetch_texel_2d_signed_r_16,
-      fetch_texel_3d_signed_r_16,
-      store_texel_signed_r_16
+      MESA_FORMAT_SIGNED_R16,
+      fetch_texel_1d_signed_r16,
+      fetch_texel_2d_signed_r16,
+      fetch_texel_3d_signed_r16,
+      store_texel_signed_r16
    },
    {
-      MESA_FORMAT_SIGNED_RG_16,
-      fetch_texel_1d_signed_rg_16,
-      fetch_texel_2d_signed_rg_16,
-      fetch_texel_3d_signed_rg_16,
-      store_texel_signed_rg_16
+      MESA_FORMAT_SIGNED_GR1616,
+      fetch_texel_1d_signed_rg1616,
+      fetch_texel_2d_signed_rg1616,
+      fetch_texel_3d_signed_rg1616,
+      store_texel_signed_rg1616
    },
    {
       MESA_FORMAT_SIGNED_RGB_16,
@@ -814,6 +814,62 @@ texfetch_funcs[MESA_FORMAT_COUNT] =
       NULL,
       NULL
    },
+   {
+      MESA_FORMAT_SIGNED_A8,
+      fetch_texel_1d_signed_a8,
+      fetch_texel_2d_signed_a8,
+      fetch_texel_3d_signed_a8,
+      store_texel_signed_a8
+   },
+   {
+      MESA_FORMAT_SIGNED_L8,
+      fetch_texel_1d_signed_l8,
+      fetch_texel_2d_signed_l8,
+      fetch_texel_3d_signed_l8,
+      store_texel_signed_l8
+   },
+   {
+      MESA_FORMAT_SIGNED_AL88,
+      fetch_texel_1d_signed_al88,
+      fetch_texel_2d_signed_al88,
+      fetch_texel_3d_signed_al88,
+      store_texel_signed_al88
+   },
+   {
+      MESA_FORMAT_SIGNED_I8,
+      fetch_texel_1d_signed_i8,
+      fetch_texel_2d_signed_i8,
+      fetch_texel_3d_signed_i8,
+      store_texel_signed_i8
+   },
+   {
+      MESA_FORMAT_SIGNED_A16,
+      fetch_texel_1d_signed_a16,
+      fetch_texel_2d_signed_a16,
+      fetch_texel_3d_signed_a16,
+      store_texel_signed_a16
+   },
+   {
+      MESA_FORMAT_SIGNED_L16,
+      fetch_texel_1d_signed_l16,
+      fetch_texel_2d_signed_l16,
+      fetch_texel_3d_signed_l16,
+      store_texel_signed_l16
+   },
+   {
+      MESA_FORMAT_SIGNED_AL1616,
+      fetch_texel_1d_signed_al1616,
+      fetch_texel_2d_signed_al1616,
+      fetch_texel_3d_signed_al1616,
+      store_texel_signed_al1616
+   },
+   {
+      MESA_FORMAT_SIGNED_I16,
+      fetch_texel_1d_signed_i16,
+      fetch_texel_2d_signed_i16,
+      fetch_texel_3d_signed_i16,
+      store_texel_signed_i16
+   },
 };
 
 
diff --git a/mesalib/src/mesa/main/texfetch_tmp.h b/mesalib/src/mesa/main/texfetch_tmp.h
index 9c2b36a02..f1f6a01a4 100644
--- a/mesalib/src/mesa/main/texfetch_tmp.h
+++ b/mesalib/src/mesa/main/texfetch_tmp.h
@@ -1,2040 +1,2233 @@
-/*

- * Mesa 3-D graphics library

- * Version:  7.7

- *

- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

- * Copyright (c) 2008-2009  VMware, Inc.

- *

- * 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.

- */

-

-

-/**

- * \file texfetch_tmp.h

- * Texel fetch functions template.

- * 

- * This template file is used by texfetch.c to generate texel fetch functions

- * for 1-D, 2-D and 3-D texture images. 

- *

- * It should be expanded by defining \p DIM as the number texture dimensions

- * (1, 2 or 3).  According to the value of \p DIM a series of macros is defined

- * for the texel lookup in the gl_texture_image::Data.

- * 

- * \author Gareth Hughes

- * \author Brian Paul

- */

-

-

-#if DIM == 1

-

-#define TEXEL_ADDR( type, image, i, j, k, size ) \

-	((void) (j), (void) (k), ((type *)(image)->Data + (i) * (size)))

-

-#define FETCH(x) fetch_texel_1d_##x

-

-#elif DIM == 2

-

-#define TEXEL_ADDR( type, image, i, j, k, size )			\

-	((void) (k),							\

-	 ((type *)(image)->Data + ((image)->RowStride * (j) + (i)) * (size)))

-

-#define FETCH(x) fetch_texel_2d_##x

-

-#elif DIM == 3

-

-#define TEXEL_ADDR( type, image, i, j, k, size )			\

-	((type *)(image)->Data + ((image)->ImageOffsets[k]		\

-             + (image)->RowStride * (j) + (i)) * (size))

-

-#define FETCH(x) fetch_texel_3d_##x

-

-#else

-#error	illegal number of texture dimensions

-#endif

-

-

-/* MESA_FORMAT_Z32 ***********************************************************/

-

-/* Fetch depth texel from 1D, 2D or 3D 32-bit depth texture,

- * returning 1 GLfloat.

- * Note: no GLchan version of this function.

- */

-static void FETCH(f_z32)( const struct gl_texture_image *texImage,

-                          GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   texel[0] = src[0] * (1.0F / 0xffffffff);

-}

-

-#if DIM == 3

-static void store_texel_z32(struct gl_texture_image *texImage,

-                            GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLuint *depth = (const GLuint *) texel;

-   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   dst[0] = *depth;

-}

-#endif

-

-

-/* MESA_FORMAT_Z16 ***********************************************************/

-

-/* Fetch depth texel from 1D, 2D or 3D 16-bit depth texture,

- * returning 1 GLfloat.

- * Note: no GLchan version of this function.

- */

-static void FETCH(f_z16)(const struct gl_texture_image *texImage,

-                         GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   texel[0] = src[0] * (1.0F / 65535.0F);

-}

-

-#if DIM == 3

-static void store_texel_z16(struct gl_texture_image *texImage,

-                            GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLushort *depth = (const GLushort *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   dst[0] = *depth;

-}

-#endif

-

-

-/* MESA_FORMAT_RGBA_F32 ******************************************************/

-

-/* Fetch texel from 1D, 2D or 3D RGBA_FLOAT32 texture, returning 4 GLfloats.

- */

-static void FETCH(f_rgba_f32)( const struct gl_texture_image *texImage,

-                               GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 4);

-   texel[RCOMP] = src[0];

-   texel[GCOMP] = src[1];

-   texel[BCOMP] = src[2];

-   texel[ACOMP] = src[3];

-}

-

-#if DIM == 3

-static void store_texel_rgba_f32(struct gl_texture_image *texImage,

-                                 GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLfloat *depth = (const GLfloat *) texel;

-   GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 4);

-   dst[0] = depth[RCOMP];

-   dst[1] = depth[GCOMP];

-   dst[2] = depth[BCOMP];

-   dst[3] = depth[ACOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_RGBA_F16 ******************************************************/

-

-/* Fetch texel from 1D, 2D or 3D RGBA_FLOAT16 texture,

- * returning 4 GLfloats.

- */

-static void FETCH(f_rgba_f16)( const struct gl_texture_image *texImage,

-                               GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 4);

-   texel[RCOMP] = _mesa_half_to_float(src[0]);

-   texel[GCOMP] = _mesa_half_to_float(src[1]);

-   texel[BCOMP] = _mesa_half_to_float(src[2]);

-   texel[ACOMP] = _mesa_half_to_float(src[3]);

-}

-

-#if DIM == 3

-static void store_texel_rgba_f16(struct gl_texture_image *texImage,

-                                 GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLfloat *src = (const GLfloat *) texel;

-   GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 4);

-   dst[0] = _mesa_float_to_half(src[RCOMP]);

-   dst[1] = _mesa_float_to_half(src[GCOMP]);

-   dst[2] = _mesa_float_to_half(src[BCOMP]);

-   dst[3] = _mesa_float_to_half(src[ACOMP]);

-}

-#endif

-

-/* MESA_FORMAT_RGB_F32 *******************************************************/

-

-/* Fetch texel from 1D, 2D or 3D RGB_FLOAT32 texture,

- * returning 4 GLfloats.

- */

-static void FETCH(f_rgb_f32)( const struct gl_texture_image *texImage,

-                              GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 3);

-   texel[RCOMP] = src[0];

-   texel[GCOMP] = src[1];

-   texel[BCOMP] = src[2];

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void store_texel_rgb_f32(struct gl_texture_image *texImage,

-                                 GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLfloat *src = (const GLfloat *) texel;

-   GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 3);

-   dst[0] = src[RCOMP];

-   dst[1] = src[GCOMP];

-   dst[2] = src[BCOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_RGB_F16 *******************************************************/

-

-/* Fetch texel from 1D, 2D or 3D RGB_FLOAT16 texture,

- * returning 4 GLfloats.

- */

-static void FETCH(f_rgb_f16)( const struct gl_texture_image *texImage,

-                              GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 3);

-   texel[RCOMP] = _mesa_half_to_float(src[0]);

-   texel[GCOMP] = _mesa_half_to_float(src[1]);

-   texel[BCOMP] = _mesa_half_to_float(src[2]);

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void store_texel_rgb_f16(struct gl_texture_image *texImage,

-                                GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLfloat *src = (const GLfloat *) texel;

-   GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 3);

-   dst[0] = _mesa_float_to_half(src[RCOMP]);

-   dst[1] = _mesa_float_to_half(src[GCOMP]);

-   dst[2] = _mesa_float_to_half(src[BCOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_ALPHA_F32 *****************************************************/

-

-/* Fetch texel from 1D, 2D or 3D ALPHA_FLOAT32 texture,

- * returning 4 GLfloats.

- */

-static void FETCH(f_alpha_f32)( const struct gl_texture_image *texImage,

-                              GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);

-   texel[RCOMP] =

-   texel[GCOMP] =

-   texel[BCOMP] = 0.0F;

-   texel[ACOMP] = src[0];

-}

-

-#if DIM == 3

-static void store_texel_alpha_f32(struct gl_texture_image *texImage,

-                                  GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLfloat *rgba = (const GLfloat *) texel;

-   GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);

-   dst[0] = rgba[ACOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_ALPHA_F32 *****************************************************/

-

-/* Fetch texel from 1D, 2D or 3D ALPHA_FLOAT16 texture,

- * returning 4 GLfloats.

- */

-static void FETCH(f_alpha_f16)( const struct gl_texture_image *texImage,

-                              GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);

-   texel[RCOMP] =

-   texel[GCOMP] =

-   texel[BCOMP] = 0.0F;

-   texel[ACOMP] = _mesa_half_to_float(src[0]);

-}

-

-#if DIM == 3

-static void store_texel_alpha_f16(struct gl_texture_image *texImage,

-                                  GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLfloat *rgba = (const GLfloat *) texel;

-   GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);

-   dst[0] = _mesa_float_to_half(rgba[ACOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_LUMINANCE_F32 *************************************************/

-

-/* Fetch texel from 1D, 2D or 3D LUMINANCE_FLOAT32 texture,

- * returning 4 GLfloats.

- */

-static void FETCH(f_luminance_f32)( const struct gl_texture_image *texImage,

-                                    GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);

-   texel[RCOMP] =

-   texel[GCOMP] =

-   texel[BCOMP] = src[0];

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void store_texel_luminance_f32(struct gl_texture_image *texImage,

-                                  GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLfloat *rgba = (const GLfloat *) texel;

-   GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);

-   dst[0] = rgba[RCOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_LUMINANCE_F16 *************************************************/

-

-/* Fetch texel from 1D, 2D or 3D LUMINANCE_FLOAT16 texture,

- * returning 4 GLfloats.

- */

-static void FETCH(f_luminance_f16)( const struct gl_texture_image *texImage,

-                                    GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);

-   texel[RCOMP] =

-   texel[GCOMP] =

-   texel[BCOMP] = _mesa_half_to_float(src[0]);

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void store_texel_luminance_f16(struct gl_texture_image *texImage,

-                                  GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLfloat *rgba = (const GLfloat *) texel;

-   GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);

-   dst[0] = _mesa_float_to_half(rgba[RCOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_LUMINANCE_ALPHA_F32 *******************************************/

-

-/* Fetch texel from 1D, 2D or 3D LUMINANCE_ALPHA_FLOAT32 texture,

- * returning 4 GLfloats.

- */

-static void FETCH(f_luminance_alpha_f32)( const struct gl_texture_image *texImage,

-                                    GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 2);

-   texel[RCOMP] =

-   texel[GCOMP] =

-   texel[BCOMP] = src[0];

-   texel[ACOMP] = src[1];

-}

-

-#if DIM == 3

-static void store_texel_luminance_alpha_f32(struct gl_texture_image *texImage,

-                                  GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLfloat *rgba = (const GLfloat *) texel;

-   GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 2);

-   dst[0] = rgba[RCOMP];

-   dst[1] = rgba[ACOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_LUMINANCE_ALPHA_F16 *******************************************/

-

-/* Fetch texel from 1D, 2D or 3D LUMINANCE_ALPHA_FLOAT16 texture,

- * returning 4 GLfloats.

- */

-static void FETCH(f_luminance_alpha_f16)( const struct gl_texture_image *texImage,

-                                    GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 2);

-   texel[RCOMP] =

-   texel[GCOMP] =

-   texel[BCOMP] = _mesa_half_to_float(src[0]);

-   texel[ACOMP] = _mesa_half_to_float(src[1]);

-}

-

-#if DIM == 3

-static void store_texel_luminance_alpha_f16(struct gl_texture_image *texImage,

-                                  GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLfloat *rgba = (const GLfloat *) texel;

-   GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 2);

-   dst[0] = _mesa_float_to_half(rgba[RCOMP]);

-   dst[1] = _mesa_float_to_half(rgba[ACOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_INTENSITY_F32 *************************************************/

-

-/* Fetch texel from 1D, 2D or 3D INTENSITY_FLOAT32 texture,

- * returning 4 GLfloats.

- */

-static void FETCH(f_intensity_f32)( const struct gl_texture_image *texImage,

-                                    GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);

-   texel[RCOMP] =

-   texel[GCOMP] =

-   texel[BCOMP] =

-   texel[ACOMP] = src[0];

-}

-

-#if DIM == 3

-static void store_texel_intensity_f32(struct gl_texture_image *texImage,

-                                  GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLfloat *rgba = (const GLfloat *) texel;

-   GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);

-   dst[0] = rgba[RCOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_INTENSITY_F16 *************************************************/

-

-/* Fetch texel from 1D, 2D or 3D INTENSITY_FLOAT16 texture,

- * returning 4 GLfloats.

- */

-static void FETCH(f_intensity_f16)( const struct gl_texture_image *texImage,

-                                    GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);

-   texel[RCOMP] =

-   texel[GCOMP] =

-   texel[BCOMP] =

-   texel[ACOMP] = _mesa_half_to_float(src[0]);

-}

-

-#if DIM == 3

-static void store_texel_intensity_f16(struct gl_texture_image *texImage,

-                                  GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLfloat *rgba = (const GLfloat *) texel;

-   GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);

-   dst[0] = _mesa_float_to_half(rgba[RCOMP]);

-}

-#endif

-

-

-

-

-/*

- * Begin Hardware formats

- */

-

-/* MESA_FORMAT_RGBA8888 ******************************************************/

-

-/* Fetch texel from 1D, 2D or 3D rgba8888 texture, return 4 GLfloats */

-static void FETCH(f_rgba8888)( const struct gl_texture_image *texImage,

-                               GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   texel[RCOMP] = UBYTE_TO_FLOAT( (s >> 24)        );

-   texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );

-   texel[BCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );

-   texel[ACOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );

-}

-

-

-

-#if DIM == 3

-static void store_texel_rgba8888(struct gl_texture_image *texImage,

-                                 GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_RGBA888_REV ***************************************************/

-

-/* Fetch texel from 1D, 2D or 3D abgr8888 texture, return 4 GLchans */

-static void FETCH(f_rgba8888_rev)( const struct gl_texture_image *texImage,

-                                   GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   texel[RCOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );

-   texel[GCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );

-   texel[BCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );

-   texel[ACOMP] = UBYTE_TO_FLOAT( (s >> 24)        );

-}

-

-#if DIM == 3

-static void store_texel_rgba8888_rev(struct gl_texture_image *texImage,

-                                  GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_8888_REV(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_ARGB8888 ******************************************************/

-

-/* Fetch texel from 1D, 2D or 3D argb8888 texture, return 4 GLchans */

-static void FETCH(f_argb8888)( const struct gl_texture_image *texImage,

-                               GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   texel[RCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );

-   texel[GCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );

-   texel[BCOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );

-   texel[ACOMP] = UBYTE_TO_FLOAT( (s >> 24)        );

-}

-

-#if DIM == 3

-static void store_texel_argb8888(struct gl_texture_image *texImage,

-                                 GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_8888(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_ARGB8888_REV **************************************************/

-

-/* Fetch texel from 1D, 2D or 3D argb8888_rev texture, return 4 GLfloats */

-static void FETCH(f_argb8888_rev)( const struct gl_texture_image *texImage,

-                                   GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   texel[RCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );

-   texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );

-   texel[BCOMP] = UBYTE_TO_FLOAT( (s >> 24)        );

-   texel[ACOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );

-}

-

-#if DIM == 3

-static void store_texel_argb8888_rev(struct gl_texture_image *texImage,

-                                  GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_8888(rgba[BCOMP], rgba[GCOMP], rgba[RCOMP], rgba[ACOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_XRGB8888 ******************************************************/

-

-/* Fetch texel from 1D, 2D or 3D xrgb8888 texture, return 4 GLchans */

-static void FETCH(f_xrgb8888)( const struct gl_texture_image *texImage,

-                               GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   texel[RCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );

-   texel[GCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );

-   texel[BCOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );

-   texel[ACOMP] = 1.0f;

-}

-

-#if DIM == 3

-static void store_texel_xrgb8888(struct gl_texture_image *texImage,

-                                 GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_8888(0xff, rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_XRGB8888_REV **************************************************/

-

-/* Fetch texel from 1D, 2D or 3D xrgb8888_rev texture, return 4 GLfloats */

-static void FETCH(f_xrgb8888_rev)( const struct gl_texture_image *texImage,

-                                   GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   texel[RCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );

-   texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );

-   texel[BCOMP] = UBYTE_TO_FLOAT( (s >> 24)        );

-   texel[ACOMP] = 1.0f;

-}

-

-#if DIM == 3

-static void store_texel_xrgb8888_rev(struct gl_texture_image *texImage,

-                                     GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_8888(rgba[BCOMP], rgba[GCOMP], rgba[RCOMP], 0xff);

-}

-#endif

-

-

-/* MESA_FORMAT_RGB888 ********************************************************/

-

-/* Fetch texel from 1D, 2D or 3D rgb888 texture, return 4 GLchans */

-static void FETCH(f_rgb888)( const struct gl_texture_image *texImage,

-                             GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);

-   texel[RCOMP] = UBYTE_TO_FLOAT( src[2] );

-   texel[GCOMP] = UBYTE_TO_FLOAT( src[1] );

-   texel[BCOMP] = UBYTE_TO_FLOAT( src[0] );

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void store_texel_rgb888(struct gl_texture_image *texImage,

-                               GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);

-   dst[0] = rgba[BCOMP];

-   dst[1] = rgba[GCOMP];

-   dst[2] = rgba[RCOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_BGR888 ********************************************************/

-

-/* Fetch texel from 1D, 2D or 3D bgr888 texture, return 4 GLchans */

-static void FETCH(f_bgr888)( const struct gl_texture_image *texImage,

-                             GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);

-   texel[RCOMP] = UBYTE_TO_FLOAT( src[0] );

-   texel[GCOMP] = UBYTE_TO_FLOAT( src[1] );

-   texel[BCOMP] = UBYTE_TO_FLOAT( src[2] );

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void store_texel_bgr888(struct gl_texture_image *texImage,

-                               GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);

-   dst[0] = rgba[RCOMP];

-   dst[1] = rgba[GCOMP];

-   dst[2] = rgba[BCOMP];

-}

-#endif

-

-

-/* use color expansion like (g << 2) | (g >> 4) (does somewhat random rounding)

-   instead of slow (g << 2) * 255 / 252 (always rounds down) */

-

-/* MESA_FORMAT_RGB565 ********************************************************/

-

-/* Fetch texel from 1D, 2D or 3D rgb565 texture, return 4 GLchans */

-static void FETCH(f_rgb565)( const struct gl_texture_image *texImage,

-                             GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   const GLushort s = *src;

-   texel[RCOMP] = ((s >> 11) & 0x1f) * (1.0F / 31.0F);

-   texel[GCOMP] = ((s >> 5 ) & 0x3f) * (1.0F / 63.0F);

-   texel[BCOMP] = ((s      ) & 0x1f) * (1.0F / 31.0F);

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void store_texel_rgb565(struct gl_texture_image *texImage,

-                               GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_565(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_RGB565_REV ****************************************************/

-

-/* Fetch texel from 1D, 2D or 3D rgb565_rev texture, return 4 GLchans */

-static void FETCH(f_rgb565_rev)( const struct gl_texture_image *texImage,

-                                 GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   const GLushort s = (*src >> 8) | (*src << 8); /* byte swap */

-   texel[RCOMP] = UBYTE_TO_FLOAT( ((s >> 8) & 0xf8) | ((s >> 13) & 0x7) );

-   texel[GCOMP] = UBYTE_TO_FLOAT( ((s >> 3) & 0xfc) | ((s >>  9) & 0x3) );

-   texel[BCOMP] = UBYTE_TO_FLOAT( ((s << 3) & 0xf8) | ((s >>  2) & 0x7) );

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void store_texel_rgb565_rev(struct gl_texture_image *texImage,

-                                  GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_565(rgba[BCOMP], rgba[GCOMP], rgba[RCOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_ARGB4444 ******************************************************/

-

-/* Fetch texel from 1D, 2D or 3D argb444 texture, return 4 GLchans */

-static void FETCH(f_argb4444)( const struct gl_texture_image *texImage,

-                               GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   const GLushort s = *src;

-   texel[RCOMP] = ((s >>  8) & 0xf) * (1.0F / 15.0F);

-   texel[GCOMP] = ((s >>  4) & 0xf) * (1.0F / 15.0F);

-   texel[BCOMP] = ((s      ) & 0xf) * (1.0F / 15.0F);

-   texel[ACOMP] = ((s >> 12) & 0xf) * (1.0F / 15.0F);

-}

-

-#if DIM == 3

-static void store_texel_argb4444(struct gl_texture_image *texImage,

-                                 GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_4444(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_ARGB4444_REV **************************************************/

-

-/* Fetch texel from 1D, 2D or 3D argb4444_rev texture, return 4 GLchans */

-static void FETCH(f_argb4444_rev)( const struct gl_texture_image *texImage,

-                                   GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   texel[RCOMP] = ((s      ) & 0xf) * (1.0F / 15.0F);

-   texel[GCOMP] = ((s >> 12) & 0xf) * (1.0F / 15.0F);

-   texel[BCOMP] = ((s >>  8) & 0xf) * (1.0F / 15.0F);

-   texel[ACOMP] = ((s >>  4) & 0xf) * (1.0F / 15.0F);

-}

-

-#if DIM == 3

-static void store_texel_argb4444_rev(struct gl_texture_image *texImage,

-                                 GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_4444(rgba[ACOMP], rgba[BCOMP], rgba[GCOMP], rgba[RCOMP]);

-}

-#endif

-

-/* MESA_FORMAT_RGBA5551 ******************************************************/

-

-/* Fetch texel from 1D, 2D or 3D argb1555 texture, return 4 GLchans */

-static void FETCH(f_rgba5551)( const struct gl_texture_image *texImage,

-                               GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   const GLushort s = *src;

-   texel[RCOMP] = ((s >> 11) & 0x1f) * (1.0F / 31.0F);

-   texel[GCOMP] = ((s >>  6) & 0x1f) * (1.0F / 31.0F);

-   texel[BCOMP] = ((s >>  1) & 0x1f) * (1.0F / 31.0F);

-   texel[ACOMP] = ((s      ) & 0x01) * 1.0F;

-}

-

-#if DIM == 3

-static void store_texel_rgba5551(struct gl_texture_image *texImage,

-                                 GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_5551(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);

-}

-#endif

-

-/* MESA_FORMAT_ARGB1555 ******************************************************/

-

-/* Fetch texel from 1D, 2D or 3D argb1555 texture, return 4 GLchans */

-static void FETCH(f_argb1555)( const struct gl_texture_image *texImage,

-			     GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   const GLushort s = *src;

-   texel[RCOMP] = ((s >> 10) & 0x1f) * (1.0F / 31.0F);

-   texel[GCOMP] = ((s >>  5) & 0x1f) * (1.0F / 31.0F);

-   texel[BCOMP] = ((s >>  0) & 0x1f) * (1.0F / 31.0F);

-   texel[ACOMP] = ((s >> 15) & 0x01) * 1.0F;

-}

-

-#if DIM == 3

-static void store_texel_argb1555(struct gl_texture_image *texImage,

-                                 GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_1555(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_ARGB1555_REV **************************************************/

-

-/* Fetch texel from 1D, 2D or 3D argb1555_rev texture, return 4 GLchans */

-static void FETCH(f_argb1555_rev)( const struct gl_texture_image *texImage,

-                                   GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   const GLushort s = (*src << 8) | (*src >> 8); /* byteswap */

-   texel[RCOMP] = UBYTE_TO_FLOAT( ((s >>  7) & 0xf8) | ((s >> 12) & 0x7) );

-   texel[GCOMP] = UBYTE_TO_FLOAT( ((s >>  2) & 0xf8) | ((s >>  7) & 0x7) );

-   texel[BCOMP] = UBYTE_TO_FLOAT( ((s <<  3) & 0xf8) | ((s >>  2) & 0x7) );

-   texel[ACOMP] = UBYTE_TO_FLOAT( ((s >> 15) & 0x01) * 255 );

-}

-

-#if DIM == 3

-static void store_texel_argb1555_rev(struct gl_texture_image *texImage,

-                                 GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_1555_REV(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_ARGB2101010 ***************************************************/

-

-/* Fetch texel from 1D, 2D or 3D argb2101010 texture, return 4 GLchans */

-static void FETCH(f_argb2101010)( const struct gl_texture_image *texImage,

-                                  GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   const GLuint s = *src;

-   texel[RCOMP] = ((s >> 20) & 0x3ff) * (1.0F / 1023.0F);

-   texel[GCOMP] = ((s >> 10) & 0x3ff) * (1.0F / 1023.0F);

-   texel[BCOMP] = ((s >>  0) & 0x3ff) * (1.0F / 1023.0F);

-   texel[ACOMP] = ((s >> 30) & 0x03) * (1.0F / 3.0F);

-}

-

-#if DIM == 3

-static void store_texel_argb2101010(struct gl_texture_image *texImage,

-                                    GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_2101010_UB(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_RG88 **********************************************************/

-

-/* Fetch texel from 1D, 2D or 3D rg88 texture, return 4 GLchans */

-static void FETCH(f_rg88)( const struct gl_texture_image *texImage,

-                           GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   texel[RCOMP] = UBYTE_TO_FLOAT( s & 0xff );

-   texel[GCOMP] = UBYTE_TO_FLOAT( s >> 8 );

-   texel[BCOMP] = 0.0;

-   texel[ACOMP] = 1.0;

-}

-

-#if DIM == 3

-static void store_texel_rg88(struct gl_texture_image *texImage,

-                             GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_88(rgba[RCOMP], rgba[GCOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_RG88_REV ******************************************************/

-

-/* Fetch texel from 1D, 2D or 3D rg88_rev texture, return 4 GLchans */

-static void FETCH(f_rg88_rev)( const struct gl_texture_image *texImage,

-                           GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   texel[RCOMP] = UBYTE_TO_FLOAT( s & 0xff );

-   texel[GCOMP] = UBYTE_TO_FLOAT( s >> 8 );

-   texel[BCOMP] = 0.0;

-   texel[ACOMP] = 1.0;

-}

-

-#if DIM == 3

-static void store_texel_rg88_rev(struct gl_texture_image *texImage,

-                             GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_88(rgba[GCOMP], rgba[RCOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_AL44 **********************************************************/

-

-/* Fetch texel from 1D, 2D or 3D al44 texture, return 4 GLchans */

-static void FETCH(f_al44)( const struct gl_texture_image *texImage,

-                           GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLubyte s = *TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);

-   texel[RCOMP] =

-   texel[GCOMP] =

-   texel[BCOMP] = (s & 0xf) * (1.0F / 15.0F);

-   texel[ACOMP] = ((s >> 4) & 0xf) * (1.0F / 15.0F);

-}

-

-#if DIM == 3

-static void store_texel_al44(struct gl_texture_image *texImage,

-                             GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_44(rgba[ACOMP], rgba[RCOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_AL88 **********************************************************/

-

-/* Fetch texel from 1D, 2D or 3D al88 texture, return 4 GLchans */

-static void FETCH(f_al88)( const struct gl_texture_image *texImage,

-                           GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   texel[RCOMP] = 

-   texel[GCOMP] = 

-   texel[BCOMP] = UBYTE_TO_FLOAT( s & 0xff );

-   texel[ACOMP] = UBYTE_TO_FLOAT( s >> 8 );

-}

-

-#if DIM == 3

-static void store_texel_al88(struct gl_texture_image *texImage,

-                             GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_88(rgba[ACOMP], rgba[RCOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_R8 ************************************************************/

-

-/* Fetch texel from 1D, 2D or 3D rg88 texture, return 4 GLchans */

-static void FETCH(f_r8)(const struct gl_texture_image *texImage,

-			GLint i, GLint j, GLint k, GLfloat *texel)

-{

-   const GLubyte s = *TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);

-   texel[RCOMP] = UBYTE_TO_FLOAT(s);

-   texel[GCOMP] = 0.0;

-   texel[BCOMP] = 0.0;

-   texel[ACOMP] = 1.0;

-}

-

-#if DIM == 3

-static void store_texel_r8(struct gl_texture_image *texImage,

-			   GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);

-   *dst = rgba[RCOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_R16 ***********************************************************/

-

-/* Fetch texel from 1D, 2D or 3D r16 texture, return 4 GLchans */

-static void FETCH(f_r16)(const struct gl_texture_image *texImage,

-			GLint i, GLint j, GLint k, GLfloat *texel)

-{

-   const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   texel[RCOMP] = USHORT_TO_FLOAT(s);

-   texel[GCOMP] = 0.0;

-   texel[BCOMP] = 0.0;

-   texel[ACOMP] = 1.0;

-}

-

-#if DIM == 3

-static void store_texel_r16(struct gl_texture_image *texImage,

-			    GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLushort *rgba = (const GLushort *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   *dst = rgba[RCOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_AL88_REV ******************************************************/

-

-/* Fetch texel from 1D, 2D or 3D al88_rev texture, return 4 GLchans */

-static void FETCH(f_al88_rev)( const struct gl_texture_image *texImage,

-                               GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   texel[RCOMP] = 

-   texel[GCOMP] = 

-   texel[BCOMP] = UBYTE_TO_FLOAT( s >> 8 );

-   texel[ACOMP] = UBYTE_TO_FLOAT( s & 0xff );

-}

-

-#if DIM == 3

-static void store_texel_al88_rev(struct gl_texture_image *texImage,

-                                 GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_88(rgba[RCOMP], rgba[ACOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_RG1616 ********************************************************/

-

-/* Fetch texel from 1D, 2D or 3D rg1616 texture, return 4 GLchans */

-static void FETCH(f_rg1616)( const struct gl_texture_image *texImage,

-                           GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   texel[RCOMP] = USHORT_TO_FLOAT( s & 0xffff );

-   texel[GCOMP] = USHORT_TO_FLOAT( s >> 16 );

-   texel[BCOMP] = 0.0;

-   texel[ACOMP] = 1.0;

-}

-

-#if DIM == 3

-static void store_texel_rg1616(struct gl_texture_image *texImage,

-                             GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_1616(rgba[RCOMP], rgba[GCOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_RG1616_REV ****************************************************/

-

-/* Fetch texel from 1D, 2D or 3D rg1616_rev texture, return 4 GLchans */

-static void FETCH(f_rg1616_rev)( const struct gl_texture_image *texImage,

-                           GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   texel[RCOMP] = USHORT_TO_FLOAT( s >> 16 );

-   texel[GCOMP] = USHORT_TO_FLOAT( s & 0xffff );

-   texel[BCOMP] = 0.0;

-   texel[ACOMP] = 1.0;

-}

-

-#if DIM == 3

-static void store_texel_rg1616_rev(struct gl_texture_image *texImage,

-                             GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_1616(rgba[GCOMP], rgba[RCOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_AL1616 ********************************************************/

-

-/* Fetch texel from 1D, 2D or 3D al1616 texture, return 4 GLchans */

-static void FETCH(f_al1616)( const struct gl_texture_image *texImage,

-			     GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   texel[RCOMP] =

-   texel[GCOMP] =

-   texel[BCOMP] = USHORT_TO_FLOAT( s & 0xffff );

-   texel[ACOMP] = USHORT_TO_FLOAT( s >> 16 );

-}

-

-#if DIM == 3

-static void store_texel_al1616(struct gl_texture_image *texImage,

-                             GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLushort *rgba = (const GLushort *) texel;

-   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_1616(rgba[ACOMP], rgba[RCOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_AL1616_REV ****************************************************/

-

-/* Fetch texel from 1D, 2D or 3D al1616_rev texture, return 4 GLchans */

-static void FETCH(f_al1616_rev)( const struct gl_texture_image *texImage,

-				 GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   texel[RCOMP] =

-   texel[GCOMP] =

-   texel[BCOMP] = USHORT_TO_FLOAT( s >> 16 );

-   texel[ACOMP] = USHORT_TO_FLOAT( s & 0xffff );

-}

-

-#if DIM == 3

-static void store_texel_al1616_rev(struct gl_texture_image *texImage,

-				   GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLushort *rgba = (const GLushort *) texel;

-   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_1616(rgba[RCOMP], rgba[ACOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_RGB332 ********************************************************/

-

-/* Fetch texel from 1D, 2D or 3D rgb332 texture, return 4 GLchans */

-static void FETCH(f_rgb332)( const struct gl_texture_image *texImage,

-                             GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);

-   const GLubyte s = *src;

-   texel[RCOMP] = ((s >> 5) & 0x7) * (1.0F / 7.0F);

-   texel[GCOMP] = ((s >> 2) & 0x7) * (1.0F / 7.0F);

-   texel[BCOMP] = ((s     ) & 0x3) * (1.0F / 3.0F);

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void store_texel_rgb332(struct gl_texture_image *texImage,

-                               GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_332(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_A8 ************************************************************/

-

-/* Fetch texel from 1D, 2D or 3D a8 texture, return 4 GLchans */

-static void FETCH(f_a8)( const struct gl_texture_image *texImage,

-                         GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);

-   texel[RCOMP] =

-   texel[GCOMP] =

-   texel[BCOMP] = 0.0F;

-   texel[ACOMP] = UBYTE_TO_FLOAT( src[0] );

-}

-

-#if DIM == 3

-static void store_texel_a8(struct gl_texture_image *texImage,

-                           GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);

-   *dst = rgba[ACOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_A16 ************************************************************/

-

-/* Fetch texel from 1D, 2D or 3D a8 texture, return 4 GLchans */

-static void FETCH(f_a16)( const struct gl_texture_image *texImage,

-                          GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   texel[RCOMP] =

-   texel[GCOMP] =

-   texel[BCOMP] = 0.0F;

-   texel[ACOMP] = USHORT_TO_FLOAT( src[0] );

-}

-

-#if DIM == 3

-static void store_texel_a16(struct gl_texture_image *texImage,

-                            GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLushort *rgba = (const GLushort *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   *dst = rgba[ACOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_L8 ************************************************************/

-

-/* Fetch texel from 1D, 2D or 3D l8 texture, return 4 GLchans */

-static void FETCH(f_l8)( const struct gl_texture_image *texImage,

-                         GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);

-   texel[RCOMP] =

-   texel[GCOMP] =

-   texel[BCOMP] = UBYTE_TO_FLOAT( src[0] );

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void store_texel_l8(struct gl_texture_image *texImage,

-                           GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);

-   *dst = rgba[RCOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_L16 ***********************************************************/

-

-/* Fetch texel from 1D, 2D or 3D l16 texture, return 4 GLchans */

-static void FETCH(f_l16)( const struct gl_texture_image *texImage,

-                          GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   texel[RCOMP] =

-   texel[GCOMP] =

-   texel[BCOMP] = USHORT_TO_FLOAT( src[0] );

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void store_texel_l16(struct gl_texture_image *texImage,

-                            GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLushort *rgba = (const GLushort *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   *dst = rgba[RCOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_I8 ************************************************************/

-

-/* Fetch texel from 1D, 2D or 3D i8 texture, return 4 GLchans */

-static void FETCH(f_i8)( const struct gl_texture_image *texImage,

-                         GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);

-   texel[RCOMP] =

-   texel[GCOMP] =

-   texel[BCOMP] =

-   texel[ACOMP] = UBYTE_TO_FLOAT( src[0] );

-}

-

-#if DIM == 3

-static void store_texel_i8(struct gl_texture_image *texImage,

-                           GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);

-   *dst = rgba[RCOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_I16 ***********************************************************/

-

-/* Fetch texel from 1D, 2D or 3D i16 texture, return 4 GLchans */

-static void FETCH(f_i16)( const struct gl_texture_image *texImage,

-                          GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   texel[RCOMP] =

-   texel[GCOMP] =

-   texel[BCOMP] =

-   texel[ACOMP] = USHORT_TO_FLOAT( src[0] );

-}

-

-#if DIM == 3

-static void store_texel_i16(struct gl_texture_image *texImage,

-                            GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLushort *rgba = (const GLushort *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);

-   *dst = rgba[RCOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_CI8 ***********************************************************/

-

-/* Fetch CI texel from 1D, 2D or 3D ci8 texture, lookup the index in a

- * color table, and return 4 GLchans.

- */

-static void FETCH(f_ci8)( const struct gl_texture_image *texImage,

-                          GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);

-   const struct gl_color_table *palette;

-   GLuint index;

-   GET_CURRENT_CONTEXT(ctx);

-

-   if (ctx->Texture.SharedPalette) {

-      palette = &ctx->Texture.Palette;

-   }

-   else {

-      palette = &texImage->TexObject->Palette;

-   }

-   if (palette->Size == 0)

-      return; /* undefined results */

-

-   /* Mask the index against size of palette to avoid going out of bounds */

-   index = (*src) & (palette->Size - 1);

-

-   {

-      const GLfloat *table = palette->TableF;

-      switch (palette->_BaseFormat) {

-      case GL_ALPHA:

-         texel[RCOMP] =

-         texel[GCOMP] =

-         texel[BCOMP] = 0.0F;

-         texel[ACOMP] = table[index];

-         break;

-      case GL_LUMINANCE:

-         texel[RCOMP] =

-         texel[GCOMP] =

-         texel[BCOMP] = table[index];

-         texel[ACOMP] = 1.0F;

-         break;

-      case GL_INTENSITY:

-         texel[RCOMP] =

-         texel[GCOMP] =

-         texel[BCOMP] =

-         texel[ACOMP] = table[index];

-         break;

-      case GL_LUMINANCE_ALPHA:

-         texel[RCOMP] =

-         texel[GCOMP] =

-         texel[BCOMP] = table[index * 2 + 0];

-         texel[ACOMP] = table[index * 2 + 1];

-         break;

-      case GL_RGB:

-         texel[RCOMP] = table[index * 3 + 0];

-         texel[GCOMP] = table[index * 3 + 1];

-         texel[BCOMP] = table[index * 3 + 2];

-         texel[ACOMP] = 1.0F;

-         break;

-      case GL_RGBA:

-         texel[RCOMP] = table[index * 4 + 0];

-         texel[GCOMP] = table[index * 4 + 1];

-         texel[BCOMP] = table[index * 4 + 2];

-         texel[ACOMP] = table[index * 4 + 3];

-         break;

-      default:

-         _mesa_problem(ctx, "Bad palette format in fetch_texel_ci8");

-         return;

-      }

-   }

-}

-

-#if DIM == 3

-static void store_texel_ci8(struct gl_texture_image *texImage,

-                            GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *index = (const GLubyte *) texel;

-   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);

-   *dst = *index;

-}

-#endif

-

-

-/* Fetch texel from 1D, 2D or 3D srgb8 texture, return 4 GLfloats */

-/* Note: component order is same as for MESA_FORMAT_RGB888 */

-static void FETCH(srgb8)(const struct gl_texture_image *texImage,

-                         GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);

-   texel[RCOMP] = nonlinear_to_linear(src[2]);

-   texel[GCOMP] = nonlinear_to_linear(src[1]);

-   texel[BCOMP] = nonlinear_to_linear(src[0]);

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void store_texel_srgb8(struct gl_texture_image *texImage,

-                              GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);

-   dst[0] = rgba[BCOMP]; /* no conversion */

-   dst[1] = rgba[GCOMP];

-   dst[2] = rgba[RCOMP];

-}

-#endif

-

-/* Fetch texel from 1D, 2D or 3D srgba8 texture, return 4 GLfloats */

-static void FETCH(srgba8)(const struct gl_texture_image *texImage,

-                          GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   texel[RCOMP] = nonlinear_to_linear( (s >> 24) );

-   texel[GCOMP] = nonlinear_to_linear( (s >> 16) & 0xff );

-   texel[BCOMP] = nonlinear_to_linear( (s >>  8) & 0xff );

-   texel[ACOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff ); /* linear! */

-}

-

-#if DIM == 3

-static void store_texel_srgba8(struct gl_texture_image *texImage,

-                               GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);

-}

-#endif

-

-/* Fetch texel from 1D, 2D or 3D sargb8 texture, return 4 GLfloats */

-static void FETCH(sargb8)(const struct gl_texture_image *texImage,

-                          GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   texel[RCOMP] = nonlinear_to_linear( (s >> 16) & 0xff );

-   texel[GCOMP] = nonlinear_to_linear( (s >>  8) & 0xff );

-   texel[BCOMP] = nonlinear_to_linear( (s      ) & 0xff );

-   texel[ACOMP] = UBYTE_TO_FLOAT( (s >> 24) ); /* linear! */

-}

-

-#if DIM == 3

-static void store_texel_sargb8(struct gl_texture_image *texImage,

-                               GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_8888(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);

-}

-#endif

-

-/* Fetch texel from 1D, 2D or 3D sl8 texture, return 4 GLfloats */

-static void FETCH(sl8)(const struct gl_texture_image *texImage,

-                       GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);

-   texel[RCOMP] = 

-   texel[GCOMP] = 

-   texel[BCOMP] = nonlinear_to_linear(src[0]);

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void store_texel_sl8(struct gl_texture_image *texImage,

-                            GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);

-   dst[0] = rgba[RCOMP];

-}

-#endif

-

-/* Fetch texel from 1D, 2D or 3D sla8 texture, return 4 GLfloats */

-static void FETCH(sla8)(const struct gl_texture_image *texImage,

-                       GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 2);

-   texel[RCOMP] =

-   texel[GCOMP] =

-   texel[BCOMP] = nonlinear_to_linear(src[0]);

-   texel[ACOMP] = UBYTE_TO_FLOAT(src[1]); /* linear */

-}

-

-#if DIM == 3

-static void store_texel_sla8(struct gl_texture_image *texImage,

-                            GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 2);

-   dst[0] = rgba[RCOMP];

-   dst[1] = rgba[ACOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_RGBA_INT8 **************************************************/

-

-static void

-FETCH(rgba_int8)(const struct gl_texture_image *texImage,

-                 GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLbyte *src = TEXEL_ADDR(GLbyte, texImage, i, j, k, 4);

-   texel[RCOMP] = (GLfloat) src[0];

-   texel[GCOMP] = (GLfloat) src[1];

-   texel[BCOMP] = (GLfloat) src[2];

-   texel[ACOMP] = (GLfloat) src[3];

-}

-

-#if DIM == 3

-static void

-store_texel_rgba_int8(struct gl_texture_image *texImage,

-                      GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLbyte *rgba = (const GLbyte *) texel;

-   GLbyte *dst = TEXEL_ADDR(GLbyte, texImage, i, j, k, 4);

-   dst[0] = rgba[RCOMP];

-   dst[1] = rgba[GCOMP];

-   dst[2] = rgba[BCOMP];

-   dst[3] = rgba[ACOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_RGBA_INT16 **************************************************/

-

-static void

-FETCH(rgba_int16)(const struct gl_texture_image *texImage,

-                  GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLshort *src = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);

-   texel[RCOMP] = (GLfloat) src[0];

-   texel[GCOMP] = (GLfloat) src[1];

-   texel[BCOMP] = (GLfloat) src[2];

-   texel[ACOMP] = (GLfloat) src[3];

-}

-

-#if DIM == 3

-static void

-store_texel_rgba_int16(struct gl_texture_image *texImage,

-                       GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLshort *rgba = (const GLshort *) texel;

-   GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);

-   dst[0] = rgba[RCOMP];

-   dst[1] = rgba[GCOMP];

-   dst[2] = rgba[BCOMP];

-   dst[3] = rgba[ACOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_RGBA_INT32 **************************************************/

-

-static void

-FETCH(rgba_int32)(const struct gl_texture_image *texImage,

-                  GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLint *src = TEXEL_ADDR(GLint, texImage, i, j, k, 4);

-   texel[RCOMP] = (GLfloat) src[0];

-   texel[GCOMP] = (GLfloat) src[1];

-   texel[BCOMP] = (GLfloat) src[2];

-   texel[ACOMP] = (GLfloat) src[3];

-}

-

-#if DIM == 3

-static void

-store_texel_rgba_int32(struct gl_texture_image *texImage,

-                       GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLint *rgba = (const GLint *) texel;

-   GLint *dst = TEXEL_ADDR(GLint, texImage, i, j, k, 4);

-   dst[0] = rgba[RCOMP];

-   dst[1] = rgba[GCOMP];

-   dst[2] = rgba[BCOMP];

-   dst[3] = rgba[ACOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_RGBA_UINT8 **************************************************/

-

-static void

-FETCH(rgba_uint8)(const struct gl_texture_image *texImage,

-                 GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 4);

-   texel[RCOMP] = (GLfloat) src[0];

-   texel[GCOMP] = (GLfloat) src[1];

-   texel[BCOMP] = (GLfloat) src[2];

-   texel[ACOMP] = (GLfloat) src[3];

-}

-

-#if DIM == 3

-static void

-store_texel_rgba_uint8(struct gl_texture_image *texImage,

-                      GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 4);

-   dst[0] = rgba[RCOMP];

-   dst[1] = rgba[GCOMP];

-   dst[2] = rgba[BCOMP];

-   dst[3] = rgba[ACOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_RGBA_UINT16 **************************************************/

-

-static void

-FETCH(rgba_uint16)(const struct gl_texture_image *texImage,

-                  GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);

-   texel[RCOMP] = (GLfloat) src[0];

-   texel[GCOMP] = (GLfloat) src[1];

-   texel[BCOMP] = (GLfloat) src[2];

-   texel[ACOMP] = (GLfloat) src[3];

-}

-

-#if DIM == 3

-static void

-store_texel_rgba_uint16(struct gl_texture_image *texImage,

-                       GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLushort *rgba = (const GLushort *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);

-   dst[0] = rgba[RCOMP];

-   dst[1] = rgba[GCOMP];

-   dst[2] = rgba[BCOMP];

-   dst[3] = rgba[ACOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_RGBA_UINT32 **************************************************/

-

-static void

-FETCH(rgba_uint32)(const struct gl_texture_image *texImage,

-                  GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 4);

-   texel[RCOMP] = (GLfloat) src[0];

-   texel[GCOMP] = (GLfloat) src[1];

-   texel[BCOMP] = (GLfloat) src[2];

-   texel[ACOMP] = (GLfloat) src[3];

-}

-

-#if DIM == 3

-static void

-store_texel_rgba_uint32(struct gl_texture_image *texImage,

-                       GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLuint *rgba = (const GLuint *) texel;

-   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 4);

-   dst[0] = rgba[RCOMP];

-   dst[1] = rgba[GCOMP];

-   dst[2] = rgba[BCOMP];

-   dst[3] = rgba[ACOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_DUDV8 ********************************************************/

-

-/* this format by definition produces 0,0,0,1 as rgba values,

-   however we'll return the dudv values as rg and fix up elsewhere */

-static void FETCH(dudv8)(const struct gl_texture_image *texImage,

-                         GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLbyte *src = TEXEL_ADDR(GLbyte, texImage, i, j, k, 2);

-   texel[RCOMP] = BYTE_TO_FLOAT(src[0]);

-   texel[GCOMP] = BYTE_TO_FLOAT(src[1]);

-   texel[BCOMP] = 0;

-   texel[ACOMP] = 0;

-}

-

-

-/* MESA_FORMAT_SIGNED_R8 ***********************************************/

-

-static void FETCH(signed_r8)( const struct gl_texture_image *texImage,

-                              GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLbyte s = *TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);

-   texel[RCOMP] = BYTE_TO_FLOAT_TEX( s );

-   texel[GCOMP] = 0.0F;

-   texel[BCOMP] = 0.0F;

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void store_texel_signed_r8(struct gl_texture_image *texImage,

-                                  GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLbyte *rgba = (const GLbyte *) texel;

-   GLbyte *dst = TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);

-   *dst = rgba[RCOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_SIGNED_RG88 ***********************************************/

-

-static void FETCH(signed_rg88)( const struct gl_texture_image *texImage,

-                                GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLushort s = *TEXEL_ADDR(GLshort, texImage, i, j, k, 1);

-   texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 8) );

-   texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s & 0xff) );

-   texel[BCOMP] = 0.0F;

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void store_texel_signed_rg88(struct gl_texture_image *texImage,

-                                    GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLbyte *rg = (const GLbyte *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 2);

-   *dst = PACK_COLOR_88(rg[RCOMP], rg[GCOMP]);

-}

-#endif

-

-

-/* MESA_FORMAT_SIGNED_RGBX8888 ***********************************************/

-

-static void FETCH(signed_rgbx8888)( const struct gl_texture_image *texImage,

-			            GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 24) );

-   texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 16) );

-   texel[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >>  8) );

-   texel[ACOMP] = 1.0f;

-}

-

-#if DIM == 3

-static void store_texel_signed_rgbx8888(struct gl_texture_image *texImage,

-                                        GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLbyte *rgba = (const GLbyte *) texel;

-   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], 255);

-}

-#endif

-

-

-/* MESA_FORMAT_SIGNED_RGBA8888 ***********************************************/

-

-static void FETCH(signed_rgba8888)( const struct gl_texture_image *texImage,

-			            GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 24) );

-   texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 16) );

-   texel[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >>  8) );

-   texel[ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s      ) );

-}

-

-#if DIM == 3

-static void store_texel_signed_rgba8888(struct gl_texture_image *texImage,

-                                        GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLbyte *rgba = (const GLbyte *) texel;

-   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);

-}

-#endif

-

-static void FETCH(signed_rgba8888_rev)( const struct gl_texture_image *texImage,

-                                        GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s      ) );

-   texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >>  8) );

-   texel[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 16) );

-   texel[ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 24) );

-}

-

-#if DIM == 3

-static void store_texel_signed_rgba8888_rev(struct gl_texture_image *texImage,

-                                            GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLubyte *rgba = (const GLubyte *) texel;

-   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   *dst = PACK_COLOR_8888_REV(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);

-}

-#endif

-

-

-

-/* MESA_FORMAT_SIGNED_R_16 ***********************************************/

-

-static void

-FETCH(signed_r_16)(const struct gl_texture_image *texImage,

-                   GLint i, GLint j, GLint k, GLfloat *texel)

-{

-   const GLshort s = *TEXEL_ADDR(GLshort, texImage, i, j, k, 1);

-   texel[RCOMP] = SHORT_TO_FLOAT_TEX( s );

-   texel[GCOMP] = 0.0F;

-   texel[BCOMP] = 0.0F;

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void

-store_texel_signed_r_16(struct gl_texture_image *texImage,

-                        GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLshort *rgba = (const GLshort *) texel;

-   GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 1);

-   *dst = rgba[0];

-}

-#endif

-

-

-/* MESA_FORMAT_SIGNED_RG_16 ***********************************************/

-

-static void

-FETCH(signed_rg_16)(const struct gl_texture_image *texImage,

-                    GLint i, GLint j, GLint k, GLfloat *texel)

-{

-   const GLshort *s = TEXEL_ADDR(GLshort, texImage, i, j, k, 2);

-   texel[RCOMP] = SHORT_TO_FLOAT_TEX( s[0] );

-   texel[GCOMP] = SHORT_TO_FLOAT_TEX( s[1] );

-   texel[BCOMP] = 0.0F;

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void

-store_texel_signed_rg_16(struct gl_texture_image *texImage,

-                         GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLshort *rgba = (const GLshort *) texel;

-   GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 2);

-   dst[0] = rgba[RCOMP];

-   dst[1] = rgba[GCOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_SIGNED_RGBA_16 ***********************************************/

-

-static void 

-FETCH(signed_rgb_16)(const struct gl_texture_image *texImage,

-                     GLint i, GLint j, GLint k, GLfloat *texel)

-{

-   const GLshort *s = TEXEL_ADDR(GLshort, texImage, i, j, k, 3);

-   texel[RCOMP] = SHORT_TO_FLOAT_TEX( s[0] );

-   texel[GCOMP] = SHORT_TO_FLOAT_TEX( s[1] );

-   texel[BCOMP] = SHORT_TO_FLOAT_TEX( s[2] );

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void

-store_texel_signed_rgb_16(struct gl_texture_image *texImage,

-                          GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLshort *rgba = (const GLshort *) texel;

-   GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 3);

-   dst[0] = rgba[RCOMP];

-   dst[1] = rgba[GCOMP];

-   dst[2] = rgba[BCOMP];

-}

-#endif

-

-

-/* MESA_FORMAT_SIGNED_RGBA_16 ***********************************************/

-

-static void

-FETCH(signed_rgba_16)(const struct gl_texture_image *texImage,

-                      GLint i, GLint j, GLint k, GLfloat *texel)

-{

-   const GLshort *s = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);

-   texel[RCOMP] = SHORT_TO_FLOAT_TEX( s[0] );

-   texel[GCOMP] = SHORT_TO_FLOAT_TEX( s[1] );

-   texel[BCOMP] = SHORT_TO_FLOAT_TEX( s[2] );

-   texel[ACOMP] = SHORT_TO_FLOAT_TEX( s[3] );

-}

-

-#if DIM == 3

-static void

-store_texel_signed_rgba_16(struct gl_texture_image *texImage,

-                           GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLshort *rgba = (const GLshort *) texel;

-   GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);

-   dst[0] = rgba[RCOMP];

-   dst[1] = rgba[GCOMP];

-   dst[2] = rgba[BCOMP];

-   dst[3] = rgba[ACOMP];

-}

-#endif

-

-

-

-/* MESA_FORMAT_RGBA_16 ***********************************************/

-

-static void

-FETCH(rgba_16)(const struct gl_texture_image *texImage,

-               GLint i, GLint j, GLint k, GLfloat *texel)

-{

-   const GLushort *s = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);

-   texel[RCOMP] = USHORT_TO_FLOAT( s[0] );

-   texel[GCOMP] = USHORT_TO_FLOAT( s[1] );

-   texel[BCOMP] = USHORT_TO_FLOAT( s[2] );

-   texel[ACOMP] = USHORT_TO_FLOAT( s[3] );

-}

-

-#if DIM == 3

-static void

-store_texel_rgba_16(struct gl_texture_image *texImage,

-                    GLint i, GLint j, GLint k, const void *texel)

-{

-   const GLushort *rgba = (const GLushort *) texel;

-   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);

-   dst[0] = rgba[RCOMP];

-   dst[1] = rgba[GCOMP];

-   dst[2] = rgba[BCOMP];

-   dst[3] = rgba[ACOMP];

-}

-#endif

-

-

-

-/* MESA_FORMAT_YCBCR *********************************************************/

-

-/* Fetch texel from 1D, 2D or 3D ycbcr texture, return 4 GLfloats.

- * We convert YCbCr to RGB here.

- */

-static void FETCH(f_ycbcr)( const struct gl_texture_image *texImage,

-                            GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLushort *src0 = TEXEL_ADDR(GLushort, texImage, (i & ~1), j, k, 1); /* even */

-   const GLushort *src1 = src0 + 1;                               /* odd */

-   const GLubyte y0 = (*src0 >> 8) & 0xff;  /* luminance */

-   const GLubyte cb = *src0 & 0xff;         /* chroma U */

-   const GLubyte y1 = (*src1 >> 8) & 0xff;  /* luminance */

-   const GLubyte cr = *src1 & 0xff;         /* chroma V */

-   const GLubyte y = (i & 1) ? y1 : y0;     /* choose even/odd luminance */

-   GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128);

-   GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);

-   GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128);

-   r *= (1.0F / 255.0F);

-   g *= (1.0F / 255.0F);

-   b *= (1.0F / 255.0F);

-   texel[RCOMP] = CLAMP(r, 0.0F, 1.0F);

-   texel[GCOMP] = CLAMP(g, 0.0F, 1.0F);

-   texel[BCOMP] = CLAMP(b, 0.0F, 1.0F);

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void store_texel_ycbcr(struct gl_texture_image *texImage,

-                              GLint i, GLint j, GLint k, const void *texel)

-{

-   (void) texImage;

-   (void) i;

-   (void) j;

-   (void) k;

-   (void) texel;

-   /* XXX to do */

-}

-#endif

-

-

-/* MESA_FORMAT_YCBCR_REV *****************************************************/

-

-/* Fetch texel from 1D, 2D or 3D ycbcr_rev texture, return 4 GLfloats.

- * We convert YCbCr to RGB here.

- */

-static void FETCH(f_ycbcr_rev)( const struct gl_texture_image *texImage,

-                                GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   const GLushort *src0 = TEXEL_ADDR(GLushort, texImage, (i & ~1), j, k, 1); /* even */

-   const GLushort *src1 = src0 + 1;                               /* odd */

-   const GLubyte y0 = *src0 & 0xff;         /* luminance */

-   const GLubyte cr = (*src0 >> 8) & 0xff;  /* chroma V */

-   const GLubyte y1 = *src1 & 0xff;         /* luminance */

-   const GLubyte cb = (*src1 >> 8) & 0xff;  /* chroma U */

-   const GLubyte y = (i & 1) ? y1 : y0;     /* choose even/odd luminance */

-   GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128);

-   GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);

-   GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128);

-   r *= (1.0F / 255.0F);

-   g *= (1.0F / 255.0F);

-   b *= (1.0F / 255.0F);

-   texel[RCOMP] = CLAMP(r, 0.0F, 1.0F);

-   texel[GCOMP] = CLAMP(g, 0.0F, 1.0F);

-   texel[BCOMP] = CLAMP(b, 0.0F, 1.0F);

-   texel[ACOMP] = 1.0F;

-}

-

-#if DIM == 3

-static void store_texel_ycbcr_rev(struct gl_texture_image *texImage,

-                                  GLint i, GLint j, GLint k, const void *texel)

-{

-   (void) texImage;

-   (void) i;

-   (void) j;

-   (void) k;

-   (void) texel;

-   /* XXX to do */

-}

-#endif

-

-

-/* MESA_TEXFORMAT_Z24_S8 ***************************************************/

-

-static void FETCH(f_z24_s8)( const struct gl_texture_image *texImage,

-                             GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   /* only return Z, not stencil data */

-   const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   const GLfloat scale = 1.0F / (GLfloat) 0xffffff;

-   texel[0] = ((*src) >> 8) * scale;

-   ASSERT(texImage->TexFormat == MESA_FORMAT_Z24_S8);

-   ASSERT(texel[0] >= 0.0F);

-   ASSERT(texel[0] <= 1.0F);

-}

-

-#if DIM == 3

-static void store_texel_z24_s8(struct gl_texture_image *texImage,

-                               GLint i, GLint j, GLint k, const void *texel)

-{

-   /* only store Z, not stencil */

-   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   GLfloat depth = *((GLfloat *) texel);

-   GLuint zi = ((GLuint) (depth * 0xffffff)) << 8;

-   *dst = zi | (*dst & 0xff);

-}

-#endif

-

-

-/* MESA_TEXFORMAT_S8_Z24 ***************************************************/

-

-static void FETCH(f_s8_z24)( const struct gl_texture_image *texImage,

-                             GLint i, GLint j, GLint k, GLfloat *texel )

-{

-   /* only return Z, not stencil data */

-   const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   const GLfloat scale = 1.0F / (GLfloat) 0xffffff;

-   texel[0] = ((*src) & 0x00ffffff) * scale;

-   ASSERT(texImage->TexFormat == MESA_FORMAT_S8_Z24);

-   ASSERT(texel[0] >= 0.0F);

-   ASSERT(texel[0] <= 1.0F);

-}

-

-#if DIM == 3

-static void store_texel_s8_z24(struct gl_texture_image *texImage,

-                               GLint i, GLint j, GLint k, const void *texel)

-{

-   /* only store Z, not stencil */

-   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);

-   GLfloat depth = *((GLfloat *) texel);

-   GLuint zi = (GLuint) (depth * 0xffffff);

-   *dst = zi | (*dst & 0xff000000);

-}

-#endif

-

-

-#undef TEXEL_ADDR

-#undef DIM

-#undef FETCH

+/*
+ * Mesa 3-D graphics library
+ * Version:  7.7
+ *
+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (c) 2008-2009  VMware, Inc.
+ *
+ * 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.
+ */
+
+
+/**
+ * \file texfetch_tmp.h
+ * Texel fetch functions template.
+ * 
+ * This template file is used by texfetch.c to generate texel fetch functions
+ * for 1-D, 2-D and 3-D texture images. 
+ *
+ * It should be expanded by defining \p DIM as the number texture dimensions
+ * (1, 2 or 3).  According to the value of \p DIM a series of macros is defined
+ * for the texel lookup in the gl_texture_image::Data.
+ * 
+ * \author Gareth Hughes
+ * \author Brian Paul
+ */
+
+
+#if DIM == 1
+
+#define TEXEL_ADDR( type, image, i, j, k, size ) \
+	((void) (j), (void) (k), ((type *)(image)->Data + (i) * (size)))
+
+#define FETCH(x) fetch_texel_1d_##x
+
+#elif DIM == 2
+
+#define TEXEL_ADDR( type, image, i, j, k, size )			\
+	((void) (k),							\
+	 ((type *)(image)->Data + ((image)->RowStride * (j) + (i)) * (size)))
+
+#define FETCH(x) fetch_texel_2d_##x
+
+#elif DIM == 3
+
+#define TEXEL_ADDR( type, image, i, j, k, size )			\
+	((type *)(image)->Data + ((image)->ImageOffsets[k]		\
+             + (image)->RowStride * (j) + (i)) * (size))
+
+#define FETCH(x) fetch_texel_3d_##x
+
+#else
+#error	illegal number of texture dimensions
+#endif
+
+
+/* MESA_FORMAT_Z32 ***********************************************************/
+
+/* Fetch depth texel from 1D, 2D or 3D 32-bit depth texture,
+ * returning 1 GLfloat.
+ * Note: no GLchan version of this function.
+ */
+static void FETCH(f_z32)( const struct gl_texture_image *texImage,
+                          GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[0] = src[0] * (1.0F / 0xffffffff);
+}
+
+#if DIM == 3
+static void store_texel_z32(struct gl_texture_image *texImage,
+                            GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLuint *depth = (const GLuint *) texel;
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   dst[0] = *depth;
+}
+#endif
+
+
+/* MESA_FORMAT_Z16 ***********************************************************/
+
+/* Fetch depth texel from 1D, 2D or 3D 16-bit depth texture,
+ * returning 1 GLfloat.
+ * Note: no GLchan version of this function.
+ */
+static void FETCH(f_z16)(const struct gl_texture_image *texImage,
+                         GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   texel[0] = src[0] * (1.0F / 65535.0F);
+}
+
+#if DIM == 3
+static void store_texel_z16(struct gl_texture_image *texImage,
+                            GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLushort *depth = (const GLushort *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   dst[0] = *depth;
+}
+#endif
+
+
+/* MESA_FORMAT_RGBA_F32 ******************************************************/
+
+/* Fetch texel from 1D, 2D or 3D RGBA_FLOAT32 texture, returning 4 GLfloats.
+ */
+static void FETCH(f_rgba_f32)( const struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 4);
+   texel[RCOMP] = src[0];
+   texel[GCOMP] = src[1];
+   texel[BCOMP] = src[2];
+   texel[ACOMP] = src[3];
+}
+
+#if DIM == 3
+static void store_texel_rgba_f32(struct gl_texture_image *texImage,
+                                 GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLfloat *depth = (const GLfloat *) texel;
+   GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 4);
+   dst[0] = depth[RCOMP];
+   dst[1] = depth[GCOMP];
+   dst[2] = depth[BCOMP];
+   dst[3] = depth[ACOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_RGBA_F16 ******************************************************/
+
+/* Fetch texel from 1D, 2D or 3D RGBA_FLOAT16 texture,
+ * returning 4 GLfloats.
+ */
+static void FETCH(f_rgba_f16)( const struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 4);
+   texel[RCOMP] = _mesa_half_to_float(src[0]);
+   texel[GCOMP] = _mesa_half_to_float(src[1]);
+   texel[BCOMP] = _mesa_half_to_float(src[2]);
+   texel[ACOMP] = _mesa_half_to_float(src[3]);
+}
+
+#if DIM == 3
+static void store_texel_rgba_f16(struct gl_texture_image *texImage,
+                                 GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLfloat *src = (const GLfloat *) texel;
+   GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 4);
+   dst[0] = _mesa_float_to_half(src[RCOMP]);
+   dst[1] = _mesa_float_to_half(src[GCOMP]);
+   dst[2] = _mesa_float_to_half(src[BCOMP]);
+   dst[3] = _mesa_float_to_half(src[ACOMP]);
+}
+#endif
+
+/* MESA_FORMAT_RGB_F32 *******************************************************/
+
+/* Fetch texel from 1D, 2D or 3D RGB_FLOAT32 texture,
+ * returning 4 GLfloats.
+ */
+static void FETCH(f_rgb_f32)( const struct gl_texture_image *texImage,
+                              GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 3);
+   texel[RCOMP] = src[0];
+   texel[GCOMP] = src[1];
+   texel[BCOMP] = src[2];
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_rgb_f32(struct gl_texture_image *texImage,
+                                 GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLfloat *src = (const GLfloat *) texel;
+   GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 3);
+   dst[0] = src[RCOMP];
+   dst[1] = src[GCOMP];
+   dst[2] = src[BCOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_RGB_F16 *******************************************************/
+
+/* Fetch texel from 1D, 2D or 3D RGB_FLOAT16 texture,
+ * returning 4 GLfloats.
+ */
+static void FETCH(f_rgb_f16)( const struct gl_texture_image *texImage,
+                              GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 3);
+   texel[RCOMP] = _mesa_half_to_float(src[0]);
+   texel[GCOMP] = _mesa_half_to_float(src[1]);
+   texel[BCOMP] = _mesa_half_to_float(src[2]);
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_rgb_f16(struct gl_texture_image *texImage,
+                                GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLfloat *src = (const GLfloat *) texel;
+   GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 3);
+   dst[0] = _mesa_float_to_half(src[RCOMP]);
+   dst[1] = _mesa_float_to_half(src[GCOMP]);
+   dst[2] = _mesa_float_to_half(src[BCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_ALPHA_F32 *****************************************************/
+
+/* Fetch texel from 1D, 2D or 3D ALPHA_FLOAT32 texture,
+ * returning 4 GLfloats.
+ */
+static void FETCH(f_alpha_f32)( const struct gl_texture_image *texImage,
+                              GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] = 0.0F;
+   texel[ACOMP] = src[0];
+}
+
+#if DIM == 3
+static void store_texel_alpha_f32(struct gl_texture_image *texImage,
+                                  GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLfloat *rgba = (const GLfloat *) texel;
+   GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
+   dst[0] = rgba[ACOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_ALPHA_F32 *****************************************************/
+
+/* Fetch texel from 1D, 2D or 3D ALPHA_FLOAT16 texture,
+ * returning 4 GLfloats.
+ */
+static void FETCH(f_alpha_f16)( const struct gl_texture_image *texImage,
+                              GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] = 0.0F;
+   texel[ACOMP] = _mesa_half_to_float(src[0]);
+}
+
+#if DIM == 3
+static void store_texel_alpha_f16(struct gl_texture_image *texImage,
+                                  GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLfloat *rgba = (const GLfloat *) texel;
+   GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
+   dst[0] = _mesa_float_to_half(rgba[ACOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_LUMINANCE_F32 *************************************************/
+
+/* Fetch texel from 1D, 2D or 3D LUMINANCE_FLOAT32 texture,
+ * returning 4 GLfloats.
+ */
+static void FETCH(f_luminance_f32)( const struct gl_texture_image *texImage,
+                                    GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] = src[0];
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_luminance_f32(struct gl_texture_image *texImage,
+                                  GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLfloat *rgba = (const GLfloat *) texel;
+   GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
+   dst[0] = rgba[RCOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_LUMINANCE_F16 *************************************************/
+
+/* Fetch texel from 1D, 2D or 3D LUMINANCE_FLOAT16 texture,
+ * returning 4 GLfloats.
+ */
+static void FETCH(f_luminance_f16)( const struct gl_texture_image *texImage,
+                                    GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] = _mesa_half_to_float(src[0]);
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_luminance_f16(struct gl_texture_image *texImage,
+                                  GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLfloat *rgba = (const GLfloat *) texel;
+   GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
+   dst[0] = _mesa_float_to_half(rgba[RCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_LUMINANCE_ALPHA_F32 *******************************************/
+
+/* Fetch texel from 1D, 2D or 3D LUMINANCE_ALPHA_FLOAT32 texture,
+ * returning 4 GLfloats.
+ */
+static void FETCH(f_luminance_alpha_f32)( const struct gl_texture_image *texImage,
+                                    GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 2);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] = src[0];
+   texel[ACOMP] = src[1];
+}
+
+#if DIM == 3
+static void store_texel_luminance_alpha_f32(struct gl_texture_image *texImage,
+                                  GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLfloat *rgba = (const GLfloat *) texel;
+   GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 2);
+   dst[0] = rgba[RCOMP];
+   dst[1] = rgba[ACOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_LUMINANCE_ALPHA_F16 *******************************************/
+
+/* Fetch texel from 1D, 2D or 3D LUMINANCE_ALPHA_FLOAT16 texture,
+ * returning 4 GLfloats.
+ */
+static void FETCH(f_luminance_alpha_f16)( const struct gl_texture_image *texImage,
+                                    GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 2);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] = _mesa_half_to_float(src[0]);
+   texel[ACOMP] = _mesa_half_to_float(src[1]);
+}
+
+#if DIM == 3
+static void store_texel_luminance_alpha_f16(struct gl_texture_image *texImage,
+                                  GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLfloat *rgba = (const GLfloat *) texel;
+   GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 2);
+   dst[0] = _mesa_float_to_half(rgba[RCOMP]);
+   dst[1] = _mesa_float_to_half(rgba[ACOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_INTENSITY_F32 *************************************************/
+
+/* Fetch texel from 1D, 2D or 3D INTENSITY_FLOAT32 texture,
+ * returning 4 GLfloats.
+ */
+static void FETCH(f_intensity_f32)( const struct gl_texture_image *texImage,
+                                    GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] =
+   texel[ACOMP] = src[0];
+}
+
+#if DIM == 3
+static void store_texel_intensity_f32(struct gl_texture_image *texImage,
+                                  GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLfloat *rgba = (const GLfloat *) texel;
+   GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
+   dst[0] = rgba[RCOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_INTENSITY_F16 *************************************************/
+
+/* Fetch texel from 1D, 2D or 3D INTENSITY_FLOAT16 texture,
+ * returning 4 GLfloats.
+ */
+static void FETCH(f_intensity_f16)( const struct gl_texture_image *texImage,
+                                    GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] =
+   texel[ACOMP] = _mesa_half_to_float(src[0]);
+}
+
+#if DIM == 3
+static void store_texel_intensity_f16(struct gl_texture_image *texImage,
+                                  GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLfloat *rgba = (const GLfloat *) texel;
+   GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
+   dst[0] = _mesa_float_to_half(rgba[RCOMP]);
+}
+#endif
+
+
+
+
+/*
+ * Begin Hardware formats
+ */
+
+/* MESA_FORMAT_RGBA8888 ******************************************************/
+
+/* Fetch texel from 1D, 2D or 3D rgba8888 texture, return 4 GLfloats */
+static void FETCH(f_rgba8888)( const struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[RCOMP] = UBYTE_TO_FLOAT( (s >> 24)        );
+   texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
+   texel[BCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
+   texel[ACOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );
+}
+
+
+
+#if DIM == 3
+static void store_texel_rgba8888(struct gl_texture_image *texImage,
+                                 GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_RGBA888_REV ***************************************************/
+
+/* Fetch texel from 1D, 2D or 3D abgr8888 texture, return 4 GLchans */
+static void FETCH(f_rgba8888_rev)( const struct gl_texture_image *texImage,
+                                   GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[RCOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );
+   texel[GCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
+   texel[BCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
+   texel[ACOMP] = UBYTE_TO_FLOAT( (s >> 24)        );
+}
+
+#if DIM == 3
+static void store_texel_rgba8888_rev(struct gl_texture_image *texImage,
+                                  GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_8888_REV(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_ARGB8888 ******************************************************/
+
+/* Fetch texel from 1D, 2D or 3D argb8888 texture, return 4 GLchans */
+static void FETCH(f_argb8888)( const struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[RCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
+   texel[GCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
+   texel[BCOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );
+   texel[ACOMP] = UBYTE_TO_FLOAT( (s >> 24)        );
+}
+
+#if DIM == 3
+static void store_texel_argb8888(struct gl_texture_image *texImage,
+                                 GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_8888(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_ARGB8888_REV **************************************************/
+
+/* Fetch texel from 1D, 2D or 3D argb8888_rev texture, return 4 GLfloats */
+static void FETCH(f_argb8888_rev)( const struct gl_texture_image *texImage,
+                                   GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[RCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
+   texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
+   texel[BCOMP] = UBYTE_TO_FLOAT( (s >> 24)        );
+   texel[ACOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );
+}
+
+#if DIM == 3
+static void store_texel_argb8888_rev(struct gl_texture_image *texImage,
+                                  GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_8888(rgba[BCOMP], rgba[GCOMP], rgba[RCOMP], rgba[ACOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_XRGB8888 ******************************************************/
+
+/* Fetch texel from 1D, 2D or 3D xrgb8888 texture, return 4 GLchans */
+static void FETCH(f_xrgb8888)( const struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[RCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
+   texel[GCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
+   texel[BCOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff );
+   texel[ACOMP] = 1.0f;
+}
+
+#if DIM == 3
+static void store_texel_xrgb8888(struct gl_texture_image *texImage,
+                                 GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_8888(0xff, rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_XRGB8888_REV **************************************************/
+
+/* Fetch texel from 1D, 2D or 3D xrgb8888_rev texture, return 4 GLfloats */
+static void FETCH(f_xrgb8888_rev)( const struct gl_texture_image *texImage,
+                                   GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[RCOMP] = UBYTE_TO_FLOAT( (s >>  8) & 0xff );
+   texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
+   texel[BCOMP] = UBYTE_TO_FLOAT( (s >> 24)        );
+   texel[ACOMP] = 1.0f;
+}
+
+#if DIM == 3
+static void store_texel_xrgb8888_rev(struct gl_texture_image *texImage,
+                                     GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_8888(rgba[BCOMP], rgba[GCOMP], rgba[RCOMP], 0xff);
+}
+#endif
+
+
+/* MESA_FORMAT_RGB888 ********************************************************/
+
+/* Fetch texel from 1D, 2D or 3D rgb888 texture, return 4 GLchans */
+static void FETCH(f_rgb888)( const struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
+   texel[RCOMP] = UBYTE_TO_FLOAT( src[2] );
+   texel[GCOMP] = UBYTE_TO_FLOAT( src[1] );
+   texel[BCOMP] = UBYTE_TO_FLOAT( src[0] );
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_rgb888(struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
+   dst[0] = rgba[BCOMP];
+   dst[1] = rgba[GCOMP];
+   dst[2] = rgba[RCOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_BGR888 ********************************************************/
+
+/* Fetch texel from 1D, 2D or 3D bgr888 texture, return 4 GLchans */
+static void FETCH(f_bgr888)( const struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
+   texel[RCOMP] = UBYTE_TO_FLOAT( src[0] );
+   texel[GCOMP] = UBYTE_TO_FLOAT( src[1] );
+   texel[BCOMP] = UBYTE_TO_FLOAT( src[2] );
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_bgr888(struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
+   dst[0] = rgba[RCOMP];
+   dst[1] = rgba[GCOMP];
+   dst[2] = rgba[BCOMP];
+}
+#endif
+
+
+/* use color expansion like (g << 2) | (g >> 4) (does somewhat random rounding)
+   instead of slow (g << 2) * 255 / 252 (always rounds down) */
+
+/* MESA_FORMAT_RGB565 ********************************************************/
+
+/* Fetch texel from 1D, 2D or 3D rgb565 texture, return 4 GLchans */
+static void FETCH(f_rgb565)( const struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   const GLushort s = *src;
+   texel[RCOMP] = ((s >> 11) & 0x1f) * (1.0F / 31.0F);
+   texel[GCOMP] = ((s >> 5 ) & 0x3f) * (1.0F / 63.0F);
+   texel[BCOMP] = ((s      ) & 0x1f) * (1.0F / 31.0F);
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_rgb565(struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_565(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_RGB565_REV ****************************************************/
+
+/* Fetch texel from 1D, 2D or 3D rgb565_rev texture, return 4 GLchans */
+static void FETCH(f_rgb565_rev)( const struct gl_texture_image *texImage,
+                                 GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   const GLushort s = (*src >> 8) | (*src << 8); /* byte swap */
+   texel[RCOMP] = UBYTE_TO_FLOAT( ((s >> 8) & 0xf8) | ((s >> 13) & 0x7) );
+   texel[GCOMP] = UBYTE_TO_FLOAT( ((s >> 3) & 0xfc) | ((s >>  9) & 0x3) );
+   texel[BCOMP] = UBYTE_TO_FLOAT( ((s << 3) & 0xf8) | ((s >>  2) & 0x7) );
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_rgb565_rev(struct gl_texture_image *texImage,
+                                  GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_565(rgba[BCOMP], rgba[GCOMP], rgba[RCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_ARGB4444 ******************************************************/
+
+/* Fetch texel from 1D, 2D or 3D argb444 texture, return 4 GLchans */
+static void FETCH(f_argb4444)( const struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   const GLushort s = *src;
+   texel[RCOMP] = ((s >>  8) & 0xf) * (1.0F / 15.0F);
+   texel[GCOMP] = ((s >>  4) & 0xf) * (1.0F / 15.0F);
+   texel[BCOMP] = ((s      ) & 0xf) * (1.0F / 15.0F);
+   texel[ACOMP] = ((s >> 12) & 0xf) * (1.0F / 15.0F);
+}
+
+#if DIM == 3
+static void store_texel_argb4444(struct gl_texture_image *texImage,
+                                 GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_4444(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_ARGB4444_REV **************************************************/
+
+/* Fetch texel from 1D, 2D or 3D argb4444_rev texture, return 4 GLchans */
+static void FETCH(f_argb4444_rev)( const struct gl_texture_image *texImage,
+                                   GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   texel[RCOMP] = ((s      ) & 0xf) * (1.0F / 15.0F);
+   texel[GCOMP] = ((s >> 12) & 0xf) * (1.0F / 15.0F);
+   texel[BCOMP] = ((s >>  8) & 0xf) * (1.0F / 15.0F);
+   texel[ACOMP] = ((s >>  4) & 0xf) * (1.0F / 15.0F);
+}
+
+#if DIM == 3
+static void store_texel_argb4444_rev(struct gl_texture_image *texImage,
+                                 GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_4444(rgba[ACOMP], rgba[BCOMP], rgba[GCOMP], rgba[RCOMP]);
+}
+#endif
+
+/* MESA_FORMAT_RGBA5551 ******************************************************/
+
+/* Fetch texel from 1D, 2D or 3D argb1555 texture, return 4 GLchans */
+static void FETCH(f_rgba5551)( const struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   const GLushort s = *src;
+   texel[RCOMP] = ((s >> 11) & 0x1f) * (1.0F / 31.0F);
+   texel[GCOMP] = ((s >>  6) & 0x1f) * (1.0F / 31.0F);
+   texel[BCOMP] = ((s >>  1) & 0x1f) * (1.0F / 31.0F);
+   texel[ACOMP] = ((s      ) & 0x01) * 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_rgba5551(struct gl_texture_image *texImage,
+                                 GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_5551(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
+}
+#endif
+
+/* MESA_FORMAT_ARGB1555 ******************************************************/
+
+/* Fetch texel from 1D, 2D or 3D argb1555 texture, return 4 GLchans */
+static void FETCH(f_argb1555)( const struct gl_texture_image *texImage,
+			     GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   const GLushort s = *src;
+   texel[RCOMP] = ((s >> 10) & 0x1f) * (1.0F / 31.0F);
+   texel[GCOMP] = ((s >>  5) & 0x1f) * (1.0F / 31.0F);
+   texel[BCOMP] = ((s >>  0) & 0x1f) * (1.0F / 31.0F);
+   texel[ACOMP] = ((s >> 15) & 0x01) * 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_argb1555(struct gl_texture_image *texImage,
+                                 GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_1555(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_ARGB1555_REV **************************************************/
+
+/* Fetch texel from 1D, 2D or 3D argb1555_rev texture, return 4 GLchans */
+static void FETCH(f_argb1555_rev)( const struct gl_texture_image *texImage,
+                                   GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   const GLushort s = (*src << 8) | (*src >> 8); /* byteswap */
+   texel[RCOMP] = UBYTE_TO_FLOAT( ((s >>  7) & 0xf8) | ((s >> 12) & 0x7) );
+   texel[GCOMP] = UBYTE_TO_FLOAT( ((s >>  2) & 0xf8) | ((s >>  7) & 0x7) );
+   texel[BCOMP] = UBYTE_TO_FLOAT( ((s <<  3) & 0xf8) | ((s >>  2) & 0x7) );
+   texel[ACOMP] = UBYTE_TO_FLOAT( ((s >> 15) & 0x01) * 255 );
+}
+
+#if DIM == 3
+static void store_texel_argb1555_rev(struct gl_texture_image *texImage,
+                                 GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_1555_REV(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_ARGB2101010 ***************************************************/
+
+/* Fetch texel from 1D, 2D or 3D argb2101010 texture, return 4 GLchans */
+static void FETCH(f_argb2101010)( const struct gl_texture_image *texImage,
+                                  GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   const GLuint s = *src;
+   texel[RCOMP] = ((s >> 20) & 0x3ff) * (1.0F / 1023.0F);
+   texel[GCOMP] = ((s >> 10) & 0x3ff) * (1.0F / 1023.0F);
+   texel[BCOMP] = ((s >>  0) & 0x3ff) * (1.0F / 1023.0F);
+   texel[ACOMP] = ((s >> 30) & 0x03) * (1.0F / 3.0F);
+}
+
+#if DIM == 3
+static void store_texel_argb2101010(struct gl_texture_image *texImage,
+                                    GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_2101010_UB(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_RG88 **********************************************************/
+
+/* Fetch texel from 1D, 2D or 3D rg88 texture, return 4 GLchans */
+static void FETCH(f_rg88)( const struct gl_texture_image *texImage,
+                           GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   texel[RCOMP] = UBYTE_TO_FLOAT( s & 0xff );
+   texel[GCOMP] = UBYTE_TO_FLOAT( s >> 8 );
+   texel[BCOMP] = 0.0;
+   texel[ACOMP] = 1.0;
+}
+
+#if DIM == 3
+static void store_texel_rg88(struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_88(rgba[RCOMP], rgba[GCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_RG88_REV ******************************************************/
+
+/* Fetch texel from 1D, 2D or 3D rg88_rev texture, return 4 GLchans */
+static void FETCH(f_rg88_rev)( const struct gl_texture_image *texImage,
+                           GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   texel[RCOMP] = UBYTE_TO_FLOAT( s & 0xff );
+   texel[GCOMP] = UBYTE_TO_FLOAT( s >> 8 );
+   texel[BCOMP] = 0.0;
+   texel[ACOMP] = 1.0;
+}
+
+#if DIM == 3
+static void store_texel_rg88_rev(struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_88(rgba[GCOMP], rgba[RCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_AL44 **********************************************************/
+
+/* Fetch texel from 1D, 2D or 3D al44 texture, return 4 GLchans */
+static void FETCH(f_al44)( const struct gl_texture_image *texImage,
+                           GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLubyte s = *TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] = (s & 0xf) * (1.0F / 15.0F);
+   texel[ACOMP] = ((s >> 4) & 0xf) * (1.0F / 15.0F);
+}
+
+#if DIM == 3
+static void store_texel_al44(struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_44(rgba[ACOMP], rgba[RCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_AL88 **********************************************************/
+
+/* Fetch texel from 1D, 2D or 3D al88 texture, return 4 GLchans */
+static void FETCH(f_al88)( const struct gl_texture_image *texImage,
+                           GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   texel[RCOMP] = 
+   texel[GCOMP] = 
+   texel[BCOMP] = UBYTE_TO_FLOAT( s & 0xff );
+   texel[ACOMP] = UBYTE_TO_FLOAT( s >> 8 );
+}
+
+#if DIM == 3
+static void store_texel_al88(struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_88(rgba[ACOMP], rgba[RCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_R8 ************************************************************/
+
+/* Fetch texel from 1D, 2D or 3D rg88 texture, return 4 GLchans */
+static void FETCH(f_r8)(const struct gl_texture_image *texImage,
+			GLint i, GLint j, GLint k, GLfloat *texel)
+{
+   const GLubyte s = *TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
+   texel[RCOMP] = UBYTE_TO_FLOAT(s);
+   texel[GCOMP] = 0.0;
+   texel[BCOMP] = 0.0;
+   texel[ACOMP] = 1.0;
+}
+
+#if DIM == 3
+static void store_texel_r8(struct gl_texture_image *texImage,
+			   GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
+   *dst = rgba[RCOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_R16 ***********************************************************/
+
+/* Fetch texel from 1D, 2D or 3D r16 texture, return 4 GLchans */
+static void FETCH(f_r16)(const struct gl_texture_image *texImage,
+			GLint i, GLint j, GLint k, GLfloat *texel)
+{
+   const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   texel[RCOMP] = USHORT_TO_FLOAT(s);
+   texel[GCOMP] = 0.0;
+   texel[BCOMP] = 0.0;
+   texel[ACOMP] = 1.0;
+}
+
+#if DIM == 3
+static void store_texel_r16(struct gl_texture_image *texImage,
+			    GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLushort *rgba = (const GLushort *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   *dst = rgba[RCOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_AL88_REV ******************************************************/
+
+/* Fetch texel from 1D, 2D or 3D al88_rev texture, return 4 GLchans */
+static void FETCH(f_al88_rev)( const struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   texel[RCOMP] = 
+   texel[GCOMP] = 
+   texel[BCOMP] = UBYTE_TO_FLOAT( s >> 8 );
+   texel[ACOMP] = UBYTE_TO_FLOAT( s & 0xff );
+}
+
+#if DIM == 3
+static void store_texel_al88_rev(struct gl_texture_image *texImage,
+                                 GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_88(rgba[RCOMP], rgba[ACOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_RG1616 ********************************************************/
+
+/* Fetch texel from 1D, 2D or 3D rg1616 texture, return 4 GLchans */
+static void FETCH(f_rg1616)( const struct gl_texture_image *texImage,
+                           GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[RCOMP] = USHORT_TO_FLOAT( s & 0xffff );
+   texel[GCOMP] = USHORT_TO_FLOAT( s >> 16 );
+   texel[BCOMP] = 0.0;
+   texel[ACOMP] = 1.0;
+}
+
+#if DIM == 3
+static void store_texel_rg1616(struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_1616(rgba[RCOMP], rgba[GCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_RG1616_REV ****************************************************/
+
+/* Fetch texel from 1D, 2D or 3D rg1616_rev texture, return 4 GLchans */
+static void FETCH(f_rg1616_rev)( const struct gl_texture_image *texImage,
+                           GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[RCOMP] = USHORT_TO_FLOAT( s >> 16 );
+   texel[GCOMP] = USHORT_TO_FLOAT( s & 0xffff );
+   texel[BCOMP] = 0.0;
+   texel[ACOMP] = 1.0;
+}
+
+#if DIM == 3
+static void store_texel_rg1616_rev(struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_1616(rgba[GCOMP], rgba[RCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_AL1616 ********************************************************/
+
+/* Fetch texel from 1D, 2D or 3D al1616 texture, return 4 GLchans */
+static void FETCH(f_al1616)( const struct gl_texture_image *texImage,
+			     GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] = USHORT_TO_FLOAT( s & 0xffff );
+   texel[ACOMP] = USHORT_TO_FLOAT( s >> 16 );
+}
+
+#if DIM == 3
+static void store_texel_al1616(struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLushort *rgba = (const GLushort *) texel;
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_1616(rgba[ACOMP], rgba[RCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_AL1616_REV ****************************************************/
+
+/* Fetch texel from 1D, 2D or 3D al1616_rev texture, return 4 GLchans */
+static void FETCH(f_al1616_rev)( const struct gl_texture_image *texImage,
+				 GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] = USHORT_TO_FLOAT( s >> 16 );
+   texel[ACOMP] = USHORT_TO_FLOAT( s & 0xffff );
+}
+
+#if DIM == 3
+static void store_texel_al1616_rev(struct gl_texture_image *texImage,
+				   GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLushort *rgba = (const GLushort *) texel;
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_1616(rgba[RCOMP], rgba[ACOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_RGB332 ********************************************************/
+
+/* Fetch texel from 1D, 2D or 3D rgb332 texture, return 4 GLchans */
+static void FETCH(f_rgb332)( const struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
+   const GLubyte s = *src;
+   texel[RCOMP] = ((s >> 5) & 0x7) * (1.0F / 7.0F);
+   texel[GCOMP] = ((s >> 2) & 0x7) * (1.0F / 7.0F);
+   texel[BCOMP] = ((s     ) & 0x3) * (1.0F / 3.0F);
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_rgb332(struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_332(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_A8 ************************************************************/
+
+/* Fetch texel from 1D, 2D or 3D a8 texture, return 4 GLchans */
+static void FETCH(f_a8)( const struct gl_texture_image *texImage,
+                         GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] = 0.0F;
+   texel[ACOMP] = UBYTE_TO_FLOAT( src[0] );
+}
+
+#if DIM == 3
+static void store_texel_a8(struct gl_texture_image *texImage,
+                           GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
+   *dst = rgba[ACOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_A16 ************************************************************/
+
+/* Fetch texel from 1D, 2D or 3D a8 texture, return 4 GLchans */
+static void FETCH(f_a16)( const struct gl_texture_image *texImage,
+                          GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] = 0.0F;
+   texel[ACOMP] = USHORT_TO_FLOAT( src[0] );
+}
+
+#if DIM == 3
+static void store_texel_a16(struct gl_texture_image *texImage,
+                            GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLushort *rgba = (const GLushort *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   *dst = rgba[ACOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_L8 ************************************************************/
+
+/* Fetch texel from 1D, 2D or 3D l8 texture, return 4 GLchans */
+static void FETCH(f_l8)( const struct gl_texture_image *texImage,
+                         GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] = UBYTE_TO_FLOAT( src[0] );
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_l8(struct gl_texture_image *texImage,
+                           GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
+   *dst = rgba[RCOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_L16 ***********************************************************/
+
+/* Fetch texel from 1D, 2D or 3D l16 texture, return 4 GLchans */
+static void FETCH(f_l16)( const struct gl_texture_image *texImage,
+                          GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] = USHORT_TO_FLOAT( src[0] );
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_l16(struct gl_texture_image *texImage,
+                            GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLushort *rgba = (const GLushort *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   *dst = rgba[RCOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_I8 ************************************************************/
+
+/* Fetch texel from 1D, 2D or 3D i8 texture, return 4 GLchans */
+static void FETCH(f_i8)( const struct gl_texture_image *texImage,
+                         GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] =
+   texel[ACOMP] = UBYTE_TO_FLOAT( src[0] );
+}
+
+#if DIM == 3
+static void store_texel_i8(struct gl_texture_image *texImage,
+                           GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
+   *dst = rgba[RCOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_I16 ***********************************************************/
+
+/* Fetch texel from 1D, 2D or 3D i16 texture, return 4 GLchans */
+static void FETCH(f_i16)( const struct gl_texture_image *texImage,
+                          GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] =
+   texel[ACOMP] = USHORT_TO_FLOAT( src[0] );
+}
+
+#if DIM == 3
+static void store_texel_i16(struct gl_texture_image *texImage,
+                            GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLushort *rgba = (const GLushort *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   *dst = rgba[RCOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_CI8 ***********************************************************/
+
+/* Fetch CI texel from 1D, 2D or 3D ci8 texture, lookup the index in a
+ * color table, and return 4 GLchans.
+ */
+static void FETCH(f_ci8)( const struct gl_texture_image *texImage,
+                          GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
+   const struct gl_color_table *palette;
+   GLuint index;
+   GET_CURRENT_CONTEXT(ctx);
+
+   if (ctx->Texture.SharedPalette) {
+      palette = &ctx->Texture.Palette;
+   }
+   else {
+      palette = &texImage->TexObject->Palette;
+   }
+   if (palette->Size == 0)
+      return; /* undefined results */
+
+   /* Mask the index against size of palette to avoid going out of bounds */
+   index = (*src) & (palette->Size - 1);
+
+   {
+      const GLfloat *table = palette->TableF;
+      switch (palette->_BaseFormat) {
+      case GL_ALPHA:
+         texel[RCOMP] =
+         texel[GCOMP] =
+         texel[BCOMP] = 0.0F;
+         texel[ACOMP] = table[index];
+         break;
+      case GL_LUMINANCE:
+         texel[RCOMP] =
+         texel[GCOMP] =
+         texel[BCOMP] = table[index];
+         texel[ACOMP] = 1.0F;
+         break;
+      case GL_INTENSITY:
+         texel[RCOMP] =
+         texel[GCOMP] =
+         texel[BCOMP] =
+         texel[ACOMP] = table[index];
+         break;
+      case GL_LUMINANCE_ALPHA:
+         texel[RCOMP] =
+         texel[GCOMP] =
+         texel[BCOMP] = table[index * 2 + 0];
+         texel[ACOMP] = table[index * 2 + 1];
+         break;
+      case GL_RGB:
+         texel[RCOMP] = table[index * 3 + 0];
+         texel[GCOMP] = table[index * 3 + 1];
+         texel[BCOMP] = table[index * 3 + 2];
+         texel[ACOMP] = 1.0F;
+         break;
+      case GL_RGBA:
+         texel[RCOMP] = table[index * 4 + 0];
+         texel[GCOMP] = table[index * 4 + 1];
+         texel[BCOMP] = table[index * 4 + 2];
+         texel[ACOMP] = table[index * 4 + 3];
+         break;
+      default:
+         _mesa_problem(ctx, "Bad palette format in fetch_texel_ci8");
+         return;
+      }
+   }
+}
+
+#if DIM == 3
+static void store_texel_ci8(struct gl_texture_image *texImage,
+                            GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *index = (const GLubyte *) texel;
+   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
+   *dst = *index;
+}
+#endif
+
+
+/* Fetch texel from 1D, 2D or 3D srgb8 texture, return 4 GLfloats */
+/* Note: component order is same as for MESA_FORMAT_RGB888 */
+static void FETCH(srgb8)(const struct gl_texture_image *texImage,
+                         GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
+   texel[RCOMP] = nonlinear_to_linear(src[2]);
+   texel[GCOMP] = nonlinear_to_linear(src[1]);
+   texel[BCOMP] = nonlinear_to_linear(src[0]);
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_srgb8(struct gl_texture_image *texImage,
+                              GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
+   dst[0] = rgba[BCOMP]; /* no conversion */
+   dst[1] = rgba[GCOMP];
+   dst[2] = rgba[RCOMP];
+}
+#endif
+
+/* Fetch texel from 1D, 2D or 3D srgba8 texture, return 4 GLfloats */
+static void FETCH(srgba8)(const struct gl_texture_image *texImage,
+                          GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[RCOMP] = nonlinear_to_linear( (s >> 24) );
+   texel[GCOMP] = nonlinear_to_linear( (s >> 16) & 0xff );
+   texel[BCOMP] = nonlinear_to_linear( (s >>  8) & 0xff );
+   texel[ACOMP] = UBYTE_TO_FLOAT( (s      ) & 0xff ); /* linear! */
+}
+
+#if DIM == 3
+static void store_texel_srgba8(struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
+}
+#endif
+
+/* Fetch texel from 1D, 2D or 3D sargb8 texture, return 4 GLfloats */
+static void FETCH(sargb8)(const struct gl_texture_image *texImage,
+                          GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[RCOMP] = nonlinear_to_linear( (s >> 16) & 0xff );
+   texel[GCOMP] = nonlinear_to_linear( (s >>  8) & 0xff );
+   texel[BCOMP] = nonlinear_to_linear( (s      ) & 0xff );
+   texel[ACOMP] = UBYTE_TO_FLOAT( (s >> 24) ); /* linear! */
+}
+
+#if DIM == 3
+static void store_texel_sargb8(struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_8888(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
+}
+#endif
+
+/* Fetch texel from 1D, 2D or 3D sl8 texture, return 4 GLfloats */
+static void FETCH(sl8)(const struct gl_texture_image *texImage,
+                       GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
+   texel[RCOMP] = 
+   texel[GCOMP] = 
+   texel[BCOMP] = nonlinear_to_linear(src[0]);
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_sl8(struct gl_texture_image *texImage,
+                            GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
+   dst[0] = rgba[RCOMP];
+}
+#endif
+
+/* Fetch texel from 1D, 2D or 3D sla8 texture, return 4 GLfloats */
+static void FETCH(sla8)(const struct gl_texture_image *texImage,
+                       GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 2);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] = nonlinear_to_linear(src[0]);
+   texel[ACOMP] = UBYTE_TO_FLOAT(src[1]); /* linear */
+}
+
+#if DIM == 3
+static void store_texel_sla8(struct gl_texture_image *texImage,
+                            GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 2);
+   dst[0] = rgba[RCOMP];
+   dst[1] = rgba[ACOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_RGBA_INT8 **************************************************/
+
+static void
+FETCH(rgba_int8)(const struct gl_texture_image *texImage,
+                 GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLbyte *src = TEXEL_ADDR(GLbyte, texImage, i, j, k, 4);
+   texel[RCOMP] = (GLfloat) src[0];
+   texel[GCOMP] = (GLfloat) src[1];
+   texel[BCOMP] = (GLfloat) src[2];
+   texel[ACOMP] = (GLfloat) src[3];
+}
+
+#if DIM == 3
+static void
+store_texel_rgba_int8(struct gl_texture_image *texImage,
+                      GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLbyte *rgba = (const GLbyte *) texel;
+   GLbyte *dst = TEXEL_ADDR(GLbyte, texImage, i, j, k, 4);
+   dst[0] = rgba[RCOMP];
+   dst[1] = rgba[GCOMP];
+   dst[2] = rgba[BCOMP];
+   dst[3] = rgba[ACOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_RGBA_INT16 **************************************************/
+
+static void
+FETCH(rgba_int16)(const struct gl_texture_image *texImage,
+                  GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLshort *src = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);
+   texel[RCOMP] = (GLfloat) src[0];
+   texel[GCOMP] = (GLfloat) src[1];
+   texel[BCOMP] = (GLfloat) src[2];
+   texel[ACOMP] = (GLfloat) src[3];
+}
+
+#if DIM == 3
+static void
+store_texel_rgba_int16(struct gl_texture_image *texImage,
+                       GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLshort *rgba = (const GLshort *) texel;
+   GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);
+   dst[0] = rgba[RCOMP];
+   dst[1] = rgba[GCOMP];
+   dst[2] = rgba[BCOMP];
+   dst[3] = rgba[ACOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_RGBA_INT32 **************************************************/
+
+static void
+FETCH(rgba_int32)(const struct gl_texture_image *texImage,
+                  GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLint *src = TEXEL_ADDR(GLint, texImage, i, j, k, 4);
+   texel[RCOMP] = (GLfloat) src[0];
+   texel[GCOMP] = (GLfloat) src[1];
+   texel[BCOMP] = (GLfloat) src[2];
+   texel[ACOMP] = (GLfloat) src[3];
+}
+
+#if DIM == 3
+static void
+store_texel_rgba_int32(struct gl_texture_image *texImage,
+                       GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLint *rgba = (const GLint *) texel;
+   GLint *dst = TEXEL_ADDR(GLint, texImage, i, j, k, 4);
+   dst[0] = rgba[RCOMP];
+   dst[1] = rgba[GCOMP];
+   dst[2] = rgba[BCOMP];
+   dst[3] = rgba[ACOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_RGBA_UINT8 **************************************************/
+
+static void
+FETCH(rgba_uint8)(const struct gl_texture_image *texImage,
+                 GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 4);
+   texel[RCOMP] = (GLfloat) src[0];
+   texel[GCOMP] = (GLfloat) src[1];
+   texel[BCOMP] = (GLfloat) src[2];
+   texel[ACOMP] = (GLfloat) src[3];
+}
+
+#if DIM == 3
+static void
+store_texel_rgba_uint8(struct gl_texture_image *texImage,
+                      GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 4);
+   dst[0] = rgba[RCOMP];
+   dst[1] = rgba[GCOMP];
+   dst[2] = rgba[BCOMP];
+   dst[3] = rgba[ACOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_RGBA_UINT16 **************************************************/
+
+static void
+FETCH(rgba_uint16)(const struct gl_texture_image *texImage,
+                  GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);
+   texel[RCOMP] = (GLfloat) src[0];
+   texel[GCOMP] = (GLfloat) src[1];
+   texel[BCOMP] = (GLfloat) src[2];
+   texel[ACOMP] = (GLfloat) src[3];
+}
+
+#if DIM == 3
+static void
+store_texel_rgba_uint16(struct gl_texture_image *texImage,
+                       GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLushort *rgba = (const GLushort *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);
+   dst[0] = rgba[RCOMP];
+   dst[1] = rgba[GCOMP];
+   dst[2] = rgba[BCOMP];
+   dst[3] = rgba[ACOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_RGBA_UINT32 **************************************************/
+
+static void
+FETCH(rgba_uint32)(const struct gl_texture_image *texImage,
+                  GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 4);
+   texel[RCOMP] = (GLfloat) src[0];
+   texel[GCOMP] = (GLfloat) src[1];
+   texel[BCOMP] = (GLfloat) src[2];
+   texel[ACOMP] = (GLfloat) src[3];
+}
+
+#if DIM == 3
+static void
+store_texel_rgba_uint32(struct gl_texture_image *texImage,
+                       GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLuint *rgba = (const GLuint *) texel;
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 4);
+   dst[0] = rgba[RCOMP];
+   dst[1] = rgba[GCOMP];
+   dst[2] = rgba[BCOMP];
+   dst[3] = rgba[ACOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_DUDV8 ********************************************************/
+
+/* this format by definition produces 0,0,0,1 as rgba values,
+   however we'll return the dudv values as rg and fix up elsewhere */
+static void FETCH(dudv8)(const struct gl_texture_image *texImage,
+                         GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLbyte *src = TEXEL_ADDR(GLbyte, texImage, i, j, k, 2);
+   texel[RCOMP] = BYTE_TO_FLOAT(src[0]);
+   texel[GCOMP] = BYTE_TO_FLOAT(src[1]);
+   texel[BCOMP] = 0;
+   texel[ACOMP] = 0;
+}
+
+
+/* MESA_FORMAT_SIGNED_R8 ***********************************************/
+
+static void FETCH(signed_r8)( const struct gl_texture_image *texImage,
+                              GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLbyte s = *TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
+   texel[RCOMP] = BYTE_TO_FLOAT_TEX( s );
+   texel[GCOMP] = 0.0F;
+   texel[BCOMP] = 0.0F;
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_signed_r8(struct gl_texture_image *texImage,
+                                  GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLbyte *rgba = (const GLbyte *) texel;
+   GLbyte *dst = TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
+   *dst = rgba[RCOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_SIGNED_A8 ***********************************************/
+
+static void FETCH(signed_a8)( const struct gl_texture_image *texImage,
+                              GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLbyte s = *TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
+   texel[RCOMP] = 0.0F;
+   texel[GCOMP] = 0.0F;
+   texel[BCOMP] = 0.0F;
+   texel[ACOMP] = BYTE_TO_FLOAT_TEX( s );
+}
+
+#if DIM == 3
+static void store_texel_signed_a8(struct gl_texture_image *texImage,
+                                  GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLbyte *rgba = (const GLbyte *) texel;
+   GLbyte *dst = TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
+   *dst = rgba[ACOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_SIGNED_L8 ***********************************************/
+
+static void FETCH(signed_l8)( const struct gl_texture_image *texImage,
+                              GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLbyte s = *TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] = BYTE_TO_FLOAT_TEX( s );
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_signed_l8(struct gl_texture_image *texImage,
+                                  GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLbyte *rgba = (const GLbyte *) texel;
+   GLbyte *dst = TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
+   *dst = rgba[RCOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_SIGNED_I8 ***********************************************/
+
+static void FETCH(signed_i8)( const struct gl_texture_image *texImage,
+                              GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLbyte s = *TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] =
+   texel[ACOMP] = BYTE_TO_FLOAT_TEX( s );
+}
+
+#if DIM == 3
+static void store_texel_signed_i8(struct gl_texture_image *texImage,
+                                  GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLbyte *rgba = (const GLbyte *) texel;
+   GLbyte *dst = TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
+   *dst = rgba[RCOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_SIGNED_RG88_REV ***********************************************/
+
+static void FETCH(signed_rg88_rev)( const struct gl_texture_image *texImage,
+                                    GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort s = *TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
+   texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s & 0xff) );
+   texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 8) );
+   texel[BCOMP] = 0.0F;
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_signed_rg88_rev(struct gl_texture_image *texImage,
+                                        GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLbyte *rg = (const GLbyte *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   dst[0] = PACK_COLOR_88(rg[GCOMP], rg[RCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_SIGNED_AL88 ***********************************************/
+
+static void FETCH(signed_al88)( const struct gl_texture_image *texImage,
+                                GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort s = *TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s & 0xff) );
+   texel[ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 8) );
+}
+
+#if DIM == 3
+static void store_texel_signed_al88(struct gl_texture_image *texImage,
+                                    GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLbyte *rg = (const GLbyte *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
+   dst[0] = PACK_COLOR_88(rg[ACOMP], rg[RCOMP]);
+}
+#endif
+
+
+/* MESA_FORMAT_SIGNED_RGBX8888 ***********************************************/
+
+static void FETCH(signed_rgbx8888)( const struct gl_texture_image *texImage,
+			            GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 24) );
+   texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 16) );
+   texel[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >>  8) );
+   texel[ACOMP] = 1.0f;
+}
+
+#if DIM == 3
+static void store_texel_signed_rgbx8888(struct gl_texture_image *texImage,
+                                        GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLbyte *rgba = (const GLbyte *) texel;
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], 255);
+}
+#endif
+
+
+/* MESA_FORMAT_SIGNED_RGBA8888 ***********************************************/
+
+static void FETCH(signed_rgba8888)( const struct gl_texture_image *texImage,
+			            GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 24) );
+   texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 16) );
+   texel[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >>  8) );
+   texel[ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s      ) );
+}
+
+#if DIM == 3
+static void store_texel_signed_rgba8888(struct gl_texture_image *texImage,
+                                        GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLbyte *rgba = (const GLbyte *) texel;
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
+}
+#endif
+
+static void FETCH(signed_rgba8888_rev)( const struct gl_texture_image *texImage,
+                                        GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s      ) );
+   texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >>  8) );
+   texel[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 16) );
+   texel[ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 24) );
+}
+
+#if DIM == 3
+static void store_texel_signed_rgba8888_rev(struct gl_texture_image *texImage,
+                                            GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLubyte *rgba = (const GLubyte *) texel;
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   *dst = PACK_COLOR_8888_REV(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
+}
+#endif
+
+
+
+/* MESA_FORMAT_SIGNED_R16 ***********************************************/
+
+static void
+FETCH(signed_r16)(const struct gl_texture_image *texImage,
+                  GLint i, GLint j, GLint k, GLfloat *texel)
+{
+   const GLshort s = *TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
+   texel[RCOMP] = SHORT_TO_FLOAT_TEX( s );
+   texel[GCOMP] = 0.0F;
+   texel[BCOMP] = 0.0F;
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void
+store_texel_signed_r16(struct gl_texture_image *texImage,
+                       GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLshort *rgba = (const GLshort *) texel;
+   GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
+   *dst = rgba[0];
+}
+#endif
+
+
+/* MESA_FORMAT_SIGNED_A16 ***********************************************/
+
+static void
+FETCH(signed_a16)(const struct gl_texture_image *texImage,
+                  GLint i, GLint j, GLint k, GLfloat *texel)
+{
+   const GLshort s = *TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
+   texel[RCOMP] = 0.0F;
+   texel[GCOMP] = 0.0F;
+   texel[BCOMP] = 0.0F;
+   texel[ACOMP] = SHORT_TO_FLOAT_TEX( s );
+}
+
+#if DIM == 3
+static void
+store_texel_signed_a16(struct gl_texture_image *texImage,
+                       GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLshort *rgba = (const GLshort *) texel;
+   GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
+   *dst = rgba[ACOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_SIGNED_L16 ***********************************************/
+
+static void
+FETCH(signed_l16)(const struct gl_texture_image *texImage,
+                  GLint i, GLint j, GLint k, GLfloat *texel)
+{
+   const GLshort s = *TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] = SHORT_TO_FLOAT_TEX( s );
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void
+store_texel_signed_l16(struct gl_texture_image *texImage,
+                       GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLshort *rgba = (const GLshort *) texel;
+   GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
+   *dst = rgba[RCOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_SIGNED_I16 ***********************************************/
+
+static void
+FETCH(signed_i16)(const struct gl_texture_image *texImage,
+                  GLint i, GLint j, GLint k, GLfloat *texel)
+{
+   const GLshort s = *TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] =
+   texel[ACOMP] = SHORT_TO_FLOAT_TEX( s );
+}
+
+#if DIM == 3
+static void
+store_texel_signed_i16(struct gl_texture_image *texImage,
+                       GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLshort *rgba = (const GLshort *) texel;
+   GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
+   *dst = rgba[RCOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_SIGNED_RG1616 ***********************************************/
+
+static void
+FETCH(signed_rg1616)(const struct gl_texture_image *texImage,
+                    GLint i, GLint j, GLint k, GLfloat *texel)
+{
+   const GLshort *s = TEXEL_ADDR(GLshort, texImage, i, j, k, 2);
+   texel[RCOMP] = SHORT_TO_FLOAT_TEX( s[0] );
+   texel[GCOMP] = SHORT_TO_FLOAT_TEX( s[1] );
+   texel[BCOMP] = 0.0F;
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void
+store_texel_signed_rg1616(struct gl_texture_image *texImage,
+                         GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLshort *rgba = (const GLshort *) texel;
+   GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 2);
+   dst[0] = rgba[RCOMP];
+   dst[1] = rgba[GCOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_SIGNED_AL1616 ***********************************************/
+
+static void
+FETCH(signed_al1616)(const struct gl_texture_image *texImage,
+                    GLint i, GLint j, GLint k, GLfloat *texel)
+{
+   const GLshort *s = TEXEL_ADDR(GLshort, texImage, i, j, k, 2);
+   texel[RCOMP] =
+   texel[GCOMP] =
+   texel[BCOMP] = SHORT_TO_FLOAT_TEX( s[0] );
+   texel[ACOMP] = SHORT_TO_FLOAT_TEX( s[1] );
+}
+
+#if DIM == 3
+static void
+store_texel_signed_al1616(struct gl_texture_image *texImage,
+                         GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLshort *rgba = (const GLshort *) texel;
+   GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 2);
+   dst[0] = rgba[RCOMP];
+   dst[1] = rgba[ACOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_SIGNED_RGB_16 ***********************************************/
+
+static void 
+FETCH(signed_rgb_16)(const struct gl_texture_image *texImage,
+                     GLint i, GLint j, GLint k, GLfloat *texel)
+{
+   const GLshort *s = TEXEL_ADDR(GLshort, texImage, i, j, k, 3);
+   texel[RCOMP] = SHORT_TO_FLOAT_TEX( s[0] );
+   texel[GCOMP] = SHORT_TO_FLOAT_TEX( s[1] );
+   texel[BCOMP] = SHORT_TO_FLOAT_TEX( s[2] );
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void
+store_texel_signed_rgb_16(struct gl_texture_image *texImage,
+                          GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLshort *rgba = (const GLshort *) texel;
+   GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 3);
+   dst[0] = rgba[RCOMP];
+   dst[1] = rgba[GCOMP];
+   dst[2] = rgba[BCOMP];
+}
+#endif
+
+
+/* MESA_FORMAT_SIGNED_RGBA_16 ***********************************************/
+
+static void
+FETCH(signed_rgba_16)(const struct gl_texture_image *texImage,
+                      GLint i, GLint j, GLint k, GLfloat *texel)
+{
+   const GLshort *s = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);
+   texel[RCOMP] = SHORT_TO_FLOAT_TEX( s[0] );
+   texel[GCOMP] = SHORT_TO_FLOAT_TEX( s[1] );
+   texel[BCOMP] = SHORT_TO_FLOAT_TEX( s[2] );
+   texel[ACOMP] = SHORT_TO_FLOAT_TEX( s[3] );
+}
+
+#if DIM == 3
+static void
+store_texel_signed_rgba_16(struct gl_texture_image *texImage,
+                           GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLshort *rgba = (const GLshort *) texel;
+   GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);
+   dst[0] = rgba[RCOMP];
+   dst[1] = rgba[GCOMP];
+   dst[2] = rgba[BCOMP];
+   dst[3] = rgba[ACOMP];
+}
+#endif
+
+
+
+/* MESA_FORMAT_RGBA_16 ***********************************************/
+
+static void
+FETCH(rgba_16)(const struct gl_texture_image *texImage,
+               GLint i, GLint j, GLint k, GLfloat *texel)
+{
+   const GLushort *s = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);
+   texel[RCOMP] = USHORT_TO_FLOAT( s[0] );
+   texel[GCOMP] = USHORT_TO_FLOAT( s[1] );
+   texel[BCOMP] = USHORT_TO_FLOAT( s[2] );
+   texel[ACOMP] = USHORT_TO_FLOAT( s[3] );
+}
+
+#if DIM == 3
+static void
+store_texel_rgba_16(struct gl_texture_image *texImage,
+                    GLint i, GLint j, GLint k, const void *texel)
+{
+   const GLushort *rgba = (const GLushort *) texel;
+   GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);
+   dst[0] = rgba[RCOMP];
+   dst[1] = rgba[GCOMP];
+   dst[2] = rgba[BCOMP];
+   dst[3] = rgba[ACOMP];
+}
+#endif
+
+
+
+/* MESA_FORMAT_YCBCR *********************************************************/
+
+/* Fetch texel from 1D, 2D or 3D ycbcr texture, return 4 GLfloats.
+ * We convert YCbCr to RGB here.
+ */
+static void FETCH(f_ycbcr)( const struct gl_texture_image *texImage,
+                            GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort *src0 = TEXEL_ADDR(GLushort, texImage, (i & ~1), j, k, 1); /* even */
+   const GLushort *src1 = src0 + 1;                               /* odd */
+   const GLubyte y0 = (*src0 >> 8) & 0xff;  /* luminance */
+   const GLubyte cb = *src0 & 0xff;         /* chroma U */
+   const GLubyte y1 = (*src1 >> 8) & 0xff;  /* luminance */
+   const GLubyte cr = *src1 & 0xff;         /* chroma V */
+   const GLubyte y = (i & 1) ? y1 : y0;     /* choose even/odd luminance */
+   GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128);
+   GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);
+   GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128);
+   r *= (1.0F / 255.0F);
+   g *= (1.0F / 255.0F);
+   b *= (1.0F / 255.0F);
+   texel[RCOMP] = CLAMP(r, 0.0F, 1.0F);
+   texel[GCOMP] = CLAMP(g, 0.0F, 1.0F);
+   texel[BCOMP] = CLAMP(b, 0.0F, 1.0F);
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_ycbcr(struct gl_texture_image *texImage,
+                              GLint i, GLint j, GLint k, const void *texel)
+{
+   (void) texImage;
+   (void) i;
+   (void) j;
+   (void) k;
+   (void) texel;
+   /* XXX to do */
+}
+#endif
+
+
+/* MESA_FORMAT_YCBCR_REV *****************************************************/
+
+/* Fetch texel from 1D, 2D or 3D ycbcr_rev texture, return 4 GLfloats.
+ * We convert YCbCr to RGB here.
+ */
+static void FETCH(f_ycbcr_rev)( const struct gl_texture_image *texImage,
+                                GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   const GLushort *src0 = TEXEL_ADDR(GLushort, texImage, (i & ~1), j, k, 1); /* even */
+   const GLushort *src1 = src0 + 1;                               /* odd */
+   const GLubyte y0 = *src0 & 0xff;         /* luminance */
+   const GLubyte cr = (*src0 >> 8) & 0xff;  /* chroma V */
+   const GLubyte y1 = *src1 & 0xff;         /* luminance */
+   const GLubyte cb = (*src1 >> 8) & 0xff;  /* chroma U */
+   const GLubyte y = (i & 1) ? y1 : y0;     /* choose even/odd luminance */
+   GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128);
+   GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);
+   GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128);
+   r *= (1.0F / 255.0F);
+   g *= (1.0F / 255.0F);
+   b *= (1.0F / 255.0F);
+   texel[RCOMP] = CLAMP(r, 0.0F, 1.0F);
+   texel[GCOMP] = CLAMP(g, 0.0F, 1.0F);
+   texel[BCOMP] = CLAMP(b, 0.0F, 1.0F);
+   texel[ACOMP] = 1.0F;
+}
+
+#if DIM == 3
+static void store_texel_ycbcr_rev(struct gl_texture_image *texImage,
+                                  GLint i, GLint j, GLint k, const void *texel)
+{
+   (void) texImage;
+   (void) i;
+   (void) j;
+   (void) k;
+   (void) texel;
+   /* XXX to do */
+}
+#endif
+
+
+/* MESA_TEXFORMAT_Z24_S8 ***************************************************/
+
+static void FETCH(f_z24_s8)( const struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   /* only return Z, not stencil data */
+   const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   const GLfloat scale = 1.0F / (GLfloat) 0xffffff;
+   texel[0] = ((*src) >> 8) * scale;
+   ASSERT(texImage->TexFormat == MESA_FORMAT_Z24_S8);
+   ASSERT(texel[0] >= 0.0F);
+   ASSERT(texel[0] <= 1.0F);
+}
+
+#if DIM == 3
+static void store_texel_z24_s8(struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, const void *texel)
+{
+   /* only store Z, not stencil */
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   GLfloat depth = *((GLfloat *) texel);
+   GLuint zi = ((GLuint) (depth * 0xffffff)) << 8;
+   *dst = zi | (*dst & 0xff);
+}
+#endif
+
+
+/* MESA_TEXFORMAT_S8_Z24 ***************************************************/
+
+static void FETCH(f_s8_z24)( const struct gl_texture_image *texImage,
+                             GLint i, GLint j, GLint k, GLfloat *texel )
+{
+   /* only return Z, not stencil data */
+   const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   const GLfloat scale = 1.0F / (GLfloat) 0xffffff;
+   texel[0] = ((*src) & 0x00ffffff) * scale;
+   ASSERT(texImage->TexFormat == MESA_FORMAT_S8_Z24);
+   ASSERT(texel[0] >= 0.0F);
+   ASSERT(texel[0] <= 1.0F);
+}
+
+#if DIM == 3
+static void store_texel_s8_z24(struct gl_texture_image *texImage,
+                               GLint i, GLint j, GLint k, const void *texel)
+{
+   /* only store Z, not stencil */
+   GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
+   GLfloat depth = *((GLfloat *) texel);
+   GLuint zi = (GLuint) (depth * 0xffffff);
+   *dst = zi | (*dst & 0xff000000);
+}
+#endif
+
+
+#undef TEXEL_ADDR
+#undef DIM
+#undef FETCH
diff --git a/mesalib/src/mesa/main/texformat.c b/mesalib/src/mesa/main/texformat.c
index 5eabf2aa5..8b7b4ff47 100644
--- a/mesalib/src/mesa/main/texformat.c
+++ b/mesalib/src/mesa/main/texformat.c
@@ -389,19 +389,7 @@ _mesa_choose_tex_format( struct gl_context *ctx, GLint internalFormat,
       }
    }
 
-   if (ctx->Extensions.MESA_texture_signed_rgba) {
-      switch (internalFormat) {
-         case GL_RGBA_SNORM:
-         case GL_RGBA8_SNORM:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RGBA8888);
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RGBA8888_REV);
-	    break;
-         default:
-            ; /* fallthrough */
-      }
-   }
-
-   if (ctx->VersionMajor * 10 + ctx->VersionMinor >= 31) {
+   if (ctx->Extensions.EXT_texture_snorm) {
       switch (internalFormat) {
          case GL_RED_SNORM:
          case GL_R8_SNORM:
@@ -409,7 +397,7 @@ _mesa_choose_tex_format( struct gl_context *ctx, GLint internalFormat,
 	    break;
          case GL_RG_SNORM:
          case GL_RG8_SNORM:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RG88);
+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RG88_REV);
 	    break;
          case GL_RGB_SNORM:
          case GL_RGB8_SNORM:
@@ -418,12 +406,29 @@ _mesa_choose_tex_format( struct gl_context *ctx, GLint internalFormat,
          case GL_RGBA_SNORM:
          case GL_RGBA8_SNORM:
 	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RGBA8888);
+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RGBA8888_REV);
 	    break;
+         case GL_ALPHA_SNORM:
+         case GL_ALPHA8_SNORM:
+            RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_A8);
+            break;
+         case GL_LUMINANCE_SNORM:
+         case GL_LUMINANCE8_SNORM:
+            RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_L8);
+            break;
+         case GL_LUMINANCE_ALPHA_SNORM:
+         case GL_LUMINANCE8_ALPHA8_SNORM:
+            RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_AL88);
+            break;
+         case GL_INTENSITY_SNORM:
+         case GL_INTENSITY8_SNORM:
+            RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_I8);
+            break;
          case GL_R16_SNORM:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_R_16);
+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_R16);
 	    break;
          case GL_RG16_SNORM:
-	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RG_16);
+	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_GR1616);
 	    break;
          case GL_RGB16_SNORM:
 	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RGB_16);
@@ -431,6 +436,18 @@ _mesa_choose_tex_format( struct gl_context *ctx, GLint internalFormat,
          case GL_RGBA16_SNORM:
 	    RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_RGBA_16);
 	    break;
+         case GL_ALPHA16_SNORM:
+            RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_A16);
+            break;
+         case GL_LUMINANCE16_SNORM:
+            RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_L16);
+            break;
+         case GL_LUMINANCE16_ALPHA16_SNORM:
+            RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_AL1616);
+            break;
+         case GL_INTENSITY16_SNORM:
+            RETURN_IF_SUPPORTED(MESA_FORMAT_SIGNED_I16);
+            break;
          default:
             ; /* fall-through */
       }
diff --git a/mesalib/src/mesa/main/teximage.c b/mesalib/src/mesa/main/teximage.c
index c6b8c05b1..86927d3b6 100644
--- a/mesalib/src/mesa/main/teximage.c
+++ b/mesalib/src/mesa/main/teximage.c
@@ -311,11 +311,40 @@ _mesa_base_tex_format( struct gl_context *ctx, GLint internalFormat )
       }
    }
 
-   if (ctx->Extensions.MESA_texture_signed_rgba) {
+   if (ctx->Extensions.EXT_texture_snorm) {
       switch (internalFormat) {
+         case GL_RED_SNORM:
+         case GL_R8_SNORM:
+         case GL_R16_SNORM:
+            return GL_RED;
+         case GL_RG_SNORM:
+         case GL_RG8_SNORM:
+         case GL_RG16_SNORM:
+            return GL_RG;
+         case GL_RGB_SNORM:
+         case GL_RGB8_SNORM:
+         case GL_RGB16_SNORM:
+            return GL_RGB;
          case GL_RGBA_SNORM:
          case GL_RGBA8_SNORM:
+         case GL_RGBA16_SNORM:
             return GL_RGBA;
+         case GL_ALPHA_SNORM:
+         case GL_ALPHA8_SNORM:
+         case GL_ALPHA16_SNORM:
+            return GL_ALPHA;
+         case GL_LUMINANCE_SNORM:
+         case GL_LUMINANCE8_SNORM:
+         case GL_LUMINANCE16_SNORM:
+            return GL_LUMINANCE;
+         case GL_LUMINANCE_ALPHA_SNORM:
+         case GL_LUMINANCE8_ALPHA8_SNORM:
+         case GL_LUMINANCE16_ALPHA16_SNORM:
+            return GL_LUMINANCE_ALPHA;
+         case GL_INTENSITY_SNORM:
+         case GL_INTENSITY8_SNORM:
+         case GL_INTENSITY16_SNORM:
+            return GL_INTENSITY;
          default:
             ; /* fallthrough */
       }
diff --git a/mesalib/src/mesa/main/texparam.c b/mesalib/src/mesa/main/texparam.c
index 6e14face4..34b6addb9 100644
--- a/mesalib/src/mesa/main/texparam.c
+++ b/mesalib/src/mesa/main/texparam.c
@@ -38,6 +38,7 @@
 #include "main/macros.h"
 #include "main/mfeatures.h"
 #include "main/mtypes.h"
+#include "main/state.h"
 #include "main/texcompress.h"
 #include "main/texparam.h"
 #include "main/teximage.h"
@@ -533,10 +534,18 @@ set_tex_parameterf(struct gl_context *ctx,
 
    case GL_TEXTURE_BORDER_COLOR:
       flush(ctx);
-      texObj->BorderColor.f[RCOMP] = params[0];
-      texObj->BorderColor.f[GCOMP] = params[1];
-      texObj->BorderColor.f[BCOMP] = params[2];
-      texObj->BorderColor.f[ACOMP] = params[3];
+      /* ARB_texture_float disables clamping */
+      if (ctx->Extensions.ARB_texture_float) {
+         texObj->BorderColor.f[RCOMP] = params[0];
+         texObj->BorderColor.f[GCOMP] = params[1];
+         texObj->BorderColor.f[BCOMP] = params[2];
+         texObj->BorderColor.f[ACOMP] = params[3];
+      } else {
+         texObj->BorderColor.f[RCOMP] = CLAMP(params[0], 0.0F, 1.0F);
+         texObj->BorderColor.f[GCOMP] = CLAMP(params[1], 0.0F, 1.0F);
+         texObj->BorderColor.f[BCOMP] = CLAMP(params[2], 0.0F, 1.0F);
+         texObj->BorderColor.f[ACOMP] = CLAMP(params[3], 0.0F, 1.0F);
+      }
       return GL_TRUE;
 
    default:
@@ -1107,10 +1116,22 @@ _mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
          *params = ENUM_TO_FLOAT(obj->WrapR);
          break;
       case GL_TEXTURE_BORDER_COLOR:
-         params[0] = CLAMP(obj->BorderColor.f[0], 0.0F, 1.0F);
-         params[1] = CLAMP(obj->BorderColor.f[1], 0.0F, 1.0F);
-         params[2] = CLAMP(obj->BorderColor.f[2], 0.0F, 1.0F);
-         params[3] = CLAMP(obj->BorderColor.f[3], 0.0F, 1.0F);
+         if(ctx->NewState & (_NEW_BUFFERS | _NEW_FRAG_CLAMP))
+            _mesa_update_state_locked(ctx);
+         if(ctx->Color._ClampFragmentColor)
+         {
+            params[0] = CLAMP(obj->BorderColor.f[0], 0.0F, 1.0F);
+            params[1] = CLAMP(obj->BorderColor.f[1], 0.0F, 1.0F);
+            params[2] = CLAMP(obj->BorderColor.f[2], 0.0F, 1.0F);
+            params[3] = CLAMP(obj->BorderColor.f[3], 0.0F, 1.0F);
+         }
+         else
+         {
+            params[0] = obj->BorderColor.f[0];
+            params[1] = obj->BorderColor.f[1];
+            params[2] = obj->BorderColor.f[2];
+            params[3] = obj->BorderColor.f[3];
+         }
          break;
       case GL_TEXTURE_RESIDENT:
          {
diff --git a/mesalib/src/mesa/main/texstore.c b/mesalib/src/mesa/main/texstore.c
index f909abfa2..eb37490e1 100644
--- a/mesalib/src/mesa/main/texstore.c
+++ b/mesalib/src/mesa/main/texstore.c
@@ -1,4709 +1,4856 @@
-/*

- * Mesa 3-D graphics library

- * Version:  7.5

- *

- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

- * Copyright (c) 2008-2009  VMware, Inc.

- *

- * 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.

- */

-

-/*

- * Authors:

- *   Brian Paul

- */

-

-/**

- * The GL texture image functions in teximage.c basically just do

- * error checking and data structure allocation.  They in turn call

- * device driver functions which actually copy/convert/store the user's

- * texture image data.

- *

- * However, most device drivers will be able to use the fallback functions

- * in this file.  That is, most drivers will have the following bit of

- * code:

- *   ctx->Driver.TexImage1D = _mesa_store_teximage1d;

- *   ctx->Driver.TexImage2D = _mesa_store_teximage2d;

- *   ctx->Driver.TexImage3D = _mesa_store_teximage3d;

- *   etc...

- *

- * Texture image processing is actually kind of complicated.  We have to do:

- *    Format/type conversions

- *    pixel unpacking

- *    pixel transfer (scale, bais, lookup, etc)

- *

- * These functions can handle most everything, including processing full

- * images and sub-images.

- */

-

-

-#include "glheader.h"

-#include "bufferobj.h"

-#include "colormac.h"

-#include "image.h"

-#include "macros.h"

-#include "mipmap.h"

-#include "mfeatures.h"

-#include "mtypes.h"

-#include "pack.h"

-#include "pbo.h"

-#include "imports.h"

-#include "pack.h"

-#include "texcompress.h"

-#include "texcompress_fxt1.h"

-#include "texcompress_rgtc.h"

-#include "texcompress_s3tc.h"

-#include "teximage.h"

-#include "texstore.h"

-#include "enums.h"

-

-

-enum {

-   ZERO = 4, 

-   ONE = 5

-};

-

-

-/**

- * Texture image storage function.

- */

-typedef GLboolean (*StoreTexImageFunc)(TEXSTORE_PARAMS);

-

-

-/**

- * Return GL_TRUE if the given image format is one that be converted

- * to another format by swizzling.

- */

-static GLboolean

-can_swizzle(GLenum logicalBaseFormat)

-{

-   switch (logicalBaseFormat) {

-   case GL_RGBA:

-   case GL_RGB:

-   case GL_LUMINANCE_ALPHA:

-   case GL_INTENSITY:

-   case GL_ALPHA:

-   case GL_LUMINANCE:

-   case GL_RED:

-   case GL_GREEN:

-   case GL_BLUE:

-   case GL_BGR:

-   case GL_BGRA:

-   case GL_ABGR_EXT:

-   case GL_RG:

-      return GL_TRUE;

-   default:

-      return GL_FALSE;

-   }

-}

-

-

-

-enum {

-   IDX_LUMINANCE = 0,

-   IDX_ALPHA,

-   IDX_INTENSITY,

-   IDX_LUMINANCE_ALPHA,

-   IDX_RGB,

-   IDX_RGBA,

-   IDX_RED,

-   IDX_GREEN,

-   IDX_BLUE,

-   IDX_BGR,

-   IDX_BGRA,

-   IDX_ABGR,

-   IDX_RG,

-   MAX_IDX

-};

-

-#define MAP1(x)       MAP4(x, ZERO, ZERO, ZERO)

-#define MAP2(x,y)     MAP4(x, y, ZERO, ZERO)

-#define MAP3(x,y,z)   MAP4(x, y, z, ZERO)

-#define MAP4(x,y,z,w) { x, y, z, w, ZERO, ONE }

-

-

-static const struct {

-   GLubyte format_idx;

-   GLubyte to_rgba[6];

-   GLubyte from_rgba[6];

-} mappings[MAX_IDX] = 

-{

-   {

-      IDX_LUMINANCE,

-      MAP4(0,0,0,ONE),

-      MAP1(0)

-   },

-

-   {

-      IDX_ALPHA,

-      MAP4(ZERO, ZERO, ZERO, 0),

-      MAP1(3)

-   },

-

-   {

-      IDX_INTENSITY,

-      MAP4(0, 0, 0, 0),

-      MAP1(0),

-   },

-

-   {

-      IDX_LUMINANCE_ALPHA,

-      MAP4(0,0,0,1),

-      MAP2(0,3)

-   },

-

-   {

-      IDX_RGB,

-      MAP4(0,1,2,ONE),

-      MAP3(0,1,2)

-   },

-

-   {

-      IDX_RGBA,

-      MAP4(0,1,2,3),

-      MAP4(0,1,2,3),

-   },

-

-   {

-      IDX_RED,

-      MAP4(0, ZERO, ZERO, ONE),

-      MAP1(0),

-   },

-

-   {

-      IDX_GREEN,

-      MAP4(ZERO, 0, ZERO, ONE),

-      MAP1(1),

-   },

-

-   {

-      IDX_BLUE,

-      MAP4(ZERO, ZERO, 0, ONE),

-      MAP1(2),

-   },

-

-   {

-      IDX_BGR,

-      MAP4(2,1,0,ONE),

-      MAP3(2,1,0)

-   },

-

-   {

-      IDX_BGRA,

-      MAP4(2,1,0,3),

-      MAP4(2,1,0,3)

-   },

-

-   {

-      IDX_ABGR,

-      MAP4(3,2,1,0),

-      MAP4(3,2,1,0)

-   },

-

-   {

-      IDX_RG,

-      MAP4(0, 1, ZERO, ONE),

-      MAP2(0, 1)

-   },

-};

-

-

-

-/**

- * Convert a GL image format enum to an IDX_* value (see above).

- */

-static int

-get_map_idx(GLenum value)

-{

-   switch (value) {

-   case GL_LUMINANCE: return IDX_LUMINANCE;

-   case GL_ALPHA: return IDX_ALPHA;

-   case GL_INTENSITY: return IDX_INTENSITY;

-   case GL_LUMINANCE_ALPHA: return IDX_LUMINANCE_ALPHA;

-   case GL_RGB: return IDX_RGB;

-   case GL_RGBA: return IDX_RGBA;

-   case GL_RED: return IDX_RED;

-   case GL_GREEN: return IDX_GREEN;

-   case GL_BLUE: return IDX_BLUE;

-   case GL_BGR: return IDX_BGR;

-   case GL_BGRA: return IDX_BGRA;

-   case GL_ABGR_EXT: return IDX_ABGR;

-   case GL_RG: return IDX_RG;

-   default:

-      _mesa_problem(NULL, "Unexpected inFormat");

-      return 0;

-   }

-}   

-

-

-/**

- * When promoting texture formats (see below) we need to compute the

- * mapping of dest components back to source components.

- * This function does that.

- * \param inFormat  the incoming format of the texture

- * \param outFormat  the final texture format

- * \return map[6]  a full 6-component map

- */

-static void

-compute_component_mapping(GLenum inFormat, GLenum outFormat, 

-			  GLubyte *map)

-{

-   const int inFmt = get_map_idx(inFormat);

-   const int outFmt = get_map_idx(outFormat);

-   const GLubyte *in2rgba = mappings[inFmt].to_rgba;

-   const GLubyte *rgba2out = mappings[outFmt].from_rgba;

-   int i;

-   

-   for (i = 0; i < 4; i++)

-      map[i] = in2rgba[rgba2out[i]];

-

-   map[ZERO] = ZERO;

-   map[ONE] = ONE;   

-

-#if 0

-   printf("from %x/%s to %x/%s map %d %d %d %d %d %d\n",

-	  inFormat, _mesa_lookup_enum_by_nr(inFormat),

-	  outFormat, _mesa_lookup_enum_by_nr(outFormat),

-	  map[0], 

-	  map[1], 

-	  map[2], 

-	  map[3], 

-	  map[4], 

-	  map[5]); 

-#endif

-}

-

-

-/**

- * Make a temporary (color) texture image with GLfloat components.

- * Apply all needed pixel unpacking and pixel transfer operations.

- * Note that there are both logicalBaseFormat and textureBaseFormat parameters.

- * Suppose the user specifies GL_LUMINANCE as the internal texture format

- * but the graphics hardware doesn't support luminance textures.  So, we might

- * use an RGB hardware format instead.

- * If logicalBaseFormat != textureBaseFormat we have some extra work to do.

- *

- * \param ctx  the rendering context

- * \param dims  image dimensions: 1, 2 or 3

- * \param logicalBaseFormat  basic texture derived from the user's

- *    internal texture format value

- * \param textureBaseFormat  the actual basic format of the texture

- * \param srcWidth  source image width

- * \param srcHeight  source image height

- * \param srcDepth  source image depth

- * \param srcFormat  source image format

- * \param srcType  source image type

- * \param srcAddr  source image address

- * \param srcPacking  source image pixel packing

- * \return resulting image with format = textureBaseFormat and type = GLfloat.

- */

-GLfloat *

-_mesa_make_temp_float_image(struct gl_context *ctx, GLuint dims,

-			    GLenum logicalBaseFormat,

-			    GLenum textureBaseFormat,

-			    GLint srcWidth, GLint srcHeight, GLint srcDepth,

-			    GLenum srcFormat, GLenum srcType,

-			    const GLvoid *srcAddr,

-			    const struct gl_pixelstore_attrib *srcPacking,

-			    GLbitfield transferOps)

-{

-   GLfloat *tempImage;

-   const GLint components = _mesa_components_in_format(logicalBaseFormat);

-   const GLint srcStride =

-      _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

-   GLfloat *dst;

-   GLint img, row;

-

-   ASSERT(dims >= 1 && dims <= 3);

-

-   ASSERT(logicalBaseFormat == GL_RGBA ||

-          logicalBaseFormat == GL_RGB ||

-          logicalBaseFormat == GL_RG ||

-          logicalBaseFormat == GL_RED ||

-          logicalBaseFormat == GL_LUMINANCE_ALPHA ||

-          logicalBaseFormat == GL_LUMINANCE ||

-          logicalBaseFormat == GL_ALPHA ||

-          logicalBaseFormat == GL_INTENSITY ||

-          logicalBaseFormat == GL_COLOR_INDEX ||

-          logicalBaseFormat == GL_DEPTH_COMPONENT);

-

-   ASSERT(textureBaseFormat == GL_RGBA ||

-          textureBaseFormat == GL_RGB ||

-          textureBaseFormat == GL_RG ||

-          textureBaseFormat == GL_RED ||

-          textureBaseFormat == GL_LUMINANCE_ALPHA ||

-          textureBaseFormat == GL_LUMINANCE ||

-          textureBaseFormat == GL_ALPHA ||

-          textureBaseFormat == GL_INTENSITY ||

-          textureBaseFormat == GL_COLOR_INDEX ||

-          textureBaseFormat == GL_DEPTH_COMPONENT);

-

-   tempImage = (GLfloat *) malloc(srcWidth * srcHeight * srcDepth

-				  * components * sizeof(GLfloat));

-   if (!tempImage)

-      return NULL;

-

-   dst = tempImage;

-   for (img = 0; img < srcDepth; img++) {

-      const GLubyte *src

-	 = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,

-						 srcWidth, srcHeight,

-						 srcFormat, srcType,

-						 img, 0, 0);

-      for (row = 0; row < srcHeight; row++) {

-	 _mesa_unpack_color_span_float(ctx, srcWidth, logicalBaseFormat,

-				       dst, srcFormat, srcType, src,

-				       srcPacking, transferOps);

-	 dst += srcWidth * components;

-	 src += srcStride;

-      }

-   }

-

-   if (logicalBaseFormat != textureBaseFormat) {

-      /* more work */

-      GLint texComponents = _mesa_components_in_format(textureBaseFormat);

-      GLint logComponents = _mesa_components_in_format(logicalBaseFormat);

-      GLfloat *newImage;

-      GLint i, n;

-      GLubyte map[6];

-

-      /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */

-      ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||

-             textureBaseFormat == GL_LUMINANCE_ALPHA);

-

-      /* The actual texture format should have at least as many components

-       * as the logical texture format.

-       */

-      ASSERT(texComponents >= logComponents);

-

-      newImage = (GLfloat *) malloc(srcWidth * srcHeight * srcDepth

-                                          * texComponents * sizeof(GLfloat));

-      if (!newImage) {

-         free(tempImage);

-         return NULL;

-      }

-

-      compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);

-

-      n = srcWidth * srcHeight * srcDepth;

-      for (i = 0; i < n; i++) {

-         GLint k;

-         for (k = 0; k < texComponents; k++) {

-            GLint j = map[k];

-            if (j == ZERO)

-               newImage[i * texComponents + k] = 0.0F;

-            else if (j == ONE)

-               newImage[i * texComponents + k] = 1.0F;

-            else

-               newImage[i * texComponents + k] = tempImage[i * logComponents + j];

-         }

-      }

-

-      free(tempImage);

-      tempImage = newImage;

-   }

-

-   return tempImage;

-}

-

-

-/**

- * Make temporary image with uint pixel values.  Used for unsigned

- * integer-valued textures.

- */

-static GLuint *

-make_temp_uint_image(struct gl_context *ctx, GLuint dims,

-                     GLenum logicalBaseFormat,

-                     GLenum textureBaseFormat,

-                     GLint srcWidth, GLint srcHeight, GLint srcDepth,

-                     GLenum srcFormat, GLenum srcType,

-                     const GLvoid *srcAddr,

-                     const struct gl_pixelstore_attrib *srcPacking)

-{

-   GLuint *tempImage;

-   const GLint components = _mesa_components_in_format(logicalBaseFormat);

-   const GLint srcStride =

-      _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

-   GLuint *dst;

-   GLint img, row;

-

-   ASSERT(dims >= 1 && dims <= 3);

-

-   ASSERT(logicalBaseFormat == GL_RGBA ||

-          logicalBaseFormat == GL_RGB ||

-          logicalBaseFormat == GL_RG ||

-          logicalBaseFormat == GL_RED ||

-          logicalBaseFormat == GL_LUMINANCE_ALPHA ||

-          logicalBaseFormat == GL_LUMINANCE ||

-          logicalBaseFormat == GL_INTENSITY ||

-          logicalBaseFormat == GL_ALPHA);

-

-   ASSERT(textureBaseFormat == GL_RGBA ||

-          textureBaseFormat == GL_RGB ||

-          textureBaseFormat == GL_RG ||

-          textureBaseFormat == GL_RED ||

-          textureBaseFormat == GL_LUMINANCE_ALPHA ||

-          textureBaseFormat == GL_LUMINANCE ||

-          textureBaseFormat == GL_ALPHA);

-

-   tempImage = (GLuint *) malloc(srcWidth * srcHeight * srcDepth

-                                 * components * sizeof(GLuint));

-   if (!tempImage)

-      return NULL;

-

-   dst = tempImage;

-   for (img = 0; img < srcDepth; img++) {

-      const GLubyte *src

-	 = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,

-						 srcWidth, srcHeight,

-						 srcFormat, srcType,

-						 img, 0, 0);

-      for (row = 0; row < srcHeight; row++) {

-	 _mesa_unpack_color_span_uint(ctx, srcWidth, logicalBaseFormat,

-                                      dst, srcFormat, srcType, src,

-                                      srcPacking);

-	 dst += srcWidth * components;

-	 src += srcStride;

-      }

-   }

-

-   if (logicalBaseFormat != textureBaseFormat) {

-      /* more work */

-      GLint texComponents = _mesa_components_in_format(textureBaseFormat);

-      GLint logComponents = _mesa_components_in_format(logicalBaseFormat);

-      GLuint *newImage;

-      GLint i, n;

-      GLubyte map[6];

-

-      /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */

-      ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||

-             textureBaseFormat == GL_LUMINANCE_ALPHA);

-

-      /* The actual texture format should have at least as many components

-       * as the logical texture format.

-       */

-      ASSERT(texComponents >= logComponents);

-

-      newImage = (GLuint *) malloc(srcWidth * srcHeight * srcDepth

-                                   * texComponents * sizeof(GLuint));

-      if (!newImage) {

-         free(tempImage);

-         return NULL;

-      }

-

-      compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);

-

-      n = srcWidth * srcHeight * srcDepth;

-      for (i = 0; i < n; i++) {

-         GLint k;

-         for (k = 0; k < texComponents; k++) {

-            GLint j = map[k];

-            if (j == ZERO)

-               newImage[i * texComponents + k] = 0.0F;

-            else if (j == ONE)

-               newImage[i * texComponents + k] = 1.0F;

-            else

-               newImage[i * texComponents + k] = tempImage[i * logComponents + j];

-         }

-      }

-

-      free(tempImage);

-      tempImage = newImage;

-   }

-

-   return tempImage;

-}

-

-

-

-/**

- * Make a temporary (color) texture image with GLchan components.

- * Apply all needed pixel unpacking and pixel transfer operations.

- * Note that there are both logicalBaseFormat and textureBaseFormat parameters.

- * Suppose the user specifies GL_LUMINANCE as the internal texture format

- * but the graphics hardware doesn't support luminance textures.  So, we might

- * use an RGB hardware format instead.

- * If logicalBaseFormat != textureBaseFormat we have some extra work to do.

- *

- * \param ctx  the rendering context

- * \param dims  image dimensions: 1, 2 or 3

- * \param logicalBaseFormat  basic texture derived from the user's

- *    internal texture format value

- * \param textureBaseFormat  the actual basic format of the texture

- * \param srcWidth  source image width

- * \param srcHeight  source image height

- * \param srcDepth  source image depth

- * \param srcFormat  source image format

- * \param srcType  source image type

- * \param srcAddr  source image address

- * \param srcPacking  source image pixel packing

- * \return resulting image with format = textureBaseFormat and type = GLchan.

- */

-GLchan *

-_mesa_make_temp_chan_image(struct gl_context *ctx, GLuint dims,

-                           GLenum logicalBaseFormat,

-                           GLenum textureBaseFormat,

-                           GLint srcWidth, GLint srcHeight, GLint srcDepth,

-                           GLenum srcFormat, GLenum srcType,

-                           const GLvoid *srcAddr,

-                           const struct gl_pixelstore_attrib *srcPacking)

-{

-   GLuint transferOps = ctx->_ImageTransferState;

-   const GLint components = _mesa_components_in_format(logicalBaseFormat);

-   GLint img, row;

-   GLchan *tempImage, *dst;

-

-   ASSERT(dims >= 1 && dims <= 3);

-

-   ASSERT(logicalBaseFormat == GL_RGBA ||

-          logicalBaseFormat == GL_RGB ||

-          logicalBaseFormat == GL_RG ||

-          logicalBaseFormat == GL_RED ||

-          logicalBaseFormat == GL_LUMINANCE_ALPHA ||

-          logicalBaseFormat == GL_LUMINANCE ||

-          logicalBaseFormat == GL_ALPHA ||

-          logicalBaseFormat == GL_INTENSITY);

-

-   ASSERT(textureBaseFormat == GL_RGBA ||

-          textureBaseFormat == GL_RGB ||

-          textureBaseFormat == GL_RG ||

-          textureBaseFormat == GL_RED ||

-          textureBaseFormat == GL_LUMINANCE_ALPHA ||

-          textureBaseFormat == GL_LUMINANCE ||

-          textureBaseFormat == GL_ALPHA ||

-          textureBaseFormat == GL_INTENSITY);

-

-   /* unpack and transfer the source image */

-   tempImage = (GLchan *) malloc(srcWidth * srcHeight * srcDepth

-                                       * components * sizeof(GLchan));

-   if (!tempImage) {

-      return NULL;

-   }

-

-   dst = tempImage;

-   for (img = 0; img < srcDepth; img++) {

-      const GLint srcStride =

-         _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

-      const GLubyte *src =

-         (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,

-                                               srcWidth, srcHeight,

-                                               srcFormat, srcType,

-                                               img, 0, 0);

-      for (row = 0; row < srcHeight; row++) {

-         _mesa_unpack_color_span_chan(ctx, srcWidth, logicalBaseFormat, dst,

-                                      srcFormat, srcType, src, srcPacking,

-                                      transferOps);

-         dst += srcWidth * components;

-         src += srcStride;

-      }

-   }

-

-   if (logicalBaseFormat != textureBaseFormat) {

-      /* one more conversion step */

-      GLint texComponents = _mesa_components_in_format(textureBaseFormat);

-      GLint logComponents = _mesa_components_in_format(logicalBaseFormat);

-      GLchan *newImage;

-      GLint i, n;

-      GLubyte map[6];

-

-      /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */

-      ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||

-             textureBaseFormat == GL_LUMINANCE_ALPHA);

-

-      /* The actual texture format should have at least as many components

-       * as the logical texture format.

-       */

-      ASSERT(texComponents >= logComponents);

-

-      newImage = (GLchan *) malloc(srcWidth * srcHeight * srcDepth

-                                         * texComponents * sizeof(GLchan));

-      if (!newImage) {

-         free(tempImage);

-         return NULL;

-      }

-

-      compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);

-

-      n = srcWidth * srcHeight * srcDepth;

-      for (i = 0; i < n; i++) {

-         GLint k;

-         for (k = 0; k < texComponents; k++) {

-            GLint j = map[k];

-            if (j == ZERO)

-               newImage[i * texComponents + k] = 0;

-            else if (j == ONE)

-               newImage[i * texComponents + k] = CHAN_MAX;

-            else

-               newImage[i * texComponents + k] = tempImage[i * logComponents + j];

-         }

-      }

-

-      free(tempImage);

-      tempImage = newImage;

-   }

-

-   return tempImage;

-}

-

-

-/**

- * Copy GLubyte pixels from <src> to <dst> with swizzling.

- * \param dst  destination pixels

- * \param dstComponents  number of color components in destination pixels

- * \param src  source pixels

- * \param srcComponents  number of color components in source pixels

- * \param map  the swizzle mapping.  map[X] says where to find the X component

- *             in the source image's pixels.  For example, if the source image

- *             is GL_BGRA and X = red, map[0] yields 2.

- * \param count  number of pixels to copy/swizzle.

- */

-static void

-swizzle_copy(GLubyte *dst, GLuint dstComponents, const GLubyte *src, 

-             GLuint srcComponents, const GLubyte *map, GLuint count)

-{

-#define SWZ_CPY(dst, src, count, dstComps, srcComps) \

-   do {                                              \

-      GLuint i;                                      \

-      for (i = 0; i < count; i++) {                  \

-         GLuint j;                                   \

-         if (srcComps == 4) {                        \

-            COPY_4UBV(tmp, src);                     \

-         }                                           \

-         else {                                      \

-            for (j = 0; j < srcComps; j++) {         \

-               tmp[j] = src[j];                      \

-            }                                        \

-         }                                           \

-         src += srcComps;                            \

-         for (j = 0; j < dstComps; j++) {            \

-            dst[j] = tmp[map[j]];                    \

-         }                                           \

-         dst += dstComps;                            \

-      }                                              \

-   } while (0)

-

-   GLubyte tmp[6];

-

-   tmp[ZERO] = 0x0;

-   tmp[ONE] = 0xff;

-

-   ASSERT(srcComponents <= 4);

-   ASSERT(dstComponents <= 4);

-

-   switch (dstComponents) {

-   case 4:

-      switch (srcComponents) {

-      case 4:

-         SWZ_CPY(dst, src, count, 4, 4);

-         break;

-      case 3:

-         SWZ_CPY(dst, src, count, 4, 3);

-         break;

-      case 2:

-         SWZ_CPY(dst, src, count, 4, 2);

-         break;

-      case 1:

-         SWZ_CPY(dst, src, count, 4, 1);

-         break;

-      default:

-         ;

-      }

-      break;

-   case 3:

-      switch (srcComponents) {

-      case 4:

-         SWZ_CPY(dst, src, count, 3, 4);

-         break;

-      case 3:

-         SWZ_CPY(dst, src, count, 3, 3);

-         break;

-      case 2:

-         SWZ_CPY(dst, src, count, 3, 2);

-         break;

-      case 1:

-         SWZ_CPY(dst, src, count, 3, 1);

-         break;

-      default:

-         ;

-      }

-      break;

-   case 2:

-      switch (srcComponents) {

-      case 4:

-         SWZ_CPY(dst, src, count, 2, 4);

-         break;

-      case 3:

-         SWZ_CPY(dst, src, count, 2, 3);

-         break;

-      case 2:

-         SWZ_CPY(dst, src, count, 2, 2);

-         break;

-      case 1:

-         SWZ_CPY(dst, src, count, 2, 1);

-         break;

-      default:

-         ;

-      }

-      break;

-   case 1:

-      switch (srcComponents) {

-      case 4:

-         SWZ_CPY(dst, src, count, 1, 4);

-         break;

-      case 3:

-         SWZ_CPY(dst, src, count, 1, 3);

-         break;

-      case 2:

-         SWZ_CPY(dst, src, count, 1, 2);

-         break;

-      case 1:

-         SWZ_CPY(dst, src, count, 1, 1);

-         break;

-      default:

-         ;

-      }

-      break;

-   default:

-      ;

-   }

-#undef SWZ_CPY

-}

-

-

-

-static const GLubyte map_identity[6] = { 0, 1, 2, 3, ZERO, ONE };

-static const GLubyte map_3210[6] = { 3, 2, 1, 0, ZERO, ONE };

-

-

-/**

- * For 1-byte/pixel formats (or 8_8_8_8 packed formats), return a

- * mapping array depending on endianness.

- */

-static const GLubyte *

-type_mapping( GLenum srcType )

-{

-   switch (srcType) {

-   case GL_BYTE:

-   case GL_UNSIGNED_BYTE:

-      return map_identity;

-   case GL_UNSIGNED_INT_8_8_8_8:

-      return _mesa_little_endian() ? map_3210 : map_identity;

-   case GL_UNSIGNED_INT_8_8_8_8_REV:

-      return _mesa_little_endian() ? map_identity : map_3210;

-   default:

-      return NULL;

-   }

-}

-

-

-/**

- * For 1-byte/pixel formats (or 8_8_8_8 packed formats), return a

- * mapping array depending on pixelstore byte swapping state.

- */

-static const GLubyte *

-byteswap_mapping( GLboolean swapBytes,

-		  GLenum srcType )

-{

-   if (!swapBytes) 

-      return map_identity;

-

-   switch (srcType) {

-   case GL_BYTE:

-   case GL_UNSIGNED_BYTE:

-      return map_identity;

-   case GL_UNSIGNED_INT_8_8_8_8:

-   case GL_UNSIGNED_INT_8_8_8_8_REV:

-      return map_3210;

-   default:

-      return NULL;

-   }

-}

-

-

-

-/**

- * Transfer a GLubyte texture image with component swizzling.

- */

-static void

-_mesa_swizzle_ubyte_image(struct gl_context *ctx, 

-			  GLuint dimensions,

-			  GLenum srcFormat,

-			  GLenum srcType,

-

-			  GLenum baseInternalFormat,

-

-			  const GLubyte *rgba2dst,

-			  GLuint dstComponents,

-

-			  GLvoid *dstAddr,

-			  GLint dstXoffset, GLint dstYoffset, GLint dstZoffset,

-			  GLint dstRowStride,

-                          const GLuint *dstImageOffsets,

-

-			  GLint srcWidth, GLint srcHeight, GLint srcDepth,

-			  const GLvoid *srcAddr,

-			  const struct gl_pixelstore_attrib *srcPacking )

-{

-   GLint srcComponents = _mesa_components_in_format(srcFormat);

-   const GLubyte *srctype2ubyte, *swap;

-   GLubyte map[4], src2base[6], base2rgba[6];

-   GLint i;

-   const GLint srcRowStride =

-      _mesa_image_row_stride(srcPacking, srcWidth,

-                             srcFormat, GL_UNSIGNED_BYTE);

-   const GLint srcImageStride

-      = _mesa_image_image_stride(srcPacking, srcWidth, srcHeight, srcFormat,

-                                 GL_UNSIGNED_BYTE);

-   const GLubyte *srcImage

-      = (const GLubyte *) _mesa_image_address(dimensions, srcPacking, srcAddr,

-                                              srcWidth, srcHeight, srcFormat,

-                                              GL_UNSIGNED_BYTE, 0, 0, 0);

-

-   (void) ctx;

-

-   /* Translate from src->baseInternal->GL_RGBA->dst.  This will

-    * correctly deal with RGBA->RGB->RGBA conversions where the final

-    * A value must be 0xff regardless of the incoming alpha values.

-    */

-   compute_component_mapping(srcFormat, baseInternalFormat, src2base);

-   compute_component_mapping(baseInternalFormat, GL_RGBA, base2rgba);

-   swap = byteswap_mapping(srcPacking->SwapBytes, srcType);

-   srctype2ubyte = type_mapping(srcType);

-

-

-   for (i = 0; i < 4; i++)

-      map[i] = srctype2ubyte[swap[src2base[base2rgba[rgba2dst[i]]]]];

-

-/*    printf("map %d %d %d %d\n", map[0], map[1], map[2], map[3]);  */

-

-   if (srcComponents == dstComponents &&

-       srcRowStride == dstRowStride &&

-       srcRowStride == srcWidth * srcComponents &&

-       dimensions < 3) {

-      /* 1 and 2D images only */

-      GLubyte *dstImage = (GLubyte *) dstAddr

-         + dstYoffset * dstRowStride

-         + dstXoffset * dstComponents;

-      swizzle_copy(dstImage, dstComponents, srcImage, srcComponents, map, 

-		   srcWidth * srcHeight);

-   }

-   else {

-      GLint img, row;

-      for (img = 0; img < srcDepth; img++) {

-         const GLubyte *srcRow = srcImage;

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * dstComponents

-            + dstYoffset * dstRowStride

-            + dstXoffset * dstComponents;

-         for (row = 0; row < srcHeight; row++) {

-	    swizzle_copy(dstRow, dstComponents, srcRow, srcComponents, map, srcWidth);

-            dstRow += dstRowStride;

-            srcRow += srcRowStride;

-         }

-         srcImage += srcImageStride;

-      }

-   }

-}

-

-

-/**

- * Teximage storage routine for when a simple memcpy will do.

- * No pixel transfer operations or special texel encodings allowed.

- * 1D, 2D and 3D images supported.

- */

-static void

-memcpy_texture(struct gl_context *ctx,

-	       GLuint dimensions,

-               gl_format dstFormat,

-               GLvoid *dstAddr,

-               GLint dstXoffset, GLint dstYoffset, GLint dstZoffset,

-               GLint dstRowStride,

-               const GLuint *dstImageOffsets,

-               GLint srcWidth, GLint srcHeight, GLint srcDepth,

-               GLenum srcFormat, GLenum srcType,

-               const GLvoid *srcAddr,

-               const struct gl_pixelstore_attrib *srcPacking)

-{

-   const GLint srcRowStride = _mesa_image_row_stride(srcPacking, srcWidth,

-                                                     srcFormat, srcType);

-   const GLint srcImageStride = _mesa_image_image_stride(srcPacking,

-                                      srcWidth, srcHeight, srcFormat, srcType);

-   const GLubyte *srcImage = (const GLubyte *) _mesa_image_address(dimensions,

-        srcPacking, srcAddr, srcWidth, srcHeight, srcFormat, srcType, 0, 0, 0);

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLint bytesPerRow = srcWidth * texelBytes;

-

-#if 0

-   /* XXX update/re-enable for dstImageOffsets array */

-   const GLint bytesPerImage = srcHeight * bytesPerRow;

-   const GLint bytesPerTexture = srcDepth * bytesPerImage;

-   GLubyte *dstImage = (GLubyte *) dstAddr

-                     + dstZoffset * dstImageStride

-                     + dstYoffset * dstRowStride

-                     + dstXoffset * texelBytes;

-

-   if (dstRowStride == srcRowStride &&

-       dstRowStride == bytesPerRow &&

-       ((dstImageStride == srcImageStride &&

-         dstImageStride == bytesPerImage) ||

-        (srcDepth == 1))) {

-      /* one big memcpy */

-      ctx->Driver.TextureMemCpy(dstImage, srcImage, bytesPerTexture);

-   }

-   else

-   {

-      GLint img, row;

-      for (img = 0; img < srcDepth; img++) {

-         const GLubyte *srcRow = srcImage;

-         GLubyte *dstRow = dstImage;

-         for (row = 0; row < srcHeight; row++) {

-            ctx->Driver.TextureMemCpy(dstRow, srcRow, bytesPerRow);

-            dstRow += dstRowStride;

-            srcRow += srcRowStride;

-         }

-         srcImage += srcImageStride;

-         dstImage += dstImageStride;

-      }

-   }

-#endif

-

-   GLint img, row;

-   for (img = 0; img < srcDepth; img++) {

-      const GLubyte *srcRow = srcImage;

-      GLubyte *dstRow = (GLubyte *) dstAddr

-         + dstImageOffsets[dstZoffset + img] * texelBytes

-         + dstYoffset * dstRowStride

-         + dstXoffset * texelBytes;

-      for (row = 0; row < srcHeight; row++) {

-         ctx->Driver.TextureMemCpy(dstRow, srcRow, bytesPerRow);

-         dstRow += dstRowStride;

-         srcRow += srcRowStride;

-      }

-      srcImage += srcImageStride;

-   }

-}

-

-

-

-/**

- * Store a 32-bit integer depth component texture image.

- */

-static GLboolean

-_mesa_texstore_z32(TEXSTORE_PARAMS)

-{

-   const GLuint depthScale = 0xffffffff;

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   (void) dims;

-   ASSERT(dstFormat == MESA_FORMAT_Z32);

-   ASSERT(texelBytes == sizeof(GLuint));

-

-   if (ctx->Pixel.DepthScale == 1.0f &&

-       ctx->Pixel.DepthBias == 0.0f &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == GL_DEPTH_COMPONENT &&

-       srcFormat == GL_DEPTH_COMPONENT &&

-       srcType == GL_UNSIGNED_INT) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      GLint img, row;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            const GLvoid *src = _mesa_image_address(dims, srcPacking,

-                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);

-            _mesa_unpack_depth_span(ctx, srcWidth,

-                                    GL_UNSIGNED_INT, (GLuint *) dstRow,

-                                    depthScale, srcType, src, srcPacking);

-            dstRow += dstRowStride;

-         }

-      }

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store a 24-bit integer depth component texture image.

- */

-static GLboolean

-_mesa_texstore_x8_z24(TEXSTORE_PARAMS)

-{

-   const GLuint depthScale = 0xffffff;

-   const GLuint texelBytes = 4;

-

-   (void) dims;

-   ASSERT(dstFormat == MESA_FORMAT_X8_Z24);

-

-   {

-      /* general path */

-      GLint img, row;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            const GLvoid *src = _mesa_image_address(dims, srcPacking,

-                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);

-            _mesa_unpack_depth_span(ctx, srcWidth,

-                                    GL_UNSIGNED_INT, (GLuint *) dstRow,

-                                    depthScale, srcType, src, srcPacking);

-            dstRow += dstRowStride;

-         }

-      }

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store a 24-bit integer depth component texture image.

- */

-static GLboolean

-_mesa_texstore_z24_x8(TEXSTORE_PARAMS)

-{

-   const GLuint depthScale = 0xffffff;

-   const GLuint texelBytes = 4;

-

-   (void) dims;

-   ASSERT(dstFormat == MESA_FORMAT_Z24_X8);

-

-   {

-      /* general path */

-      GLint img, row;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            const GLvoid *src = _mesa_image_address(dims, srcPacking,

-                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);

-            GLuint *dst = (GLuint *) dstRow;

-            GLint i;

-            _mesa_unpack_depth_span(ctx, srcWidth,

-                                    GL_UNSIGNED_INT, dst,

-                                    depthScale, srcType, src, srcPacking);

-            for (i = 0; i < srcWidth; i++)

-               dst[i] <<= 8;

-            dstRow += dstRowStride;

-         }

-      }

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store a 16-bit integer depth component texture image.

- */

-static GLboolean

-_mesa_texstore_z16(TEXSTORE_PARAMS)

-{

-   const GLuint depthScale = 0xffff;

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   (void) dims;

-   ASSERT(dstFormat == MESA_FORMAT_Z16);

-   ASSERT(texelBytes == sizeof(GLushort));

-

-   if (ctx->Pixel.DepthScale == 1.0f &&

-       ctx->Pixel.DepthBias == 0.0f &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == GL_DEPTH_COMPONENT &&

-       srcFormat == GL_DEPTH_COMPONENT &&

-       srcType == GL_UNSIGNED_SHORT) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      GLint img, row;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            const GLvoid *src = _mesa_image_address(dims, srcPacking,

-                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);

-            GLushort *dst16 = (GLushort *) dstRow;

-            _mesa_unpack_depth_span(ctx, srcWidth,

-                                    GL_UNSIGNED_SHORT, dst16, depthScale,

-                                    srcType, src, srcPacking);

-            dstRow += dstRowStride;

-         }

-      }

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store an rgb565 or rgb565_rev texture image.

- */

-static GLboolean

-_mesa_texstore_rgb565(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGB565 ||

-          dstFormat == MESA_FORMAT_RGB565_REV);

-   ASSERT(texelBytes == 2);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       dstFormat == MESA_FORMAT_RGB565 &&

-       baseInternalFormat == GL_RGB &&

-       srcFormat == GL_RGB &&

-       srcType == GL_UNSIGNED_SHORT_5_6_5) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-            !srcPacking->SwapBytes &&

-            baseInternalFormat == GL_RGB &&

-            srcFormat == GL_RGB &&

-            srcType == GL_UNSIGNED_BYTE &&

-            dims == 2) {

-      /* do optimized tex store */

-      const GLint srcRowStride =

-         _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

-      const GLubyte *src = (const GLubyte *)

-         _mesa_image_address(dims, srcPacking, srcAddr, srcWidth, srcHeight,

-                             srcFormat, srcType, 0, 0, 0);

-      GLubyte *dst = (GLubyte *) dstAddr

-                   + dstYoffset * dstRowStride

-                   + dstXoffset * texelBytes;

-      GLint row, col;

-      for (row = 0; row < srcHeight; row++) {

-         const GLubyte *srcUB = (const GLubyte *) src;

-         GLushort *dstUS = (GLushort *) dst;

-         /* check for byteswapped format */

-         if (dstFormat == MESA_FORMAT_RGB565) {

-            for (col = 0; col < srcWidth; col++) {

-               dstUS[col] = PACK_COLOR_565( srcUB[0], srcUB[1], srcUB[2] );

-               srcUB += 3;

-            }

-         }

-         else {

-            for (col = 0; col < srcWidth; col++) {

-               dstUS[col] = PACK_COLOR_565_REV( srcUB[0], srcUB[1], srcUB[2] );

-               srcUB += 3;

-            }

-         }

-         dst += dstRowStride;

-         src += srcRowStride;

-      }

-   }

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLushort *dstUS = (GLushort *) dstRow;

-            /* check for byteswapped format */

-            if (dstFormat == MESA_FORMAT_RGB565) {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUS[col] = PACK_COLOR_565( CHAN_TO_UBYTE(src[RCOMP]),

-                                               CHAN_TO_UBYTE(src[GCOMP]),

-                                               CHAN_TO_UBYTE(src[BCOMP]) );

-                  src += 3;

-               }

-            }

-            else {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUS[col] = PACK_COLOR_565_REV( CHAN_TO_UBYTE(src[RCOMP]),

-                                                   CHAN_TO_UBYTE(src[GCOMP]),

-                                                   CHAN_TO_UBYTE(src[BCOMP]) );

-                  src += 3;

-               }

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store a texture in MESA_FORMAT_RGBA8888 or MESA_FORMAT_RGBA8888_REV.

- */

-static GLboolean

-_mesa_texstore_rgba8888(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA8888 ||

-          dstFormat == MESA_FORMAT_RGBA8888_REV);

-   ASSERT(texelBytes == 4);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       dstFormat == MESA_FORMAT_RGBA8888 &&

-       baseInternalFormat == GL_RGBA &&

-      ((srcFormat == GL_RGBA && srcType == GL_UNSIGNED_INT_8_8_8_8) ||

-       (srcFormat == GL_RGBA && srcType == GL_UNSIGNED_BYTE && !littleEndian) ||

-       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_INT_8_8_8_8_REV) ||

-       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_BYTE && littleEndian))) {

-       /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       dstFormat == MESA_FORMAT_RGBA8888_REV &&

-       baseInternalFormat == GL_RGBA &&

-      ((srcFormat == GL_RGBA && srcType == GL_UNSIGNED_INT_8_8_8_8_REV) ||

-       (srcFormat == GL_RGBA && srcType == GL_UNSIGNED_BYTE && littleEndian) ||

-       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_INT_8_8_8_8) ||

-       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_BYTE && !littleEndian))) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-	    (srcType == GL_UNSIGNED_BYTE ||

-	     srcType == GL_UNSIGNED_INT_8_8_8_8 ||

-	     srcType == GL_UNSIGNED_INT_8_8_8_8_REV) &&

-	    can_swizzle(baseInternalFormat) &&

-	    can_swizzle(srcFormat)) {

-

-      GLubyte dstmap[4];

-

-      /* dstmap - how to swizzle from RGBA to dst format:

-       */

-      if ((littleEndian && dstFormat == MESA_FORMAT_RGBA8888) ||

-	  (!littleEndian && dstFormat == MESA_FORMAT_RGBA8888_REV)) {

-	 dstmap[3] = 0;

-	 dstmap[2] = 1;

-	 dstmap[1] = 2;

-	 dstmap[0] = 3;

-      }

-      else {

-	 dstmap[3] = 3;

-	 dstmap[2] = 2;

-	 dstmap[1] = 1;

-	 dstmap[0] = 0;

-      }

-      

-      _mesa_swizzle_ubyte_image(ctx, dims,

-				srcFormat,

-				srcType,

-				baseInternalFormat,

-				dstmap, 4,

-				dstAddr, dstXoffset, dstYoffset, dstZoffset,

-				dstRowStride, dstImageOffsets,

-				srcWidth, srcHeight, srcDepth, srcAddr,

-				srcPacking);      

-   }

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLuint *dstUI = (GLuint *) dstRow;

-            if (dstFormat == MESA_FORMAT_RGBA8888) {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUI[col] = PACK_COLOR_8888( CHAN_TO_UBYTE(src[RCOMP]),

-                                                CHAN_TO_UBYTE(src[GCOMP]),

-                                                CHAN_TO_UBYTE(src[BCOMP]),

-                                                CHAN_TO_UBYTE(src[ACOMP]) );

-                  src += 4;

-               }

-            }

-            else {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUI[col] = PACK_COLOR_8888_REV( CHAN_TO_UBYTE(src[RCOMP]),

-                                                    CHAN_TO_UBYTE(src[GCOMP]),

-                                                    CHAN_TO_UBYTE(src[BCOMP]),

-                                                    CHAN_TO_UBYTE(src[ACOMP]) );

-                  src += 4;

-               }

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-static GLboolean

-_mesa_texstore_argb8888(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = GL_RGBA;

-

-   ASSERT(dstFormat == MESA_FORMAT_ARGB8888 ||

-          dstFormat == MESA_FORMAT_ARGB8888_REV ||

-          dstFormat == MESA_FORMAT_XRGB8888 ||

-          dstFormat == MESA_FORMAT_XRGB8888_REV );

-   ASSERT(texelBytes == 4);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       (dstFormat == MESA_FORMAT_ARGB8888 ||

-        dstFormat == MESA_FORMAT_XRGB8888) &&

-       baseInternalFormat == GL_RGBA &&

-       srcFormat == GL_BGRA &&

-       ((srcType == GL_UNSIGNED_BYTE && littleEndian) ||

-        srcType == GL_UNSIGNED_INT_8_8_8_8_REV)) {

-      /* simple memcpy path (little endian) */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       (dstFormat == MESA_FORMAT_ARGB8888_REV ||

-        dstFormat == MESA_FORMAT_XRGB8888_REV) &&

-       baseInternalFormat == GL_RGBA &&

-       srcFormat == GL_BGRA &&

-       ((srcType == GL_UNSIGNED_BYTE && !littleEndian) ||

-        srcType == GL_UNSIGNED_INT_8_8_8_8)) {

-      /* simple memcpy path (big endian) */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-            !srcPacking->SwapBytes &&

-	    (dstFormat == MESA_FORMAT_ARGB8888 ||

-             dstFormat == MESA_FORMAT_XRGB8888) &&

-            srcFormat == GL_RGB &&

-	    (baseInternalFormat == GL_RGBA ||

-	     baseInternalFormat == GL_RGB) &&

-            srcType == GL_UNSIGNED_BYTE) {

-      int img, row, col;

-      for (img = 0; img < srcDepth; img++) {

-         const GLint srcRowStride =

-            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

-         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,

-                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLuint *d4 = (GLuint *) dstRow;

-            for (col = 0; col < srcWidth; col++) {

-               d4[col] = PACK_COLOR_8888(0xff,

-                                         srcRow[col * 3 + RCOMP],

-                                         srcRow[col * 3 + GCOMP],

-                                         srcRow[col * 3 + BCOMP]);

-            }

-            dstRow += dstRowStride;

-            srcRow += srcRowStride;

-         }

-      }

-   }

-   else if (!ctx->_ImageTransferState &&

-            !srcPacking->SwapBytes &&

-	    dstFormat == MESA_FORMAT_ARGB8888 &&

-            srcFormat == GL_RGBA &&

-	    baseInternalFormat == GL_RGBA &&

-            srcType == GL_UNSIGNED_BYTE) {

-      /* same as above case, but src data has alpha too */

-      GLint img, row, col;

-      /* For some reason, streaming copies to write-combined regions

-       * are extremely sensitive to the characteristics of how the

-       * source data is retrieved.  By reordering the source reads to

-       * be in-order, the speed of this operation increases by half.

-       * Strangely the same isn't required for the RGB path, above.

-       */

-      for (img = 0; img < srcDepth; img++) {

-         const GLint srcRowStride =

-            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

-         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,

-                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLuint *d4 = (GLuint *) dstRow;

-            for (col = 0; col < srcWidth; col++) {

-               d4[col] = PACK_COLOR_8888(srcRow[col * 4 + ACOMP],

-                                         srcRow[col * 4 + RCOMP],

-                                         srcRow[col * 4 + GCOMP],

-                                         srcRow[col * 4 + BCOMP]);

-            }

-            dstRow += dstRowStride;

-            srcRow += srcRowStride;

-         }

-      }

-   }

-   else if (!ctx->_ImageTransferState &&

-	    (srcType == GL_UNSIGNED_BYTE ||

-	     srcType == GL_UNSIGNED_INT_8_8_8_8 ||

-	     srcType == GL_UNSIGNED_INT_8_8_8_8_REV) &&

-	    can_swizzle(baseInternalFormat) &&	   

-	    can_swizzle(srcFormat)) {

-

-      GLubyte dstmap[4];

-

-      /* dstmap - how to swizzle from RGBA to dst format:

-       */

-      if ((littleEndian && dstFormat == MESA_FORMAT_ARGB8888) ||

-          (littleEndian && dstFormat == MESA_FORMAT_XRGB8888) ||

-	  (!littleEndian && dstFormat == MESA_FORMAT_ARGB8888_REV) ||

-	  (!littleEndian && dstFormat == MESA_FORMAT_XRGB8888_REV)) {

-	 dstmap[3] = 3;		/* alpha */

-	 dstmap[2] = 0;		/* red */

-	 dstmap[1] = 1;		/* green */

-	 dstmap[0] = 2;		/* blue */

-      }

-      else {

-	 assert((littleEndian && dstFormat == MESA_FORMAT_ARGB8888_REV) ||

-		(!littleEndian && dstFormat == MESA_FORMAT_ARGB8888) ||

-		(littleEndian && dstFormat == MESA_FORMAT_XRGB8888_REV) ||

-		(!littleEndian && dstFormat == MESA_FORMAT_XRGB8888));

-	 dstmap[3] = 2;

-	 dstmap[2] = 1;

-	 dstmap[1] = 0;

-	 dstmap[0] = 3;

-      }

- 

-      _mesa_swizzle_ubyte_image(ctx, dims,

-				srcFormat,

-				srcType,

-				baseInternalFormat,

-				dstmap, 4,

-				dstAddr, dstXoffset, dstYoffset, dstZoffset,

-				dstRowStride,

-                                dstImageOffsets,

-				srcWidth, srcHeight, srcDepth, srcAddr,

-				srcPacking);      

-   }

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLuint *dstUI = (GLuint *) dstRow;

-            if (dstFormat == MESA_FORMAT_ARGB8888) {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUI[col] = PACK_COLOR_8888( CHAN_TO_UBYTE(src[ACOMP]),

-                                                CHAN_TO_UBYTE(src[RCOMP]),

-                                                CHAN_TO_UBYTE(src[GCOMP]),

-                                                CHAN_TO_UBYTE(src[BCOMP]) );

-                  src += 4;

-               }

-            }

-            else if (dstFormat == MESA_FORMAT_XRGB8888) {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUI[col] = PACK_COLOR_8888( 0xff,

-                                                CHAN_TO_UBYTE(src[RCOMP]),

-                                                CHAN_TO_UBYTE(src[GCOMP]),

-                                                CHAN_TO_UBYTE(src[BCOMP]) );

-                  src += 4;

-               }

-            }

-            else {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUI[col] = PACK_COLOR_8888_REV( CHAN_TO_UBYTE(src[ACOMP]),

-                                                    CHAN_TO_UBYTE(src[RCOMP]),

-                                                    CHAN_TO_UBYTE(src[GCOMP]),

-                                                    CHAN_TO_UBYTE(src[BCOMP]) );

-                  src += 4;

-               }

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-static GLboolean

-_mesa_texstore_rgb888(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGB888);

-   ASSERT(texelBytes == 3);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == GL_RGB &&

-       srcFormat == GL_BGR &&

-       srcType == GL_UNSIGNED_BYTE &&

-       littleEndian) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-            !srcPacking->SwapBytes &&

-            srcFormat == GL_RGBA &&

-            srcType == GL_UNSIGNED_BYTE) {

-      /* extract RGB from RGBA */

-      GLint img, row, col;

-      for (img = 0; img < srcDepth; img++) {

-         const GLint srcRowStride =

-            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

-         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,

-                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            for (col = 0; col < srcWidth; col++) {

-               dstRow[col * 3 + 0] = srcRow[col * 4 + BCOMP];

-               dstRow[col * 3 + 1] = srcRow[col * 4 + GCOMP];

-               dstRow[col * 3 + 2] = srcRow[col * 4 + RCOMP];

-            }

-            dstRow += dstRowStride;

-            srcRow += srcRowStride;

-         }

-      }

-   }

-   else if (!ctx->_ImageTransferState &&

-	    srcType == GL_UNSIGNED_BYTE &&

-	    can_swizzle(baseInternalFormat) &&

-	    can_swizzle(srcFormat)) {

-

-      GLubyte dstmap[4];

-

-      /* dstmap - how to swizzle from RGBA to dst format:

-       */

-      dstmap[0] = 2;

-      dstmap[1] = 1;

-      dstmap[2] = 0;

-      dstmap[3] = ONE;		/* ? */

-      

-      _mesa_swizzle_ubyte_image(ctx, dims,

-				srcFormat,

-				srcType,

-				baseInternalFormat,

-				dstmap, 3,

-				dstAddr, dstXoffset, dstYoffset, dstZoffset,

-				dstRowStride, dstImageOffsets,

-				srcWidth, srcHeight, srcDepth, srcAddr,

-				srcPacking);      

-   }

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = (const GLchan *) tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-#if 0

-            if (littleEndian) {

-               for (col = 0; col < srcWidth; col++) {

-                  dstRow[col * 3 + 0] = CHAN_TO_UBYTE(src[RCOMP]);

-                  dstRow[col * 3 + 1] = CHAN_TO_UBYTE(src[GCOMP]);

-                  dstRow[col * 3 + 2] = CHAN_TO_UBYTE(src[BCOMP]);

-                  srcUB += 3;

-               }

-            }

-            else {

-               for (col = 0; col < srcWidth; col++) {

-                  dstRow[col * 3 + 0] = srcUB[BCOMP];

-                  dstRow[col * 3 + 1] = srcUB[GCOMP];

-                  dstRow[col * 3 + 2] = srcUB[RCOMP];

-                  srcUB += 3;

-               }

-            }

-#else

-            for (col = 0; col < srcWidth; col++) {

-               dstRow[col * 3 + 0] = CHAN_TO_UBYTE(src[BCOMP]);

-               dstRow[col * 3 + 1] = CHAN_TO_UBYTE(src[GCOMP]);

-               dstRow[col * 3 + 2] = CHAN_TO_UBYTE(src[RCOMP]);

-               src += 3;

-            }

-#endif

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-static GLboolean

-_mesa_texstore_bgr888(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_BGR888);

-   ASSERT(texelBytes == 3);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == GL_RGB &&

-       srcFormat == GL_RGB &&

-       srcType == GL_UNSIGNED_BYTE &&

-       littleEndian) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-            !srcPacking->SwapBytes &&

-            srcFormat == GL_RGBA &&

-            srcType == GL_UNSIGNED_BYTE) {

-      /* extract BGR from RGBA */

-      int img, row, col;

-      for (img = 0; img < srcDepth; img++) {

-         const GLint srcRowStride =

-            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

-         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,

-                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            for (col = 0; col < srcWidth; col++) {

-               dstRow[col * 3 + 0] = srcRow[col * 4 + RCOMP];

-               dstRow[col * 3 + 1] = srcRow[col * 4 + GCOMP];

-               dstRow[col * 3 + 2] = srcRow[col * 4 + BCOMP];

-            }

-            dstRow += dstRowStride;

-            srcRow += srcRowStride;

-         }

-      }

-   }

-   else if (!ctx->_ImageTransferState &&

-	    srcType == GL_UNSIGNED_BYTE &&

-	    can_swizzle(baseInternalFormat) &&

-	    can_swizzle(srcFormat)) {

-

-      GLubyte dstmap[4];

-

-      /* dstmap - how to swizzle from RGBA to dst format:

-       */

-      dstmap[0] = 0;

-      dstmap[1] = 1;

-      dstmap[2] = 2;

-      dstmap[3] = ONE;		/* ? */

-      

-      _mesa_swizzle_ubyte_image(ctx, dims,

-				srcFormat,

-				srcType,

-				baseInternalFormat,

-				dstmap, 3,

-				dstAddr, dstXoffset, dstYoffset, dstZoffset,

-				dstRowStride, dstImageOffsets,

-				srcWidth, srcHeight, srcDepth, srcAddr,

-				srcPacking);      

-   }   

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = (const GLchan *) tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            for (col = 0; col < srcWidth; col++) {

-               dstRow[col * 3 + 0] = CHAN_TO_UBYTE(src[RCOMP]);

-               dstRow[col * 3 + 1] = CHAN_TO_UBYTE(src[GCOMP]);

-               dstRow[col * 3 + 2] = CHAN_TO_UBYTE(src[BCOMP]);

-               src += 3;

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-static GLboolean

-_mesa_texstore_argb4444(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_ARGB4444 ||

-          dstFormat == MESA_FORMAT_ARGB4444_REV);

-   ASSERT(texelBytes == 2);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       dstFormat == MESA_FORMAT_ARGB4444 &&

-       baseInternalFormat == GL_RGBA &&

-       srcFormat == GL_BGRA &&

-       srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLushort *dstUS = (GLushort *) dstRow;

-            if (dstFormat == MESA_FORMAT_ARGB4444) {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUS[col] = PACK_COLOR_4444( CHAN_TO_UBYTE(src[ACOMP]),

-                                                CHAN_TO_UBYTE(src[RCOMP]),

-                                                CHAN_TO_UBYTE(src[GCOMP]),

-                                                CHAN_TO_UBYTE(src[BCOMP]) );

-                  src += 4;

-               }

-            }

-            else {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUS[col] = PACK_COLOR_4444_REV( CHAN_TO_UBYTE(src[ACOMP]),

-                                                    CHAN_TO_UBYTE(src[RCOMP]),

-                                                    CHAN_TO_UBYTE(src[GCOMP]),

-                                                    CHAN_TO_UBYTE(src[BCOMP]) );

-                  src += 4;

-               }

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-static GLboolean

-_mesa_texstore_rgba5551(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA5551);

-   ASSERT(texelBytes == 2);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       dstFormat == MESA_FORMAT_RGBA5551 &&

-       baseInternalFormat == GL_RGBA &&

-       srcFormat == GL_RGBA &&

-       srcType == GL_UNSIGNED_SHORT_5_5_5_1) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src =tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLushort *dstUS = (GLushort *) dstRow;

-	    for (col = 0; col < srcWidth; col++) {

-	       dstUS[col] = PACK_COLOR_5551( CHAN_TO_UBYTE(src[RCOMP]),

-					     CHAN_TO_UBYTE(src[GCOMP]),

-					     CHAN_TO_UBYTE(src[BCOMP]),

-					     CHAN_TO_UBYTE(src[ACOMP]) );

-	      src += 4;

-	    }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-static GLboolean

-_mesa_texstore_argb1555(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_ARGB1555 ||

-          dstFormat == MESA_FORMAT_ARGB1555_REV);

-   ASSERT(texelBytes == 2);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       dstFormat == MESA_FORMAT_ARGB1555 &&

-       baseInternalFormat == GL_RGBA &&

-       srcFormat == GL_BGRA &&

-       srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src =tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLushort *dstUS = (GLushort *) dstRow;

-            if (dstFormat == MESA_FORMAT_ARGB1555) {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUS[col] = PACK_COLOR_1555( CHAN_TO_UBYTE(src[ACOMP]),

-                                                CHAN_TO_UBYTE(src[RCOMP]),

-                                                CHAN_TO_UBYTE(src[GCOMP]),

-                                                CHAN_TO_UBYTE(src[BCOMP]) );

-                  src += 4;

-               }

-            }

-            else {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUS[col] = PACK_COLOR_1555_REV( CHAN_TO_UBYTE(src[ACOMP]),

-                                                    CHAN_TO_UBYTE(src[RCOMP]),

-                                                    CHAN_TO_UBYTE(src[GCOMP]),

-                                                    CHAN_TO_UBYTE(src[BCOMP]) );

-                  src += 4;

-               }

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-static GLboolean

-_mesa_texstore_argb2101010(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_ARGB2101010);

-   ASSERT(texelBytes == 4);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       dstFormat == MESA_FORMAT_ARGB2101010 &&

-       srcFormat == GL_BGRA &&

-       srcType == GL_UNSIGNED_INT_2_10_10_10_REV &&

-       baseInternalFormat == GL_RGBA) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         if (baseInternalFormat == GL_RGBA) {

-            for (row = 0; row < srcHeight; row++) {

-               GLuint *dstUI = (GLuint *) dstRow;

-               for (col = 0; col < srcWidth; col++) {

-                  GLushort a,r,g,b;

-

-                  UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);

-                  UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);

-                  UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);

-                  UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);

-                  dstUI[col] = PACK_COLOR_2101010_US(a, r, g, b);

-                  src += 4;

-               }

-               dstRow += dstRowStride;

-            }

-         } else if (baseInternalFormat == GL_RGB) {

-            for (row = 0; row < srcHeight; row++) {

-               GLuint *dstUI = (GLuint *) dstRow;

-               for (col = 0; col < srcWidth; col++) {

-                  GLushort r,g,b;

-

-                  UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);

-                  UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);

-                  UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);

-                  dstUI[col] = PACK_COLOR_2101010_US(0xffff, r, g, b);

-                  src += 4;

-               }

-               dstRow += dstRowStride;

-            }

-         } else {

-            ASSERT(0);

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Do texstore for 2-channel, 4-bit/channel, unsigned normalized formats.

- */

-static GLboolean

-_mesa_texstore_unorm44(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_AL44);

-   ASSERT(texelBytes == 1);

-

-   {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLubyte *dstUS = (GLubyte *) dstRow;

-            for (col = 0; col < srcWidth; col++) {

-               /* src[0] is luminance, src[1] is alpha */

-               dstUS[col] = PACK_COLOR_44( CHAN_TO_UBYTE(src[1]),

-                                           CHAN_TO_UBYTE(src[0]) );

-               src += 2;

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Do texstore for 2-channel, 8-bit/channel, unsigned normalized formats.

- */

-static GLboolean

-_mesa_texstore_unorm88(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_AL88 ||

-          dstFormat == MESA_FORMAT_AL88_REV ||

-          dstFormat == MESA_FORMAT_RG88 ||

-          dstFormat == MESA_FORMAT_RG88_REV);

-   ASSERT(texelBytes == 2);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       (dstFormat == MESA_FORMAT_AL88 || dstFormat == MESA_FORMAT_RG88) &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_UNSIGNED_BYTE &&

-       littleEndian) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-	    littleEndian &&

-	    srcType == GL_UNSIGNED_BYTE &&

-	    can_swizzle(baseInternalFormat) &&

-	    can_swizzle(srcFormat)) {

-      GLubyte dstmap[4];

-

-      /* dstmap - how to swizzle from RGBA to dst format:

-       */

-      if (dstFormat == MESA_FORMAT_AL88 || dstFormat == MESA_FORMAT_AL88_REV) {

-	 if ((littleEndian && dstFormat == MESA_FORMAT_AL88) ||

-	     (!littleEndian && dstFormat == MESA_FORMAT_AL88_REV)) {

-	    dstmap[0] = 0;

-	    dstmap[1] = 3;

-	 }

-	 else {

-	    dstmap[0] = 3;

-	    dstmap[1] = 0;

-	 }

-      }

-      else {

-	 if ((littleEndian && dstFormat == MESA_FORMAT_RG88) ||

-	     (!littleEndian && dstFormat == MESA_FORMAT_RG88_REV)) {

-	    dstmap[0] = 0;

-	    dstmap[1] = 1;

-	 }

-	 else {

-	    dstmap[0] = 1;

-	    dstmap[1] = 0;

-	 }

-      }

-      dstmap[2] = ZERO;		/* ? */

-      dstmap[3] = ONE;		/* ? */

-      

-      _mesa_swizzle_ubyte_image(ctx, dims,

-				srcFormat,

-				srcType,

-				baseInternalFormat,

-				dstmap, 2,

-				dstAddr, dstXoffset, dstYoffset, dstZoffset,

-				dstRowStride, dstImageOffsets,

-				srcWidth, srcHeight, srcDepth, srcAddr,

-				srcPacking);      

-   }   

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLushort *dstUS = (GLushort *) dstRow;

-            if (dstFormat == MESA_FORMAT_AL88 ||

-		dstFormat == MESA_FORMAT_RG88) {

-               for (col = 0; col < srcWidth; col++) {

-                  /* src[0] is luminance, src[1] is alpha */

-                 dstUS[col] = PACK_COLOR_88( CHAN_TO_UBYTE(src[1]),

-                                             CHAN_TO_UBYTE(src[0]) );

-                 src += 2;

-               }

-            }

-            else {

-               for (col = 0; col < srcWidth; col++) {

-                  /* src[0] is luminance, src[1] is alpha */

-                 dstUS[col] = PACK_COLOR_88_REV( CHAN_TO_UBYTE(src[1]),

-                                                 CHAN_TO_UBYTE(src[0]) );

-                 src += 2;

-               }

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Do texstore for 2-channel, 16-bit/channel, unsigned normalized formats.

- */

-static GLboolean

-_mesa_texstore_unorm1616(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_AL1616 ||

-          dstFormat == MESA_FORMAT_AL1616_REV ||

-	  dstFormat == MESA_FORMAT_RG1616 ||

-          dstFormat == MESA_FORMAT_RG1616_REV);

-   ASSERT(texelBytes == 4);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       (dstFormat == MESA_FORMAT_AL1616 || dstFormat == MESA_FORMAT_RG1616) &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_UNSIGNED_SHORT &&

-       littleEndian) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLuint *dstUI = (GLuint *) dstRow;

-            if (dstFormat == MESA_FORMAT_AL1616 ||

-		dstFormat == MESA_FORMAT_RG1616) {

-               for (col = 0; col < srcWidth; col++) {

-		  GLushort l, a;

-

-		  UNCLAMPED_FLOAT_TO_USHORT(l, src[0]);

-		  UNCLAMPED_FLOAT_TO_USHORT(a, src[1]);

-		  dstUI[col] = PACK_COLOR_1616(a, l);

-		  src += 2;

-               }

-            }

-            else {

-               for (col = 0; col < srcWidth; col++) {

-		  GLushort l, a;

-

-		  UNCLAMPED_FLOAT_TO_USHORT(l, src[0]);

-		  UNCLAMPED_FLOAT_TO_USHORT(a, src[1]);

-		  dstUI[col] = PACK_COLOR_1616_REV(a, l);

-		  src += 2;

-               }

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/* Texstore for R16, A16, L16, I16. */

-static GLboolean

-_mesa_texstore_unorm16(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_R16 ||

-          dstFormat == MESA_FORMAT_A16 ||

-          dstFormat == MESA_FORMAT_L16 ||

-          dstFormat == MESA_FORMAT_I16);

-   ASSERT(texelBytes == 2);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_UNSIGNED_SHORT &&

-       littleEndian) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLushort *dstUS = (GLushort *) dstRow;

-	    for (col = 0; col < srcWidth; col++) {

-	       GLushort r;

-

-	       UNCLAMPED_FLOAT_TO_USHORT(r, src[0]);

-	       dstUS[col] = r;

-	       src += 1;

-	    }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-static GLboolean

-_mesa_texstore_rgba_16(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA_16);

-   ASSERT(texelBytes == 8);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == GL_RGBA &&

-       srcFormat == GL_RGBA &&

-       srcType == GL_UNSIGNED_SHORT) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLushort *dstUS = (GLushort *) dstRow;

-            for (col = 0; col < srcWidth; col++) {

-               GLushort r, g, b, a;

-

-               UNCLAMPED_FLOAT_TO_USHORT(r, src[0]);

-               UNCLAMPED_FLOAT_TO_USHORT(g, src[1]);

-               UNCLAMPED_FLOAT_TO_USHORT(b, src[2]);

-               UNCLAMPED_FLOAT_TO_USHORT(a, src[3]);

-               dstUS[col*4+0] = r;

-               dstUS[col*4+1] = g;

-               dstUS[col*4+2] = b;

-               dstUS[col*4+3] = a;

-               src += 4;

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-static GLboolean

-_mesa_texstore_signed_rgba_16(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_SIGNED_R_16 ||

-          dstFormat == MESA_FORMAT_SIGNED_RG_16 ||

-          dstFormat == MESA_FORMAT_SIGNED_RGB_16 ||

-          dstFormat == MESA_FORMAT_SIGNED_RGBA_16);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == GL_RGBA &&

-       dstFormat == MESA_FORMAT_SIGNED_RGBA_16 &&

-       srcFormat == GL_RGBA &&

-       srcType == GL_SHORT) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *src = tempImage;

-      const GLuint comps = _mesa_get_format_bytes(dstFormat) / 2;

-      GLint img, row, col;

-

-      if (!tempImage)

-         return GL_FALSE;

-

-      /* Note: tempImage is always float[4] / RGBA.  We convert to 1, 2,

-       * 3 or 4 components/pixel here.

-       */

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLshort *dstRowS = (GLshort *) dstRow;

-            for (col = 0; col < srcWidth; col++) {

-               GLuint c;

-               for (c = 0; c < comps; c++) {

-                  GLshort p;

-                  UNCLAMPED_FLOAT_TO_SHORT(p, src[col * 4 + c]);

-                  dstRowS[col * comps + c] = p;

-               }

-            }

-            dstRow += dstRowStride;

-            src += 4 * srcWidth;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-static GLboolean

-_mesa_texstore_rgb332(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGB332);

-   ASSERT(texelBytes == 1);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == GL_RGB &&

-       srcFormat == GL_RGB && srcType == GL_UNSIGNED_BYTE_3_3_2) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            for (col = 0; col < srcWidth; col++) {

-               dstRow[col] = PACK_COLOR_332( CHAN_TO_UBYTE(src[RCOMP]),

-                                             CHAN_TO_UBYTE(src[GCOMP]),

-                                             CHAN_TO_UBYTE(src[BCOMP]) );

-               src += 3;

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Texstore for _mesa_texformat_a8, _mesa_texformat_l8, _mesa_texformat_i8.

- */

-static GLboolean

-_mesa_texstore_unorm8(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_A8 ||

-          dstFormat == MESA_FORMAT_L8 ||

-          dstFormat == MESA_FORMAT_I8 ||

-          dstFormat == MESA_FORMAT_R8);

-   ASSERT(texelBytes == 1);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_UNSIGNED_BYTE) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-	    srcType == GL_UNSIGNED_BYTE &&

-	    can_swizzle(baseInternalFormat) &&

-	    can_swizzle(srcFormat)) {

-      GLubyte dstmap[4];

-

-      /* dstmap - how to swizzle from RGBA to dst format:

-       */

-      if (dstFormat == MESA_FORMAT_A8) {

-	 dstmap[0] = 3;

-      }

-      else {

-	 dstmap[0] = 0;

-      }

-      dstmap[1] = ZERO;		/* ? */

-      dstmap[2] = ZERO;		/* ? */

-      dstmap[3] = ONE;		/* ? */

-      

-      _mesa_swizzle_ubyte_image(ctx, dims,

-				srcFormat,

-				srcType,

-				baseInternalFormat,

-				dstmap, 1,

-				dstAddr, dstXoffset, dstYoffset, dstZoffset,

-				dstRowStride, dstImageOffsets,

-				srcWidth, srcHeight, srcDepth, srcAddr,

-				srcPacking);      

-   }   

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            for (col = 0; col < srcWidth; col++) {

-               dstRow[col] = CHAN_TO_UBYTE(src[col]);

-            }

-            dstRow += dstRowStride;

-            src += srcWidth;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-

-static GLboolean

-_mesa_texstore_ci8(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-

-   (void) dims; (void) baseInternalFormat;

-   ASSERT(dstFormat == MESA_FORMAT_CI8);

-   ASSERT(texelBytes == 1);

-   ASSERT(baseInternalFormat == GL_COLOR_INDEX);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       srcFormat == GL_COLOR_INDEX &&

-       srcType == GL_UNSIGNED_BYTE) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      GLint img, row;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            const GLvoid *src = _mesa_image_address(dims, srcPacking,

-                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);

-            _mesa_unpack_index_span(ctx, srcWidth, GL_UNSIGNED_BYTE, dstRow,

-                                    srcType, src, srcPacking,

-                                    ctx->_ImageTransferState);

-            dstRow += dstRowStride;

-         }

-      }

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Texstore for _mesa_texformat_ycbcr or _mesa_texformat_ycbcr_REV.

- */

-static GLboolean

-_mesa_texstore_ycbcr(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-

-   (void) ctx; (void) dims; (void) baseInternalFormat;

-

-   ASSERT((dstFormat == MESA_FORMAT_YCBCR) ||

-          (dstFormat == MESA_FORMAT_YCBCR_REV));

-   ASSERT(texelBytes == 2);

-   ASSERT(ctx->Extensions.MESA_ycbcr_texture);

-   ASSERT(srcFormat == GL_YCBCR_MESA);

-   ASSERT((srcType == GL_UNSIGNED_SHORT_8_8_MESA) ||

-          (srcType == GL_UNSIGNED_SHORT_8_8_REV_MESA));

-   ASSERT(baseInternalFormat == GL_YCBCR_MESA);

-

-   /* always just memcpy since no pixel transfer ops apply */

-   memcpy_texture(ctx, dims,

-                  dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                  dstRowStride,

-                  dstImageOffsets,

-                  srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                  srcAddr, srcPacking);

-

-   /* Check if we need byte swapping */

-   /* XXX the logic here _might_ be wrong */

-   if (srcPacking->SwapBytes ^

-       (srcType == GL_UNSIGNED_SHORT_8_8_REV_MESA) ^

-       (dstFormat == MESA_FORMAT_YCBCR_REV) ^

-       !littleEndian) {

-      GLint img, row;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            _mesa_swap2((GLushort *) dstRow, srcWidth);

-            dstRow += dstRowStride;

-         }

-      }

-   }

-   return GL_TRUE;

-}

-

-static GLboolean

-_mesa_texstore_dudv8(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_DUDV8);

-   ASSERT(texelBytes == 2);

-   ASSERT(ctx->Extensions.ATI_envmap_bumpmap);

-   ASSERT((srcFormat == GL_DU8DV8_ATI) ||

-	  (srcFormat == GL_DUDV_ATI));

-   ASSERT(baseInternalFormat == GL_DUDV_ATI);

-

-   if (!srcPacking->SwapBytes && srcType == GL_BYTE &&

-       littleEndian) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (srcType == GL_BYTE) {

-      GLubyte dstmap[4];

-

-      /* dstmap - how to swizzle from RGBA to dst format:

-       */

-      if (littleEndian) {

-	 dstmap[0] = 0;

-	 dstmap[1] = 3;

-      }

-      else {

-	 dstmap[0] = 3;

-	 dstmap[1] = 0;

-      }

-      dstmap[2] = ZERO;		/* ? */

-      dstmap[3] = ONE;		/* ? */

-      

-      _mesa_swizzle_ubyte_image(ctx, dims,

-				GL_LUMINANCE_ALPHA, /* hack */

-				GL_UNSIGNED_BYTE, /* hack */

-				GL_LUMINANCE_ALPHA, /* hack */

-				dstmap, 2,

-				dstAddr, dstXoffset, dstYoffset, dstZoffset,

-				dstRowStride, dstImageOffsets,

-				srcWidth, srcHeight, srcDepth, srcAddr,

-				srcPacking);      

-   }   

-   else {

-      /* general path - note this is defined for 2d textures only */

-      const GLint components = _mesa_components_in_format(baseInternalFormat);

-      const GLint srcStride = _mesa_image_row_stride(srcPacking, srcWidth,

-                                                     srcFormat, srcType);

-      GLbyte *tempImage, *dst, *src;

-      GLint row;

-

-      tempImage = (GLbyte *) malloc(srcWidth * srcHeight * srcDepth

-                                          * components * sizeof(GLbyte));

-      if (!tempImage)

-         return GL_FALSE;

-

-      src = (GLbyte *) _mesa_image_address(dims, srcPacking, srcAddr,

-                                           srcWidth, srcHeight,

-                                           srcFormat, srcType,

-                                           0, 0, 0);

-

-      dst = tempImage;

-      for (row = 0; row < srcHeight; row++) {

-         _mesa_unpack_dudv_span_byte(ctx, srcWidth, baseInternalFormat,

-                                     dst, srcFormat, srcType, src,

-                                     srcPacking, 0);

-         dst += srcWidth * components;

-         src += srcStride;

-      }

- 

-      src = tempImage;

-      dst = (GLbyte *) dstAddr

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-      for (row = 0; row < srcHeight; row++) {

-         memcpy(dst, src, srcWidth * texelBytes);

-         dst += dstRowStride;

-         src += srcWidth * texelBytes;

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store a texture in MESA_FORMAT_SIGNED_R8 format.

- */

-static GLboolean

-_mesa_texstore_signed_r8(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_SIGNED_R8);

-   ASSERT(texelBytes == 1);

-

-   /* XXX look at adding optimized paths */

-   {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *srcRow = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLubyte *dstB = (GLubyte *) dstRow;

-            for (col = 0; col < srcWidth; col++) {

-               dstB[col] = FLOAT_TO_BYTE_TEX(srcRow[RCOMP]);

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store a texture in MESA_FORMAT_SIGNED_RG88 format.

- */

-static GLboolean

-_mesa_texstore_signed_rg88(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RG88);

-   ASSERT(texelBytes == 1);

-

-   /* XXX look at adding optimized paths */

-   {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *srcRow = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLushort *dstUS = (GLushort *) dstRow;

-            for (col = 0; col < srcWidth; col++) {

-               dstUS[col] = PACK_COLOR_88(FLOAT_TO_BYTE_TEX(srcRow[RCOMP]),

-                                          FLOAT_TO_BYTE_TEX(srcRow[GCOMP]));

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store a texture in MESA_FORMAT_SIGNED_RGBX8888.

- */

-static GLboolean

-_mesa_texstore_signed_rgbx8888(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RGBX8888);

-   ASSERT(texelBytes == 4);

-

-   {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *srcRow = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLuint *dstUI = (GLuint *) dstRow;

-            for (col = 0; col < srcWidth; col++) {

-               dstUI[col] = PACK_COLOR_8888( FLOAT_TO_BYTE_TEX(srcRow[RCOMP]),

-                                             FLOAT_TO_BYTE_TEX(srcRow[GCOMP]),

-                                             FLOAT_TO_BYTE_TEX(srcRow[BCOMP]),

-                                             0xff );

-               srcRow += 4;

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-

-/**

- * Store a texture in MESA_FORMAT_SIGNED_RGBA8888 or

- * MESA_FORMAT_SIGNED_RGBA8888_REV

- */

-static GLboolean

-_mesa_texstore_signed_rgba8888(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RGBA8888 ||

-          dstFormat == MESA_FORMAT_SIGNED_RGBA8888_REV);

-   ASSERT(texelBytes == 4);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       dstFormat == MESA_FORMAT_SIGNED_RGBA8888 &&

-       baseInternalFormat == GL_RGBA &&

-      ((srcFormat == GL_RGBA && srcType == GL_BYTE && !littleEndian) ||

-       (srcFormat == GL_ABGR_EXT && srcType == GL_BYTE && littleEndian))) {

-       /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       dstFormat == MESA_FORMAT_SIGNED_RGBA8888_REV &&

-       baseInternalFormat == GL_RGBA &&

-      ((srcFormat == GL_RGBA && srcType == GL_BYTE && littleEndian) ||

-       (srcFormat == GL_ABGR_EXT && srcType == GL_BYTE && !littleEndian))) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-	    (srcType == GL_BYTE) &&

-	    can_swizzle(baseInternalFormat) &&

-	    can_swizzle(srcFormat)) {

-

-      GLubyte dstmap[4];

-

-      /* dstmap - how to swizzle from RGBA to dst format:

-       */

-      if ((littleEndian && dstFormat == MESA_FORMAT_SIGNED_RGBA8888) ||

-	  (!littleEndian && dstFormat == MESA_FORMAT_SIGNED_RGBA8888_REV)) {

-	 dstmap[3] = 0;

-	 dstmap[2] = 1;

-	 dstmap[1] = 2;

-	 dstmap[0] = 3;

-      }

-      else {

-	 dstmap[3] = 3;

-	 dstmap[2] = 2;

-	 dstmap[1] = 1;

-	 dstmap[0] = 0;

-      }

-      

-      _mesa_swizzle_ubyte_image(ctx, dims,

-				srcFormat,

-				srcType,

-				baseInternalFormat,

-				dstmap, 4,

-				dstAddr, dstXoffset, dstYoffset, dstZoffset,

-				dstRowStride, dstImageOffsets,

-				srcWidth, srcHeight, srcDepth, srcAddr,

-				srcPacking);      

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *srcRow = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLuint *dstUI = (GLuint *) dstRow;

-            if (dstFormat == MESA_FORMAT_SIGNED_RGBA8888) {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUI[col] = PACK_COLOR_8888( FLOAT_TO_BYTE_TEX(srcRow[RCOMP]),

-                                                FLOAT_TO_BYTE_TEX(srcRow[GCOMP]),

-                                                FLOAT_TO_BYTE_TEX(srcRow[BCOMP]),

-                                                FLOAT_TO_BYTE_TEX(srcRow[ACOMP]) );

-                  srcRow += 4;

-               }

-            }

-            else {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUI[col] = PACK_COLOR_8888_REV( FLOAT_TO_BYTE_TEX(srcRow[RCOMP]),

-                                                    FLOAT_TO_BYTE_TEX(srcRow[GCOMP]),

-                                                    FLOAT_TO_BYTE_TEX(srcRow[BCOMP]),

-                                                    FLOAT_TO_BYTE_TEX(srcRow[ACOMP]) );

-                  srcRow += 4;

-               }

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store a combined depth/stencil texture image.

- */

-static GLboolean

-_mesa_texstore_z24_s8(TEXSTORE_PARAMS)

-{

-   const GLuint depthScale = 0xffffff;

-   const GLint srcRowStride

-      = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)

-      / sizeof(GLuint);

-   GLint img, row;

-

-   ASSERT(dstFormat == MESA_FORMAT_Z24_S8);

-   ASSERT(srcFormat == GL_DEPTH_STENCIL_EXT || srcFormat == GL_DEPTH_COMPONENT);

-   ASSERT(srcFormat != GL_DEPTH_STENCIL_EXT || srcType == GL_UNSIGNED_INT_24_8_EXT);

-

-   if (srcFormat != GL_DEPTH_COMPONENT && ctx->Pixel.DepthScale == 1.0f &&

-       ctx->Pixel.DepthBias == 0.0f &&

-       !srcPacking->SwapBytes) {

-      /* simple path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (srcFormat == GL_DEPTH_COMPONENT) {

-      /* In case we only upload depth we need to preserve the stencil */

-      for (img = 0; img < srcDepth; img++) {

-	 GLuint *dstRow = (GLuint *) dstAddr

-            + dstImageOffsets[dstZoffset + img]

-            + dstYoffset * dstRowStride / sizeof(GLuint)

-            + dstXoffset;

-         const GLuint *src

-            = (const GLuint *) _mesa_image_address(dims, srcPacking, srcAddr,

-                  srcWidth, srcHeight,

-                  srcFormat, srcType,

-                  img, 0, 0);

-         for (row = 0; row < srcHeight; row++) {

-            GLuint depth[MAX_WIDTH];

-	    GLubyte stencil[MAX_WIDTH];

-            GLint i;

-	    GLboolean keepdepth = GL_FALSE, keepstencil = GL_FALSE;

-

-	    if (srcFormat == GL_DEPTH_COMPONENT) { /* preserve stencil */

-	       keepstencil = GL_TRUE;

-	    }

-            else if (srcFormat == GL_STENCIL_INDEX) { /* preserve depth */

-	       keepdepth = GL_TRUE;

-	    }

-

-	    if (keepdepth == GL_FALSE)

-	       /* the 24 depth bits will be in the low position: */

-	       _mesa_unpack_depth_span(ctx, srcWidth,

-				       GL_UNSIGNED_INT, /* dst type */

-				       keepstencil ? depth : dstRow, /* dst addr */

-				       depthScale,

-				       srcType, src, srcPacking);

-

-	    if (keepstencil == GL_FALSE)

-	       /* get the 8-bit stencil values */

-	       _mesa_unpack_stencil_span(ctx, srcWidth,

-					 GL_UNSIGNED_BYTE, /* dst type */

-					 stencil, /* dst addr */

-					 srcType, src, srcPacking,

-					 ctx->_ImageTransferState);

-

-	    for (i = 0; i < srcWidth; i++) {

-	       if (keepstencil)

-		  dstRow[i] = depth[i] << 8 | (dstRow[i] & 0x000000FF);

-	       else

-		  dstRow[i] = (dstRow[i] & 0xFFFFFF00) | (stencil[i] & 0xFF);

-	    }

-

-            src += srcRowStride;

-            dstRow += dstRowStride / sizeof(GLuint);

-         }

-      }

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store a combined depth/stencil texture image.

- */

-static GLboolean

-_mesa_texstore_s8_z24(TEXSTORE_PARAMS)

-{

-   const GLuint depthScale = 0xffffff;

-   const GLint srcRowStride

-      = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)

-      / sizeof(GLuint);

-   GLint img, row;

-

-   ASSERT(dstFormat == MESA_FORMAT_S8_Z24);

-   ASSERT(srcFormat == GL_DEPTH_STENCIL_EXT ||

-          srcFormat == GL_DEPTH_COMPONENT ||

-          srcFormat == GL_STENCIL_INDEX);

-   ASSERT(srcFormat != GL_DEPTH_STENCIL_EXT ||

-          srcType == GL_UNSIGNED_INT_24_8_EXT);

-

-   for (img = 0; img < srcDepth; img++) {

-      GLuint *dstRow = (GLuint *) dstAddr

-	 + dstImageOffsets[dstZoffset + img]

-	 + dstYoffset * dstRowStride / sizeof(GLuint)

-	 + dstXoffset;

-      const GLuint *src

-	 = (const GLuint *) _mesa_image_address(dims, srcPacking, srcAddr,

-						srcWidth, srcHeight,

-						srcFormat, srcType,

-						img, 0, 0);

-      for (row = 0; row < srcHeight; row++) {

-	 GLuint depth[MAX_WIDTH];

-	 GLubyte stencil[MAX_WIDTH];

-	 GLint i;

-	 GLboolean keepdepth = GL_FALSE, keepstencil = GL_FALSE;

-	 

-	 if (srcFormat == GL_DEPTH_COMPONENT) { /* preserve stencil */

-	    keepstencil = GL_TRUE;

-	 }

-         else if (srcFormat == GL_STENCIL_INDEX) { /* preserve depth */

-	    keepdepth = GL_TRUE;

-	 }

-

-	 if (keepdepth == GL_FALSE)

-	    /* the 24 depth bits will be in the low position: */

-	    _mesa_unpack_depth_span(ctx, srcWidth,

-				    GL_UNSIGNED_INT, /* dst type */

-				    keepstencil ? depth : dstRow, /* dst addr */

-				    depthScale,

-				    srcType, src, srcPacking);	 

-

-	 if (keepstencil == GL_FALSE)

-	    /* get the 8-bit stencil values */

-	    _mesa_unpack_stencil_span(ctx, srcWidth,

-				      GL_UNSIGNED_BYTE, /* dst type */

-				      stencil, /* dst addr */

-				      srcType, src, srcPacking,

-				      ctx->_ImageTransferState);

-

-	 /* merge stencil values into depth values */

-	 for (i = 0; i < srcWidth; i++) {

-	    if (keepstencil)

-	       dstRow[i] = depth[i] | (dstRow[i] & 0xFF000000);

-	    else

-	       dstRow[i] = (dstRow[i] & 0xFFFFFF) | (stencil[i] << 24);

-

-	 }

-	 src += srcRowStride;

-	 dstRow += dstRowStride / sizeof(GLuint);

-      }

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store simple 8-bit/value stencil texture data.

- */

-static GLboolean

-_mesa_texstore_s8(TEXSTORE_PARAMS)

-{

-   ASSERT(dstFormat == MESA_FORMAT_S8);

-   ASSERT(srcFormat == GL_STENCIL_INDEX);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_UNSIGNED_BYTE) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      const GLint srcRowStride

-	 = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)

-	 / sizeof(GLuint);

-      GLint img, row;

-      

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img]

-            + dstYoffset * dstRowStride / sizeof(GLuint)

-            + dstXoffset;

-         const GLuint *src

-            = (const GLuint *) _mesa_image_address(dims, srcPacking, srcAddr,

-                                                   srcWidth, srcHeight,

-                                                   srcFormat, srcType,

-                                                   img, 0, 0);

-         for (row = 0; row < srcHeight; row++) {

-            GLubyte stencil[MAX_WIDTH];

-            GLint i;

-

-            /* get the 8-bit stencil values */

-            _mesa_unpack_stencil_span(ctx, srcWidth,

-                                      GL_UNSIGNED_BYTE, /* dst type */

-                                      stencil, /* dst addr */

-                                      srcType, src, srcPacking,

-                                      ctx->_ImageTransferState);

-            /* merge stencil values into depth values */

-            for (i = 0; i < srcWidth; i++)

-               dstRow[i] = stencil[i];

-

-            src += srcRowStride;

-            dstRow += dstRowStride / sizeof(GLubyte);

-         }

-      }

-

-   }

-

-   return GL_TRUE;

-}

-

-

-/**

- * Store an image in any of the formats:

- *   _mesa_texformat_rgba_float32

- *   _mesa_texformat_rgb_float32

- *   _mesa_texformat_alpha_float32

- *   _mesa_texformat_luminance_float32

- *   _mesa_texformat_luminance_alpha_float32

- *   _mesa_texformat_intensity_float32

- */

-static GLboolean

-_mesa_texstore_rgba_float32(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-   const GLint components = _mesa_components_in_format(baseFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA_FLOAT32 ||

-          dstFormat == MESA_FORMAT_RGB_FLOAT32 ||

-          dstFormat == MESA_FORMAT_ALPHA_FLOAT32 ||

-          dstFormat == MESA_FORMAT_LUMINANCE_FLOAT32 ||

-          dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32 ||

-          dstFormat == MESA_FORMAT_INTENSITY_FLOAT32);

-   ASSERT(baseInternalFormat == GL_RGBA ||

-          baseInternalFormat == GL_RGB ||

-          baseInternalFormat == GL_ALPHA ||

-          baseInternalFormat == GL_LUMINANCE ||

-          baseInternalFormat == GL_LUMINANCE_ALPHA ||

-          baseInternalFormat == GL_INTENSITY);

-   ASSERT(texelBytes == components * sizeof(GLfloat));

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_FLOAT) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *srcRow = tempImage;

-      GLint bytesPerRow;

-      GLint img, row;

-      if (!tempImage)

-         return GL_FALSE;

-      bytesPerRow = srcWidth * components * sizeof(GLfloat);

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            memcpy(dstRow, srcRow, bytesPerRow);

-            dstRow += dstRowStride;

-            srcRow += srcWidth * components;

-         }

-      }

-

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-

-/**

- * As above, but store 16-bit floats.

- */

-static GLboolean

-_mesa_texstore_rgba_float16(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-   const GLint components = _mesa_components_in_format(baseFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA_FLOAT16 ||

-          dstFormat == MESA_FORMAT_RGB_FLOAT16 ||

-          dstFormat == MESA_FORMAT_ALPHA_FLOAT16 ||

-          dstFormat == MESA_FORMAT_LUMINANCE_FLOAT16 ||

-          dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16 ||

-          dstFormat == MESA_FORMAT_INTENSITY_FLOAT16);

-   ASSERT(baseInternalFormat == GL_RGBA ||

-          baseInternalFormat == GL_RGB ||

-          baseInternalFormat == GL_ALPHA ||

-          baseInternalFormat == GL_LUMINANCE ||

-          baseInternalFormat == GL_LUMINANCE_ALPHA ||

-          baseInternalFormat == GL_INTENSITY);

-   ASSERT(texelBytes == components * sizeof(GLhalfARB));

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_HALF_FLOAT_ARB) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *src = tempImage;

-      GLint img, row;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLhalfARB *dstTexel = (GLhalfARB *) dstRow;

-            GLint i;

-            for (i = 0; i < srcWidth * components; i++) {

-               dstTexel[i] = _mesa_float_to_half(src[i]);

-            }

-            dstRow += dstRowStride;

-            src += srcWidth * components;

-         }

-      }

-

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/* non-normalized, signed int8 */

-static GLboolean

-_mesa_texstore_rgba_int8(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-   const GLint components = _mesa_components_in_format(baseFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA_INT8);

-   ASSERT(baseInternalFormat == GL_RGBA ||

-          baseInternalFormat == GL_RGB ||

-          baseInternalFormat == GL_ALPHA ||

-          baseInternalFormat == GL_LUMINANCE ||

-          baseInternalFormat == GL_LUMINANCE_ALPHA ||

-          baseInternalFormat == GL_INTENSITY);

-   ASSERT(texelBytes == components * sizeof(GLbyte));

-

-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply

-    * to integer formats.

-    */

-   if (!srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_BYTE) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking, 0x0);

-      const GLfloat *src = tempImage;

-      GLint img, row;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLbyte *dstTexel = (GLbyte *) dstRow;

-            GLint i;

-            for (i = 0; i < srcWidth * components; i++) {

-               dstTexel[i] = (GLbyte) src[i];

-            }

-            dstRow += dstRowStride;

-            src += srcWidth * components;

-         }

-      }

-

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/* non-normalized, signed int16 */

-static GLboolean

-_mesa_texstore_rgba_int16(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-   const GLint components = _mesa_components_in_format(baseFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA_INT16);

-   ASSERT(baseInternalFormat == GL_RGBA ||

-          baseInternalFormat == GL_RGB ||

-          baseInternalFormat == GL_ALPHA ||

-          baseInternalFormat == GL_LUMINANCE ||

-          baseInternalFormat == GL_LUMINANCE_ALPHA ||

-          baseInternalFormat == GL_INTENSITY);

-   ASSERT(texelBytes == components * sizeof(GLshort));

-

-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply

-    * to integer formats.

-    */

-   if (!srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_SHORT) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking, 0x0);

-      const GLfloat *src = tempImage;

-      GLint img, row;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLshort *dstTexel = (GLshort *) dstRow;

-            GLint i;

-            for (i = 0; i < srcWidth * components; i++) {

-               dstTexel[i] = (GLint) src[i];

-            }

-            dstRow += dstRowStride;

-            src += srcWidth * components;

-         }

-      }

-

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/* non-normalized, signed int32 */

-static GLboolean

-_mesa_texstore_rgba_int32(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-   const GLint components = _mesa_components_in_format(baseFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA_INT32);

-   ASSERT(baseInternalFormat == GL_RGBA ||

-          baseInternalFormat == GL_RGB ||

-          baseInternalFormat == GL_ALPHA ||

-          baseInternalFormat == GL_LUMINANCE ||

-          baseInternalFormat == GL_LUMINANCE_ALPHA ||

-          baseInternalFormat == GL_INTENSITY);

-   ASSERT(texelBytes == components * sizeof(GLint));

-

-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply

-    * to integer formats.

-    */

-   if (!srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_INT) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking, 0x0);

-      const GLfloat *src = tempImage;

-      GLint img, row;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLint *dstTexel = (GLint *) dstRow;

-            GLint i;

-            for (i = 0; i < srcWidth * components; i++) {

-               dstTexel[i] = (GLint) src[i];

-            }

-            dstRow += dstRowStride;

-            src += srcWidth * components;

-         }

-      }

-

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/* non-normalized, unsigned int8 */

-static GLboolean

-_mesa_texstore_rgba_uint8(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-   const GLint components = _mesa_components_in_format(baseFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA_UINT8);

-   ASSERT(baseInternalFormat == GL_RGBA ||

-          baseInternalFormat == GL_RGB ||

-          baseInternalFormat == GL_ALPHA ||

-          baseInternalFormat == GL_LUMINANCE ||

-          baseInternalFormat == GL_LUMINANCE_ALPHA ||

-          baseInternalFormat == GL_INTENSITY);

-   ASSERT(texelBytes == components * sizeof(GLubyte));

-

-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply

-    * to integer formats.

-    */

-   if (!srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_UNSIGNED_BYTE) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLuint *tempImage =

-         make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,

-                              srcWidth, srcHeight, srcDepth,

-                              srcFormat, srcType, srcAddr, srcPacking);

-      const GLuint *src = tempImage;

-      GLint img, row;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLubyte *dstTexel = (GLubyte *) dstRow;

-            GLint i;

-            for (i = 0; i < srcWidth * components; i++) {

-               dstTexel[i] = (GLubyte) CLAMP(src[i], 0, 0xff);

-            }

-            dstRow += dstRowStride;

-            src += srcWidth * components;

-         }

-      }

-

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/* non-normalized, unsigned int16 */

-static GLboolean

-_mesa_texstore_rgba_uint16(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-   const GLint components = _mesa_components_in_format(baseFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA_UINT16);

-   ASSERT(baseInternalFormat == GL_RGBA ||

-          baseInternalFormat == GL_RGB ||

-          baseInternalFormat == GL_ALPHA ||

-          baseInternalFormat == GL_LUMINANCE ||

-          baseInternalFormat == GL_LUMINANCE_ALPHA ||

-          baseInternalFormat == GL_INTENSITY);

-   ASSERT(texelBytes == components * sizeof(GLushort));

-

-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply

-    * to integer formats.

-    */

-   if (!srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_UNSIGNED_SHORT) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLuint *tempImage =

-         make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,

-                              srcWidth, srcHeight, srcDepth,

-                              srcFormat, srcType, srcAddr, srcPacking);

-      const GLuint *src = tempImage;

-      GLint img, row;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLushort *dstTexel = (GLushort *) dstRow;

-            GLint i;

-            for (i = 0; i < srcWidth * components; i++) {

-               dstTexel[i] = (GLushort) CLAMP(src[i], 0, 0xffff);

-            }

-            dstRow += dstRowStride;

-            src += srcWidth * components;

-         }

-      }

-

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/* non-normalized, unsigned int32 */

-static GLboolean

-_mesa_texstore_rgba_uint32(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-   const GLint components = _mesa_components_in_format(baseFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA_UINT32);

-   ASSERT(baseInternalFormat == GL_RGBA ||

-          baseInternalFormat == GL_RGB ||

-          baseInternalFormat == GL_ALPHA ||

-          baseInternalFormat == GL_LUMINANCE ||

-          baseInternalFormat == GL_LUMINANCE_ALPHA ||

-          baseInternalFormat == GL_INTENSITY);

-   ASSERT(texelBytes == components * sizeof(GLuint));

-

-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply

-    * to integer formats.

-    */

-   if (!srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_UNSIGNED_INT) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLuint *tempImage =

-         make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,

-                              srcWidth, srcHeight, srcDepth,

-                              srcFormat, srcType, srcAddr, srcPacking);

-      const GLuint *src = tempImage;

-      GLint img, row;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLuint *dstTexel = (GLuint *) dstRow;

-            GLint i;

-            for (i = 0; i < srcWidth * components; i++) {

-               dstTexel[i] = src[i];

-            }

-            dstRow += dstRowStride;

-            src += srcWidth * components;

-         }

-      }

-

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-

-

-#if FEATURE_EXT_texture_sRGB

-static GLboolean

-_mesa_texstore_srgb8(TEXSTORE_PARAMS)

-{

-   gl_format newDstFormat;

-   GLboolean k;

-

-   ASSERT(dstFormat == MESA_FORMAT_SRGB8);

-

-   /* reuse normal rgb texstore code */

-   newDstFormat = MESA_FORMAT_RGB888;

-

-   k = _mesa_texstore_rgb888(ctx, dims, baseInternalFormat,

-                             newDstFormat, dstAddr,

-                             dstXoffset, dstYoffset, dstZoffset,

-                             dstRowStride, dstImageOffsets,

-                             srcWidth, srcHeight, srcDepth,

-                             srcFormat, srcType,

-                             srcAddr, srcPacking);

-   return k;

-}

-

-

-static GLboolean

-_mesa_texstore_srgba8(TEXSTORE_PARAMS)

-{

-   gl_format newDstFormat;

-   GLboolean k;

-

-   ASSERT(dstFormat == MESA_FORMAT_SRGBA8);

-

-   /* reuse normal rgba texstore code */

-   newDstFormat = MESA_FORMAT_RGBA8888;

-   k = _mesa_texstore_rgba8888(ctx, dims, baseInternalFormat,

-                               newDstFormat, dstAddr,

-                               dstXoffset, dstYoffset, dstZoffset,

-                               dstRowStride, dstImageOffsets,

-                               srcWidth, srcHeight, srcDepth,

-                               srcFormat, srcType,

-                               srcAddr, srcPacking);

-   return k;

-}

-

-

-static GLboolean

-_mesa_texstore_sargb8(TEXSTORE_PARAMS)

-{

-   gl_format newDstFormat;

-   GLboolean k;

-

-   ASSERT(dstFormat == MESA_FORMAT_SARGB8);

-

-   /* reuse normal rgba texstore code */

-   newDstFormat = MESA_FORMAT_ARGB8888;

-

-   k = _mesa_texstore_argb8888(ctx, dims, baseInternalFormat,

-                               newDstFormat, dstAddr,

-                               dstXoffset, dstYoffset, dstZoffset,

-                               dstRowStride, dstImageOffsets,

-                               srcWidth, srcHeight, srcDepth,

-                               srcFormat, srcType,

-                               srcAddr, srcPacking);

-   return k;

-}

-

-

-static GLboolean

-_mesa_texstore_sl8(TEXSTORE_PARAMS)

-{

-   gl_format newDstFormat;

-   GLboolean k;

-

-   ASSERT(dstFormat == MESA_FORMAT_SL8);

-

-   newDstFormat = MESA_FORMAT_L8;

-

-   /* _mesa_textore_a8 handles luminance8 too */

-   k = _mesa_texstore_unorm8(ctx, dims, baseInternalFormat,

-                         newDstFormat, dstAddr,

-                         dstXoffset, dstYoffset, dstZoffset,

-                         dstRowStride, dstImageOffsets,

-                         srcWidth, srcHeight, srcDepth,

-                         srcFormat, srcType,

-                         srcAddr, srcPacking);

-   return k;

-}

-

-

-static GLboolean

-_mesa_texstore_sla8(TEXSTORE_PARAMS)

-{

-   gl_format newDstFormat;

-   GLboolean k;

-

-   ASSERT(dstFormat == MESA_FORMAT_SLA8);

-

-   /* reuse normal luminance/alpha texstore code */

-   newDstFormat = MESA_FORMAT_AL88;

-

-   k = _mesa_texstore_unorm88(ctx, dims, baseInternalFormat,

-			      newDstFormat, dstAddr,

-			      dstXoffset, dstYoffset, dstZoffset,

-			      dstRowStride, dstImageOffsets,

-			      srcWidth, srcHeight, srcDepth,

-			      srcFormat, srcType,

-			      srcAddr, srcPacking);

-   return k;

-}

-

-#else

-

-/* these are used only in texstore_funcs[] below */

-#define _mesa_texstore_srgb8 NULL

-#define _mesa_texstore_srgba8 NULL

-#define _mesa_texstore_sargb8 NULL

-#define _mesa_texstore_sl8 NULL

-#define _mesa_texstore_sla8 NULL

-

-#endif /* FEATURE_EXT_texture_sRGB */

-

-

-

-

-/**

- * Table mapping MESA_FORMAT_* to _mesa_texstore_*()

- * XXX this is somewhat temporary.

- */

-static const struct {

-   gl_format Name;

-   StoreTexImageFunc Store;

-}

-texstore_funcs[MESA_FORMAT_COUNT] =

-{

-   { MESA_FORMAT_NONE, NULL },

-   { MESA_FORMAT_RGBA8888, _mesa_texstore_rgba8888 },

-   { MESA_FORMAT_RGBA8888_REV, _mesa_texstore_rgba8888 },

-   { MESA_FORMAT_ARGB8888, _mesa_texstore_argb8888 },

-   { MESA_FORMAT_ARGB8888_REV, _mesa_texstore_argb8888 },

-   { MESA_FORMAT_XRGB8888, _mesa_texstore_argb8888 },

-   { MESA_FORMAT_XRGB8888_REV, _mesa_texstore_argb8888 },

-   { MESA_FORMAT_RGB888, _mesa_texstore_rgb888 },

-   { MESA_FORMAT_BGR888, _mesa_texstore_bgr888 },

-   { MESA_FORMAT_RGB565, _mesa_texstore_rgb565 },

-   { MESA_FORMAT_RGB565_REV, _mesa_texstore_rgb565 },

-   { MESA_FORMAT_ARGB4444, _mesa_texstore_argb4444 },

-   { MESA_FORMAT_ARGB4444_REV, _mesa_texstore_argb4444 },

-   { MESA_FORMAT_RGBA5551, _mesa_texstore_rgba5551 },

-   { MESA_FORMAT_ARGB1555, _mesa_texstore_argb1555 },

-   { MESA_FORMAT_ARGB1555_REV, _mesa_texstore_argb1555 },

-   { MESA_FORMAT_AL44, _mesa_texstore_unorm44 },

-   { MESA_FORMAT_AL88, _mesa_texstore_unorm88 },

-   { MESA_FORMAT_AL88_REV, _mesa_texstore_unorm88 },

-   { MESA_FORMAT_AL1616, _mesa_texstore_unorm1616 },

-   { MESA_FORMAT_AL1616_REV, _mesa_texstore_unorm1616 },

-   { MESA_FORMAT_RGB332, _mesa_texstore_rgb332 },

-   { MESA_FORMAT_A8, _mesa_texstore_unorm8 },

-   { MESA_FORMAT_A16, _mesa_texstore_unorm16 },

-   { MESA_FORMAT_L8, _mesa_texstore_unorm8 },

-   { MESA_FORMAT_L16, _mesa_texstore_unorm16 },

-   { MESA_FORMAT_I8, _mesa_texstore_unorm8 },

-   { MESA_FORMAT_I16, _mesa_texstore_unorm16 },

-   { MESA_FORMAT_CI8, _mesa_texstore_ci8 },

-   { MESA_FORMAT_YCBCR, _mesa_texstore_ycbcr },

-   { MESA_FORMAT_YCBCR_REV, _mesa_texstore_ycbcr },

-   { MESA_FORMAT_R8, _mesa_texstore_unorm8 },

-   { MESA_FORMAT_RG88, _mesa_texstore_unorm88 },

-   { MESA_FORMAT_RG88_REV, _mesa_texstore_unorm88 },

-   { MESA_FORMAT_R16, _mesa_texstore_unorm16 },

-   { MESA_FORMAT_RG1616, _mesa_texstore_unorm1616 },

-   { MESA_FORMAT_RG1616_REV, _mesa_texstore_unorm1616 },

-   { MESA_FORMAT_ARGB2101010, _mesa_texstore_argb2101010 },

-   { MESA_FORMAT_Z24_S8, _mesa_texstore_z24_s8 },

-   { MESA_FORMAT_S8_Z24, _mesa_texstore_s8_z24 },

-   { MESA_FORMAT_Z16, _mesa_texstore_z16 },

-   { MESA_FORMAT_X8_Z24, _mesa_texstore_x8_z24 },

-   { MESA_FORMAT_Z24_X8, _mesa_texstore_z24_x8 },

-   { MESA_FORMAT_Z32, _mesa_texstore_z32 },

-   { MESA_FORMAT_S8, _mesa_texstore_s8 },

-   { MESA_FORMAT_SRGB8, _mesa_texstore_srgb8 },

-   { MESA_FORMAT_SRGBA8, _mesa_texstore_srgba8 },

-   { MESA_FORMAT_SARGB8, _mesa_texstore_sargb8 },

-   { MESA_FORMAT_SL8, _mesa_texstore_sl8 },

-   { MESA_FORMAT_SLA8, _mesa_texstore_sla8 },

-   { MESA_FORMAT_SRGB_DXT1, _mesa_texstore_rgb_dxt1 },

-   { MESA_FORMAT_SRGBA_DXT1, _mesa_texstore_rgba_dxt1 },

-   { MESA_FORMAT_SRGBA_DXT3, _mesa_texstore_rgba_dxt3 },

-   { MESA_FORMAT_SRGBA_DXT5, _mesa_texstore_rgba_dxt5 },

-   { MESA_FORMAT_RGB_FXT1, _mesa_texstore_rgb_fxt1 },

-   { MESA_FORMAT_RGBA_FXT1, _mesa_texstore_rgba_fxt1 },

-   { MESA_FORMAT_RGB_DXT1, _mesa_texstore_rgb_dxt1 },

-   { MESA_FORMAT_RGBA_DXT1, _mesa_texstore_rgba_dxt1 },

-   { MESA_FORMAT_RGBA_DXT3, _mesa_texstore_rgba_dxt3 },

-   { MESA_FORMAT_RGBA_DXT5, _mesa_texstore_rgba_dxt5 },

-   { MESA_FORMAT_RGBA_FLOAT32, _mesa_texstore_rgba_float32 },

-   { MESA_FORMAT_RGBA_FLOAT16, _mesa_texstore_rgba_float16 },

-   { MESA_FORMAT_RGB_FLOAT32, _mesa_texstore_rgba_float32 },

-   { MESA_FORMAT_RGB_FLOAT16, _mesa_texstore_rgba_float16 },

-   { MESA_FORMAT_ALPHA_FLOAT32, _mesa_texstore_rgba_float32 },

-   { MESA_FORMAT_ALPHA_FLOAT16, _mesa_texstore_rgba_float16 },

-   { MESA_FORMAT_LUMINANCE_FLOAT32, _mesa_texstore_rgba_float32 },

-   { MESA_FORMAT_LUMINANCE_FLOAT16, _mesa_texstore_rgba_float16 },

-   { MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32, _mesa_texstore_rgba_float32 },

-   { MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16, _mesa_texstore_rgba_float16 },

-   { MESA_FORMAT_INTENSITY_FLOAT32, _mesa_texstore_rgba_float32 },

-   { MESA_FORMAT_INTENSITY_FLOAT16, _mesa_texstore_rgba_float16 },

-

-   { MESA_FORMAT_RGBA_INT8, _mesa_texstore_rgba_int8 },

-   { MESA_FORMAT_RGBA_INT16, _mesa_texstore_rgba_int16 },

-   { MESA_FORMAT_RGBA_INT32, _mesa_texstore_rgba_int32 },

-   { MESA_FORMAT_RGBA_UINT8, _mesa_texstore_rgba_uint8 },

-   { MESA_FORMAT_RGBA_UINT16, _mesa_texstore_rgba_uint16 },

-   { MESA_FORMAT_RGBA_UINT32, _mesa_texstore_rgba_uint32 },

-

-   { MESA_FORMAT_DUDV8, _mesa_texstore_dudv8 },

-

-   { MESA_FORMAT_SIGNED_R8, _mesa_texstore_signed_r8 },

-   { MESA_FORMAT_SIGNED_RG88, _mesa_texstore_signed_rg88 },

-   { MESA_FORMAT_SIGNED_RGBX8888, _mesa_texstore_signed_rgbx8888 },

-

-   { MESA_FORMAT_SIGNED_RGBA8888, _mesa_texstore_signed_rgba8888 },

-   { MESA_FORMAT_SIGNED_RGBA8888_REV, _mesa_texstore_signed_rgba8888 },

-

-   { MESA_FORMAT_SIGNED_R_16, _mesa_texstore_signed_rgba_16 },

-   { MESA_FORMAT_SIGNED_RG_16, _mesa_texstore_signed_rgba_16 },

-   { MESA_FORMAT_SIGNED_RGB_16, _mesa_texstore_signed_rgba_16 },

-   { MESA_FORMAT_SIGNED_RGBA_16, _mesa_texstore_signed_rgba_16 },

-   { MESA_FORMAT_RGBA_16, _mesa_texstore_rgba_16 },

-

-   { MESA_FORMAT_RED_RGTC1, _mesa_texstore_red_rgtc1 },

-   { MESA_FORMAT_SIGNED_RED_RGTC1, _mesa_texstore_signed_red_rgtc1 },

-   { MESA_FORMAT_RG_RGTC2, _mesa_texstore_rg_rgtc2 },

-   { MESA_FORMAT_SIGNED_RG_RGTC2, _mesa_texstore_signed_rg_rgtc2 },

-

-   /* Re-use the R/RG texstore functions.

-    * The code is generic enough to handle LATC too. */

-   { MESA_FORMAT_L_LATC1, _mesa_texstore_red_rgtc1 },

-   { MESA_FORMAT_SIGNED_L_LATC1, _mesa_texstore_signed_red_rgtc1 },

-   { MESA_FORMAT_LA_LATC2, _mesa_texstore_rg_rgtc2 },

-   { MESA_FORMAT_SIGNED_LA_LATC2, _mesa_texstore_signed_rg_rgtc2 }

-};

-

-

-static GLboolean

-_mesa_texstore_null(TEXSTORE_PARAMS)

-{

-   (void) ctx; (void) dims;

-   (void) baseInternalFormat;

-   (void) dstFormat;

-   (void) dstAddr;

-   (void) dstXoffset; (void) dstYoffset; (void) dstZoffset;

-   (void) dstRowStride; (void) dstImageOffsets;

-   (void) srcWidth; (void) srcHeight; (void) srcDepth;

-   (void) srcFormat; (void) srcType;

-   (void) srcAddr;

-   (void) srcPacking;

-

-   /* should never happen */

-   _mesa_problem(NULL, "_mesa_texstore_null() is called");

-   return GL_FALSE;

-}

-

-

-/**

- * Return the StoreTexImageFunc pointer to store an image in the given format.

- */

-static StoreTexImageFunc

-_mesa_get_texstore_func(gl_format format)

-{

-#ifdef DEBUG

-   GLuint i;

-   for (i = 0; i < MESA_FORMAT_COUNT; i++) {

-      ASSERT(texstore_funcs[i].Name == i);

-   }

-#endif

-   ASSERT(texstore_funcs[format].Name == format);

-

-   if (texstore_funcs[format].Store)

-      return texstore_funcs[format].Store;

-   else

-      return _mesa_texstore_null;

-}

-

-

-/**

- * Store user data into texture memory.

- * Called via glTex[Sub]Image1/2/3D()

- */

-GLboolean

-_mesa_texstore(TEXSTORE_PARAMS)

-{

-   StoreTexImageFunc storeImage;

-   GLboolean success;

-

-   storeImage = _mesa_get_texstore_func(dstFormat);

-

-   success = storeImage(ctx, dims, baseInternalFormat,

-                        dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                        dstRowStride, dstImageOffsets,

-                        srcWidth, srcHeight, srcDepth,

-                        srcFormat, srcType, srcAddr, srcPacking);

-   return success;

-}

-

-

-/** Return texture size in bytes */

-static GLuint

-texture_size(const struct gl_texture_image *texImage)

-{

-   GLuint sz = _mesa_format_image_size(texImage->TexFormat, texImage->Width,

-                                       texImage->Height, texImage->Depth);

-   return sz;

-}

-

-

-/** Return row stride in bytes */

-static GLuint

-texture_row_stride(const struct gl_texture_image *texImage)

-{

-   GLuint stride = _mesa_format_row_stride(texImage->TexFormat,

-                                           texImage->Width);

-   return stride;

-}

-

-

-

-/**

- * This is the software fallback for Driver.TexImage1D()

- * and Driver.CopyTexImage1D().

- * \sa _mesa_store_teximage2d()

- */

-void

-_mesa_store_teximage1d(struct gl_context *ctx, GLenum target, GLint level,

-                       GLint internalFormat,

-                       GLint width, GLint border,

-                       GLenum format, GLenum type, const GLvoid *pixels,

-                       const struct gl_pixelstore_attrib *packing,

-                       struct gl_texture_object *texObj,

-                       struct gl_texture_image *texImage)

-{

-   GLuint sizeInBytes;

-   (void) border;

-

-   /* allocate memory */

-   sizeInBytes = texture_size(texImage);

-   texImage->Data = _mesa_alloc_texmemory(sizeInBytes);

-   if (!texImage->Data) {

-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");

-      return;

-   }

-

-   pixels = _mesa_validate_pbo_teximage(ctx, 1, width, 1, 1, format, type,

-                                        pixels, packing, "glTexImage1D");

-   if (!pixels) {

-      /* Note: we check for a NULL image pointer here, _after_ we allocated

-       * memory for the texture.  That's what the GL spec calls for.

-       */

-      return;

-   }

-   else {

-      const GLint dstRowStride = 0;

-      GLboolean success = _mesa_texstore(ctx, 1, texImage->_BaseFormat,

-                                         texImage->TexFormat,

-                                         texImage->Data,

-                                         0, 0, 0,  /* dstX/Y/Zoffset */

-                                         dstRowStride,

-                                         texImage->ImageOffsets,

-                                         width, 1, 1,

-                                         format, type, pixels, packing);

-      if (!success) {

-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");

-      }

-   }

-

-   _mesa_unmap_teximage_pbo(ctx, packing);

-}

-

-

-/**

- * This is the software fallback for Driver.TexImage2D()

- * and Driver.CopyTexImage2D().

- *

- * This function is oriented toward storing images in main memory, rather

- * than VRAM.  Device driver's can easily plug in their own replacement.

- */

-void

-_mesa_store_teximage2d(struct gl_context *ctx, GLenum target, GLint level,

-                       GLint internalFormat,

-                       GLint width, GLint height, GLint border,

-                       GLenum format, GLenum type, const void *pixels,

-                       const struct gl_pixelstore_attrib *packing,

-                       struct gl_texture_object *texObj,

-                       struct gl_texture_image *texImage)

-{

-   GLuint sizeInBytes;

-   (void) border;

-

-   /* allocate memory */

-   sizeInBytes = texture_size(texImage);

-   texImage->Data = _mesa_alloc_texmemory(sizeInBytes);

-   if (!texImage->Data) {

-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");

-      return;

-   }

-

-   pixels = _mesa_validate_pbo_teximage(ctx, 2, width, height, 1, format, type,

-                                        pixels, packing, "glTexImage2D");

-   if (!pixels) {

-      /* Note: we check for a NULL image pointer here, _after_ we allocated

-       * memory for the texture.  That's what the GL spec calls for.

-       */

-      return;

-   }

-   else {

-      GLint dstRowStride = texture_row_stride(texImage);

-      GLboolean success = _mesa_texstore(ctx, 2, texImage->_BaseFormat,

-                                         texImage->TexFormat,

-                                         texImage->Data,

-                                         0, 0, 0,  /* dstX/Y/Zoffset */

-                                         dstRowStride,

-                                         texImage->ImageOffsets,

-                                         width, height, 1,

-                                         format, type, pixels, packing);

-      if (!success) {

-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");

-      }

-   }

-

-   _mesa_unmap_teximage_pbo(ctx, packing);

-}

-

-

-

-/**

- * This is the software fallback for Driver.TexImage3D()

- * and Driver.CopyTexImage3D().

- * \sa _mesa_store_teximage2d()

- */

-void

-_mesa_store_teximage3d(struct gl_context *ctx, GLenum target, GLint level,

-                       GLint internalFormat,

-                       GLint width, GLint height, GLint depth, GLint border,

-                       GLenum format, GLenum type, const void *pixels,

-                       const struct gl_pixelstore_attrib *packing,

-                       struct gl_texture_object *texObj,

-                       struct gl_texture_image *texImage)

-{

-   GLuint sizeInBytes;

-   (void) border;

-

-   /* allocate memory */

-   sizeInBytes = texture_size(texImage);

-   texImage->Data = _mesa_alloc_texmemory(sizeInBytes);

-   if (!texImage->Data) {

-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");

-      return;

-   }

-

-   pixels = _mesa_validate_pbo_teximage(ctx, 3, width, height, depth, format,

-                                        type, pixels, packing, "glTexImage3D");

-   if (!pixels) {

-      /* Note: we check for a NULL image pointer here, _after_ we allocated

-       * memory for the texture.  That's what the GL spec calls for.

-       */

-      return;

-   }

-   else {

-      GLint dstRowStride = texture_row_stride(texImage);

-      GLboolean success = _mesa_texstore(ctx, 3, texImage->_BaseFormat,

-                                         texImage->TexFormat,

-                                         texImage->Data,

-                                         0, 0, 0,  /* dstX/Y/Zoffset */

-                                         dstRowStride,

-                                         texImage->ImageOffsets,

-                                         width, height, depth,

-                                         format, type, pixels, packing);

-      if (!success) {

-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");

-      }

-   }

-

-   _mesa_unmap_teximage_pbo(ctx, packing);

-}

-

-

-

-

-/*

- * This is the software fallback for Driver.TexSubImage1D()

- * and Driver.CopyTexSubImage1D().

- */

-void

-_mesa_store_texsubimage1d(struct gl_context *ctx, GLenum target, GLint level,

-                          GLint xoffset, GLint width,

-                          GLenum format, GLenum type, const void *pixels,

-                          const struct gl_pixelstore_attrib *packing,

-                          struct gl_texture_object *texObj,

-                          struct gl_texture_image *texImage)

-{

-   /* get pointer to src pixels (may be in a pbo which we'll map here) */

-   pixels = _mesa_validate_pbo_teximage(ctx, 1, width, 1, 1, format, type,

-                                        pixels, packing, "glTexSubImage1D");

-   if (!pixels)

-      return;

-

-   {

-      const GLint dstRowStride = 0;

-      GLboolean success = _mesa_texstore(ctx, 1, texImage->_BaseFormat,

-                                         texImage->TexFormat,

-                                         texImage->Data,

-                                         xoffset, 0, 0,  /* offsets */

-                                         dstRowStride,

-                                         texImage->ImageOffsets,

-                                         width, 1, 1,

-                                         format, type, pixels, packing);

-      if (!success) {

-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage1D");

-      }

-   }

-

-   _mesa_unmap_teximage_pbo(ctx, packing);

-}

-

-

-

-/**

- * This is the software fallback for Driver.TexSubImage2D()

- * and Driver.CopyTexSubImage2D().

- */

-void

-_mesa_store_texsubimage2d(struct gl_context *ctx, GLenum target, GLint level,

-                          GLint xoffset, GLint yoffset,

-                          GLint width, GLint height,

-                          GLenum format, GLenum type, const void *pixels,

-                          const struct gl_pixelstore_attrib *packing,

-                          struct gl_texture_object *texObj,

-                          struct gl_texture_image *texImage)

-{

-   /* get pointer to src pixels (may be in a pbo which we'll map here) */

-   pixels = _mesa_validate_pbo_teximage(ctx, 2, width, height, 1, format, type,

-                                        pixels, packing, "glTexSubImage2D");

-   if (!pixels)

-      return;

-

-   {

-      GLint dstRowStride = texture_row_stride(texImage);

-      GLboolean success = _mesa_texstore(ctx, 2, texImage->_BaseFormat,

-                                         texImage->TexFormat,

-                                         texImage->Data,

-                                         xoffset, yoffset, 0,

-                                         dstRowStride,

-                                         texImage->ImageOffsets,

-                                         width, height, 1,

-                                         format, type, pixels, packing);

-      if (!success) {

-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage2D");

-      }

-   }

-

-   _mesa_unmap_teximage_pbo(ctx, packing);

-}

-

-

-/*

- * This is the software fallback for Driver.TexSubImage3D().

- * and Driver.CopyTexSubImage3D().

- */

-void

-_mesa_store_texsubimage3d(struct gl_context *ctx, GLenum target, GLint level,

-                          GLint xoffset, GLint yoffset, GLint zoffset,

-                          GLint width, GLint height, GLint depth,

-                          GLenum format, GLenum type, const void *pixels,

-                          const struct gl_pixelstore_attrib *packing,

-                          struct gl_texture_object *texObj,

-                          struct gl_texture_image *texImage)

-{

-   /* get pointer to src pixels (may be in a pbo which we'll map here) */

-   pixels = _mesa_validate_pbo_teximage(ctx, 3, width, height, depth, format,

-                                        type, pixels, packing,

-                                        "glTexSubImage3D");

-   if (!pixels)

-      return;

-

-   {

-      GLint dstRowStride = texture_row_stride(texImage);

-      GLboolean success = _mesa_texstore(ctx, 3, texImage->_BaseFormat,

-                                         texImage->TexFormat,

-                                         texImage->Data,

-                                         xoffset, yoffset, zoffset,

-                                         dstRowStride,

-                                         texImage->ImageOffsets,

-                                         width, height, depth,

-                                         format, type, pixels, packing);

-      if (!success) {

-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage3D");

-      }

-   }

-

-   _mesa_unmap_teximage_pbo(ctx, packing);

-}

-

-

-/*

- * Fallback for Driver.CompressedTexImage1D()

- */

-void

-_mesa_store_compressed_teximage1d(struct gl_context *ctx,

-                                  GLenum target, GLint level,

-                                  GLint internalFormat,

-                                  GLint width, GLint border,

-                                  GLsizei imageSize, const GLvoid *data,

-                                  struct gl_texture_object *texObj,

-                                  struct gl_texture_image *texImage)

-{

-   /* this space intentionally left blank */

-   (void) ctx;

-   (void) target; (void) level;

-   (void) internalFormat;

-   (void) width; (void) border;

-   (void) imageSize; (void) data;

-   (void) texObj;

-   (void) texImage;

-}

-

-

-

-/**

- * Fallback for Driver.CompressedTexImage2D()

- */

-void

-_mesa_store_compressed_teximage2d(struct gl_context *ctx,

-                                  GLenum target, GLint level,

-                                  GLint internalFormat,

-                                  GLint width, GLint height, GLint border,

-                                  GLsizei imageSize, const GLvoid *data,

-                                  struct gl_texture_object *texObj,

-                                  struct gl_texture_image *texImage)

-{

-   (void) width; (void) height; (void) border;

-

-   /* This is pretty simple, basically just do a memcpy without worrying

-    * about the usual image unpacking or image transfer operations.

-    */

-   ASSERT(texObj);

-   ASSERT(texImage);

-   ASSERT(texImage->Width > 0);

-   ASSERT(texImage->Height > 0);

-   ASSERT(texImage->Depth == 1);

-   ASSERT(texImage->Data == NULL); /* was freed in glCompressedTexImage2DARB */

-

-   /* allocate storage */

-   texImage->Data = _mesa_alloc_texmemory(imageSize);

-   if (!texImage->Data) {

-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2DARB");

-      return;

-   }

-

-   data = _mesa_validate_pbo_compressed_teximage(ctx, imageSize, data,

-                                                 &ctx->Unpack,

-                                                 "glCompressedTexImage2D");

-   if (!data)

-      return;

-

-   /* copy the data */

-   memcpy(texImage->Data, data, imageSize);

-

-   _mesa_unmap_teximage_pbo(ctx, &ctx->Unpack);

-}

-

-

-

-/*

- * Fallback for Driver.CompressedTexImage3D()

- */

-void

-_mesa_store_compressed_teximage3d(struct gl_context *ctx,

-                                  GLenum target, GLint level,

-                                  GLint internalFormat,

-                                  GLint width, GLint height, GLint depth,

-                                  GLint border,

-                                  GLsizei imageSize, const GLvoid *data,

-                                  struct gl_texture_object *texObj,

-                                  struct gl_texture_image *texImage)

-{

-   /* this space intentionally left blank */

-   (void) ctx;

-   (void) target; (void) level;

-   (void) internalFormat;

-   (void) width; (void) height; (void) depth;

-   (void) border;

-   (void) imageSize; (void) data;

-   (void) texObj;

-   (void) texImage;

-}

-

-

-

-/**

- * Fallback for Driver.CompressedTexSubImage1D()

- */

-void

-_mesa_store_compressed_texsubimage1d(struct gl_context *ctx, GLenum target,

-                                     GLint level,

-                                     GLint xoffset, GLsizei width,

-                                     GLenum format,

-                                     GLsizei imageSize, const GLvoid *data,

-                                     struct gl_texture_object *texObj,

-                                     struct gl_texture_image *texImage)

-{

-   /* there are no compressed 1D texture formats yet */

-   (void) ctx;

-   (void) target; (void) level;

-   (void) xoffset; (void) width;

-   (void) format;

-   (void) imageSize; (void) data;

-   (void) texObj;

-   (void) texImage;

-}

-

-

-/**

- * Fallback for Driver.CompressedTexSubImage2D()

- */

-void

-_mesa_store_compressed_texsubimage2d(struct gl_context *ctx, GLenum target,

-                                     GLint level,

-                                     GLint xoffset, GLint yoffset,

-                                     GLsizei width, GLsizei height,

-                                     GLenum format,

-                                     GLsizei imageSize, const GLvoid *data,

-                                     struct gl_texture_object *texObj,

-                                     struct gl_texture_image *texImage)

-{

-   GLint bytesPerRow, destRowStride, srcRowStride;

-   GLint i, rows;

-   GLubyte *dest;

-   const GLubyte *src;

-   const gl_format texFormat = texImage->TexFormat;

-   const GLint destWidth = texImage->Width;

-   GLuint bw, bh;

-

-   _mesa_get_format_block_size(texFormat, &bw, &bh);

-

-   (void) level;

-   (void) format;

-

-   /* these should have been caught sooner */

-   ASSERT((width % bw) == 0 || width == 2 || width == 1);

-   ASSERT((height % bh) == 0 || height == 2 || height == 1);

-   ASSERT((xoffset % bw) == 0);

-   ASSERT((yoffset % bh) == 0);

-

-   /* get pointer to src pixels (may be in a pbo which we'll map here) */

-   data = _mesa_validate_pbo_compressed_teximage(ctx, imageSize, data,

-                                                 &ctx->Unpack,

-                                                 "glCompressedTexSubImage2D");

-   if (!data)

-      return;

-

-   srcRowStride = _mesa_format_row_stride(texFormat, width);

-   src = (const GLubyte *) data;

-

-   destRowStride = _mesa_format_row_stride(texFormat, destWidth);

-   dest = _mesa_compressed_image_address(xoffset, yoffset, 0,

-                                         texFormat, destWidth,

-                                         (GLubyte *) texImage->Data);

-

-   bytesPerRow = srcRowStride;  /* bytes per row of blocks */

-   rows = height / bh;  /* rows in blocks */

-

-   /* copy rows of blocks */

-   for (i = 0; i < rows; i++) {

-      memcpy(dest, src, bytesPerRow);

-      dest += destRowStride;

-      src += srcRowStride;

-   }

-

-   _mesa_unmap_teximage_pbo(ctx, &ctx->Unpack);

-}

-

-

-/**

- * Fallback for Driver.CompressedTexSubImage3D()

- */

-void

-_mesa_store_compressed_texsubimage3d(struct gl_context *ctx, GLenum target,

-                                GLint level,

-                                GLint xoffset, GLint yoffset, GLint zoffset,

-                                GLsizei width, GLsizei height, GLsizei depth,

-                                GLenum format,

-                                GLsizei imageSize, const GLvoid *data,

-                                struct gl_texture_object *texObj,

-                                struct gl_texture_image *texImage)

-{

-   /* there are no compressed 3D texture formats yet */

-   (void) ctx;

-   (void) target; (void) level;

-   (void) xoffset; (void) yoffset; (void) zoffset;

-   (void) width; (void) height; (void) depth;

-   (void) format;

-   (void) imageSize; (void) data;

-   (void) texObj;

-   (void) texImage;

-}

+/*
+ * Mesa 3-D graphics library
+ * Version:  7.5
+ *
+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (c) 2008-2009  VMware, Inc.
+ *
+ * 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.
+ */
+
+/*
+ * Authors:
+ *   Brian Paul
+ */
+
+/**
+ * The GL texture image functions in teximage.c basically just do
+ * error checking and data structure allocation.  They in turn call
+ * device driver functions which actually copy/convert/store the user's
+ * texture image data.
+ *
+ * However, most device drivers will be able to use the fallback functions
+ * in this file.  That is, most drivers will have the following bit of
+ * code:
+ *   ctx->Driver.TexImage1D = _mesa_store_teximage1d;
+ *   ctx->Driver.TexImage2D = _mesa_store_teximage2d;
+ *   ctx->Driver.TexImage3D = _mesa_store_teximage3d;
+ *   etc...
+ *
+ * Texture image processing is actually kind of complicated.  We have to do:
+ *    Format/type conversions
+ *    pixel unpacking
+ *    pixel transfer (scale, bais, lookup, etc)
+ *
+ * These functions can handle most everything, including processing full
+ * images and sub-images.
+ */
+
+
+#include "glheader.h"
+#include "bufferobj.h"
+#include "colormac.h"
+#include "image.h"
+#include "macros.h"
+#include "mipmap.h"
+#include "mfeatures.h"
+#include "mtypes.h"
+#include "pack.h"
+#include "pbo.h"
+#include "imports.h"
+#include "pack.h"
+#include "texcompress.h"
+#include "texcompress_fxt1.h"
+#include "texcompress_rgtc.h"
+#include "texcompress_s3tc.h"
+#include "teximage.h"
+#include "texstore.h"
+#include "enums.h"
+
+
+enum {
+   ZERO = 4, 
+   ONE = 5
+};
+
+
+/**
+ * Texture image storage function.
+ */
+typedef GLboolean (*StoreTexImageFunc)(TEXSTORE_PARAMS);
+
+
+/**
+ * Return GL_TRUE if the given image format is one that be converted
+ * to another format by swizzling.
+ */
+static GLboolean
+can_swizzle(GLenum logicalBaseFormat)
+{
+   switch (logicalBaseFormat) {
+   case GL_RGBA:
+   case GL_RGB:
+   case GL_LUMINANCE_ALPHA:
+   case GL_INTENSITY:
+   case GL_ALPHA:
+   case GL_LUMINANCE:
+   case GL_RED:
+   case GL_GREEN:
+   case GL_BLUE:
+   case GL_BGR:
+   case GL_BGRA:
+   case GL_ABGR_EXT:
+   case GL_RG:
+      return GL_TRUE;
+   default:
+      return GL_FALSE;
+   }
+}
+
+
+
+enum {
+   IDX_LUMINANCE = 0,
+   IDX_ALPHA,
+   IDX_INTENSITY,
+   IDX_LUMINANCE_ALPHA,
+   IDX_RGB,
+   IDX_RGBA,
+   IDX_RED,
+   IDX_GREEN,
+   IDX_BLUE,
+   IDX_BGR,
+   IDX_BGRA,
+   IDX_ABGR,
+   IDX_RG,
+   MAX_IDX
+};
+
+#define MAP1(x)       MAP4(x, ZERO, ZERO, ZERO)
+#define MAP2(x,y)     MAP4(x, y, ZERO, ZERO)
+#define MAP3(x,y,z)   MAP4(x, y, z, ZERO)
+#define MAP4(x,y,z,w) { x, y, z, w, ZERO, ONE }
+
+
+static const struct {
+   GLubyte format_idx;
+   GLubyte to_rgba[6];
+   GLubyte from_rgba[6];
+} mappings[MAX_IDX] = 
+{
+   {
+      IDX_LUMINANCE,
+      MAP4(0,0,0,ONE),
+      MAP1(0)
+   },
+
+   {
+      IDX_ALPHA,
+      MAP4(ZERO, ZERO, ZERO, 0),
+      MAP1(3)
+   },
+
+   {
+      IDX_INTENSITY,
+      MAP4(0, 0, 0, 0),
+      MAP1(0),
+   },
+
+   {
+      IDX_LUMINANCE_ALPHA,
+      MAP4(0,0,0,1),
+      MAP2(0,3)
+   },
+
+   {
+      IDX_RGB,
+      MAP4(0,1,2,ONE),
+      MAP3(0,1,2)
+   },
+
+   {
+      IDX_RGBA,
+      MAP4(0,1,2,3),
+      MAP4(0,1,2,3),
+   },
+
+   {
+      IDX_RED,
+      MAP4(0, ZERO, ZERO, ONE),
+      MAP1(0),
+   },
+
+   {
+      IDX_GREEN,
+      MAP4(ZERO, 0, ZERO, ONE),
+      MAP1(1),
+   },
+
+   {
+      IDX_BLUE,
+      MAP4(ZERO, ZERO, 0, ONE),
+      MAP1(2),
+   },
+
+   {
+      IDX_BGR,
+      MAP4(2,1,0,ONE),
+      MAP3(2,1,0)
+   },
+
+   {
+      IDX_BGRA,
+      MAP4(2,1,0,3),
+      MAP4(2,1,0,3)
+   },
+
+   {
+      IDX_ABGR,
+      MAP4(3,2,1,0),
+      MAP4(3,2,1,0)
+   },
+
+   {
+      IDX_RG,
+      MAP4(0, 1, ZERO, ONE),
+      MAP2(0, 1)
+   },
+};
+
+
+
+/**
+ * Convert a GL image format enum to an IDX_* value (see above).
+ */
+static int
+get_map_idx(GLenum value)
+{
+   switch (value) {
+   case GL_LUMINANCE: return IDX_LUMINANCE;
+   case GL_ALPHA: return IDX_ALPHA;
+   case GL_INTENSITY: return IDX_INTENSITY;
+   case GL_LUMINANCE_ALPHA: return IDX_LUMINANCE_ALPHA;
+   case GL_RGB: return IDX_RGB;
+   case GL_RGBA: return IDX_RGBA;
+   case GL_RED: return IDX_RED;
+   case GL_GREEN: return IDX_GREEN;
+   case GL_BLUE: return IDX_BLUE;
+   case GL_BGR: return IDX_BGR;
+   case GL_BGRA: return IDX_BGRA;
+   case GL_ABGR_EXT: return IDX_ABGR;
+   case GL_RG: return IDX_RG;
+   default:
+      _mesa_problem(NULL, "Unexpected inFormat");
+      return 0;
+   }
+}   
+
+
+/**
+ * When promoting texture formats (see below) we need to compute the
+ * mapping of dest components back to source components.
+ * This function does that.
+ * \param inFormat  the incoming format of the texture
+ * \param outFormat  the final texture format
+ * \return map[6]  a full 6-component map
+ */
+static void
+compute_component_mapping(GLenum inFormat, GLenum outFormat, 
+			  GLubyte *map)
+{
+   const int inFmt = get_map_idx(inFormat);
+   const int outFmt = get_map_idx(outFormat);
+   const GLubyte *in2rgba = mappings[inFmt].to_rgba;
+   const GLubyte *rgba2out = mappings[outFmt].from_rgba;
+   int i;
+   
+   for (i = 0; i < 4; i++)
+      map[i] = in2rgba[rgba2out[i]];
+
+   map[ZERO] = ZERO;
+   map[ONE] = ONE;   
+
+#if 0
+   printf("from %x/%s to %x/%s map %d %d %d %d %d %d\n",
+	  inFormat, _mesa_lookup_enum_by_nr(inFormat),
+	  outFormat, _mesa_lookup_enum_by_nr(outFormat),
+	  map[0], 
+	  map[1], 
+	  map[2], 
+	  map[3], 
+	  map[4], 
+	  map[5]); 
+#endif
+}
+
+
+/**
+ * Make a temporary (color) texture image with GLfloat components.
+ * Apply all needed pixel unpacking and pixel transfer operations.
+ * Note that there are both logicalBaseFormat and textureBaseFormat parameters.
+ * Suppose the user specifies GL_LUMINANCE as the internal texture format
+ * but the graphics hardware doesn't support luminance textures.  So, we might
+ * use an RGB hardware format instead.
+ * If logicalBaseFormat != textureBaseFormat we have some extra work to do.
+ *
+ * \param ctx  the rendering context
+ * \param dims  image dimensions: 1, 2 or 3
+ * \param logicalBaseFormat  basic texture derived from the user's
+ *    internal texture format value
+ * \param textureBaseFormat  the actual basic format of the texture
+ * \param srcWidth  source image width
+ * \param srcHeight  source image height
+ * \param srcDepth  source image depth
+ * \param srcFormat  source image format
+ * \param srcType  source image type
+ * \param srcAddr  source image address
+ * \param srcPacking  source image pixel packing
+ * \return resulting image with format = textureBaseFormat and type = GLfloat.
+ */
+GLfloat *
+_mesa_make_temp_float_image(struct gl_context *ctx, GLuint dims,
+			    GLenum logicalBaseFormat,
+			    GLenum textureBaseFormat,
+			    GLint srcWidth, GLint srcHeight, GLint srcDepth,
+			    GLenum srcFormat, GLenum srcType,
+			    const GLvoid *srcAddr,
+			    const struct gl_pixelstore_attrib *srcPacking,
+			    GLbitfield transferOps)
+{
+   GLfloat *tempImage;
+   const GLint components = _mesa_components_in_format(logicalBaseFormat);
+   const GLint srcStride =
+      _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
+   GLfloat *dst;
+   GLint img, row;
+
+   ASSERT(dims >= 1 && dims <= 3);
+
+   ASSERT(logicalBaseFormat == GL_RGBA ||
+          logicalBaseFormat == GL_RGB ||
+          logicalBaseFormat == GL_RG ||
+          logicalBaseFormat == GL_RED ||
+          logicalBaseFormat == GL_LUMINANCE_ALPHA ||
+          logicalBaseFormat == GL_LUMINANCE ||
+          logicalBaseFormat == GL_ALPHA ||
+          logicalBaseFormat == GL_INTENSITY ||
+          logicalBaseFormat == GL_COLOR_INDEX ||
+          logicalBaseFormat == GL_DEPTH_COMPONENT);
+
+   ASSERT(textureBaseFormat == GL_RGBA ||
+          textureBaseFormat == GL_RGB ||
+          textureBaseFormat == GL_RG ||
+          textureBaseFormat == GL_RED ||
+          textureBaseFormat == GL_LUMINANCE_ALPHA ||
+          textureBaseFormat == GL_LUMINANCE ||
+          textureBaseFormat == GL_ALPHA ||
+          textureBaseFormat == GL_INTENSITY ||
+          textureBaseFormat == GL_COLOR_INDEX ||
+          textureBaseFormat == GL_DEPTH_COMPONENT);
+
+   tempImage = (GLfloat *) malloc(srcWidth * srcHeight * srcDepth
+				  * components * sizeof(GLfloat));
+   if (!tempImage)
+      return NULL;
+
+   dst = tempImage;
+   for (img = 0; img < srcDepth; img++) {
+      const GLubyte *src
+	 = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
+						 srcWidth, srcHeight,
+						 srcFormat, srcType,
+						 img, 0, 0);
+      for (row = 0; row < srcHeight; row++) {
+	 _mesa_unpack_color_span_float(ctx, srcWidth, logicalBaseFormat,
+				       dst, srcFormat, srcType, src,
+				       srcPacking, transferOps);
+	 dst += srcWidth * components;
+	 src += srcStride;
+      }
+   }
+
+   if (logicalBaseFormat != textureBaseFormat) {
+      /* more work */
+      GLint texComponents = _mesa_components_in_format(textureBaseFormat);
+      GLint logComponents = _mesa_components_in_format(logicalBaseFormat);
+      GLfloat *newImage;
+      GLint i, n;
+      GLubyte map[6];
+
+      /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */
+      ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||
+             textureBaseFormat == GL_LUMINANCE_ALPHA);
+
+      /* The actual texture format should have at least as many components
+       * as the logical texture format.
+       */
+      ASSERT(texComponents >= logComponents);
+
+      newImage = (GLfloat *) malloc(srcWidth * srcHeight * srcDepth
+                                          * texComponents * sizeof(GLfloat));
+      if (!newImage) {
+         free(tempImage);
+         return NULL;
+      }
+
+      compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);
+
+      n = srcWidth * srcHeight * srcDepth;
+      for (i = 0; i < n; i++) {
+         GLint k;
+         for (k = 0; k < texComponents; k++) {
+            GLint j = map[k];
+            if (j == ZERO)
+               newImage[i * texComponents + k] = 0.0F;
+            else if (j == ONE)
+               newImage[i * texComponents + k] = 1.0F;
+            else
+               newImage[i * texComponents + k] = tempImage[i * logComponents + j];
+         }
+      }
+
+      free(tempImage);
+      tempImage = newImage;
+   }
+
+   return tempImage;
+}
+
+
+/**
+ * Make temporary image with uint pixel values.  Used for unsigned
+ * integer-valued textures.
+ */
+static GLuint *
+make_temp_uint_image(struct gl_context *ctx, GLuint dims,
+                     GLenum logicalBaseFormat,
+                     GLenum textureBaseFormat,
+                     GLint srcWidth, GLint srcHeight, GLint srcDepth,
+                     GLenum srcFormat, GLenum srcType,
+                     const GLvoid *srcAddr,
+                     const struct gl_pixelstore_attrib *srcPacking)
+{
+   GLuint *tempImage;
+   const GLint components = _mesa_components_in_format(logicalBaseFormat);
+   const GLint srcStride =
+      _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
+   GLuint *dst;
+   GLint img, row;
+
+   ASSERT(dims >= 1 && dims <= 3);
+
+   ASSERT(logicalBaseFormat == GL_RGBA ||
+          logicalBaseFormat == GL_RGB ||
+          logicalBaseFormat == GL_RG ||
+          logicalBaseFormat == GL_RED ||
+          logicalBaseFormat == GL_LUMINANCE_ALPHA ||
+          logicalBaseFormat == GL_LUMINANCE ||
+          logicalBaseFormat == GL_INTENSITY ||
+          logicalBaseFormat == GL_ALPHA);
+
+   ASSERT(textureBaseFormat == GL_RGBA ||
+          textureBaseFormat == GL_RGB ||
+          textureBaseFormat == GL_RG ||
+          textureBaseFormat == GL_RED ||
+          textureBaseFormat == GL_LUMINANCE_ALPHA ||
+          textureBaseFormat == GL_LUMINANCE ||
+          textureBaseFormat == GL_ALPHA);
+
+   tempImage = (GLuint *) malloc(srcWidth * srcHeight * srcDepth
+                                 * components * sizeof(GLuint));
+   if (!tempImage)
+      return NULL;
+
+   dst = tempImage;
+   for (img = 0; img < srcDepth; img++) {
+      const GLubyte *src
+	 = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
+						 srcWidth, srcHeight,
+						 srcFormat, srcType,
+						 img, 0, 0);
+      for (row = 0; row < srcHeight; row++) {
+	 _mesa_unpack_color_span_uint(ctx, srcWidth, logicalBaseFormat,
+                                      dst, srcFormat, srcType, src,
+                                      srcPacking);
+	 dst += srcWidth * components;
+	 src += srcStride;
+      }
+   }
+
+   if (logicalBaseFormat != textureBaseFormat) {
+      /* more work */
+      GLint texComponents = _mesa_components_in_format(textureBaseFormat);
+      GLint logComponents = _mesa_components_in_format(logicalBaseFormat);
+      GLuint *newImage;
+      GLint i, n;
+      GLubyte map[6];
+
+      /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */
+      ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||
+             textureBaseFormat == GL_LUMINANCE_ALPHA);
+
+      /* The actual texture format should have at least as many components
+       * as the logical texture format.
+       */
+      ASSERT(texComponents >= logComponents);
+
+      newImage = (GLuint *) malloc(srcWidth * srcHeight * srcDepth
+                                   * texComponents * sizeof(GLuint));
+      if (!newImage) {
+         free(tempImage);
+         return NULL;
+      }
+
+      compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);
+
+      n = srcWidth * srcHeight * srcDepth;
+      for (i = 0; i < n; i++) {
+         GLint k;
+         for (k = 0; k < texComponents; k++) {
+            GLint j = map[k];
+            if (j == ZERO)
+               newImage[i * texComponents + k] = 0.0F;
+            else if (j == ONE)
+               newImage[i * texComponents + k] = 1.0F;
+            else
+               newImage[i * texComponents + k] = tempImage[i * logComponents + j];
+         }
+      }
+
+      free(tempImage);
+      tempImage = newImage;
+   }
+
+   return tempImage;
+}
+
+
+
+/**
+ * Make a temporary (color) texture image with GLchan components.
+ * Apply all needed pixel unpacking and pixel transfer operations.
+ * Note that there are both logicalBaseFormat and textureBaseFormat parameters.
+ * Suppose the user specifies GL_LUMINANCE as the internal texture format
+ * but the graphics hardware doesn't support luminance textures.  So, we might
+ * use an RGB hardware format instead.
+ * If logicalBaseFormat != textureBaseFormat we have some extra work to do.
+ *
+ * \param ctx  the rendering context
+ * \param dims  image dimensions: 1, 2 or 3
+ * \param logicalBaseFormat  basic texture derived from the user's
+ *    internal texture format value
+ * \param textureBaseFormat  the actual basic format of the texture
+ * \param srcWidth  source image width
+ * \param srcHeight  source image height
+ * \param srcDepth  source image depth
+ * \param srcFormat  source image format
+ * \param srcType  source image type
+ * \param srcAddr  source image address
+ * \param srcPacking  source image pixel packing
+ * \return resulting image with format = textureBaseFormat and type = GLchan.
+ */
+GLchan *
+_mesa_make_temp_chan_image(struct gl_context *ctx, GLuint dims,
+                           GLenum logicalBaseFormat,
+                           GLenum textureBaseFormat,
+                           GLint srcWidth, GLint srcHeight, GLint srcDepth,
+                           GLenum srcFormat, GLenum srcType,
+                           const GLvoid *srcAddr,
+                           const struct gl_pixelstore_attrib *srcPacking)
+{
+   GLuint transferOps = ctx->_ImageTransferState;
+   const GLint components = _mesa_components_in_format(logicalBaseFormat);
+   GLint img, row;
+   GLchan *tempImage, *dst;
+
+   ASSERT(dims >= 1 && dims <= 3);
+
+   ASSERT(logicalBaseFormat == GL_RGBA ||
+          logicalBaseFormat == GL_RGB ||
+          logicalBaseFormat == GL_RG ||
+          logicalBaseFormat == GL_RED ||
+          logicalBaseFormat == GL_LUMINANCE_ALPHA ||
+          logicalBaseFormat == GL_LUMINANCE ||
+          logicalBaseFormat == GL_ALPHA ||
+          logicalBaseFormat == GL_INTENSITY);
+
+   ASSERT(textureBaseFormat == GL_RGBA ||
+          textureBaseFormat == GL_RGB ||
+          textureBaseFormat == GL_RG ||
+          textureBaseFormat == GL_RED ||
+          textureBaseFormat == GL_LUMINANCE_ALPHA ||
+          textureBaseFormat == GL_LUMINANCE ||
+          textureBaseFormat == GL_ALPHA ||
+          textureBaseFormat == GL_INTENSITY);
+
+   /* unpack and transfer the source image */
+   tempImage = (GLchan *) malloc(srcWidth * srcHeight * srcDepth
+                                       * components * sizeof(GLchan));
+   if (!tempImage) {
+      return NULL;
+   }
+
+   dst = tempImage;
+   for (img = 0; img < srcDepth; img++) {
+      const GLint srcStride =
+         _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
+      const GLubyte *src =
+         (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
+                                               srcWidth, srcHeight,
+                                               srcFormat, srcType,
+                                               img, 0, 0);
+      for (row = 0; row < srcHeight; row++) {
+         _mesa_unpack_color_span_chan(ctx, srcWidth, logicalBaseFormat, dst,
+                                      srcFormat, srcType, src, srcPacking,
+                                      transferOps);
+         dst += srcWidth * components;
+         src += srcStride;
+      }
+   }
+
+   if (logicalBaseFormat != textureBaseFormat) {
+      /* one more conversion step */
+      GLint texComponents = _mesa_components_in_format(textureBaseFormat);
+      GLint logComponents = _mesa_components_in_format(logicalBaseFormat);
+      GLchan *newImage;
+      GLint i, n;
+      GLubyte map[6];
+
+      /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */
+      ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||
+             textureBaseFormat == GL_LUMINANCE_ALPHA);
+
+      /* The actual texture format should have at least as many components
+       * as the logical texture format.
+       */
+      ASSERT(texComponents >= logComponents);
+
+      newImage = (GLchan *) malloc(srcWidth * srcHeight * srcDepth
+                                         * texComponents * sizeof(GLchan));
+      if (!newImage) {
+         free(tempImage);
+         return NULL;
+      }
+
+      compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);
+
+      n = srcWidth * srcHeight * srcDepth;
+      for (i = 0; i < n; i++) {
+         GLint k;
+         for (k = 0; k < texComponents; k++) {
+            GLint j = map[k];
+            if (j == ZERO)
+               newImage[i * texComponents + k] = 0;
+            else if (j == ONE)
+               newImage[i * texComponents + k] = CHAN_MAX;
+            else
+               newImage[i * texComponents + k] = tempImage[i * logComponents + j];
+         }
+      }
+
+      free(tempImage);
+      tempImage = newImage;
+   }
+
+   return tempImage;
+}
+
+
+/**
+ * Copy GLubyte pixels from <src> to <dst> with swizzling.
+ * \param dst  destination pixels
+ * \param dstComponents  number of color components in destination pixels
+ * \param src  source pixels
+ * \param srcComponents  number of color components in source pixels
+ * \param map  the swizzle mapping.  map[X] says where to find the X component
+ *             in the source image's pixels.  For example, if the source image
+ *             is GL_BGRA and X = red, map[0] yields 2.
+ * \param count  number of pixels to copy/swizzle.
+ */
+static void
+swizzle_copy(GLubyte *dst, GLuint dstComponents, const GLubyte *src, 
+             GLuint srcComponents, const GLubyte *map, GLuint count)
+{
+#define SWZ_CPY(dst, src, count, dstComps, srcComps) \
+   do {                                              \
+      GLuint i;                                      \
+      for (i = 0; i < count; i++) {                  \
+         GLuint j;                                   \
+         if (srcComps == 4) {                        \
+            COPY_4UBV(tmp, src);                     \
+         }                                           \
+         else {                                      \
+            for (j = 0; j < srcComps; j++) {         \
+               tmp[j] = src[j];                      \
+            }                                        \
+         }                                           \
+         src += srcComps;                            \
+         for (j = 0; j < dstComps; j++) {            \
+            dst[j] = tmp[map[j]];                    \
+         }                                           \
+         dst += dstComps;                            \
+      }                                              \
+   } while (0)
+
+   GLubyte tmp[6];
+
+   tmp[ZERO] = 0x0;
+   tmp[ONE] = 0xff;
+
+   ASSERT(srcComponents <= 4);
+   ASSERT(dstComponents <= 4);
+
+   switch (dstComponents) {
+   case 4:
+      switch (srcComponents) {
+      case 4:
+         SWZ_CPY(dst, src, count, 4, 4);
+         break;
+      case 3:
+         SWZ_CPY(dst, src, count, 4, 3);
+         break;
+      case 2:
+         SWZ_CPY(dst, src, count, 4, 2);
+         break;
+      case 1:
+         SWZ_CPY(dst, src, count, 4, 1);
+         break;
+      default:
+         ;
+      }
+      break;
+   case 3:
+      switch (srcComponents) {
+      case 4:
+         SWZ_CPY(dst, src, count, 3, 4);
+         break;
+      case 3:
+         SWZ_CPY(dst, src, count, 3, 3);
+         break;
+      case 2:
+         SWZ_CPY(dst, src, count, 3, 2);
+         break;
+      case 1:
+         SWZ_CPY(dst, src, count, 3, 1);
+         break;
+      default:
+         ;
+      }
+      break;
+   case 2:
+      switch (srcComponents) {
+      case 4:
+         SWZ_CPY(dst, src, count, 2, 4);
+         break;
+      case 3:
+         SWZ_CPY(dst, src, count, 2, 3);
+         break;
+      case 2:
+         SWZ_CPY(dst, src, count, 2, 2);
+         break;
+      case 1:
+         SWZ_CPY(dst, src, count, 2, 1);
+         break;
+      default:
+         ;
+      }
+      break;
+   case 1:
+      switch (srcComponents) {
+      case 4:
+         SWZ_CPY(dst, src, count, 1, 4);
+         break;
+      case 3:
+         SWZ_CPY(dst, src, count, 1, 3);
+         break;
+      case 2:
+         SWZ_CPY(dst, src, count, 1, 2);
+         break;
+      case 1:
+         SWZ_CPY(dst, src, count, 1, 1);
+         break;
+      default:
+         ;
+      }
+      break;
+   default:
+      ;
+   }
+#undef SWZ_CPY
+}
+
+
+
+static const GLubyte map_identity[6] = { 0, 1, 2, 3, ZERO, ONE };
+static const GLubyte map_3210[6] = { 3, 2, 1, 0, ZERO, ONE };
+
+
+/**
+ * For 1-byte/pixel formats (or 8_8_8_8 packed formats), return a
+ * mapping array depending on endianness.
+ */
+static const GLubyte *
+type_mapping( GLenum srcType )
+{
+   switch (srcType) {
+   case GL_BYTE:
+   case GL_UNSIGNED_BYTE:
+      return map_identity;
+   case GL_UNSIGNED_INT_8_8_8_8:
+      return _mesa_little_endian() ? map_3210 : map_identity;
+   case GL_UNSIGNED_INT_8_8_8_8_REV:
+      return _mesa_little_endian() ? map_identity : map_3210;
+   default:
+      return NULL;
+   }
+}
+
+
+/**
+ * For 1-byte/pixel formats (or 8_8_8_8 packed formats), return a
+ * mapping array depending on pixelstore byte swapping state.
+ */
+static const GLubyte *
+byteswap_mapping( GLboolean swapBytes,
+		  GLenum srcType )
+{
+   if (!swapBytes) 
+      return map_identity;
+
+   switch (srcType) {
+   case GL_BYTE:
+   case GL_UNSIGNED_BYTE:
+      return map_identity;
+   case GL_UNSIGNED_INT_8_8_8_8:
+   case GL_UNSIGNED_INT_8_8_8_8_REV:
+      return map_3210;
+   default:
+      return NULL;
+   }
+}
+
+
+
+/**
+ * Transfer a GLubyte texture image with component swizzling.
+ */
+static void
+_mesa_swizzle_ubyte_image(struct gl_context *ctx, 
+			  GLuint dimensions,
+			  GLenum srcFormat,
+			  GLenum srcType,
+
+			  GLenum baseInternalFormat,
+
+			  const GLubyte *rgba2dst,
+			  GLuint dstComponents,
+
+			  GLvoid *dstAddr,
+			  GLint dstXoffset, GLint dstYoffset, GLint dstZoffset,
+			  GLint dstRowStride,
+                          const GLuint *dstImageOffsets,
+
+			  GLint srcWidth, GLint srcHeight, GLint srcDepth,
+			  const GLvoid *srcAddr,
+			  const struct gl_pixelstore_attrib *srcPacking )
+{
+   GLint srcComponents = _mesa_components_in_format(srcFormat);
+   const GLubyte *srctype2ubyte, *swap;
+   GLubyte map[4], src2base[6], base2rgba[6];
+   GLint i;
+   const GLint srcRowStride =
+      _mesa_image_row_stride(srcPacking, srcWidth,
+                             srcFormat, GL_UNSIGNED_BYTE);
+   const GLint srcImageStride
+      = _mesa_image_image_stride(srcPacking, srcWidth, srcHeight, srcFormat,
+                                 GL_UNSIGNED_BYTE);
+   const GLubyte *srcImage
+      = (const GLubyte *) _mesa_image_address(dimensions, srcPacking, srcAddr,
+                                              srcWidth, srcHeight, srcFormat,
+                                              GL_UNSIGNED_BYTE, 0, 0, 0);
+
+   (void) ctx;
+
+   /* Translate from src->baseInternal->GL_RGBA->dst.  This will
+    * correctly deal with RGBA->RGB->RGBA conversions where the final
+    * A value must be 0xff regardless of the incoming alpha values.
+    */
+   compute_component_mapping(srcFormat, baseInternalFormat, src2base);
+   compute_component_mapping(baseInternalFormat, GL_RGBA, base2rgba);
+   swap = byteswap_mapping(srcPacking->SwapBytes, srcType);
+   srctype2ubyte = type_mapping(srcType);
+
+
+   for (i = 0; i < 4; i++)
+      map[i] = srctype2ubyte[swap[src2base[base2rgba[rgba2dst[i]]]]];
+
+/*    printf("map %d %d %d %d\n", map[0], map[1], map[2], map[3]);  */
+
+   if (srcComponents == dstComponents &&
+       srcRowStride == dstRowStride &&
+       srcRowStride == srcWidth * srcComponents &&
+       dimensions < 3) {
+      /* 1 and 2D images only */
+      GLubyte *dstImage = (GLubyte *) dstAddr
+         + dstYoffset * dstRowStride
+         + dstXoffset * dstComponents;
+      swizzle_copy(dstImage, dstComponents, srcImage, srcComponents, map, 
+		   srcWidth * srcHeight);
+   }
+   else {
+      GLint img, row;
+      for (img = 0; img < srcDepth; img++) {
+         const GLubyte *srcRow = srcImage;
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * dstComponents
+            + dstYoffset * dstRowStride
+            + dstXoffset * dstComponents;
+         for (row = 0; row < srcHeight; row++) {
+	    swizzle_copy(dstRow, dstComponents, srcRow, srcComponents, map, srcWidth);
+            dstRow += dstRowStride;
+            srcRow += srcRowStride;
+         }
+         srcImage += srcImageStride;
+      }
+   }
+}
+
+
+/**
+ * Teximage storage routine for when a simple memcpy will do.
+ * No pixel transfer operations or special texel encodings allowed.
+ * 1D, 2D and 3D images supported.
+ */
+static void
+memcpy_texture(struct gl_context *ctx,
+	       GLuint dimensions,
+               gl_format dstFormat,
+               GLvoid *dstAddr,
+               GLint dstXoffset, GLint dstYoffset, GLint dstZoffset,
+               GLint dstRowStride,
+               const GLuint *dstImageOffsets,
+               GLint srcWidth, GLint srcHeight, GLint srcDepth,
+               GLenum srcFormat, GLenum srcType,
+               const GLvoid *srcAddr,
+               const struct gl_pixelstore_attrib *srcPacking)
+{
+   const GLint srcRowStride = _mesa_image_row_stride(srcPacking, srcWidth,
+                                                     srcFormat, srcType);
+   const GLint srcImageStride = _mesa_image_image_stride(srcPacking,
+                                      srcWidth, srcHeight, srcFormat, srcType);
+   const GLubyte *srcImage = (const GLubyte *) _mesa_image_address(dimensions,
+        srcPacking, srcAddr, srcWidth, srcHeight, srcFormat, srcType, 0, 0, 0);
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLint bytesPerRow = srcWidth * texelBytes;
+
+#if 0
+   /* XXX update/re-enable for dstImageOffsets array */
+   const GLint bytesPerImage = srcHeight * bytesPerRow;
+   const GLint bytesPerTexture = srcDepth * bytesPerImage;
+   GLubyte *dstImage = (GLubyte *) dstAddr
+                     + dstZoffset * dstImageStride
+                     + dstYoffset * dstRowStride
+                     + dstXoffset * texelBytes;
+
+   if (dstRowStride == srcRowStride &&
+       dstRowStride == bytesPerRow &&
+       ((dstImageStride == srcImageStride &&
+         dstImageStride == bytesPerImage) ||
+        (srcDepth == 1))) {
+      /* one big memcpy */
+      ctx->Driver.TextureMemCpy(dstImage, srcImage, bytesPerTexture);
+   }
+   else
+   {
+      GLint img, row;
+      for (img = 0; img < srcDepth; img++) {
+         const GLubyte *srcRow = srcImage;
+         GLubyte *dstRow = dstImage;
+         for (row = 0; row < srcHeight; row++) {
+            ctx->Driver.TextureMemCpy(dstRow, srcRow, bytesPerRow);
+            dstRow += dstRowStride;
+            srcRow += srcRowStride;
+         }
+         srcImage += srcImageStride;
+         dstImage += dstImageStride;
+      }
+   }
+#endif
+
+   GLint img, row;
+   for (img = 0; img < srcDepth; img++) {
+      const GLubyte *srcRow = srcImage;
+      GLubyte *dstRow = (GLubyte *) dstAddr
+         + dstImageOffsets[dstZoffset + img] * texelBytes
+         + dstYoffset * dstRowStride
+         + dstXoffset * texelBytes;
+      for (row = 0; row < srcHeight; row++) {
+         ctx->Driver.TextureMemCpy(dstRow, srcRow, bytesPerRow);
+         dstRow += dstRowStride;
+         srcRow += srcRowStride;
+      }
+      srcImage += srcImageStride;
+   }
+}
+
+
+
+/**
+ * Store a 32-bit integer depth component texture image.
+ */
+static GLboolean
+_mesa_texstore_z32(TEXSTORE_PARAMS)
+{
+   const GLuint depthScale = 0xffffffff;
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   (void) dims;
+   ASSERT(dstFormat == MESA_FORMAT_Z32);
+   ASSERT(texelBytes == sizeof(GLuint));
+
+   if (ctx->Pixel.DepthScale == 1.0f &&
+       ctx->Pixel.DepthBias == 0.0f &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == GL_DEPTH_COMPONENT &&
+       srcFormat == GL_DEPTH_COMPONENT &&
+       srcType == GL_UNSIGNED_INT) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      GLint img, row;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            const GLvoid *src = _mesa_image_address(dims, srcPacking,
+                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
+            _mesa_unpack_depth_span(ctx, srcWidth,
+                                    GL_UNSIGNED_INT, (GLuint *) dstRow,
+                                    depthScale, srcType, src, srcPacking);
+            dstRow += dstRowStride;
+         }
+      }
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store a 24-bit integer depth component texture image.
+ */
+static GLboolean
+_mesa_texstore_x8_z24(TEXSTORE_PARAMS)
+{
+   const GLuint depthScale = 0xffffff;
+   const GLuint texelBytes = 4;
+
+   (void) dims;
+   ASSERT(dstFormat == MESA_FORMAT_X8_Z24);
+
+   {
+      /* general path */
+      GLint img, row;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            const GLvoid *src = _mesa_image_address(dims, srcPacking,
+                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
+            _mesa_unpack_depth_span(ctx, srcWidth,
+                                    GL_UNSIGNED_INT, (GLuint *) dstRow,
+                                    depthScale, srcType, src, srcPacking);
+            dstRow += dstRowStride;
+         }
+      }
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store a 24-bit integer depth component texture image.
+ */
+static GLboolean
+_mesa_texstore_z24_x8(TEXSTORE_PARAMS)
+{
+   const GLuint depthScale = 0xffffff;
+   const GLuint texelBytes = 4;
+
+   (void) dims;
+   ASSERT(dstFormat == MESA_FORMAT_Z24_X8);
+
+   {
+      /* general path */
+      GLint img, row;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            const GLvoid *src = _mesa_image_address(dims, srcPacking,
+                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
+            GLuint *dst = (GLuint *) dstRow;
+            GLint i;
+            _mesa_unpack_depth_span(ctx, srcWidth,
+                                    GL_UNSIGNED_INT, dst,
+                                    depthScale, srcType, src, srcPacking);
+            for (i = 0; i < srcWidth; i++)
+               dst[i] <<= 8;
+            dstRow += dstRowStride;
+         }
+      }
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store a 16-bit integer depth component texture image.
+ */
+static GLboolean
+_mesa_texstore_z16(TEXSTORE_PARAMS)
+{
+   const GLuint depthScale = 0xffff;
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   (void) dims;
+   ASSERT(dstFormat == MESA_FORMAT_Z16);
+   ASSERT(texelBytes == sizeof(GLushort));
+
+   if (ctx->Pixel.DepthScale == 1.0f &&
+       ctx->Pixel.DepthBias == 0.0f &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == GL_DEPTH_COMPONENT &&
+       srcFormat == GL_DEPTH_COMPONENT &&
+       srcType == GL_UNSIGNED_SHORT) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      GLint img, row;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            const GLvoid *src = _mesa_image_address(dims, srcPacking,
+                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
+            GLushort *dst16 = (GLushort *) dstRow;
+            _mesa_unpack_depth_span(ctx, srcWidth,
+                                    GL_UNSIGNED_SHORT, dst16, depthScale,
+                                    srcType, src, srcPacking);
+            dstRow += dstRowStride;
+         }
+      }
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store an rgb565 or rgb565_rev texture image.
+ */
+static GLboolean
+_mesa_texstore_rgb565(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGB565 ||
+          dstFormat == MESA_FORMAT_RGB565_REV);
+   ASSERT(texelBytes == 2);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == MESA_FORMAT_RGB565 &&
+       baseInternalFormat == GL_RGB &&
+       srcFormat == GL_RGB &&
+       srcType == GL_UNSIGNED_SHORT_5_6_5) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+            !srcPacking->SwapBytes &&
+            baseInternalFormat == GL_RGB &&
+            srcFormat == GL_RGB &&
+            srcType == GL_UNSIGNED_BYTE &&
+            dims == 2) {
+      /* do optimized tex store */
+      const GLint srcRowStride =
+         _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
+      const GLubyte *src = (const GLubyte *)
+         _mesa_image_address(dims, srcPacking, srcAddr, srcWidth, srcHeight,
+                             srcFormat, srcType, 0, 0, 0);
+      GLubyte *dst = (GLubyte *) dstAddr
+                   + dstYoffset * dstRowStride
+                   + dstXoffset * texelBytes;
+      GLint row, col;
+      for (row = 0; row < srcHeight; row++) {
+         const GLubyte *srcUB = (const GLubyte *) src;
+         GLushort *dstUS = (GLushort *) dst;
+         /* check for byteswapped format */
+         if (dstFormat == MESA_FORMAT_RGB565) {
+            for (col = 0; col < srcWidth; col++) {
+               dstUS[col] = PACK_COLOR_565( srcUB[0], srcUB[1], srcUB[2] );
+               srcUB += 3;
+            }
+         }
+         else {
+            for (col = 0; col < srcWidth; col++) {
+               dstUS[col] = PACK_COLOR_565_REV( srcUB[0], srcUB[1], srcUB[2] );
+               srcUB += 3;
+            }
+         }
+         dst += dstRowStride;
+         src += srcRowStride;
+      }
+   }
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLushort *dstUS = (GLushort *) dstRow;
+            /* check for byteswapped format */
+            if (dstFormat == MESA_FORMAT_RGB565) {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUS[col] = PACK_COLOR_565( CHAN_TO_UBYTE(src[RCOMP]),
+                                               CHAN_TO_UBYTE(src[GCOMP]),
+                                               CHAN_TO_UBYTE(src[BCOMP]) );
+                  src += 3;
+               }
+            }
+            else {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUS[col] = PACK_COLOR_565_REV( CHAN_TO_UBYTE(src[RCOMP]),
+                                                   CHAN_TO_UBYTE(src[GCOMP]),
+                                                   CHAN_TO_UBYTE(src[BCOMP]) );
+                  src += 3;
+               }
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store a texture in MESA_FORMAT_RGBA8888 or MESA_FORMAT_RGBA8888_REV.
+ */
+static GLboolean
+_mesa_texstore_rgba8888(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA8888 ||
+          dstFormat == MESA_FORMAT_RGBA8888_REV);
+   ASSERT(texelBytes == 4);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == MESA_FORMAT_RGBA8888 &&
+       baseInternalFormat == GL_RGBA &&
+      ((srcFormat == GL_RGBA && srcType == GL_UNSIGNED_INT_8_8_8_8) ||
+       (srcFormat == GL_RGBA && srcType == GL_UNSIGNED_BYTE && !littleEndian) ||
+       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_INT_8_8_8_8_REV) ||
+       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_BYTE && littleEndian))) {
+       /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == MESA_FORMAT_RGBA8888_REV &&
+       baseInternalFormat == GL_RGBA &&
+      ((srcFormat == GL_RGBA && srcType == GL_UNSIGNED_INT_8_8_8_8_REV) ||
+       (srcFormat == GL_RGBA && srcType == GL_UNSIGNED_BYTE && littleEndian) ||
+       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_INT_8_8_8_8) ||
+       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_BYTE && !littleEndian))) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+	    (srcType == GL_UNSIGNED_BYTE ||
+	     srcType == GL_UNSIGNED_INT_8_8_8_8 ||
+	     srcType == GL_UNSIGNED_INT_8_8_8_8_REV) &&
+	    can_swizzle(baseInternalFormat) &&
+	    can_swizzle(srcFormat)) {
+
+      GLubyte dstmap[4];
+
+      /* dstmap - how to swizzle from RGBA to dst format:
+       */
+      if ((littleEndian && dstFormat == MESA_FORMAT_RGBA8888) ||
+	  (!littleEndian && dstFormat == MESA_FORMAT_RGBA8888_REV)) {
+	 dstmap[3] = 0;
+	 dstmap[2] = 1;
+	 dstmap[1] = 2;
+	 dstmap[0] = 3;
+      }
+      else {
+	 dstmap[3] = 3;
+	 dstmap[2] = 2;
+	 dstmap[1] = 1;
+	 dstmap[0] = 0;
+      }
+      
+      _mesa_swizzle_ubyte_image(ctx, dims,
+				srcFormat,
+				srcType,
+				baseInternalFormat,
+				dstmap, 4,
+				dstAddr, dstXoffset, dstYoffset, dstZoffset,
+				dstRowStride, dstImageOffsets,
+				srcWidth, srcHeight, srcDepth, srcAddr,
+				srcPacking);      
+   }
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLuint *dstUI = (GLuint *) dstRow;
+            if (dstFormat == MESA_FORMAT_RGBA8888) {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUI[col] = PACK_COLOR_8888( CHAN_TO_UBYTE(src[RCOMP]),
+                                                CHAN_TO_UBYTE(src[GCOMP]),
+                                                CHAN_TO_UBYTE(src[BCOMP]),
+                                                CHAN_TO_UBYTE(src[ACOMP]) );
+                  src += 4;
+               }
+            }
+            else {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUI[col] = PACK_COLOR_8888_REV( CHAN_TO_UBYTE(src[RCOMP]),
+                                                    CHAN_TO_UBYTE(src[GCOMP]),
+                                                    CHAN_TO_UBYTE(src[BCOMP]),
+                                                    CHAN_TO_UBYTE(src[ACOMP]) );
+                  src += 4;
+               }
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+static GLboolean
+_mesa_texstore_argb8888(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = GL_RGBA;
+
+   ASSERT(dstFormat == MESA_FORMAT_ARGB8888 ||
+          dstFormat == MESA_FORMAT_ARGB8888_REV ||
+          dstFormat == MESA_FORMAT_XRGB8888 ||
+          dstFormat == MESA_FORMAT_XRGB8888_REV );
+   ASSERT(texelBytes == 4);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       (dstFormat == MESA_FORMAT_ARGB8888 ||
+        dstFormat == MESA_FORMAT_XRGB8888) &&
+       baseInternalFormat == GL_RGBA &&
+       srcFormat == GL_BGRA &&
+       ((srcType == GL_UNSIGNED_BYTE && littleEndian) ||
+        srcType == GL_UNSIGNED_INT_8_8_8_8_REV)) {
+      /* simple memcpy path (little endian) */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       (dstFormat == MESA_FORMAT_ARGB8888_REV ||
+        dstFormat == MESA_FORMAT_XRGB8888_REV) &&
+       baseInternalFormat == GL_RGBA &&
+       srcFormat == GL_BGRA &&
+       ((srcType == GL_UNSIGNED_BYTE && !littleEndian) ||
+        srcType == GL_UNSIGNED_INT_8_8_8_8)) {
+      /* simple memcpy path (big endian) */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+            !srcPacking->SwapBytes &&
+	    (dstFormat == MESA_FORMAT_ARGB8888 ||
+             dstFormat == MESA_FORMAT_XRGB8888) &&
+            srcFormat == GL_RGB &&
+	    (baseInternalFormat == GL_RGBA ||
+	     baseInternalFormat == GL_RGB) &&
+            srcType == GL_UNSIGNED_BYTE) {
+      int img, row, col;
+      for (img = 0; img < srcDepth; img++) {
+         const GLint srcRowStride =
+            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
+         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,
+                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLuint *d4 = (GLuint *) dstRow;
+            for (col = 0; col < srcWidth; col++) {
+               d4[col] = PACK_COLOR_8888(0xff,
+                                         srcRow[col * 3 + RCOMP],
+                                         srcRow[col * 3 + GCOMP],
+                                         srcRow[col * 3 + BCOMP]);
+            }
+            dstRow += dstRowStride;
+            srcRow += srcRowStride;
+         }
+      }
+   }
+   else if (!ctx->_ImageTransferState &&
+            !srcPacking->SwapBytes &&
+	    dstFormat == MESA_FORMAT_ARGB8888 &&
+            srcFormat == GL_RGBA &&
+	    baseInternalFormat == GL_RGBA &&
+            srcType == GL_UNSIGNED_BYTE) {
+      /* same as above case, but src data has alpha too */
+      GLint img, row, col;
+      /* For some reason, streaming copies to write-combined regions
+       * are extremely sensitive to the characteristics of how the
+       * source data is retrieved.  By reordering the source reads to
+       * be in-order, the speed of this operation increases by half.
+       * Strangely the same isn't required for the RGB path, above.
+       */
+      for (img = 0; img < srcDepth; img++) {
+         const GLint srcRowStride =
+            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
+         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,
+                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLuint *d4 = (GLuint *) dstRow;
+            for (col = 0; col < srcWidth; col++) {
+               d4[col] = PACK_COLOR_8888(srcRow[col * 4 + ACOMP],
+                                         srcRow[col * 4 + RCOMP],
+                                         srcRow[col * 4 + GCOMP],
+                                         srcRow[col * 4 + BCOMP]);
+            }
+            dstRow += dstRowStride;
+            srcRow += srcRowStride;
+         }
+      }
+   }
+   else if (!ctx->_ImageTransferState &&
+	    (srcType == GL_UNSIGNED_BYTE ||
+	     srcType == GL_UNSIGNED_INT_8_8_8_8 ||
+	     srcType == GL_UNSIGNED_INT_8_8_8_8_REV) &&
+	    can_swizzle(baseInternalFormat) &&	   
+	    can_swizzle(srcFormat)) {
+
+      GLubyte dstmap[4];
+
+      /* dstmap - how to swizzle from RGBA to dst format:
+       */
+      if ((littleEndian && dstFormat == MESA_FORMAT_ARGB8888) ||
+          (littleEndian && dstFormat == MESA_FORMAT_XRGB8888) ||
+	  (!littleEndian && dstFormat == MESA_FORMAT_ARGB8888_REV) ||
+	  (!littleEndian && dstFormat == MESA_FORMAT_XRGB8888_REV)) {
+	 dstmap[3] = 3;		/* alpha */
+	 dstmap[2] = 0;		/* red */
+	 dstmap[1] = 1;		/* green */
+	 dstmap[0] = 2;		/* blue */
+      }
+      else {
+	 assert((littleEndian && dstFormat == MESA_FORMAT_ARGB8888_REV) ||
+		(!littleEndian && dstFormat == MESA_FORMAT_ARGB8888) ||
+		(littleEndian && dstFormat == MESA_FORMAT_XRGB8888_REV) ||
+		(!littleEndian && dstFormat == MESA_FORMAT_XRGB8888));
+	 dstmap[3] = 2;
+	 dstmap[2] = 1;
+	 dstmap[1] = 0;
+	 dstmap[0] = 3;
+      }
+ 
+      _mesa_swizzle_ubyte_image(ctx, dims,
+				srcFormat,
+				srcType,
+				baseInternalFormat,
+				dstmap, 4,
+				dstAddr, dstXoffset, dstYoffset, dstZoffset,
+				dstRowStride,
+                                dstImageOffsets,
+				srcWidth, srcHeight, srcDepth, srcAddr,
+				srcPacking);      
+   }
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLuint *dstUI = (GLuint *) dstRow;
+            if (dstFormat == MESA_FORMAT_ARGB8888) {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUI[col] = PACK_COLOR_8888( CHAN_TO_UBYTE(src[ACOMP]),
+                                                CHAN_TO_UBYTE(src[RCOMP]),
+                                                CHAN_TO_UBYTE(src[GCOMP]),
+                                                CHAN_TO_UBYTE(src[BCOMP]) );
+                  src += 4;
+               }
+            }
+            else if (dstFormat == MESA_FORMAT_XRGB8888) {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUI[col] = PACK_COLOR_8888( 0xff,
+                                                CHAN_TO_UBYTE(src[RCOMP]),
+                                                CHAN_TO_UBYTE(src[GCOMP]),
+                                                CHAN_TO_UBYTE(src[BCOMP]) );
+                  src += 4;
+               }
+            }
+            else {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUI[col] = PACK_COLOR_8888_REV( CHAN_TO_UBYTE(src[ACOMP]),
+                                                    CHAN_TO_UBYTE(src[RCOMP]),
+                                                    CHAN_TO_UBYTE(src[GCOMP]),
+                                                    CHAN_TO_UBYTE(src[BCOMP]) );
+                  src += 4;
+               }
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+static GLboolean
+_mesa_texstore_rgb888(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGB888);
+   ASSERT(texelBytes == 3);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == GL_RGB &&
+       srcFormat == GL_BGR &&
+       srcType == GL_UNSIGNED_BYTE &&
+       littleEndian) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+            !srcPacking->SwapBytes &&
+            srcFormat == GL_RGBA &&
+            srcType == GL_UNSIGNED_BYTE) {
+      /* extract RGB from RGBA */
+      GLint img, row, col;
+      for (img = 0; img < srcDepth; img++) {
+         const GLint srcRowStride =
+            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
+         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,
+                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            for (col = 0; col < srcWidth; col++) {
+               dstRow[col * 3 + 0] = srcRow[col * 4 + BCOMP];
+               dstRow[col * 3 + 1] = srcRow[col * 4 + GCOMP];
+               dstRow[col * 3 + 2] = srcRow[col * 4 + RCOMP];
+            }
+            dstRow += dstRowStride;
+            srcRow += srcRowStride;
+         }
+      }
+   }
+   else if (!ctx->_ImageTransferState &&
+	    srcType == GL_UNSIGNED_BYTE &&
+	    can_swizzle(baseInternalFormat) &&
+	    can_swizzle(srcFormat)) {
+
+      GLubyte dstmap[4];
+
+      /* dstmap - how to swizzle from RGBA to dst format:
+       */
+      dstmap[0] = 2;
+      dstmap[1] = 1;
+      dstmap[2] = 0;
+      dstmap[3] = ONE;		/* ? */
+      
+      _mesa_swizzle_ubyte_image(ctx, dims,
+				srcFormat,
+				srcType,
+				baseInternalFormat,
+				dstmap, 3,
+				dstAddr, dstXoffset, dstYoffset, dstZoffset,
+				dstRowStride, dstImageOffsets,
+				srcWidth, srcHeight, srcDepth, srcAddr,
+				srcPacking);      
+   }
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = (const GLchan *) tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+#if 0
+            if (littleEndian) {
+               for (col = 0; col < srcWidth; col++) {
+                  dstRow[col * 3 + 0] = CHAN_TO_UBYTE(src[RCOMP]);
+                  dstRow[col * 3 + 1] = CHAN_TO_UBYTE(src[GCOMP]);
+                  dstRow[col * 3 + 2] = CHAN_TO_UBYTE(src[BCOMP]);
+                  srcUB += 3;
+               }
+            }
+            else {
+               for (col = 0; col < srcWidth; col++) {
+                  dstRow[col * 3 + 0] = srcUB[BCOMP];
+                  dstRow[col * 3 + 1] = srcUB[GCOMP];
+                  dstRow[col * 3 + 2] = srcUB[RCOMP];
+                  srcUB += 3;
+               }
+            }
+#else
+            for (col = 0; col < srcWidth; col++) {
+               dstRow[col * 3 + 0] = CHAN_TO_UBYTE(src[BCOMP]);
+               dstRow[col * 3 + 1] = CHAN_TO_UBYTE(src[GCOMP]);
+               dstRow[col * 3 + 2] = CHAN_TO_UBYTE(src[RCOMP]);
+               src += 3;
+            }
+#endif
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+static GLboolean
+_mesa_texstore_bgr888(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_BGR888);
+   ASSERT(texelBytes == 3);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == GL_RGB &&
+       srcFormat == GL_RGB &&
+       srcType == GL_UNSIGNED_BYTE &&
+       littleEndian) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+            !srcPacking->SwapBytes &&
+            srcFormat == GL_RGBA &&
+            srcType == GL_UNSIGNED_BYTE) {
+      /* extract BGR from RGBA */
+      int img, row, col;
+      for (img = 0; img < srcDepth; img++) {
+         const GLint srcRowStride =
+            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
+         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,
+                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            for (col = 0; col < srcWidth; col++) {
+               dstRow[col * 3 + 0] = srcRow[col * 4 + RCOMP];
+               dstRow[col * 3 + 1] = srcRow[col * 4 + GCOMP];
+               dstRow[col * 3 + 2] = srcRow[col * 4 + BCOMP];
+            }
+            dstRow += dstRowStride;
+            srcRow += srcRowStride;
+         }
+      }
+   }
+   else if (!ctx->_ImageTransferState &&
+	    srcType == GL_UNSIGNED_BYTE &&
+	    can_swizzle(baseInternalFormat) &&
+	    can_swizzle(srcFormat)) {
+
+      GLubyte dstmap[4];
+
+      /* dstmap - how to swizzle from RGBA to dst format:
+       */
+      dstmap[0] = 0;
+      dstmap[1] = 1;
+      dstmap[2] = 2;
+      dstmap[3] = ONE;		/* ? */
+      
+      _mesa_swizzle_ubyte_image(ctx, dims,
+				srcFormat,
+				srcType,
+				baseInternalFormat,
+				dstmap, 3,
+				dstAddr, dstXoffset, dstYoffset, dstZoffset,
+				dstRowStride, dstImageOffsets,
+				srcWidth, srcHeight, srcDepth, srcAddr,
+				srcPacking);      
+   }   
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = (const GLchan *) tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            for (col = 0; col < srcWidth; col++) {
+               dstRow[col * 3 + 0] = CHAN_TO_UBYTE(src[RCOMP]);
+               dstRow[col * 3 + 1] = CHAN_TO_UBYTE(src[GCOMP]);
+               dstRow[col * 3 + 2] = CHAN_TO_UBYTE(src[BCOMP]);
+               src += 3;
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+static GLboolean
+_mesa_texstore_argb4444(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_ARGB4444 ||
+          dstFormat == MESA_FORMAT_ARGB4444_REV);
+   ASSERT(texelBytes == 2);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == MESA_FORMAT_ARGB4444 &&
+       baseInternalFormat == GL_RGBA &&
+       srcFormat == GL_BGRA &&
+       srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLushort *dstUS = (GLushort *) dstRow;
+            if (dstFormat == MESA_FORMAT_ARGB4444) {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUS[col] = PACK_COLOR_4444( CHAN_TO_UBYTE(src[ACOMP]),
+                                                CHAN_TO_UBYTE(src[RCOMP]),
+                                                CHAN_TO_UBYTE(src[GCOMP]),
+                                                CHAN_TO_UBYTE(src[BCOMP]) );
+                  src += 4;
+               }
+            }
+            else {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUS[col] = PACK_COLOR_4444_REV( CHAN_TO_UBYTE(src[ACOMP]),
+                                                    CHAN_TO_UBYTE(src[RCOMP]),
+                                                    CHAN_TO_UBYTE(src[GCOMP]),
+                                                    CHAN_TO_UBYTE(src[BCOMP]) );
+                  src += 4;
+               }
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+static GLboolean
+_mesa_texstore_rgba5551(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA5551);
+   ASSERT(texelBytes == 2);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == MESA_FORMAT_RGBA5551 &&
+       baseInternalFormat == GL_RGBA &&
+       srcFormat == GL_RGBA &&
+       srcType == GL_UNSIGNED_SHORT_5_5_5_1) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src =tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLushort *dstUS = (GLushort *) dstRow;
+	    for (col = 0; col < srcWidth; col++) {
+	       dstUS[col] = PACK_COLOR_5551( CHAN_TO_UBYTE(src[RCOMP]),
+					     CHAN_TO_UBYTE(src[GCOMP]),
+					     CHAN_TO_UBYTE(src[BCOMP]),
+					     CHAN_TO_UBYTE(src[ACOMP]) );
+	      src += 4;
+	    }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+static GLboolean
+_mesa_texstore_argb1555(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_ARGB1555 ||
+          dstFormat == MESA_FORMAT_ARGB1555_REV);
+   ASSERT(texelBytes == 2);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == MESA_FORMAT_ARGB1555 &&
+       baseInternalFormat == GL_RGBA &&
+       srcFormat == GL_BGRA &&
+       srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src =tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLushort *dstUS = (GLushort *) dstRow;
+            if (dstFormat == MESA_FORMAT_ARGB1555) {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUS[col] = PACK_COLOR_1555( CHAN_TO_UBYTE(src[ACOMP]),
+                                                CHAN_TO_UBYTE(src[RCOMP]),
+                                                CHAN_TO_UBYTE(src[GCOMP]),
+                                                CHAN_TO_UBYTE(src[BCOMP]) );
+                  src += 4;
+               }
+            }
+            else {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUS[col] = PACK_COLOR_1555_REV( CHAN_TO_UBYTE(src[ACOMP]),
+                                                    CHAN_TO_UBYTE(src[RCOMP]),
+                                                    CHAN_TO_UBYTE(src[GCOMP]),
+                                                    CHAN_TO_UBYTE(src[BCOMP]) );
+                  src += 4;
+               }
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+static GLboolean
+_mesa_texstore_argb2101010(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_ARGB2101010);
+   ASSERT(texelBytes == 4);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == MESA_FORMAT_ARGB2101010 &&
+       srcFormat == GL_BGRA &&
+       srcType == GL_UNSIGNED_INT_2_10_10_10_REV &&
+       baseInternalFormat == GL_RGBA) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         if (baseInternalFormat == GL_RGBA) {
+            for (row = 0; row < srcHeight; row++) {
+               GLuint *dstUI = (GLuint *) dstRow;
+               for (col = 0; col < srcWidth; col++) {
+                  GLushort a,r,g,b;
+
+                  UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
+                  UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
+                  UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
+                  UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
+                  dstUI[col] = PACK_COLOR_2101010_US(a, r, g, b);
+                  src += 4;
+               }
+               dstRow += dstRowStride;
+            }
+         } else if (baseInternalFormat == GL_RGB) {
+            for (row = 0; row < srcHeight; row++) {
+               GLuint *dstUI = (GLuint *) dstRow;
+               for (col = 0; col < srcWidth; col++) {
+                  GLushort r,g,b;
+
+                  UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
+                  UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
+                  UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
+                  dstUI[col] = PACK_COLOR_2101010_US(0xffff, r, g, b);
+                  src += 4;
+               }
+               dstRow += dstRowStride;
+            }
+         } else {
+            ASSERT(0);
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Do texstore for 2-channel, 4-bit/channel, unsigned normalized formats.
+ */
+static GLboolean
+_mesa_texstore_unorm44(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_AL44);
+   ASSERT(texelBytes == 1);
+
+   {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLubyte *dstUS = (GLubyte *) dstRow;
+            for (col = 0; col < srcWidth; col++) {
+               /* src[0] is luminance, src[1] is alpha */
+               dstUS[col] = PACK_COLOR_44( CHAN_TO_UBYTE(src[1]),
+                                           CHAN_TO_UBYTE(src[0]) );
+               src += 2;
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Do texstore for 2-channel, 8-bit/channel, unsigned normalized formats.
+ */
+static GLboolean
+_mesa_texstore_unorm88(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_AL88 ||
+          dstFormat == MESA_FORMAT_AL88_REV ||
+          dstFormat == MESA_FORMAT_RG88 ||
+          dstFormat == MESA_FORMAT_RG88_REV);
+   ASSERT(texelBytes == 2);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       (dstFormat == MESA_FORMAT_AL88 || dstFormat == MESA_FORMAT_RG88) &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_UNSIGNED_BYTE &&
+       littleEndian) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+	    littleEndian &&
+	    srcType == GL_UNSIGNED_BYTE &&
+	    can_swizzle(baseInternalFormat) &&
+	    can_swizzle(srcFormat)) {
+      GLubyte dstmap[4];
+
+      /* dstmap - how to swizzle from RGBA to dst format:
+       */
+      if (dstFormat == MESA_FORMAT_AL88 || dstFormat == MESA_FORMAT_AL88_REV) {
+	 if ((littleEndian && dstFormat == MESA_FORMAT_AL88) ||
+	     (!littleEndian && dstFormat == MESA_FORMAT_AL88_REV)) {
+	    dstmap[0] = 0;
+	    dstmap[1] = 3;
+	 }
+	 else {
+	    dstmap[0] = 3;
+	    dstmap[1] = 0;
+	 }
+      }
+      else {
+	 if ((littleEndian && dstFormat == MESA_FORMAT_RG88) ||
+	     (!littleEndian && dstFormat == MESA_FORMAT_RG88_REV)) {
+	    dstmap[0] = 0;
+	    dstmap[1] = 1;
+	 }
+	 else {
+	    dstmap[0] = 1;
+	    dstmap[1] = 0;
+	 }
+      }
+      dstmap[2] = ZERO;		/* ? */
+      dstmap[3] = ONE;		/* ? */
+      
+      _mesa_swizzle_ubyte_image(ctx, dims,
+				srcFormat,
+				srcType,
+				baseInternalFormat,
+				dstmap, 2,
+				dstAddr, dstXoffset, dstYoffset, dstZoffset,
+				dstRowStride, dstImageOffsets,
+				srcWidth, srcHeight, srcDepth, srcAddr,
+				srcPacking);      
+   }   
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLushort *dstUS = (GLushort *) dstRow;
+            if (dstFormat == MESA_FORMAT_AL88 ||
+		dstFormat == MESA_FORMAT_RG88) {
+               for (col = 0; col < srcWidth; col++) {
+                  /* src[0] is luminance, src[1] is alpha */
+                 dstUS[col] = PACK_COLOR_88( CHAN_TO_UBYTE(src[1]),
+                                             CHAN_TO_UBYTE(src[0]) );
+                 src += 2;
+               }
+            }
+            else {
+               for (col = 0; col < srcWidth; col++) {
+                  /* src[0] is luminance, src[1] is alpha */
+                 dstUS[col] = PACK_COLOR_88_REV( CHAN_TO_UBYTE(src[1]),
+                                                 CHAN_TO_UBYTE(src[0]) );
+                 src += 2;
+               }
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Do texstore for 2-channel, 16-bit/channel, unsigned normalized formats.
+ */
+static GLboolean
+_mesa_texstore_unorm1616(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_AL1616 ||
+          dstFormat == MESA_FORMAT_AL1616_REV ||
+	  dstFormat == MESA_FORMAT_RG1616 ||
+          dstFormat == MESA_FORMAT_RG1616_REV);
+   ASSERT(texelBytes == 4);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       (dstFormat == MESA_FORMAT_AL1616 || dstFormat == MESA_FORMAT_RG1616) &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_UNSIGNED_SHORT &&
+       littleEndian) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLuint *dstUI = (GLuint *) dstRow;
+            if (dstFormat == MESA_FORMAT_AL1616 ||
+		dstFormat == MESA_FORMAT_RG1616) {
+               for (col = 0; col < srcWidth; col++) {
+		  GLushort l, a;
+
+		  UNCLAMPED_FLOAT_TO_USHORT(l, src[0]);
+		  UNCLAMPED_FLOAT_TO_USHORT(a, src[1]);
+		  dstUI[col] = PACK_COLOR_1616(a, l);
+		  src += 2;
+               }
+            }
+            else {
+               for (col = 0; col < srcWidth; col++) {
+		  GLushort l, a;
+
+		  UNCLAMPED_FLOAT_TO_USHORT(l, src[0]);
+		  UNCLAMPED_FLOAT_TO_USHORT(a, src[1]);
+		  dstUI[col] = PACK_COLOR_1616_REV(a, l);
+		  src += 2;
+               }
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/* Texstore for R16, A16, L16, I16. */
+static GLboolean
+_mesa_texstore_unorm16(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_R16 ||
+          dstFormat == MESA_FORMAT_A16 ||
+          dstFormat == MESA_FORMAT_L16 ||
+          dstFormat == MESA_FORMAT_I16);
+   ASSERT(texelBytes == 2);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_UNSIGNED_SHORT &&
+       littleEndian) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLushort *dstUS = (GLushort *) dstRow;
+	    for (col = 0; col < srcWidth; col++) {
+	       GLushort r;
+
+	       UNCLAMPED_FLOAT_TO_USHORT(r, src[0]);
+	       dstUS[col] = r;
+	       src += 1;
+	    }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+static GLboolean
+_mesa_texstore_rgba_16(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA_16);
+   ASSERT(texelBytes == 8);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == GL_RGBA &&
+       srcFormat == GL_RGBA &&
+       srcType == GL_UNSIGNED_SHORT) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLushort *dstUS = (GLushort *) dstRow;
+            for (col = 0; col < srcWidth; col++) {
+               GLushort r, g, b, a;
+
+               UNCLAMPED_FLOAT_TO_USHORT(r, src[0]);
+               UNCLAMPED_FLOAT_TO_USHORT(g, src[1]);
+               UNCLAMPED_FLOAT_TO_USHORT(b, src[2]);
+               UNCLAMPED_FLOAT_TO_USHORT(a, src[3]);
+               dstUS[col*4+0] = r;
+               dstUS[col*4+1] = g;
+               dstUS[col*4+2] = b;
+               dstUS[col*4+3] = a;
+               src += 4;
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+static GLboolean
+_mesa_texstore_signed_rgba_16(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RGB_16 ||
+          dstFormat == MESA_FORMAT_SIGNED_RGBA_16);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == GL_RGBA &&
+       dstFormat == MESA_FORMAT_SIGNED_RGBA_16 &&
+       srcFormat == GL_RGBA &&
+       srcType == GL_SHORT) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      const GLuint comps = _mesa_get_format_bytes(dstFormat) / 2;
+      GLint img, row, col;
+
+      if (!tempImage)
+         return GL_FALSE;
+
+      /* Note: tempImage is always float[4] / RGBA.  We convert to 1, 2,
+       * 3 or 4 components/pixel here.
+       */
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLshort *dstRowS = (GLshort *) dstRow;
+            if (dstFormat == MESA_FORMAT_SIGNED_RGBA_16) {
+               for (col = 0; col < srcWidth; col++) {
+                  GLuint c;
+                  for (c = 0; c < comps; c++) {
+                     GLshort p;
+                     UNCLAMPED_FLOAT_TO_SHORT(p, src[col * 4 + c]);
+                     dstRowS[col * comps + c] = p;
+                  }
+               }
+               dstRow += dstRowStride;
+               src += 4 * srcWidth;
+            } else {
+               for (col = 0; col < srcWidth; col++) {
+                  GLuint c;
+                  for (c = 0; c < comps; c++) {
+                     GLshort p;
+                     UNCLAMPED_FLOAT_TO_SHORT(p, src[col * 3 + c]);
+                     dstRowS[col * comps + c] = p;
+                  }
+               }
+               dstRow += dstRowStride;
+               src += 3 * srcWidth;
+            }
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+static GLboolean
+_mesa_texstore_rgb332(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGB332);
+   ASSERT(texelBytes == 1);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == GL_RGB &&
+       srcFormat == GL_RGB && srcType == GL_UNSIGNED_BYTE_3_3_2) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            for (col = 0; col < srcWidth; col++) {
+               dstRow[col] = PACK_COLOR_332( CHAN_TO_UBYTE(src[RCOMP]),
+                                             CHAN_TO_UBYTE(src[GCOMP]),
+                                             CHAN_TO_UBYTE(src[BCOMP]) );
+               src += 3;
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Texstore for _mesa_texformat_a8, _mesa_texformat_l8, _mesa_texformat_i8.
+ */
+static GLboolean
+_mesa_texstore_unorm8(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_A8 ||
+          dstFormat == MESA_FORMAT_L8 ||
+          dstFormat == MESA_FORMAT_I8 ||
+          dstFormat == MESA_FORMAT_R8);
+   ASSERT(texelBytes == 1);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_UNSIGNED_BYTE) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+	    srcType == GL_UNSIGNED_BYTE &&
+	    can_swizzle(baseInternalFormat) &&
+	    can_swizzle(srcFormat)) {
+      GLubyte dstmap[4];
+
+      /* dstmap - how to swizzle from RGBA to dst format:
+       */
+      if (dstFormat == MESA_FORMAT_A8) {
+	 dstmap[0] = 3;
+      }
+      else {
+	 dstmap[0] = 0;
+      }
+      dstmap[1] = ZERO;		/* ? */
+      dstmap[2] = ZERO;		/* ? */
+      dstmap[3] = ONE;		/* ? */
+      
+      _mesa_swizzle_ubyte_image(ctx, dims,
+				srcFormat,
+				srcType,
+				baseInternalFormat,
+				dstmap, 1,
+				dstAddr, dstXoffset, dstYoffset, dstZoffset,
+				dstRowStride, dstImageOffsets,
+				srcWidth, srcHeight, srcDepth, srcAddr,
+				srcPacking);      
+   }   
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            for (col = 0; col < srcWidth; col++) {
+               dstRow[col] = CHAN_TO_UBYTE(src[col]);
+            }
+            dstRow += dstRowStride;
+            src += srcWidth;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+
+static GLboolean
+_mesa_texstore_ci8(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+
+   (void) dims; (void) baseInternalFormat;
+   ASSERT(dstFormat == MESA_FORMAT_CI8);
+   ASSERT(texelBytes == 1);
+   ASSERT(baseInternalFormat == GL_COLOR_INDEX);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       srcFormat == GL_COLOR_INDEX &&
+       srcType == GL_UNSIGNED_BYTE) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      GLint img, row;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            const GLvoid *src = _mesa_image_address(dims, srcPacking,
+                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
+            _mesa_unpack_index_span(ctx, srcWidth, GL_UNSIGNED_BYTE, dstRow,
+                                    srcType, src, srcPacking,
+                                    ctx->_ImageTransferState);
+            dstRow += dstRowStride;
+         }
+      }
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Texstore for _mesa_texformat_ycbcr or _mesa_texformat_ycbcr_REV.
+ */
+static GLboolean
+_mesa_texstore_ycbcr(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+
+   (void) ctx; (void) dims; (void) baseInternalFormat;
+
+   ASSERT((dstFormat == MESA_FORMAT_YCBCR) ||
+          (dstFormat == MESA_FORMAT_YCBCR_REV));
+   ASSERT(texelBytes == 2);
+   ASSERT(ctx->Extensions.MESA_ycbcr_texture);
+   ASSERT(srcFormat == GL_YCBCR_MESA);
+   ASSERT((srcType == GL_UNSIGNED_SHORT_8_8_MESA) ||
+          (srcType == GL_UNSIGNED_SHORT_8_8_REV_MESA));
+   ASSERT(baseInternalFormat == GL_YCBCR_MESA);
+
+   /* always just memcpy since no pixel transfer ops apply */
+   memcpy_texture(ctx, dims,
+                  dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                  dstRowStride,
+                  dstImageOffsets,
+                  srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                  srcAddr, srcPacking);
+
+   /* Check if we need byte swapping */
+   /* XXX the logic here _might_ be wrong */
+   if (srcPacking->SwapBytes ^
+       (srcType == GL_UNSIGNED_SHORT_8_8_REV_MESA) ^
+       (dstFormat == MESA_FORMAT_YCBCR_REV) ^
+       !littleEndian) {
+      GLint img, row;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            _mesa_swap2((GLushort *) dstRow, srcWidth);
+            dstRow += dstRowStride;
+         }
+      }
+   }
+   return GL_TRUE;
+}
+
+static GLboolean
+_mesa_texstore_dudv8(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_DUDV8);
+   ASSERT(texelBytes == 2);
+   ASSERT(ctx->Extensions.ATI_envmap_bumpmap);
+   ASSERT((srcFormat == GL_DU8DV8_ATI) ||
+	  (srcFormat == GL_DUDV_ATI));
+   ASSERT(baseInternalFormat == GL_DUDV_ATI);
+
+   if (!srcPacking->SwapBytes && srcType == GL_BYTE &&
+       littleEndian) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (srcType == GL_BYTE) {
+      GLubyte dstmap[4];
+
+      /* dstmap - how to swizzle from RGBA to dst format:
+       */
+      if (littleEndian) {
+	 dstmap[0] = 0;
+	 dstmap[1] = 3;
+      }
+      else {
+	 dstmap[0] = 3;
+	 dstmap[1] = 0;
+      }
+      dstmap[2] = ZERO;		/* ? */
+      dstmap[3] = ONE;		/* ? */
+      
+      _mesa_swizzle_ubyte_image(ctx, dims,
+				GL_LUMINANCE_ALPHA, /* hack */
+				GL_UNSIGNED_BYTE, /* hack */
+				GL_LUMINANCE_ALPHA, /* hack */
+				dstmap, 2,
+				dstAddr, dstXoffset, dstYoffset, dstZoffset,
+				dstRowStride, dstImageOffsets,
+				srcWidth, srcHeight, srcDepth, srcAddr,
+				srcPacking);      
+   }   
+   else {
+      /* general path - note this is defined for 2d textures only */
+      const GLint components = _mesa_components_in_format(baseInternalFormat);
+      const GLint srcStride = _mesa_image_row_stride(srcPacking, srcWidth,
+                                                     srcFormat, srcType);
+      GLbyte *tempImage, *dst, *src;
+      GLint row;
+
+      tempImage = (GLbyte *) malloc(srcWidth * srcHeight * srcDepth
+                                          * components * sizeof(GLbyte));
+      if (!tempImage)
+         return GL_FALSE;
+
+      src = (GLbyte *) _mesa_image_address(dims, srcPacking, srcAddr,
+                                           srcWidth, srcHeight,
+                                           srcFormat, srcType,
+                                           0, 0, 0);
+
+      dst = tempImage;
+      for (row = 0; row < srcHeight; row++) {
+         _mesa_unpack_dudv_span_byte(ctx, srcWidth, baseInternalFormat,
+                                     dst, srcFormat, srcType, src,
+                                     srcPacking, 0);
+         dst += srcWidth * components;
+         src += srcStride;
+      }
+ 
+      src = tempImage;
+      dst = (GLbyte *) dstAddr
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+      for (row = 0; row < srcHeight; row++) {
+         memcpy(dst, src, srcWidth * texelBytes);
+         dst += dstRowStride;
+         src += srcWidth * texelBytes;
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store a texture in a signed normalized 8-bit format.
+ */
+static GLboolean
+_mesa_texstore_snorm8(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_A8 ||
+          dstFormat == MESA_FORMAT_SIGNED_L8 ||
+          dstFormat == MESA_FORMAT_SIGNED_I8 ||
+          dstFormat == MESA_FORMAT_SIGNED_R8);
+   ASSERT(texelBytes == 1);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_BYTE) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLbyte *dstRow = (GLbyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            for (col = 0; col < srcWidth; col++) {
+               dstRow[col] = FLOAT_TO_BYTE_TEX(src[col]);
+            }
+            dstRow += dstRowStride;
+            src += srcWidth;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store a texture in a signed normalized two-channel 16-bit format.
+ */
+static GLboolean
+_mesa_texstore_snorm88(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_AL88 ||
+          dstFormat == MESA_FORMAT_SIGNED_RG88_REV);
+   ASSERT(texelBytes == 2);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_BYTE &&
+       littleEndian) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLbyte *dstRow = (GLbyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLbyte *dst = dstRow;
+            for (col = 0; col < srcWidth; col++) {
+               dst[0] = FLOAT_TO_BYTE_TEX(src[0]);
+               dst[1] = FLOAT_TO_BYTE_TEX(src[1]);
+               src += 2;
+               dst += 2;
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+/* Texstore for signed R16, A16, L16, I16. */
+static GLboolean
+_mesa_texstore_snorm16(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_R16 ||
+          dstFormat == MESA_FORMAT_SIGNED_A16 ||
+          dstFormat == MESA_FORMAT_SIGNED_L16 ||
+          dstFormat == MESA_FORMAT_SIGNED_I16);
+   ASSERT(texelBytes == 2);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_SHORT &&
+       littleEndian) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLshort *dstUS = (GLshort *) dstRow;
+	    for (col = 0; col < srcWidth; col++) {
+	       GLushort r;
+
+	       UNCLAMPED_FLOAT_TO_SHORT(r, src[0]);
+	       dstUS[col] = r;
+	       src += 1;
+	    }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+/**
+ * Do texstore for 2-channel, 16-bit/channel, signed normalized formats.
+ */
+static GLboolean
+_mesa_texstore_snorm1616(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_AL1616 ||
+          dstFormat == MESA_FORMAT_SIGNED_GR1616);
+   ASSERT(texelBytes == 4);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_SHORT &&
+       littleEndian) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLshort *dst = (GLshort *) dstRow;
+            for (col = 0; col < srcWidth; col++) {
+               GLushort l, a;
+
+               UNCLAMPED_FLOAT_TO_SHORT(l, src[0]);
+               UNCLAMPED_FLOAT_TO_SHORT(a, src[1]);
+               dst[0] = l;
+               dst[1] = a;
+               src += 2;
+               dst += 2;
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+/**
+ * Store a texture in MESA_FORMAT_SIGNED_RGBX8888.
+ */
+static GLboolean
+_mesa_texstore_signed_rgbx8888(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RGBX8888);
+   ASSERT(texelBytes == 4);
+
+   {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *srcRow = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLbyte *dstRow = (GLbyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLbyte *dst = dstRow;
+            for (col = 0; col < srcWidth; col++) {
+               dst[3] = FLOAT_TO_BYTE_TEX(srcRow[RCOMP]);
+               dst[2] = FLOAT_TO_BYTE_TEX(srcRow[GCOMP]);
+               dst[1] = FLOAT_TO_BYTE_TEX(srcRow[BCOMP]);
+               dst[0] = 0xff;
+               srcRow += 3;
+               dst += 4;
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+
+/**
+ * Store a texture in MESA_FORMAT_SIGNED_RGBA8888 or
+ * MESA_FORMAT_SIGNED_RGBA8888_REV
+ */
+static GLboolean
+_mesa_texstore_signed_rgba8888(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RGBA8888 ||
+          dstFormat == MESA_FORMAT_SIGNED_RGBA8888_REV);
+   ASSERT(texelBytes == 4);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == MESA_FORMAT_SIGNED_RGBA8888 &&
+       baseInternalFormat == GL_RGBA &&
+      ((srcFormat == GL_RGBA && srcType == GL_BYTE && !littleEndian) ||
+       (srcFormat == GL_ABGR_EXT && srcType == GL_BYTE && littleEndian))) {
+       /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == MESA_FORMAT_SIGNED_RGBA8888_REV &&
+       baseInternalFormat == GL_RGBA &&
+      ((srcFormat == GL_RGBA && srcType == GL_BYTE && littleEndian) ||
+       (srcFormat == GL_ABGR_EXT && srcType == GL_BYTE && !littleEndian))) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *srcRow = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLbyte *dstRow = (GLbyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLbyte *dst = dstRow;
+            if (dstFormat == MESA_FORMAT_SIGNED_RGBA8888) {
+               for (col = 0; col < srcWidth; col++) {
+                  dst[3] = FLOAT_TO_BYTE_TEX(srcRow[RCOMP]);
+                  dst[2] = FLOAT_TO_BYTE_TEX(srcRow[GCOMP]);
+                  dst[1] = FLOAT_TO_BYTE_TEX(srcRow[BCOMP]);
+                  dst[0] = FLOAT_TO_BYTE_TEX(srcRow[ACOMP]);
+                  srcRow += 4;
+                  dst += 4;
+               }
+            }
+            else {
+               for (col = 0; col < srcWidth; col++) {
+                  dst[0] = FLOAT_TO_BYTE_TEX(srcRow[RCOMP]);
+                  dst[1] = FLOAT_TO_BYTE_TEX(srcRow[GCOMP]);
+                  dst[2] = FLOAT_TO_BYTE_TEX(srcRow[BCOMP]);
+                  dst[3] = FLOAT_TO_BYTE_TEX(srcRow[ACOMP]);
+                  srcRow += 4;
+                  dst += 4;
+               }
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store a combined depth/stencil texture image.
+ */
+static GLboolean
+_mesa_texstore_z24_s8(TEXSTORE_PARAMS)
+{
+   const GLuint depthScale = 0xffffff;
+   const GLint srcRowStride
+      = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)
+      / sizeof(GLuint);
+   GLint img, row;
+
+   ASSERT(dstFormat == MESA_FORMAT_Z24_S8);
+   ASSERT(srcFormat == GL_DEPTH_STENCIL_EXT || srcFormat == GL_DEPTH_COMPONENT);
+   ASSERT(srcFormat != GL_DEPTH_STENCIL_EXT || srcType == GL_UNSIGNED_INT_24_8_EXT);
+
+   if (srcFormat != GL_DEPTH_COMPONENT && ctx->Pixel.DepthScale == 1.0f &&
+       ctx->Pixel.DepthBias == 0.0f &&
+       !srcPacking->SwapBytes) {
+      /* simple path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (srcFormat == GL_DEPTH_COMPONENT) {
+      /* In case we only upload depth we need to preserve the stencil */
+      for (img = 0; img < srcDepth; img++) {
+	 GLuint *dstRow = (GLuint *) dstAddr
+            + dstImageOffsets[dstZoffset + img]
+            + dstYoffset * dstRowStride / sizeof(GLuint)
+            + dstXoffset;
+         const GLuint *src
+            = (const GLuint *) _mesa_image_address(dims, srcPacking, srcAddr,
+                  srcWidth, srcHeight,
+                  srcFormat, srcType,
+                  img, 0, 0);
+         for (row = 0; row < srcHeight; row++) {
+            GLuint depth[MAX_WIDTH];
+	    GLubyte stencil[MAX_WIDTH];
+            GLint i;
+	    GLboolean keepdepth = GL_FALSE, keepstencil = GL_FALSE;
+
+	    if (srcFormat == GL_DEPTH_COMPONENT) { /* preserve stencil */
+	       keepstencil = GL_TRUE;
+	    }
+            else if (srcFormat == GL_STENCIL_INDEX) { /* preserve depth */
+	       keepdepth = GL_TRUE;
+	    }
+
+	    if (keepdepth == GL_FALSE)
+	       /* the 24 depth bits will be in the low position: */
+	       _mesa_unpack_depth_span(ctx, srcWidth,
+				       GL_UNSIGNED_INT, /* dst type */
+				       keepstencil ? depth : dstRow, /* dst addr */
+				       depthScale,
+				       srcType, src, srcPacking);
+
+	    if (keepstencil == GL_FALSE)
+	       /* get the 8-bit stencil values */
+	       _mesa_unpack_stencil_span(ctx, srcWidth,
+					 GL_UNSIGNED_BYTE, /* dst type */
+					 stencil, /* dst addr */
+					 srcType, src, srcPacking,
+					 ctx->_ImageTransferState);
+
+	    for (i = 0; i < srcWidth; i++) {
+	       if (keepstencil)
+		  dstRow[i] = depth[i] << 8 | (dstRow[i] & 0x000000FF);
+	       else
+		  dstRow[i] = (dstRow[i] & 0xFFFFFF00) | (stencil[i] & 0xFF);
+	    }
+
+            src += srcRowStride;
+            dstRow += dstRowStride / sizeof(GLuint);
+         }
+      }
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store a combined depth/stencil texture image.
+ */
+static GLboolean
+_mesa_texstore_s8_z24(TEXSTORE_PARAMS)
+{
+   const GLuint depthScale = 0xffffff;
+   const GLint srcRowStride
+      = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)
+      / sizeof(GLuint);
+   GLint img, row;
+
+   ASSERT(dstFormat == MESA_FORMAT_S8_Z24);
+   ASSERT(srcFormat == GL_DEPTH_STENCIL_EXT ||
+          srcFormat == GL_DEPTH_COMPONENT ||
+          srcFormat == GL_STENCIL_INDEX);
+   ASSERT(srcFormat != GL_DEPTH_STENCIL_EXT ||
+          srcType == GL_UNSIGNED_INT_24_8_EXT);
+
+   for (img = 0; img < srcDepth; img++) {
+      GLuint *dstRow = (GLuint *) dstAddr
+	 + dstImageOffsets[dstZoffset + img]
+	 + dstYoffset * dstRowStride / sizeof(GLuint)
+	 + dstXoffset;
+      const GLuint *src
+	 = (const GLuint *) _mesa_image_address(dims, srcPacking, srcAddr,
+						srcWidth, srcHeight,
+						srcFormat, srcType,
+						img, 0, 0);
+      for (row = 0; row < srcHeight; row++) {
+	 GLuint depth[MAX_WIDTH];
+	 GLubyte stencil[MAX_WIDTH];
+	 GLint i;
+	 GLboolean keepdepth = GL_FALSE, keepstencil = GL_FALSE;
+	 
+	 if (srcFormat == GL_DEPTH_COMPONENT) { /* preserve stencil */
+	    keepstencil = GL_TRUE;
+	 }
+         else if (srcFormat == GL_STENCIL_INDEX) { /* preserve depth */
+	    keepdepth = GL_TRUE;
+	 }
+
+	 if (keepdepth == GL_FALSE)
+	    /* the 24 depth bits will be in the low position: */
+	    _mesa_unpack_depth_span(ctx, srcWidth,
+				    GL_UNSIGNED_INT, /* dst type */
+				    keepstencil ? depth : dstRow, /* dst addr */
+				    depthScale,
+				    srcType, src, srcPacking);	 
+
+	 if (keepstencil == GL_FALSE)
+	    /* get the 8-bit stencil values */
+	    _mesa_unpack_stencil_span(ctx, srcWidth,
+				      GL_UNSIGNED_BYTE, /* dst type */
+				      stencil, /* dst addr */
+				      srcType, src, srcPacking,
+				      ctx->_ImageTransferState);
+
+	 /* merge stencil values into depth values */
+	 for (i = 0; i < srcWidth; i++) {
+	    if (keepstencil)
+	       dstRow[i] = depth[i] | (dstRow[i] & 0xFF000000);
+	    else
+	       dstRow[i] = (dstRow[i] & 0xFFFFFF) | (stencil[i] << 24);
+
+	 }
+	 src += srcRowStride;
+	 dstRow += dstRowStride / sizeof(GLuint);
+      }
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store simple 8-bit/value stencil texture data.
+ */
+static GLboolean
+_mesa_texstore_s8(TEXSTORE_PARAMS)
+{
+   ASSERT(dstFormat == MESA_FORMAT_S8);
+   ASSERT(srcFormat == GL_STENCIL_INDEX);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_UNSIGNED_BYTE) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      const GLint srcRowStride
+	 = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)
+	 / sizeof(GLuint);
+      GLint img, row;
+      
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img]
+            + dstYoffset * dstRowStride / sizeof(GLuint)
+            + dstXoffset;
+         const GLuint *src
+            = (const GLuint *) _mesa_image_address(dims, srcPacking, srcAddr,
+                                                   srcWidth, srcHeight,
+                                                   srcFormat, srcType,
+                                                   img, 0, 0);
+         for (row = 0; row < srcHeight; row++) {
+            GLubyte stencil[MAX_WIDTH];
+            GLint i;
+
+            /* get the 8-bit stencil values */
+            _mesa_unpack_stencil_span(ctx, srcWidth,
+                                      GL_UNSIGNED_BYTE, /* dst type */
+                                      stencil, /* dst addr */
+                                      srcType, src, srcPacking,
+                                      ctx->_ImageTransferState);
+            /* merge stencil values into depth values */
+            for (i = 0; i < srcWidth; i++)
+               dstRow[i] = stencil[i];
+
+            src += srcRowStride;
+            dstRow += dstRowStride / sizeof(GLubyte);
+         }
+      }
+
+   }
+
+   return GL_TRUE;
+}
+
+
+/**
+ * Store an image in any of the formats:
+ *   _mesa_texformat_rgba_float32
+ *   _mesa_texformat_rgb_float32
+ *   _mesa_texformat_alpha_float32
+ *   _mesa_texformat_luminance_float32
+ *   _mesa_texformat_luminance_alpha_float32
+ *   _mesa_texformat_intensity_float32
+ */
+static GLboolean
+_mesa_texstore_rgba_float32(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+   const GLint components = _mesa_components_in_format(baseFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA_FLOAT32 ||
+          dstFormat == MESA_FORMAT_RGB_FLOAT32 ||
+          dstFormat == MESA_FORMAT_ALPHA_FLOAT32 ||
+          dstFormat == MESA_FORMAT_LUMINANCE_FLOAT32 ||
+          dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32 ||
+          dstFormat == MESA_FORMAT_INTENSITY_FLOAT32);
+   ASSERT(baseInternalFormat == GL_RGBA ||
+          baseInternalFormat == GL_RGB ||
+          baseInternalFormat == GL_ALPHA ||
+          baseInternalFormat == GL_LUMINANCE ||
+          baseInternalFormat == GL_LUMINANCE_ALPHA ||
+          baseInternalFormat == GL_INTENSITY);
+   ASSERT(texelBytes == components * sizeof(GLfloat));
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_FLOAT) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *srcRow = tempImage;
+      GLint bytesPerRow;
+      GLint img, row;
+      if (!tempImage)
+         return GL_FALSE;
+      bytesPerRow = srcWidth * components * sizeof(GLfloat);
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            memcpy(dstRow, srcRow, bytesPerRow);
+            dstRow += dstRowStride;
+            srcRow += srcWidth * components;
+         }
+      }
+
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+
+/**
+ * As above, but store 16-bit floats.
+ */
+static GLboolean
+_mesa_texstore_rgba_float16(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+   const GLint components = _mesa_components_in_format(baseFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA_FLOAT16 ||
+          dstFormat == MESA_FORMAT_RGB_FLOAT16 ||
+          dstFormat == MESA_FORMAT_ALPHA_FLOAT16 ||
+          dstFormat == MESA_FORMAT_LUMINANCE_FLOAT16 ||
+          dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16 ||
+          dstFormat == MESA_FORMAT_INTENSITY_FLOAT16);
+   ASSERT(baseInternalFormat == GL_RGBA ||
+          baseInternalFormat == GL_RGB ||
+          baseInternalFormat == GL_ALPHA ||
+          baseInternalFormat == GL_LUMINANCE ||
+          baseInternalFormat == GL_LUMINANCE_ALPHA ||
+          baseInternalFormat == GL_INTENSITY);
+   ASSERT(texelBytes == components * sizeof(GLhalfARB));
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_HALF_FLOAT_ARB) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      GLint img, row;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLhalfARB *dstTexel = (GLhalfARB *) dstRow;
+            GLint i;
+            for (i = 0; i < srcWidth * components; i++) {
+               dstTexel[i] = _mesa_float_to_half(src[i]);
+            }
+            dstRow += dstRowStride;
+            src += srcWidth * components;
+         }
+      }
+
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/* non-normalized, signed int8 */
+static GLboolean
+_mesa_texstore_rgba_int8(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+   const GLint components = _mesa_components_in_format(baseFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA_INT8);
+   ASSERT(baseInternalFormat == GL_RGBA ||
+          baseInternalFormat == GL_RGB ||
+          baseInternalFormat == GL_ALPHA ||
+          baseInternalFormat == GL_LUMINANCE ||
+          baseInternalFormat == GL_LUMINANCE_ALPHA ||
+          baseInternalFormat == GL_INTENSITY);
+   ASSERT(texelBytes == components * sizeof(GLbyte));
+
+   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
+    * to integer formats.
+    */
+   if (!srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_BYTE) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking, 0x0);
+      const GLfloat *src = tempImage;
+      GLint img, row;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLbyte *dstTexel = (GLbyte *) dstRow;
+            GLint i;
+            for (i = 0; i < srcWidth * components; i++) {
+               dstTexel[i] = (GLbyte) src[i];
+            }
+            dstRow += dstRowStride;
+            src += srcWidth * components;
+         }
+      }
+
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/* non-normalized, signed int16 */
+static GLboolean
+_mesa_texstore_rgba_int16(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+   const GLint components = _mesa_components_in_format(baseFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA_INT16);
+   ASSERT(baseInternalFormat == GL_RGBA ||
+          baseInternalFormat == GL_RGB ||
+          baseInternalFormat == GL_ALPHA ||
+          baseInternalFormat == GL_LUMINANCE ||
+          baseInternalFormat == GL_LUMINANCE_ALPHA ||
+          baseInternalFormat == GL_INTENSITY);
+   ASSERT(texelBytes == components * sizeof(GLshort));
+
+   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
+    * to integer formats.
+    */
+   if (!srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_SHORT) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking, 0x0);
+      const GLfloat *src = tempImage;
+      GLint img, row;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLshort *dstTexel = (GLshort *) dstRow;
+            GLint i;
+            for (i = 0; i < srcWidth * components; i++) {
+               dstTexel[i] = (GLint) src[i];
+            }
+            dstRow += dstRowStride;
+            src += srcWidth * components;
+         }
+      }
+
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/* non-normalized, signed int32 */
+static GLboolean
+_mesa_texstore_rgba_int32(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+   const GLint components = _mesa_components_in_format(baseFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA_INT32);
+   ASSERT(baseInternalFormat == GL_RGBA ||
+          baseInternalFormat == GL_RGB ||
+          baseInternalFormat == GL_ALPHA ||
+          baseInternalFormat == GL_LUMINANCE ||
+          baseInternalFormat == GL_LUMINANCE_ALPHA ||
+          baseInternalFormat == GL_INTENSITY);
+   ASSERT(texelBytes == components * sizeof(GLint));
+
+   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
+    * to integer formats.
+    */
+   if (!srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_INT) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking, 0x0);
+      const GLfloat *src = tempImage;
+      GLint img, row;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLint *dstTexel = (GLint *) dstRow;
+            GLint i;
+            for (i = 0; i < srcWidth * components; i++) {
+               dstTexel[i] = (GLint) src[i];
+            }
+            dstRow += dstRowStride;
+            src += srcWidth * components;
+         }
+      }
+
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/* non-normalized, unsigned int8 */
+static GLboolean
+_mesa_texstore_rgba_uint8(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+   const GLint components = _mesa_components_in_format(baseFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA_UINT8);
+   ASSERT(baseInternalFormat == GL_RGBA ||
+          baseInternalFormat == GL_RGB ||
+          baseInternalFormat == GL_ALPHA ||
+          baseInternalFormat == GL_LUMINANCE ||
+          baseInternalFormat == GL_LUMINANCE_ALPHA ||
+          baseInternalFormat == GL_INTENSITY);
+   ASSERT(texelBytes == components * sizeof(GLubyte));
+
+   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
+    * to integer formats.
+    */
+   if (!srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_UNSIGNED_BYTE) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLuint *tempImage =
+         make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,
+                              srcWidth, srcHeight, srcDepth,
+                              srcFormat, srcType, srcAddr, srcPacking);
+      const GLuint *src = tempImage;
+      GLint img, row;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLubyte *dstTexel = (GLubyte *) dstRow;
+            GLint i;
+            for (i = 0; i < srcWidth * components; i++) {
+               dstTexel[i] = (GLubyte) CLAMP(src[i], 0, 0xff);
+            }
+            dstRow += dstRowStride;
+            src += srcWidth * components;
+         }
+      }
+
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/* non-normalized, unsigned int16 */
+static GLboolean
+_mesa_texstore_rgba_uint16(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+   const GLint components = _mesa_components_in_format(baseFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA_UINT16);
+   ASSERT(baseInternalFormat == GL_RGBA ||
+          baseInternalFormat == GL_RGB ||
+          baseInternalFormat == GL_ALPHA ||
+          baseInternalFormat == GL_LUMINANCE ||
+          baseInternalFormat == GL_LUMINANCE_ALPHA ||
+          baseInternalFormat == GL_INTENSITY);
+   ASSERT(texelBytes == components * sizeof(GLushort));
+
+   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
+    * to integer formats.
+    */
+   if (!srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_UNSIGNED_SHORT) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLuint *tempImage =
+         make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,
+                              srcWidth, srcHeight, srcDepth,
+                              srcFormat, srcType, srcAddr, srcPacking);
+      const GLuint *src = tempImage;
+      GLint img, row;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLushort *dstTexel = (GLushort *) dstRow;
+            GLint i;
+            for (i = 0; i < srcWidth * components; i++) {
+               dstTexel[i] = (GLushort) CLAMP(src[i], 0, 0xffff);
+            }
+            dstRow += dstRowStride;
+            src += srcWidth * components;
+         }
+      }
+
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/* non-normalized, unsigned int32 */
+static GLboolean
+_mesa_texstore_rgba_uint32(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+   const GLint components = _mesa_components_in_format(baseFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA_UINT32);
+   ASSERT(baseInternalFormat == GL_RGBA ||
+          baseInternalFormat == GL_RGB ||
+          baseInternalFormat == GL_ALPHA ||
+          baseInternalFormat == GL_LUMINANCE ||
+          baseInternalFormat == GL_LUMINANCE_ALPHA ||
+          baseInternalFormat == GL_INTENSITY);
+   ASSERT(texelBytes == components * sizeof(GLuint));
+
+   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
+    * to integer formats.
+    */
+   if (!srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_UNSIGNED_INT) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLuint *tempImage =
+         make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,
+                              srcWidth, srcHeight, srcDepth,
+                              srcFormat, srcType, srcAddr, srcPacking);
+      const GLuint *src = tempImage;
+      GLint img, row;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLuint *dstTexel = (GLuint *) dstRow;
+            GLint i;
+            for (i = 0; i < srcWidth * components; i++) {
+               dstTexel[i] = src[i];
+            }
+            dstRow += dstRowStride;
+            src += srcWidth * components;
+         }
+      }
+
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+
+
+#if FEATURE_EXT_texture_sRGB
+static GLboolean
+_mesa_texstore_srgb8(TEXSTORE_PARAMS)
+{
+   gl_format newDstFormat;
+   GLboolean k;
+
+   ASSERT(dstFormat == MESA_FORMAT_SRGB8);
+
+   /* reuse normal rgb texstore code */
+   newDstFormat = MESA_FORMAT_RGB888;
+
+   k = _mesa_texstore_rgb888(ctx, dims, baseInternalFormat,
+                             newDstFormat, dstAddr,
+                             dstXoffset, dstYoffset, dstZoffset,
+                             dstRowStride, dstImageOffsets,
+                             srcWidth, srcHeight, srcDepth,
+                             srcFormat, srcType,
+                             srcAddr, srcPacking);
+   return k;
+}
+
+
+static GLboolean
+_mesa_texstore_srgba8(TEXSTORE_PARAMS)
+{
+   gl_format newDstFormat;
+   GLboolean k;
+
+   ASSERT(dstFormat == MESA_FORMAT_SRGBA8);
+
+   /* reuse normal rgba texstore code */
+   newDstFormat = MESA_FORMAT_RGBA8888;
+   k = _mesa_texstore_rgba8888(ctx, dims, baseInternalFormat,
+                               newDstFormat, dstAddr,
+                               dstXoffset, dstYoffset, dstZoffset,
+                               dstRowStride, dstImageOffsets,
+                               srcWidth, srcHeight, srcDepth,
+                               srcFormat, srcType,
+                               srcAddr, srcPacking);
+   return k;
+}
+
+
+static GLboolean
+_mesa_texstore_sargb8(TEXSTORE_PARAMS)
+{
+   gl_format newDstFormat;
+   GLboolean k;
+
+   ASSERT(dstFormat == MESA_FORMAT_SARGB8);
+
+   /* reuse normal rgba texstore code */
+   newDstFormat = MESA_FORMAT_ARGB8888;
+
+   k = _mesa_texstore_argb8888(ctx, dims, baseInternalFormat,
+                               newDstFormat, dstAddr,
+                               dstXoffset, dstYoffset, dstZoffset,
+                               dstRowStride, dstImageOffsets,
+                               srcWidth, srcHeight, srcDepth,
+                               srcFormat, srcType,
+                               srcAddr, srcPacking);
+   return k;
+}
+
+
+static GLboolean
+_mesa_texstore_sl8(TEXSTORE_PARAMS)
+{
+   gl_format newDstFormat;
+   GLboolean k;
+
+   ASSERT(dstFormat == MESA_FORMAT_SL8);
+
+   newDstFormat = MESA_FORMAT_L8;
+
+   /* _mesa_textore_a8 handles luminance8 too */
+   k = _mesa_texstore_unorm8(ctx, dims, baseInternalFormat,
+                         newDstFormat, dstAddr,
+                         dstXoffset, dstYoffset, dstZoffset,
+                         dstRowStride, dstImageOffsets,
+                         srcWidth, srcHeight, srcDepth,
+                         srcFormat, srcType,
+                         srcAddr, srcPacking);
+   return k;
+}
+
+
+static GLboolean
+_mesa_texstore_sla8(TEXSTORE_PARAMS)
+{
+   gl_format newDstFormat;
+   GLboolean k;
+
+   ASSERT(dstFormat == MESA_FORMAT_SLA8);
+
+   /* reuse normal luminance/alpha texstore code */
+   newDstFormat = MESA_FORMAT_AL88;
+
+   k = _mesa_texstore_unorm88(ctx, dims, baseInternalFormat,
+			      newDstFormat, dstAddr,
+			      dstXoffset, dstYoffset, dstZoffset,
+			      dstRowStride, dstImageOffsets,
+			      srcWidth, srcHeight, srcDepth,
+			      srcFormat, srcType,
+			      srcAddr, srcPacking);
+   return k;
+}
+
+#else
+
+/* these are used only in texstore_funcs[] below */
+#define _mesa_texstore_srgb8 NULL
+#define _mesa_texstore_srgba8 NULL
+#define _mesa_texstore_sargb8 NULL
+#define _mesa_texstore_sl8 NULL
+#define _mesa_texstore_sla8 NULL
+
+#endif /* FEATURE_EXT_texture_sRGB */
+
+
+
+
+/**
+ * Table mapping MESA_FORMAT_* to _mesa_texstore_*()
+ * XXX this is somewhat temporary.
+ */
+static const struct {
+   gl_format Name;
+   StoreTexImageFunc Store;
+}
+texstore_funcs[MESA_FORMAT_COUNT] =
+{
+   { MESA_FORMAT_NONE, NULL },
+   { MESA_FORMAT_RGBA8888, _mesa_texstore_rgba8888 },
+   { MESA_FORMAT_RGBA8888_REV, _mesa_texstore_rgba8888 },
+   { MESA_FORMAT_ARGB8888, _mesa_texstore_argb8888 },
+   { MESA_FORMAT_ARGB8888_REV, _mesa_texstore_argb8888 },
+   { MESA_FORMAT_XRGB8888, _mesa_texstore_argb8888 },
+   { MESA_FORMAT_XRGB8888_REV, _mesa_texstore_argb8888 },
+   { MESA_FORMAT_RGB888, _mesa_texstore_rgb888 },
+   { MESA_FORMAT_BGR888, _mesa_texstore_bgr888 },
+   { MESA_FORMAT_RGB565, _mesa_texstore_rgb565 },
+   { MESA_FORMAT_RGB565_REV, _mesa_texstore_rgb565 },
+   { MESA_FORMAT_ARGB4444, _mesa_texstore_argb4444 },
+   { MESA_FORMAT_ARGB4444_REV, _mesa_texstore_argb4444 },
+   { MESA_FORMAT_RGBA5551, _mesa_texstore_rgba5551 },
+   { MESA_FORMAT_ARGB1555, _mesa_texstore_argb1555 },
+   { MESA_FORMAT_ARGB1555_REV, _mesa_texstore_argb1555 },
+   { MESA_FORMAT_AL44, _mesa_texstore_unorm44 },
+   { MESA_FORMAT_AL88, _mesa_texstore_unorm88 },
+   { MESA_FORMAT_AL88_REV, _mesa_texstore_unorm88 },
+   { MESA_FORMAT_AL1616, _mesa_texstore_unorm1616 },
+   { MESA_FORMAT_AL1616_REV, _mesa_texstore_unorm1616 },
+   { MESA_FORMAT_RGB332, _mesa_texstore_rgb332 },
+   { MESA_FORMAT_A8, _mesa_texstore_unorm8 },
+   { MESA_FORMAT_A16, _mesa_texstore_unorm16 },
+   { MESA_FORMAT_L8, _mesa_texstore_unorm8 },
+   { MESA_FORMAT_L16, _mesa_texstore_unorm16 },
+   { MESA_FORMAT_I8, _mesa_texstore_unorm8 },
+   { MESA_FORMAT_I16, _mesa_texstore_unorm16 },
+   { MESA_FORMAT_CI8, _mesa_texstore_ci8 },
+   { MESA_FORMAT_YCBCR, _mesa_texstore_ycbcr },
+   { MESA_FORMAT_YCBCR_REV, _mesa_texstore_ycbcr },
+   { MESA_FORMAT_R8, _mesa_texstore_unorm8 },
+   { MESA_FORMAT_RG88, _mesa_texstore_unorm88 },
+   { MESA_FORMAT_RG88_REV, _mesa_texstore_unorm88 },
+   { MESA_FORMAT_R16, _mesa_texstore_unorm16 },
+   { MESA_FORMAT_RG1616, _mesa_texstore_unorm1616 },
+   { MESA_FORMAT_RG1616_REV, _mesa_texstore_unorm1616 },
+   { MESA_FORMAT_ARGB2101010, _mesa_texstore_argb2101010 },
+   { MESA_FORMAT_Z24_S8, _mesa_texstore_z24_s8 },
+   { MESA_FORMAT_S8_Z24, _mesa_texstore_s8_z24 },
+   { MESA_FORMAT_Z16, _mesa_texstore_z16 },
+   { MESA_FORMAT_X8_Z24, _mesa_texstore_x8_z24 },
+   { MESA_FORMAT_Z24_X8, _mesa_texstore_z24_x8 },
+   { MESA_FORMAT_Z32, _mesa_texstore_z32 },
+   { MESA_FORMAT_S8, _mesa_texstore_s8 },
+   { MESA_FORMAT_SRGB8, _mesa_texstore_srgb8 },
+   { MESA_FORMAT_SRGBA8, _mesa_texstore_srgba8 },
+   { MESA_FORMAT_SARGB8, _mesa_texstore_sargb8 },
+   { MESA_FORMAT_SL8, _mesa_texstore_sl8 },
+   { MESA_FORMAT_SLA8, _mesa_texstore_sla8 },
+   { MESA_FORMAT_SRGB_DXT1, _mesa_texstore_rgb_dxt1 },
+   { MESA_FORMAT_SRGBA_DXT1, _mesa_texstore_rgba_dxt1 },
+   { MESA_FORMAT_SRGBA_DXT3, _mesa_texstore_rgba_dxt3 },
+   { MESA_FORMAT_SRGBA_DXT5, _mesa_texstore_rgba_dxt5 },
+   { MESA_FORMAT_RGB_FXT1, _mesa_texstore_rgb_fxt1 },
+   { MESA_FORMAT_RGBA_FXT1, _mesa_texstore_rgba_fxt1 },
+   { MESA_FORMAT_RGB_DXT1, _mesa_texstore_rgb_dxt1 },
+   { MESA_FORMAT_RGBA_DXT1, _mesa_texstore_rgba_dxt1 },
+   { MESA_FORMAT_RGBA_DXT3, _mesa_texstore_rgba_dxt3 },
+   { MESA_FORMAT_RGBA_DXT5, _mesa_texstore_rgba_dxt5 },
+   { MESA_FORMAT_RGBA_FLOAT32, _mesa_texstore_rgba_float32 },
+   { MESA_FORMAT_RGBA_FLOAT16, _mesa_texstore_rgba_float16 },
+   { MESA_FORMAT_RGB_FLOAT32, _mesa_texstore_rgba_float32 },
+   { MESA_FORMAT_RGB_FLOAT16, _mesa_texstore_rgba_float16 },
+   { MESA_FORMAT_ALPHA_FLOAT32, _mesa_texstore_rgba_float32 },
+   { MESA_FORMAT_ALPHA_FLOAT16, _mesa_texstore_rgba_float16 },
+   { MESA_FORMAT_LUMINANCE_FLOAT32, _mesa_texstore_rgba_float32 },
+   { MESA_FORMAT_LUMINANCE_FLOAT16, _mesa_texstore_rgba_float16 },
+   { MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32, _mesa_texstore_rgba_float32 },
+   { MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16, _mesa_texstore_rgba_float16 },
+   { MESA_FORMAT_INTENSITY_FLOAT32, _mesa_texstore_rgba_float32 },
+   { MESA_FORMAT_INTENSITY_FLOAT16, _mesa_texstore_rgba_float16 },
+
+   { MESA_FORMAT_RGBA_INT8, _mesa_texstore_rgba_int8 },
+   { MESA_FORMAT_RGBA_INT16, _mesa_texstore_rgba_int16 },
+   { MESA_FORMAT_RGBA_INT32, _mesa_texstore_rgba_int32 },
+   { MESA_FORMAT_RGBA_UINT8, _mesa_texstore_rgba_uint8 },
+   { MESA_FORMAT_RGBA_UINT16, _mesa_texstore_rgba_uint16 },
+   { MESA_FORMAT_RGBA_UINT32, _mesa_texstore_rgba_uint32 },
+
+   { MESA_FORMAT_DUDV8, _mesa_texstore_dudv8 },
+
+   { MESA_FORMAT_SIGNED_R8, _mesa_texstore_snorm8 },
+   { MESA_FORMAT_SIGNED_RG88_REV, _mesa_texstore_snorm88 },
+   { MESA_FORMAT_SIGNED_RGBX8888, _mesa_texstore_signed_rgbx8888 },
+
+   { MESA_FORMAT_SIGNED_RGBA8888, _mesa_texstore_signed_rgba8888 },
+   { MESA_FORMAT_SIGNED_RGBA8888_REV, _mesa_texstore_signed_rgba8888 },
+
+   { MESA_FORMAT_SIGNED_R16, _mesa_texstore_snorm16 },
+   { MESA_FORMAT_SIGNED_GR1616, _mesa_texstore_snorm1616 },
+   { MESA_FORMAT_SIGNED_RGB_16, _mesa_texstore_signed_rgba_16 },
+   { MESA_FORMAT_SIGNED_RGBA_16, _mesa_texstore_signed_rgba_16 },
+   { MESA_FORMAT_RGBA_16, _mesa_texstore_rgba_16 },
+
+   { MESA_FORMAT_RED_RGTC1, _mesa_texstore_red_rgtc1 },
+   { MESA_FORMAT_SIGNED_RED_RGTC1, _mesa_texstore_signed_red_rgtc1 },
+   { MESA_FORMAT_RG_RGTC2, _mesa_texstore_rg_rgtc2 },
+   { MESA_FORMAT_SIGNED_RG_RGTC2, _mesa_texstore_signed_rg_rgtc2 },
+
+   /* Re-use the R/RG texstore functions.
+    * The code is generic enough to handle LATC too. */
+   { MESA_FORMAT_L_LATC1, _mesa_texstore_red_rgtc1 },
+   { MESA_FORMAT_SIGNED_L_LATC1, _mesa_texstore_signed_red_rgtc1 },
+   { MESA_FORMAT_LA_LATC2, _mesa_texstore_rg_rgtc2 },
+   { MESA_FORMAT_SIGNED_LA_LATC2, _mesa_texstore_signed_rg_rgtc2 },
+
+   { MESA_FORMAT_SIGNED_A8, _mesa_texstore_snorm8 },
+   { MESA_FORMAT_SIGNED_L8, _mesa_texstore_snorm8 },
+   { MESA_FORMAT_SIGNED_AL88, _mesa_texstore_snorm88 },
+   { MESA_FORMAT_SIGNED_I8, _mesa_texstore_snorm8 },
+
+   { MESA_FORMAT_SIGNED_A16, _mesa_texstore_snorm16 },
+   { MESA_FORMAT_SIGNED_L16, _mesa_texstore_snorm16 },
+   { MESA_FORMAT_SIGNED_AL1616, _mesa_texstore_snorm1616 },
+   { MESA_FORMAT_SIGNED_I16, _mesa_texstore_snorm16 },
+};
+
+
+static GLboolean
+_mesa_texstore_null(TEXSTORE_PARAMS)
+{
+   (void) ctx; (void) dims;
+   (void) baseInternalFormat;
+   (void) dstFormat;
+   (void) dstAddr;
+   (void) dstXoffset; (void) dstYoffset; (void) dstZoffset;
+   (void) dstRowStride; (void) dstImageOffsets;
+   (void) srcWidth; (void) srcHeight; (void) srcDepth;
+   (void) srcFormat; (void) srcType;
+   (void) srcAddr;
+   (void) srcPacking;
+
+   /* should never happen */
+   _mesa_problem(NULL, "_mesa_texstore_null() is called");
+   return GL_FALSE;
+}
+
+
+/**
+ * Return the StoreTexImageFunc pointer to store an image in the given format.
+ */
+static StoreTexImageFunc
+_mesa_get_texstore_func(gl_format format)
+{
+#ifdef DEBUG
+   GLuint i;
+   for (i = 0; i < MESA_FORMAT_COUNT; i++) {
+      ASSERT(texstore_funcs[i].Name == i);
+   }
+#endif
+   ASSERT(texstore_funcs[format].Name == format);
+
+   if (texstore_funcs[format].Store)
+      return texstore_funcs[format].Store;
+   else
+      return _mesa_texstore_null;
+}
+
+
+/**
+ * Store user data into texture memory.
+ * Called via glTex[Sub]Image1/2/3D()
+ */
+GLboolean
+_mesa_texstore(TEXSTORE_PARAMS)
+{
+   StoreTexImageFunc storeImage;
+   GLboolean success;
+
+   storeImage = _mesa_get_texstore_func(dstFormat);
+
+   success = storeImage(ctx, dims, baseInternalFormat,
+                        dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                        dstRowStride, dstImageOffsets,
+                        srcWidth, srcHeight, srcDepth,
+                        srcFormat, srcType, srcAddr, srcPacking);
+   return success;
+}
+
+
+/** Return texture size in bytes */
+static GLuint
+texture_size(const struct gl_texture_image *texImage)
+{
+   GLuint sz = _mesa_format_image_size(texImage->TexFormat, texImage->Width,
+                                       texImage->Height, texImage->Depth);
+   return sz;
+}
+
+
+/** Return row stride in bytes */
+static GLuint
+texture_row_stride(const struct gl_texture_image *texImage)
+{
+   GLuint stride = _mesa_format_row_stride(texImage->TexFormat,
+                                           texImage->Width);
+   return stride;
+}
+
+
+
+/**
+ * This is the software fallback for Driver.TexImage1D()
+ * and Driver.CopyTexImage1D().
+ * \sa _mesa_store_teximage2d()
+ */
+void
+_mesa_store_teximage1d(struct gl_context *ctx, GLenum target, GLint level,
+                       GLint internalFormat,
+                       GLint width, GLint border,
+                       GLenum format, GLenum type, const GLvoid *pixels,
+                       const struct gl_pixelstore_attrib *packing,
+                       struct gl_texture_object *texObj,
+                       struct gl_texture_image *texImage)
+{
+   GLuint sizeInBytes;
+   (void) border;
+
+   /* allocate memory */
+   sizeInBytes = texture_size(texImage);
+   texImage->Data = _mesa_alloc_texmemory(sizeInBytes);
+   if (!texImage->Data) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");
+      return;
+   }
+
+   pixels = _mesa_validate_pbo_teximage(ctx, 1, width, 1, 1, format, type,
+                                        pixels, packing, "glTexImage1D");
+   if (!pixels) {
+      /* Note: we check for a NULL image pointer here, _after_ we allocated
+       * memory for the texture.  That's what the GL spec calls for.
+       */
+      return;
+   }
+   else {
+      const GLint dstRowStride = 0;
+      GLboolean success = _mesa_texstore(ctx, 1, texImage->_BaseFormat,
+                                         texImage->TexFormat,
+                                         texImage->Data,
+                                         0, 0, 0,  /* dstX/Y/Zoffset */
+                                         dstRowStride,
+                                         texImage->ImageOffsets,
+                                         width, 1, 1,
+                                         format, type, pixels, packing);
+      if (!success) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");
+      }
+   }
+
+   _mesa_unmap_teximage_pbo(ctx, packing);
+}
+
+
+/**
+ * This is the software fallback for Driver.TexImage2D()
+ * and Driver.CopyTexImage2D().
+ *
+ * This function is oriented toward storing images in main memory, rather
+ * than VRAM.  Device driver's can easily plug in their own replacement.
+ */
+void
+_mesa_store_teximage2d(struct gl_context *ctx, GLenum target, GLint level,
+                       GLint internalFormat,
+                       GLint width, GLint height, GLint border,
+                       GLenum format, GLenum type, const void *pixels,
+                       const struct gl_pixelstore_attrib *packing,
+                       struct gl_texture_object *texObj,
+                       struct gl_texture_image *texImage)
+{
+   GLuint sizeInBytes;
+   (void) border;
+
+   /* allocate memory */
+   sizeInBytes = texture_size(texImage);
+   texImage->Data = _mesa_alloc_texmemory(sizeInBytes);
+   if (!texImage->Data) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
+      return;
+   }
+
+   pixels = _mesa_validate_pbo_teximage(ctx, 2, width, height, 1, format, type,
+                                        pixels, packing, "glTexImage2D");
+   if (!pixels) {
+      /* Note: we check for a NULL image pointer here, _after_ we allocated
+       * memory for the texture.  That's what the GL spec calls for.
+       */
+      return;
+   }
+   else {
+      GLint dstRowStride = texture_row_stride(texImage);
+      GLboolean success = _mesa_texstore(ctx, 2, texImage->_BaseFormat,
+                                         texImage->TexFormat,
+                                         texImage->Data,
+                                         0, 0, 0,  /* dstX/Y/Zoffset */
+                                         dstRowStride,
+                                         texImage->ImageOffsets,
+                                         width, height, 1,
+                                         format, type, pixels, packing);
+      if (!success) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
+      }
+   }
+
+   _mesa_unmap_teximage_pbo(ctx, packing);
+}
+
+
+
+/**
+ * This is the software fallback for Driver.TexImage3D()
+ * and Driver.CopyTexImage3D().
+ * \sa _mesa_store_teximage2d()
+ */
+void
+_mesa_store_teximage3d(struct gl_context *ctx, GLenum target, GLint level,
+                       GLint internalFormat,
+                       GLint width, GLint height, GLint depth, GLint border,
+                       GLenum format, GLenum type, const void *pixels,
+                       const struct gl_pixelstore_attrib *packing,
+                       struct gl_texture_object *texObj,
+                       struct gl_texture_image *texImage)
+{
+   GLuint sizeInBytes;
+   (void) border;
+
+   /* allocate memory */
+   sizeInBytes = texture_size(texImage);
+   texImage->Data = _mesa_alloc_texmemory(sizeInBytes);
+   if (!texImage->Data) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");
+      return;
+   }
+
+   pixels = _mesa_validate_pbo_teximage(ctx, 3, width, height, depth, format,
+                                        type, pixels, packing, "glTexImage3D");
+   if (!pixels) {
+      /* Note: we check for a NULL image pointer here, _after_ we allocated
+       * memory for the texture.  That's what the GL spec calls for.
+       */
+      return;
+   }
+   else {
+      GLint dstRowStride = texture_row_stride(texImage);
+      GLboolean success = _mesa_texstore(ctx, 3, texImage->_BaseFormat,
+                                         texImage->TexFormat,
+                                         texImage->Data,
+                                         0, 0, 0,  /* dstX/Y/Zoffset */
+                                         dstRowStride,
+                                         texImage->ImageOffsets,
+                                         width, height, depth,
+                                         format, type, pixels, packing);
+      if (!success) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");
+      }
+   }
+
+   _mesa_unmap_teximage_pbo(ctx, packing);
+}
+
+
+
+
+/*
+ * This is the software fallback for Driver.TexSubImage1D()
+ * and Driver.CopyTexSubImage1D().
+ */
+void
+_mesa_store_texsubimage1d(struct gl_context *ctx, GLenum target, GLint level,
+                          GLint xoffset, GLint width,
+                          GLenum format, GLenum type, const void *pixels,
+                          const struct gl_pixelstore_attrib *packing,
+                          struct gl_texture_object *texObj,
+                          struct gl_texture_image *texImage)
+{
+   /* get pointer to src pixels (may be in a pbo which we'll map here) */
+   pixels = _mesa_validate_pbo_teximage(ctx, 1, width, 1, 1, format, type,
+                                        pixels, packing, "glTexSubImage1D");
+   if (!pixels)
+      return;
+
+   {
+      const GLint dstRowStride = 0;
+      GLboolean success = _mesa_texstore(ctx, 1, texImage->_BaseFormat,
+                                         texImage->TexFormat,
+                                         texImage->Data,
+                                         xoffset, 0, 0,  /* offsets */
+                                         dstRowStride,
+                                         texImage->ImageOffsets,
+                                         width, 1, 1,
+                                         format, type, pixels, packing);
+      if (!success) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage1D");
+      }
+   }
+
+   _mesa_unmap_teximage_pbo(ctx, packing);
+}
+
+
+
+/**
+ * This is the software fallback for Driver.TexSubImage2D()
+ * and Driver.CopyTexSubImage2D().
+ */
+void
+_mesa_store_texsubimage2d(struct gl_context *ctx, GLenum target, GLint level,
+                          GLint xoffset, GLint yoffset,
+                          GLint width, GLint height,
+                          GLenum format, GLenum type, const void *pixels,
+                          const struct gl_pixelstore_attrib *packing,
+                          struct gl_texture_object *texObj,
+                          struct gl_texture_image *texImage)
+{
+   /* get pointer to src pixels (may be in a pbo which we'll map here) */
+   pixels = _mesa_validate_pbo_teximage(ctx, 2, width, height, 1, format, type,
+                                        pixels, packing, "glTexSubImage2D");
+   if (!pixels)
+      return;
+
+   {
+      GLint dstRowStride = texture_row_stride(texImage);
+      GLboolean success = _mesa_texstore(ctx, 2, texImage->_BaseFormat,
+                                         texImage->TexFormat,
+                                         texImage->Data,
+                                         xoffset, yoffset, 0,
+                                         dstRowStride,
+                                         texImage->ImageOffsets,
+                                         width, height, 1,
+                                         format, type, pixels, packing);
+      if (!success) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage2D");
+      }
+   }
+
+   _mesa_unmap_teximage_pbo(ctx, packing);
+}
+
+
+/*
+ * This is the software fallback for Driver.TexSubImage3D().
+ * and Driver.CopyTexSubImage3D().
+ */
+void
+_mesa_store_texsubimage3d(struct gl_context *ctx, GLenum target, GLint level,
+                          GLint xoffset, GLint yoffset, GLint zoffset,
+                          GLint width, GLint height, GLint depth,
+                          GLenum format, GLenum type, const void *pixels,
+                          const struct gl_pixelstore_attrib *packing,
+                          struct gl_texture_object *texObj,
+                          struct gl_texture_image *texImage)
+{
+   /* get pointer to src pixels (may be in a pbo which we'll map here) */
+   pixels = _mesa_validate_pbo_teximage(ctx, 3, width, height, depth, format,
+                                        type, pixels, packing,
+                                        "glTexSubImage3D");
+   if (!pixels)
+      return;
+
+   {
+      GLint dstRowStride = texture_row_stride(texImage);
+      GLboolean success = _mesa_texstore(ctx, 3, texImage->_BaseFormat,
+                                         texImage->TexFormat,
+                                         texImage->Data,
+                                         xoffset, yoffset, zoffset,
+                                         dstRowStride,
+                                         texImage->ImageOffsets,
+                                         width, height, depth,
+                                         format, type, pixels, packing);
+      if (!success) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage3D");
+      }
+   }
+
+   _mesa_unmap_teximage_pbo(ctx, packing);
+}
+
+
+/*
+ * Fallback for Driver.CompressedTexImage1D()
+ */
+void
+_mesa_store_compressed_teximage1d(struct gl_context *ctx,
+                                  GLenum target, GLint level,
+                                  GLint internalFormat,
+                                  GLint width, GLint border,
+                                  GLsizei imageSize, const GLvoid *data,
+                                  struct gl_texture_object *texObj,
+                                  struct gl_texture_image *texImage)
+{
+   /* this space intentionally left blank */
+   (void) ctx;
+   (void) target; (void) level;
+   (void) internalFormat;
+   (void) width; (void) border;
+   (void) imageSize; (void) data;
+   (void) texObj;
+   (void) texImage;
+}
+
+
+
+/**
+ * Fallback for Driver.CompressedTexImage2D()
+ */
+void
+_mesa_store_compressed_teximage2d(struct gl_context *ctx,
+                                  GLenum target, GLint level,
+                                  GLint internalFormat,
+                                  GLint width, GLint height, GLint border,
+                                  GLsizei imageSize, const GLvoid *data,
+                                  struct gl_texture_object *texObj,
+                                  struct gl_texture_image *texImage)
+{
+   (void) width; (void) height; (void) border;
+
+   /* This is pretty simple, basically just do a memcpy without worrying
+    * about the usual image unpacking or image transfer operations.
+    */
+   ASSERT(texObj);
+   ASSERT(texImage);
+   ASSERT(texImage->Width > 0);
+   ASSERT(texImage->Height > 0);
+   ASSERT(texImage->Depth == 1);
+   ASSERT(texImage->Data == NULL); /* was freed in glCompressedTexImage2DARB */
+
+   /* allocate storage */
+   texImage->Data = _mesa_alloc_texmemory(imageSize);
+   if (!texImage->Data) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2DARB");
+      return;
+   }
+
+   data = _mesa_validate_pbo_compressed_teximage(ctx, imageSize, data,
+                                                 &ctx->Unpack,
+                                                 "glCompressedTexImage2D");
+   if (!data)
+      return;
+
+   /* copy the data */
+   memcpy(texImage->Data, data, imageSize);
+
+   _mesa_unmap_teximage_pbo(ctx, &ctx->Unpack);
+}
+
+
+
+/*
+ * Fallback for Driver.CompressedTexImage3D()
+ */
+void
+_mesa_store_compressed_teximage3d(struct gl_context *ctx,
+                                  GLenum target, GLint level,
+                                  GLint internalFormat,
+                                  GLint width, GLint height, GLint depth,
+                                  GLint border,
+                                  GLsizei imageSize, const GLvoid *data,
+                                  struct gl_texture_object *texObj,
+                                  struct gl_texture_image *texImage)
+{
+   /* this space intentionally left blank */
+   (void) ctx;
+   (void) target; (void) level;
+   (void) internalFormat;
+   (void) width; (void) height; (void) depth;
+   (void) border;
+   (void) imageSize; (void) data;
+   (void) texObj;
+   (void) texImage;
+}
+
+
+
+/**
+ * Fallback for Driver.CompressedTexSubImage1D()
+ */
+void
+_mesa_store_compressed_texsubimage1d(struct gl_context *ctx, GLenum target,
+                                     GLint level,
+                                     GLint xoffset, GLsizei width,
+                                     GLenum format,
+                                     GLsizei imageSize, const GLvoid *data,
+                                     struct gl_texture_object *texObj,
+                                     struct gl_texture_image *texImage)
+{
+   /* there are no compressed 1D texture formats yet */
+   (void) ctx;
+   (void) target; (void) level;
+   (void) xoffset; (void) width;
+   (void) format;
+   (void) imageSize; (void) data;
+   (void) texObj;
+   (void) texImage;
+}
+
+
+/**
+ * Fallback for Driver.CompressedTexSubImage2D()
+ */
+void
+_mesa_store_compressed_texsubimage2d(struct gl_context *ctx, GLenum target,
+                                     GLint level,
+                                     GLint xoffset, GLint yoffset,
+                                     GLsizei width, GLsizei height,
+                                     GLenum format,
+                                     GLsizei imageSize, const GLvoid *data,
+                                     struct gl_texture_object *texObj,
+                                     struct gl_texture_image *texImage)
+{
+   GLint bytesPerRow, destRowStride, srcRowStride;
+   GLint i, rows;
+   GLubyte *dest;
+   const GLubyte *src;
+   const gl_format texFormat = texImage->TexFormat;
+   const GLint destWidth = texImage->Width;
+   GLuint bw, bh;
+
+   _mesa_get_format_block_size(texFormat, &bw, &bh);
+
+   (void) level;
+   (void) format;
+
+   /* these should have been caught sooner */
+   ASSERT((width % bw) == 0 || width == 2 || width == 1);
+   ASSERT((height % bh) == 0 || height == 2 || height == 1);
+   ASSERT((xoffset % bw) == 0);
+   ASSERT((yoffset % bh) == 0);
+
+   /* get pointer to src pixels (may be in a pbo which we'll map here) */
+   data = _mesa_validate_pbo_compressed_teximage(ctx, imageSize, data,
+                                                 &ctx->Unpack,
+                                                 "glCompressedTexSubImage2D");
+   if (!data)
+      return;
+
+   srcRowStride = _mesa_format_row_stride(texFormat, width);
+   src = (const GLubyte *) data;
+
+   destRowStride = _mesa_format_row_stride(texFormat, destWidth);
+   dest = _mesa_compressed_image_address(xoffset, yoffset, 0,
+                                         texFormat, destWidth,
+                                         (GLubyte *) texImage->Data);
+
+   bytesPerRow = srcRowStride;  /* bytes per row of blocks */
+   rows = height / bh;  /* rows in blocks */
+
+   /* copy rows of blocks */
+   for (i = 0; i < rows; i++) {
+      memcpy(dest, src, bytesPerRow);
+      dest += destRowStride;
+      src += srcRowStride;
+   }
+
+   _mesa_unmap_teximage_pbo(ctx, &ctx->Unpack);
+}
+
+
+/**
+ * Fallback for Driver.CompressedTexSubImage3D()
+ */
+void
+_mesa_store_compressed_texsubimage3d(struct gl_context *ctx, GLenum target,
+                                GLint level,
+                                GLint xoffset, GLint yoffset, GLint zoffset,
+                                GLsizei width, GLsizei height, GLsizei depth,
+                                GLenum format,
+                                GLsizei imageSize, const GLvoid *data,
+                                struct gl_texture_object *texObj,
+                                struct gl_texture_image *texImage)
+{
+   /* there are no compressed 3D texture formats yet */
+   (void) ctx;
+   (void) target; (void) level;
+   (void) xoffset; (void) yoffset; (void) zoffset;
+   (void) width; (void) height; (void) depth;
+   (void) format;
+   (void) imageSize; (void) data;
+   (void) texObj;
+   (void) texImage;
+}
diff --git a/mesalib/src/mesa/main/uniforms.c b/mesalib/src/mesa/main/uniforms.c
index 523b8e1a9..f984ce3bc 100644
--- a/mesalib/src/mesa/main/uniforms.c
+++ b/mesalib/src/mesa/main/uniforms.c
@@ -1,1707 +1,1459 @@
-/*

- * Mesa 3-D graphics library

- *

- * Copyright (C) 2004-2008  Brian Paul   All Rights Reserved.

- * Copyright (C) 2009-2010  VMware, Inc.  All Rights Reserved.

- * Copyright © 2010 Intel Corporation

- *

- * 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.

- */

-

-/**

- * \file uniforms.c

- * Functions related to GLSL uniform variables.

- * \author Brian Paul

- */

-

-/**

- * XXX things to do:

- * 1. Check that the right error code is generated for all _mesa_error() calls.

- * 2. Insert FLUSH_VERTICES calls in various places

- */

-

-

-#include "main/glheader.h"

-#include "main/context.h"

-#include "main/dispatch.h"

-#include "main/mfeatures.h"

-#include "main/mtypes.h"

-#include "main/shaderapi.h"

-#include "main/shaderobj.h"

-#include "main/uniforms.h"

-#include "program/prog_parameter.h"

-#include "program/prog_statevars.h"

-#include "program/prog_uniform.h"

-#include "program/prog_instruction.h"

-

-

-static GLenum

-base_uniform_type(GLenum type)

-{

-   switch (type) {

-#if 0 /* not needed, for now */

-   case GL_BOOL:

-   case GL_BOOL_VEC2:

-   case GL_BOOL_VEC3:

-   case GL_BOOL_VEC4:

-      return GL_BOOL;

-#endif

-   case GL_FLOAT:

-   case GL_FLOAT_VEC2:

-   case GL_FLOAT_VEC3:

-   case GL_FLOAT_VEC4:

-      return GL_FLOAT;

-   case GL_UNSIGNED_INT:

-   case GL_UNSIGNED_INT_VEC2:

-   case GL_UNSIGNED_INT_VEC3:

-   case GL_UNSIGNED_INT_VEC4:

-      return GL_UNSIGNED_INT;

-   case GL_INT:

-   case GL_INT_VEC2:

-   case GL_INT_VEC3:

-   case GL_INT_VEC4:

-      return GL_INT;

-   default:

-      _mesa_problem(NULL, "Invalid type in base_uniform_type()");

-      return GL_FLOAT;

-   }

-}

-

-static struct gl_builtin_uniform_element gl_DepthRange_elements[] = {

-   {"near", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_XXXX},

-   {"far", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_YYYY},

-   {"diff", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_ZZZZ},

-};

-

-static struct gl_builtin_uniform_element gl_ClipPlane_elements[] = {

-   {NULL, {STATE_CLIPPLANE, 0, 0}, SWIZZLE_XYZW}

-};

-

-static struct gl_builtin_uniform_element gl_Point_elements[] = {

-   {"size", {STATE_POINT_SIZE}, SWIZZLE_XXXX},

-   {"sizeMin", {STATE_POINT_SIZE}, SWIZZLE_YYYY},

-   {"sizeMax", {STATE_POINT_SIZE}, SWIZZLE_ZZZZ},

-   {"fadeThresholdSize", {STATE_POINT_SIZE}, SWIZZLE_WWWW},

-   {"distanceConstantAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_XXXX},

-   {"distanceLinearAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_YYYY},

-   {"distanceQuadraticAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_ZZZZ},

-};

-

-static struct gl_builtin_uniform_element gl_FrontMaterial_elements[] = {

-   {"emission", {STATE_MATERIAL, 0, STATE_EMISSION}, SWIZZLE_XYZW},

-   {"ambient", {STATE_MATERIAL, 0, STATE_AMBIENT}, SWIZZLE_XYZW},

-   {"diffuse", {STATE_MATERIAL, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},

-   {"specular", {STATE_MATERIAL, 0, STATE_SPECULAR}, SWIZZLE_XYZW},

-   {"shininess", {STATE_MATERIAL, 0, STATE_SHININESS}, SWIZZLE_XXXX},

-};

-

-static struct gl_builtin_uniform_element gl_BackMaterial_elements[] = {

-   {"emission", {STATE_MATERIAL, 1, STATE_EMISSION}, SWIZZLE_XYZW},

-   {"ambient", {STATE_MATERIAL, 1, STATE_AMBIENT}, SWIZZLE_XYZW},

-   {"diffuse", {STATE_MATERIAL, 1, STATE_DIFFUSE}, SWIZZLE_XYZW},

-   {"specular", {STATE_MATERIAL, 1, STATE_SPECULAR}, SWIZZLE_XYZW},

-   {"shininess", {STATE_MATERIAL, 1, STATE_SHININESS}, SWIZZLE_XXXX},

-};

-

-static struct gl_builtin_uniform_element gl_LightSource_elements[] = {

-   {"ambient", {STATE_LIGHT, 0, STATE_AMBIENT}, SWIZZLE_XYZW},

-   {"diffuse", {STATE_LIGHT, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},

-   {"specular", {STATE_LIGHT, 0, STATE_SPECULAR}, SWIZZLE_XYZW},

-   {"position", {STATE_LIGHT, 0, STATE_POSITION}, SWIZZLE_XYZW},

-   {"halfVector", {STATE_LIGHT, 0, STATE_HALF_VECTOR}, SWIZZLE_XYZW},

-   {"spotDirection", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION},

-    MAKE_SWIZZLE4(SWIZZLE_X,

-		  SWIZZLE_Y,

-		  SWIZZLE_Z,

-		  SWIZZLE_Z)},

-   {"spotCosCutoff", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION}, SWIZZLE_WWWW},

-   {"spotCutoff", {STATE_LIGHT, 0, STATE_SPOT_CUTOFF}, SWIZZLE_XXXX},

-   {"spotExponent", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_WWWW},

-   {"constantAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_XXXX},

-   {"linearAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_YYYY},

-   {"quadraticAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_ZZZZ},

-};

-

-static struct gl_builtin_uniform_element gl_LightModel_elements[] = {

-   {"ambient", {STATE_LIGHTMODEL_AMBIENT, 0}, SWIZZLE_XYZW},

-};

-

-static struct gl_builtin_uniform_element gl_FrontLightModelProduct_elements[] = {

-   {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 0}, SWIZZLE_XYZW},

-};

-

-static struct gl_builtin_uniform_element gl_BackLightModelProduct_elements[] = {

-   {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 1}, SWIZZLE_XYZW},

-};

-

-static struct gl_builtin_uniform_element gl_FrontLightProduct_elements[] = {

-   {"ambient", {STATE_LIGHTPROD, 0, 0, STATE_AMBIENT}, SWIZZLE_XYZW},

-   {"diffuse", {STATE_LIGHTPROD, 0, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},

-   {"specular", {STATE_LIGHTPROD, 0, 0, STATE_SPECULAR}, SWIZZLE_XYZW},

-};

-

-static struct gl_builtin_uniform_element gl_BackLightProduct_elements[] = {

-   {"ambient", {STATE_LIGHTPROD, 0, 1, STATE_AMBIENT}, SWIZZLE_XYZW},

-   {"diffuse", {STATE_LIGHTPROD, 0, 1, STATE_DIFFUSE}, SWIZZLE_XYZW},

-   {"specular", {STATE_LIGHTPROD, 0, 1, STATE_SPECULAR}, SWIZZLE_XYZW},

-};

-

-static struct gl_builtin_uniform_element gl_TextureEnvColor_elements[] = {

-   {NULL, {STATE_TEXENV_COLOR, 0}, SWIZZLE_XYZW},

-};

-

-static struct gl_builtin_uniform_element gl_EyePlaneS_elements[] = {

-   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_S}, SWIZZLE_XYZW},

-};

-

-static struct gl_builtin_uniform_element gl_EyePlaneT_elements[] = {

-   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_T}, SWIZZLE_XYZW},

-};

-

-static struct gl_builtin_uniform_element gl_EyePlaneR_elements[] = {

-   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_R}, SWIZZLE_XYZW},

-};

-

-static struct gl_builtin_uniform_element gl_EyePlaneQ_elements[] = {

-   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_Q}, SWIZZLE_XYZW},

-};

-

-static struct gl_builtin_uniform_element gl_ObjectPlaneS_elements[] = {

-   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_S}, SWIZZLE_XYZW},

-};

-

-static struct gl_builtin_uniform_element gl_ObjectPlaneT_elements[] = {

-   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_T}, SWIZZLE_XYZW},

-};

-

-static struct gl_builtin_uniform_element gl_ObjectPlaneR_elements[] = {

-   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_R}, SWIZZLE_XYZW},

-};

-

-static struct gl_builtin_uniform_element gl_ObjectPlaneQ_elements[] = {

-   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_Q}, SWIZZLE_XYZW},

-};

-

-static struct gl_builtin_uniform_element gl_Fog_elements[] = {

-   {"color", {STATE_FOG_COLOR}, SWIZZLE_XYZW},

-   {"density", {STATE_FOG_PARAMS}, SWIZZLE_XXXX},

-   {"start", {STATE_FOG_PARAMS}, SWIZZLE_YYYY},

-   {"end", {STATE_FOG_PARAMS}, SWIZZLE_ZZZZ},

-   {"scale", {STATE_FOG_PARAMS}, SWIZZLE_WWWW},

-};

-

-static struct gl_builtin_uniform_element gl_NormalScale_elements[] = {

-   {NULL, {STATE_NORMAL_SCALE}, SWIZZLE_XXXX},

-};

-

-static struct gl_builtin_uniform_element gl_MESABumpRotMatrix0_elements[] = {

-   {NULL, {STATE_INTERNAL, STATE_ROT_MATRIX_0}, SWIZZLE_XYZW},

-};

-

-static struct gl_builtin_uniform_element gl_MESABumpRotMatrix1_elements[] = {

-   {NULL, {STATE_INTERNAL, STATE_ROT_MATRIX_1}, SWIZZLE_XYZW},

-};

-

-static struct gl_builtin_uniform_element gl_MESAFogParamsOptimized_elements[] = {

-   {NULL, {STATE_INTERNAL, STATE_FOG_PARAMS_OPTIMIZED}, SWIZZLE_XYZW},

-};

-

-#define MATRIX(name, statevar, modifier)				\

-   static struct gl_builtin_uniform_element name ## _elements[] = {	\

-      { NULL, { statevar, 0, 0, 0, modifier}, SWIZZLE_XYZW },		\

-      { NULL, { statevar, 0, 1, 1, modifier}, SWIZZLE_XYZW },		\

-      { NULL, { statevar, 0, 2, 2, modifier}, SWIZZLE_XYZW },		\

-      { NULL, { statevar, 0, 3, 3, modifier}, SWIZZLE_XYZW },		\

-   }

-

-MATRIX(gl_ModelViewMatrix,

-       STATE_MODELVIEW_MATRIX, STATE_MATRIX_TRANSPOSE);

-MATRIX(gl_ModelViewMatrixInverse,

-       STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVTRANS);

-MATRIX(gl_ModelViewMatrixTranspose,

-       STATE_MODELVIEW_MATRIX, 0);

-MATRIX(gl_ModelViewMatrixInverseTranspose,

-       STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVERSE);

-

-MATRIX(gl_ProjectionMatrix,

-       STATE_PROJECTION_MATRIX, STATE_MATRIX_TRANSPOSE);

-MATRIX(gl_ProjectionMatrixInverse,

-       STATE_PROJECTION_MATRIX, STATE_MATRIX_INVTRANS);

-MATRIX(gl_ProjectionMatrixTranspose,

-       STATE_PROJECTION_MATRIX, 0);

-MATRIX(gl_ProjectionMatrixInverseTranspose,

-       STATE_PROJECTION_MATRIX, STATE_MATRIX_INVERSE);

-

-MATRIX(gl_ModelViewProjectionMatrix,

-       STATE_MVP_MATRIX, STATE_MATRIX_TRANSPOSE);

-MATRIX(gl_ModelViewProjectionMatrixInverse,

-       STATE_MVP_MATRIX, STATE_MATRIX_INVTRANS);

-MATRIX(gl_ModelViewProjectionMatrixTranspose,

-       STATE_MVP_MATRIX, 0);

-MATRIX(gl_ModelViewProjectionMatrixInverseTranspose,

-       STATE_MVP_MATRIX, STATE_MATRIX_INVERSE);

-

-MATRIX(gl_TextureMatrix,

-       STATE_TEXTURE_MATRIX, STATE_MATRIX_TRANSPOSE);

-MATRIX(gl_TextureMatrixInverse,

-       STATE_TEXTURE_MATRIX, STATE_MATRIX_INVTRANS);

-MATRIX(gl_TextureMatrixTranspose,

-       STATE_TEXTURE_MATRIX, 0);

-MATRIX(gl_TextureMatrixInverseTranspose,

-       STATE_TEXTURE_MATRIX, STATE_MATRIX_INVERSE);

-

-static struct gl_builtin_uniform_element gl_NormalMatrix_elements[] = {

-   { NULL, { STATE_MODELVIEW_MATRIX, 0, 0, 0, STATE_MATRIX_INVERSE},

-     SWIZZLE_XYZW },

-   { NULL, { STATE_MODELVIEW_MATRIX, 0, 1, 1, STATE_MATRIX_INVERSE},

-     SWIZZLE_XYZW },

-   { NULL, { STATE_MODELVIEW_MATRIX, 0, 2, 2, STATE_MATRIX_INVERSE},

-     SWIZZLE_XYZW },

-};

-

-#undef MATRIX

-

-#define STATEVAR(name) {#name, name ## _elements, Elements(name ## _elements)}

-

-const struct gl_builtin_uniform_desc _mesa_builtin_uniform_desc[] = {

-   STATEVAR(gl_DepthRange),

-   STATEVAR(gl_ClipPlane),

-   STATEVAR(gl_Point),

-   STATEVAR(gl_FrontMaterial),

-   STATEVAR(gl_BackMaterial),

-   STATEVAR(gl_LightSource),

-   STATEVAR(gl_LightModel),

-   STATEVAR(gl_FrontLightModelProduct),

-   STATEVAR(gl_BackLightModelProduct),

-   STATEVAR(gl_FrontLightProduct),

-   STATEVAR(gl_BackLightProduct),

-   STATEVAR(gl_TextureEnvColor),

-   STATEVAR(gl_EyePlaneS),

-   STATEVAR(gl_EyePlaneT),

-   STATEVAR(gl_EyePlaneR),

-   STATEVAR(gl_EyePlaneQ),

-   STATEVAR(gl_ObjectPlaneS),

-   STATEVAR(gl_ObjectPlaneT),

-   STATEVAR(gl_ObjectPlaneR),

-   STATEVAR(gl_ObjectPlaneQ),

-   STATEVAR(gl_Fog),

-

-   STATEVAR(gl_ModelViewMatrix),

-   STATEVAR(gl_ModelViewMatrixInverse),

-   STATEVAR(gl_ModelViewMatrixTranspose),

-   STATEVAR(gl_ModelViewMatrixInverseTranspose),

-

-   STATEVAR(gl_ProjectionMatrix),

-   STATEVAR(gl_ProjectionMatrixInverse),

-   STATEVAR(gl_ProjectionMatrixTranspose),

-   STATEVAR(gl_ProjectionMatrixInverseTranspose),

-

-   STATEVAR(gl_ModelViewProjectionMatrix),

-   STATEVAR(gl_ModelViewProjectionMatrixInverse),

-   STATEVAR(gl_ModelViewProjectionMatrixTranspose),

-   STATEVAR(gl_ModelViewProjectionMatrixInverseTranspose),

-

-   STATEVAR(gl_TextureMatrix),

-   STATEVAR(gl_TextureMatrixInverse),

-   STATEVAR(gl_TextureMatrixTranspose),

-   STATEVAR(gl_TextureMatrixInverseTranspose),

-

-   STATEVAR(gl_NormalMatrix),

-   STATEVAR(gl_NormalScale),

-

-   STATEVAR(gl_MESABumpRotMatrix0),

-   STATEVAR(gl_MESABumpRotMatrix1),

-   STATEVAR(gl_MESAFogParamsOptimized),

-

-   {NULL, NULL, 0}

-};

-

-static GLboolean

-is_boolean_type(GLenum type)

-{

-   switch (type) {

-   case GL_BOOL:

-   case GL_BOOL_VEC2:

-   case GL_BOOL_VEC3:

-   case GL_BOOL_VEC4:

-      return GL_TRUE;

-   default:

-      return GL_FALSE;

-   }

-}

-

-

-static GLboolean

-is_sampler_type(GLenum type)

-{

-   switch (type) {

-   case GL_SAMPLER_1D:

-   case GL_SAMPLER_2D:

-   case GL_SAMPLER_3D:

-   case GL_SAMPLER_CUBE:

-   case GL_SAMPLER_1D_SHADOW:

-   case GL_SAMPLER_2D_SHADOW:

-   case GL_SAMPLER_2D_RECT_ARB:

-   case GL_SAMPLER_2D_RECT_SHADOW_ARB:

-   case GL_SAMPLER_1D_ARRAY_EXT:

-   case GL_SAMPLER_2D_ARRAY_EXT:

-   case GL_SAMPLER_1D_ARRAY_SHADOW_EXT:

-   case GL_SAMPLER_2D_ARRAY_SHADOW_EXT:

-      return GL_TRUE;

-   default:

-      return GL_FALSE;

-   }

-}

-

-

-static struct gl_program_parameter *

-get_uniform_parameter(const struct gl_shader_program *shProg, GLuint index)

-{

-   const struct gl_program *prog = NULL;

-   GLint progPos;

-

-   progPos = shProg->Uniforms->Uniforms[index].VertPos;

-   if (progPos >= 0) {

-      prog = &shProg->VertexProgram->Base;

-   }

-   else {

-      progPos = shProg->Uniforms->Uniforms[index].FragPos;

-      if (progPos >= 0) {

-         prog = &shProg->FragmentProgram->Base;

-      } else {

-         progPos = shProg->Uniforms->Uniforms[index].GeomPos;

-         if (progPos >= 0) {

-            prog = &shProg->GeometryProgram->Base;

-         }

-      }

-   }

-

-   if (!prog || progPos < 0)

-      return NULL; /* should never happen */

-

-   return &prog->Parameters->Parameters[progPos];

-}

-

-

-/**

- * Called by glGetActiveUniform().

- */

-static void

-_mesa_get_active_uniform(struct gl_context *ctx, GLuint program, GLuint index,

-                         GLsizei maxLength, GLsizei *length, GLint *size,

-                         GLenum *type, GLchar *nameOut)

-{

-   const struct gl_shader_program *shProg;

-   const struct gl_program *prog = NULL;

-   const struct gl_program_parameter *param;

-   GLint progPos;

-

-   shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniform");

-   if (!shProg)

-      return;

-

-   if (!shProg->Uniforms || index >= shProg->Uniforms->NumUniforms) {

-      _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");

-      return;

-   }

-

-   progPos = shProg->Uniforms->Uniforms[index].VertPos;

-   if (progPos >= 0) {

-      prog = &shProg->VertexProgram->Base;

-   }

-   else {

-      progPos = shProg->Uniforms->Uniforms[index].FragPos;

-      if (progPos >= 0) {

-         prog = &shProg->FragmentProgram->Base;

-      } else {

-         progPos = shProg->Uniforms->Uniforms[index].GeomPos;

-         if (progPos >= 0) {

-            prog = &shProg->GeometryProgram->Base;

-         }

-      }

-   }

-

-   if (!prog || progPos < 0)

-      return; /* should never happen */

-

-   ASSERT(progPos < prog->Parameters->NumParameters);

-   param = &prog->Parameters->Parameters[progPos];

-

-   if (nameOut) {

-      _mesa_copy_string(nameOut, maxLength, length, param->Name);

-   }

-

-   if (size) {

-      GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);

-      if ((GLint) param->Size > typeSize) {

-         /* This is an array.

-          * Array elements are placed on vector[4] boundaries so they're

-          * a multiple of four floats.  We round typeSize up to next multiple

-          * of four to get the right size below.

-          */

-         typeSize = (typeSize + 3) & ~3;

-      }

-      /* Note that the returned size is in units of the <type>, not bytes */

-      *size = param->Size / typeSize;

-   }

-

-   if (type) {

-      *type = param->DataType;

-   }

-}

-

-

-static unsigned

-get_vector_elements(GLenum type)

-{

-   switch (type) {

-   case GL_FLOAT:

-   case GL_INT:

-   case GL_BOOL:

-   case GL_UNSIGNED_INT:

-   default: /* Catch all the various sampler types. */

-      return 1;

-

-   case GL_FLOAT_VEC2:

-   case GL_INT_VEC2:

-   case GL_BOOL_VEC2:

-   case GL_UNSIGNED_INT_VEC2:

-      return 2;

-

-   case GL_FLOAT_VEC3:

-   case GL_INT_VEC3:

-   case GL_BOOL_VEC3:

-   case GL_UNSIGNED_INT_VEC3:

-      return 3;

-

-   case GL_FLOAT_VEC4:

-   case GL_INT_VEC4:

-   case GL_BOOL_VEC4:

-   case GL_UNSIGNED_INT_VEC4:

-      return 4;

-   }

-}

-

-static void

-get_matrix_dims(GLenum type, GLint *rows, GLint *cols)

-{

-   switch (type) {

-   case GL_FLOAT_MAT2:

-      *rows = *cols = 2;

-      break;

-   case GL_FLOAT_MAT2x3:

-      *rows = 3;

-      *cols = 2;

-      break;

-   case GL_FLOAT_MAT2x4:

-      *rows = 4;

-      *cols = 2;

-      break;

-   case GL_FLOAT_MAT3:

-      *rows = 3;

-      *cols = 3;

-      break;

-   case GL_FLOAT_MAT3x2:

-      *rows = 2;

-      *cols = 3;

-      break;

-   case GL_FLOAT_MAT3x4:

-      *rows = 4;

-      *cols = 3;

-      break;

-   case GL_FLOAT_MAT4:

-      *rows = 4;

-      *cols = 4;

-      break;

-   case GL_FLOAT_MAT4x2:

-      *rows = 2;

-      *cols = 4;

-      break;

-   case GL_FLOAT_MAT4x3:

-      *rows = 3;

-      *cols = 4;

-      break;

-   default:

-      *rows = *cols = 0;

-   }

-}

-

-

-/**

- * Determine the number of rows and columns occupied by a uniform

- * according to its datatype.  For non-matrix types (such as GL_FLOAT_VEC4),

- * the number of rows = 1 and cols = number of elements in the vector.

- */

-static void

-get_uniform_rows_cols(const struct gl_program_parameter *p,

-                      GLint *rows, GLint *cols)

-{

-   get_matrix_dims(p->DataType, rows, cols);

-   if (*rows == 0 && *cols == 0) {

-      /* not a matrix type, probably a float or vector */

-      *rows = 1;

-      *cols = get_vector_elements(p->DataType);

-   }

-}

-

-

-/**

- * Helper for get_uniform[fi]v() functions.

- * Given a shader program name and uniform location, return a pointer

- * to the shader program and return the program parameter position.

- */

-static void

-lookup_uniform_parameter(struct gl_context *ctx, GLuint program, GLint location,

-                         struct gl_program **progOut, GLint *paramPosOut)

-{

-   struct gl_shader_program *shProg

-      = _mesa_lookup_shader_program_err(ctx, program, "glGetUniform[if]v");

-   struct gl_program *prog = NULL;

-   GLint progPos = -1;

-

-   /* if shProg is NULL, we'll have already recorded an error */

-

-   if (shProg) {

-      if (!shProg->Uniforms ||

-          location < 0 ||

-          location >= (GLint) shProg->Uniforms->NumUniforms) {

-         _mesa_error(ctx, GL_INVALID_OPERATION,  "glGetUniformfv(location)");

-      }

-      else {

-         /* OK, find the gl_program and program parameter location */

-         progPos = shProg->Uniforms->Uniforms[location].VertPos;

-         if (progPos >= 0) {

-            prog = &shProg->VertexProgram->Base;

-         }

-         else {

-            progPos = shProg->Uniforms->Uniforms[location].FragPos;

-            if (progPos >= 0) {

-               prog = &shProg->FragmentProgram->Base;

-            } else {

-               progPos = shProg->Uniforms->Uniforms[location].GeomPos;

-               if (progPos >= 0) {

-                  prog = &shProg->GeometryProgram->Base;

-               }

-            }

-         }

-      }

-   }

-

-   *progOut = prog;

-   *paramPosOut = progPos;

-}

-

-

-/**

- * GLGL uniform arrays and structs require special handling.

- *

- * The GL_ARB_shader_objects spec says that if you use

- * glGetUniformLocation to get the location of an array, you CANNOT

- * access other elements of the array by adding an offset to the

- * returned location.  For example, you must call

- * glGetUniformLocation("foo[16]") if you want to set the 16th element

- * of the array with glUniform().

- *

- * HOWEVER, some other OpenGL drivers allow accessing array elements

- * by adding an offset to the returned array location.  And some apps

- * seem to depend on that behaviour.

- *

- * Mesa's gl_uniform_list doesn't directly support this since each

- * entry in the list describes one uniform variable, not one uniform

- * element.  We could insert dummy entries in the list for each array

- * element after [0] but that causes complications elsewhere.

- *

- * We solve this problem by encoding two values in the location that's

- * returned by glGetUniformLocation():

- *  a) index into gl_uniform_list::Uniforms[] for the uniform

- *  b) an array/field offset (0 for simple types)

- *

- * These two values are encoded in the high and low halves of a GLint.

- * By putting the uniform number in the high part and the offset in the

- * low part, we can support the unofficial ability to index into arrays

- * by adding offsets to the location value.

- */

-static void

-merge_location_offset(GLint *location, GLint offset)

-{

-   *location = (*location << 16) | offset;

-}

-

-

-/**

- * Separate the uniform location and parameter offset.  See above.

- */

-static void

-split_location_offset(GLint *location, GLint *offset)

-{

-   *offset = *location & 0xffff;

-   *location = *location >> 16;

-}

-

-

-

-/**

- * Called via glGetUniformfv().

- */

-static void

-_mesa_get_uniformfv(struct gl_context *ctx, GLuint program, GLint location,

-                    GLfloat *params)

-{

-   struct gl_program *prog;

-   GLint paramPos;

-   GLint offset;

-

-   split_location_offset(&location, &offset);

-

-   lookup_uniform_parameter(ctx, program, location, &prog, &paramPos);

-

-   if (prog) {

-      const struct gl_program_parameter *p =

-         &prog->Parameters->Parameters[paramPos];

-      GLint rows, cols, i, j, k;

-

-      get_uniform_rows_cols(p, &rows, &cols);

-

-      k = 0;

-      for (i = 0; i < rows; i++) {

-	 const int base = paramPos + offset + i;

-

-         for (j = 0; j < cols; j++ ) {

-            params[k++] = prog->Parameters->ParameterValues[base][j];

-         }

-      }

-   }

-}

-

-

-/**

- * Called via glGetUniformiv().

- * \sa _mesa_get_uniformfv, only difference is a cast.

- */

-static void

-_mesa_get_uniformiv(struct gl_context *ctx, GLuint program, GLint location,

-                    GLint *params)

-{

-   struct gl_program *prog;

-   GLint paramPos;

-   GLint offset;

-

-   split_location_offset(&location, &offset);

-

-   lookup_uniform_parameter(ctx, program, location, &prog, &paramPos);

-

-   if (prog) {

-      const struct gl_program_parameter *p =

-         &prog->Parameters->Parameters[paramPos];

-      GLint rows, cols, i, j, k;

-

-      get_uniform_rows_cols(p, &rows, &cols);

-

-      k = 0;

-      for (i = 0; i < rows; i++) {

-	 const int base = paramPos + offset + i;

-

-         for (j = 0; j < cols; j++ ) {

-            params[k++] = (GLint) prog->Parameters->ParameterValues[base][j];

-         }

-      }

-   }

-}

-

-

-/**

- * Called via glGetUniformuiv().

- * New in GL_EXT_gpu_shader4, OpenGL 3.0

- * \sa _mesa_get_uniformfv, only difference is a cast.

- */

-static void

-_mesa_get_uniformuiv(struct gl_context *ctx, GLuint program, GLint location,

-                     GLuint *params)

-{

-   struct gl_program *prog;

-   GLint paramPos;

-   GLint offset;

-

-   split_location_offset(&location, &offset);

-

-   lookup_uniform_parameter(ctx, program, location, &prog, &paramPos);

-

-   if (prog) {

-      const struct gl_program_parameter *p =

-         &prog->Parameters->Parameters[paramPos];

-      GLint rows, cols, i, j, k;

-

-      get_uniform_rows_cols(p, &rows, &cols);

-

-      k = 0;

-      for (i = 0; i < rows; i++) {

-	 const int base = paramPos + offset + i;

-

-         for (j = 0; j < cols; j++ ) {

-            params[k++] = (GLuint) prog->Parameters->ParameterValues[base][j];

-         }

-      }

-   }

-}

-

-

-/**

- * Called via glGetUniformLocation().

- *

- * The return value will encode two values, the uniform location and an

- * offset (used for arrays, structs).

- */

-GLint

-_mesa_get_uniform_location(struct gl_context *ctx, struct gl_shader_program *shProg,

-			   const GLchar *name)

-{

-   GLint offset = 0, location = -1;

-

-   if (shProg->LinkStatus == GL_FALSE) {

-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformfv(program)");

-      return -1;

-   }

-

-   /* XXX we should return -1 if the uniform was declared, but not

-    * actually used.

-    */

-

-   /* XXX we need to be able to parse uniform names for structs and arrays

-    * such as:

-    *   mymatrix[1]

-    *   mystruct.field1

-    */

-

-   {

-      /* handle 1-dimension arrays here... */

-      char *c = strchr(name, '[');

-      if (c) {

-         /* truncate name at [ */

-         const GLint len = c - name;

-         GLchar *newName = malloc(len + 1);

-         if (!newName)

-            return -1; /* out of mem */

-         memcpy(newName, name, len);

-         newName[len] = 0;

-

-         location = _mesa_lookup_uniform(shProg->Uniforms, newName);

-         if (location >= 0) {

-            const GLint element = atoi(c + 1);

-            if (element > 0) {

-               /* get type of the uniform array element */

-               struct gl_program_parameter *p;

-               p = get_uniform_parameter(shProg, location);

-               if (p) {

-                  GLint rows, cols;

-                  get_matrix_dims(p->DataType, &rows, &cols);

-                  if (rows < 1)

-                     rows = 1;

-                  offset = element * rows;

-               }

-            }

-         }

-

-         free(newName);

-      }

-   }

-

-   if (location < 0) {

-      location = _mesa_lookup_uniform(shProg->Uniforms, name);

-   }

-

-   if (location >= 0) {

-      merge_location_offset(&location, offset);

-   }

-

-   return location;

-}

-

-

-

-/**

- * Update the vertex/fragment program's TexturesUsed array.

- *

- * This needs to be called after glUniform(set sampler var) is called.

- * A call to glUniform(samplerVar, value) causes a sampler to point to a

- * particular texture unit.  We know the sampler's texture target

- * (1D/2D/3D/etc) from compile time but the sampler's texture unit is

- * set by glUniform() calls.

- *

- * So, scan the program->SamplerUnits[] and program->SamplerTargets[]

- * information to update the prog->TexturesUsed[] values.

- * Each value of TexturesUsed[unit] is one of zero, TEXTURE_1D_INDEX,

- * TEXTURE_2D_INDEX, TEXTURE_3D_INDEX, etc.

- * We'll use that info for state validation before rendering.

- */

-void

-_mesa_update_shader_textures_used(struct gl_program *prog)

-{

-   GLuint s;

-

-   memset(prog->TexturesUsed, 0, sizeof(prog->TexturesUsed));

-

-   for (s = 0; s < MAX_SAMPLERS; s++) {

-      if (prog->SamplersUsed & (1 << s)) {

-         GLuint unit = prog->SamplerUnits[s];

-         GLuint tgt = prog->SamplerTargets[s];

-         assert(unit < MAX_TEXTURE_IMAGE_UNITS);

-         assert(tgt < NUM_TEXTURE_TARGETS);

-         prog->TexturesUsed[unit] |= (1 << tgt);

-      }

-   }

-}

-

-

-/**

- * Check if the type given by userType is allowed to set a uniform of the

- * target type.  Generally, equivalence is required, but setting Boolean

- * uniforms can be done with glUniformiv or glUniformfv.

- */

-static GLboolean

-compatible_types(GLenum userType, GLenum targetType)

-{

-   if (userType == targetType)

-      return GL_TRUE;

-

-   if (targetType == GL_BOOL && (userType == GL_FLOAT ||

-                                 userType == GL_UNSIGNED_INT ||

-                                 userType == GL_INT))

-      return GL_TRUE;

-

-   if (targetType == GL_BOOL_VEC2 && (userType == GL_FLOAT_VEC2 ||

-                                      userType == GL_UNSIGNED_INT_VEC2 ||

-                                      userType == GL_INT_VEC2))

-      return GL_TRUE;

-

-   if (targetType == GL_BOOL_VEC3 && (userType == GL_FLOAT_VEC3 ||

-                                      userType == GL_UNSIGNED_INT_VEC3 ||

-                                      userType == GL_INT_VEC3))

-      return GL_TRUE;

-

-   if (targetType == GL_BOOL_VEC4 && (userType == GL_FLOAT_VEC4 ||

-                                      userType == GL_UNSIGNED_INT_VEC4 ||

-                                      userType == GL_INT_VEC4))

-      return GL_TRUE;

-

-   if (is_sampler_type(targetType) && userType == GL_INT)

-      return GL_TRUE;

-

-   return GL_FALSE;

-}

-

-

-/**

- * Set the value of a program's uniform variable.

- * \param program  the program whose uniform to update

- * \param index  the index of the program parameter for the uniform

- * \param offset  additional parameter slot offset (for arrays)

- * \param type  the incoming datatype of 'values'

- * \param count  the number of uniforms to set

- * \param elems  number of elements per uniform (1, 2, 3 or 4)

- * \param values  the new values, of datatype 'type'

- */

-static void

-set_program_uniform(struct gl_context *ctx, struct gl_program *program,

-                    GLint index, GLint offset,

-                    GLenum type, GLsizei count, GLint elems,

-                    const void *values)

-{

-   const struct gl_program_parameter *param =

-      &program->Parameters->Parameters[index];

-

-   assert(offset >= 0);

-   assert(elems >= 1);

-   assert(elems <= 4);

-

-   if (!compatible_types(type, param->DataType)) {

-      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(type mismatch)");

-      return;

-   }

-

-   if (index + offset > (GLint) program->Parameters->Size) {

-      /* out of bounds! */

-      return;

-   }

-

-   if (param->Type == PROGRAM_SAMPLER) {

-      /* This controls which texture unit which is used by a sampler */

-      GLboolean changed = GL_FALSE;

-      GLint i;

-

-      /* this should have been caught by the compatible_types() check */

-      ASSERT(type == GL_INT);

-

-      /* loop over number of samplers to change */

-      for (i = 0; i < count; i++) {

-         GLuint sampler =

-            (GLuint) program->Parameters->ParameterValues[index + offset + i][0];

-         GLuint texUnit = ((GLuint *) values)[i];

-

-         /* check that the sampler (tex unit index) is legal */

-         if (texUnit >= ctx->Const.MaxTextureImageUnits) {

-            _mesa_error(ctx, GL_INVALID_VALUE,

-                        "glUniform1(invalid sampler/tex unit index for '%s')",

-                        param->Name);

-            return;

-         }

-

-         /* This maps a sampler to a texture unit: */

-         if (sampler < MAX_SAMPLERS) {

-#if 0

-            printf("Set program %p sampler %d '%s' to unit %u\n",

-		   program, sampler, param->Name, texUnit);

-#endif

-            if (program->SamplerUnits[sampler] != texUnit) {

-               program->SamplerUnits[sampler] = texUnit;

-               changed = GL_TRUE;

-            }

-         }

-      }

-

-      if (changed) {

-         /* When a sampler's value changes it usually requires rewriting

-          * a GPU program's TEX instructions since there may not be a

-          * sampler->texture lookup table.  We signal this with the

-          * ProgramStringNotify() callback.

-          */

-         FLUSH_VERTICES(ctx, _NEW_TEXTURE | _NEW_PROGRAM);

-         _mesa_update_shader_textures_used(program);

-         /* Do we need to care about the return value here?

-          * This should not be the first time the driver was notified of

-          * this program.

-          */

-         (void) ctx->Driver.ProgramStringNotify(ctx, program->Target, program);

-      }

-   }

-   else {

-      /* ordinary uniform variable */

-      const GLboolean isUniformBool = is_boolean_type(param->DataType);

-      const GLenum basicType = base_uniform_type(type);

-      const GLint slots = (param->Size + 3) / 4;

-      const GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);

-      GLsizei k, i;

-

-      if ((GLint) param->Size > typeSize) {

-         /* an array */

-         /* we'll ignore extra data below */

-      }

-      else {

-         /* non-array: count must be at most one; count == 0 is handled by the loop below */

-         if (count > 1) {

-            _mesa_error(ctx, GL_INVALID_OPERATION,

-                        "glUniform(uniform '%s' is not an array)",

-                        param->Name);

-            return;

-         }

-      }

-

-      /* loop over number of array elements */

-      for (k = 0; k < count; k++) {

-         GLfloat *uniformVal;

-

-         if (offset + k >= slots) {

-            /* Extra array data is ignored */

-            break;

-         }

-

-         /* uniformVal (the destination) is always float[4] */

-         uniformVal = program->Parameters->ParameterValues[index + offset + k];

-

-         if (basicType == GL_INT) {

-            /* convert user's ints to floats */

-            const GLint *iValues = ((const GLint *) values) + k * elems;

-            for (i = 0; i < elems; i++) {

-               uniformVal[i] = (GLfloat) iValues[i];

-            }

-         }

-         else if (basicType == GL_UNSIGNED_INT) {

-            /* convert user's uints to floats */

-            const GLuint *iValues = ((const GLuint *) values) + k * elems;

-            for (i = 0; i < elems; i++) {

-               uniformVal[i] = (GLfloat) iValues[i];

-            }

-         }

-         else {

-            const GLfloat *fValues = ((const GLfloat *) values) + k * elems;

-            assert(basicType == GL_FLOAT);

-            for (i = 0; i < elems; i++) {

-               uniformVal[i] = fValues[i];

-            }

-         }

-

-         /* if the uniform is bool-valued, convert to 1.0 or 0.0 */

-         if (isUniformBool) {

-            for (i = 0; i < elems; i++) {

-               uniformVal[i] = uniformVal[i] ? 1.0f : 0.0f;

-            }

-         }

-      }

-   }

-}

-

-

-/**

- * Called via glUniform*() functions.

- */

-void

-_mesa_uniform(struct gl_context *ctx, struct gl_shader_program *shProg,

-	      GLint location, GLsizei count,

-              const GLvoid *values, GLenum type)

-{

-   struct gl_uniform *uniform;

-   GLint elems, offset;

-

-   if (!shProg || !shProg->LinkStatus) {

-      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(program not linked)");

-      return;

-   }

-

-   if (location == -1)

-      return;   /* The standard specifies this as a no-op */

-

-   if (location < -1) {

-      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(location=%d)",

-                  location);

-      return;

-   }

-

-   split_location_offset(&location, &offset);

-

-   if (location < 0 || location >= (GLint) shProg->Uniforms->NumUniforms) {

-      _mesa_error(ctx, GL_INVALID_VALUE, "glUniform(location=%d)", location);

-      return;

-   }

-

-   if (count < 0) {

-      _mesa_error(ctx, GL_INVALID_VALUE, "glUniform(count < 0)");

-      return;

-   }

-

-   elems = _mesa_sizeof_glsl_type(type);

-

-   FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);

-

-   uniform = &shProg->Uniforms->Uniforms[location];

-

-   if (ctx->Shader.Flags & GLSL_UNIFORMS) {

-      const GLenum basicType = base_uniform_type(type);

-      GLint i;

-      printf("Mesa: set program %u uniform %s (loc %d) to: ",

-	     shProg->Name, uniform->Name, location);

-      if (basicType == GL_INT) {

-         const GLint *v = (const GLint *) values;

-         for (i = 0; i < count * elems; i++) {

-            printf("%d ", v[i]);

-         }

-      }

-      else if (basicType == GL_UNSIGNED_INT) {

-         const GLuint *v = (const GLuint *) values;

-         for (i = 0; i < count * elems; i++) {

-            printf("%u ", v[i]);

-         }

-      }

-      else {

-         const GLfloat *v = (const GLfloat *) values;

-         assert(basicType == GL_FLOAT);

-         for (i = 0; i < count * elems; i++) {

-            printf("%g ", v[i]);

-         }

-      }

-      printf("\n");

-   }

-

-   /* A uniform var may be used by both a vertex shader and a fragment

-    * shader.  We may need to update one or both shader's uniform here:

-    */

-   if (shProg->VertexProgram) {

-      /* convert uniform location to program parameter index */

-      GLint index = uniform->VertPos;

-      if (index >= 0) {

-         set_program_uniform(ctx, &shProg->VertexProgram->Base,

-                             index, offset, type, count, elems, values);

-      }

-   }

-

-   if (shProg->FragmentProgram) {

-      /* convert uniform location to program parameter index */

-      GLint index = uniform->FragPos;

-      if (index >= 0) {

-         set_program_uniform(ctx, &shProg->FragmentProgram->Base,

-                             index, offset, type, count, elems, values);

-      }

-   }

-

-   if (shProg->GeometryProgram) {

-      /* convert uniform location to program parameter index */

-      GLint index = uniform->GeomPos;

-      if (index >= 0) {

-         set_program_uniform(ctx, &shProg->GeometryProgram->Base,

-                             index, offset, type, count, elems, values);

-      }

-   }

-

-   uniform->Initialized = GL_TRUE;

-}

-

-

-/**

- * Set a matrix-valued program parameter.

- */

-static void

-set_program_uniform_matrix(struct gl_context *ctx, struct gl_program *program,

-                           GLuint index, GLuint offset,

-                           GLuint count, GLuint rows, GLuint cols,

-                           GLboolean transpose, const GLfloat *values)

-{

-   GLuint mat, row, col;

-   GLuint src = 0;

-   const struct gl_program_parameter * param = &program->Parameters->Parameters[index];

-   const GLuint slots = (param->Size + 3) / 4;

-   const GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);

-   GLint nr, nc;

-

-   /* check that the number of rows, columns is correct */

-   get_matrix_dims(param->DataType, &nr, &nc);

-   if (rows != nr || cols != nc) {

-      _mesa_error(ctx, GL_INVALID_OPERATION,

-                  "glUniformMatrix(matrix size mismatch)");

-      return;

-   }

-

-   if ((GLint) param->Size <= typeSize) {

-      /* non-array: count must be at most one; count == 0 is handled by the loop below */

-      if (count > 1) {

-         _mesa_error(ctx, GL_INVALID_OPERATION,

-                     "glUniformMatrix(uniform is not an array)");

-         return;

-      }

-   }

-

-   /*

-    * Note: the _columns_ of a matrix are stored in program registers, not

-    * the rows.  So, the loops below look a little funny.

-    * XXX could optimize this a bit...

-    */

-

-   /* loop over matrices */

-   for (mat = 0; mat < count; mat++) {

-

-      /* each matrix: */

-      for (col = 0; col < cols; col++) {

-         GLfloat *v;

-         if (offset >= slots) {

-            /* Ignore writes beyond the end of (the used part of) an array */

-            return;

-         }

-         v = program->Parameters->ParameterValues[index + offset];

-         for (row = 0; row < rows; row++) {

-            if (transpose) {

-               v[row] = values[src + row * cols + col];

-            }

-            else {

-               v[row] = values[src + col * rows + row];

-            }

-         }

-

-         offset++;

-      }

-

-      src += rows * cols;  /* next matrix */

-   }

-}

-

-

-/**

- * Called by glUniformMatrix*() functions.

- * Note: cols=2, rows=4  ==>  array[2] of vec4

- */

-void

-_mesa_uniform_matrix(struct gl_context *ctx, struct gl_shader_program *shProg,

-		     GLint cols, GLint rows,

-                     GLint location, GLsizei count,

-                     GLboolean transpose, const GLfloat *values)

-{

-   struct gl_uniform *uniform;

-   GLint offset;

-

-   if (!shProg || !shProg->LinkStatus) {

-      _mesa_error(ctx, GL_INVALID_OPERATION,

-         "glUniformMatrix(program not linked)");

-      return;

-   }

-

-   if (location == -1)

-      return;   /* The standard specifies this as a no-op */

-

-   if (location < -1) {

-      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniformMatrix(location)");

-      return;

-   }

-

-   split_location_offset(&location, &offset);

-

-   if (location < 0 || location >= (GLint) shProg->Uniforms->NumUniforms) {

-      _mesa_error(ctx, GL_INVALID_VALUE, "glUniformMatrix(location)");

-      return;

-   }

-   if (values == NULL) {

-      _mesa_error(ctx, GL_INVALID_VALUE, "glUniformMatrix");

-      return;

-   }

-

-   FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);

-

-   uniform = &shProg->Uniforms->Uniforms[location];

-

-   if (shProg->VertexProgram) {

-      /* convert uniform location to program parameter index */

-      GLint index = uniform->VertPos;

-      if (index >= 0) {

-         set_program_uniform_matrix(ctx, &shProg->VertexProgram->Base,

-                                    index, offset,

-                                    count, rows, cols, transpose, values);

-      }

-   }

-

-   if (shProg->FragmentProgram) {

-      /* convert uniform location to program parameter index */

-      GLint index = uniform->FragPos;

-      if (index >= 0) {

-         set_program_uniform_matrix(ctx, &shProg->FragmentProgram->Base,

-                                    index, offset,

-                                    count, rows, cols, transpose, values);

-      }

-   }

-

-   if (shProg->GeometryProgram) {

-      /* convert uniform location to program parameter index */

-      GLint index = uniform->GeomPos;

-      if (index >= 0) {

-         set_program_uniform_matrix(ctx, &shProg->GeometryProgram->Base,

-                                    index, offset,

-                                    count, rows, cols, transpose, values);

-      }

-   }

-

-   uniform->Initialized = GL_TRUE;

-}

-

-

-void GLAPIENTRY

-_mesa_Uniform1fARB(GLint location, GLfloat v0)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, &v0, GL_FLOAT);

-}

-

-void GLAPIENTRY

-_mesa_Uniform2fARB(GLint location, GLfloat v0, GLfloat v1)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   GLfloat v[2];

-   v[0] = v0;

-   v[1] = v1;

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_FLOAT_VEC2);

-}

-

-void GLAPIENTRY

-_mesa_Uniform3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   GLfloat v[3];

-   v[0] = v0;

-   v[1] = v1;

-   v[2] = v2;

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_FLOAT_VEC3);

-}

-

-void GLAPIENTRY

-_mesa_Uniform4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2,

-                   GLfloat v3)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   GLfloat v[4];

-   v[0] = v0;

-   v[1] = v1;

-   v[2] = v2;

-   v[3] = v3;

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_FLOAT_VEC4);

-}

-

-void GLAPIENTRY

-_mesa_Uniform1iARB(GLint location, GLint v0)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, &v0, GL_INT);

-}

-

-void GLAPIENTRY

-_mesa_Uniform2iARB(GLint location, GLint v0, GLint v1)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   GLint v[2];

-   v[0] = v0;

-   v[1] = v1;

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_INT_VEC2);

-}

-

-void GLAPIENTRY

-_mesa_Uniform3iARB(GLint location, GLint v0, GLint v1, GLint v2)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   GLint v[3];

-   v[0] = v0;

-   v[1] = v1;

-   v[2] = v2;

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_INT_VEC3);

-}

-

-void GLAPIENTRY

-_mesa_Uniform4iARB(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   GLint v[4];

-   v[0] = v0;

-   v[1] = v1;

-   v[2] = v2;

-   v[3] = v3;

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_INT_VEC4);

-}

-

-void GLAPIENTRY

-_mesa_Uniform1fvARB(GLint location, GLsizei count, const GLfloat * value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT);

-}

-

-void GLAPIENTRY

-_mesa_Uniform2fvARB(GLint location, GLsizei count, const GLfloat * value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT_VEC2);

-}

-

-void GLAPIENTRY

-_mesa_Uniform3fvARB(GLint location, GLsizei count, const GLfloat * value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT_VEC3);

-}

-

-void GLAPIENTRY

-_mesa_Uniform4fvARB(GLint location, GLsizei count, const GLfloat * value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT_VEC4);

-}

-

-void GLAPIENTRY

-_mesa_Uniform1ivARB(GLint location, GLsizei count, const GLint * value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT);

-}

-

-void GLAPIENTRY

-_mesa_Uniform2ivARB(GLint location, GLsizei count, const GLint * value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT_VEC2);

-}

-

-void GLAPIENTRY

-_mesa_Uniform3ivARB(GLint location, GLsizei count, const GLint * value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT_VEC3);

-}

-

-void GLAPIENTRY

-_mesa_Uniform4ivARB(GLint location, GLsizei count, const GLint * value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT_VEC4);

-}

-

-

-/** OpenGL 3.0 GLuint-valued functions **/

-void GLAPIENTRY

-_mesa_Uniform1ui(GLint location, GLuint v0)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, &v0, GL_UNSIGNED_INT);

-}

-

-void GLAPIENTRY

-_mesa_Uniform2ui(GLint location, GLuint v0, GLuint v1)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   GLuint v[2];

-   v[0] = v0;

-   v[1] = v1;

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC2);

-}

-

-void GLAPIENTRY

-_mesa_Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   GLuint v[3];

-   v[0] = v0;

-   v[1] = v1;

-   v[2] = v2;

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC3);

-}

-

-void GLAPIENTRY

-_mesa_Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   GLuint v[4];

-   v[0] = v0;

-   v[1] = v1;

-   v[2] = v2;

-   v[3] = v3;

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC4);

-}

-

-void GLAPIENTRY

-_mesa_Uniform1uiv(GLint location, GLsizei count, const GLuint *value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT);

-}

-

-void GLAPIENTRY

-_mesa_Uniform2uiv(GLint location, GLsizei count, const GLuint *value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC2);

-}

-

-void GLAPIENTRY

-_mesa_Uniform3uiv(GLint location, GLsizei count, const GLuint *value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC3);

-}

-

-void GLAPIENTRY

-_mesa_Uniform4uiv(GLint location, GLsizei count, const GLuint *value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC4);

-}

-

-

-

-void GLAPIENTRY

-_mesa_UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose,

-                          const GLfloat * value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,

-			2, 2, location, count, transpose, value);

-}

-

-void GLAPIENTRY

-_mesa_UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose,

-                          const GLfloat * value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,

-			3, 3, location, count, transpose, value);

-}

-

-void GLAPIENTRY

-_mesa_UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose,

-                          const GLfloat * value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,

-			4, 4, location, count, transpose, value);

-}

-

-

-/**

- * Non-square UniformMatrix are OpenGL 2.1

- */

-void GLAPIENTRY

-_mesa_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,

-                         const GLfloat *value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,

-			2, 3, location, count, transpose, value);

-}

-

-void GLAPIENTRY

-_mesa_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,

-                         const GLfloat *value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,

-			3, 2, location, count, transpose, value);

-}

-

-void GLAPIENTRY

-_mesa_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,

-                         const GLfloat *value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,

-			2, 4, location, count, transpose, value);

-}

-

-void GLAPIENTRY

-_mesa_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,

-                         const GLfloat *value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,

-			4, 2, location, count, transpose, value);

-}

-

-void GLAPIENTRY

-_mesa_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,

-                         const GLfloat *value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,

-			3, 4, location, count, transpose, value);

-}

-

-void GLAPIENTRY

-_mesa_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,

-                         const GLfloat *value)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,

-			4, 3, location, count, transpose, value);

-}

-

-

-void GLAPIENTRY

-_mesa_GetUniformfvARB(GLhandleARB program, GLint location, GLfloat *params)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_get_uniformfv(ctx, program, location, params);

-}

-

-

-void GLAPIENTRY

-_mesa_GetUniformivARB(GLhandleARB program, GLint location, GLint *params)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_get_uniformiv(ctx, program, location, params);

-}

-

-

-/* GL3 */

-void GLAPIENTRY

-_mesa_GetUniformuiv(GLhandleARB program, GLint location, GLuint *params)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_get_uniformuiv(ctx, program, location, params);

-}

-

-

-

-GLint GLAPIENTRY

-_mesa_GetUniformLocationARB(GLhandleARB programObj, const GLcharARB *name)

-{

-   struct gl_shader_program *shProg;

-

-   GET_CURRENT_CONTEXT(ctx);

-

-   shProg = _mesa_lookup_shader_program_err(ctx, programObj,

-					    "glGetUniformLocation");

-   if (!shProg)

-      return -1;

-

-   return _mesa_get_uniform_location(ctx, shProg, name);

-}

-

-

-void GLAPIENTRY

-_mesa_GetActiveUniformARB(GLhandleARB program, GLuint index,

-                          GLsizei maxLength, GLsizei * length, GLint * size,

-                          GLenum * type, GLcharARB * name)

-{

-   GET_CURRENT_CONTEXT(ctx);

-   _mesa_get_active_uniform(ctx, program, index, maxLength, length, size,

-                            type, name);

-}

-

-

-/**

- * Plug in shader uniform-related functions into API dispatch table.

- */

-void

-_mesa_init_shader_uniform_dispatch(struct _glapi_table *exec)

-{

-#if FEATURE_GL

-   SET_Uniform1fARB(exec, _mesa_Uniform1fARB);

-   SET_Uniform2fARB(exec, _mesa_Uniform2fARB);

-   SET_Uniform3fARB(exec, _mesa_Uniform3fARB);

-   SET_Uniform4fARB(exec, _mesa_Uniform4fARB);

-   SET_Uniform1iARB(exec, _mesa_Uniform1iARB);

-   SET_Uniform2iARB(exec, _mesa_Uniform2iARB);

-   SET_Uniform3iARB(exec, _mesa_Uniform3iARB);

-   SET_Uniform4iARB(exec, _mesa_Uniform4iARB);

-   SET_Uniform1fvARB(exec, _mesa_Uniform1fvARB);

-   SET_Uniform2fvARB(exec, _mesa_Uniform2fvARB);

-   SET_Uniform3fvARB(exec, _mesa_Uniform3fvARB);

-   SET_Uniform4fvARB(exec, _mesa_Uniform4fvARB);

-   SET_Uniform1ivARB(exec, _mesa_Uniform1ivARB);

-   SET_Uniform2ivARB(exec, _mesa_Uniform2ivARB);

-   SET_Uniform3ivARB(exec, _mesa_Uniform3ivARB);

-   SET_Uniform4ivARB(exec, _mesa_Uniform4ivARB);

-   SET_UniformMatrix2fvARB(exec, _mesa_UniformMatrix2fvARB);

-   SET_UniformMatrix3fvARB(exec, _mesa_UniformMatrix3fvARB);

-   SET_UniformMatrix4fvARB(exec, _mesa_UniformMatrix4fvARB);

-

-   SET_GetActiveUniformARB(exec, _mesa_GetActiveUniformARB);

-   SET_GetUniformLocationARB(exec, _mesa_GetUniformLocationARB);

-   SET_GetUniformfvARB(exec, _mesa_GetUniformfvARB);

-   SET_GetUniformivARB(exec, _mesa_GetUniformivARB);

-

-   /* OpenGL 2.1 */

-   SET_UniformMatrix2x3fv(exec, _mesa_UniformMatrix2x3fv);

-   SET_UniformMatrix3x2fv(exec, _mesa_UniformMatrix3x2fv);

-   SET_UniformMatrix2x4fv(exec, _mesa_UniformMatrix2x4fv);

-   SET_UniformMatrix4x2fv(exec, _mesa_UniformMatrix4x2fv);

-   SET_UniformMatrix3x4fv(exec, _mesa_UniformMatrix3x4fv);

-   SET_UniformMatrix4x3fv(exec, _mesa_UniformMatrix4x3fv);

-

-   /* OpenGL 3.0 */

-   /* XXX finish dispatch */

-   SET_Uniform1uiEXT(exec, _mesa_Uniform1ui);

-   SET_Uniform2uiEXT(exec, _mesa_Uniform2ui);

-   SET_Uniform3uiEXT(exec, _mesa_Uniform3ui);

-   SET_Uniform4uiEXT(exec, _mesa_Uniform4ui);

-   SET_Uniform1uivEXT(exec, _mesa_Uniform1uiv);

-   SET_Uniform2uivEXT(exec, _mesa_Uniform2uiv);

-   SET_Uniform3uivEXT(exec, _mesa_Uniform3uiv);

-   SET_Uniform4uivEXT(exec, _mesa_Uniform4uiv);

-   SET_GetUniformuivEXT(exec, _mesa_GetUniformuiv);

-

-

-#endif /* FEATURE_GL */

-}

+/*
+ * Mesa 3-D graphics library
+ *
+ * Copyright (C) 2004-2008  Brian Paul   All Rights Reserved.
+ * Copyright (C) 2009-2010  VMware, Inc.  All Rights Reserved.
+ * Copyright © 2010 Intel Corporation
+ *
+ * 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.
+ */
+
+/**
+ * \file uniforms.c
+ * Functions related to GLSL uniform variables.
+ * \author Brian Paul
+ */
+
+/**
+ * XXX things to do:
+ * 1. Check that the right error code is generated for all _mesa_error() calls.
+ * 2. Insert FLUSH_VERTICES calls in various places
+ */
+
+
+#include "main/glheader.h"
+#include "main/context.h"
+#include "main/dispatch.h"
+#include "main/mfeatures.h"
+#include "main/mtypes.h"
+#include "main/shaderapi.h"
+#include "main/shaderobj.h"
+#include "main/uniforms.h"
+#include "program/prog_parameter.h"
+#include "program/prog_statevars.h"
+#include "program/prog_uniform.h"
+#include "program/prog_instruction.h"
+
+
+static GLenum
+base_uniform_type(GLenum type)
+{
+   switch (type) {
+#if 0 /* not needed, for now */
+   case GL_BOOL:
+   case GL_BOOL_VEC2:
+   case GL_BOOL_VEC3:
+   case GL_BOOL_VEC4:
+      return GL_BOOL;
+#endif
+   case GL_FLOAT:
+   case GL_FLOAT_VEC2:
+   case GL_FLOAT_VEC3:
+   case GL_FLOAT_VEC4:
+      return GL_FLOAT;
+   case GL_UNSIGNED_INT:
+   case GL_UNSIGNED_INT_VEC2:
+   case GL_UNSIGNED_INT_VEC3:
+   case GL_UNSIGNED_INT_VEC4:
+      return GL_UNSIGNED_INT;
+   case GL_INT:
+   case GL_INT_VEC2:
+   case GL_INT_VEC3:
+   case GL_INT_VEC4:
+      return GL_INT;
+   default:
+      _mesa_problem(NULL, "Invalid type in base_uniform_type()");
+      return GL_FLOAT;
+   }
+}
+
+
+static GLboolean
+is_boolean_type(GLenum type)
+{
+   switch (type) {
+   case GL_BOOL:
+   case GL_BOOL_VEC2:
+   case GL_BOOL_VEC3:
+   case GL_BOOL_VEC4:
+      return GL_TRUE;
+   default:
+      return GL_FALSE;
+   }
+}
+
+
+static GLboolean
+is_sampler_type(GLenum type)
+{
+   switch (type) {
+   case GL_SAMPLER_1D:
+   case GL_SAMPLER_2D:
+   case GL_SAMPLER_3D:
+   case GL_SAMPLER_CUBE:
+   case GL_SAMPLER_1D_SHADOW:
+   case GL_SAMPLER_2D_SHADOW:
+   case GL_SAMPLER_2D_RECT_ARB:
+   case GL_SAMPLER_2D_RECT_SHADOW_ARB:
+   case GL_SAMPLER_1D_ARRAY_EXT:
+   case GL_SAMPLER_2D_ARRAY_EXT:
+   case GL_SAMPLER_1D_ARRAY_SHADOW_EXT:
+   case GL_SAMPLER_2D_ARRAY_SHADOW_EXT:
+      return GL_TRUE;
+   default:
+      return GL_FALSE;
+   }
+}
+
+
+static struct gl_program_parameter *
+get_uniform_parameter(const struct gl_shader_program *shProg, GLuint index)
+{
+   const struct gl_program *prog = NULL;
+   GLint progPos;
+
+   progPos = shProg->Uniforms->Uniforms[index].VertPos;
+   if (progPos >= 0) {
+      prog = &shProg->VertexProgram->Base;
+   }
+   else {
+      progPos = shProg->Uniforms->Uniforms[index].FragPos;
+      if (progPos >= 0) {
+         prog = &shProg->FragmentProgram->Base;
+      } else {
+         progPos = shProg->Uniforms->Uniforms[index].GeomPos;
+         if (progPos >= 0) {
+            prog = &shProg->GeometryProgram->Base;
+         }
+      }
+   }
+
+   if (!prog || progPos < 0)
+      return NULL; /* should never happen */
+
+   return &prog->Parameters->Parameters[progPos];
+}
+
+
+/**
+ * Called by glGetActiveUniform().
+ */
+static void
+_mesa_get_active_uniform(struct gl_context *ctx, GLuint program, GLuint index,
+                         GLsizei maxLength, GLsizei *length, GLint *size,
+                         GLenum *type, GLchar *nameOut)
+{
+   const struct gl_shader_program *shProg;
+   const struct gl_program *prog = NULL;
+   const struct gl_program_parameter *param;
+   GLint progPos;
+
+   shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniform");
+   if (!shProg)
+      return;
+
+   if (!shProg->Uniforms || index >= shProg->Uniforms->NumUniforms) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");
+      return;
+   }
+
+   progPos = shProg->Uniforms->Uniforms[index].VertPos;
+   if (progPos >= 0) {
+      prog = &shProg->VertexProgram->Base;
+   }
+   else {
+      progPos = shProg->Uniforms->Uniforms[index].FragPos;
+      if (progPos >= 0) {
+         prog = &shProg->FragmentProgram->Base;
+      } else {
+         progPos = shProg->Uniforms->Uniforms[index].GeomPos;
+         if (progPos >= 0) {
+            prog = &shProg->GeometryProgram->Base;
+         }
+      }
+   }
+
+   if (!prog || progPos < 0)
+      return; /* should never happen */
+
+   ASSERT(progPos < prog->Parameters->NumParameters);
+   param = &prog->Parameters->Parameters[progPos];
+
+   if (nameOut) {
+      _mesa_copy_string(nameOut, maxLength, length, param->Name);
+   }
+
+   if (size) {
+      GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);
+      if ((GLint) param->Size > typeSize) {
+         /* This is an array.
+          * Array elements are placed on vector[4] boundaries so they're
+          * a multiple of four floats.  We round typeSize up to next multiple
+          * of four to get the right size below.
+          */
+         typeSize = (typeSize + 3) & ~3;
+      }
+      /* Note that the returned size is in units of the <type>, not bytes */
+      *size = param->Size / typeSize;
+   }
+
+   if (type) {
+      *type = param->DataType;
+   }
+}
+
+
+static unsigned
+get_vector_elements(GLenum type)
+{
+   switch (type) {
+   case GL_FLOAT:
+   case GL_INT:
+   case GL_BOOL:
+   case GL_UNSIGNED_INT:
+   default: /* Catch all the various sampler types. */
+      return 1;
+
+   case GL_FLOAT_VEC2:
+   case GL_INT_VEC2:
+   case GL_BOOL_VEC2:
+   case GL_UNSIGNED_INT_VEC2:
+      return 2;
+
+   case GL_FLOAT_VEC3:
+   case GL_INT_VEC3:
+   case GL_BOOL_VEC3:
+   case GL_UNSIGNED_INT_VEC3:
+      return 3;
+
+   case GL_FLOAT_VEC4:
+   case GL_INT_VEC4:
+   case GL_BOOL_VEC4:
+   case GL_UNSIGNED_INT_VEC4:
+      return 4;
+   }
+}
+
+static void
+get_matrix_dims(GLenum type, GLint *rows, GLint *cols)
+{
+   switch (type) {
+   case GL_FLOAT_MAT2:
+      *rows = *cols = 2;
+      break;
+   case GL_FLOAT_MAT2x3:
+      *rows = 3;
+      *cols = 2;
+      break;
+   case GL_FLOAT_MAT2x4:
+      *rows = 4;
+      *cols = 2;
+      break;
+   case GL_FLOAT_MAT3:
+      *rows = 3;
+      *cols = 3;
+      break;
+   case GL_FLOAT_MAT3x2:
+      *rows = 2;
+      *cols = 3;
+      break;
+   case GL_FLOAT_MAT3x4:
+      *rows = 4;
+      *cols = 3;
+      break;
+   case GL_FLOAT_MAT4:
+      *rows = 4;
+      *cols = 4;
+      break;
+   case GL_FLOAT_MAT4x2:
+      *rows = 2;
+      *cols = 4;
+      break;
+   case GL_FLOAT_MAT4x3:
+      *rows = 3;
+      *cols = 4;
+      break;
+   default:
+      *rows = *cols = 0;
+   }
+}
+
+
+/**
+ * Determine the number of rows and columns occupied by a uniform
+ * according to its datatype.  For non-matrix types (such as GL_FLOAT_VEC4),
+ * the number of rows = 1 and cols = number of elements in the vector.
+ */
+static void
+get_uniform_rows_cols(const struct gl_program_parameter *p,
+                      GLint *rows, GLint *cols)
+{
+   get_matrix_dims(p->DataType, rows, cols);
+   if (*rows == 0 && *cols == 0) {
+      /* not a matrix type, probably a float or vector */
+      *rows = 1;
+      *cols = get_vector_elements(p->DataType);
+   }
+}
+
+
+/**
+ * Helper for get_uniform[fi]v() functions.
+ * Given a shader program name and uniform location, return a pointer
+ * to the shader program and return the program parameter position.
+ */
+static void
+lookup_uniform_parameter(struct gl_context *ctx, GLuint program, GLint location,
+                         struct gl_program **progOut, GLint *paramPosOut)
+{
+   struct gl_shader_program *shProg
+      = _mesa_lookup_shader_program_err(ctx, program, "glGetUniform[if]v");
+   struct gl_program *prog = NULL;
+   GLint progPos = -1;
+
+   /* if shProg is NULL, we'll have already recorded an error */
+
+   if (shProg) {
+      if (!shProg->Uniforms ||
+          location < 0 ||
+          location >= (GLint) shProg->Uniforms->NumUniforms) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,  "glGetUniformfv(location)");
+      }
+      else {
+         /* OK, find the gl_program and program parameter location */
+         progPos = shProg->Uniforms->Uniforms[location].VertPos;
+         if (progPos >= 0) {
+            prog = &shProg->VertexProgram->Base;
+         }
+         else {
+            progPos = shProg->Uniforms->Uniforms[location].FragPos;
+            if (progPos >= 0) {
+               prog = &shProg->FragmentProgram->Base;
+            } else {
+               progPos = shProg->Uniforms->Uniforms[location].GeomPos;
+               if (progPos >= 0) {
+                  prog = &shProg->GeometryProgram->Base;
+               }
+            }
+         }
+      }
+   }
+
+   *progOut = prog;
+   *paramPosOut = progPos;
+}
+
+
+/**
+ * GLGL uniform arrays and structs require special handling.
+ *
+ * The GL_ARB_shader_objects spec says that if you use
+ * glGetUniformLocation to get the location of an array, you CANNOT
+ * access other elements of the array by adding an offset to the
+ * returned location.  For example, you must call
+ * glGetUniformLocation("foo[16]") if you want to set the 16th element
+ * of the array with glUniform().
+ *
+ * HOWEVER, some other OpenGL drivers allow accessing array elements
+ * by adding an offset to the returned array location.  And some apps
+ * seem to depend on that behaviour.
+ *
+ * Mesa's gl_uniform_list doesn't directly support this since each
+ * entry in the list describes one uniform variable, not one uniform
+ * element.  We could insert dummy entries in the list for each array
+ * element after [0] but that causes complications elsewhere.
+ *
+ * We solve this problem by encoding two values in the location that's
+ * returned by glGetUniformLocation():
+ *  a) index into gl_uniform_list::Uniforms[] for the uniform
+ *  b) an array/field offset (0 for simple types)
+ *
+ * These two values are encoded in the high and low halves of a GLint.
+ * By putting the uniform number in the high part and the offset in the
+ * low part, we can support the unofficial ability to index into arrays
+ * by adding offsets to the location value.
+ */
+static void
+merge_location_offset(GLint *location, GLint offset)
+{
+   *location = (*location << 16) | offset;
+}
+
+
+/**
+ * Separate the uniform location and parameter offset.  See above.
+ */
+static void
+split_location_offset(GLint *location, GLint *offset)
+{
+   *offset = *location & 0xffff;
+   *location = *location >> 16;
+}
+
+
+
+/**
+ * Called via glGetUniformfv().
+ */
+static void
+_mesa_get_uniformfv(struct gl_context *ctx, GLuint program, GLint location,
+                    GLfloat *params)
+{
+   struct gl_program *prog;
+   GLint paramPos;
+   GLint offset;
+
+   split_location_offset(&location, &offset);
+
+   lookup_uniform_parameter(ctx, program, location, &prog, &paramPos);
+
+   if (prog) {
+      const struct gl_program_parameter *p =
+         &prog->Parameters->Parameters[paramPos];
+      GLint rows, cols, i, j, k;
+
+      get_uniform_rows_cols(p, &rows, &cols);
+
+      k = 0;
+      for (i = 0; i < rows; i++) {
+	 const int base = paramPos + offset + i;
+
+         for (j = 0; j < cols; j++ ) {
+            params[k++] = prog->Parameters->ParameterValues[base][j];
+         }
+      }
+   }
+}
+
+
+/**
+ * Called via glGetUniformiv().
+ * \sa _mesa_get_uniformfv, only difference is a cast.
+ */
+static void
+_mesa_get_uniformiv(struct gl_context *ctx, GLuint program, GLint location,
+                    GLint *params)
+{
+   struct gl_program *prog;
+   GLint paramPos;
+   GLint offset;
+
+   split_location_offset(&location, &offset);
+
+   lookup_uniform_parameter(ctx, program, location, &prog, &paramPos);
+
+   if (prog) {
+      const struct gl_program_parameter *p =
+         &prog->Parameters->Parameters[paramPos];
+      GLint rows, cols, i, j, k;
+
+      get_uniform_rows_cols(p, &rows, &cols);
+
+      k = 0;
+      for (i = 0; i < rows; i++) {
+	 const int base = paramPos + offset + i;
+
+         for (j = 0; j < cols; j++ ) {
+            params[k++] = (GLint) prog->Parameters->ParameterValues[base][j];
+         }
+      }
+   }
+}
+
+
+/**
+ * Called via glGetUniformuiv().
+ * New in GL_EXT_gpu_shader4, OpenGL 3.0
+ * \sa _mesa_get_uniformfv, only difference is a cast.
+ */
+static void
+_mesa_get_uniformuiv(struct gl_context *ctx, GLuint program, GLint location,
+                     GLuint *params)
+{
+   struct gl_program *prog;
+   GLint paramPos;
+   GLint offset;
+
+   split_location_offset(&location, &offset);
+
+   lookup_uniform_parameter(ctx, program, location, &prog, &paramPos);
+
+   if (prog) {
+      const struct gl_program_parameter *p =
+         &prog->Parameters->Parameters[paramPos];
+      GLint rows, cols, i, j, k;
+
+      get_uniform_rows_cols(p, &rows, &cols);
+
+      k = 0;
+      for (i = 0; i < rows; i++) {
+	 const int base = paramPos + offset + i;
+
+         for (j = 0; j < cols; j++ ) {
+            params[k++] = (GLuint) prog->Parameters->ParameterValues[base][j];
+         }
+      }
+   }
+}
+
+
+/**
+ * Called via glGetUniformLocation().
+ *
+ * The return value will encode two values, the uniform location and an
+ * offset (used for arrays, structs).
+ */
+GLint
+_mesa_get_uniform_location(struct gl_context *ctx, struct gl_shader_program *shProg,
+			   const GLchar *name)
+{
+   GLint offset = 0, location = -1;
+
+   if (shProg->LinkStatus == GL_FALSE) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformfv(program)");
+      return -1;
+   }
+
+   /* XXX we should return -1 if the uniform was declared, but not
+    * actually used.
+    */
+
+   /* XXX we need to be able to parse uniform names for structs and arrays
+    * such as:
+    *   mymatrix[1]
+    *   mystruct.field1
+    */
+
+   {
+      /* handle 1-dimension arrays here... */
+      char *c = strchr(name, '[');
+      if (c) {
+         /* truncate name at [ */
+         const GLint len = c - name;
+         GLchar *newName = malloc(len + 1);
+         if (!newName)
+            return -1; /* out of mem */
+         memcpy(newName, name, len);
+         newName[len] = 0;
+
+         location = _mesa_lookup_uniform(shProg->Uniforms, newName);
+         if (location >= 0) {
+            const GLint element = atoi(c + 1);
+            if (element > 0) {
+               /* get type of the uniform array element */
+               struct gl_program_parameter *p;
+               p = get_uniform_parameter(shProg, location);
+               if (p) {
+                  GLint rows, cols;
+                  get_matrix_dims(p->DataType, &rows, &cols);
+                  if (rows < 1)
+                     rows = 1;
+                  offset = element * rows;
+               }
+            }
+         }
+
+         free(newName);
+      }
+   }
+
+   if (location < 0) {
+      location = _mesa_lookup_uniform(shProg->Uniforms, name);
+   }
+
+   if (location >= 0) {
+      merge_location_offset(&location, offset);
+   }
+
+   return location;
+}
+
+
+
+/**
+ * Update the vertex/fragment program's TexturesUsed array.
+ *
+ * This needs to be called after glUniform(set sampler var) is called.
+ * A call to glUniform(samplerVar, value) causes a sampler to point to a
+ * particular texture unit.  We know the sampler's texture target
+ * (1D/2D/3D/etc) from compile time but the sampler's texture unit is
+ * set by glUniform() calls.
+ *
+ * So, scan the program->SamplerUnits[] and program->SamplerTargets[]
+ * information to update the prog->TexturesUsed[] values.
+ * Each value of TexturesUsed[unit] is one of zero, TEXTURE_1D_INDEX,
+ * TEXTURE_2D_INDEX, TEXTURE_3D_INDEX, etc.
+ * We'll use that info for state validation before rendering.
+ */
+void
+_mesa_update_shader_textures_used(struct gl_program *prog)
+{
+   GLuint s;
+
+   memset(prog->TexturesUsed, 0, sizeof(prog->TexturesUsed));
+
+   for (s = 0; s < MAX_SAMPLERS; s++) {
+      if (prog->SamplersUsed & (1 << s)) {
+         GLuint unit = prog->SamplerUnits[s];
+         GLuint tgt = prog->SamplerTargets[s];
+         assert(unit < MAX_TEXTURE_IMAGE_UNITS);
+         assert(tgt < NUM_TEXTURE_TARGETS);
+         prog->TexturesUsed[unit] |= (1 << tgt);
+      }
+   }
+}
+
+
+/**
+ * Check if the type given by userType is allowed to set a uniform of the
+ * target type.  Generally, equivalence is required, but setting Boolean
+ * uniforms can be done with glUniformiv or glUniformfv.
+ */
+static GLboolean
+compatible_types(GLenum userType, GLenum targetType)
+{
+   if (userType == targetType)
+      return GL_TRUE;
+
+   if (targetType == GL_BOOL && (userType == GL_FLOAT ||
+                                 userType == GL_UNSIGNED_INT ||
+                                 userType == GL_INT))
+      return GL_TRUE;
+
+   if (targetType == GL_BOOL_VEC2 && (userType == GL_FLOAT_VEC2 ||
+                                      userType == GL_UNSIGNED_INT_VEC2 ||
+                                      userType == GL_INT_VEC2))
+      return GL_TRUE;
+
+   if (targetType == GL_BOOL_VEC3 && (userType == GL_FLOAT_VEC3 ||
+                                      userType == GL_UNSIGNED_INT_VEC3 ||
+                                      userType == GL_INT_VEC3))
+      return GL_TRUE;
+
+   if (targetType == GL_BOOL_VEC4 && (userType == GL_FLOAT_VEC4 ||
+                                      userType == GL_UNSIGNED_INT_VEC4 ||
+                                      userType == GL_INT_VEC4))
+      return GL_TRUE;
+
+   if (is_sampler_type(targetType) && userType == GL_INT)
+      return GL_TRUE;
+
+   return GL_FALSE;
+}
+
+
+/**
+ * Set the value of a program's uniform variable.
+ * \param program  the program whose uniform to update
+ * \param index  the index of the program parameter for the uniform
+ * \param offset  additional parameter slot offset (for arrays)
+ * \param type  the incoming datatype of 'values'
+ * \param count  the number of uniforms to set
+ * \param elems  number of elements per uniform (1, 2, 3 or 4)
+ * \param values  the new values, of datatype 'type'
+ */
+static void
+set_program_uniform(struct gl_context *ctx, struct gl_program *program,
+                    GLint index, GLint offset,
+                    GLenum type, GLsizei count, GLint elems,
+                    const void *values)
+{
+   const struct gl_program_parameter *param =
+      &program->Parameters->Parameters[index];
+
+   assert(offset >= 0);
+   assert(elems >= 1);
+   assert(elems <= 4);
+
+   if (!compatible_types(type, param->DataType)) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(type mismatch)");
+      return;
+   }
+
+   if (index + offset > (GLint) program->Parameters->Size) {
+      /* out of bounds! */
+      return;
+   }
+
+   if (param->Type == PROGRAM_SAMPLER) {
+      /* This controls which texture unit which is used by a sampler */
+      GLboolean changed = GL_FALSE;
+      GLint i;
+
+      /* this should have been caught by the compatible_types() check */
+      ASSERT(type == GL_INT);
+
+      /* loop over number of samplers to change */
+      for (i = 0; i < count; i++) {
+         GLuint sampler =
+            (GLuint) program->Parameters->ParameterValues[index + offset + i][0];
+         GLuint texUnit = ((GLuint *) values)[i];
+
+         /* check that the sampler (tex unit index) is legal */
+         if (texUnit >= ctx->Const.MaxTextureImageUnits) {
+            _mesa_error(ctx, GL_INVALID_VALUE,
+                        "glUniform1(invalid sampler/tex unit index for '%s')",
+                        param->Name);
+            return;
+         }
+
+         /* This maps a sampler to a texture unit: */
+         if (sampler < MAX_SAMPLERS) {
+#if 0
+            printf("Set program %p sampler %d '%s' to unit %u\n",
+		   program, sampler, param->Name, texUnit);
+#endif
+            if (program->SamplerUnits[sampler] != texUnit) {
+               program->SamplerUnits[sampler] = texUnit;
+               changed = GL_TRUE;
+            }
+         }
+      }
+
+      if (changed) {
+         /* When a sampler's value changes it usually requires rewriting
+          * a GPU program's TEX instructions since there may not be a
+          * sampler->texture lookup table.  We signal this with the
+          * ProgramStringNotify() callback.
+          */
+         FLUSH_VERTICES(ctx, _NEW_TEXTURE | _NEW_PROGRAM);
+         _mesa_update_shader_textures_used(program);
+         /* Do we need to care about the return value here?
+          * This should not be the first time the driver was notified of
+          * this program.
+          */
+         (void) ctx->Driver.ProgramStringNotify(ctx, program->Target, program);
+      }
+   }
+   else {
+      /* ordinary uniform variable */
+      const GLboolean isUniformBool = is_boolean_type(param->DataType);
+      const GLenum basicType = base_uniform_type(type);
+      const GLint slots = (param->Size + 3) / 4;
+      const GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);
+      GLsizei k, i;
+
+      if ((GLint) param->Size > typeSize) {
+         /* an array */
+         /* we'll ignore extra data below */
+      }
+      else {
+         /* non-array: count must be at most one; count == 0 is handled by the loop below */
+         if (count > 1) {
+            _mesa_error(ctx, GL_INVALID_OPERATION,
+                        "glUniform(uniform '%s' is not an array)",
+                        param->Name);
+            return;
+         }
+      }
+
+      /* loop over number of array elements */
+      for (k = 0; k < count; k++) {
+         GLfloat *uniformVal;
+
+         if (offset + k >= slots) {
+            /* Extra array data is ignored */
+            break;
+         }
+
+         /* uniformVal (the destination) is always float[4] */
+         uniformVal = program->Parameters->ParameterValues[index + offset + k];
+
+         if (basicType == GL_INT) {
+            /* convert user's ints to floats */
+            const GLint *iValues = ((const GLint *) values) + k * elems;
+            for (i = 0; i < elems; i++) {
+               uniformVal[i] = (GLfloat) iValues[i];
+            }
+         }
+         else if (basicType == GL_UNSIGNED_INT) {
+            /* convert user's uints to floats */
+            const GLuint *iValues = ((const GLuint *) values) + k * elems;
+            for (i = 0; i < elems; i++) {
+               uniformVal[i] = (GLfloat) iValues[i];
+            }
+         }
+         else {
+            const GLfloat *fValues = ((const GLfloat *) values) + k * elems;
+            assert(basicType == GL_FLOAT);
+            for (i = 0; i < elems; i++) {
+               uniformVal[i] = fValues[i];
+            }
+         }
+
+         /* if the uniform is bool-valued, convert to 1.0 or 0.0 */
+         if (isUniformBool) {
+            for (i = 0; i < elems; i++) {
+               uniformVal[i] = uniformVal[i] ? 1.0f : 0.0f;
+            }
+         }
+      }
+   }
+}
+
+
+/**
+ * Called via glUniform*() functions.
+ */
+void
+_mesa_uniform(struct gl_context *ctx, struct gl_shader_program *shProg,
+	      GLint location, GLsizei count,
+              const GLvoid *values, GLenum type)
+{
+   struct gl_uniform *uniform;
+   GLint elems, offset;
+
+   if (!shProg || !shProg->LinkStatus) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(program not linked)");
+      return;
+   }
+
+   if (location == -1)
+      return;   /* The standard specifies this as a no-op */
+
+   if (location < -1) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(location=%d)",
+                  location);
+      return;
+   }
+
+   split_location_offset(&location, &offset);
+
+   if (location < 0 || location >= (GLint) shProg->Uniforms->NumUniforms) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glUniform(location=%d)", location);
+      return;
+   }
+
+   if (count < 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glUniform(count < 0)");
+      return;
+   }
+
+   elems = _mesa_sizeof_glsl_type(type);
+
+   FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);
+
+   uniform = &shProg->Uniforms->Uniforms[location];
+
+   if (ctx->Shader.Flags & GLSL_UNIFORMS) {
+      const GLenum basicType = base_uniform_type(type);
+      GLint i;
+      printf("Mesa: set program %u uniform %s (loc %d) to: ",
+	     shProg->Name, uniform->Name, location);
+      if (basicType == GL_INT) {
+         const GLint *v = (const GLint *) values;
+         for (i = 0; i < count * elems; i++) {
+            printf("%d ", v[i]);
+         }
+      }
+      else if (basicType == GL_UNSIGNED_INT) {
+         const GLuint *v = (const GLuint *) values;
+         for (i = 0; i < count * elems; i++) {
+            printf("%u ", v[i]);
+         }
+      }
+      else {
+         const GLfloat *v = (const GLfloat *) values;
+         assert(basicType == GL_FLOAT);
+         for (i = 0; i < count * elems; i++) {
+            printf("%g ", v[i]);
+         }
+      }
+      printf("\n");
+   }
+
+   /* A uniform var may be used by both a vertex shader and a fragment
+    * shader.  We may need to update one or both shader's uniform here:
+    */
+   if (shProg->VertexProgram) {
+      /* convert uniform location to program parameter index */
+      GLint index = uniform->VertPos;
+      if (index >= 0) {
+         set_program_uniform(ctx, &shProg->VertexProgram->Base,
+                             index, offset, type, count, elems, values);
+      }
+   }
+
+   if (shProg->FragmentProgram) {
+      /* convert uniform location to program parameter index */
+      GLint index = uniform->FragPos;
+      if (index >= 0) {
+         set_program_uniform(ctx, &shProg->FragmentProgram->Base,
+                             index, offset, type, count, elems, values);
+      }
+   }
+
+   if (shProg->GeometryProgram) {
+      /* convert uniform location to program parameter index */
+      GLint index = uniform->GeomPos;
+      if (index >= 0) {
+         set_program_uniform(ctx, &shProg->GeometryProgram->Base,
+                             index, offset, type, count, elems, values);
+      }
+   }
+
+   uniform->Initialized = GL_TRUE;
+}
+
+
+/**
+ * Set a matrix-valued program parameter.
+ */
+static void
+set_program_uniform_matrix(struct gl_context *ctx, struct gl_program *program,
+                           GLuint index, GLuint offset,
+                           GLuint count, GLuint rows, GLuint cols,
+                           GLboolean transpose, const GLfloat *values)
+{
+   GLuint mat, row, col;
+   GLuint src = 0;
+   const struct gl_program_parameter * param = &program->Parameters->Parameters[index];
+   const GLuint slots = (param->Size + 3) / 4;
+   const GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);
+   GLint nr, nc;
+
+   /* check that the number of rows, columns is correct */
+   get_matrix_dims(param->DataType, &nr, &nc);
+   if (rows != nr || cols != nc) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+                  "glUniformMatrix(matrix size mismatch)");
+      return;
+   }
+
+   if ((GLint) param->Size <= typeSize) {
+      /* non-array: count must be at most one; count == 0 is handled by the loop below */
+      if (count > 1) {
+         _mesa_error(ctx, GL_INVALID_OPERATION,
+                     "glUniformMatrix(uniform is not an array)");
+         return;
+      }
+   }
+
+   /*
+    * Note: the _columns_ of a matrix are stored in program registers, not
+    * the rows.  So, the loops below look a little funny.
+    * XXX could optimize this a bit...
+    */
+
+   /* loop over matrices */
+   for (mat = 0; mat < count; mat++) {
+
+      /* each matrix: */
+      for (col = 0; col < cols; col++) {
+         GLfloat *v;
+         if (offset >= slots) {
+            /* Ignore writes beyond the end of (the used part of) an array */
+            return;
+         }
+         v = program->Parameters->ParameterValues[index + offset];
+         for (row = 0; row < rows; row++) {
+            if (transpose) {
+               v[row] = values[src + row * cols + col];
+            }
+            else {
+               v[row] = values[src + col * rows + row];
+            }
+         }
+
+         offset++;
+      }
+
+      src += rows * cols;  /* next matrix */
+   }
+}
+
+
+/**
+ * Called by glUniformMatrix*() functions.
+ * Note: cols=2, rows=4  ==>  array[2] of vec4
+ */
+void
+_mesa_uniform_matrix(struct gl_context *ctx, struct gl_shader_program *shProg,
+		     GLint cols, GLint rows,
+                     GLint location, GLsizei count,
+                     GLboolean transpose, const GLfloat *values)
+{
+   struct gl_uniform *uniform;
+   GLint offset;
+
+   if (!shProg || !shProg->LinkStatus) {
+      _mesa_error(ctx, GL_INVALID_OPERATION,
+         "glUniformMatrix(program not linked)");
+      return;
+   }
+
+   if (location == -1)
+      return;   /* The standard specifies this as a no-op */
+
+   if (location < -1) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniformMatrix(location)");
+      return;
+   }
+
+   split_location_offset(&location, &offset);
+
+   if (location < 0 || location >= (GLint) shProg->Uniforms->NumUniforms) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glUniformMatrix(location)");
+      return;
+   }
+   if (values == NULL) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "glUniformMatrix");
+      return;
+   }
+
+   FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);
+
+   uniform = &shProg->Uniforms->Uniforms[location];
+
+   if (shProg->VertexProgram) {
+      /* convert uniform location to program parameter index */
+      GLint index = uniform->VertPos;
+      if (index >= 0) {
+         set_program_uniform_matrix(ctx, &shProg->VertexProgram->Base,
+                                    index, offset,
+                                    count, rows, cols, transpose, values);
+      }
+   }
+
+   if (shProg->FragmentProgram) {
+      /* convert uniform location to program parameter index */
+      GLint index = uniform->FragPos;
+      if (index >= 0) {
+         set_program_uniform_matrix(ctx, &shProg->FragmentProgram->Base,
+                                    index, offset,
+                                    count, rows, cols, transpose, values);
+      }
+   }
+
+   if (shProg->GeometryProgram) {
+      /* convert uniform location to program parameter index */
+      GLint index = uniform->GeomPos;
+      if (index >= 0) {
+         set_program_uniform_matrix(ctx, &shProg->GeometryProgram->Base,
+                                    index, offset,
+                                    count, rows, cols, transpose, values);
+      }
+   }
+
+   uniform->Initialized = GL_TRUE;
+}
+
+
+void GLAPIENTRY
+_mesa_Uniform1fARB(GLint location, GLfloat v0)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, &v0, GL_FLOAT);
+}
+
+void GLAPIENTRY
+_mesa_Uniform2fARB(GLint location, GLfloat v0, GLfloat v1)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat v[2];
+   v[0] = v0;
+   v[1] = v1;
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_FLOAT_VEC2);
+}
+
+void GLAPIENTRY
+_mesa_Uniform3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat v[3];
+   v[0] = v0;
+   v[1] = v1;
+   v[2] = v2;
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_FLOAT_VEC3);
+}
+
+void GLAPIENTRY
+_mesa_Uniform4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2,
+                   GLfloat v3)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLfloat v[4];
+   v[0] = v0;
+   v[1] = v1;
+   v[2] = v2;
+   v[3] = v3;
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_FLOAT_VEC4);
+}
+
+void GLAPIENTRY
+_mesa_Uniform1iARB(GLint location, GLint v0)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, &v0, GL_INT);
+}
+
+void GLAPIENTRY
+_mesa_Uniform2iARB(GLint location, GLint v0, GLint v1)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLint v[2];
+   v[0] = v0;
+   v[1] = v1;
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_INT_VEC2);
+}
+
+void GLAPIENTRY
+_mesa_Uniform3iARB(GLint location, GLint v0, GLint v1, GLint v2)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLint v[3];
+   v[0] = v0;
+   v[1] = v1;
+   v[2] = v2;
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_INT_VEC3);
+}
+
+void GLAPIENTRY
+_mesa_Uniform4iARB(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLint v[4];
+   v[0] = v0;
+   v[1] = v1;
+   v[2] = v2;
+   v[3] = v3;
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_INT_VEC4);
+}
+
+void GLAPIENTRY
+_mesa_Uniform1fvARB(GLint location, GLsizei count, const GLfloat * value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT);
+}
+
+void GLAPIENTRY
+_mesa_Uniform2fvARB(GLint location, GLsizei count, const GLfloat * value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT_VEC2);
+}
+
+void GLAPIENTRY
+_mesa_Uniform3fvARB(GLint location, GLsizei count, const GLfloat * value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT_VEC3);
+}
+
+void GLAPIENTRY
+_mesa_Uniform4fvARB(GLint location, GLsizei count, const GLfloat * value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT_VEC4);
+}
+
+void GLAPIENTRY
+_mesa_Uniform1ivARB(GLint location, GLsizei count, const GLint * value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT);
+}
+
+void GLAPIENTRY
+_mesa_Uniform2ivARB(GLint location, GLsizei count, const GLint * value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT_VEC2);
+}
+
+void GLAPIENTRY
+_mesa_Uniform3ivARB(GLint location, GLsizei count, const GLint * value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT_VEC3);
+}
+
+void GLAPIENTRY
+_mesa_Uniform4ivARB(GLint location, GLsizei count, const GLint * value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT_VEC4);
+}
+
+
+/** OpenGL 3.0 GLuint-valued functions **/
+void GLAPIENTRY
+_mesa_Uniform1ui(GLint location, GLuint v0)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, &v0, GL_UNSIGNED_INT);
+}
+
+void GLAPIENTRY
+_mesa_Uniform2ui(GLint location, GLuint v0, GLuint v1)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLuint v[2];
+   v[0] = v0;
+   v[1] = v1;
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC2);
+}
+
+void GLAPIENTRY
+_mesa_Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLuint v[3];
+   v[0] = v0;
+   v[1] = v1;
+   v[2] = v2;
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC3);
+}
+
+void GLAPIENTRY
+_mesa_Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   GLuint v[4];
+   v[0] = v0;
+   v[1] = v1;
+   v[2] = v2;
+   v[3] = v3;
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC4);
+}
+
+void GLAPIENTRY
+_mesa_Uniform1uiv(GLint location, GLsizei count, const GLuint *value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT);
+}
+
+void GLAPIENTRY
+_mesa_Uniform2uiv(GLint location, GLsizei count, const GLuint *value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC2);
+}
+
+void GLAPIENTRY
+_mesa_Uniform3uiv(GLint location, GLsizei count, const GLuint *value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC3);
+}
+
+void GLAPIENTRY
+_mesa_Uniform4uiv(GLint location, GLsizei count, const GLuint *value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC4);
+}
+
+
+
+void GLAPIENTRY
+_mesa_UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose,
+                          const GLfloat * value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
+			2, 2, location, count, transpose, value);
+}
+
+void GLAPIENTRY
+_mesa_UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose,
+                          const GLfloat * value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
+			3, 3, location, count, transpose, value);
+}
+
+void GLAPIENTRY
+_mesa_UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose,
+                          const GLfloat * value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
+			4, 4, location, count, transpose, value);
+}
+
+
+/**
+ * Non-square UniformMatrix are OpenGL 2.1
+ */
+void GLAPIENTRY
+_mesa_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,
+                         const GLfloat *value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
+			2, 3, location, count, transpose, value);
+}
+
+void GLAPIENTRY
+_mesa_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,
+                         const GLfloat *value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
+			3, 2, location, count, transpose, value);
+}
+
+void GLAPIENTRY
+_mesa_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,
+                         const GLfloat *value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
+			2, 4, location, count, transpose, value);
+}
+
+void GLAPIENTRY
+_mesa_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,
+                         const GLfloat *value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
+			4, 2, location, count, transpose, value);
+}
+
+void GLAPIENTRY
+_mesa_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,
+                         const GLfloat *value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
+			3, 4, location, count, transpose, value);
+}
+
+void GLAPIENTRY
+_mesa_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,
+                         const GLfloat *value)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
+			4, 3, location, count, transpose, value);
+}
+
+
+void GLAPIENTRY
+_mesa_GetUniformfvARB(GLhandleARB program, GLint location, GLfloat *params)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_get_uniformfv(ctx, program, location, params);
+}
+
+
+void GLAPIENTRY
+_mesa_GetUniformivARB(GLhandleARB program, GLint location, GLint *params)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_get_uniformiv(ctx, program, location, params);
+}
+
+
+/* GL3 */
+void GLAPIENTRY
+_mesa_GetUniformuiv(GLhandleARB program, GLint location, GLuint *params)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_get_uniformuiv(ctx, program, location, params);
+}
+
+
+
+GLint GLAPIENTRY
+_mesa_GetUniformLocationARB(GLhandleARB programObj, const GLcharARB *name)
+{
+   struct gl_shader_program *shProg;
+
+   GET_CURRENT_CONTEXT(ctx);
+
+   shProg = _mesa_lookup_shader_program_err(ctx, programObj,
+					    "glGetUniformLocation");
+   if (!shProg)
+      return -1;
+
+   return _mesa_get_uniform_location(ctx, shProg, name);
+}
+
+
+void GLAPIENTRY
+_mesa_GetActiveUniformARB(GLhandleARB program, GLuint index,
+                          GLsizei maxLength, GLsizei * length, GLint * size,
+                          GLenum * type, GLcharARB * name)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   _mesa_get_active_uniform(ctx, program, index, maxLength, length, size,
+                            type, name);
+}
+
+
+/**
+ * Plug in shader uniform-related functions into API dispatch table.
+ */
+void
+_mesa_init_shader_uniform_dispatch(struct _glapi_table *exec)
+{
+#if FEATURE_GL
+   SET_Uniform1fARB(exec, _mesa_Uniform1fARB);
+   SET_Uniform2fARB(exec, _mesa_Uniform2fARB);
+   SET_Uniform3fARB(exec, _mesa_Uniform3fARB);
+   SET_Uniform4fARB(exec, _mesa_Uniform4fARB);
+   SET_Uniform1iARB(exec, _mesa_Uniform1iARB);
+   SET_Uniform2iARB(exec, _mesa_Uniform2iARB);
+   SET_Uniform3iARB(exec, _mesa_Uniform3iARB);
+   SET_Uniform4iARB(exec, _mesa_Uniform4iARB);
+   SET_Uniform1fvARB(exec, _mesa_Uniform1fvARB);
+   SET_Uniform2fvARB(exec, _mesa_Uniform2fvARB);
+   SET_Uniform3fvARB(exec, _mesa_Uniform3fvARB);
+   SET_Uniform4fvARB(exec, _mesa_Uniform4fvARB);
+   SET_Uniform1ivARB(exec, _mesa_Uniform1ivARB);
+   SET_Uniform2ivARB(exec, _mesa_Uniform2ivARB);
+   SET_Uniform3ivARB(exec, _mesa_Uniform3ivARB);
+   SET_Uniform4ivARB(exec, _mesa_Uniform4ivARB);
+   SET_UniformMatrix2fvARB(exec, _mesa_UniformMatrix2fvARB);
+   SET_UniformMatrix3fvARB(exec, _mesa_UniformMatrix3fvARB);
+   SET_UniformMatrix4fvARB(exec, _mesa_UniformMatrix4fvARB);
+
+   SET_GetActiveUniformARB(exec, _mesa_GetActiveUniformARB);
+   SET_GetUniformLocationARB(exec, _mesa_GetUniformLocationARB);
+   SET_GetUniformfvARB(exec, _mesa_GetUniformfvARB);
+   SET_GetUniformivARB(exec, _mesa_GetUniformivARB);
+
+   /* OpenGL 2.1 */
+   SET_UniformMatrix2x3fv(exec, _mesa_UniformMatrix2x3fv);
+   SET_UniformMatrix3x2fv(exec, _mesa_UniformMatrix3x2fv);
+   SET_UniformMatrix2x4fv(exec, _mesa_UniformMatrix2x4fv);
+   SET_UniformMatrix4x2fv(exec, _mesa_UniformMatrix4x2fv);
+   SET_UniformMatrix3x4fv(exec, _mesa_UniformMatrix3x4fv);
+   SET_UniformMatrix4x3fv(exec, _mesa_UniformMatrix4x3fv);
+
+   /* OpenGL 3.0 */
+   /* XXX finish dispatch */
+   SET_Uniform1uiEXT(exec, _mesa_Uniform1ui);
+   SET_Uniform2uiEXT(exec, _mesa_Uniform2ui);
+   SET_Uniform3uiEXT(exec, _mesa_Uniform3ui);
+   SET_Uniform4uiEXT(exec, _mesa_Uniform4ui);
+   SET_Uniform1uivEXT(exec, _mesa_Uniform1uiv);
+   SET_Uniform2uivEXT(exec, _mesa_Uniform2uiv);
+   SET_Uniform3uivEXT(exec, _mesa_Uniform3uiv);
+   SET_Uniform4uivEXT(exec, _mesa_Uniform4uiv);
+   SET_GetUniformuivEXT(exec, _mesa_GetUniformuiv);
+
+
+#endif /* FEATURE_GL */
+}
diff --git a/mesalib/src/mesa/main/version.c b/mesalib/src/mesa/main/version.c
index f18fa5fcc..c7a0d69a4 100644
--- a/mesalib/src/mesa/main/version.c
+++ b/mesalib/src/mesa/main/version.c
@@ -1,285 +1,288 @@
-/*

- * Mesa 3-D graphics library

- *

- * Copyright (C) 2010  VMware, Inc.  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

- * THE AUTHORS 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 "imports.h"

-#include "mtypes.h"

-#include "version.h"

-

-

-

-/**

- * Examine enabled GL extensions to determine GL version.

- * Return major and minor version numbers.

- */

-static void

-compute_version(struct gl_context *ctx)

-{

-   GLuint major, minor;

-   static const int max = 100;

-

-   const GLboolean ver_1_3 = (ctx->Extensions.ARB_multisample &&

-                              ctx->Extensions.ARB_multitexture &&

-                              ctx->Extensions.ARB_texture_border_clamp &&

-                              ctx->Extensions.ARB_texture_compression &&

-                              ctx->Extensions.ARB_texture_cube_map &&

-                              ctx->Extensions.EXT_texture_env_add &&

-                              ctx->Extensions.ARB_texture_env_combine &&

-                              ctx->Extensions.ARB_texture_env_dot3);

-   const GLboolean ver_1_4 = (ver_1_3 &&

-                              ctx->Extensions.ARB_depth_texture &&

-                              ctx->Extensions.ARB_shadow &&

-                              ctx->Extensions.ARB_texture_env_crossbar &&

-                              ctx->Extensions.ARB_texture_mirrored_repeat &&

-                              ctx->Extensions.ARB_window_pos &&

-                              ctx->Extensions.EXT_blend_color &&

-                              ctx->Extensions.EXT_blend_func_separate &&

-                              ctx->Extensions.EXT_blend_minmax &&

-                              ctx->Extensions.EXT_blend_subtract &&

-                              ctx->Extensions.EXT_fog_coord &&

-                              ctx->Extensions.EXT_multi_draw_arrays &&

-                              ctx->Extensions.EXT_point_parameters &&

-                              ctx->Extensions.EXT_secondary_color &&

-                              ctx->Extensions.EXT_stencil_wrap &&

-                              ctx->Extensions.EXT_texture_lod_bias &&

-                              ctx->Extensions.SGIS_generate_mipmap);

-   const GLboolean ver_1_5 = (ver_1_4 &&

-                              ctx->Extensions.ARB_occlusion_query &&

-                              ctx->Extensions.ARB_vertex_buffer_object &&

-                              ctx->Extensions.EXT_shadow_funcs);

-   const GLboolean ver_2_0 = (ver_1_5 &&

-                              ctx->Extensions.ARB_draw_buffers &&

-                              ctx->Extensions.ARB_point_sprite &&

-                              ctx->Extensions.ARB_shader_objects &&

-                              ctx->Extensions.ARB_vertex_shader &&

-                              ctx->Extensions.ARB_fragment_shader &&

-                              ctx->Extensions.ARB_texture_non_power_of_two &&

-                              ctx->Extensions.EXT_blend_equation_separate &&

-

-			      /* Technically, 2.0 requires the functionality

-			       * of the EXT version.  Enable 2.0 if either

-			       * extension is available, and assume that a

-			       * driver that only exposes the ATI extension

-			       * will fallback to software when necessary.

-			       */

-			      (ctx->Extensions.EXT_stencil_two_side

-			       || ctx->Extensions.ATI_separate_stencil));

-   const GLboolean ver_2_1 = (ver_2_0 &&

-                              ctx->Const.GLSLVersion >= 120 &&

-                              ctx->Extensions.EXT_pixel_buffer_object &&

-                              ctx->Extensions.EXT_texture_sRGB);

-   const GLboolean ver_3_0 = (ver_2_1 &&

-                              ctx->Extensions.ARB_half_float_pixel &&

-                              ctx->Extensions.ARB_map_buffer_range &&

-                              ctx->Extensions.ARB_texture_float &&

-                              ctx->Extensions.ARB_texture_rg &&

-                              ctx->Extensions.ARB_texture_compression_rgtc &&

-                              ctx->Extensions.APPLE_vertex_array_object &&

-                              ctx->Extensions.EXT_draw_buffers2 &&

-                              ctx->Extensions.EXT_framebuffer_blit &&

-                              ctx->Extensions.EXT_framebuffer_multisample &&

-                              ctx->Extensions.EXT_framebuffer_object &&

-                              ctx->Extensions.EXT_framebuffer_sRGB &&

-                              ctx->Extensions.EXT_packed_depth_stencil &&

-                              ctx->Extensions.EXT_packed_float &&

-                              ctx->Extensions.EXT_texture_array &&

-                              ctx->Extensions.EXT_texture_integer &&

-                              ctx->Extensions.EXT_texture_shared_exponent &&

-                              ctx->Extensions.EXT_transform_feedback &&

-                              ctx->Extensions.NV_conditional_render);

-   const GLboolean ver_3_1 = (ver_3_0 &&

-                              ctx->Extensions.ARB_copy_buffer &&

-                              ctx->Extensions.ARB_draw_instanced &&

-                              ctx->Extensions.ARB_texture_buffer_object &&

-                              ctx->Extensions.ARB_uniform_buffer_object &&

-                              ctx->Extensions.NV_primitive_restart &&

-                              ctx->Extensions.NV_texture_rectangle &&

-                              ctx->Const.MaxVertexTextureImageUnits >= 16);

-   const GLboolean ver_3_2 = (ver_3_1 &&

-                              ctx->Extensions.ARB_depth_clamp &&

-                              ctx->Extensions.ARB_draw_elements_base_vertex &&

-                              ctx->Extensions.ARB_fragment_coord_conventions &&

-                              ctx->Extensions.ARB_geometry_shader4 &&

-                              ctx->Extensions.EXT_provoking_vertex &&

-                              ctx->Extensions.ARB_seamless_cube_map &&

-                              ctx->Extensions.ARB_sync &&

-                              ctx->Extensions.ARB_texture_multisample &&

-                              ctx->Extensions.EXT_vertex_array_bgra);

-   const GLboolean ver_3_3 = (ver_3_2 &&

-                              ctx->Extensions.ARB_blend_func_extended &&

-                              ctx->Extensions.ARB_explicit_attrib_location &&

-                              ctx->Extensions.ARB_instanced_arrays &&

-                              ctx->Extensions.ARB_occlusion_query2 &&

-                              ctx->Extensions.ARB_sampler_objects &&

-                              ctx->Extensions.ARB_texture_rgb10_a2ui &&

-                              ctx->Extensions.ARB_timer_query &&

-                              ctx->Extensions.ARB_vertex_type_2_10_10_10_rev &&

-                              ctx->Extensions.EXT_texture_swizzle);

-

-   if (ver_3_3) {

-      major = 3;

-      minor = 3;

-   }

-   else if (ver_3_2) {

-      major = 3;

-      minor = 2;

-   }

-   else if (ver_3_1) {

-      major = 3;

-      minor = 1;

-   }

-   else if (ver_3_0) {

-      major = 3;

-      minor = 0;

-   }

-   else if (ver_2_1) {

-      major = 2;

-      minor = 1;

-   }

-   else if (ver_2_0) {

-      major = 2;

-      minor = 0;

-   }

-   else if (ver_1_5) {

-      major = 1;

-      minor = 5;

-   }

-   else if (ver_1_4) {

-      major = 1;

-      minor = 4;

-   }

-   else if (ver_1_3) {

-      major = 1;

-      minor = 3;

-   }

-   else {

-      major = 1;

-      minor = 2;

-   }

-

-   ctx->VersionMajor = major;

-   ctx->VersionMinor = minor;

-   ctx->VersionString = (char *) malloc(max);

-   if (ctx->VersionString) {

-      _mesa_snprintf(ctx->VersionString, max,

-		     "%u.%u Mesa " MESA_VERSION_STRING,

-		     ctx->VersionMajor, ctx->VersionMinor);

-   }

-}

-

-static void

-compute_version_es1(struct gl_context *ctx)

-{

-   static const int max = 100;

-

-   /* OpenGL ES 1.0 is derived from OpenGL 1.3 */

-   const GLboolean ver_1_0 = (ctx->Extensions.ARB_multisample &&

-                              ctx->Extensions.ARB_multitexture &&

-                              ctx->Extensions.ARB_texture_compression &&

-                              ctx->Extensions.EXT_texture_env_add &&

-                              ctx->Extensions.ARB_texture_env_combine &&

-                              ctx->Extensions.ARB_texture_env_dot3);

-   /* OpenGL ES 1.1 is derived from OpenGL 1.5 */

-   const GLboolean ver_1_1 = (ver_1_0 &&

-                              ctx->Extensions.EXT_point_parameters &&

-                              ctx->Extensions.SGIS_generate_mipmap &&

-                              ctx->Extensions.ARB_vertex_buffer_object);

-

-   if (ver_1_1) {

-      ctx->VersionMajor = 1;

-      ctx->VersionMinor = 1;

-   } else if (ver_1_0) {

-      ctx->VersionMajor = 1;

-      ctx->VersionMinor = 0;

-   } else {

-      _mesa_problem(ctx, "Incomplete OpenGL ES 1.0 support.");

-   }

-

-   ctx->VersionString = (char *) malloc(max);

-   if (ctx->VersionString) {

-      _mesa_snprintf(ctx->VersionString, max,

-		     "OpenGL ES-CM 1.%d Mesa " MESA_VERSION_STRING,

-		     ctx->VersionMinor);

-   }

-}

-

-static void

-compute_version_es2(struct gl_context *ctx)

-{

-   static const int max = 100;

-

-   /* OpenGL ES 2.0 is derived from OpenGL 2.0 */

-   const GLboolean ver_2_0 = (ctx->Extensions.ARB_multisample &&

-                              ctx->Extensions.ARB_multitexture &&

-                              ctx->Extensions.ARB_texture_compression &&

-                              ctx->Extensions.ARB_texture_cube_map &&

-                              ctx->Extensions.ARB_texture_mirrored_repeat &&

-                              ctx->Extensions.EXT_blend_color &&

-                              ctx->Extensions.EXT_blend_func_separate &&

-                              ctx->Extensions.EXT_blend_minmax &&

-                              ctx->Extensions.EXT_blend_subtract &&

-                              ctx->Extensions.EXT_stencil_wrap &&

-                              ctx->Extensions.ARB_vertex_buffer_object &&

-                              ctx->Extensions.ARB_shader_objects &&

-                              ctx->Extensions.ARB_vertex_shader &&

-                              ctx->Extensions.ARB_fragment_shader &&

-                              ctx->Extensions.ARB_texture_non_power_of_two &&

-                              ctx->Extensions.EXT_blend_equation_separate);

-   if (ver_2_0) {

-      ctx->VersionMajor = 2;

-      ctx->VersionMinor = 0;

-   } else {

-      _mesa_problem(ctx, "Incomplete OpenGL ES 2.0 support.");

-   }

-

-   ctx->VersionString = (char *) malloc(max);

-   if (ctx->VersionString) {

-      _mesa_snprintf(ctx->VersionString, max,

-		     "OpenGL ES 2.0 Mesa " MESA_VERSION_STRING);

-   }

-}

-

-/**

- * Set the context's VersionMajor, VersionMinor, VersionString fields.

- * This should only be called once as part of context initialization

- * or to perform version check for GLX_ARB_create_context_profile.

- */

-void

-_mesa_compute_version(struct gl_context *ctx)

-{

-   if (ctx->VersionMajor)

-      return;

-

-   switch (ctx->API) {

-   case API_OPENGL:

-      compute_version(ctx);

-      break;

-   case API_OPENGLES:

-      compute_version_es1(ctx);

-      break;

-   case API_OPENGLES2:

-      compute_version_es2(ctx);

-      break;

-   }

-

-}

+/*
+ * Mesa 3-D graphics library
+ *
+ * Copyright (C) 2010  VMware, Inc.  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
+ * THE AUTHORS 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 "imports.h"
+#include "mtypes.h"
+#include "version.h"
+
+
+
+/**
+ * Examine enabled GL extensions to determine GL version.
+ * Return major and minor version numbers.
+ */
+static void
+compute_version(struct gl_context *ctx)
+{
+   GLuint major, minor;
+   static const int max = 100;
+
+   const GLboolean ver_1_3 = (ctx->Extensions.ARB_multisample &&
+                              ctx->Extensions.ARB_multitexture &&
+                              ctx->Extensions.ARB_texture_border_clamp &&
+                              ctx->Extensions.ARB_texture_compression &&
+                              ctx->Extensions.ARB_texture_cube_map &&
+                              ctx->Extensions.EXT_texture_env_add &&
+                              ctx->Extensions.ARB_texture_env_combine &&
+                              ctx->Extensions.ARB_texture_env_dot3);
+   const GLboolean ver_1_4 = (ver_1_3 &&
+                              ctx->Extensions.ARB_depth_texture &&
+                              ctx->Extensions.ARB_shadow &&
+                              ctx->Extensions.ARB_texture_env_crossbar &&
+                              ctx->Extensions.ARB_texture_mirrored_repeat &&
+                              ctx->Extensions.ARB_window_pos &&
+                              ctx->Extensions.EXT_blend_color &&
+                              ctx->Extensions.EXT_blend_func_separate &&
+                              ctx->Extensions.EXT_blend_minmax &&
+                              ctx->Extensions.EXT_blend_subtract &&
+                              ctx->Extensions.EXT_fog_coord &&
+                              ctx->Extensions.EXT_multi_draw_arrays &&
+                              ctx->Extensions.EXT_point_parameters &&
+                              ctx->Extensions.EXT_secondary_color &&
+                              ctx->Extensions.EXT_stencil_wrap &&
+                              ctx->Extensions.EXT_texture_lod_bias &&
+                              ctx->Extensions.SGIS_generate_mipmap);
+   const GLboolean ver_1_5 = (ver_1_4 &&
+                              ctx->Extensions.ARB_occlusion_query &&
+                              ctx->Extensions.ARB_vertex_buffer_object &&
+                              ctx->Extensions.EXT_shadow_funcs);
+   const GLboolean ver_2_0 = (ver_1_5 &&
+                              ctx->Extensions.ARB_draw_buffers &&
+                              ctx->Extensions.ARB_point_sprite &&
+                              ctx->Extensions.ARB_shader_objects &&
+                              ctx->Extensions.ARB_vertex_shader &&
+                              ctx->Extensions.ARB_fragment_shader &&
+                              ctx->Extensions.ARB_texture_non_power_of_two &&
+                              ctx->Extensions.EXT_blend_equation_separate &&
+
+			      /* Technically, 2.0 requires the functionality
+			       * of the EXT version.  Enable 2.0 if either
+			       * extension is available, and assume that a
+			       * driver that only exposes the ATI extension
+			       * will fallback to software when necessary.
+			       */
+			      (ctx->Extensions.EXT_stencil_two_side
+			       || ctx->Extensions.ATI_separate_stencil));
+   const GLboolean ver_2_1 = (ver_2_0 &&
+                              ctx->Const.GLSLVersion >= 120 &&
+                              ctx->Extensions.EXT_pixel_buffer_object &&
+                              ctx->Extensions.EXT_texture_sRGB);
+   const GLboolean ver_3_0 = (ver_2_1 &&
+                              ctx->Extensions.ARB_color_buffer_float &&
+                              ctx->Extensions.ARB_depth_buffer_float &&
+                              ctx->Extensions.ARB_half_float_pixel &&
+                              ctx->Extensions.ARB_map_buffer_range &&
+                              ctx->Extensions.ARB_texture_float &&
+                              ctx->Extensions.ARB_texture_rg &&
+                              ctx->Extensions.ARB_texture_compression_rgtc &&
+                              ctx->Extensions.APPLE_vertex_array_object &&
+                              ctx->Extensions.EXT_draw_buffers2 &&
+                              ctx->Extensions.EXT_framebuffer_blit &&
+                              ctx->Extensions.EXT_framebuffer_multisample &&
+                              ctx->Extensions.EXT_framebuffer_object &&
+                              ctx->Extensions.EXT_framebuffer_sRGB &&
+                              ctx->Extensions.EXT_packed_depth_stencil &&
+                              ctx->Extensions.EXT_packed_float &&
+                              ctx->Extensions.EXT_texture_array &&
+                              ctx->Extensions.EXT_texture_integer &&
+                              ctx->Extensions.EXT_texture_shared_exponent &&
+                              ctx->Extensions.EXT_transform_feedback &&
+                              ctx->Extensions.NV_conditional_render);
+   const GLboolean ver_3_1 = (ver_3_0 &&
+                              ctx->Extensions.ARB_copy_buffer &&
+                              ctx->Extensions.ARB_draw_instanced &&
+                              ctx->Extensions.ARB_texture_buffer_object &&
+                              ctx->Extensions.ARB_uniform_buffer_object &&
+                              ctx->Extensions.EXT_texture_snorm &&
+                              ctx->Extensions.NV_primitive_restart &&
+                              ctx->Extensions.NV_texture_rectangle &&
+                              ctx->Const.MaxVertexTextureImageUnits >= 16);
+   const GLboolean ver_3_2 = (ver_3_1 &&
+                              ctx->Extensions.ARB_depth_clamp &&
+                              ctx->Extensions.ARB_draw_elements_base_vertex &&
+                              ctx->Extensions.ARB_fragment_coord_conventions &&
+                              ctx->Extensions.ARB_geometry_shader4 &&
+                              ctx->Extensions.EXT_provoking_vertex &&
+                              ctx->Extensions.ARB_seamless_cube_map &&
+                              ctx->Extensions.ARB_sync &&
+                              ctx->Extensions.ARB_texture_multisample &&
+                              ctx->Extensions.EXT_vertex_array_bgra);
+   const GLboolean ver_3_3 = (ver_3_2 &&
+                              ctx->Extensions.ARB_blend_func_extended &&
+                              ctx->Extensions.ARB_explicit_attrib_location &&
+                              ctx->Extensions.ARB_instanced_arrays &&
+                              ctx->Extensions.ARB_occlusion_query2 &&
+                              ctx->Extensions.ARB_sampler_objects &&
+                              ctx->Extensions.ARB_texture_rgb10_a2ui &&
+                              ctx->Extensions.ARB_timer_query &&
+                              ctx->Extensions.ARB_vertex_type_2_10_10_10_rev &&
+                              ctx->Extensions.EXT_texture_swizzle);
+
+   if (ver_3_3) {
+      major = 3;
+      minor = 3;
+   }
+   else if (ver_3_2) {
+      major = 3;
+      minor = 2;
+   }
+   else if (ver_3_1) {
+      major = 3;
+      minor = 1;
+   }
+   else if (ver_3_0) {
+      major = 3;
+      minor = 0;
+   }
+   else if (ver_2_1) {
+      major = 2;
+      minor = 1;
+   }
+   else if (ver_2_0) {
+      major = 2;
+      minor = 0;
+   }
+   else if (ver_1_5) {
+      major = 1;
+      minor = 5;
+   }
+   else if (ver_1_4) {
+      major = 1;
+      minor = 4;
+   }
+   else if (ver_1_3) {
+      major = 1;
+      minor = 3;
+   }
+   else {
+      major = 1;
+      minor = 2;
+   }
+
+   ctx->VersionMajor = major;
+   ctx->VersionMinor = minor;
+   ctx->VersionString = (char *) malloc(max);
+   if (ctx->VersionString) {
+      _mesa_snprintf(ctx->VersionString, max,
+		     "%u.%u Mesa " MESA_VERSION_STRING,
+		     ctx->VersionMajor, ctx->VersionMinor);
+   }
+}
+
+static void
+compute_version_es1(struct gl_context *ctx)
+{
+   static const int max = 100;
+
+   /* OpenGL ES 1.0 is derived from OpenGL 1.3 */
+   const GLboolean ver_1_0 = (ctx->Extensions.ARB_multisample &&
+                              ctx->Extensions.ARB_multitexture &&
+                              ctx->Extensions.ARB_texture_compression &&
+                              ctx->Extensions.EXT_texture_env_add &&
+                              ctx->Extensions.ARB_texture_env_combine &&
+                              ctx->Extensions.ARB_texture_env_dot3);
+   /* OpenGL ES 1.1 is derived from OpenGL 1.5 */
+   const GLboolean ver_1_1 = (ver_1_0 &&
+                              ctx->Extensions.EXT_point_parameters &&
+                              ctx->Extensions.SGIS_generate_mipmap &&
+                              ctx->Extensions.ARB_vertex_buffer_object);
+
+   if (ver_1_1) {
+      ctx->VersionMajor = 1;
+      ctx->VersionMinor = 1;
+   } else if (ver_1_0) {
+      ctx->VersionMajor = 1;
+      ctx->VersionMinor = 0;
+   } else {
+      _mesa_problem(ctx, "Incomplete OpenGL ES 1.0 support.");
+   }
+
+   ctx->VersionString = (char *) malloc(max);
+   if (ctx->VersionString) {
+      _mesa_snprintf(ctx->VersionString, max,
+		     "OpenGL ES-CM 1.%d Mesa " MESA_VERSION_STRING,
+		     ctx->VersionMinor);
+   }
+}
+
+static void
+compute_version_es2(struct gl_context *ctx)
+{
+   static const int max = 100;
+
+   /* OpenGL ES 2.0 is derived from OpenGL 2.0 */
+   const GLboolean ver_2_0 = (ctx->Extensions.ARB_multisample &&
+                              ctx->Extensions.ARB_multitexture &&
+                              ctx->Extensions.ARB_texture_compression &&
+                              ctx->Extensions.ARB_texture_cube_map &&
+                              ctx->Extensions.ARB_texture_mirrored_repeat &&
+                              ctx->Extensions.EXT_blend_color &&
+                              ctx->Extensions.EXT_blend_func_separate &&
+                              ctx->Extensions.EXT_blend_minmax &&
+                              ctx->Extensions.EXT_blend_subtract &&
+                              ctx->Extensions.EXT_stencil_wrap &&
+                              ctx->Extensions.ARB_vertex_buffer_object &&
+                              ctx->Extensions.ARB_shader_objects &&
+                              ctx->Extensions.ARB_vertex_shader &&
+                              ctx->Extensions.ARB_fragment_shader &&
+                              ctx->Extensions.ARB_texture_non_power_of_two &&
+                              ctx->Extensions.EXT_blend_equation_separate);
+   if (ver_2_0) {
+      ctx->VersionMajor = 2;
+      ctx->VersionMinor = 0;
+   } else {
+      _mesa_problem(ctx, "Incomplete OpenGL ES 2.0 support.");
+   }
+
+   ctx->VersionString = (char *) malloc(max);
+   if (ctx->VersionString) {
+      _mesa_snprintf(ctx->VersionString, max,
+		     "OpenGL ES 2.0 Mesa " MESA_VERSION_STRING);
+   }
+}
+
+/**
+ * Set the context's VersionMajor, VersionMinor, VersionString fields.
+ * This should only be called once as part of context initialization
+ * or to perform version check for GLX_ARB_create_context_profile.
+ */
+void
+_mesa_compute_version(struct gl_context *ctx)
+{
+   if (ctx->VersionMajor)
+      return;
+
+   switch (ctx->API) {
+   case API_OPENGL:
+      compute_version(ctx);
+      break;
+   case API_OPENGLES:
+      compute_version_es1(ctx);
+      break;
+   case API_OPENGLES2:
+      compute_version_es2(ctx);
+      break;
+   }
+
+}