Attachment 4330 Details for Bug 2996 – New size and dispatch patch for modular build.

[patch] New size and dispatch patch for modular build.

Xorg-dispatch-04.patch (text/plain), 822.33 KB, created by Ian Romanick on 2006-01-12 11:01:48 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Ian Romanick

Created: 2006-01-12 11:01:48 UTC

Size: 822.33 KB

patch

obsolete

>Index: xorg/GL/symlink-mesa.sh
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/symlink-mesa.sh,v
>retrieving revision 1.4
>diff -u -d -r1.4 symlink-mesa.sh
>--- xorg/GL/symlink-mesa.sh	29 Nov 2005 16:39:24 -0000	1.4
>+++ xorg/GL/symlink-mesa.sh	12 Jan 2006 00:04:15 -0000
>@@ -63,7 +63,6 @@
>     dst_dir mesa/glapi
> 
>     action dispatch.h
>-    action glapi.c
>     action glapi.h
>     action glapioffsets.h
>     action glapitable.h
>@@ -111,7 +110,6 @@
>     action debug.h
>     action depth.c
>     action depth.h
>-    action dispatch.c
>     action dlist.c
>     action dlist.h
>     action drawpix.c
>@@ -521,13 +519,17 @@
>     src_dir src/glx/x11
>     dst_dir glx
> 
>-    action indirect_size.c
>     action indirect_size.h
> 
>     src_dir src/mesa/drivers/dri/common
> 
>     action glcontextmodes.c
>     action glcontextmodes.h
>+
>+    src_dir src/mesa/glapi
>+
>+    action glapi.c
>+    action glthread.c
> }
> 
> #########
>Index: xorg/GL/glx/Makefile.am
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/Makefile.am,v
>retrieving revision 1.9
>diff -u -d -r1.9 Makefile.am
>--- xorg/GL/glx/Makefile.am	2 Dec 2005 06:02:36 -0000	1.9
>+++ xorg/GL/glx/Makefile.am	12 Jan 2006 00:04:15 -0000
>@@ -5,6 +5,8 @@
> 	@GL_CFLAGS@ \
> 	@XLIB_CFLAGS@ \
> 	-I@MESA_SOURCE@/include \
>+	-I@MESA_SOURCE@/src/mesa/glapi \
>+	-I@MESA_SOURCE@/src/mesa/main \
> 	@SERVER_DEFINES@ \
> 	@MODULE_DEFINES@ \
> 	@LOADER_DEFINES@
>@@ -14,20 +16,18 @@
> 
> INCLUDES = -I$(top_srcdir)/GL/include -I$(top_srcdir)/hw/xfree86/os-support
> 
>-nodist_libglx_la_SOURCES = indirect_size.c indirect_size.h
>+nodist_libglx_la_SOURCES = indirect_size.h
> 
> libglx_la_SOURCES = \
>         g_disptab.c \
>         g_disptab.h \
>         g_disptab_EXT.c \
>         g_disptab_EXT.h \
>-        g_render.c \
>-        g_renderswap.c \
>-        g_single.c \
>-        g_singleswap.c \
>+        glapi.c \
>         glcontextmodes.c \
>         glcontextmodes.h \
>         global.c \
>+        glthread.c \
>         glxbuf.c \
>         glxbuf.h \
>         glxcmds.c \
>@@ -50,7 +50,15 @@
>         glxserver.h \
>         glxutil.c \
>         glxutil.h \
>-        impsize.h \
>+        indirect_dispatch.c \
>+        indirect_dispatch.h \
>+        indirect_dispatch_swap.c \
>+        indirect_reqsize.c \
>+        indirect_reqsize.h \
>+        indirect_size_get.c \
>+        indirect_size_get.h \
>+        indirect_util.c \
>+        indirect_util.h \
>         render2.c \
>         render2swap.c \
>         renderpix.c \
>Index: xorg/GL/glx/g_disptab.c
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/g_disptab.c,v
>retrieving revision 1.4
>diff -u -d -r1.4 g_disptab.c
>--- xorg/GL/glx/g_disptab.c	3 Jul 2005 07:01:01 -0000	1.4
>+++ xorg/GL/glx/g_disptab.c	12 Jan 2006 00:04:15 -0000
>@@ -36,6 +36,8 @@
> #include "glxserver.h"
> #include "glxext.h"
> #include "g_disptab.h"
>+#include "indirect_dispatch.h"
>+
> __GLXdispatchSingleProcPtr __glXSingleTable[__GLX_SINGLE_TABLE_SIZE] = {
> 	__glXNoSuchSingleOpcode,
> 	__glXRender,
>@@ -431,7 +433,7 @@
> 	__glXNoSuchRenderOpcode,
> 	__glXDisp_SampleCoverageARB,
> #ifndef MISSING_GL_EXTS
>-	__glXDisp_WindowPos3fARB /* 230 */
>+	__glXDisp_WindowPos3fvMESA /* 230 */
> #else
> 	__glXNoSuchRenderOpcode
> #endif
>@@ -832,7 +834,7 @@
> 	__glXNoSuchRenderOpcode,
> 	__glXDispSwap_SampleCoverageARB,
> #ifndef MISSING_GL_EXTS
>-	__glXDispSwap_WindowPos3fARB /* 230 */
>+	__glXDispSwap_WindowPos3fvMESA /* 230 */
> #else
> 	__glXNoSuchRenderOpcode
> #endif
>Index: xorg/GL/glx/g_disptab.h
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/g_disptab.h,v
>retrieving revision 1.4
>diff -u -d -r1.4 g_disptab.h
>--- xorg/GL/glx/g_disptab.h	3 Jul 2005 07:01:01 -0000	1.4
>+++ xorg/GL/glx/g_disptab.h	12 Jan 2006 00:04:15 -0000
>@@ -60,281 +60,6 @@
> extern int __glXCreateNewContext(__GLXclientState*, GLbyte*);
> extern int __glXCreatePixmap(__GLXclientState*, GLbyte*);
> 
>-extern int __glXDisp_NewList(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_EndList(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_DeleteLists(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GenLists(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_FeedbackBuffer(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_SelectBuffer(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_RenderMode(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_Finish(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_PixelStoref(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_PixelStorei(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_ReadPixels(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetBooleanv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetClipPlane(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetDoublev(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetError(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetFloatv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetIntegerv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetLightfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetLightiv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetMapdv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetMapfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetMapiv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetMaterialfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetMaterialiv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetPixelMapfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetPixelMapuiv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetPixelMapusv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetPolygonStipple(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetString(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexEnvfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexEnviv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexGendv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexGenfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexGeniv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexImage(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexLevelParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetTexLevelParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_IsEnabled(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_IsList(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_Flush(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_AreTexturesResident(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_DeleteTextures(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GenTextures(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_IsTexture(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetColorTable(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetColorTableParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetColorTableParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetConvolutionFilter(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetConvolutionParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetConvolutionParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetSeparableFilter(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetHistogram(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetHistogramParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetHistogramParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetMinmax(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetMinmaxParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GetMinmaxParameteriv(__GLXclientState*, GLbyte*);
>-
>-extern void __glXDisp_CallList(GLbyte*);
>-extern void __glXDisp_CallLists(GLbyte*);
>-extern void __glXDisp_ListBase(GLbyte*);
>-extern void __glXDisp_Begin(GLbyte*);
>-extern void __glXDisp_Bitmap(GLbyte*);
>-extern void __glXDisp_Color3bv(GLbyte*);
>-extern void __glXDisp_Color3dv(GLbyte*);
>-extern void __glXDisp_Color3fv(GLbyte*);
>-extern void __glXDisp_Color3iv(GLbyte*);
>-extern void __glXDisp_Color3sv(GLbyte*);
>-extern void __glXDisp_Color3ubv(GLbyte*);
>-extern void __glXDisp_Color3uiv(GLbyte*);
>-extern void __glXDisp_Color3usv(GLbyte*);
>-extern void __glXDisp_Color4bv(GLbyte*);
>-extern void __glXDisp_Color4dv(GLbyte*);
>-extern void __glXDisp_Color4fv(GLbyte*);
>-extern void __glXDisp_Color4iv(GLbyte*);
>-extern void __glXDisp_Color4sv(GLbyte*);
>-extern void __glXDisp_Color4ubv(GLbyte*);
>-extern void __glXDisp_Color4uiv(GLbyte*);
>-extern void __glXDisp_Color4usv(GLbyte*);
>-extern void __glXDisp_EdgeFlagv(GLbyte*);
>-extern void __glXDisp_End(GLbyte*);
>-extern void __glXDisp_Indexdv(GLbyte*);
>-extern void __glXDisp_Indexfv(GLbyte*);
>-extern void __glXDisp_Indexiv(GLbyte*);
>-extern void __glXDisp_Indexsv(GLbyte*);
>-extern void __glXDisp_Normal3bv(GLbyte*);
>-extern void __glXDisp_Normal3dv(GLbyte*);
>-extern void __glXDisp_Normal3fv(GLbyte*);
>-extern void __glXDisp_Normal3iv(GLbyte*);
>-extern void __glXDisp_Normal3sv(GLbyte*);
>-extern void __glXDisp_RasterPos2dv(GLbyte*);
>-extern void __glXDisp_RasterPos2fv(GLbyte*);
>-extern void __glXDisp_RasterPos2iv(GLbyte*);
>-extern void __glXDisp_RasterPos2sv(GLbyte*);
>-extern void __glXDisp_RasterPos3dv(GLbyte*);
>-extern void __glXDisp_RasterPos3fv(GLbyte*);
>-extern void __glXDisp_RasterPos3iv(GLbyte*);
>-extern void __glXDisp_RasterPos3sv(GLbyte*);
>-extern void __glXDisp_RasterPos4dv(GLbyte*);
>-extern void __glXDisp_RasterPos4fv(GLbyte*);
>-extern void __glXDisp_RasterPos4iv(GLbyte*);
>-extern void __glXDisp_RasterPos4sv(GLbyte*);
>-extern void __glXDisp_Rectdv(GLbyte*);
>-extern void __glXDisp_Rectfv(GLbyte*);
>-extern void __glXDisp_Rectiv(GLbyte*);
>-extern void __glXDisp_Rectsv(GLbyte*);
>-extern void __glXDisp_TexCoord1dv(GLbyte*);
>-extern void __glXDisp_TexCoord1fv(GLbyte*);
>-extern void __glXDisp_TexCoord1iv(GLbyte*);
>-extern void __glXDisp_TexCoord1sv(GLbyte*);
>-extern void __glXDisp_TexCoord2dv(GLbyte*);
>-extern void __glXDisp_TexCoord2fv(GLbyte*);
>-extern void __glXDisp_TexCoord2iv(GLbyte*);
>-extern void __glXDisp_TexCoord2sv(GLbyte*);
>-extern void __glXDisp_TexCoord3dv(GLbyte*);
>-extern void __glXDisp_TexCoord3fv(GLbyte*);
>-extern void __glXDisp_TexCoord3iv(GLbyte*);
>-extern void __glXDisp_TexCoord3sv(GLbyte*);
>-extern void __glXDisp_TexCoord4dv(GLbyte*);
>-extern void __glXDisp_TexCoord4fv(GLbyte*);
>-extern void __glXDisp_TexCoord4iv(GLbyte*);
>-extern void __glXDisp_TexCoord4sv(GLbyte*);
>-extern void __glXDisp_Vertex2dv(GLbyte*);
>-extern void __glXDisp_Vertex2fv(GLbyte*);
>-extern void __glXDisp_Vertex2iv(GLbyte*);
>-extern void __glXDisp_Vertex2sv(GLbyte*);
>-extern void __glXDisp_Vertex3dv(GLbyte*);
>-extern void __glXDisp_Vertex3fv(GLbyte*);
>-extern void __glXDisp_Vertex3iv(GLbyte*);
>-extern void __glXDisp_Vertex3sv(GLbyte*);
>-extern void __glXDisp_Vertex4dv(GLbyte*);
>-extern void __glXDisp_Vertex4fv(GLbyte*);
>-extern void __glXDisp_Vertex4iv(GLbyte*);
>-extern void __glXDisp_Vertex4sv(GLbyte*);
>-extern void __glXDisp_ClipPlane(GLbyte*);
>-extern void __glXDisp_ColorMaterial(GLbyte*);
>-extern void __glXDisp_CullFace(GLbyte*);
>-extern void __glXDisp_Fogf(GLbyte*);
>-extern void __glXDisp_Fogfv(GLbyte*);
>-extern void __glXDisp_Fogi(GLbyte*);
>-extern void __glXDisp_Fogiv(GLbyte*);
>-extern void __glXDisp_FrontFace(GLbyte*);
>-extern void __glXDisp_Hint(GLbyte*);
>-extern void __glXDisp_Lightf(GLbyte*);
>-extern void __glXDisp_Lightfv(GLbyte*);
>-extern void __glXDisp_Lighti(GLbyte*);
>-extern void __glXDisp_Lightiv(GLbyte*);
>-extern void __glXDisp_LightModelf(GLbyte*);
>-extern void __glXDisp_LightModelfv(GLbyte*);
>-extern void __glXDisp_LightModeli(GLbyte*);
>-extern void __glXDisp_LightModeliv(GLbyte*);
>-extern void __glXDisp_LineStipple(GLbyte*);
>-extern void __glXDisp_LineWidth(GLbyte*);
>-extern void __glXDisp_Materialf(GLbyte*);
>-extern void __glXDisp_Materialfv(GLbyte*);
>-extern void __glXDisp_Materiali(GLbyte*);
>-extern void __glXDisp_Materialiv(GLbyte*);
>-extern void __glXDisp_PointSize(GLbyte*);
>-extern void __glXDisp_PolygonMode(GLbyte*);
>-extern void __glXDisp_PolygonStipple(GLbyte*);
>-extern void __glXDisp_Scissor(GLbyte*);
>-extern void __glXDisp_ShadeModel(GLbyte*);
>-extern void __glXDisp_TexParameterf(GLbyte*);
>-extern void __glXDisp_TexParameterfv(GLbyte*);
>-extern void __glXDisp_TexParameteri(GLbyte*);
>-extern void __glXDisp_TexParameteriv(GLbyte*);
>-extern void __glXDisp_TexImage1D(GLbyte*);
>-extern void __glXDisp_TexImage2D(GLbyte*);
>-extern void __glXDisp_TexEnvf(GLbyte*);
>-extern void __glXDisp_TexEnvfv(GLbyte*);
>-extern void __glXDisp_TexEnvi(GLbyte*);
>-extern void __glXDisp_TexEnviv(GLbyte*);
>-extern void __glXDisp_TexGend(GLbyte*);
>-extern void __glXDisp_TexGendv(GLbyte*);
>-extern void __glXDisp_TexGenf(GLbyte*);
>-extern void __glXDisp_TexGenfv(GLbyte*);
>-extern void __glXDisp_TexGeni(GLbyte*);
>-extern void __glXDisp_TexGeniv(GLbyte*);
>-extern void __glXDisp_InitNames(GLbyte*);
>-extern void __glXDisp_LoadName(GLbyte*);
>-extern void __glXDisp_PassThrough(GLbyte*);
>-extern void __glXDisp_PopName(GLbyte*);
>-extern void __glXDisp_PushName(GLbyte*);
>-extern void __glXDisp_DrawBuffer(GLbyte*);
>-extern void __glXDisp_Clear(GLbyte*);
>-extern void __glXDisp_ClearAccum(GLbyte*);
>-extern void __glXDisp_ClearIndex(GLbyte*);
>-extern void __glXDisp_ClearColor(GLbyte*);
>-extern void __glXDisp_ClearStencil(GLbyte*);
>-extern void __glXDisp_ClearDepth(GLbyte*);
>-extern void __glXDisp_StencilMask(GLbyte*);
>-extern void __glXDisp_ColorMask(GLbyte*);
>-extern void __glXDisp_DepthMask(GLbyte*);
>-extern void __glXDisp_IndexMask(GLbyte*);
>-extern void __glXDisp_Accum(GLbyte*);
>-extern void __glXDisp_Disable(GLbyte*);
>-extern void __glXDisp_Enable(GLbyte*);
>-extern void __glXDisp_PopAttrib(GLbyte*);
>-extern void __glXDisp_PushAttrib(GLbyte*);
>-extern void __glXDisp_Map1d(GLbyte*);
>-extern void __glXDisp_Map1f(GLbyte*);
>-extern void __glXDisp_Map2d(GLbyte*);
>-extern void __glXDisp_Map2f(GLbyte*);
>-extern void __glXDisp_MapGrid1d(GLbyte*);
>-extern void __glXDisp_MapGrid1f(GLbyte*);
>-extern void __glXDisp_MapGrid2d(GLbyte*);
>-extern void __glXDisp_MapGrid2f(GLbyte*);
>-extern void __glXDisp_EvalCoord1dv(GLbyte*);
>-extern void __glXDisp_EvalCoord1fv(GLbyte*);
>-extern void __glXDisp_EvalCoord2dv(GLbyte*);
>-extern void __glXDisp_EvalCoord2fv(GLbyte*);
>-extern void __glXDisp_EvalMesh1(GLbyte*);
>-extern void __glXDisp_EvalPoint1(GLbyte*);
>-extern void __glXDisp_EvalMesh2(GLbyte*);
>-extern void __glXDisp_EvalPoint2(GLbyte*);
>-extern void __glXDisp_AlphaFunc(GLbyte*);
>-extern void __glXDisp_BlendFunc(GLbyte*);
>-extern void __glXDisp_LogicOp(GLbyte*);
>-extern void __glXDisp_StencilFunc(GLbyte*);
>-extern void __glXDisp_StencilOp(GLbyte*);
>-extern void __glXDisp_DepthFunc(GLbyte*);
>-extern void __glXDisp_PixelZoom(GLbyte*);
>-extern void __glXDisp_PixelTransferf(GLbyte*);
>-extern void __glXDisp_PixelTransferi(GLbyte*);
>-extern void __glXDisp_PixelMapfv(GLbyte*);
>-extern void __glXDisp_PixelMapuiv(GLbyte*);
>-extern void __glXDisp_PixelMapusv(GLbyte*);
>-extern void __glXDisp_ReadBuffer(GLbyte*);
>-extern void __glXDisp_CopyPixels(GLbyte*);
>-extern void __glXDisp_DrawPixels(GLbyte*);
>-extern void __glXDisp_DepthRange(GLbyte*);
>-extern void __glXDisp_Frustum(GLbyte*);
>-extern void __glXDisp_LoadIdentity(GLbyte*);
>-extern void __glXDisp_LoadMatrixf(GLbyte*);
>-extern void __glXDisp_LoadMatrixd(GLbyte*);
>-extern void __glXDisp_MatrixMode(GLbyte*);
>-extern void __glXDisp_MultMatrixf(GLbyte*);
>-extern void __glXDisp_MultMatrixd(GLbyte*);
>-extern void __glXDisp_Ortho(GLbyte*);
>-extern void __glXDisp_PopMatrix(GLbyte*);
>-extern void __glXDisp_PushMatrix(GLbyte*);
>-extern void __glXDisp_Rotated(GLbyte*);
>-extern void __glXDisp_Rotatef(GLbyte*);
>-extern void __glXDisp_Scaled(GLbyte*);
>-extern void __glXDisp_Scalef(GLbyte*);
>-extern void __glXDisp_Translated(GLbyte*);
>-extern void __glXDisp_Translatef(GLbyte*);
>-extern void __glXDisp_Viewport(GLbyte*);
>-extern void __glXDisp_PolygonOffset(GLbyte*);
>-extern void __glXDisp_DrawArrays(GLbyte*);
>-extern void __glXDisp_Indexubv(GLbyte*);
>-extern void __glXDisp_ColorSubTable(GLbyte*);
>-extern void __glXDisp_CopyColorSubTable(GLbyte*);
>-extern void __glXDisp_ActiveTextureARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord1dvARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord1fvARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord1ivARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord1svARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord2dvARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord2fvARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord2ivARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord2svARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord3dvARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord3fvARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord3ivARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord3svARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord4dvARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord4fvARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord4ivARB(GLbyte*);
>-extern void __glXDisp_MultiTexCoord4svARB(GLbyte*);
>-extern void __glXDisp_SampleCoverageARB(GLbyte *);
>-extern void __glXDisp_WindowPos3fARB(GLbyte *);
>-
> extern int __glXSwapRender(__GLXclientState*, GLbyte*);
> extern int __glXSwapRenderLarge(__GLXclientState*, GLbyte*);
> extern int __glXSwapCreateContext(__GLXclientState*, GLbyte*);
>@@ -360,281 +85,6 @@
> extern int __glXSwapCreateNewContext(__GLXclientState*, GLbyte*);
> extern int __glXSwapCreatePixmap(__GLXclientState*, GLbyte*);
> 
>-extern int __glXDispSwap_NewList(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_EndList(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_DeleteLists(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GenLists(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_FeedbackBuffer(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_SelectBuffer(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_RenderMode(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_Finish(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_PixelStoref(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_PixelStorei(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_ReadPixels(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetBooleanv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetClipPlane(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetDoublev(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetError(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetFloatv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetIntegerv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetLightfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetLightiv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetMapdv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetMapfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetMapiv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetMaterialfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetMaterialiv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetPixelMapfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetPixelMapuiv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetPixelMapusv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetPolygonStipple(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetString(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexEnvfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexEnviv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexGendv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexGenfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexGeniv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexImage(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexLevelParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetTexLevelParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_IsEnabled(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_IsList(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_Flush(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_AreTexturesResident(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_DeleteTextures(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GenTextures(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_IsTexture(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetColorTable(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetColorTableParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetColorTableParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetConvolutionFilter(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetConvolutionParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetConvolutionParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetSeparableFilter(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetHistogram(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetHistogramParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetHistogramParameteriv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetMinmax(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetMinmaxParameterfv(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GetMinmaxParameteriv(__GLXclientState*, GLbyte*);
>-
>-extern void __glXDispSwap_CallList(GLbyte*);
>-extern void __glXDispSwap_CallLists(GLbyte*);
>-extern void __glXDispSwap_ListBase(GLbyte*);
>-extern void __glXDispSwap_Begin(GLbyte*);
>-extern void __glXDispSwap_Bitmap(GLbyte*);
>-extern void __glXDispSwap_Color3bv(GLbyte*);
>-extern void __glXDispSwap_Color3dv(GLbyte*);
>-extern void __glXDispSwap_Color3fv(GLbyte*);
>-extern void __glXDispSwap_Color3iv(GLbyte*);
>-extern void __glXDispSwap_Color3sv(GLbyte*);
>-extern void __glXDispSwap_Color3ubv(GLbyte*);
>-extern void __glXDispSwap_Color3uiv(GLbyte*);
>-extern void __glXDispSwap_Color3usv(GLbyte*);
>-extern void __glXDispSwap_Color4bv(GLbyte*);
>-extern void __glXDispSwap_Color4dv(GLbyte*);
>-extern void __glXDispSwap_Color4fv(GLbyte*);
>-extern void __glXDispSwap_Color4iv(GLbyte*);
>-extern void __glXDispSwap_Color4sv(GLbyte*);
>-extern void __glXDispSwap_Color4ubv(GLbyte*);
>-extern void __glXDispSwap_Color4uiv(GLbyte*);
>-extern void __glXDispSwap_Color4usv(GLbyte*);
>-extern void __glXDispSwap_EdgeFlagv(GLbyte*);
>-extern void __glXDispSwap_End(GLbyte*);
>-extern void __glXDispSwap_Indexdv(GLbyte*);
>-extern void __glXDispSwap_Indexfv(GLbyte*);
>-extern void __glXDispSwap_Indexiv(GLbyte*);
>-extern void __glXDispSwap_Indexsv(GLbyte*);
>-extern void __glXDispSwap_Normal3bv(GLbyte*);
>-extern void __glXDispSwap_Normal3dv(GLbyte*);
>-extern void __glXDispSwap_Normal3fv(GLbyte*);
>-extern void __glXDispSwap_Normal3iv(GLbyte*);
>-extern void __glXDispSwap_Normal3sv(GLbyte*);
>-extern void __glXDispSwap_RasterPos2dv(GLbyte*);
>-extern void __glXDispSwap_RasterPos2fv(GLbyte*);
>-extern void __glXDispSwap_RasterPos2iv(GLbyte*);
>-extern void __glXDispSwap_RasterPos2sv(GLbyte*);
>-extern void __glXDispSwap_RasterPos3dv(GLbyte*);
>-extern void __glXDispSwap_RasterPos3fv(GLbyte*);
>-extern void __glXDispSwap_RasterPos3iv(GLbyte*);
>-extern void __glXDispSwap_RasterPos3sv(GLbyte*);
>-extern void __glXDispSwap_RasterPos4dv(GLbyte*);
>-extern void __glXDispSwap_RasterPos4fv(GLbyte*);
>-extern void __glXDispSwap_RasterPos4iv(GLbyte*);
>-extern void __glXDispSwap_RasterPos4sv(GLbyte*);
>-extern void __glXDispSwap_Rectdv(GLbyte*);
>-extern void __glXDispSwap_Rectfv(GLbyte*);
>-extern void __glXDispSwap_Rectiv(GLbyte*);
>-extern void __glXDispSwap_Rectsv(GLbyte*);
>-extern void __glXDispSwap_TexCoord1dv(GLbyte*);
>-extern void __glXDispSwap_TexCoord1fv(GLbyte*);
>-extern void __glXDispSwap_TexCoord1iv(GLbyte*);
>-extern void __glXDispSwap_TexCoord1sv(GLbyte*);
>-extern void __glXDispSwap_TexCoord2dv(GLbyte*);
>-extern void __glXDispSwap_TexCoord2fv(GLbyte*);
>-extern void __glXDispSwap_TexCoord2iv(GLbyte*);
>-extern void __glXDispSwap_TexCoord2sv(GLbyte*);
>-extern void __glXDispSwap_TexCoord3dv(GLbyte*);
>-extern void __glXDispSwap_TexCoord3fv(GLbyte*);
>-extern void __glXDispSwap_TexCoord3iv(GLbyte*);
>-extern void __glXDispSwap_TexCoord3sv(GLbyte*);
>-extern void __glXDispSwap_TexCoord4dv(GLbyte*);
>-extern void __glXDispSwap_TexCoord4fv(GLbyte*);
>-extern void __glXDispSwap_TexCoord4iv(GLbyte*);
>-extern void __glXDispSwap_TexCoord4sv(GLbyte*);
>-extern void __glXDispSwap_Vertex2dv(GLbyte*);
>-extern void __glXDispSwap_Vertex2fv(GLbyte*);
>-extern void __glXDispSwap_Vertex2iv(GLbyte*);
>-extern void __glXDispSwap_Vertex2sv(GLbyte*);
>-extern void __glXDispSwap_Vertex3dv(GLbyte*);
>-extern void __glXDispSwap_Vertex3fv(GLbyte*);
>-extern void __glXDispSwap_Vertex3iv(GLbyte*);
>-extern void __glXDispSwap_Vertex3sv(GLbyte*);
>-extern void __glXDispSwap_Vertex4dv(GLbyte*);
>-extern void __glXDispSwap_Vertex4fv(GLbyte*);
>-extern void __glXDispSwap_Vertex4iv(GLbyte*);
>-extern void __glXDispSwap_Vertex4sv(GLbyte*);
>-extern void __glXDispSwap_ClipPlane(GLbyte*);
>-extern void __glXDispSwap_ColorMaterial(GLbyte*);
>-extern void __glXDispSwap_CullFace(GLbyte*);
>-extern void __glXDispSwap_Fogf(GLbyte*);
>-extern void __glXDispSwap_Fogfv(GLbyte*);
>-extern void __glXDispSwap_Fogi(GLbyte*);
>-extern void __glXDispSwap_Fogiv(GLbyte*);
>-extern void __glXDispSwap_FrontFace(GLbyte*);
>-extern void __glXDispSwap_Hint(GLbyte*);
>-extern void __glXDispSwap_Lightf(GLbyte*);
>-extern void __glXDispSwap_Lightfv(GLbyte*);
>-extern void __glXDispSwap_Lighti(GLbyte*);
>-extern void __glXDispSwap_Lightiv(GLbyte*);
>-extern void __glXDispSwap_LightModelf(GLbyte*);
>-extern void __glXDispSwap_LightModelfv(GLbyte*);
>-extern void __glXDispSwap_LightModeli(GLbyte*);
>-extern void __glXDispSwap_LightModeliv(GLbyte*);
>-extern void __glXDispSwap_LineStipple(GLbyte*);
>-extern void __glXDispSwap_LineWidth(GLbyte*);
>-extern void __glXDispSwap_Materialf(GLbyte*);
>-extern void __glXDispSwap_Materialfv(GLbyte*);
>-extern void __glXDispSwap_Materiali(GLbyte*);
>-extern void __glXDispSwap_Materialiv(GLbyte*);
>-extern void __glXDispSwap_PointSize(GLbyte*);
>-extern void __glXDispSwap_PolygonMode(GLbyte*);
>-extern void __glXDispSwap_PolygonStipple(GLbyte*);
>-extern void __glXDispSwap_Scissor(GLbyte*);
>-extern void __glXDispSwap_ShadeModel(GLbyte*);
>-extern void __glXDispSwap_TexParameterf(GLbyte*);
>-extern void __glXDispSwap_TexParameterfv(GLbyte*);
>-extern void __glXDispSwap_TexParameteri(GLbyte*);
>-extern void __glXDispSwap_TexParameteriv(GLbyte*);
>-extern void __glXDispSwap_TexImage1D(GLbyte*);
>-extern void __glXDispSwap_TexImage2D(GLbyte*);
>-extern void __glXDispSwap_TexEnvf(GLbyte*);
>-extern void __glXDispSwap_TexEnvfv(GLbyte*);
>-extern void __glXDispSwap_TexEnvi(GLbyte*);
>-extern void __glXDispSwap_TexEnviv(GLbyte*);
>-extern void __glXDispSwap_TexGend(GLbyte*);
>-extern void __glXDispSwap_TexGendv(GLbyte*);
>-extern void __glXDispSwap_TexGenf(GLbyte*);
>-extern void __glXDispSwap_TexGenfv(GLbyte*);
>-extern void __glXDispSwap_TexGeni(GLbyte*);
>-extern void __glXDispSwap_TexGeniv(GLbyte*);
>-extern void __glXDispSwap_InitNames(GLbyte*);
>-extern void __glXDispSwap_LoadName(GLbyte*);
>-extern void __glXDispSwap_PassThrough(GLbyte*);
>-extern void __glXDispSwap_PopName(GLbyte*);
>-extern void __glXDispSwap_PushName(GLbyte*);
>-extern void __glXDispSwap_DrawBuffer(GLbyte*);
>-extern void __glXDispSwap_Clear(GLbyte*);
>-extern void __glXDispSwap_ClearAccum(GLbyte*);
>-extern void __glXDispSwap_ClearIndex(GLbyte*);
>-extern void __glXDispSwap_ClearColor(GLbyte*);
>-extern void __glXDispSwap_ClearStencil(GLbyte*);
>-extern void __glXDispSwap_ClearDepth(GLbyte*);
>-extern void __glXDispSwap_StencilMask(GLbyte*);
>-extern void __glXDispSwap_ColorMask(GLbyte*);
>-extern void __glXDispSwap_DepthMask(GLbyte*);
>-extern void __glXDispSwap_IndexMask(GLbyte*);
>-extern void __glXDispSwap_Accum(GLbyte*);
>-extern void __glXDispSwap_Disable(GLbyte*);
>-extern void __glXDispSwap_Enable(GLbyte*);
>-extern void __glXDispSwap_PopAttrib(GLbyte*);
>-extern void __glXDispSwap_PushAttrib(GLbyte*);
>-extern void __glXDispSwap_Map1d(GLbyte*);
>-extern void __glXDispSwap_Map1f(GLbyte*);
>-extern void __glXDispSwap_Map2d(GLbyte*);
>-extern void __glXDispSwap_Map2f(GLbyte*);
>-extern void __glXDispSwap_MapGrid1d(GLbyte*);
>-extern void __glXDispSwap_MapGrid1f(GLbyte*);
>-extern void __glXDispSwap_MapGrid2d(GLbyte*);
>-extern void __glXDispSwap_MapGrid2f(GLbyte*);
>-extern void __glXDispSwap_EvalCoord1dv(GLbyte*);
>-extern void __glXDispSwap_EvalCoord1fv(GLbyte*);
>-extern void __glXDispSwap_EvalCoord2dv(GLbyte*);
>-extern void __glXDispSwap_EvalCoord2fv(GLbyte*);
>-extern void __glXDispSwap_EvalMesh1(GLbyte*);
>-extern void __glXDispSwap_EvalPoint1(GLbyte*);
>-extern void __glXDispSwap_EvalMesh2(GLbyte*);
>-extern void __glXDispSwap_EvalPoint2(GLbyte*);
>-extern void __glXDispSwap_AlphaFunc(GLbyte*);
>-extern void __glXDispSwap_BlendFunc(GLbyte*);
>-extern void __glXDispSwap_LogicOp(GLbyte*);
>-extern void __glXDispSwap_StencilFunc(GLbyte*);
>-extern void __glXDispSwap_StencilOp(GLbyte*);
>-extern void __glXDispSwap_DepthFunc(GLbyte*);
>-extern void __glXDispSwap_PixelZoom(GLbyte*);
>-extern void __glXDispSwap_PixelTransferf(GLbyte*);
>-extern void __glXDispSwap_PixelTransferi(GLbyte*);
>-extern void __glXDispSwap_PixelMapfv(GLbyte*);
>-extern void __glXDispSwap_PixelMapuiv(GLbyte*);
>-extern void __glXDispSwap_PixelMapusv(GLbyte*);
>-extern void __glXDispSwap_ReadBuffer(GLbyte*);
>-extern void __glXDispSwap_CopyPixels(GLbyte*);
>-extern void __glXDispSwap_DrawPixels(GLbyte*);
>-extern void __glXDispSwap_DepthRange(GLbyte*);
>-extern void __glXDispSwap_Frustum(GLbyte*);
>-extern void __glXDispSwap_LoadIdentity(GLbyte*);
>-extern void __glXDispSwap_LoadMatrixf(GLbyte*);
>-extern void __glXDispSwap_LoadMatrixd(GLbyte*);
>-extern void __glXDispSwap_MatrixMode(GLbyte*);
>-extern void __glXDispSwap_MultMatrixf(GLbyte*);
>-extern void __glXDispSwap_MultMatrixd(GLbyte*);
>-extern void __glXDispSwap_Ortho(GLbyte*);
>-extern void __glXDispSwap_PopMatrix(GLbyte*);
>-extern void __glXDispSwap_PushMatrix(GLbyte*);
>-extern void __glXDispSwap_Rotated(GLbyte*);
>-extern void __glXDispSwap_Rotatef(GLbyte*);
>-extern void __glXDispSwap_Scaled(GLbyte*);
>-extern void __glXDispSwap_Scalef(GLbyte*);
>-extern void __glXDispSwap_Translated(GLbyte*);
>-extern void __glXDispSwap_Translatef(GLbyte*);
>-extern void __glXDispSwap_Viewport(GLbyte*);
>-extern void __glXDispSwap_PolygonOffset(GLbyte*);
>-extern void __glXDispSwap_DrawArrays(GLbyte*);
>-extern void __glXDispSwap_Indexubv(GLbyte*);
>-extern void __glXDispSwap_ColorSubTable(GLbyte*);
>-extern void __glXDispSwap_CopyColorSubTable(GLbyte*);
>-extern void __glXDispSwap_ActiveTextureARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord1dvARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord1fvARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord1ivARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord1svARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord2dvARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord2fvARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord2ivARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord2svARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord3dvARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord3fvARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord3ivARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord3svARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord4dvARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord4fvARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord4ivARB(GLbyte*);
>-extern void __glXDispSwap_MultiTexCoord4svARB(GLbyte*);
>-extern void __glXDispSwap_SampleCoverageARB(GLbyte *);
>-extern void __glXDispSwap_WindowPos3fARB(GLbyte *);
>-
> #define __GLX_MIN_GLXCMD_OPCODE 1
> #define __GLX_MAX_GLXCMD_OPCODE 20
> #define __GLX_MIN_RENDER_OPCODE 1
>Index: xorg/GL/glx/g_disptab_EXT.c
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/g_disptab_EXT.c,v
>retrieving revision 1.4
>diff -u -d -r1.4 g_disptab_EXT.c
>--- xorg/GL/glx/g_disptab_EXT.c	12 Aug 2005 16:30:57 -0000	1.4
>+++ xorg/GL/glx/g_disptab_EXT.c	12 Jan 2006 00:04:15 -0000
>@@ -36,6 +36,8 @@
> #include "glxserver.h"
> #include "glxext.h"
> #include "g_disptab_EXT.h"
>+#include "indirect_dispatch.h"
>+
> __GLXdispatchRenderProcPtr __glXRenderTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT - __GLX_MIN_RENDER_OPCODE_EXT + 1] = {
> 	__glXDisp_ColorTable, /* 2053 */
> 	__glXDisp_ColorTableParameterfv, /* 2054 */
>@@ -50,8 +52,8 @@
> 	__glXNoSuchRenderOpcode,
> 	__glXNoSuchRenderOpcode,
> #ifndef MISSING_GL_EXTS
>-	__glXDisp_PointParameterfARB, /* 2065 */
>-	__glXDisp_PointParameterfvARB, /* 2066 */
>+	__glXDisp_PointParameterfEXT, /* 2065 */
>+	__glXDisp_PointParameterfvEXT, /* 2066 */
> #else
> 	__glXNoSuchRenderOpcode,
> 	__glXNoSuchRenderOpcode,
>@@ -2105,7 +2107,7 @@
> 	__glXDisp_ResetMinmax,
> 	__glXDisp_TexImage3D,
> 	__glXDisp_TexSubImage3D,
>-	__glXDisp_DrawArraysEXT,
>+	__glXDisp_DrawArrays,
> 	__glXDisp_BindTexture,
> 	__glXDisp_PrioritizeTextures,
> 	__glXDisp_CopyTexImage1D,
>@@ -2114,17 +2116,17 @@
> 	__glXDisp_CopyTexSubImage2D,  /* 4122 */
> 	__glXDisp_CopyTexSubImage3D,  /* 4123 */
> #ifndef MISSING_GL_EXTS
>-	__glXDisp_FogCoordfv,         /* 4124 */
>-	__glXDisp_FogCoorddv,         /* 4125 */
>-	__glXDisp_SecondaryColor3bv,  /* 4126 */
>-	__glXDisp_SecondaryColor3sv,  /* 4127 */
>-	__glXDisp_SecondaryColor3iv,  /* 4128 */
>-	__glXDisp_SecondaryColor3fv,  /* 4129 */
>-	__glXDisp_SecondaryColor3dv,  /* 4130 */
>-	__glXDisp_SecondaryColor3ubv, /* 4131 */
>-	__glXDisp_SecondaryColor3usv, /* 4132 */
>-	__glXDisp_SecondaryColor3uiv, /* 4133 */
>-	__glXDisp_BlendFuncSeparate,  /* 4134 */
>+	__glXDisp_FogCoordfvEXT,         /* 4124 */
>+	__glXDisp_FogCoorddvEXT,         /* 4125 */
>+	__glXDisp_SecondaryColor3bvEXT,  /* 4126 */
>+	__glXDisp_SecondaryColor3svEXT,  /* 4127 */
>+	__glXDisp_SecondaryColor3ivEXT,  /* 4128 */
>+	__glXDisp_SecondaryColor3fvEXT,  /* 4129 */
>+	__glXDisp_SecondaryColor3dvEXT,  /* 4130 */
>+	__glXDisp_SecondaryColor3ubvEXT, /* 4131 */
>+	__glXDisp_SecondaryColor3usvEXT, /* 4132 */
>+	__glXDisp_SecondaryColor3uivEXT, /* 4133 */
>+	__glXDisp_BlendFuncSeparateEXT,  /* 4134 */
> #else
> 	__glXNoSuchRenderOpcode,      /* 4124 */
> 	__glXNoSuchRenderOpcode,      /* 4125 */
>@@ -2235,7 +2237,7 @@
> };
> __GLXdispatchVendorPrivProcPtr __glXVendorPrivTable_EXT[__GLX_MAX_VENDPRIV_OPCODE_EXT - __GLX_MIN_VENDPRIV_OPCODE_EXT + 1] = {
> 	__glXDisp_AreTexturesResidentEXT, /* 11 */
>-	__glXDisp_DeleteTexturesEXT, /* 12 */
>+	__glXDisp_DeleteTextures, /* 12 */
> 	__glXDisp_GenTexturesEXT, /* 13 */
> 	__glXDisp_IsTextureEXT, /* 14 */
> };
>@@ -2255,8 +2257,8 @@
> 	__glXNoSuchRenderOpcode,
> 	__glXNoSuchRenderOpcode,
> #ifndef MISSING_GL_EXTS
>-	__glXDispSwap_PointParameterfARB, /* 2065 */
>-	__glXDispSwap_PointParameterfvARB, /* 2066 */
>+	__glXDispSwap_PointParameterfEXT, /* 2065 */
>+	__glXDispSwap_PointParameterfvEXT, /* 2066 */
> #else
> 	__glXNoSuchRenderOpcode,
> 	__glXNoSuchRenderOpcode,
>@@ -4310,7 +4312,7 @@
> 	__glXDispSwap_ResetMinmax,
> 	__glXDispSwap_TexImage3D,
> 	__glXDispSwap_TexSubImage3D,
>-	__glXDispSwap_DrawArraysEXT,
>+	__glXDispSwap_DrawArrays,
> 	__glXDispSwap_BindTexture,
> 	__glXDispSwap_PrioritizeTextures,
> 	__glXDispSwap_CopyTexImage1D,
>@@ -4319,17 +4321,17 @@
> 	__glXDispSwap_CopyTexSubImage2D,  /* 4122 */
> 	__glXDispSwap_CopyTexSubImage3D,  /* 4123 */
> #ifndef MISSING_GL_EXTS
>-	__glXDispSwap_FogCoordfv,         /* 4124 */
>-	__glXDispSwap_FogCoorddv,         /* 4125 */
>-	__glXDispSwap_SecondaryColor3bv,  /* 4126 */
>-	__glXDispSwap_SecondaryColor3sv,  /* 4127 */
>-	__glXDispSwap_SecondaryColor3iv,  /* 4128 */
>-	__glXDispSwap_SecondaryColor3fv,  /* 4129 */
>-	__glXDispSwap_SecondaryColor3dv,  /* 4130 */
>-	__glXDispSwap_SecondaryColor3ubv, /* 4131 */
>-	__glXDispSwap_SecondaryColor3usv, /* 4132 */
>-	__glXDispSwap_SecondaryColor3uiv, /* 4133 */
>-	__glXDisp_BlendFuncSeparate,      /* 4134 */
>+	__glXDispSwap_FogCoordfvEXT,         /* 4124 */
>+	__glXDispSwap_FogCoorddvEXT,         /* 4125 */
>+	__glXDispSwap_SecondaryColor3bvEXT,  /* 4126 */
>+	__glXDispSwap_SecondaryColor3svEXT,  /* 4127 */
>+	__glXDispSwap_SecondaryColor3ivEXT,  /* 4128 */
>+	__glXDispSwap_SecondaryColor3fvEXT,  /* 4129 */
>+	__glXDispSwap_SecondaryColor3dvEXT,  /* 4130 */
>+	__glXDispSwap_SecondaryColor3ubvEXT, /* 4131 */
>+	__glXDispSwap_SecondaryColor3usvEXT, /* 4132 */
>+	__glXDispSwap_SecondaryColor3uivEXT, /* 4133 */
>+	__glXDisp_BlendFuncSeparateEXT,      /* 4134 */
> #else
> 	__glXNoSuchRenderOpcode,          /* 4124 */
> 	__glXNoSuchRenderOpcode,          /* 4125 */
>@@ -4440,7 +4442,7 @@
> };
> __GLXdispatchVendorPrivProcPtr __glXSwapVendorPrivTable_EXT[__GLX_MAX_VENDPRIV_OPCODE_EXT - __GLX_MIN_VENDPRIV_OPCODE_EXT + 1] = {
> 	__glXDispSwap_AreTexturesResidentEXT, /* 11 */
>-	__glXDispSwap_DeleteTexturesEXT, /* 12 */
>+	__glXDispSwap_DeleteTextures, /* 12 */
> 	__glXDispSwap_GenTexturesEXT, /* 13 */
> 	__glXDispSwap_IsTextureEXT, /* 14 */
> };
>Index: xorg/GL/glx/g_disptab_EXT.h
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/g_disptab_EXT.h,v
>retrieving revision 1.4
>diff -u -d -r1.4 g_disptab_EXT.h
>--- xorg/GL/glx/g_disptab_EXT.h	12 Aug 2005 16:30:57 -0000	1.4
>+++ xorg/GL/glx/g_disptab_EXT.h	12 Jan 2006 00:04:15 -0000
>@@ -35,117 +35,6 @@
> ** version 1.2.1 Specification.
> */
> 
>-extern int __glXDisp_AreTexturesResidentEXT(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_DeleteTexturesEXT(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_GenTexturesEXT(__GLXclientState*, GLbyte*);
>-extern int __glXDisp_IsTextureEXT(__GLXclientState*, GLbyte*);
>-
>-extern void __glXDisp_ColorTable(GLbyte*);
>-extern void __glXDisp_ColorTableParameterfv(GLbyte*);
>-extern void __glXDisp_ColorTableParameteriv(GLbyte*);
>-extern void __glXDisp_CopyColorTable(GLbyte*);
>-extern void __glXDisp_BlendColor(GLbyte*);
>-extern void __glXDisp_BlendEquation(GLbyte*);
>-extern void __glXDisp_TexSubImage1D(GLbyte*);
>-extern void __glXDisp_TexSubImage2D(GLbyte*);
>-extern void __glXDisp_ConvolutionFilter1D(GLbyte*);
>-extern void __glXDisp_ConvolutionFilter2D(GLbyte*);
>-extern void __glXDisp_ConvolutionParameterf(GLbyte*);
>-extern void __glXDisp_ConvolutionParameterfv(GLbyte*);
>-extern void __glXDisp_ConvolutionParameteri(GLbyte*);
>-extern void __glXDisp_ConvolutionParameteriv(GLbyte*);
>-extern void __glXDisp_CopyConvolutionFilter1D(GLbyte*);
>-extern void __glXDisp_CopyConvolutionFilter2D(GLbyte*);
>-extern void __glXDisp_SeparableFilter2D(GLbyte*);
>-extern void __glXDisp_Histogram(GLbyte*);
>-extern void __glXDisp_Minmax(GLbyte*);
>-extern void __glXDisp_ResetHistogram(GLbyte*);
>-extern void __glXDisp_ResetMinmax(GLbyte*);
>-extern void __glXDisp_TexImage3D(GLbyte*);
>-extern void __glXDisp_TexSubImage3D(GLbyte*);
>-extern void __glXDisp_DrawArraysEXT(GLbyte*);
>-extern void __glXDisp_BindTexture(GLbyte*);
>-extern void __glXDisp_PrioritizeTextures(GLbyte*);
>-extern void __glXDisp_CopyTexImage1D(GLbyte*);
>-extern void __glXDisp_CopyTexImage2D(GLbyte*);
>-extern void __glXDisp_CopyTexSubImage1D(GLbyte*);
>-extern void __glXDisp_CopyTexSubImage2D(GLbyte*);
>-extern void __glXDisp_CopyTexSubImage3D(GLbyte*);
>-extern void __glXDisp_PointParameterfARB(GLbyte*);
>-extern void __glXDisp_PointParameterfvARB(GLbyte*);
>-
>-extern void __glXDisp_FogCoordfv(GLbyte *);
>-extern void __glXDisp_FogCoorddv(GLbyte *);
>-extern void __glXDispSwap_FogCoordfv(GLbyte *);
>-extern void __glXDispSwap_FogCoorddv(GLbyte *);
>-
>-extern void __glXDisp_SecondaryColor3bv(GLbyte *);
>-extern void __glXDisp_SecondaryColor3sv(GLbyte *);
>-extern void __glXDisp_SecondaryColor3iv(GLbyte *);
>-extern void __glXDisp_SecondaryColor3ubv(GLbyte *);
>-extern void __glXDisp_SecondaryColor3usv(GLbyte *);
>-extern void __glXDisp_SecondaryColor3uiv(GLbyte *);
>-extern void __glXDisp_SecondaryColor3fv(GLbyte *);
>-extern void __glXDisp_SecondaryColor3dv(GLbyte *);
>-extern void __glXDispSwap_SecondaryColor3bv(GLbyte *);
>-extern void __glXDispSwap_SecondaryColor3sv(GLbyte *);
>-extern void __glXDispSwap_SecondaryColor3iv(GLbyte *);
>-extern void __glXDispSwap_SecondaryColor3ubv(GLbyte *);
>-extern void __glXDispSwap_SecondaryColor3usv(GLbyte *);
>-extern void __glXDispSwap_SecondaryColor3uiv(GLbyte *);
>-extern void __glXDispSwap_SecondaryColor3fv(GLbyte *);
>-extern void __glXDispSwap_SecondaryColor3dv(GLbyte *);
>-
>-extern void __glXDisp_BlendFuncSeparate(GLbyte *);
>-extern void __glXDispSwap_BlendFuncSeparate(GLbyte *);
>-
>-extern void __glXDisp_PointParameteriNV(GLbyte *);
>-extern void __glXDisp_PointParameterivNV(GLbyte *);
>-extern void __glXDispSwap_PointParameteriNV(GLbyte *);
>-extern void __glXDispSwap_PointParameterivNV(GLbyte *);
>-
>-extern void __glXDisp_ActiveStencilFaceEXT(GLbyte*);
>-
>-extern int __glXDispSwap_AreTexturesResidentEXT(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_DeleteTexturesEXT(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_GenTexturesEXT(__GLXclientState*, GLbyte*);
>-extern int __glXDispSwap_IsTextureEXT(__GLXclientState*, GLbyte*);
>-
>-extern void __glXDispSwap_ColorTable(GLbyte*);
>-extern void __glXDispSwap_ColorTableParameterfv(GLbyte*);
>-extern void __glXDispSwap_ColorTableParameteriv(GLbyte*);
>-extern void __glXDispSwap_CopyColorTable(GLbyte*);
>-extern void __glXDispSwap_BlendColor(GLbyte*);
>-extern void __glXDispSwap_BlendEquation(GLbyte*);
>-extern void __glXDispSwap_TexSubImage1D(GLbyte*);
>-extern void __glXDispSwap_TexSubImage2D(GLbyte*);
>-extern void __glXDispSwap_ConvolutionFilter1D(GLbyte*);
>-extern void __glXDispSwap_ConvolutionFilter2D(GLbyte*);
>-extern void __glXDispSwap_ConvolutionParameterf(GLbyte*);
>-extern void __glXDispSwap_ConvolutionParameterfv(GLbyte*);
>-extern void __glXDispSwap_ConvolutionParameteri(GLbyte*);
>-extern void __glXDispSwap_ConvolutionParameteriv(GLbyte*);
>-extern void __glXDispSwap_CopyConvolutionFilter1D(GLbyte*);
>-extern void __glXDispSwap_CopyConvolutionFilter2D(GLbyte*);
>-extern void __glXDispSwap_SeparableFilter2D(GLbyte*);
>-extern void __glXDispSwap_Histogram(GLbyte*);
>-extern void __glXDispSwap_Minmax(GLbyte*);
>-extern void __glXDispSwap_ResetHistogram(GLbyte*);
>-extern void __glXDispSwap_ResetMinmax(GLbyte*);
>-extern void __glXDispSwap_TexImage3D(GLbyte*);
>-extern void __glXDispSwap_TexSubImage3D(GLbyte*);
>-extern void __glXDispSwap_DrawArraysEXT(GLbyte*);
>-extern void __glXDispSwap_BindTexture(GLbyte*);
>-extern void __glXDispSwap_PrioritizeTextures(GLbyte*);
>-extern void __glXDispSwap_CopyTexImage1D(GLbyte*);
>-extern void __glXDispSwap_CopyTexImage2D(GLbyte*);
>-extern void __glXDispSwap_CopyTexSubImage1D(GLbyte*);
>-extern void __glXDispSwap_CopyTexSubImage2D(GLbyte*);
>-extern void __glXDispSwap_CopyTexSubImage3D(GLbyte*);
>-extern void __glXDispSwap_PointParameterfARB(GLbyte*);
>-extern void __glXDispSwap_PointParameterfvARB(GLbyte*);
>-extern void __glXDispSwap_ActiveStencilFaceEXT(GLbyte*);
>-
> #define __GLX_MIN_RENDER_OPCODE_EXT 2053
> #define __GLX_MAX_RENDER_OPCODE_EXT 4222
> #define __GLX_MIN_VENDPRIV_OPCODE_EXT 11
>Index: xorg/GL/glx/g_render.c
>===================================================================
>RCS file: xorg/GL/glx/g_render.c
>diff -N xorg/GL/glx/g_render.c
>--- xorg/GL/glx/g_render.c	12 Aug 2005 16:30:57 -0000	1.5
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,2282 +0,0 @@
>-/* $XFree86: xc/programs/Xserver/GL/glx/g_render.c,v 1.8 2004/02/03 21:34:36 alanh Exp $ */
>-/* DO NOT EDIT - THIS FILE IS AUTOMATICALLY GENERATED */
>-/*
>-** License Applicability. Except to the extent portions of this file are
>-** made subject to an alternative license as permitted in the SGI Free
>-** Software License B, Version 1.1 (the "License"), the contents of this
>-** file are subject only to the provisions of the License. You may not use
>-** this file except in compliance with the License. You may obtain a copy
>-** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
>-** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
>-** 
>-** http://oss.sgi.com/projects/FreeB
>-** 
>-** Note that, as provided in the License, the Software is distributed on an
>-** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
>-** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
>-** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
>-** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
>-** 
>-** Original Code. The Original Code is: OpenGL Sample Implementation,
>-** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
>-** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
>-** Copyright in any portions created by third parties is as indicated
>-** elsewhere herein. All Rights Reserved.
>-** 
>-** Additional Notice Provisions: This software was created using the
>-** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
>-** not been independently verified as being compliant with the OpenGL(R)
>-** version 1.2.1 Specification.
>-*/
>-
>-#define NEED_REPLIES
>-#ifdef HAVE_DIX_CONFIG_H
>-#include <dix-config.h>
>-#endif
>-
>-#include "glxserver.h"
>-#include "glxext.h"
>-#include "g_disptab.h"
>-#include "g_disptab_EXT.h"
>-#include "unpack.h"
>-#include "impsize.h"
>-#include "singlesize.h"
>-
>-void __glXDisp_CallList(GLbyte *pc)
>-{
>-	glCallList( 
>-		*(GLuint   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_ListBase(GLbyte *pc)
>-{
>-	glListBase( 
>-		*(GLuint   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Begin(GLbyte *pc)
>-{
>-	glBegin( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-#define __GLX_SWAP_GLbyte(ptr)
>-#define __GLX_SWAP_GLshort(ptr)  __GLX_SWAP_SHORT(ptr)
>-#define __GLX_SWAP_GLint(ptr)    __GLX_SWAP_INT(ptr)
>-#define __GLX_SWAP_GLubyte(ptr)
>-#define __GLX_SWAP_GLushort(ptr) __GLX_SWAP_SHORT(ptr)
>-#define __GLX_SWAP_GLuint(ptr)   __GLX_SWAP_INT(ptr)
>-#define __GLX_SWAP_GLdouble(ptr) __GLX_SWAP_DOUBLE(ptr)
>-#define __GLX_SWAP_GLfloat(ptr)  __GLX_SWAP_FLOAT(ptr)
>-
>-#define __GLX_SWAP_GLbyte_ARRAY(ptr,count)   (void) swapEnd; (void) swapPC; (void) sw;
>-#define __GLX_SWAP_GLshort_ARRAY(ptr,count)  __GLX_SWAP_SHORT_ARRAY(ptr,count)
>-#define __GLX_SWAP_GLint_ARRAY(ptr,count)    __GLX_SWAP_INT_ARRAY(ptr,count)
>-#define __GLX_SWAP_GLenum_ARRAY(ptr,count)   __GLX_SWAP_INT_ARRAY(ptr,count)
>-#define __GLX_SWAP_GLubyte_ARRAY(ptr,count)  (void) swapEnd; (void) swapPC; (void) sw;
>-#define __GLX_SWAP_GLushort_ARRAY(ptr,count) __GLX_SWAP_SHORT_ARRAY(ptr,count)
>-#define __GLX_SWAP_GLuint_ARRAY(ptr,count)   __GLX_SWAP_INT_ARRAY(ptr,count)
>-#define __GLX_SWAP_GLdouble_ARRAY(ptr,count) __GLX_SWAP_DOUBLE_ARRAY(ptr,count)
>-#define __GLX_SWAP_GLfloat_ARRAY(ptr,count)  __GLX_SWAP_FLOAT_ARRAY(ptr,count)
>-
>-#ifdef __GLX_ALIGN64
>-/* If type is not GLdouble, the compiler should optimize this away.
>- */
>-# define GLX_DO_ALIGN_MAGIC(count, type) \
>-	do { \
>-	    if ( (sizeof(type) == 8) && ((unsigned long)(pc) & 7)) \
>-	    { \
>-	       	__GLX_MEM_COPY(pc-4, pc, (count * sizeof( type ) )); \
>-	    	pc -= 4; \
>-	    } \
>-	} while( 0 )
>-#else
>-# define GLX_DO_ALIGN_MAGIC(count, type)
>-#endif
>-
>-#define dispatch_template_1( name, type ) \
>-    void __glXDisp_ ## name ( GLbyte * pc ) \
>-    { \
>-	GLX_DO_ALIGN_MAGIC( 1, type ); \
>-	gl ## name ( (type *) pc ); \
>-    } \
>-    void __glXDispSwap_ ## name ( GLbyte * pc ) \
>-    { \
>-	__GLX_DECLARE_SWAP_VARIABLES; \
>-	GLX_DO_ALIGN_MAGIC( 1, type ); \
>-	__GLX_SWAP_ ## type ( pc ); \
>-	gl ## name ( (type *) pc ); \
>-    }
>-
>-#define dispatch_template_3( name, type ) \
>-    void __glXDisp_ ## name ( GLbyte * pc ) \
>-    { \
>-	GLX_DO_ALIGN_MAGIC( 3, type ); \
>-	gl ## name ( (type *) pc ); \
>-    } \
>-    void __glXDispSwap_ ## name ( GLbyte * pc ) \
>-    { \
>-	__GLX_DECLARE_SWAP_VARIABLES; \
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES; \
>-	GLX_DO_ALIGN_MAGIC( 3, type ); \
>-	__GLX_SWAP_ ## type ## _ARRAY(pc, 3); \
>-	gl ## name ( (type *) pc ); \
>-    }
>-
>-#define dispatch_template_4( name, type ) \
>-    void __glXDisp_ ## name ( GLbyte * pc ) \
>-    { \
>-	GLX_DO_ALIGN_MAGIC( 4, type ); \
>-	gl ## name ( (type *) pc ); \
>-    } \
>-    void __glXDispSwap_ ## name ( GLbyte * pc ) \
>-    { \
>-	__GLX_DECLARE_SWAP_VARIABLES; \
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES; \
>-	GLX_DO_ALIGN_MAGIC( 4, type ); \
>-	__GLX_SWAP_ ## type ## _ARRAY(pc, 4); \
>-	gl ## name ( (type *) pc ); \
>-    }
>-
>-#define dispatch_template_4s( name, type ) \
>-    void __glXDisp_ ## name ( GLbyte * pc ) \
>-    { \
>-	GLX_DO_ALIGN_MAGIC( 4, type ); \
>-	gl ## name ( ((type *) pc)[0], ((type *) pc)[1], \
>-		     ((type *) pc)[2], ((type *) pc)[3] ); \
>-    } \
>-    void __glXDispSwap_ ## name ( GLbyte * pc ) \
>-    { \
>-	__GLX_DECLARE_SWAP_VARIABLES; \
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES; \
>-	GLX_DO_ALIGN_MAGIC( 4, type ); \
>-	__GLX_SWAP_ ## type ## _ARRAY(pc, 4); \
>-	gl ## name ( ((type *) pc)[0], ((type *) pc)[1], \
>-		     ((type *) pc)[2], ((type *) pc)[3] ); \
>-    }
>-
>-/**
>- * \bug All of the enum1 templates need to be updated to handle the case where
>- * \c type is \c GLdouble.  When the type is a double, the data comes before
>- * the enum.  This is also the reason the invocation of the
>- * \c GLX_DO_ALIGN_MAGIC macro was removed.
>- */
>-#define dispatch_template_enum1_1s( name, type ) \
>-    void __glXDisp_ ## name ( GLbyte * pc ) \
>-    { \
>-	gl ## name ( *(GLenum *) (pc + 0), \
>-		     *(type *)   (pc + 4) ); \
>-    } \
>-    void __glXDispSwap_ ## name ( GLbyte * pc ) \
>-    { \
>-	__GLX_DECLARE_SWAP_VARIABLES; \
>-	__GLX_SWAP_INT      (pc + 0); \
>-	__GLX_SWAP_ ## type (pc + 4); \
>-	gl ## name ( *(GLenum *) (pc + 0), \
>-		     *(type *)   (pc + 4) ); \
>-    }
>-
>-#define dispatch_template_enum1_Vv( name, type ) \
>-    void __glXDisp_ ## name ( GLbyte * pc ) \
>-    { \
>-	gl ## name ( *(GLenum *) (pc + 0), \
>-		      (type *)   (pc + 4) ); \
>-    } \
>-    void __glXDispSwap_ ## name ( GLbyte * pc ) \
>-    { \
>-	GLenum pname; GLint compsize; \
>-	__GLX_DECLARE_SWAP_VARIABLES; \
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES; \
>-	__GLX_SWAP_INT(pc + 0); \
>-	pname = *(GLenum *)(pc + 0); \
>-	compsize = __gl ## name ## _size(pname); \
>-	if (compsize < 0) compsize = 0; \
>-	__GLX_SWAP_ ## type ## _ARRAY(pc + 4, compsize); \
>-	gl ## name ( *(GLenum *) (pc + 0), \
>-		      (type *)   (pc + 4) ); \
>-    }
>-
>-#ifndef MISSING_GL_EXTS
>-dispatch_template_1( FogCoordfv,         GLfloat )
>-dispatch_template_1( FogCoorddv,         GLdouble )
>-dispatch_template_3( SecondaryColor3bv,  GLbyte )
>-dispatch_template_3( SecondaryColor3sv,  GLshort )
>-dispatch_template_3( SecondaryColor3iv,  GLint )
>-dispatch_template_3( SecondaryColor3ubv, GLubyte )
>-dispatch_template_3( SecondaryColor3usv, GLushort )
>-dispatch_template_3( SecondaryColor3uiv, GLuint )
>-dispatch_template_3( SecondaryColor3fv,  GLfloat )
>-dispatch_template_3( SecondaryColor3dv,  GLdouble )
>-
>-dispatch_template_4s( BlendFuncSeparate,  GLenum )
>-#endif /* !MISSING_GL_EXTS */
>-
>-void __glXDisp_Color3bv(GLbyte *pc)
>-{
>-	glColor3bv( 
>-		(GLbyte   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Color3dv(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 24);
>-	    pc -= 4;
>-	}
>-#endif
>-	glColor3dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Color3fv(GLbyte *pc)
>-{
>-	glColor3fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Color3iv(GLbyte *pc)
>-{
>-	glColor3iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Color3sv(GLbyte *pc)
>-{
>-	glColor3sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Color3ubv(GLbyte *pc)
>-{
>-	glColor3ubv( 
>-		(GLubyte  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Color3uiv(GLbyte *pc)
>-{
>-	glColor3uiv( 
>-		(GLuint   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Color3usv(GLbyte *pc)
>-{
>-	glColor3usv( 
>-		(GLushort *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Color4bv(GLbyte *pc)
>-{
>-	glColor4bv( 
>-		(GLbyte   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Color4dv(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 32);
>-	    pc -= 4;
>-	}
>-#endif
>-	glColor4dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Color4fv(GLbyte *pc)
>-{
>-	glColor4fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Color4iv(GLbyte *pc)
>-{
>-	glColor4iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Color4sv(GLbyte *pc)
>-{
>-	glColor4sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Color4ubv(GLbyte *pc)
>-{
>-	glColor4ubv( 
>-		(GLubyte  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Color4uiv(GLbyte *pc)
>-{
>-	glColor4uiv( 
>-		(GLuint   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Color4usv(GLbyte *pc)
>-{
>-	glColor4usv( 
>-		(GLushort *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_EdgeFlagv(GLbyte *pc)
>-{
>-	glEdgeFlagv( 
>-		(GLboolean *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_End(GLbyte *pc)
>-{
>-	glEnd( 
>-	);
>-}
>-
>-void __glXDisp_Indexdv(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 8);
>-	    pc -= 4;
>-	}
>-#endif
>-	glIndexdv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Indexfv(GLbyte *pc)
>-{
>-	glIndexfv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Indexiv(GLbyte *pc)
>-{
>-	glIndexiv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Indexsv(GLbyte *pc)
>-{
>-	glIndexsv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Normal3bv(GLbyte *pc)
>-{
>-	glNormal3bv( 
>-		(GLbyte   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Normal3dv(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 24);
>-	    pc -= 4;
>-	}
>-#endif
>-	glNormal3dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Normal3fv(GLbyte *pc)
>-{
>-	glNormal3fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Normal3iv(GLbyte *pc)
>-{
>-	glNormal3iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Normal3sv(GLbyte *pc)
>-{
>-	glNormal3sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_RasterPos2dv(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 16);
>-	    pc -= 4;
>-	}
>-#endif
>-	glRasterPos2dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_RasterPos2fv(GLbyte *pc)
>-{
>-	glRasterPos2fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_RasterPos2iv(GLbyte *pc)
>-{
>-	glRasterPos2iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_RasterPos2sv(GLbyte *pc)
>-{
>-	glRasterPos2sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_RasterPos3dv(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 24);
>-	    pc -= 4;
>-	}
>-#endif
>-	glRasterPos3dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_RasterPos3fv(GLbyte *pc)
>-{
>-	glRasterPos3fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_RasterPos3iv(GLbyte *pc)
>-{
>-	glRasterPos3iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_RasterPos3sv(GLbyte *pc)
>-{
>-	glRasterPos3sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_RasterPos4dv(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 32);
>-	    pc -= 4;
>-	}
>-#endif
>-	glRasterPos4dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_RasterPos4fv(GLbyte *pc)
>-{
>-	glRasterPos4fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_RasterPos4iv(GLbyte *pc)
>-{
>-	glRasterPos4iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_RasterPos4sv(GLbyte *pc)
>-{
>-	glRasterPos4sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Rectdv(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 32);
>-	    pc -= 4;
>-	}
>-#endif
>-	glRectdv( 
>-		(GLdouble *)(pc + 0),
>-		(GLdouble *)(pc + 16)
>-	);
>-}
>-
>-void __glXDisp_Rectfv(GLbyte *pc)
>-{
>-	glRectfv( 
>-		(GLfloat  *)(pc + 0),
>-		(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_Rectiv(GLbyte *pc)
>-{
>-	glRectiv( 
>-		(GLint    *)(pc + 0),
>-		(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_Rectsv(GLbyte *pc)
>-{
>-	glRectsv( 
>-		(GLshort  *)(pc + 0),
>-		(GLshort  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_TexCoord1dv(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 8);
>-	    pc -= 4;
>-	}
>-#endif
>-	glTexCoord1dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_TexCoord1fv(GLbyte *pc)
>-{
>-	glTexCoord1fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_TexCoord1iv(GLbyte *pc)
>-{
>-	glTexCoord1iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_TexCoord1sv(GLbyte *pc)
>-{
>-	glTexCoord1sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_TexCoord2dv(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 16);
>-	    pc -= 4;
>-	}
>-#endif
>-	glTexCoord2dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_TexCoord2fv(GLbyte *pc)
>-{
>-	glTexCoord2fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_TexCoord2iv(GLbyte *pc)
>-{
>-	glTexCoord2iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_TexCoord2sv(GLbyte *pc)
>-{
>-	glTexCoord2sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_TexCoord3dv(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 24);
>-	    pc -= 4;
>-	}
>-#endif
>-	glTexCoord3dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_TexCoord3fv(GLbyte *pc)
>-{
>-	glTexCoord3fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_TexCoord3iv(GLbyte *pc)
>-{
>-	glTexCoord3iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_TexCoord3sv(GLbyte *pc)
>-{
>-	glTexCoord3sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_TexCoord4dv(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 32);
>-	    pc -= 4;
>-	}
>-#endif
>-	glTexCoord4dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_TexCoord4fv(GLbyte *pc)
>-{
>-	glTexCoord4fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_TexCoord4iv(GLbyte *pc)
>-{
>-	glTexCoord4iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_TexCoord4sv(GLbyte *pc)
>-{
>-	glTexCoord4sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Vertex2dv(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 16);
>-	    pc -= 4;
>-	}
>-#endif
>-	glVertex2dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Vertex2fv(GLbyte *pc)
>-{
>-	glVertex2fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Vertex2iv(GLbyte *pc)
>-{
>-	glVertex2iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Vertex2sv(GLbyte *pc)
>-{
>-	glVertex2sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Vertex3dv(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 24);
>-	    pc -= 4;
>-	}
>-#endif
>-	glVertex3dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Vertex3fv(GLbyte *pc)
>-{
>-	glVertex3fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Vertex3iv(GLbyte *pc)
>-{
>-	glVertex3iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Vertex3sv(GLbyte *pc)
>-{
>-	glVertex3sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Vertex4dv(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 32);
>-	    pc -= 4;
>-	}
>-#endif
>-	glVertex4dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Vertex4fv(GLbyte *pc)
>-{
>-	glVertex4fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Vertex4iv(GLbyte *pc)
>-{
>-	glVertex4iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Vertex4sv(GLbyte *pc)
>-{
>-	glVertex4sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_ClipPlane(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 36);
>-	    pc -= 4;
>-	}
>-#endif
>-	glClipPlane( 
>-		*(GLenum   *)(pc + 32),
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_ColorMaterial(GLbyte *pc)
>-{
>-	glColorMaterial( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_CullFace(GLbyte *pc)
>-{
>-	glCullFace( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Fogf(GLbyte *pc)
>-{
>-	glFogf( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_Fogfv(GLbyte *pc)
>-{
>-	glFogfv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_Fogi(GLbyte *pc)
>-{
>-	glFogi( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_Fogiv(GLbyte *pc)
>-{
>-	glFogiv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_FrontFace(GLbyte *pc)
>-{
>-	glFrontFace( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Hint(GLbyte *pc)
>-{
>-	glHint( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_Lightf(GLbyte *pc)
>-{
>-	glLightf( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_Lightfv(GLbyte *pc)
>-{
>-	glLightfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_Lighti(GLbyte *pc)
>-{
>-	glLighti( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_Lightiv(GLbyte *pc)
>-{
>-	glLightiv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_LightModelf(GLbyte *pc)
>-{
>-	glLightModelf( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_LightModelfv(GLbyte *pc)
>-{
>-	glLightModelfv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_LightModeli(GLbyte *pc)
>-{
>-	glLightModeli( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_LightModeliv(GLbyte *pc)
>-{
>-	glLightModeliv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_LineStipple(GLbyte *pc)
>-{
>-	glLineStipple( 
>-		*(GLint    *)(pc + 0),
>-		*(GLushort *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_LineWidth(GLbyte *pc)
>-{
>-	glLineWidth( 
>-		*(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Materialf(GLbyte *pc)
>-{
>-	glMaterialf( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_Materialfv(GLbyte *pc)
>-{
>-	glMaterialfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_Materiali(GLbyte *pc)
>-{
>-	glMateriali( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_Materialiv(GLbyte *pc)
>-{
>-	glMaterialiv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_PointSize(GLbyte *pc)
>-{
>-	glPointSize( 
>-		*(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_PolygonMode(GLbyte *pc)
>-{
>-	glPolygonMode( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_Scissor(GLbyte *pc)
>-{
>-	glScissor( 
>-		*(GLint    *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLsizei  *)(pc + 8),
>-		*(GLsizei  *)(pc + 12)
>-	);
>-}
>-
>-void __glXDisp_ShadeModel(GLbyte *pc)
>-{
>-	glShadeModel( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_TexParameterf(GLbyte *pc)
>-{
>-	glTexParameterf( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_TexParameterfv(GLbyte *pc)
>-{
>-	glTexParameterfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_TexParameteri(GLbyte *pc)
>-{
>-	glTexParameteri( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_TexParameteriv(GLbyte *pc)
>-{
>-	glTexParameteriv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_TexEnvf(GLbyte *pc)
>-{
>-	glTexEnvf( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_TexEnvfv(GLbyte *pc)
>-{
>-	glTexEnvfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_TexEnvi(GLbyte *pc)
>-{
>-	glTexEnvi( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_TexEnviv(GLbyte *pc)
>-{
>-	glTexEnviv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_TexGend(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 16);
>-	    pc -= 4;
>-	}
>-#endif
>-	glTexGend( 
>-		*(GLenum   *)(pc + 8),
>-		*(GLenum   *)(pc + 12),
>-		*(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_TexGendv(GLbyte *pc)
>-{
>-#ifdef __GLX_ALIGN64
>-	GLenum pname;
>-	GLint cmdlen;
>-	GLint compsize;
>-
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glTexGendv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	cmdlen = __GLX_PAD(8+compsize*8);
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, cmdlen);
>-	    pc -= 4;
>-	}
>-#endif
>-
>-	glTexGendv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLdouble *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_TexGenf(GLbyte *pc)
>-{
>-	glTexGenf( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_TexGenfv(GLbyte *pc)
>-{
>-	glTexGenfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_TexGeni(GLbyte *pc)
>-{
>-	glTexGeni( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_TexGeniv(GLbyte *pc)
>-{
>-	glTexGeniv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_InitNames(GLbyte *pc)
>-{
>-	glInitNames( 
>-	);
>-}
>-
>-void __glXDisp_LoadName(GLbyte *pc)
>-{
>-	glLoadName( 
>-		*(GLuint   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_PassThrough(GLbyte *pc)
>-{
>-	glPassThrough( 
>-		*(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_PopName(GLbyte *pc)
>-{
>-	glPopName( 
>-	);
>-}
>-
>-void __glXDisp_PushName(GLbyte *pc)
>-{
>-	glPushName( 
>-		*(GLuint   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_DrawBuffer(GLbyte *pc)
>-{
>-	glDrawBuffer( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Clear(GLbyte *pc)
>-{
>-	glClear( 
>-		*(GLbitfield *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_ClearAccum(GLbyte *pc)
>-{
>-	glClearAccum( 
>-		*(GLfloat  *)(pc + 0),
>-		*(GLfloat  *)(pc + 4),
>-		*(GLfloat  *)(pc + 8),
>-		*(GLfloat  *)(pc + 12)
>-	);
>-}
>-
>-void __glXDisp_ClearIndex(GLbyte *pc)
>-{
>-	glClearIndex( 
>-		*(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_ClearColor(GLbyte *pc)
>-{
>-	glClearColor( 
>-		*(GLclampf *)(pc + 0),
>-		*(GLclampf *)(pc + 4),
>-		*(GLclampf *)(pc + 8),
>-		*(GLclampf *)(pc + 12)
>-	);
>-}
>-
>-void __glXDisp_ClearStencil(GLbyte *pc)
>-{
>-	glClearStencil( 
>-		*(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_ClearDepth(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 8);
>-	    pc -= 4;
>-	}
>-#endif
>-	glClearDepth( 
>-		*(GLclampd *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_StencilMask(GLbyte *pc)
>-{
>-	glStencilMask( 
>-		*(GLuint   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_ColorMask(GLbyte *pc)
>-{
>-	glColorMask( 
>-		*(GLboolean *)(pc + 0),
>-		*(GLboolean *)(pc + 1),
>-		*(GLboolean *)(pc + 2),
>-		*(GLboolean *)(pc + 3)
>-	);
>-}
>-
>-void __glXDisp_DepthMask(GLbyte *pc)
>-{
>-	glDepthMask( 
>-		*(GLboolean *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_IndexMask(GLbyte *pc)
>-{
>-	glIndexMask( 
>-		*(GLuint   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Accum(GLbyte *pc)
>-{
>-	glAccum( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_Disable(GLbyte *pc)
>-{
>-	glDisable( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Enable(GLbyte *pc)
>-{
>-	glEnable( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_PopAttrib(GLbyte *pc)
>-{
>-	glPopAttrib( 
>-	);
>-}
>-
>-void __glXDisp_PushAttrib(GLbyte *pc)
>-{
>-	glPushAttrib( 
>-		*(GLbitfield *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_MapGrid1d(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 20);
>-	    pc -= 4;
>-	}
>-#endif
>-	glMapGrid1d( 
>-		*(GLint    *)(pc + 16),
>-		*(GLdouble *)(pc + 0),
>-		*(GLdouble *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_MapGrid1f(GLbyte *pc)
>-{
>-	glMapGrid1f( 
>-		*(GLint    *)(pc + 0),
>-		*(GLfloat  *)(pc + 4),
>-		*(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_MapGrid2d(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 40);
>-	    pc -= 4;
>-	}
>-#endif
>-	glMapGrid2d( 
>-		*(GLint    *)(pc + 32),
>-		*(GLdouble *)(pc + 0),
>-		*(GLdouble *)(pc + 8),
>-		*(GLint    *)(pc + 36),
>-		*(GLdouble *)(pc + 16),
>-		*(GLdouble *)(pc + 24)
>-	);
>-}
>-
>-void __glXDisp_MapGrid2f(GLbyte *pc)
>-{
>-	glMapGrid2f( 
>-		*(GLint    *)(pc + 0),
>-		*(GLfloat  *)(pc + 4),
>-		*(GLfloat  *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLfloat  *)(pc + 16),
>-		*(GLfloat  *)(pc + 20)
>-	);
>-}
>-
>-void __glXDisp_EvalCoord1dv(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 8);
>-	    pc -= 4;
>-	}
>-#endif
>-	glEvalCoord1dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_EvalCoord1fv(GLbyte *pc)
>-{
>-	glEvalCoord1fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_EvalCoord2dv(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 16);
>-	    pc -= 4;
>-	}
>-#endif
>-	glEvalCoord2dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_EvalCoord2fv(GLbyte *pc)
>-{
>-	glEvalCoord2fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_EvalMesh1(GLbyte *pc)
>-{
>-	glEvalMesh1( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_EvalPoint1(GLbyte *pc)
>-{
>-	glEvalPoint1( 
>-		*(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_EvalMesh2(GLbyte *pc)
>-{
>-	glEvalMesh2( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLint    *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLint    *)(pc + 16)
>-	);
>-}
>-
>-void __glXDisp_EvalPoint2(GLbyte *pc)
>-{
>-	glEvalPoint2( 
>-		*(GLint    *)(pc + 0),
>-		*(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_AlphaFunc(GLbyte *pc)
>-{
>-	glAlphaFunc( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLclampf *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_BlendFunc(GLbyte *pc)
>-{
>-	glBlendFunc( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_LogicOp(GLbyte *pc)
>-{
>-	glLogicOp( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_StencilFunc(GLbyte *pc)
>-{
>-	glStencilFunc( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLuint   *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_StencilOp(GLbyte *pc)
>-{
>-	glStencilOp( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLenum   *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_DepthFunc(GLbyte *pc)
>-{
>-	glDepthFunc( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_PixelZoom(GLbyte *pc)
>-{
>-	glPixelZoom( 
>-		*(GLfloat  *)(pc + 0),
>-		*(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_PixelTransferf(GLbyte *pc)
>-{
>-	glPixelTransferf( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_PixelTransferi(GLbyte *pc)
>-{
>-	glPixelTransferi( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_PixelMapfv(GLbyte *pc)
>-{
>-	glPixelMapfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_PixelMapuiv(GLbyte *pc)
>-{
>-	glPixelMapuiv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		(GLuint   *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_PixelMapusv(GLbyte *pc)
>-{
>-	glPixelMapusv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		(GLushort *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_ReadBuffer(GLbyte *pc)
>-{
>-	glReadBuffer( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_CopyPixels(GLbyte *pc)
>-{
>-	glCopyPixels( 
>-		*(GLint    *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLsizei  *)(pc + 8),
>-		*(GLsizei  *)(pc + 12),
>-		*(GLenum   *)(pc + 16)
>-	);
>-}
>-
>-void __glXDisp_DepthRange(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 16);
>-	    pc -= 4;
>-	}
>-#endif
>-	glDepthRange( 
>-		*(GLclampd *)(pc + 0),
>-		*(GLclampd *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_Frustum(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 48);
>-	    pc -= 4;
>-	}
>-#endif
>-	glFrustum( 
>-		*(GLdouble *)(pc + 0),
>-		*(GLdouble *)(pc + 8),
>-		*(GLdouble *)(pc + 16),
>-		*(GLdouble *)(pc + 24),
>-		*(GLdouble *)(pc + 32),
>-		*(GLdouble *)(pc + 40)
>-	);
>-}
>-
>-void __glXDisp_LoadIdentity(GLbyte *pc)
>-{
>-	glLoadIdentity( 
>-	);
>-}
>-
>-void __glXDisp_LoadMatrixf(GLbyte *pc)
>-{
>-	glLoadMatrixf( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_LoadMatrixd(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 128);
>-	    pc -= 4;
>-	}
>-#endif
>-	glLoadMatrixd( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_MatrixMode(GLbyte *pc)
>-{
>-	glMatrixMode( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_MultMatrixf(GLbyte *pc)
>-{
>-	glMultMatrixf( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_MultMatrixd(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 128);
>-	    pc -= 4;
>-	}
>-#endif
>-	glMultMatrixd( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_Ortho(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 48);
>-	    pc -= 4;
>-	}
>-#endif
>-	glOrtho( 
>-		*(GLdouble *)(pc + 0),
>-		*(GLdouble *)(pc + 8),
>-		*(GLdouble *)(pc + 16),
>-		*(GLdouble *)(pc + 24),
>-		*(GLdouble *)(pc + 32),
>-		*(GLdouble *)(pc + 40)
>-	);
>-}
>-
>-void __glXDisp_PopMatrix(GLbyte *pc)
>-{
>-	glPopMatrix( 
>-	);
>-}
>-
>-void __glXDisp_PushMatrix(GLbyte *pc)
>-{
>-	glPushMatrix( 
>-	);
>-}
>-
>-void __glXDisp_Rotated(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 32);
>-	    pc -= 4;
>-	}
>-#endif
>-	glRotated( 
>-		*(GLdouble *)(pc + 0),
>-		*(GLdouble *)(pc + 8),
>-		*(GLdouble *)(pc + 16),
>-		*(GLdouble *)(pc + 24)
>-	);
>-}
>-
>-void __glXDisp_Rotatef(GLbyte *pc)
>-{
>-	glRotatef( 
>-		*(GLfloat  *)(pc + 0),
>-		*(GLfloat  *)(pc + 4),
>-		*(GLfloat  *)(pc + 8),
>-		*(GLfloat  *)(pc + 12)
>-	);
>-}
>-
>-void __glXDisp_Scaled(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 24);
>-	    pc -= 4;
>-	}
>-#endif
>-	glScaled( 
>-		*(GLdouble *)(pc + 0),
>-		*(GLdouble *)(pc + 8),
>-		*(GLdouble *)(pc + 16)
>-	);
>-}
>-
>-void __glXDisp_Scalef(GLbyte *pc)
>-{
>-	glScalef( 
>-		*(GLfloat  *)(pc + 0),
>-		*(GLfloat  *)(pc + 4),
>-		*(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_Translated(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 24);
>-	    pc -= 4;
>-	}
>-#endif
>-	glTranslated( 
>-		*(GLdouble *)(pc + 0),
>-		*(GLdouble *)(pc + 8),
>-		*(GLdouble *)(pc + 16)
>-	);
>-}
>-
>-void __glXDisp_Translatef(GLbyte *pc)
>-{
>-	glTranslatef( 
>-		*(GLfloat  *)(pc + 0),
>-		*(GLfloat  *)(pc + 4),
>-		*(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_Viewport(GLbyte *pc)
>-{
>-	glViewport( 
>-		*(GLint    *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLsizei  *)(pc + 8),
>-		*(GLsizei  *)(pc + 12)
>-	);
>-}
>-
>-void __glXDisp_PolygonOffset(GLbyte *pc)
>-{
>-	glPolygonOffset( 
>-		*(GLfloat  *)(pc + 0),
>-		*(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_CopyTexImage1D(GLbyte *pc)
>-{
>-	glCopyTexImage1D( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLenum   *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLint    *)(pc + 16),
>-		*(GLsizei  *)(pc + 20),
>-		*(GLint    *)(pc + 24)
>-	);
>-}
>-
>-void __glXDisp_CopyTexImage2D(GLbyte *pc)
>-{
>-	glCopyTexImage2D( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLenum   *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLint    *)(pc + 16),
>-		*(GLsizei  *)(pc + 20),
>-		*(GLsizei  *)(pc + 24),
>-		*(GLint    *)(pc + 28)
>-	);
>-}
>-
>-void __glXDisp_CopyTexSubImage1D(GLbyte *pc)
>-{
>-	glCopyTexSubImage1D( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLint    *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLint    *)(pc + 16),
>-		*(GLsizei  *)(pc + 20)
>-	);
>-}
>-
>-void __glXDisp_CopyTexSubImage2D(GLbyte *pc)
>-{
>-	glCopyTexSubImage2D( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLint    *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLint    *)(pc + 16),
>-		*(GLint    *)(pc + 20),
>-		*(GLsizei  *)(pc + 24),
>-		*(GLsizei  *)(pc + 28)
>-	);
>-}
>-
>-void __glXDisp_BindTexture(GLbyte *pc)
>-{
>-	glBindTexture( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLuint   *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_PrioritizeTextures(GLbyte *pc)
>-{
>-	GLsizei n;
>-
>-	n = *(GLsizei *)(pc + 0);
>-
>-	glPrioritizeTextures( 
>-		*(GLsizei  *)(pc + 0),
>-		(GLuint   *)(pc + 4),
>-		(GLclampf *)(pc + 4+n*4)
>-	);
>-}
>-
>-void __glXDisp_Indexubv(GLbyte *pc)
>-{
>-	glIndexubv( 
>-		(GLubyte  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_BlendColor(GLbyte *pc)
>-{
>-	glBlendColor( 
>-		*(GLclampf *)(pc + 0),
>-		*(GLclampf *)(pc + 4),
>-		*(GLclampf *)(pc + 8),
>-		*(GLclampf *)(pc + 12)
>-	);
>-}
>-
>-void __glXDisp_BlendEquation(GLbyte *pc)
>-{
>-	glBlendEquation( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_ColorTableParameterfv(GLbyte *pc)
>-{
>-	glColorTableParameterfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_ColorTableParameteriv(GLbyte *pc)
>-{
>-	glColorTableParameteriv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_CopyColorTable(GLbyte *pc)
>-{
>-	glCopyColorTable( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLint    *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLsizei  *)(pc + 16)
>-	);
>-}
>-
>-void __glXDisp_CopyColorSubTable(GLbyte *pc)
>-{
>-	glCopyColorSubTable( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLsizei  *)(pc + 4),
>-		*(GLint    *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLsizei  *)(pc + 16)
>-	);
>-}
>-
>-void __glXDisp_ConvolutionParameterf(GLbyte *pc)
>-{
>-	glConvolutionParameterf( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_ConvolutionParameterfv(GLbyte *pc)
>-{
>-	glConvolutionParameterfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_ConvolutionParameteri(GLbyte *pc)
>-{
>-	glConvolutionParameteri( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_ConvolutionParameteriv(GLbyte *pc)
>-{
>-	glConvolutionParameteriv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_CopyConvolutionFilter1D(GLbyte *pc)
>-{
>-	glCopyConvolutionFilter1D( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLint    *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLsizei  *)(pc + 16)
>-	);
>-}
>-
>-void __glXDisp_CopyConvolutionFilter2D(GLbyte *pc)
>-{
>-	glCopyConvolutionFilter2D( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLint    *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLsizei  *)(pc + 16),
>-		*(GLsizei  *)(pc + 20)
>-	);
>-}
>-
>-void __glXDisp_Histogram(GLbyte *pc)
>-{
>-	glHistogram( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLsizei  *)(pc + 4),
>-		*(GLenum   *)(pc + 8),
>-		*(GLboolean *)(pc + 12)
>-	);
>-}
>-
>-void __glXDisp_Minmax(GLbyte *pc)
>-{
>-	glMinmax( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLboolean *)(pc + 8)
>-	);
>-}
>-
>-void __glXDisp_ResetHistogram(GLbyte *pc)
>-{
>-	glResetHistogram( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_ResetMinmax(GLbyte *pc)
>-{
>-	glResetMinmax( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_CopyTexSubImage3D(GLbyte *pc)
>-{
>-	glCopyTexSubImage3D( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLint    *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLint    *)(pc + 16),
>-		*(GLint    *)(pc + 20),
>-		*(GLint    *)(pc + 24),
>-		*(GLsizei  *)(pc + 28),
>-		*(GLsizei  *)(pc + 32)
>-	);
>-}
>-
>-void __glXDisp_ActiveTextureARB(GLbyte *pc)
>-{
>-	glActiveTextureARB( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_MultiTexCoord1dvARB(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 12);
>-	    pc -= 4;
>-	}
>-#endif
>-	glMultiTexCoord1dvARB( 
>-		*(GLenum   *)(pc + 8),
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_MultiTexCoord1fvARB(GLbyte *pc)
>-{
>-	glMultiTexCoord1fvARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_MultiTexCoord1ivARB(GLbyte *pc)
>-{
>-	glMultiTexCoord1ivARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_MultiTexCoord1svARB(GLbyte *pc)
>-{
>-	glMultiTexCoord1svARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLshort  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_MultiTexCoord2dvARB(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 20);
>-	    pc -= 4;
>-	}
>-#endif
>-	glMultiTexCoord2dvARB( 
>-		*(GLenum   *)(pc + 16),
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_MultiTexCoord2fvARB(GLbyte *pc)
>-{
>-	glMultiTexCoord2fvARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_MultiTexCoord2ivARB(GLbyte *pc)
>-{
>-	glMultiTexCoord2ivARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_MultiTexCoord2svARB(GLbyte *pc)
>-{
>-	glMultiTexCoord2svARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLshort  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_MultiTexCoord3dvARB(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 28);
>-	    pc -= 4;
>-	}
>-#endif
>-	glMultiTexCoord3dvARB( 
>-		*(GLenum   *)(pc + 24),
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_MultiTexCoord3fvARB(GLbyte *pc)
>-{
>-	glMultiTexCoord3fvARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_MultiTexCoord3ivARB(GLbyte *pc)
>-{
>-	glMultiTexCoord3ivARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_MultiTexCoord3svARB(GLbyte *pc)
>-{
>-	glMultiTexCoord3svARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLshort  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_MultiTexCoord4dvARB(GLbyte *pc)
>-{
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 36);
>-	    pc -= 4;
>-	}
>-#endif
>-	glMultiTexCoord4dvARB( 
>-		*(GLenum   *)(pc + 32),
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_MultiTexCoord4fvARB(GLbyte *pc)
>-{
>-	glMultiTexCoord4fvARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_MultiTexCoord4ivARB(GLbyte *pc)
>-{
>-	glMultiTexCoord4ivARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDisp_MultiTexCoord4svARB(GLbyte *pc)
>-{
>-	glMultiTexCoord4svARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLshort  *)(pc + 4)
>-	);
>-}
>-
>-
>-/*
>- * Extensions
>- */
>-
>-#ifndef MISSING_GL_EXTS
>-
>-void __glXDisp_PointParameterfARB(GLbyte *pc)
>-{
>-	glPointParameterfARB(
>-		*(GLenum *)(pc + 0),
>-		*(GLfloat *)(pc + 4)
>-	);
>-}
>-
>-
>-void __glXDisp_PointParameterfvARB(GLbyte *pc)
>-{
>-	glPointParameterfvARB(
>-		*(GLenum *)(pc + 0),
>-		(GLfloat *)(pc + 4)
>-	);
>-}
>-
>-dispatch_template_enum1_1s(PointParameteriNV,  GLint)
>-dispatch_template_enum1_Vv(PointParameterivNV, GLint)
>-
>-void __glXDisp_ActiveStencilFaceEXT(GLbyte *pc)
>-{
>-	glActiveStencilFaceEXT(
>-		*(GLenum *)(pc + 0)
>-	);
>-}
>-
>-void __glXDisp_WindowPos3fARB(GLbyte *pc)
>-{
>-	glWindowPos3fARB(
>-		*(GLfloat *)(pc + 0),
>-		*(GLfloat *)(pc + 4),
>-		*(GLfloat *)(pc + 8)
>-	);
>-}
>-#endif /* !MISSING_GL_EXTS */
>-
>-void __glXDisp_SampleCoverageARB(GLbyte *pc)
>-{
>-	glSampleCoverageARB(
>-		*(GLfloat *)(pc + 0),
>-		*(GLboolean *)(pc + 4)
>-	);
>-}
>Index: xorg/GL/glx/g_renderswap.c
>===================================================================
>RCS file: xorg/GL/glx/g_renderswap.c
>diff -N xorg/GL/glx/g_renderswap.c
>--- xorg/GL/glx/g_renderswap.c	12 Aug 2005 16:30:57 -0000	1.5
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,3387 +0,0 @@
>-/* $XFree86: xc/programs/Xserver/GL/glx/g_renderswap.c,v 1.8 2004/01/28 18:11:50 alanh Exp $ */
>-/*
>-** License Applicability. Except to the extent portions of this file are
>-** made subject to an alternative license as permitted in the SGI Free
>-** Software License B, Version 1.1 (the "License"), the contents of this
>-** file are subject only to the provisions of the License. You may not use
>-** this file except in compliance with the License. You may obtain a copy
>-** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
>-** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
>-** 
>-** http://oss.sgi.com/projects/FreeB
>-** 
>-** Note that, as provided in the License, the Software is distributed on an
>-** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
>-** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
>-** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
>-** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
>-** 
>-** Original Code. The Original Code is: OpenGL Sample Implementation,
>-** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
>-** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
>-** Copyright in any portions created by third parties is as indicated
>-** elsewhere herein. All Rights Reserved.
>-** 
>-** Additional Notice Provisions: This software was created using the
>-** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
>-** not been independently verified as being compliant with the OpenGL(R)
>-** version 1.2.1 Specification.
>-*/
>-
>-#define NEED_REPLIES
>-#ifdef HAVE_DIX_CONFIG_H
>-#include <dix-config.h>
>-#endif
>-
>-#include "glxserver.h"
>-#include "glxext.h"
>-#include "g_disptab.h"
>-#include "g_disptab_EXT.h"
>-#include "unpack.h"
>-#include "impsize.h"
>-#include "singlesize.h"
>-
>-void __glXDispSwap_CallList(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glCallList( 
>-		*(GLuint   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_ListBase(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glListBase( 
>-		*(GLuint   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Begin(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glBegin( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Color3bv(GLbyte *pc)
>-{
>-	glColor3bv( 
>-		(GLbyte   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Color3dv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 24);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
>-
>-	glColor3dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Color3fv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
>-
>-	glColor3fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Color3iv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT_ARRAY(pc + 0, 3);
>-
>-	glColor3iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Color3sv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
>-
>-	glColor3sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Color3ubv(GLbyte *pc)
>-{
>-	glColor3ubv( 
>-		(GLubyte  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Color3uiv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT_ARRAY(pc + 0, 3);
>-
>-	glColor3uiv( 
>-		(GLuint   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Color3usv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
>-
>-	glColor3usv( 
>-		(GLushort *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Color4bv(GLbyte *pc)
>-{
>-	glColor4bv( 
>-		(GLbyte   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Color4dv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 32);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
>-
>-	glColor4dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Color4fv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
>-
>-	glColor4fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Color4iv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT_ARRAY(pc + 0, 4);
>-
>-	glColor4iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Color4sv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
>-
>-	glColor4sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Color4ubv(GLbyte *pc)
>-{
>-	glColor4ubv( 
>-		(GLubyte  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Color4uiv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT_ARRAY(pc + 0, 4);
>-
>-	glColor4uiv( 
>-		(GLuint   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Color4usv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
>-
>-	glColor4usv( 
>-		(GLushort *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_EdgeFlagv(GLbyte *pc)
>-{
>-	glEdgeFlagv( 
>-		(GLboolean *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_End(GLbyte *pc)
>-{
>-	glEnd( 
>-	);
>-}
>-
>-void __glXDispSwap_Indexdv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 8);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
>-
>-	glIndexdv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Indexfv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);
>-
>-	glIndexfv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Indexiv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT_ARRAY(pc + 0, 1);
>-
>-	glIndexiv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Indexsv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 1);
>-
>-	glIndexsv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Normal3bv(GLbyte *pc)
>-{
>-	glNormal3bv( 
>-		(GLbyte   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Normal3dv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 24);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
>-
>-	glNormal3dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Normal3fv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
>-
>-	glNormal3fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Normal3iv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT_ARRAY(pc + 0, 3);
>-
>-	glNormal3iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Normal3sv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
>-
>-	glNormal3sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_RasterPos2dv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 16);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
>-
>-	glRasterPos2dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_RasterPos2fv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
>-
>-	glRasterPos2fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_RasterPos2iv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT_ARRAY(pc + 0, 2);
>-
>-	glRasterPos2iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_RasterPos2sv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
>-
>-	glRasterPos2sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_RasterPos3dv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 24);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
>-
>-	glRasterPos3dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_RasterPos3fv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
>-
>-	glRasterPos3fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_RasterPos3iv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT_ARRAY(pc + 0, 3);
>-
>-	glRasterPos3iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_RasterPos3sv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
>-
>-	glRasterPos3sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_RasterPos4dv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 32);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
>-
>-	glRasterPos4dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_RasterPos4fv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
>-
>-	glRasterPos4fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_RasterPos4iv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT_ARRAY(pc + 0, 4);
>-
>-	glRasterPos4iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_RasterPos4sv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
>-
>-	glRasterPos4sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Rectdv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 32);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 16, 2);
>-
>-	glRectdv( 
>-		(GLdouble *)(pc + 0),
>-		(GLdouble *)(pc + 16)
>-	);
>-}
>-
>-void __glXDispSwap_Rectfv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 8, 2);
>-
>-	glRectfv( 
>-		(GLfloat  *)(pc + 0),
>-		(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_Rectiv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT_ARRAY(pc + 0, 2);
>-	__GLX_SWAP_INT_ARRAY(pc + 8, 2);
>-
>-	glRectiv( 
>-		(GLint    *)(pc + 0),
>-		(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_Rectsv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
>-	__GLX_SWAP_SHORT_ARRAY(pc + 4, 2);
>-
>-	glRectsv( 
>-		(GLshort  *)(pc + 0),
>-		(GLshort  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_TexCoord1dv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 8);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
>-
>-	glTexCoord1dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_TexCoord1fv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);
>-
>-	glTexCoord1fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_TexCoord1iv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT_ARRAY(pc + 0, 1);
>-
>-	glTexCoord1iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_TexCoord1sv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 1);
>-
>-	glTexCoord1sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_TexCoord2dv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 16);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
>-
>-	glTexCoord2dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_TexCoord2fv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
>-
>-	glTexCoord2fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_TexCoord2iv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT_ARRAY(pc + 0, 2);
>-
>-	glTexCoord2iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_TexCoord2sv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
>-
>-	glTexCoord2sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_TexCoord3dv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 24);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
>-
>-	glTexCoord3dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_TexCoord3fv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
>-
>-	glTexCoord3fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_TexCoord3iv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT_ARRAY(pc + 0, 3);
>-
>-	glTexCoord3iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_TexCoord3sv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
>-
>-	glTexCoord3sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_TexCoord4dv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 32);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
>-
>-	glTexCoord4dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_TexCoord4fv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
>-
>-	glTexCoord4fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_TexCoord4iv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT_ARRAY(pc + 0, 4);
>-
>-	glTexCoord4iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_TexCoord4sv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
>-
>-	glTexCoord4sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Vertex2dv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 16);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
>-
>-	glVertex2dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Vertex2fv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
>-
>-	glVertex2fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Vertex2iv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT_ARRAY(pc + 0, 2);
>-
>-	glVertex2iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Vertex2sv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
>-
>-	glVertex2sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Vertex3dv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 24);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
>-
>-	glVertex3dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Vertex3fv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
>-
>-	glVertex3fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Vertex3iv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT_ARRAY(pc + 0, 3);
>-
>-	glVertex3iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Vertex3sv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
>-
>-	glVertex3sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Vertex4dv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 32);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
>-
>-	glVertex4dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Vertex4fv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
>-
>-	glVertex4fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Vertex4iv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT_ARRAY(pc + 0, 4);
>-
>-	glVertex4iv( 
>-		(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Vertex4sv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
>-
>-	glVertex4sv( 
>-		(GLshort  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_ClipPlane(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 36);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_INT(pc + 32);
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
>-
>-	glClipPlane( 
>-		*(GLenum   *)(pc + 32),
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_ColorMaterial(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-
>-	glColorMaterial( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_CullFace(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glCullFace( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Fogf(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT(pc + 4);
>-
>-	glFogf( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_Fogfv(GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	pname = *(GLenum *)(pc + 0);
>-	compsize = __glFogfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 4, compsize);
>-
>-	glFogfv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_Fogi(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-
>-	glFogi( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_Fogiv(GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	pname = *(GLenum *)(pc + 0);
>-	compsize = __glFogiv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT_ARRAY(pc + 4, compsize);
>-
>-	glFogiv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_FrontFace(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glFrontFace( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Hint(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-
>-	glHint( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_Lightf(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_FLOAT(pc + 8);
>-
>-	glLightf( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_Lightfv(GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glLightfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
>-
>-	glLightfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_Lighti(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-
>-	glLighti( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_Lightiv(GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glLightiv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
>-
>-	glLightiv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_LightModelf(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT(pc + 4);
>-
>-	glLightModelf( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_LightModelfv(GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	pname = *(GLenum *)(pc + 0);
>-	compsize = __glLightModelfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 4, compsize);
>-
>-	glLightModelfv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_LightModeli(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-
>-	glLightModeli( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_LightModeliv(GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	pname = *(GLenum *)(pc + 0);
>-	compsize = __glLightModeliv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT_ARRAY(pc + 4, compsize);
>-
>-	glLightModeliv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_LineStipple(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_SHORT(pc + 4);
>-
>-	glLineStipple( 
>-		*(GLint    *)(pc + 0),
>-		*(GLushort *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_LineWidth(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT(pc + 0);
>-
>-	glLineWidth( 
>-		*(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Materialf(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_FLOAT(pc + 8);
>-
>-	glMaterialf( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_Materialfv(GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glMaterialfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
>-
>-	glMaterialfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_Materiali(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-
>-	glMateriali( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_Materialiv(GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glMaterialiv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
>-
>-	glMaterialiv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_PointSize(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT(pc + 0);
>-
>-	glPointSize( 
>-		*(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_PolygonMode(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-
>-	glPolygonMode( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_Scissor(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-	__GLX_SWAP_INT(pc + 12);
>-
>-	glScissor( 
>-		*(GLint    *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLsizei  *)(pc + 8),
>-		*(GLsizei  *)(pc + 12)
>-	);
>-}
>-
>-void __glXDispSwap_ShadeModel(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glShadeModel( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_TexParameterf(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_FLOAT(pc + 8);
>-
>-	glTexParameterf( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_TexParameterfv(GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glTexParameterfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
>-
>-	glTexParameterfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_TexParameteri(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-
>-	glTexParameteri( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_TexParameteriv(GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glTexParameteriv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
>-
>-	glTexParameteriv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_TexEnvf(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_FLOAT(pc + 8);
>-
>-	glTexEnvf( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_TexEnvfv(GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glTexEnvfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
>-
>-	glTexEnvfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_TexEnvi(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-
>-	glTexEnvi( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_TexEnviv(GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glTexEnviv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
>-
>-	glTexEnviv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_TexGend(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 16);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_INT(pc + 8);
>-	__GLX_SWAP_INT(pc + 12);
>-	__GLX_SWAP_DOUBLE(pc + 0);
>-
>-	glTexGend( 
>-		*(GLenum   *)(pc + 8),
>-		*(GLenum   *)(pc + 12),
>-		*(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_TexGendv(GLbyte *pc)
>-{
>-	GLenum pname;
>-#ifdef __GLX_ALIGN64
>-	GLint cmdlen;
>-#endif
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glTexGendv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-#ifdef __GLX_ALIGN64
>-	cmdlen = __GLX_PAD(8+compsize*8);
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, cmdlen);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 8, compsize);
>-
>-	glTexGendv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLdouble *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_TexGenf(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_FLOAT(pc + 8);
>-
>-	glTexGenf( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_TexGenfv(GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glTexGenfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
>-
>-	glTexGenfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_TexGeni(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-
>-	glTexGeni( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_TexGeniv(GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glTexGeniv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
>-
>-	glTexGeniv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_InitNames(GLbyte *pc)
>-{
>-	glInitNames( 
>-	);
>-}
>-
>-void __glXDispSwap_LoadName(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glLoadName( 
>-		*(GLuint   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_PassThrough(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT(pc + 0);
>-
>-	glPassThrough( 
>-		*(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_PopName(GLbyte *pc)
>-{
>-	glPopName( 
>-	);
>-}
>-
>-void __glXDispSwap_PushName(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glPushName( 
>-		*(GLuint   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_DrawBuffer(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glDrawBuffer( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Clear(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glClear( 
>-		*(GLbitfield *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_ClearAccum(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT(pc + 0);
>-	__GLX_SWAP_FLOAT(pc + 4);
>-	__GLX_SWAP_FLOAT(pc + 8);
>-	__GLX_SWAP_FLOAT(pc + 12);
>-
>-	glClearAccum( 
>-		*(GLfloat  *)(pc + 0),
>-		*(GLfloat  *)(pc + 4),
>-		*(GLfloat  *)(pc + 8),
>-		*(GLfloat  *)(pc + 12)
>-	);
>-}
>-
>-void __glXDispSwap_ClearIndex(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT(pc + 0);
>-
>-	glClearIndex( 
>-		*(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_ClearColor(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT(pc + 0);
>-	__GLX_SWAP_FLOAT(pc + 4);
>-	__GLX_SWAP_FLOAT(pc + 8);
>-	__GLX_SWAP_FLOAT(pc + 12);
>-
>-	glClearColor( 
>-		*(GLclampf *)(pc + 0),
>-		*(GLclampf *)(pc + 4),
>-		*(GLclampf *)(pc + 8),
>-		*(GLclampf *)(pc + 12)
>-	);
>-}
>-
>-void __glXDispSwap_ClearStencil(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glClearStencil( 
>-		*(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_ClearDepth(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 8);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE(pc + 0);
>-
>-	glClearDepth( 
>-		*(GLclampd *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_StencilMask(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glStencilMask( 
>-		*(GLuint   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_ColorMask(GLbyte *pc)
>-{
>-	glColorMask( 
>-		*(GLboolean *)(pc + 0),
>-		*(GLboolean *)(pc + 1),
>-		*(GLboolean *)(pc + 2),
>-		*(GLboolean *)(pc + 3)
>-	);
>-}
>-
>-void __glXDispSwap_DepthMask(GLbyte *pc)
>-{
>-	glDepthMask( 
>-		*(GLboolean *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_IndexMask(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glIndexMask( 
>-		*(GLuint   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Accum(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT(pc + 4);
>-
>-	glAccum( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_Disable(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glDisable( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Enable(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glEnable( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_PopAttrib(GLbyte *pc)
>-{
>-	glPopAttrib( 
>-	);
>-}
>-
>-void __glXDispSwap_PushAttrib(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glPushAttrib( 
>-		*(GLbitfield *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_MapGrid1d(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 20);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_INT(pc + 16);
>-	__GLX_SWAP_DOUBLE(pc + 0);
>-	__GLX_SWAP_DOUBLE(pc + 8);
>-
>-	glMapGrid1d( 
>-		*(GLint    *)(pc + 16),
>-		*(GLdouble *)(pc + 0),
>-		*(GLdouble *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_MapGrid1f(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT(pc + 4);
>-	__GLX_SWAP_FLOAT(pc + 8);
>-
>-	glMapGrid1f( 
>-		*(GLint    *)(pc + 0),
>-		*(GLfloat  *)(pc + 4),
>-		*(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_MapGrid2d(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 40);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_INT(pc + 32);
>-	__GLX_SWAP_DOUBLE(pc + 0);
>-	__GLX_SWAP_DOUBLE(pc + 8);
>-	__GLX_SWAP_INT(pc + 36);
>-	__GLX_SWAP_DOUBLE(pc + 16);
>-	__GLX_SWAP_DOUBLE(pc + 24);
>-
>-	glMapGrid2d( 
>-		*(GLint    *)(pc + 32),
>-		*(GLdouble *)(pc + 0),
>-		*(GLdouble *)(pc + 8),
>-		*(GLint    *)(pc + 36),
>-		*(GLdouble *)(pc + 16),
>-		*(GLdouble *)(pc + 24)
>-	);
>-}
>-
>-void __glXDispSwap_MapGrid2f(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT(pc + 4);
>-	__GLX_SWAP_FLOAT(pc + 8);
>-	__GLX_SWAP_INT(pc + 12);
>-	__GLX_SWAP_FLOAT(pc + 16);
>-	__GLX_SWAP_FLOAT(pc + 20);
>-
>-	glMapGrid2f( 
>-		*(GLint    *)(pc + 0),
>-		*(GLfloat  *)(pc + 4),
>-		*(GLfloat  *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLfloat  *)(pc + 16),
>-		*(GLfloat  *)(pc + 20)
>-	);
>-}
>-
>-void __glXDispSwap_EvalCoord1dv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 8);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
>-
>-	glEvalCoord1dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_EvalCoord1fv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);
>-
>-	glEvalCoord1fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_EvalCoord2dv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 16);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
>-
>-	glEvalCoord2dv( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_EvalCoord2fv(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
>-
>-	glEvalCoord2fv( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_EvalMesh1(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-
>-	glEvalMesh1( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_EvalPoint1(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glEvalPoint1( 
>-		*(GLint    *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_EvalMesh2(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-	__GLX_SWAP_INT(pc + 12);
>-	__GLX_SWAP_INT(pc + 16);
>-
>-	glEvalMesh2( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLint    *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLint    *)(pc + 16)
>-	);
>-}
>-
>-void __glXDispSwap_EvalPoint2(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-
>-	glEvalPoint2( 
>-		*(GLint    *)(pc + 0),
>-		*(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_AlphaFunc(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT(pc + 4);
>-
>-	glAlphaFunc( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLclampf *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_BlendFunc(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-
>-	glBlendFunc( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_LogicOp(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glLogicOp( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_StencilFunc(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-
>-	glStencilFunc( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLuint   *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_StencilOp(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-
>-	glStencilOp( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLenum   *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_DepthFunc(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glDepthFunc( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_PixelZoom(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT(pc + 0);
>-	__GLX_SWAP_FLOAT(pc + 4);
>-
>-	glPixelZoom( 
>-		*(GLfloat  *)(pc + 0),
>-		*(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_PixelTransferf(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT(pc + 4);
>-
>-	glPixelTransferf( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_PixelTransferi(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-
>-	glPixelTransferi( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_PixelMapfv(GLbyte *pc)
>-{
>-	GLint mapsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 4);
>-	mapsize = *(GLint *)(pc + 4);
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 8, mapsize);
>-
>-	glPixelMapfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_PixelMapuiv(GLbyte *pc)
>-{
>-	GLint mapsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 4);
>-	mapsize = *(GLint *)(pc + 4);
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT_ARRAY(pc + 8, mapsize);
>-
>-	glPixelMapuiv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		(GLuint   *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_PixelMapusv(GLbyte *pc)
>-{
>-	GLint mapsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 4);
>-	mapsize = *(GLint *)(pc + 4);
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_SHORT_ARRAY(pc + 8, mapsize);
>-
>-	glPixelMapusv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		(GLushort *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_ReadBuffer(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glReadBuffer( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_CopyPixels(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-	__GLX_SWAP_INT(pc + 12);
>-	__GLX_SWAP_INT(pc + 16);
>-
>-	glCopyPixels( 
>-		*(GLint    *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLsizei  *)(pc + 8),
>-		*(GLsizei  *)(pc + 12),
>-		*(GLenum   *)(pc + 16)
>-	);
>-}
>-
>-void __glXDispSwap_DepthRange(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 16);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE(pc + 0);
>-	__GLX_SWAP_DOUBLE(pc + 8);
>-
>-	glDepthRange( 
>-		*(GLclampd *)(pc + 0),
>-		*(GLclampd *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_Frustum(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 48);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE(pc + 0);
>-	__GLX_SWAP_DOUBLE(pc + 8);
>-	__GLX_SWAP_DOUBLE(pc + 16);
>-	__GLX_SWAP_DOUBLE(pc + 24);
>-	__GLX_SWAP_DOUBLE(pc + 32);
>-	__GLX_SWAP_DOUBLE(pc + 40);
>-
>-	glFrustum( 
>-		*(GLdouble *)(pc + 0),
>-		*(GLdouble *)(pc + 8),
>-		*(GLdouble *)(pc + 16),
>-		*(GLdouble *)(pc + 24),
>-		*(GLdouble *)(pc + 32),
>-		*(GLdouble *)(pc + 40)
>-	);
>-}
>-
>-void __glXDispSwap_LoadIdentity(GLbyte *pc)
>-{
>-	glLoadIdentity( 
>-	);
>-}
>-
>-void __glXDispSwap_LoadMatrixf(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 16);
>-
>-	glLoadMatrixf( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_LoadMatrixd(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 128);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 16);
>-
>-	glLoadMatrixd( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_MatrixMode(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glMatrixMode( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_MultMatrixf(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 16);
>-
>-	glMultMatrixf( 
>-		(GLfloat  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_MultMatrixd(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 128);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 16);
>-
>-	glMultMatrixd( 
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_Ortho(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 48);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE(pc + 0);
>-	__GLX_SWAP_DOUBLE(pc + 8);
>-	__GLX_SWAP_DOUBLE(pc + 16);
>-	__GLX_SWAP_DOUBLE(pc + 24);
>-	__GLX_SWAP_DOUBLE(pc + 32);
>-	__GLX_SWAP_DOUBLE(pc + 40);
>-
>-	glOrtho( 
>-		*(GLdouble *)(pc + 0),
>-		*(GLdouble *)(pc + 8),
>-		*(GLdouble *)(pc + 16),
>-		*(GLdouble *)(pc + 24),
>-		*(GLdouble *)(pc + 32),
>-		*(GLdouble *)(pc + 40)
>-	);
>-}
>-
>-void __glXDispSwap_PopMatrix(GLbyte *pc)
>-{
>-	glPopMatrix( 
>-	);
>-}
>-
>-void __glXDispSwap_PushMatrix(GLbyte *pc)
>-{
>-	glPushMatrix( 
>-	);
>-}
>-
>-void __glXDispSwap_Rotated(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 32);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE(pc + 0);
>-	__GLX_SWAP_DOUBLE(pc + 8);
>-	__GLX_SWAP_DOUBLE(pc + 16);
>-	__GLX_SWAP_DOUBLE(pc + 24);
>-
>-	glRotated( 
>-		*(GLdouble *)(pc + 0),
>-		*(GLdouble *)(pc + 8),
>-		*(GLdouble *)(pc + 16),
>-		*(GLdouble *)(pc + 24)
>-	);
>-}
>-
>-void __glXDispSwap_Rotatef(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT(pc + 0);
>-	__GLX_SWAP_FLOAT(pc + 4);
>-	__GLX_SWAP_FLOAT(pc + 8);
>-	__GLX_SWAP_FLOAT(pc + 12);
>-
>-	glRotatef( 
>-		*(GLfloat  *)(pc + 0),
>-		*(GLfloat  *)(pc + 4),
>-		*(GLfloat  *)(pc + 8),
>-		*(GLfloat  *)(pc + 12)
>-	);
>-}
>-
>-void __glXDispSwap_Scaled(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 24);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE(pc + 0);
>-	__GLX_SWAP_DOUBLE(pc + 8);
>-	__GLX_SWAP_DOUBLE(pc + 16);
>-
>-	glScaled( 
>-		*(GLdouble *)(pc + 0),
>-		*(GLdouble *)(pc + 8),
>-		*(GLdouble *)(pc + 16)
>-	);
>-}
>-
>-void __glXDispSwap_Scalef(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT(pc + 0);
>-	__GLX_SWAP_FLOAT(pc + 4);
>-	__GLX_SWAP_FLOAT(pc + 8);
>-
>-	glScalef( 
>-		*(GLfloat  *)(pc + 0),
>-		*(GLfloat  *)(pc + 4),
>-		*(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_Translated(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 24);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_DOUBLE(pc + 0);
>-	__GLX_SWAP_DOUBLE(pc + 8);
>-	__GLX_SWAP_DOUBLE(pc + 16);
>-
>-	glTranslated( 
>-		*(GLdouble *)(pc + 0),
>-		*(GLdouble *)(pc + 8),
>-		*(GLdouble *)(pc + 16)
>-	);
>-}
>-
>-void __glXDispSwap_Translatef(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT(pc + 0);
>-	__GLX_SWAP_FLOAT(pc + 4);
>-	__GLX_SWAP_FLOAT(pc + 8);
>-
>-	glTranslatef( 
>-		*(GLfloat  *)(pc + 0),
>-		*(GLfloat  *)(pc + 4),
>-		*(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_Viewport(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-	__GLX_SWAP_INT(pc + 12);
>-
>-	glViewport( 
>-		*(GLint    *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLsizei  *)(pc + 8),
>-		*(GLsizei  *)(pc + 12)
>-	);
>-}
>-
>-void __glXDispSwap_PolygonOffset(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT(pc + 0);
>-	__GLX_SWAP_FLOAT(pc + 4);
>-
>-	glPolygonOffset( 
>-		*(GLfloat  *)(pc + 0),
>-		*(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_CopyTexImage1D(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-	__GLX_SWAP_INT(pc + 12);
>-	__GLX_SWAP_INT(pc + 16);
>-	__GLX_SWAP_INT(pc + 20);
>-	__GLX_SWAP_INT(pc + 24);
>-
>-	glCopyTexImage1D( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLenum   *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLint    *)(pc + 16),
>-		*(GLsizei  *)(pc + 20),
>-		*(GLint    *)(pc + 24)
>-	);
>-}
>-
>-void __glXDispSwap_CopyTexImage2D(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-	__GLX_SWAP_INT(pc + 12);
>-	__GLX_SWAP_INT(pc + 16);
>-	__GLX_SWAP_INT(pc + 20);
>-	__GLX_SWAP_INT(pc + 24);
>-	__GLX_SWAP_INT(pc + 28);
>-
>-	glCopyTexImage2D( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLenum   *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLint    *)(pc + 16),
>-		*(GLsizei  *)(pc + 20),
>-		*(GLsizei  *)(pc + 24),
>-		*(GLint    *)(pc + 28)
>-	);
>-}
>-
>-void __glXDispSwap_CopyTexSubImage1D(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-	__GLX_SWAP_INT(pc + 12);
>-	__GLX_SWAP_INT(pc + 16);
>-	__GLX_SWAP_INT(pc + 20);
>-
>-	glCopyTexSubImage1D( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLint    *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLint    *)(pc + 16),
>-		*(GLsizei  *)(pc + 20)
>-	);
>-}
>-
>-void __glXDispSwap_CopyTexSubImage2D(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-	__GLX_SWAP_INT(pc + 12);
>-	__GLX_SWAP_INT(pc + 16);
>-	__GLX_SWAP_INT(pc + 20);
>-	__GLX_SWAP_INT(pc + 24);
>-	__GLX_SWAP_INT(pc + 28);
>-
>-	glCopyTexSubImage2D( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLint    *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLint    *)(pc + 16),
>-		*(GLint    *)(pc + 20),
>-		*(GLsizei  *)(pc + 24),
>-		*(GLsizei  *)(pc + 28)
>-	);
>-}
>-
>-void __glXDispSwap_BindTexture(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-
>-	glBindTexture( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLuint   *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_PrioritizeTextures(GLbyte *pc)
>-{
>-	GLsizei n;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	n = *(GLsizei *)(pc + 0);
>-	__GLX_SWAP_INT_ARRAY(pc + 4, n);
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 4+n*4, n);
>-
>-	glPrioritizeTextures( 
>-		*(GLsizei  *)(pc + 0),
>-		(GLuint   *)(pc + 4),
>-		(GLclampf *)(pc + 4+n*4)
>-	);
>-}
>-
>-void __glXDispSwap_Indexubv(GLbyte *pc)
>-{
>-	glIndexubv( 
>-		(GLubyte  *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_BlendColor(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_FLOAT(pc + 0);
>-	__GLX_SWAP_FLOAT(pc + 4);
>-	__GLX_SWAP_FLOAT(pc + 8);
>-	__GLX_SWAP_FLOAT(pc + 12);
>-
>-	glBlendColor( 
>-		*(GLclampf *)(pc + 0),
>-		*(GLclampf *)(pc + 4),
>-		*(GLclampf *)(pc + 8),
>-		*(GLclampf *)(pc + 12)
>-	);
>-}
>-
>-void __glXDispSwap_BlendEquation(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glBlendEquation( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_ColorTableParameterfv(GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glColorTableParameterfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
>-
>-	glColorTableParameterfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_ColorTableParameteriv(GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glColorTableParameteriv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
>-
>-	glColorTableParameteriv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_CopyColorTable(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-	__GLX_SWAP_INT(pc + 12);
>-	__GLX_SWAP_INT(pc + 16);
>-
>-	glCopyColorTable( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLint    *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLsizei  *)(pc + 16)
>-	);
>-}
>-
>-void __glXDispSwap_CopyColorSubTable(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-	__GLX_SWAP_INT(pc + 12);
>-	__GLX_SWAP_INT(pc + 16);
>-
>-	glCopyColorSubTable( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLsizei  *)(pc + 4),
>-		*(GLint    *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLsizei  *)(pc + 16)
>-	);
>-}
>-
>-void __glXDispSwap_ConvolutionParameterf(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_FLOAT(pc + 8);
>-
>-	glConvolutionParameterf( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_ConvolutionParameterfv(GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glConvolutionParameterfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
>-
>-	glConvolutionParameterfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_ConvolutionParameteri(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-
>-	glConvolutionParameteri( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_ConvolutionParameteriv(GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glConvolutionParameteriv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
>-
>-	glConvolutionParameteriv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_CopyConvolutionFilter1D(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-	__GLX_SWAP_INT(pc + 12);
>-	__GLX_SWAP_INT(pc + 16);
>-
>-	glCopyConvolutionFilter1D( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLint    *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLsizei  *)(pc + 16)
>-	);
>-}
>-
>-void __glXDispSwap_CopyConvolutionFilter2D(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-	__GLX_SWAP_INT(pc + 12);
>-	__GLX_SWAP_INT(pc + 16);
>-	__GLX_SWAP_INT(pc + 20);
>-
>-	glCopyConvolutionFilter2D( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLint    *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLsizei  *)(pc + 16),
>-		*(GLsizei  *)(pc + 20)
>-	);
>-}
>-
>-void __glXDispSwap_Histogram(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-
>-	glHistogram( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLsizei  *)(pc + 4),
>-		*(GLenum   *)(pc + 8),
>-		*(GLboolean *)(pc + 12)
>-	);
>-}
>-
>-void __glXDispSwap_Minmax(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-
>-	glMinmax( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		*(GLboolean *)(pc + 8)
>-	);
>-}
>-
>-void __glXDispSwap_ResetHistogram(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glResetHistogram( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_ResetMinmax(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glResetMinmax( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_CopyTexSubImage3D(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	__GLX_SWAP_INT(pc + 8);
>-	__GLX_SWAP_INT(pc + 12);
>-	__GLX_SWAP_INT(pc + 16);
>-	__GLX_SWAP_INT(pc + 20);
>-	__GLX_SWAP_INT(pc + 24);
>-	__GLX_SWAP_INT(pc + 28);
>-	__GLX_SWAP_INT(pc + 32);
>-
>-	glCopyTexSubImage3D( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLint    *)(pc + 8),
>-		*(GLint    *)(pc + 12),
>-		*(GLint    *)(pc + 16),
>-		*(GLint    *)(pc + 20),
>-		*(GLint    *)(pc + 24),
>-		*(GLsizei  *)(pc + 28),
>-		*(GLsizei  *)(pc + 32)
>-	);
>-}
>-
>-void __glXDispSwap_ActiveTextureARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glActiveTextureARB( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_MultiTexCoord1dvARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 12);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_INT(pc + 8);
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
>-
>-	glMultiTexCoord1dvARB( 
>-		*(GLenum   *)(pc + 8),
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_MultiTexCoord1fvARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 1);
>-
>-	glMultiTexCoord1fvARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_MultiTexCoord1ivARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT_ARRAY(pc + 4, 1);
>-
>-	glMultiTexCoord1ivARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_MultiTexCoord1svARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_SHORT_ARRAY(pc + 4, 1);
>-
>-	glMultiTexCoord1svARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLshort  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_MultiTexCoord2dvARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 20);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_INT(pc + 16);
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
>-
>-	glMultiTexCoord2dvARB( 
>-		*(GLenum   *)(pc + 16),
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_MultiTexCoord2fvARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 2);
>-
>-	glMultiTexCoord2fvARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_MultiTexCoord2ivARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT_ARRAY(pc + 4, 2);
>-
>-	glMultiTexCoord2ivARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_MultiTexCoord2svARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_SHORT_ARRAY(pc + 4, 2);
>-
>-	glMultiTexCoord2svARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLshort  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_MultiTexCoord3dvARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 28);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_INT(pc + 24);
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
>-
>-	glMultiTexCoord3dvARB( 
>-		*(GLenum   *)(pc + 24),
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_MultiTexCoord3fvARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 3);
>-
>-	glMultiTexCoord3fvARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_MultiTexCoord3ivARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT_ARRAY(pc + 4, 3);
>-
>-	glMultiTexCoord3ivARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_MultiTexCoord3svARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_SHORT_ARRAY(pc + 4, 3);
>-
>-	glMultiTexCoord3svARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLshort  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_MultiTexCoord4dvARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-#ifdef __GLX_ALIGN64
>-	if ((unsigned long)(pc) & 7) {
>-	    __GLX_MEM_COPY(pc-4, pc, 36);
>-	    pc -= 4;
>-	}
>-#endif
>-	__GLX_SWAP_INT(pc + 32);
>-	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
>-
>-	glMultiTexCoord4dvARB( 
>-		*(GLenum   *)(pc + 32),
>-		(GLdouble *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_MultiTexCoord4fvARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 4);
>-
>-	glMultiTexCoord4fvARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLfloat  *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_MultiTexCoord4ivARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT_ARRAY(pc + 4, 4);
>-
>-	glMultiTexCoord4ivARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLint    *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_MultiTexCoord4svARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_SHORT_ARRAY(pc + 4, 4);
>-
>-	glMultiTexCoord4svARB( 
>-		*(GLenum   *)(pc + 0),
>-		(GLshort  *)(pc + 4)
>-	);
>-}
>-
>-
>-/*
>- * Extensions
>- */
>-
>-#ifndef MISSING_GL_EXTS
>-
>-void __glXDispSwap_PointParameterfARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT(pc + 4);
>-	glPointParameterfARB(
>-		*(GLenum *)(pc + 0),
>-		*(GLfloat *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_PointParameterfvARB(GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-	pname = *(GLenum *)(pc + 0);
>-	compsize = __glPointParameterfvEXT_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_FLOAT_ARRAY(pc + 4, compsize);
>-
>-	glPointParameterfvARB(
>-		*(GLenum *)(pc + 0),
>-		(GLfloat *)(pc + 4)
>-	);
>-}
>-
>-void __glXDispSwap_ActiveStencilFaceEXT(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	glActiveStencilFaceEXT(
>-		*(GLenum *)(pc + 0)
>-	);
>-}
>-
>-void __glXDispSwap_WindowPos3fARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_SWAP_FLOAT(pc + 0);
>-	__GLX_SWAP_FLOAT(pc + 4);
>-	__GLX_SWAP_FLOAT(pc + 8);
>-	glWindowPos3fARB(
>-		*(GLfloat *)(pc + 0),
>-		*(GLfloat *)(pc + 4),
>-		*(GLfloat *)(pc + 8)
>-	);
>-}
>-#endif /* !MISSING_GL_EXTS */
>-
>-void __glXDispSwap_SampleCoverageARB(GLbyte *pc)
>-{
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_SWAP_FLOAT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-
>-	glSampleCoverageARB(
>-		*(GLfloat *)(pc + 0),
>-		*(GLboolean *)(pc + 4)
>-	);
>-}
>Index: xorg/GL/glx/g_single.c
>===================================================================
>RCS file: xorg/GL/glx/g_single.c
>diff -N xorg/GL/glx/g_single.c
>--- xorg/GL/glx/g_single.c	3 Jul 2005 07:01:02 -0000	1.3
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,1787 +0,0 @@
>-/* $XFree86: xc/programs/Xserver/GL/glx/g_single.c,v 1.5tsi Exp $ */
>-/*
>-** License Applicability. Except to the extent portions of this file are
>-** made subject to an alternative license as permitted in the SGI Free
>-** Software License B, Version 1.1 (the "License"), the contents of this
>-** file are subject only to the provisions of the License. You may not use
>-** this file except in compliance with the License. You may obtain a copy
>-** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
>-** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
>-** 
>-** http://oss.sgi.com/projects/FreeB
>-** 
>-** Note that, as provided in the License, the Software is distributed on an
>-** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
>-** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
>-** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
>-** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
>-** 
>-** Original Code. The Original Code is: OpenGL Sample Implementation,
>-** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
>-** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
>-** Copyright in any portions created by third parties is as indicated
>-** elsewhere herein. All Rights Reserved.
>-** 
>-** Additional Notice Provisions: This software was created using the
>-** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
>-** not been independently verified as being compliant with the OpenGL(R)
>-** version 1.2.1 Specification.
>-*/
>-
>-#define NEED_REPLIES
>-#ifdef HAVE_DIX_CONFIG_H
>-#include <dix-config.h>
>-#endif
>-
>-#include "glxserver.h"
>-#include "glxext.h"
>-#include "g_disptab.h"
>-#include "g_disptab_EXT.h"
>-#include "unpack.h"
>-#include "impsize.h"
>-#include "singlesize.h"
>-
>-int __glXDisp_NewList(__GLXclientState *cl, GLbyte *pc)
>-{
>-	__GLXcontext *cx;
>-	int error;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-
>-	glNewList( 
>-		*(GLuint   *)(pc + 0),
>-		*(GLenum   *)(pc + 4)
>-	);
>-	__GLX_NOTE_UNFLUSHED_CMDS(cx);
>-	return Success;
>-}
>-
>-int __glXDisp_EndList(__GLXclientState *cl, GLbyte *pc)
>-{
>-	__GLXcontext *cx;
>-	int error;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-
>-	glEndList( 
>-	);
>-	return Success;
>-}
>-
>-int __glXDisp_DeleteLists(__GLXclientState *cl, GLbyte *pc)
>-{
>-	__GLXcontext *cx;
>-	int error;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-
>-	glDeleteLists( 
>-		*(GLuint   *)(pc + 0),
>-		*(GLsizei  *)(pc + 4)
>-	);
>-	__GLX_NOTE_UNFLUSHED_CMDS(cx);
>-	return Success;
>-}
>-
>-int __glXDisp_GenLists(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLuint retval;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-
>-	retval =
>-	glGenLists( 
>-		*(GLsizei  *)(pc + 0)
>-	);
>-	__GLX_PUT_RETVAL(retval);
>-	__GLX_BEGIN_REPLY(0);
>-	__GLX_SEND_HEADER();
>-	return Success;
>-}
>-
>-int __glXDisp_PixelStoref(__GLXclientState *cl, GLbyte *pc)
>-{
>-	__GLXcontext *cx;
>-	int error;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-
>-	glPixelStoref( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLfloat  *)(pc + 4)
>-	);
>-	__GLX_NOTE_UNFLUSHED_CMDS(cx);
>-	return Success;
>-}
>-
>-int __glXDisp_PixelStorei(__GLXclientState *cl, GLbyte *pc)
>-{
>-	__GLXcontext *cx;
>-	int error;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-
>-	glPixelStorei( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4)
>-	);
>-	__GLX_NOTE_UNFLUSHED_CMDS(cx);
>-	return Success;
>-}
>-
>-int __glXDisp_GetBooleanv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLboolean answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 0);
>-	compsize = __glGetBooleanv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>-	__glXClearErrorOccured();
>-	glGetBooleanv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLboolean *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_BYTE();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_BYTE_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetDoublev(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLdouble answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 0);
>-	compsize = __glGetDoublev_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*8,8);
>-	__glXClearErrorOccured();
>-	glGetDoublev( 
>-		*(GLenum   *)(pc + 0),
>-		(GLdouble *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_DOUBLE();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*8);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_DOUBLE_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetError(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum retval;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-
>-	retval =
>-	glGetError( 
>-	);
>-	__GLX_PUT_RETVAL(retval);
>-	__GLX_BEGIN_REPLY(0);
>-	__GLX_SEND_HEADER();
>-	return Success;
>-}
>-
>-int __glXDisp_GetFloatv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 0);
>-	compsize = __glGetFloatv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetFloatv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLfloat  *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetIntegerv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 0);
>-	compsize = __glGetIntegerv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetIntegerv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLint    *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetLightfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetLightfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetLightfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetLightiv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetLightiv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetLightiv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetMapdv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum target;
>-	GLenum query;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLdouble answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	target = *(GLenum *)(pc + 0);
>-	query = *(GLenum *)(pc + 4);
>-	compsize = __glGetMapdv_size(target,query);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*8,8);
>-	__glXClearErrorOccured();
>-	glGetMapdv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLdouble *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_DOUBLE();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*8);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_DOUBLE_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetMapfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum target;
>-	GLenum query;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	target = *(GLenum *)(pc + 0);
>-	query = *(GLenum *)(pc + 4);
>-	compsize = __glGetMapfv_size(target,query);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetMapfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetMapiv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum target;
>-	GLenum query;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	target = *(GLenum *)(pc + 0);
>-	query = *(GLenum *)(pc + 4);
>-	compsize = __glGetMapiv_size(target,query);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetMapiv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetMaterialfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetMaterialfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetMaterialfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetMaterialiv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetMaterialiv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetMaterialiv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetPixelMapfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum map;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	map = *(GLenum *)(pc + 0);
>-	compsize = __glGetPixelMapfv_size(map);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetPixelMapfv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLfloat  *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetPixelMapuiv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum map;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLuint answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	map = *(GLenum *)(pc + 0);
>-	compsize = __glGetPixelMapuiv_size(map);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetPixelMapuiv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLuint   *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetPixelMapusv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum map;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLushort answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	map = *(GLenum *)(pc + 0);
>-	compsize = __glGetPixelMapusv_size(map);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*2,2);
>-	__glXClearErrorOccured();
>-	glGetPixelMapusv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLushort *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_SHORT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*2);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_SHORT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetTexEnvfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetTexEnvfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetTexEnvfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetTexEnviv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetTexEnviv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetTexEnviv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetTexGendv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLdouble answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetTexGendv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*8,8);
>-	__glXClearErrorOccured();
>-	glGetTexGendv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLdouble *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_DOUBLE();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*8);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_DOUBLE_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetTexGenfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetTexGenfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetTexGenfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetTexGeniv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetTexGeniv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetTexGeniv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetTexParameterfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetTexParameterfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetTexParameterfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetTexParameteriv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetTexParameteriv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetTexParameteriv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetTexLevelParameterfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 8);
>-	compsize = __glGetTexLevelParameterfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetTexLevelParameterfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLenum   *)(pc + 8),
>-		(GLfloat  *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetTexLevelParameteriv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 8);
>-	compsize = __glGetTexLevelParameteriv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetTexLevelParameteriv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLenum   *)(pc + 8),
>-		(GLint    *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_IsEnabled(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLboolean retval;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-
>-	retval =
>-	glIsEnabled( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-	__GLX_PUT_RETVAL(retval);
>-	__GLX_BEGIN_REPLY(0);
>-	__GLX_SEND_HEADER();
>-	return Success;
>-}
>-
>-int __glXDisp_IsList(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLboolean retval;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-
>-	retval =
>-	glIsList( 
>-		*(GLuint   *)(pc + 0)
>-	);
>-	__GLX_PUT_RETVAL(retval);
>-	__GLX_BEGIN_REPLY(0);
>-	__GLX_SEND_HEADER();
>-	return Success;
>-}
>-
>-int __glXDisp_AreTexturesResident(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLsizei n;
>-	GLboolean retval;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLboolean answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	n = *(GLsizei *)(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,n,1);
>-	retval =
>-	glAreTexturesResident( 
>-		*(GLsizei  *)(pc + 0),
>-		(GLuint   *)(pc + 4),
>-		(GLboolean *) answer
>-	);
>-	__GLX_PUT_RETVAL(retval);
>-	__GLX_BEGIN_REPLY(n);
>-	__GLX_SEND_HEADER();
>-	__GLX_SEND_BYTE_ARRAY(n);
>-	return Success;
>-}
>-
>-int __glXDisp_DeleteTextures(__GLXclientState *cl, GLbyte *pc)
>-{
>-	__GLXcontext *cx;
>-	int error;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-
>-	glDeleteTextures( 
>-		*(GLsizei  *)(pc + 0),
>-		(GLuint   *)(pc + 4)
>-	);
>-	return Success;
>-}
>-
>-int __glXDisp_GenTextures(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLsizei n;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLuint answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	n = *(GLsizei *)(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,n*4,4);
>-	glGenTextures( 
>-		*(GLsizei  *)(pc + 0),
>-		(GLuint   *) answer
>-	);
>-	__GLX_BEGIN_REPLY(n*4);
>-	__GLX_SEND_HEADER();
>-	__GLX_SEND_INT_ARRAY(n);
>-	return Success;
>-}
>-
>-int __glXDisp_IsTexture(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLboolean retval;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-
>-	retval =
>-	glIsTexture( 
>-		*(GLuint   *)(pc + 0)
>-	);
>-	__GLX_PUT_RETVAL(retval);
>-	__GLX_BEGIN_REPLY(0);
>-	__GLX_SEND_HEADER();
>-	return Success;
>-}
>-
>-int __glXDisp_GetColorTableParameterfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetColorTableParameterfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetColorTableParameterfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetColorTableParameteriv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetColorTableParameteriv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetColorTableParameteriv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetConvolutionParameterfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetConvolutionParameterfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetConvolutionParameterfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetConvolutionParameteriv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetConvolutionParameteriv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetConvolutionParameteriv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetHistogramParameterfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetHistogramParameterfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetHistogramParameterfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetHistogramParameteriv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetHistogramParameteriv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetHistogramParameteriv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetMinmaxParameterfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetMinmaxParameterfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetMinmaxParameterfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_GetMinmaxParameteriv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetMinmaxParameteriv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetMinmaxParameteriv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDisp_AreTexturesResidentEXT(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLsizei n;
>-	GLboolean retval;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLboolean answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_VENDPRIV_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_VENDPRIV_HDR_SIZE;
>-	n = *(GLsizei *)(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,n,1);
>-	retval =
>-	glAreTexturesResidentEXT( 
>-		*(GLsizei  *)(pc + 0),
>-		(GLuint   *)(pc + 4),
>-		(GLboolean *) answer
>-	);
>-	__GLX_PUT_RETVAL(retval);
>-	__GLX_BEGIN_REPLY(n);
>-	__GLX_SEND_HEADER();
>-	__GLX_SEND_BYTE_ARRAY(n);
>-	return Success;
>-}
>-
>-int __glXDisp_DeleteTexturesEXT(__GLXclientState *cl, GLbyte *pc)
>-{
>-	__GLXcontext *cx;
>-	int error;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_VENDPRIV_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_VENDPRIV_HDR_SIZE;
>-
>-	glDeleteTexturesEXT( 
>-		*(GLsizei  *)(pc + 0),
>-		(GLuint   *)(pc + 4)
>-	);
>-	return Success;
>-}
>-
>-int __glXDisp_GenTexturesEXT(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLsizei n;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLuint answerBuffer[200];
>-	char *answer;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_VENDPRIV_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_VENDPRIV_HDR_SIZE;
>-	n = *(GLsizei *)(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,n*4,4);
>-	glGenTexturesEXT( 
>-		*(GLsizei  *)(pc + 0),
>-		(GLuint   *) answer
>-	);
>-	__GLX_BEGIN_REPLY(n*4);
>-	__GLX_SEND_HEADER();
>-	__GLX_SEND_INT_ARRAY(n);
>-	return Success;
>-}
>-
>-int __glXDisp_IsTextureEXT(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLboolean retval;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-
>-	cx = __glXForceCurrent(cl, __GLX_GET_VENDPRIV_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_VENDPRIV_HDR_SIZE;
>-
>-	retval =
>-	glIsTextureEXT( 
>-		*(GLuint   *)(pc + 0)
>-	);
>-	__GLX_PUT_RETVAL(retval);
>-	__GLX_BEGIN_REPLY(0);
>-	__GLX_SEND_HEADER();
>-	return Success;
>-}
>-
>Index: xorg/GL/glx/g_singleswap.c
>===================================================================
>RCS file: xorg/GL/glx/g_singleswap.c
>diff -N xorg/GL/glx/g_singleswap.c
>--- xorg/GL/glx/g_singleswap.c	3 Jul 2005 07:01:02 -0000	1.3
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,2208 +0,0 @@
>-/* $XFree86: xc/programs/Xserver/GL/glx/g_singleswap.c,v 1.4tsi Exp $ */
>-/*
>-** License Applicability. Except to the extent portions of this file are
>-** made subject to an alternative license as permitted in the SGI Free
>-** Software License B, Version 1.1 (the "License"), the contents of this
>-** file are subject only to the provisions of the License. You may not use
>-** this file except in compliance with the License. You may obtain a copy
>-** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
>-** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
>-** 
>-** http://oss.sgi.com/projects/FreeB
>-** 
>-** Note that, as provided in the License, the Software is distributed on an
>-** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
>-** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
>-** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
>-** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
>-** 
>-** Original Code. The Original Code is: OpenGL Sample Implementation,
>-** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
>-** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
>-** Copyright in any portions created by third parties is as indicated
>-** elsewhere herein. All Rights Reserved.
>-** 
>-** Additional Notice Provisions: This software was created using the
>-** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
>-** not been independently verified as being compliant with the OpenGL(R)
>-** version 1.2.1 Specification.
>-*/
>-
>-#define NEED_REPLIES
>-#ifdef HAVE_DIX_CONFIG_H
>-#include <dix-config.h>
>-#endif
>-
>-#include "glxserver.h"
>-#include "glxext.h"
>-#include "g_disptab.h"
>-#include "g_disptab_EXT.h"
>-#include "unpack.h"
>-#include "impsize.h"
>-#include "singlesize.h"
>-
>-int __glXDispSwap_NewList(__GLXclientState *cl, GLbyte *pc)
>-{
>-	__GLXcontext *cx;
>-	int error;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-
>-	glNewList( 
>-		*(GLuint   *)(pc + 0),
>-		*(GLenum   *)(pc + 4)
>-	);
>-	__GLX_NOTE_UNFLUSHED_CMDS(cx);
>-	return Success;
>-}
>-
>-int __glXDispSwap_EndList(__GLXclientState *cl, GLbyte *pc)
>-{
>-	__GLXcontext *cx;
>-	int error;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-
>-	glEndList( 
>-	);
>-	return Success;
>-}
>-
>-int __glXDispSwap_DeleteLists(__GLXclientState *cl, GLbyte *pc)
>-{
>-	__GLXcontext *cx;
>-	int error;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-
>-	glDeleteLists( 
>-		*(GLuint   *)(pc + 0),
>-		*(GLsizei  *)(pc + 4)
>-	);
>-	__GLX_NOTE_UNFLUSHED_CMDS(cx);
>-	return Success;
>-}
>-
>-int __glXDispSwap_GenLists(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLuint retval;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	retval =
>-	glGenLists( 
>-		*(GLsizei  *)(pc + 0)
>-	);
>-	__GLX_PUT_RETVAL(retval);
>-	__GLX_SWAP_REPLY_RETVAL();
>-	__GLX_BEGIN_REPLY(0);
>-	__GLX_SWAP_REPLY_HEADER();
>-	__GLX_SEND_HEADER();
>-	return Success;
>-}
>-
>-int __glXDispSwap_PixelStoref(__GLXclientState *cl, GLbyte *pc)
>-{
>-	__GLXcontext *cx;
>-	int error;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_FLOAT(pc + 4);
>-
>-	glPixelStoref( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLfloat  *)(pc + 4)
>-	);
>-	__GLX_NOTE_UNFLUSHED_CMDS(cx);
>-	return Success;
>-}
>-
>-int __glXDispSwap_PixelStorei(__GLXclientState *cl, GLbyte *pc)
>-{
>-	__GLXcontext *cx;
>-	int error;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-
>-	glPixelStorei( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4)
>-	);
>-	__GLX_NOTE_UNFLUSHED_CMDS(cx);
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetBooleanv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLboolean answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	pname = *(GLenum *)(pc + 0);
>-	compsize = __glGetBooleanv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>-	__glXClearErrorOccured();
>-	glGetBooleanv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLboolean *) answer
>-	);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_BYTE();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_BYTE_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetDoublev(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLdouble answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	pname = *(GLenum *)(pc + 0);
>-	compsize = __glGetDoublev_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*8,8);
>-	__glXClearErrorOccured();
>-	glGetDoublev( 
>-		*(GLenum   *)(pc + 0),
>-		(GLdouble *) answer
>-	);
>-	__GLX_SWAP_DOUBLE_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_DOUBLE();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*8);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_DOUBLE_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetError(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum retval;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-
>-	retval =
>-	glGetError( 
>-	);
>-	__GLX_PUT_RETVAL(retval);
>-	__GLX_SWAP_REPLY_RETVAL();
>-	__GLX_BEGIN_REPLY(0);
>-	__GLX_SWAP_REPLY_HEADER();
>-	__GLX_SEND_HEADER();
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetFloatv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	pname = *(GLenum *)(pc + 0);
>-	compsize = __glGetFloatv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetFloatv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLfloat  *) answer
>-	);
>-	__GLX_SWAP_FLOAT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetIntegerv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	pname = *(GLenum *)(pc + 0);
>-	compsize = __glGetIntegerv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetIntegerv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLint    *) answer
>-	);
>-	__GLX_SWAP_INT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetLightfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetLightfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetLightfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	__GLX_SWAP_FLOAT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetLightiv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetLightiv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetLightiv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	__GLX_SWAP_INT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetMapdv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum target;
>-	GLenum query;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLdouble answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	target = *(GLenum *)(pc + 0);
>-	query = *(GLenum *)(pc + 4);
>-	compsize = __glGetMapdv_size(target,query);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*8,8);
>-	__glXClearErrorOccured();
>-	glGetMapdv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLdouble *) answer
>-	);
>-	__GLX_SWAP_DOUBLE_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_DOUBLE();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*8);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_DOUBLE_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetMapfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum target;
>-	GLenum query;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	target = *(GLenum *)(pc + 0);
>-	query = *(GLenum *)(pc + 4);
>-	compsize = __glGetMapfv_size(target,query);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetMapfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	__GLX_SWAP_FLOAT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetMapiv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum target;
>-	GLenum query;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-	target = *(GLenum *)(pc + 0);
>-	query = *(GLenum *)(pc + 4);
>-	compsize = __glGetMapiv_size(target,query);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetMapiv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	__GLX_SWAP_INT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetMaterialfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetMaterialfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetMaterialfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	__GLX_SWAP_FLOAT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetMaterialiv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetMaterialiv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetMaterialiv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	__GLX_SWAP_INT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetPixelMapfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum map;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	map = *(GLenum *)(pc + 0);
>-	compsize = __glGetPixelMapfv_size(map);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetPixelMapfv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLfloat  *) answer
>-	);
>-	__GLX_SWAP_FLOAT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetPixelMapuiv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum map;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLuint answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	map = *(GLenum *)(pc + 0);
>-	compsize = __glGetPixelMapuiv_size(map);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetPixelMapuiv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLuint   *) answer
>-	);
>-	__GLX_SWAP_INT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetPixelMapusv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum map;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLushort answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	map = *(GLenum *)(pc + 0);
>-	compsize = __glGetPixelMapusv_size(map);
>-	if (compsize < 0) compsize = 0;
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*2,2);
>-	__glXClearErrorOccured();
>-	glGetPixelMapusv( 
>-		*(GLenum   *)(pc + 0),
>-		(GLushort *) answer
>-	);
>-	__GLX_SWAP_SHORT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_SHORT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*2);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_SHORT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetTexEnvfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetTexEnvfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetTexEnvfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	__GLX_SWAP_FLOAT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetTexEnviv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetTexEnviv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetTexEnviv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	__GLX_SWAP_INT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetTexGendv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLdouble answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetTexGendv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*8,8);
>-	__glXClearErrorOccured();
>-	glGetTexGendv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLdouble *) answer
>-	);
>-	__GLX_SWAP_DOUBLE_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_DOUBLE();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*8);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_DOUBLE_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetTexGenfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetTexGenfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetTexGenfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	__GLX_SWAP_FLOAT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetTexGeniv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetTexGeniv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetTexGeniv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	__GLX_SWAP_INT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetTexParameterfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetTexParameterfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetTexParameterfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	__GLX_SWAP_FLOAT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetTexParameteriv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetTexParameteriv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetTexParameteriv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	__GLX_SWAP_INT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetTexLevelParameterfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 8);
>-	pname = *(GLenum *)(pc + 8);
>-	compsize = __glGetTexLevelParameterfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetTexLevelParameterfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLenum   *)(pc + 8),
>-		(GLfloat  *) answer
>-	);
>-	__GLX_SWAP_FLOAT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetTexLevelParameteriv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 8);
>-	pname = *(GLenum *)(pc + 8);
>-	compsize = __glGetTexLevelParameteriv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-	__GLX_SWAP_INT(pc + 4);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetTexLevelParameteriv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLint    *)(pc + 4),
>-		*(GLenum   *)(pc + 8),
>-		(GLint    *) answer
>-	);
>-	__GLX_SWAP_INT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_IsEnabled(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLboolean retval;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	retval =
>-	glIsEnabled( 
>-		*(GLenum   *)(pc + 0)
>-	);
>-	__GLX_PUT_RETVAL(retval);
>-	__GLX_SWAP_REPLY_RETVAL();
>-	__GLX_BEGIN_REPLY(0);
>-	__GLX_SWAP_REPLY_HEADER();
>-	__GLX_SEND_HEADER();
>-	return Success;
>-}
>-
>-int __glXDispSwap_IsList(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLboolean retval;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	retval =
>-	glIsList( 
>-		*(GLuint   *)(pc + 0)
>-	);
>-	__GLX_PUT_RETVAL(retval);
>-	__GLX_SWAP_REPLY_RETVAL();
>-	__GLX_BEGIN_REPLY(0);
>-	__GLX_SWAP_REPLY_HEADER();
>-	__GLX_SEND_HEADER();
>-	return Success;
>-}
>-
>-int __glXDispSwap_AreTexturesResident(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLsizei n;
>-	GLboolean retval;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLboolean answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	n = *(GLsizei *)(pc + 0);
>-	__GLX_SWAP_INT_ARRAY(pc + 4, n);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,n,1);
>-	retval =
>-	glAreTexturesResident( 
>-		*(GLsizei  *)(pc + 0),
>-		(GLuint   *)(pc + 4),
>-		(GLboolean *) answer
>-	);
>-	__GLX_PUT_RETVAL(retval);
>-	__GLX_SWAP_REPLY_RETVAL();
>-	__GLX_BEGIN_REPLY(n);
>-	__GLX_SWAP_REPLY_HEADER();
>-	__GLX_SEND_HEADER();
>-	__GLX_SEND_BYTE_ARRAY(n);
>-	return Success;
>-}
>-
>-int __glXDispSwap_DeleteTextures(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLsizei n;
>-	__GLXcontext *cx;
>-	int error;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	n = *(GLsizei *)(pc + 0);
>-	__GLX_SWAP_INT_ARRAY(pc + 4, n);
>-
>-	glDeleteTextures( 
>-		*(GLsizei  *)(pc + 0),
>-		(GLuint   *)(pc + 4)
>-	);
>-	return Success;
>-}
>-
>-int __glXDispSwap_GenTextures(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLsizei n;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLuint answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	n = *(GLsizei *)(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,n*4,4);
>-	glGenTextures( 
>-		*(GLsizei  *)(pc + 0),
>-		(GLuint   *) answer
>-	);
>-	__GLX_SWAP_INT_ARRAY(answer, n);
>-	__GLX_BEGIN_REPLY(n*4);
>-	__GLX_SWAP_REPLY_HEADER();
>-	__GLX_SEND_HEADER();
>-	__GLX_SEND_INT_ARRAY(n);
>-	return Success;
>-}
>-
>-int __glXDispSwap_IsTexture(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLboolean retval;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	retval =
>-	glIsTexture( 
>-		*(GLuint   *)(pc + 0)
>-	);
>-	__GLX_PUT_RETVAL(retval);
>-	__GLX_SWAP_REPLY_RETVAL();
>-	__GLX_BEGIN_REPLY(0);
>-	__GLX_SWAP_REPLY_HEADER();
>-	__GLX_SEND_HEADER();
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetColorTableParameterfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetColorTableParameterfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetColorTableParameterfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	__GLX_SWAP_FLOAT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetColorTableParameteriv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetColorTableParameteriv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetColorTableParameteriv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	__GLX_SWAP_INT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetConvolutionParameterfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetConvolutionParameterfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetConvolutionParameterfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	__GLX_SWAP_FLOAT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetConvolutionParameteriv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetConvolutionParameteriv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetConvolutionParameteriv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	__GLX_SWAP_INT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetHistogramParameterfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetHistogramParameterfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetHistogramParameterfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	__GLX_SWAP_FLOAT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetHistogramParameteriv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetHistogramParameteriv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetHistogramParameteriv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	__GLX_SWAP_INT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetMinmaxParameterfv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLfloat answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetMinmaxParameterfv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetMinmaxParameterfv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLfloat  *) answer
>-	);
>-	__GLX_SWAP_FLOAT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_FLOAT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_FLOAT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_GetMinmaxParameteriv(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLenum pname;
>-	GLint compsize;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLint answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_SINGLE_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 4);
>-	pname = *(GLenum *)(pc + 4);
>-	compsize = __glGetMinmaxParameteriv_size(pname);
>-	if (compsize < 0) compsize = 0;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
>-	__glXClearErrorOccured();
>-	glGetMinmaxParameteriv( 
>-		*(GLenum   *)(pc + 0),
>-		*(GLenum   *)(pc + 4),
>-		(GLint    *) answer
>-	);
>-	__GLX_SWAP_INT_ARRAY(answer, compsize);
>-	if (__glXErrorOccured()) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(0);
>-	    __GLX_SEND_HEADER();
>-	} else if (compsize == 1) {
>-	    __GLX_BEGIN_REPLY(0);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(1);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_PUT_INT();
>-	    __GLX_SEND_HEADER();
>-	} else {
>-	    __GLX_BEGIN_REPLY(compsize*4);
>-	    __GLX_SWAP_REPLY_HEADER();
>-	    __GLX_PUT_SIZE(compsize);
>-	    __GLX_SWAP_REPLY_SIZE();
>-	    __GLX_SEND_HEADER();
>-	    __GLX_SEND_INT_ARRAY(compsize);
>-	}
>-	return Success;
>-}
>-
>-int __glXDispSwap_AreTexturesResidentEXT(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLsizei n;
>-	GLboolean retval;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLboolean answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXVendorPrivateReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_VENDPRIV_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_VENDPRIV_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	n = *(GLsizei *)(pc + 0);
>-	__GLX_SWAP_INT_ARRAY(pc + 4, n);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,n,1);
>-	retval =
>-	glAreTexturesResidentEXT( 
>-		*(GLsizei  *)(pc + 0),
>-		(GLuint   *)(pc + 4),
>-		(GLboolean *) answer
>-	);
>-	__GLX_PUT_RETVAL(retval);
>-	__GLX_SWAP_REPLY_RETVAL();
>-	__GLX_BEGIN_REPLY(n);
>-	__GLX_SWAP_REPLY_HEADER();
>-	__GLX_SEND_HEADER();
>-	__GLX_SEND_BYTE_ARRAY(n);
>-	return Success;
>-}
>-
>-int __glXDispSwap_DeleteTexturesEXT(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLsizei n;
>-	__GLXcontext *cx;
>-	int error;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXVendorPrivateReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_VENDPRIV_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_VENDPRIV_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	n = *(GLsizei *)(pc + 0);
>-	__GLX_SWAP_INT_ARRAY(pc + 4, n);
>-
>-	glDeleteTexturesEXT( 
>-		*(GLsizei  *)(pc + 0),
>-		(GLuint   *)(pc + 4)
>-	);
>-	return Success;
>-}
>-
>-int __glXDispSwap_GenTexturesEXT(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLsizei n;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	GLuint answerBuffer[200];
>-	char *answer;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXVendorPrivateReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_VENDPRIV_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_VENDPRIV_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-	n = *(GLsizei *)(pc + 0);
>-
>-	__GLX_GET_ANSWER_BUFFER(answer,cl,n*4,4);
>-	glGenTexturesEXT( 
>-		*(GLsizei  *)(pc + 0),
>-		(GLuint   *) answer
>-	);
>-	__GLX_SWAP_INT_ARRAY(answer, n);
>-	__GLX_BEGIN_REPLY(n*4);
>-	__GLX_SWAP_REPLY_HEADER();
>-	__GLX_SEND_HEADER();
>-	__GLX_SEND_INT_ARRAY(n);
>-	return Success;
>-}
>-
>-int __glXDispSwap_IsTextureEXT(__GLXclientState *cl, GLbyte *pc)
>-{
>-	GLboolean retval;
>-	__GLXcontext *cx;
>-	ClientPtr client = cl->client;
>-	int error;
>-	__GLX_DECLARE_SWAP_VARIABLES;
>-
>-	__GLX_SWAP_INT(&((xGLXVendorPrivateReq *)pc)->contextTag);
>-	cx = __glXForceCurrent(cl, __GLX_GET_VENDPRIV_CONTEXT_TAG(pc), &error);
>-	if (!cx) {
>-		return error;
>-	}
>-	pc += __GLX_VENDPRIV_HDR_SIZE;
>-	__GLX_SWAP_INT(pc + 0);
>-
>-	retval =
>-	glIsTextureEXT( 
>-		*(GLuint   *)(pc + 0)
>-	);
>-	__GLX_PUT_RETVAL(retval);
>-	__GLX_SWAP_REPLY_RETVAL();
>-	__GLX_BEGIN_REPLY(0);
>-	__GLX_SWAP_REPLY_HEADER();
>-	__GLX_SEND_HEADER();
>-	return Success;
>-}
>-
>Index: xorg/GL/glx/glxcmds.c
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/glxcmds.c,v
>retrieving revision 1.8
>diff -u -d -r1.8 glxcmds.c
>--- xorg/GL/glx/glxcmds.c	5 Oct 2005 22:39:41 -0000	1.8
>+++ xorg/GL/glx/glxcmds.c	12 Jan 2006 00:04:16 -0000
>@@ -52,6 +52,10 @@
> #include "glxext.h"
> #include "GL/glx_ansic.h"
> #include "glcontextmodes.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
>+#include "dispatch.h"
> 
> /************************************************************************/
> 
>@@ -624,7 +628,7 @@
> 	*/
> 	if (__GLX_HAS_UNFLUSHED_CMDS(prevglxc)) {
> 	    if (__glXForceCurrent(cl, tag, (int *)&error)) {
>-		glFlush();
>+		CALL_Flush( GET_DISPATCH(), () );
> 		__GLX_NOTE_FLUSHED_CMDS(prevglxc);
> 	    } else {
> 		return error;
>@@ -810,7 +814,7 @@
>     if (!__glXForceCurrent(cl, req->contextTag, &error)) {
> 	return error;
>     }
>-    glFinish();
>+    CALL_Finish( GET_DISPATCH(), () );
>     return Success;
> }
> 
>@@ -896,7 +900,7 @@
> 	    ** Do whatever is needed to make sure that all preceding requests
> 	    ** in both streams are completed before the copy is executed.
> 	    */
>-	    glFinish();
>+	    CALL_Finish( GET_DISPATCH(), () );
> 	    __GLX_NOTE_FLUSHED_CMDS(tagcx);
> 	} else {
> 	    return error;
>@@ -1325,7 +1329,7 @@
> 	    ** Do whatever is needed to make sure that all preceding requests
> 	    ** in both streams are completed before the swap is executed.
> 	    */
>-	    glFinish();
>+	    CALL_Finish( GET_DISPATCH(), () );
> 	    __GLX_NOTE_FLUSHED_CMDS(glxc);
> 	} else {
> 	    return error;
>@@ -1971,11 +1975,11 @@
> #ifndef __DARWIN__
>     switch( vendorcode ) {
>     case X_GLvop_SampleMaskSGIS:
>-	glSampleMaskSGIS(*(GLfloat *)(pc + 4),
>-			 *(GLboolean *)(pc + 8));
>+	CALL_SampleMaskSGIS( GET_DISPATCH(),
>+			     (*(GLfloat *)(pc + 4), *(GLboolean *)(pc + 8)) );
> 	return Success;
>     case X_GLvop_SamplePatternSGIS:
>-	glSamplePatternSGIS( *(GLenum *)(pc + 4));
>+	CALL_SamplePatternSGIS( GET_DISPATCH(),	(*(GLenum *)(pc + 4)) );
> 	return Success;
>     case X_GLXvop_BindSwapBarrierSGIX:
>         return __glXBindSwapBarrierSGIX(cl, pc);
>Index: xorg/GL/glx/glxcmdsswap.c
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/glxcmdsswap.c,v
>retrieving revision 1.4
>diff -u -d -r1.4 glxcmdsswap.c
>--- xorg/GL/glx/glxcmdsswap.c	3 Jul 2005 07:01:02 -0000	1.4
>+++ xorg/GL/glx/glxcmdsswap.c	12 Jan 2006 00:04:16 -0000
>@@ -50,6 +50,10 @@
> #include <windowstr.h>
> #include "glxext.h"
> #include "GL/glx_ansic.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
>+#include "dispatch.h"
> 
> static int __glXSwapGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc);
> static int __glXSwapCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
>@@ -813,12 +817,12 @@
>     case X_GLvop_SampleMaskSGIS:
> 	__GLX_SWAP_FLOAT(pc + 4);
> 	__GLX_SWAP_INT(pc + 8);
>-	glSampleMaskSGIS(*(GLfloat *)(pc + 4),
>-			 *(GLboolean *)(pc + 8));
>+	CALL_SampleMaskSGIS( GET_DISPATCH(),
>+			     (*(GLfloat *)(pc + 4), *(GLboolean *)(pc + 8)) );
> 	return Success;
>     case X_GLvop_SamplePatternSGIS:
> 	__GLX_SWAP_INT(pc + 4);
>-	glSamplePatternSGIS( *(GLenum *)(pc + 4));
>+	CALL_SamplePatternSGIS( GET_DISPATCH(), (*(GLenum *)(pc + 4)) );
> 	return Success;
>     }
> #endif
>Index: xorg/GL/glx/glxserver.h
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/glxserver.h,v
>retrieving revision 1.5
>diff -u -d -r1.5 glxserver.h
>--- xorg/GL/glx/glxserver.h	1 Oct 2005 22:25:13 -0000	1.5
>+++ xorg/GL/glx/glxserver.h	12 Jan 2006 00:04:16 -0000
>@@ -178,7 +178,7 @@
>  */
> typedef struct {
>     int bytes;
>-    int (*varsize)(GLbyte *pc, Bool swap);
>+    int (*varsize)(const GLbyte *pc, Bool swap);
> } __GLXrenderSizeData;
> extern __GLXrenderSizeData __glXRenderSizeTable[];
> extern __GLXrenderSizeData __glXRenderSizeTable_EXT[];
>@@ -230,58 +230,6 @@
>     GLint imageHeight, GLint rowLength, GLint skipImages, GLint skipRows,
>     GLint alignment);
> 
>-extern int __glXCallListsReqSize(GLbyte *pc, Bool swap);
>-extern int __glXBitmapReqSize(GLbyte *pc, Bool swap);
>-extern int __glXFogfvReqSize(GLbyte *pc, Bool swap);
>-extern int __glXFogivReqSize(GLbyte *pc, Bool swap);
>-extern int __glXLightfvReqSize(GLbyte *pc, Bool swap);
>-extern int __glXLightivReqSize(GLbyte *pc, Bool swap);
>-extern int __glXLightModelfvReqSize(GLbyte *pc, Bool swap);
>-extern int __glXLightModelivReqSize(GLbyte *pc, Bool swap);
>-extern int __glXMaterialfvReqSize(GLbyte *pc, Bool swap);
>-extern int __glXMaterialivReqSize(GLbyte *pc, Bool swap);
>-extern int __glXTexParameterfvReqSize(GLbyte *pc, Bool swap);
>-extern int __glXTexParameterivReqSize(GLbyte *pc, Bool swap);
>-extern int __glXTexImage1DReqSize(GLbyte *pc, Bool swap);
>-extern int __glXTexImage2DReqSize(GLbyte *pc, Bool swap);
>-extern int __glXTexEnvfvReqSize(GLbyte *pc, Bool swap);
>-extern int __glXTexEnvivReqSize(GLbyte *pc, Bool swap);
>-extern int __glXTexGendvReqSize(GLbyte *pc, Bool swap);
>-extern int __glXTexGenfvReqSize(GLbyte *pc, Bool swap);
>-extern int __glXTexGenivReqSize(GLbyte *pc, Bool swap);
>-extern int __glXMap1dReqSize(GLbyte *pc, Bool swap);
>-extern int __glXMap1fReqSize(GLbyte *pc, Bool swap);
>-extern int __glXMap2dReqSize(GLbyte *pc, Bool swap);
>-extern int __glXMap2fReqSize(GLbyte *pc, Bool swap);
>-extern int __glXPixelMapfvReqSize(GLbyte *pc, Bool swap);
>-extern int __glXPixelMapuivReqSize(GLbyte *pc, Bool swap);
>-extern int __glXPixelMapusvReqSize(GLbyte *pc, Bool swap);
>-extern int __glXDrawPixelsReqSize(GLbyte *pc, Bool swap);
>-extern int __glXDrawArraysSize(GLbyte *pc, Bool swap);
>-extern int __glXPrioritizeTexturesReqSize(GLbyte *pc, Bool swap);
>-extern int __glXTexSubImage1DReqSize(GLbyte *pc, Bool swap);
>-extern int __glXTexSubImage2DReqSize(GLbyte *pc, Bool swap);
>-extern int __glXTexImage3DReqSize(GLbyte *pc, Bool swap );
>-extern int __glXTexSubImage3DReqSize(GLbyte *pc, Bool swap);
>-extern int __glXConvolutionFilter1DReqSize(GLbyte *pc, Bool swap);
>-extern int __glXConvolutionFilter2DReqSize(GLbyte *pc, Bool swap);
>-extern int __glXConvolutionParameterivReqSize(GLbyte *pc, Bool swap);
>-extern int __glXConvolutionParameterfvReqSize(GLbyte *pc, Bool swap);
>-extern int __glXSeparableFilter2DReqSize(GLbyte *pc, Bool swap);
>-extern int __glXColorTableReqSize(GLbyte *pc, Bool swap);
>-extern int __glXColorSubTableReqSize(GLbyte *pc, Bool swap);
>-extern int __glXColorTableParameterfvReqSize(GLbyte *pc, Bool swap);
>-extern int __glXColorTableParameterivReqSize(GLbyte *pc, Bool swap);
>-
>-/*
>- * Routines for computing the size of returned data.
>- */
>-extern int __glXConvolutionParameterivSize(GLenum pname);
>-extern int __glXConvolutionParameterfvSize(GLenum pname);
>-extern int __glXColorTableParameterfvSize(GLenum pname);
>-extern int __glXColorTableParameterivSize(GLenum pname);
>-
>-extern int __glXPointParameterfvARBReqSize(GLbyte *pc, Bool swap);
>-extern int __glXPointParameterivReqSize(GLbyte *pc, Bool swap);
>+extern int __glXDrawArraysSize(const GLbyte *pc, Bool swap);
> 
> #endif /* !__GLX_server_h__ */
>Index: xorg/GL/glx/impsize.h
>===================================================================
>RCS file: xorg/GL/glx/impsize.h
>diff -N xorg/GL/glx/impsize.h
>--- xorg/GL/glx/impsize.h	28 Sep 2005 03:37:22 -0000	1.6
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,56 +0,0 @@
>-/* $XFree86: xc/programs/Xserver/GL/glx/impsize.h,v 1.4 2003/09/28 20:15:43 alanh Exp $ */
>-#ifdef HAVE_DIX_CONFIG_H
>-#include <dix-config.h>
>-#endif
>-
>-#ifndef _impsize_h_
>-#define _impsize_h_
>-
>-/*
>-** License Applicability. Except to the extent portions of this file are
>-** made subject to an alternative license as permitted in the SGI Free
>-** Software License B, Version 1.1 (the "License"), the contents of this
>-** file are subject only to the provisions of the License. You may not use
>-** this file except in compliance with the License. You may obtain a copy
>-** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
>-** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
>-** 
>-** http://oss.sgi.com/projects/FreeB
>-** 
>-** Note that, as provided in the License, the Software is distributed on an
>-** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
>-** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
>-** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
>-** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
>-** 
>-** Original Code. The Original Code is: OpenGL Sample Implementation,
>-** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
>-** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
>-** Copyright in any portions created by third parties is as indicated
>-** elsewhere herein. All Rights Reserved.
>-** 
>-** Additional Notice Provisions: The application programming interfaces
>-** established by SGI in conjunction with the Original Code are The
>-** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
>-** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
>-** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
>-** Window System(R) (Version 1.3), released October 19, 1998. This software
>-** was created using the OpenGL(R) version 1.2.1 Sample Implementation
>-** published by SGI, but has not been independently verified as being
>-** compliant with the OpenGL(R) version 1.2.1 Specification.
>-**
>-*/
>-
>-/*
>-** These are defined in libsampleGL.a. They are not technically part of
>-** the defined interface between libdixGL.a and libsampleGL.a (that interface
>-** being the functions in the __glXScreenInfo structure, plus the OpenGL API
>-** itself), but we thought it was better to call these routines than to
>-** replicate the code in here.
>-*/
>-
>-#include "indirect_size.h"
>-
>-extern int __glDrawPixels_size(GLenum format, GLenum type, GLsizei w,GLsizei h);
>-
>-#endif /* _impsize_h_ */
>Index: xorg/GL/glx/indirect_dispatch.c
>===================================================================
>RCS file: xorg/GL/glx/indirect_dispatch.c
>diff -N xorg/GL/glx/indirect_dispatch.c
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ xorg/GL/glx/indirect_dispatch.c	12 Jan 2006 00:04:16 -0000
>@@ -0,0 +1,5654 @@
>+/* DO NOT EDIT - This file generated automatically by glX_proto_recv.py (from Mesa) script */
>+
>+/*
>+ * (C) Copyright IBM Corporation 2005
>+ * 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
>+ * IBM,
>+ * 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 <X11/Xmd.h>
>+#include <GL/gl.h>
>+#include <GL/glxproto.h>
>+#include <byteswap.h>
>+#include <inttypes.h>
>+#include "indirect_size.h"
>+#include "indirect_size_get.h"
>+#include "indirect_dispatch.h"
>+#include "glxserver.h"
>+#include "indirect_util.h"
>+#include "singlesize.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
>+#include "dispatch.h"
>+
>+#define __GLX_PAD(x)  (((x) + 3) & ~3)
>+
>+typedef struct {
>+    __GLX_PIXEL_3D_HDR;
>+} __GLXpixel3DHeader;
>+
>+extern GLboolean __glXErrorOccured( void );
>+extern void __glXClearErrorOccured( void );
>+
>+static const unsigned dummy_answer[2] = {0, 0};
>+
>+int __glXDisp_NewList(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        CALL_NewList( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0),
>+            *(GLenum   *)(pc +  4)
>+        ) );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_EndList(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        CALL_EndList( GET_DISPATCH(), () );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_CallList(GLbyte * pc)
>+{
>+    CALL_CallList( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_CallLists(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  0);
>+    const GLenum type = *(GLenum   *)(pc +  4);
>+    const GLvoid * lists =  (const GLvoid *)(pc +  8);
>+
>+    lists = (const GLvoid *) (pc + 8);
>+
>+    CALL_CallLists( GET_DISPATCH(), (
>+        n,
>+        *(GLenum   *)(pc +  4),
>+        lists
>+    ) );
>+}
>+
>+int __glXDisp_DeleteLists(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        CALL_DeleteLists( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0),
>+            *(GLsizei  *)(pc +  4)
>+        ) );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GenLists(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLuint retval;
>+        retval = CALL_GenLists( GET_DISPATCH(), (
>+            *(GLsizei  *)(pc +  0)
>+        ) );
>+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_ListBase(GLbyte * pc)
>+{
>+    CALL_ListBase( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Begin(GLbyte * pc)
>+{
>+    CALL_Begin( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Bitmap(GLbyte * pc)
>+{
>+    const GLubyte * const bitmap = (const GLubyte *) (pc + 44);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
>+
>+    CALL_Bitmap( GET_DISPATCH(), (
>+        *(GLsizei  *)(pc + 20),
>+        *(GLsizei  *)(pc + 24),
>+        *(GLfloat  *)(pc + 28),
>+        *(GLfloat  *)(pc + 32),
>+        *(GLfloat  *)(pc + 36),
>+        *(GLfloat  *)(pc + 40),
>+        bitmap
>+    ) );
>+}
>+
>+void __glXDisp_Color3bv(GLbyte * pc)
>+{
>+    CALL_Color3bv( GET_DISPATCH(), (
>+         (const GLbyte *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Color3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Color3dv( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Color3fv(GLbyte * pc)
>+{
>+    CALL_Color3fv( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Color3iv(GLbyte * pc)
>+{
>+    CALL_Color3iv( GET_DISPATCH(), (
>+         (const GLint *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Color3sv(GLbyte * pc)
>+{
>+    CALL_Color3sv( GET_DISPATCH(), (
>+         (const GLshort *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Color3ubv(GLbyte * pc)
>+{
>+    CALL_Color3ubv( GET_DISPATCH(), (
>+         (const GLubyte *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Color3uiv(GLbyte * pc)
>+{
>+    CALL_Color3uiv( GET_DISPATCH(), (
>+         (const GLuint *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Color3usv(GLbyte * pc)
>+{
>+    CALL_Color3usv( GET_DISPATCH(), (
>+         (const GLushort *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Color4bv(GLbyte * pc)
>+{
>+    CALL_Color4bv( GET_DISPATCH(), (
>+         (const GLbyte *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Color4dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Color4dv( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Color4fv(GLbyte * pc)
>+{
>+    CALL_Color4fv( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Color4iv(GLbyte * pc)
>+{
>+    CALL_Color4iv( GET_DISPATCH(), (
>+         (const GLint *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Color4sv(GLbyte * pc)
>+{
>+    CALL_Color4sv( GET_DISPATCH(), (
>+         (const GLshort *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Color4ubv(GLbyte * pc)
>+{
>+    CALL_Color4ubv( GET_DISPATCH(), (
>+         (const GLubyte *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Color4uiv(GLbyte * pc)
>+{
>+    CALL_Color4uiv( GET_DISPATCH(), (
>+         (const GLuint *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Color4usv(GLbyte * pc)
>+{
>+    CALL_Color4usv( GET_DISPATCH(), (
>+         (const GLushort *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_EdgeFlagv(GLbyte * pc)
>+{
>+    CALL_EdgeFlagv( GET_DISPATCH(), (
>+         (const GLboolean *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_End(GLbyte * pc)
>+{
>+    CALL_End( GET_DISPATCH(), () );
>+}
>+
>+void __glXDisp_Indexdv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Indexdv( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Indexfv(GLbyte * pc)
>+{
>+    CALL_Indexfv( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Indexiv(GLbyte * pc)
>+{
>+    CALL_Indexiv( GET_DISPATCH(), (
>+         (const GLint *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Indexsv(GLbyte * pc)
>+{
>+    CALL_Indexsv( GET_DISPATCH(), (
>+         (const GLshort *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Normal3bv(GLbyte * pc)
>+{
>+    CALL_Normal3bv( GET_DISPATCH(), (
>+         (const GLbyte *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Normal3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Normal3dv( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Normal3fv(GLbyte * pc)
>+{
>+    CALL_Normal3fv( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Normal3iv(GLbyte * pc)
>+{
>+    CALL_Normal3iv( GET_DISPATCH(), (
>+         (const GLint *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Normal3sv(GLbyte * pc)
>+{
>+    CALL_Normal3sv( GET_DISPATCH(), (
>+         (const GLshort *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_RasterPos2dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_RasterPos2dv( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_RasterPos2fv(GLbyte * pc)
>+{
>+    CALL_RasterPos2fv( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_RasterPos2iv(GLbyte * pc)
>+{
>+    CALL_RasterPos2iv( GET_DISPATCH(), (
>+         (const GLint *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_RasterPos2sv(GLbyte * pc)
>+{
>+    CALL_RasterPos2sv( GET_DISPATCH(), (
>+         (const GLshort *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_RasterPos3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_RasterPos3dv( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_RasterPos3fv(GLbyte * pc)
>+{
>+    CALL_RasterPos3fv( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_RasterPos3iv(GLbyte * pc)
>+{
>+    CALL_RasterPos3iv( GET_DISPATCH(), (
>+         (const GLint *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_RasterPos3sv(GLbyte * pc)
>+{
>+    CALL_RasterPos3sv( GET_DISPATCH(), (
>+         (const GLshort *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_RasterPos4dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_RasterPos4dv( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_RasterPos4fv(GLbyte * pc)
>+{
>+    CALL_RasterPos4fv( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_RasterPos4iv(GLbyte * pc)
>+{
>+    CALL_RasterPos4iv( GET_DISPATCH(), (
>+         (const GLint *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_RasterPos4sv(GLbyte * pc)
>+{
>+    CALL_RasterPos4sv( GET_DISPATCH(), (
>+         (const GLshort *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Rectdv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Rectdv( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0),
>+         (const GLdouble *)(pc + 16)
>+    ) );
>+}
>+
>+void __glXDisp_Rectfv(GLbyte * pc)
>+{
>+    CALL_Rectfv( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0),
>+         (const GLfloat *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_Rectiv(GLbyte * pc)
>+{
>+    CALL_Rectiv( GET_DISPATCH(), (
>+         (const GLint *)(pc +  0),
>+         (const GLint *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_Rectsv(GLbyte * pc)
>+{
>+    CALL_Rectsv( GET_DISPATCH(), (
>+         (const GLshort *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_TexCoord1dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_TexCoord1dv( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_TexCoord1fv(GLbyte * pc)
>+{
>+    CALL_TexCoord1fv( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_TexCoord1iv(GLbyte * pc)
>+{
>+    CALL_TexCoord1iv( GET_DISPATCH(), (
>+         (const GLint *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_TexCoord1sv(GLbyte * pc)
>+{
>+    CALL_TexCoord1sv( GET_DISPATCH(), (
>+         (const GLshort *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_TexCoord2dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_TexCoord2dv( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_TexCoord2fv(GLbyte * pc)
>+{
>+    CALL_TexCoord2fv( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_TexCoord2iv(GLbyte * pc)
>+{
>+    CALL_TexCoord2iv( GET_DISPATCH(), (
>+         (const GLint *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_TexCoord2sv(GLbyte * pc)
>+{
>+    CALL_TexCoord2sv( GET_DISPATCH(), (
>+         (const GLshort *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_TexCoord3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_TexCoord3dv( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_TexCoord3fv(GLbyte * pc)
>+{
>+    CALL_TexCoord3fv( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_TexCoord3iv(GLbyte * pc)
>+{
>+    CALL_TexCoord3iv( GET_DISPATCH(), (
>+         (const GLint *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_TexCoord3sv(GLbyte * pc)
>+{
>+    CALL_TexCoord3sv( GET_DISPATCH(), (
>+         (const GLshort *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_TexCoord4dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_TexCoord4dv( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_TexCoord4fv(GLbyte * pc)
>+{
>+    CALL_TexCoord4fv( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_TexCoord4iv(GLbyte * pc)
>+{
>+    CALL_TexCoord4iv( GET_DISPATCH(), (
>+         (const GLint *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_TexCoord4sv(GLbyte * pc)
>+{
>+    CALL_TexCoord4sv( GET_DISPATCH(), (
>+         (const GLshort *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Vertex2dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Vertex2dv( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Vertex2fv(GLbyte * pc)
>+{
>+    CALL_Vertex2fv( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Vertex2iv(GLbyte * pc)
>+{
>+    CALL_Vertex2iv( GET_DISPATCH(), (
>+         (const GLint *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Vertex2sv(GLbyte * pc)
>+{
>+    CALL_Vertex2sv( GET_DISPATCH(), (
>+         (const GLshort *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Vertex3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Vertex3dv( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Vertex3fv(GLbyte * pc)
>+{
>+    CALL_Vertex3fv( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Vertex3iv(GLbyte * pc)
>+{
>+    CALL_Vertex3iv( GET_DISPATCH(), (
>+         (const GLint *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Vertex3sv(GLbyte * pc)
>+{
>+    CALL_Vertex3sv( GET_DISPATCH(), (
>+         (const GLshort *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Vertex4dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Vertex4dv( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Vertex4fv(GLbyte * pc)
>+{
>+    CALL_Vertex4fv( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Vertex4iv(GLbyte * pc)
>+{
>+    CALL_Vertex4iv( GET_DISPATCH(), (
>+         (const GLint *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Vertex4sv(GLbyte * pc)
>+{
>+    CALL_Vertex4sv( GET_DISPATCH(), (
>+         (const GLshort *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_ClipPlane(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 36);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_ClipPlane( GET_DISPATCH(), (
>+        *(GLenum   *)(pc + 32),
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_ColorMaterial(GLbyte * pc)
>+{
>+    CALL_ColorMaterial( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_CullFace(GLbyte * pc)
>+{
>+    CALL_CullFace( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Fogf(GLbyte * pc)
>+{
>+    CALL_Fogf( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLfloat  *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_Fogfv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  0);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 4);
>+
>+    CALL_Fogfv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_Fogi(GLbyte * pc)
>+{
>+    CALL_Fogi( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_Fogiv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  0);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 4);
>+
>+    CALL_Fogiv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_FrontFace(GLbyte * pc)
>+{
>+    CALL_FrontFace( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Hint(GLbyte * pc)
>+{
>+    CALL_Hint( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_Lightf(GLbyte * pc)
>+{
>+    CALL_Lightf( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLfloat  *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_Lightfv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 8);
>+
>+    CALL_Lightfv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_Lighti(GLbyte * pc)
>+{
>+    CALL_Lighti( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLint    *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_Lightiv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 8);
>+
>+    CALL_Lightiv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_LightModelf(GLbyte * pc)
>+{
>+    CALL_LightModelf( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLfloat  *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_LightModelfv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  0);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 4);
>+
>+    CALL_LightModelfv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_LightModeli(GLbyte * pc)
>+{
>+    CALL_LightModeli( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_LightModeliv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  0);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 4);
>+
>+    CALL_LightModeliv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_LineStipple(GLbyte * pc)
>+{
>+    CALL_LineStipple( GET_DISPATCH(), (
>+        *(GLint    *)(pc +  0),
>+        *(GLushort *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_LineWidth(GLbyte * pc)
>+{
>+    CALL_LineWidth( GET_DISPATCH(), (
>+        *(GLfloat  *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Materialf(GLbyte * pc)
>+{
>+    CALL_Materialf( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLfloat  *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_Materialfv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 8);
>+
>+    CALL_Materialfv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_Materiali(GLbyte * pc)
>+{
>+    CALL_Materiali( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLint    *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_Materialiv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 8);
>+
>+    CALL_Materialiv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_PointSize(GLbyte * pc)
>+{
>+    CALL_PointSize( GET_DISPATCH(), (
>+        *(GLfloat  *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_PolygonMode(GLbyte * pc)
>+{
>+    CALL_PolygonMode( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_PolygonStipple(GLbyte * pc)
>+{
>+    const GLubyte * const mask = (const GLubyte *) (pc + 20);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
>+
>+    CALL_PolygonStipple( GET_DISPATCH(), (
>+        mask
>+    ) );
>+}
>+
>+void __glXDisp_Scissor(GLbyte * pc)
>+{
>+    CALL_Scissor( GET_DISPATCH(), (
>+        *(GLint    *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLsizei  *)(pc +  8),
>+        *(GLsizei  *)(pc + 12)
>+    ) );
>+}
>+
>+void __glXDisp_ShadeModel(GLbyte * pc)
>+{
>+    CALL_ShadeModel( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_TexParameterf(GLbyte * pc)
>+{
>+    CALL_TexParameterf( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLfloat  *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_TexParameterfv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 8);
>+
>+    CALL_TexParameterfv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_TexParameteri(GLbyte * pc)
>+{
>+    CALL_TexParameteri( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLint    *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_TexParameteriv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 8);
>+
>+    CALL_TexParameteriv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_TexImage1D(GLbyte * pc)
>+{
>+    const GLvoid * const pixels = (const GLvoid *) (pc + 52);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
>+
>+    CALL_TexImage1D( GET_DISPATCH(), (
>+        *(GLenum   *)(pc + 20),
>+        *(GLint    *)(pc + 24),
>+        *(GLint    *)(pc + 28),
>+        *(GLsizei  *)(pc + 32),
>+        *(GLint    *)(pc + 40),
>+        *(GLenum   *)(pc + 44),
>+        *(GLenum   *)(pc + 48),
>+        pixels
>+    ) );
>+}
>+
>+void __glXDisp_TexImage2D(GLbyte * pc)
>+{
>+    const GLvoid * const pixels = (const GLvoid *) (pc + 52);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
>+
>+    CALL_TexImage2D( GET_DISPATCH(), (
>+        *(GLenum   *)(pc + 20),
>+        *(GLint    *)(pc + 24),
>+        *(GLint    *)(pc + 28),
>+        *(GLsizei  *)(pc + 32),
>+        *(GLsizei  *)(pc + 36),
>+        *(GLint    *)(pc + 40),
>+        *(GLenum   *)(pc + 44),
>+        *(GLenum   *)(pc + 48),
>+        pixels
>+    ) );
>+}
>+
>+void __glXDisp_TexEnvf(GLbyte * pc)
>+{
>+    CALL_TexEnvf( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLfloat  *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_TexEnvfv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 8);
>+
>+    CALL_TexEnvfv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_TexEnvi(GLbyte * pc)
>+{
>+    CALL_TexEnvi( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLint    *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_TexEnviv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 8);
>+
>+    CALL_TexEnviv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_TexGend(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_TexGend( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  8),
>+        *(GLenum   *)(pc + 12),
>+        *(GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_TexGendv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLdouble * params;
>+
>+#ifdef __GLX_ALIGN64
>+    const GLuint compsize = __glTexGendv_size(pname);
>+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8)) - 4;
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, cmdlen);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    params = (const GLdouble *) (pc + 8);
>+
>+    CALL_TexGendv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_TexGenf(GLbyte * pc)
>+{
>+    CALL_TexGenf( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLfloat  *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_TexGenfv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 8);
>+
>+    CALL_TexGenfv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_TexGeni(GLbyte * pc)
>+{
>+    CALL_TexGeni( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLint    *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_TexGeniv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 8);
>+
>+    CALL_TexGeniv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_InitNames(GLbyte * pc)
>+{
>+    CALL_InitNames( GET_DISPATCH(), () );
>+}
>+
>+void __glXDisp_LoadName(GLbyte * pc)
>+{
>+    CALL_LoadName( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_PassThrough(GLbyte * pc)
>+{
>+    CALL_PassThrough( GET_DISPATCH(), (
>+        *(GLfloat  *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_PopName(GLbyte * pc)
>+{
>+    CALL_PopName( GET_DISPATCH(), () );
>+}
>+
>+void __glXDisp_PushName(GLbyte * pc)
>+{
>+    CALL_PushName( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_DrawBuffer(GLbyte * pc)
>+{
>+    CALL_DrawBuffer( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Clear(GLbyte * pc)
>+{
>+    CALL_Clear( GET_DISPATCH(), (
>+        *(GLbitfield *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_ClearAccum(GLbyte * pc)
>+{
>+    CALL_ClearAccum( GET_DISPATCH(), (
>+        *(GLfloat  *)(pc +  0),
>+        *(GLfloat  *)(pc +  4),
>+        *(GLfloat  *)(pc +  8),
>+        *(GLfloat  *)(pc + 12)
>+    ) );
>+}
>+
>+void __glXDisp_ClearIndex(GLbyte * pc)
>+{
>+    CALL_ClearIndex( GET_DISPATCH(), (
>+        *(GLfloat  *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_ClearColor(GLbyte * pc)
>+{
>+    CALL_ClearColor( GET_DISPATCH(), (
>+        *(GLclampf *)(pc +  0),
>+        *(GLclampf *)(pc +  4),
>+        *(GLclampf *)(pc +  8),
>+        *(GLclampf *)(pc + 12)
>+    ) );
>+}
>+
>+void __glXDisp_ClearStencil(GLbyte * pc)
>+{
>+    CALL_ClearStencil( GET_DISPATCH(), (
>+        *(GLint    *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_ClearDepth(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_ClearDepth( GET_DISPATCH(), (
>+        *(GLclampd *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_StencilMask(GLbyte * pc)
>+{
>+    CALL_StencilMask( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_ColorMask(GLbyte * pc)
>+{
>+    CALL_ColorMask( GET_DISPATCH(), (
>+        *(GLboolean *)(pc +  0),
>+        *(GLboolean *)(pc +  1),
>+        *(GLboolean *)(pc +  2),
>+        *(GLboolean *)(pc +  3)
>+    ) );
>+}
>+
>+void __glXDisp_DepthMask(GLbyte * pc)
>+{
>+    CALL_DepthMask( GET_DISPATCH(), (
>+        *(GLboolean *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_IndexMask(GLbyte * pc)
>+{
>+    CALL_IndexMask( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Accum(GLbyte * pc)
>+{
>+    CALL_Accum( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLfloat  *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_Disable(GLbyte * pc)
>+{
>+    CALL_Disable( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Enable(GLbyte * pc)
>+{
>+    CALL_Enable( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_PopAttrib(GLbyte * pc)
>+{
>+    CALL_PopAttrib( GET_DISPATCH(), () );
>+}
>+
>+void __glXDisp_PushAttrib(GLbyte * pc)
>+{
>+    CALL_PushAttrib( GET_DISPATCH(), (
>+        *(GLbitfield *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_MapGrid1d(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 20);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_MapGrid1d( GET_DISPATCH(), (
>+        *(GLint    *)(pc + 16),
>+        *(GLdouble *)(pc +  0),
>+        *(GLdouble *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_MapGrid1f(GLbyte * pc)
>+{
>+    CALL_MapGrid1f( GET_DISPATCH(), (
>+        *(GLint    *)(pc +  0),
>+        *(GLfloat  *)(pc +  4),
>+        *(GLfloat  *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_MapGrid2d(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 40);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_MapGrid2d( GET_DISPATCH(), (
>+        *(GLint    *)(pc + 32),
>+        *(GLdouble *)(pc +  0),
>+        *(GLdouble *)(pc +  8),
>+        *(GLint    *)(pc + 36),
>+        *(GLdouble *)(pc + 16),
>+        *(GLdouble *)(pc + 24)
>+    ) );
>+}
>+
>+void __glXDisp_MapGrid2f(GLbyte * pc)
>+{
>+    CALL_MapGrid2f( GET_DISPATCH(), (
>+        *(GLint    *)(pc +  0),
>+        *(GLfloat  *)(pc +  4),
>+        *(GLfloat  *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLfloat  *)(pc + 16),
>+        *(GLfloat  *)(pc + 20)
>+    ) );
>+}
>+
>+void __glXDisp_EvalCoord1dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_EvalCoord1dv( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_EvalCoord1fv(GLbyte * pc)
>+{
>+    CALL_EvalCoord1fv( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_EvalCoord2dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_EvalCoord2dv( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_EvalCoord2fv(GLbyte * pc)
>+{
>+    CALL_EvalCoord2fv( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_EvalMesh1(GLbyte * pc)
>+{
>+    CALL_EvalMesh1( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLint    *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_EvalPoint1(GLbyte * pc)
>+{
>+    CALL_EvalPoint1( GET_DISPATCH(), (
>+        *(GLint    *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_EvalMesh2(GLbyte * pc)
>+{
>+    CALL_EvalMesh2( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLint    *)(pc + 16)
>+    ) );
>+}
>+
>+void __glXDisp_EvalPoint2(GLbyte * pc)
>+{
>+    CALL_EvalPoint2( GET_DISPATCH(), (
>+        *(GLint    *)(pc +  0),
>+        *(GLint    *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_AlphaFunc(GLbyte * pc)
>+{
>+    CALL_AlphaFunc( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLclampf *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_BlendFunc(GLbyte * pc)
>+{
>+    CALL_BlendFunc( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_LogicOp(GLbyte * pc)
>+{
>+    CALL_LogicOp( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_StencilFunc(GLbyte * pc)
>+{
>+    CALL_StencilFunc( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLuint   *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_StencilOp(GLbyte * pc)
>+{
>+    CALL_StencilOp( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLenum   *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_DepthFunc(GLbyte * pc)
>+{
>+    CALL_DepthFunc( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_PixelZoom(GLbyte * pc)
>+{
>+    CALL_PixelZoom( GET_DISPATCH(), (
>+        *(GLfloat  *)(pc +  0),
>+        *(GLfloat  *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_PixelTransferf(GLbyte * pc)
>+{
>+    CALL_PixelTransferf( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLfloat  *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_PixelTransferi(GLbyte * pc)
>+{
>+    CALL_PixelTransferi( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4)
>+    ) );
>+}
>+
>+int __glXDisp_PixelStoref(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        CALL_PixelStoref( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLfloat  *)(pc +  4)
>+        ) );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_PixelStorei(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        CALL_PixelStorei( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLint    *)(pc +  4)
>+        ) );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_PixelMapfv(GLbyte * pc)
>+{
>+    const GLsizei mapsize = *(GLsizei  *)(pc +  4);
>+
>+    CALL_PixelMapfv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        mapsize,
>+         (const GLfloat *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_PixelMapuiv(GLbyte * pc)
>+{
>+    const GLsizei mapsize = *(GLsizei  *)(pc +  4);
>+
>+    CALL_PixelMapuiv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        mapsize,
>+         (const GLuint *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_PixelMapusv(GLbyte * pc)
>+{
>+    const GLsizei mapsize = *(GLsizei  *)(pc +  4);
>+
>+    CALL_PixelMapusv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        mapsize,
>+         (const GLushort *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_ReadBuffer(GLbyte * pc)
>+{
>+    CALL_ReadBuffer( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_CopyPixels(GLbyte * pc)
>+{
>+    CALL_CopyPixels( GET_DISPATCH(), (
>+        *(GLint    *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLsizei  *)(pc +  8),
>+        *(GLsizei  *)(pc + 12),
>+        *(GLenum   *)(pc + 16)
>+    ) );
>+}
>+
>+void __glXDisp_DrawPixels(GLbyte * pc)
>+{
>+    const GLvoid * const pixels = (const GLvoid *) (pc + 36);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
>+
>+    CALL_DrawPixels( GET_DISPATCH(), (
>+        *(GLsizei  *)(pc + 20),
>+        *(GLsizei  *)(pc + 24),
>+        *(GLenum   *)(pc + 28),
>+        *(GLenum   *)(pc + 32),
>+        pixels
>+    ) );
>+}
>+
>+int __glXDisp_GetBooleanv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  0);
>+
>+        const GLuint compsize = __glGetBooleanv_size(pname);
>+        GLboolean answerBuffer[200];
>+        GLboolean * params = __glXGetAnswerBuffer(cl, compsize, answerBuffer, sizeof(answerBuffer), 1);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetBooleanv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 1, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetClipPlane(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLdouble equation[4];
>+        CALL_GetClipPlane( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            equation
>+        ) );
>+        __glXSendReply(cl->client, equation, 4, 8, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetDoublev(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  0);
>+
>+        const GLuint compsize = __glGetDoublev_size(pname);
>+        GLdouble answerBuffer[200];
>+        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetDoublev( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetError(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLenum retval;
>+        retval = CALL_GetError( GET_DISPATCH(), () );
>+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetFloatv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  0);
>+
>+        const GLuint compsize = __glGetFloatv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetFloatv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetIntegerv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  0);
>+
>+        const GLuint compsize = __glGetIntegerv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetIntegerv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetLightfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetLightfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetLightfv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetLightiv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetLightiv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetLightiv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetMapdv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum target = *(GLenum   *)(pc +  0);
>+        const GLenum query = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetMapdv_size(target,query);
>+        GLdouble answerBuffer[200];
>+        GLdouble * v = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (v == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetMapdv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            v
>+        ) );
>+        __glXSendReply(cl->client, v, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetMapfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum target = *(GLenum   *)(pc +  0);
>+        const GLenum query = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetMapfv_size(target,query);
>+        GLfloat answerBuffer[200];
>+        GLfloat * v = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (v == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetMapfv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            v
>+        ) );
>+        __glXSendReply(cl->client, v, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetMapiv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum target = *(GLenum   *)(pc +  0);
>+        const GLenum query = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetMapiv_size(target,query);
>+        GLint answerBuffer[200];
>+        GLint * v = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (v == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetMapiv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            v
>+        ) );
>+        __glXSendReply(cl->client, v, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetMaterialfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetMaterialfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetMaterialfv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetMaterialiv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetMaterialiv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetMaterialiv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetPixelMapfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum map = *(GLenum   *)(pc +  0);
>+
>+        const GLuint compsize = __glGetPixelMapfv_size(map);
>+        GLfloat answerBuffer[200];
>+        GLfloat * values = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (values == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetPixelMapfv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            values
>+        ) );
>+        __glXSendReply(cl->client, values, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetPixelMapuiv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum map = *(GLenum   *)(pc +  0);
>+
>+        const GLuint compsize = __glGetPixelMapuiv_size(map);
>+        GLuint answerBuffer[200];
>+        GLuint * values = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (values == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetPixelMapuiv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            values
>+        ) );
>+        __glXSendReply(cl->client, values, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetPixelMapusv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum map = *(GLenum   *)(pc +  0);
>+
>+        const GLuint compsize = __glGetPixelMapusv_size(map);
>+        GLushort answerBuffer[200];
>+        GLushort * values = __glXGetAnswerBuffer(cl, compsize * 2, answerBuffer, sizeof(answerBuffer), 2);
>+
>+        if (values == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetPixelMapusv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            values
>+        ) );
>+        __glXSendReply(cl->client, values, compsize, 2, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTexEnvfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetTexEnvfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetTexEnvfv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTexEnviv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetTexEnviv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetTexEnviv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTexGendv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetTexGendv_size(pname);
>+        GLdouble answerBuffer[200];
>+        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetTexGendv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTexGenfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetTexGenfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetTexGenfv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTexGeniv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetTexGeniv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetTexGeniv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTexParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetTexParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetTexParameterfv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTexParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetTexParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetTexParameteriv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTexLevelParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  8);
>+
>+        const GLuint compsize = __glGetTexLevelParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetTexLevelParameterfv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLint    *)(pc +  4),
>+            *(GLenum   *)(pc +  8),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTexLevelParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  8);
>+
>+        const GLuint compsize = __glGetTexLevelParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetTexLevelParameteriv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLint    *)(pc +  4),
>+            *(GLenum   *)(pc +  8),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_IsEnabled(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = CALL_IsEnabled( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0)
>+        ) );
>+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_IsList(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = CALL_IsList( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0)
>+        ) );
>+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_DepthRange(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_DepthRange( GET_DISPATCH(), (
>+        *(GLclampd *)(pc +  0),
>+        *(GLclampd *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_Frustum(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 48);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Frustum( GET_DISPATCH(), (
>+        *(GLdouble *)(pc +  0),
>+        *(GLdouble *)(pc +  8),
>+        *(GLdouble *)(pc + 16),
>+        *(GLdouble *)(pc + 24),
>+        *(GLdouble *)(pc + 32),
>+        *(GLdouble *)(pc + 40)
>+    ) );
>+}
>+
>+void __glXDisp_LoadIdentity(GLbyte * pc)
>+{
>+    CALL_LoadIdentity( GET_DISPATCH(), () );
>+}
>+
>+void __glXDisp_LoadMatrixf(GLbyte * pc)
>+{
>+    CALL_LoadMatrixf( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_LoadMatrixd(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 128);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_LoadMatrixd( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_MatrixMode(GLbyte * pc)
>+{
>+    CALL_MatrixMode( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_MultMatrixf(GLbyte * pc)
>+{
>+    CALL_MultMatrixf( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_MultMatrixd(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 128);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_MultMatrixd( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_Ortho(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 48);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Ortho( GET_DISPATCH(), (
>+        *(GLdouble *)(pc +  0),
>+        *(GLdouble *)(pc +  8),
>+        *(GLdouble *)(pc + 16),
>+        *(GLdouble *)(pc + 24),
>+        *(GLdouble *)(pc + 32),
>+        *(GLdouble *)(pc + 40)
>+    ) );
>+}
>+
>+void __glXDisp_PopMatrix(GLbyte * pc)
>+{
>+    CALL_PopMatrix( GET_DISPATCH(), () );
>+}
>+
>+void __glXDisp_PushMatrix(GLbyte * pc)
>+{
>+    CALL_PushMatrix( GET_DISPATCH(), () );
>+}
>+
>+void __glXDisp_Rotated(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Rotated( GET_DISPATCH(), (
>+        *(GLdouble *)(pc +  0),
>+        *(GLdouble *)(pc +  8),
>+        *(GLdouble *)(pc + 16),
>+        *(GLdouble *)(pc + 24)
>+    ) );
>+}
>+
>+void __glXDisp_Rotatef(GLbyte * pc)
>+{
>+    CALL_Rotatef( GET_DISPATCH(), (
>+        *(GLfloat  *)(pc +  0),
>+        *(GLfloat  *)(pc +  4),
>+        *(GLfloat  *)(pc +  8),
>+        *(GLfloat  *)(pc + 12)
>+    ) );
>+}
>+
>+void __glXDisp_Scaled(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Scaled( GET_DISPATCH(), (
>+        *(GLdouble *)(pc +  0),
>+        *(GLdouble *)(pc +  8),
>+        *(GLdouble *)(pc + 16)
>+    ) );
>+}
>+
>+void __glXDisp_Scalef(GLbyte * pc)
>+{
>+    CALL_Scalef( GET_DISPATCH(), (
>+        *(GLfloat  *)(pc +  0),
>+        *(GLfloat  *)(pc +  4),
>+        *(GLfloat  *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_Translated(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Translated( GET_DISPATCH(), (
>+        *(GLdouble *)(pc +  0),
>+        *(GLdouble *)(pc +  8),
>+        *(GLdouble *)(pc + 16)
>+    ) );
>+}
>+
>+void __glXDisp_Translatef(GLbyte * pc)
>+{
>+    CALL_Translatef( GET_DISPATCH(), (
>+        *(GLfloat  *)(pc +  0),
>+        *(GLfloat  *)(pc +  4),
>+        *(GLfloat  *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_Viewport(GLbyte * pc)
>+{
>+    CALL_Viewport( GET_DISPATCH(), (
>+        *(GLint    *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLsizei  *)(pc +  8),
>+        *(GLsizei  *)(pc + 12)
>+    ) );
>+}
>+
>+void __glXDisp_BindTexture(GLbyte * pc)
>+{
>+    CALL_BindTexture( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_Indexubv(GLbyte * pc)
>+{
>+    CALL_Indexubv( GET_DISPATCH(), (
>+         (const GLubyte *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_PolygonOffset(GLbyte * pc)
>+{
>+    CALL_PolygonOffset( GET_DISPATCH(), (
>+        *(GLfloat  *)(pc +  0),
>+        *(GLfloat  *)(pc +  4)
>+    ) );
>+}
>+
>+int __glXDisp_AreTexturesResident(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        GLboolean retval;
>+        GLboolean answerBuffer[200];
>+        GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
>+        retval = CALL_AreTexturesResident( GET_DISPATCH(), (
>+            n,
>+             (const GLuint *)(pc +  4),
>+            residences
>+        ) );
>+        __glXSendReply(cl->client, residences, n, 1, GL_TRUE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_CopyTexImage1D(GLbyte * pc)
>+{
>+    CALL_CopyTexImage1D( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLint    *)(pc + 16),
>+        *(GLsizei  *)(pc + 20),
>+        *(GLint    *)(pc + 24)
>+    ) );
>+}
>+
>+void __glXDisp_CopyTexImage2D(GLbyte * pc)
>+{
>+    CALL_CopyTexImage2D( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLint    *)(pc + 16),
>+        *(GLsizei  *)(pc + 20),
>+        *(GLsizei  *)(pc + 24),
>+        *(GLint    *)(pc + 28)
>+    ) );
>+}
>+
>+void __glXDisp_CopyTexSubImage1D(GLbyte * pc)
>+{
>+    CALL_CopyTexSubImage1D( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLint    *)(pc + 16),
>+        *(GLsizei  *)(pc + 20)
>+    ) );
>+}
>+
>+void __glXDisp_CopyTexSubImage2D(GLbyte * pc)
>+{
>+    CALL_CopyTexSubImage2D( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLint    *)(pc + 16),
>+        *(GLint    *)(pc + 20),
>+        *(GLsizei  *)(pc + 24),
>+        *(GLsizei  *)(pc + 28)
>+    ) );
>+}
>+
>+int __glXDisp_DeleteTextures(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        CALL_DeleteTextures( GET_DISPATCH(), (
>+            n,
>+             (const GLuint *)(pc +  4)
>+        ) );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GenTextures(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        GLuint answerBuffer[200];
>+        GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        CALL_GenTextures( GET_DISPATCH(), (
>+            n,
>+            textures
>+        ) );
>+        __glXSendReply(cl->client, textures, n, 4, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_IsTexture(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = CALL_IsTexture( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0)
>+        ) );
>+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_PrioritizeTextures(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+    CALL_PrioritizeTextures( GET_DISPATCH(), (
>+        n,
>+         (const GLuint *)(pc +  4),
>+         (const GLclampf *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_TexSubImage1D(GLbyte * pc)
>+{
>+    const CARD32 ptr_is_null = *(CARD32 *)(pc + 52);
>+    const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 56);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
>+
>+    CALL_TexSubImage1D( GET_DISPATCH(), (
>+        *(GLenum   *)(pc + 20),
>+        *(GLint    *)(pc + 24),
>+        *(GLint    *)(pc + 28),
>+        *(GLsizei  *)(pc + 36),
>+        *(GLenum   *)(pc + 44),
>+        *(GLenum   *)(pc + 48),
>+        pixels
>+    ) );
>+}
>+
>+void __glXDisp_TexSubImage2D(GLbyte * pc)
>+{
>+    const CARD32 ptr_is_null = *(CARD32 *)(pc + 52);
>+    const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 56);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
>+
>+    CALL_TexSubImage2D( GET_DISPATCH(), (
>+        *(GLenum   *)(pc + 20),
>+        *(GLint    *)(pc + 24),
>+        *(GLint    *)(pc + 28),
>+        *(GLint    *)(pc + 32),
>+        *(GLsizei  *)(pc + 36),
>+        *(GLsizei  *)(pc + 40),
>+        *(GLenum   *)(pc + 44),
>+        *(GLenum   *)(pc + 48),
>+        pixels
>+    ) );
>+}
>+
>+void __glXDisp_BlendColor(GLbyte * pc)
>+{
>+    CALL_BlendColor( GET_DISPATCH(), (
>+        *(GLclampf *)(pc +  0),
>+        *(GLclampf *)(pc +  4),
>+        *(GLclampf *)(pc +  8),
>+        *(GLclampf *)(pc + 12)
>+    ) );
>+}
>+
>+void __glXDisp_BlendEquation(GLbyte * pc)
>+{
>+    CALL_BlendEquation( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_ColorTable(GLbyte * pc)
>+{
>+    const GLvoid * const table = (const GLvoid *) (pc + 40);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
>+
>+    CALL_ColorTable( GET_DISPATCH(), (
>+        *(GLenum   *)(pc + 20),
>+        *(GLenum   *)(pc + 24),
>+        *(GLsizei  *)(pc + 28),
>+        *(GLenum   *)(pc + 32),
>+        *(GLenum   *)(pc + 36),
>+        table
>+    ) );
>+}
>+
>+void __glXDisp_ColorTableParameterfv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 8);
>+
>+    CALL_ColorTableParameterfv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_ColorTableParameteriv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 8);
>+
>+    CALL_ColorTableParameteriv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_CopyColorTable(GLbyte * pc)
>+{
>+    CALL_CopyColorTable( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLsizei  *)(pc + 16)
>+    ) );
>+}
>+
>+int __glXDisp_GetColorTableParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetColorTableParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetColorTableParameterfv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetColorTableParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetColorTableParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetColorTableParameteriv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_ColorSubTable(GLbyte * pc)
>+{
>+    const GLvoid * const data = (const GLvoid *) (pc + 40);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
>+
>+    CALL_ColorSubTable( GET_DISPATCH(), (
>+        *(GLenum   *)(pc + 20),
>+        *(GLsizei  *)(pc + 24),
>+        *(GLsizei  *)(pc + 28),
>+        *(GLenum   *)(pc + 32),
>+        *(GLenum   *)(pc + 36),
>+        data
>+    ) );
>+}
>+
>+void __glXDisp_CopyColorSubTable(GLbyte * pc)
>+{
>+    CALL_CopyColorSubTable( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLsizei  *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLsizei  *)(pc + 16)
>+    ) );
>+}
>+
>+void __glXDisp_ConvolutionFilter1D(GLbyte * pc)
>+{
>+    const GLvoid * const image = (const GLvoid *) (pc + 44);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
>+
>+    CALL_ConvolutionFilter1D( GET_DISPATCH(), (
>+        *(GLenum   *)(pc + 20),
>+        *(GLenum   *)(pc + 24),
>+        *(GLsizei  *)(pc + 28),
>+        *(GLenum   *)(pc + 36),
>+        *(GLenum   *)(pc + 40),
>+        image
>+    ) );
>+}
>+
>+void __glXDisp_ConvolutionFilter2D(GLbyte * pc)
>+{
>+    const GLvoid * const image = (const GLvoid *) (pc + 44);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
>+
>+    CALL_ConvolutionFilter2D( GET_DISPATCH(), (
>+        *(GLenum   *)(pc + 20),
>+        *(GLenum   *)(pc + 24),
>+        *(GLsizei  *)(pc + 28),
>+        *(GLsizei  *)(pc + 32),
>+        *(GLenum   *)(pc + 36),
>+        *(GLenum   *)(pc + 40),
>+        image
>+    ) );
>+}
>+
>+void __glXDisp_ConvolutionParameterf(GLbyte * pc)
>+{
>+    CALL_ConvolutionParameterf( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLfloat  *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_ConvolutionParameterfv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 8);
>+
>+    CALL_ConvolutionParameterfv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_ConvolutionParameteri(GLbyte * pc)
>+{
>+    CALL_ConvolutionParameteri( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLint    *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_ConvolutionParameteriv(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  4);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 8);
>+
>+    CALL_ConvolutionParameteriv( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_CopyConvolutionFilter1D(GLbyte * pc)
>+{
>+    CALL_CopyConvolutionFilter1D( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLsizei  *)(pc + 16)
>+    ) );
>+}
>+
>+void __glXDisp_CopyConvolutionFilter2D(GLbyte * pc)
>+{
>+    CALL_CopyConvolutionFilter2D( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLsizei  *)(pc + 16),
>+        *(GLsizei  *)(pc + 20)
>+    ) );
>+}
>+
>+int __glXDisp_GetConvolutionParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetConvolutionParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetConvolutionParameterfv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetConvolutionParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetConvolutionParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetConvolutionParameteriv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetHistogramParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetHistogramParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetHistogramParameterfv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetHistogramParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetHistogramParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetHistogramParameteriv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetMinmaxParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetMinmaxParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetMinmaxParameterfv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetMinmaxParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetMinmaxParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetMinmaxParameteriv( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_Histogram(GLbyte * pc)
>+{
>+    CALL_Histogram( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLsizei  *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLboolean *)(pc + 12)
>+    ) );
>+}
>+
>+void __glXDisp_Minmax(GLbyte * pc)
>+{
>+    CALL_Minmax( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLboolean *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_ResetHistogram(GLbyte * pc)
>+{
>+    CALL_ResetHistogram( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_ResetMinmax(GLbyte * pc)
>+{
>+    CALL_ResetMinmax( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_TexImage3D(GLbyte * pc)
>+{
>+    const CARD32 ptr_is_null = *(CARD32 *)(pc + 76);
>+    const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 80);
>+    __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_IMAGES,  (GLint) hdr->skipImages) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
>+
>+    CALL_TexImage3D( GET_DISPATCH(), (
>+        *(GLenum   *)(pc + 36),
>+        *(GLint    *)(pc + 40),
>+        *(GLint    *)(pc + 44),
>+        *(GLsizei  *)(pc + 48),
>+        *(GLsizei  *)(pc + 52),
>+        *(GLsizei  *)(pc + 56),
>+        *(GLint    *)(pc + 64),
>+        *(GLenum   *)(pc + 68),
>+        *(GLenum   *)(pc + 72),
>+        pixels
>+    ) );
>+}
>+
>+void __glXDisp_TexSubImage3D(GLbyte * pc)
>+{
>+    const CARD32 ptr_is_null = *(CARD32 *)(pc + 84);
>+    const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 88);
>+    __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_IMAGES,  (GLint) hdr->skipImages) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
>+
>+    CALL_TexSubImage3D( GET_DISPATCH(), (
>+        *(GLenum   *)(pc + 36),
>+        *(GLint    *)(pc + 40),
>+        *(GLint    *)(pc + 44),
>+        *(GLint    *)(pc + 48),
>+        *(GLint    *)(pc + 52),
>+        *(GLsizei  *)(pc + 60),
>+        *(GLsizei  *)(pc + 64),
>+        *(GLsizei  *)(pc + 68),
>+        *(GLenum   *)(pc + 76),
>+        *(GLenum   *)(pc + 80),
>+        pixels
>+    ) );
>+}
>+
>+void __glXDisp_CopyTexSubImage3D(GLbyte * pc)
>+{
>+    CALL_CopyTexSubImage3D( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLint    *)(pc + 16),
>+        *(GLint    *)(pc + 20),
>+        *(GLint    *)(pc + 24),
>+        *(GLsizei  *)(pc + 28),
>+        *(GLsizei  *)(pc + 32)
>+    ) );
>+}
>+
>+void __glXDisp_ActiveTextureARB(GLbyte * pc)
>+{
>+    CALL_ActiveTextureARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_MultiTexCoord1dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 12);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_MultiTexCoord1dvARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  8),
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_MultiTexCoord1fvARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord1fvARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_MultiTexCoord1ivARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord1ivARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+         (const GLint *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_MultiTexCoord1svARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord1svARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_MultiTexCoord2dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 20);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_MultiTexCoord2dvARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc + 16),
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_MultiTexCoord2fvARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord2fvARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_MultiTexCoord2ivARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord2ivARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+         (const GLint *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_MultiTexCoord2svARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord2svARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_MultiTexCoord3dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 28);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_MultiTexCoord3dvARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc + 24),
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_MultiTexCoord3fvARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord3fvARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_MultiTexCoord3ivARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord3ivARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+         (const GLint *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_MultiTexCoord3svARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord3svARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_MultiTexCoord4dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 36);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_MultiTexCoord4dvARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc + 32),
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_MultiTexCoord4fvARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord4fvARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_MultiTexCoord4ivARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord4ivARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+         (const GLint *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_MultiTexCoord4svARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord4svARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_SampleCoverageARB(GLbyte * pc)
>+{
>+    CALL_SampleCoverageARB( GET_DISPATCH(), (
>+        *(GLclampf *)(pc +  0),
>+        *(GLboolean *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_DrawBuffersARB(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+    CALL_DrawBuffersARB( GET_DISPATCH(), (
>+        n,
>+         (const GLenum *)(pc +  4)
>+    ) );
>+}
>+
>+int __glXDisp_AreTexturesResidentEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        GLboolean retval;
>+        GLboolean answerBuffer[200];
>+        GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
>+        retval = CALL_AreTexturesResidentEXT( GET_DISPATCH(), (
>+            n,
>+             (const GLuint *)(pc +  4),
>+            residences
>+        ) );
>+        __glXSendReply(cl->client, residences, n, 1, GL_TRUE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GenTexturesEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        GLuint answerBuffer[200];
>+        GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        CALL_GenTexturesEXT( GET_DISPATCH(), (
>+            n,
>+            textures
>+        ) );
>+        __glXSendReply(cl->client, textures, n, 4, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_IsTextureEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = CALL_IsTextureEXT( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0)
>+        ) );
>+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_SampleMaskSGIS(GLbyte * pc)
>+{
>+    CALL_SampleMaskSGIS( GET_DISPATCH(), (
>+        *(GLclampf *)(pc +  0),
>+        *(GLboolean *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_SamplePatternSGIS(GLbyte * pc)
>+{
>+    CALL_SamplePatternSGIS( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_PointParameterfEXT(GLbyte * pc)
>+{
>+    CALL_PointParameterfEXT( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLfloat  *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_PointParameterfvEXT(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  0);
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) (pc + 4);
>+
>+    CALL_PointParameterfvEXT( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_WindowPos3fvMESA(GLbyte * pc)
>+{
>+    CALL_WindowPos3fvMESA( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_BlendFuncSeparateEXT(GLbyte * pc)
>+{
>+    CALL_BlendFuncSeparateEXT( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLenum   *)(pc + 12)
>+    ) );
>+}
>+
>+void __glXDisp_FogCoordfvEXT(GLbyte * pc)
>+{
>+    CALL_FogCoordfvEXT( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_FogCoorddvEXT(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_FogCoorddvEXT( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_CompressedTexImage3DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize = *(GLsizei  *)(pc + 28);
>+
>+    CALL_CompressedTexImage3DARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLsizei  *)(pc + 12),
>+        *(GLsizei  *)(pc + 16),
>+        *(GLsizei  *)(pc + 20),
>+        *(GLint    *)(pc + 24),
>+        imageSize,
>+         (const GLvoid *)(pc + 32)
>+    ) );
>+}
>+
>+void __glXDisp_CompressedTexImage2DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize = *(GLsizei  *)(pc + 24);
>+
>+    CALL_CompressedTexImage2DARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLsizei  *)(pc + 12),
>+        *(GLsizei  *)(pc + 16),
>+        *(GLint    *)(pc + 20),
>+        imageSize,
>+         (const GLvoid *)(pc + 28)
>+    ) );
>+}
>+
>+void __glXDisp_CompressedTexImage1DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize = *(GLsizei  *)(pc + 20);
>+
>+    CALL_CompressedTexImage1DARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLsizei  *)(pc + 12),
>+        *(GLint    *)(pc + 16),
>+        imageSize,
>+         (const GLvoid *)(pc + 24)
>+    ) );
>+}
>+
>+void __glXDisp_CompressedTexSubImage3DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize = *(GLsizei  *)(pc + 36);
>+
>+    CALL_CompressedTexSubImage3DARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLint    *)(pc + 16),
>+        *(GLsizei  *)(pc + 20),
>+        *(GLsizei  *)(pc + 24),
>+        *(GLsizei  *)(pc + 28),
>+        *(GLenum   *)(pc + 32),
>+        imageSize,
>+         (const GLvoid *)(pc + 40)
>+    ) );
>+}
>+
>+void __glXDisp_CompressedTexSubImage2DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize = *(GLsizei  *)(pc + 28);
>+
>+    CALL_CompressedTexSubImage2DARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLint    *)(pc + 12),
>+        *(GLsizei  *)(pc + 16),
>+        *(GLsizei  *)(pc + 20),
>+        *(GLenum   *)(pc + 24),
>+        imageSize,
>+         (const GLvoid *)(pc + 32)
>+    ) );
>+}
>+
>+void __glXDisp_CompressedTexSubImage1DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize = *(GLsizei  *)(pc + 20);
>+
>+    CALL_CompressedTexSubImage1DARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4),
>+        *(GLint    *)(pc +  8),
>+        *(GLsizei  *)(pc + 12),
>+        *(GLenum   *)(pc + 16),
>+        imageSize,
>+         (const GLvoid *)(pc + 24)
>+    ) );
>+}
>+
>+void __glXDisp_SecondaryColor3bvEXT(GLbyte * pc)
>+{
>+    CALL_SecondaryColor3bvEXT( GET_DISPATCH(), (
>+         (const GLbyte *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_SecondaryColor3dvEXT(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_SecondaryColor3dvEXT( GET_DISPATCH(), (
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_SecondaryColor3fvEXT(GLbyte * pc)
>+{
>+    CALL_SecondaryColor3fvEXT( GET_DISPATCH(), (
>+         (const GLfloat *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_SecondaryColor3ivEXT(GLbyte * pc)
>+{
>+    CALL_SecondaryColor3ivEXT( GET_DISPATCH(), (
>+         (const GLint *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_SecondaryColor3svEXT(GLbyte * pc)
>+{
>+    CALL_SecondaryColor3svEXT( GET_DISPATCH(), (
>+         (const GLshort *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_SecondaryColor3ubvEXT(GLbyte * pc)
>+{
>+    CALL_SecondaryColor3ubvEXT( GET_DISPATCH(), (
>+         (const GLubyte *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_SecondaryColor3uivEXT(GLbyte * pc)
>+{
>+    CALL_SecondaryColor3uivEXT( GET_DISPATCH(), (
>+         (const GLuint *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_SecondaryColor3usvEXT(GLbyte * pc)
>+{
>+    CALL_SecondaryColor3usvEXT( GET_DISPATCH(), (
>+         (const GLushort *)(pc +  0)
>+    ) );
>+}
>+
>+int __glXDisp_AreProgramsResidentNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        GLboolean retval;
>+        GLboolean answerBuffer[200];
>+        GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
>+        retval = CALL_AreProgramsResidentNV( GET_DISPATCH(), (
>+            n,
>+             (const GLuint *)(pc +  4),
>+            residences
>+        ) );
>+        __glXSendReply(cl->client, residences, n, 1, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_BindProgramNV(GLbyte * pc)
>+{
>+    CALL_BindProgramNV( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4)
>+    ) );
>+}
>+
>+int __glXDisp_DeleteProgramsNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        CALL_DeleteProgramsNV( GET_DISPATCH(), (
>+            n,
>+             (const GLuint *)(pc +  4)
>+        ) );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_ExecuteProgramNV(GLbyte * pc)
>+{
>+    CALL_ExecuteProgramNV( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4),
>+         (const GLfloat *)(pc +  8)
>+    ) );
>+}
>+
>+int __glXDisp_GenProgramsNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        GLuint answerBuffer[200];
>+        GLuint * programs = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        CALL_GenProgramsNV( GET_DISPATCH(), (
>+            n,
>+            programs
>+        ) );
>+        __glXSendReply(cl->client, programs, n, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetProgramParameterdvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLdouble params[4];
>+        CALL_GetProgramParameterdvNV( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLuint   *)(pc +  4),
>+            *(GLenum   *)(pc +  8),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetProgramParameterfvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLfloat params[4];
>+        CALL_GetProgramParameterfvNV( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLuint   *)(pc +  4),
>+            *(GLenum   *)(pc +  8),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetProgramivNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetProgramivNV_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetProgramivNV( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetTrackMatrixivNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLint params[1];
>+        CALL_GetTrackMatrixivNV( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLuint   *)(pc +  4),
>+            *(GLenum   *)(pc +  8),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetVertexAttribdvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetVertexAttribdvARB_size(pname);
>+        GLdouble answerBuffer[200];
>+        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetVertexAttribdvARB( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetVertexAttribfvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetVertexAttribfvARB_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetVertexAttribfvARB( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetVertexAttribivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetVertexAttribivARB_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetVertexAttribivARB( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_IsProgramNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = CALL_IsProgramNV( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0)
>+        ) );
>+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_LoadProgramNV(GLbyte * pc)
>+{
>+    const GLsizei len = *(GLsizei  *)(pc +  8);
>+
>+    CALL_LoadProgramNV( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4),
>+        len,
>+         (const GLubyte *)(pc + 12)
>+    ) );
>+}
>+
>+void __glXDisp_ProgramParameter4dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 40);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_ProgramParameter4dvNV( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4),
>+         (const GLdouble *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_ProgramParameter4fvNV(GLbyte * pc)
>+{
>+    CALL_ProgramParameter4fvNV( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4),
>+         (const GLfloat *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_ProgramParameters4dvNV(GLbyte * pc)
>+{
>+    const GLuint num = *(GLuint   *)(pc +  8);
>+
>+#ifdef __GLX_ALIGN64
>+    const GLuint cmdlen = 16 + __GLX_PAD((num * 32)) - 4;
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, cmdlen);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_ProgramParameters4dvNV( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4),
>+        num,
>+         (const GLdouble *)(pc + 12)
>+    ) );
>+}
>+
>+void __glXDisp_ProgramParameters4fvNV(GLbyte * pc)
>+{
>+    const GLuint num = *(GLuint   *)(pc +  8);
>+
>+    CALL_ProgramParameters4fvNV( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4),
>+        num,
>+         (const GLfloat *)(pc + 12)
>+    ) );
>+}
>+
>+void __glXDisp_RequestResidentProgramsNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+    CALL_RequestResidentProgramsNV( GET_DISPATCH(), (
>+        n,
>+         (const GLuint *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_TrackMatrixNV(GLbyte * pc)
>+{
>+    CALL_TrackMatrixNV( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLenum   *)(pc + 12)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib1dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 12);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttrib1dvARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  8),
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib1fvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib1fvARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib1svARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib1svARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib2dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 20);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttrib2dvARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc + 16),
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib2fvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib2fvARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib2svARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib2svARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib3dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 28);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttrib3dvARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc + 24),
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib3fvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib3fvARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib3svARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib3svARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib4dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 36);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttrib4dvARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc + 32),
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib4fvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4fvARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib4svARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4svARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib4NubvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4NubvARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLubyte *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttribs1dvNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+#ifdef __GLX_ALIGN64
>+    const GLuint cmdlen = 12 + __GLX_PAD((n * 8)) - 4;
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, cmdlen);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttribs1dvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLdouble *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttribs1fvNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+    CALL_VertexAttribs1fvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLfloat *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttribs1svNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+    CALL_VertexAttribs1svNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLshort *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttribs2dvNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+#ifdef __GLX_ALIGN64
>+    const GLuint cmdlen = 12 + __GLX_PAD((n * 16)) - 4;
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, cmdlen);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttribs2dvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLdouble *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttribs2fvNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+    CALL_VertexAttribs2fvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLfloat *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttribs2svNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+    CALL_VertexAttribs2svNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLshort *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttribs3dvNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+#ifdef __GLX_ALIGN64
>+    const GLuint cmdlen = 12 + __GLX_PAD((n * 24)) - 4;
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, cmdlen);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttribs3dvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLdouble *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttribs3fvNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+    CALL_VertexAttribs3fvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLfloat *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttribs3svNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+    CALL_VertexAttribs3svNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLshort *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttribs4dvNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+#ifdef __GLX_ALIGN64
>+    const GLuint cmdlen = 12 + __GLX_PAD((n * 32)) - 4;
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, cmdlen);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttribs4dvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLdouble *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttribs4fvNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+    CALL_VertexAttribs4fvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLfloat *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttribs4svNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+    CALL_VertexAttribs4svNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLshort *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttribs4ubvNV(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  4);
>+
>+    CALL_VertexAttribs4ubvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+        n,
>+         (const GLubyte *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_PointParameteriNV(GLbyte * pc)
>+{
>+    CALL_PointParameteriNV( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLint    *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_PointParameterivNV(GLbyte * pc)
>+{
>+    const GLenum pname = *(GLenum   *)(pc +  0);
>+    const GLint * params;
>+
>+    params = (const GLint *) (pc + 4);
>+
>+    CALL_PointParameterivNV( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        params
>+    ) );
>+}
>+
>+void __glXDisp_ActiveStencilFaceEXT(GLbyte * pc)
>+{
>+    CALL_ActiveStencilFaceEXT( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib4bvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4bvARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLbyte *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib4ivARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4ivARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLint *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib4ubvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4ubvARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLubyte *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib4usvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4usvARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLushort *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib4uivARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4uivARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLuint *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib4NbvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4NbvARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLbyte *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib4NsvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4NsvARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib4NivARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4NivARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLint *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib4NusvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4NusvARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLushort *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib4NuivARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4NuivARB( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLuint *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_ProgramStringARB(GLbyte * pc)
>+{
>+    const GLsizei len = *(GLsizei  *)(pc +  8);
>+
>+    CALL_ProgramStringARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        len,
>+         (const GLvoid *)(pc + 12)
>+    ) );
>+}
>+
>+void __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 40);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_ProgramEnvParameter4dvARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4),
>+         (const GLdouble *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_ProgramEnvParameter4fvARB(GLbyte * pc)
>+{
>+    CALL_ProgramEnvParameter4fvARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4),
>+         (const GLfloat *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_ProgramLocalParameter4dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 40);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_ProgramLocalParameter4dvARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4),
>+         (const GLdouble *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_ProgramLocalParameter4fvARB(GLbyte * pc)
>+{
>+    CALL_ProgramLocalParameter4fvARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4),
>+         (const GLfloat *)(pc +  8)
>+    ) );
>+}
>+
>+int __glXDisp_GetProgramEnvParameterdvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLdouble params[4];
>+        CALL_GetProgramEnvParameterdvARB( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLuint   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetProgramEnvParameterfvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLfloat params[4];
>+        CALL_GetProgramEnvParameterfvARB( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLuint   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetProgramLocalParameterdvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLdouble params[4];
>+        CALL_GetProgramLocalParameterdvARB( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLuint   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetProgramLocalParameterfvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLfloat params[4];
>+        CALL_GetProgramLocalParameterfvARB( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLuint   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetProgramivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetProgramivARB_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetProgramivARB( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_ProgramNamedParameter4fvNV(GLbyte * pc)
>+{
>+    const GLsizei len = *(GLsizei  *)(pc +  4);
>+
>+    CALL_ProgramNamedParameter4fvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+        len,
>+         (const GLubyte *)(pc + 24),
>+         (const GLfloat *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDisp_ProgramNamedParameter4dvNV(GLbyte * pc)
>+{
>+    const GLsizei len = *(GLsizei  *)(pc + 36);
>+
>+#ifdef __GLX_ALIGN64
>+    const GLuint cmdlen = 44 + __GLX_PAD(len) - 4;
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, cmdlen);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_ProgramNamedParameter4dvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc + 32),
>+        len,
>+         (const GLubyte *)(pc + 40),
>+         (const GLdouble *)(pc +  0)
>+    ) );
>+}
>+
>+int __glXDisp_GetProgramNamedParameterfvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei len = *(GLsizei  *)(pc +  4);
>+
>+        GLfloat params[4];
>+        CALL_GetProgramNamedParameterfvNV( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0),
>+            len,
>+             (const GLubyte *)(pc +  8),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, 4, 4, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetProgramNamedParameterdvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei len = *(GLsizei  *)(pc +  4);
>+
>+        GLdouble params[4];
>+        CALL_GetProgramNamedParameterdvNV( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0),
>+            len,
>+             (const GLubyte *)(pc +  8),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, 4, 8, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GenQueriesARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        GLuint answerBuffer[200];
>+        GLuint * ids = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        CALL_GenQueriesARB( GET_DISPATCH(), (
>+            n,
>+            ids
>+        ) );
>+        __glXSendReply(cl->client, ids, n, 4, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_DeleteQueriesARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        CALL_DeleteQueriesARB( GET_DISPATCH(), (
>+            n,
>+             (const GLuint *)(pc +  4)
>+        ) );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_IsQueryARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = CALL_IsQueryARB( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0)
>+        ) );
>+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_BeginQueryARB(GLbyte * pc)
>+{
>+    CALL_BeginQueryARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_EndQueryARB(GLbyte * pc)
>+{
>+    CALL_EndQueryARB( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0)
>+    ) );
>+}
>+
>+int __glXDisp_GetQueryivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetQueryivARB_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetQueryivARB( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetQueryObjectivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetQueryObjectivARB_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetQueryObjectivARB( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetQueryObjectuivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetQueryObjectuivARB_size(pname);
>+        GLuint answerBuffer[200];
>+        GLuint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetQueryObjectuivARB( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetVertexAttribdvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetVertexAttribdvNV_size(pname);
>+        GLdouble answerBuffer[200];
>+        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetVertexAttribdvNV( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetVertexAttribfvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetVertexAttribfvNV_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetVertexAttribfvNV( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_GetVertexAttribivNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname = *(GLenum   *)(pc +  4);
>+
>+        const GLuint compsize = __glGetVertexAttribivNV_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetVertexAttribivNV( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_VertexAttrib1dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 12);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttrib1dvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLdouble *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib1fvNV(GLbyte * pc)
>+{
>+    CALL_VertexAttrib1fvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib1svNV(GLbyte * pc)
>+{
>+    CALL_VertexAttrib1svNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib2dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 20);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttrib2dvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLdouble *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib2fvNV(GLbyte * pc)
>+{
>+    CALL_VertexAttrib2fvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib2svNV(GLbyte * pc)
>+{
>+    CALL_VertexAttrib2svNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib3dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 28);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttrib3dvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLdouble *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib3fvNV(GLbyte * pc)
>+{
>+    CALL_VertexAttrib3fvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib3svNV(GLbyte * pc)
>+{
>+    CALL_VertexAttrib3svNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib4dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 36);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttrib4dvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLdouble *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib4fvNV(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4fvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLfloat *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib4svNV(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4svNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLshort *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_VertexAttrib4ubvNV(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4ubvNV( GET_DISPATCH(), (
>+        *(GLuint   *)(pc +  0),
>+         (const GLubyte *)(pc +  4)
>+    ) );
>+}
>+
>+int __glXDisp_IsRenderbufferEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = CALL_IsRenderbufferEXT( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0)
>+        ) );
>+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_BindRenderbufferEXT(GLbyte * pc)
>+{
>+    CALL_BindRenderbufferEXT( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_DeleteRenderbuffersEXT(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+    CALL_DeleteRenderbuffersEXT( GET_DISPATCH(), (
>+        n,
>+         (const GLuint *)(pc +  4)
>+    ) );
>+}
>+
>+int __glXDisp_GenRenderbuffersEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        GLuint answerBuffer[200];
>+        GLuint * renderbuffers = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        CALL_GenRenderbuffersEXT( GET_DISPATCH(), (
>+            n,
>+            renderbuffers
>+        ) );
>+        __glXSendReply(cl->client, renderbuffers, n, 4, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_RenderbufferStorageEXT(GLbyte * pc)
>+{
>+    CALL_RenderbufferStorageEXT( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLsizei  *)(pc +  8),
>+        *(GLsizei  *)(pc + 12)
>+    ) );
>+}
>+
>+int __glXDisp_GetRenderbufferParameterivEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLint params[1];
>+        CALL_GetRenderbufferParameterivEXT( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_IsFramebufferEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = CALL_IsFramebufferEXT( GET_DISPATCH(), (
>+            *(GLuint   *)(pc +  0)
>+        ) );
>+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_BindFramebufferEXT(GLbyte * pc)
>+{
>+    CALL_BindFramebufferEXT( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLuint   *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDisp_DeleteFramebuffersEXT(GLbyte * pc)
>+{
>+    const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+    CALL_DeleteFramebuffersEXT( GET_DISPATCH(), (
>+        n,
>+         (const GLuint *)(pc +  4)
>+    ) );
>+}
>+
>+int __glXDisp_GenFramebuffersEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n = *(GLsizei  *)(pc +  0);
>+
>+        GLuint answerBuffer[200];
>+        GLuint * framebuffers = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        CALL_GenFramebuffersEXT( GET_DISPATCH(), (
>+            n,
>+            framebuffers
>+        ) );
>+        __glXSendReply(cl->client, framebuffers, n, 4, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDisp_CheckFramebufferStatusEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLenum retval;
>+        retval = CALL_CheckFramebufferStatusEXT( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0)
>+        ) );
>+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_FramebufferTexture1DEXT(GLbyte * pc)
>+{
>+    CALL_FramebufferTexture1DEXT( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLuint   *)(pc + 12),
>+        *(GLint    *)(pc + 16)
>+    ) );
>+}
>+
>+void __glXDisp_FramebufferTexture2DEXT(GLbyte * pc)
>+{
>+    CALL_FramebufferTexture2DEXT( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLuint   *)(pc + 12),
>+        *(GLint    *)(pc + 16)
>+    ) );
>+}
>+
>+void __glXDisp_FramebufferTexture3DEXT(GLbyte * pc)
>+{
>+    CALL_FramebufferTexture3DEXT( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLuint   *)(pc + 12),
>+        *(GLint    *)(pc + 16),
>+        *(GLint    *)(pc + 20)
>+    ) );
>+}
>+
>+void __glXDisp_FramebufferRenderbufferEXT(GLbyte * pc)
>+{
>+    CALL_FramebufferRenderbufferEXT( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0),
>+        *(GLenum   *)(pc +  4),
>+        *(GLenum   *)(pc +  8),
>+        *(GLuint   *)(pc + 12)
>+    ) );
>+}
>+
>+int __glXDisp_GetFramebufferAttachmentParameterivEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLint params[1];
>+        CALL_GetFramebufferAttachmentParameterivEXT( GET_DISPATCH(), (
>+            *(GLenum   *)(pc +  0),
>+            *(GLenum   *)(pc +  4),
>+            *(GLenum   *)(pc +  8),
>+            params
>+        ) );
>+        __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDisp_GenerateMipmapEXT(GLbyte * pc)
>+{
>+    CALL_GenerateMipmapEXT( GET_DISPATCH(), (
>+        *(GLenum   *)(pc +  0)
>+    ) );
>+}
>+
>Index: xorg/GL/glx/indirect_dispatch.h
>===================================================================
>RCS file: xorg/GL/glx/indirect_dispatch.h
>diff -N xorg/GL/glx/indirect_dispatch.h
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ xorg/GL/glx/indirect_dispatch.h	12 Jan 2006 00:04:16 -0000
>@@ -0,0 +1,931 @@
>+/* DO NOT EDIT - This file generated automatically by glX_proto_recv.py (from Mesa) script */
>+
>+/*
>+ * (C) Copyright IBM Corporation 2005
>+ * 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
>+ * IBM,
>+ * 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.
>+ */
>+
>+#if !defined( _INDIRECT_DISPATCH_H_ )
>+#  define _INDIRECT_DISPATCH_H_
>+
>+#  if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__)
>+#    define HIDDEN  __attribute__((visibility("hidden")))
>+#  else
>+#    define HIDDEN
>+#  endif
>+struct __GLXclientStateRec;
>+
>+extern HIDDEN void __glXDisp_MapGrid1d(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MapGrid1d(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MapGrid1f(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MapGrid1f(GLbyte * pc);
>+extern HIDDEN int __glXDisp_NewList(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_NewList(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_LoadIdentity(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LoadIdentity(GLbyte * pc);
>+extern HIDDEN void __glXDisp_SampleCoverageARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SampleCoverageARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ConvolutionFilter1D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ConvolutionFilter1D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_BeginQueryARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_BeginQueryARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos3dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos3dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PointParameteriNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PointParameteriNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord1iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord1iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord4sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord4sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ActiveTextureARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ActiveTextureARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4ubvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4ubvNV(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetProgramNamedParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramNamedParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_Histogram(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Histogram(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetMapfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetMapfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_PolygonStipple(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PolygonStipple(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetPixelMapfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetPixelMapfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_Color3uiv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color3uiv(GLbyte * pc);
>+extern HIDDEN int __glXDisp_IsEnabled(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_IsEnabled(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_VertexAttrib4svNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4svNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_EvalCoord2fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EvalCoord2fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetMapiv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetMapiv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_Indexubv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Indexubv(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetQueryivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetQueryivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_TexImage3D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexImage3D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color3ubv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color3ubv(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetQueryObjectivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetQueryObjectivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_Vertex3dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex3dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CompressedTexSubImage2DARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CompressedTexSubImage2DARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_LightModeliv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LightModeliv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib1svARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib1svARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs1dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs1dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Normal3bv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Normal3bv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexGeniv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexGeniv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex3iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex3iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CopyConvolutionFilter1D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyConvolutionFilter1D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_BlendColor(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_BlendColor(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CallLists(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CallLists(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Normal3iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Normal3iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PassThrough(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PassThrough(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Viewport(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Viewport(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4NusvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4NusvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PrioritizeTextures(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PrioritizeTextures(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ResetHistogram(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ResetHistogram(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetProgramNamedParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramNamedParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_PointParameterfEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PointParameterfEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramParameter4dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramParameter4dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord2sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord2sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex4dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex4dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CompressedTexImage3DARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CompressedTexImage3DARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color3sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color3sv(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetConvolutionParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetConvolutionParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_Vertex2dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex2dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord1fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord1fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord3iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord3iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color3fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color3fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PointSize(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PointSize(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PopName(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PopName(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4NbvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4NbvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex4sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex4sv(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetTexEnvfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexEnvfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_TexEnvi(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexEnvi(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetClipPlane(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetClipPlane(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_VertexAttribs3dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs3dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs4fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs4fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Scaled(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Scaled(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Scalef(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Scalef(GLbyte * pc);
>+extern HIDDEN void __glXDisp_AlphaFunc(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_AlphaFunc(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord2iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord2iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CompressedTexImage1DARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CompressedTexImage1DARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Rotated(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Rotated(GLbyte * pc);
>+extern HIDDEN int __glXDisp_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_EdgeFlagv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EdgeFlagv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color4iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color4iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexParameterf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexParameterf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexParameteri(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexParameteri(GLbyte * pc);
>+extern HIDDEN void __glXDisp_DrawPixels(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_DrawPixels(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord2svARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord2svARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs3fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs3fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_GenerateMipmapEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_GenerateMipmapEXT(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GenLists(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GenLists(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_MapGrid2d(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MapGrid2d(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MapGrid2f(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MapGrid2f(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Scissor(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Scissor(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Fogf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Fogf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexSubImage1D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexSubImage1D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color4usv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color4usv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Fogi(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Fogi(GLbyte * pc);
>+extern HIDDEN void __glXDisp_DepthRange(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_DepthRange(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos3iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos3iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PixelMapfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PixelMapfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color3usv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color3usv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_DrawBuffersARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_DrawBuffersARB(GLbyte * pc);
>+extern HIDDEN int __glXDisp_AreTexturesResident(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_AreTexturesResident(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_IsRenderbufferEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_IsRenderbufferEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_ColorTableParameteriv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ColorTableParameteriv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PointParameterfvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PointParameterfvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color3bv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color3bv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_SecondaryColor3bvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SecondaryColor3bvEXT(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetProgramLocalParameterfvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramLocalParameterfvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_RenderbufferStorageEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RenderbufferStorageEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ColorTable(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ColorTable(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Accum(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Accum(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetTexImage(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexImage(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_ConvolutionFilter2D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ConvolutionFilter2D(GLbyte * pc);
>+extern HIDDEN int __glXDisp_Finish(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_Finish(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_ClearStencil(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ClearStencil(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib3dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib3dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ConvolutionParameteriv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ConvolutionParameteriv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos2fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos2fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord1fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord1fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramEnvParameter4fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramEnvParameter4fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos4fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos4fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ClearIndex(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ClearIndex(GLbyte * pc);
>+extern HIDDEN void __glXDisp_LoadMatrixd(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LoadMatrixd(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos2dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos2dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ConvolutionParameterfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ConvolutionParameterfv(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetTexGendv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexGendv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_LoadProgramNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LoadProgramNV(GLbyte * pc);
>+extern HIDDEN int __glXDisp_EndList(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_EndList(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_VertexAttrib4fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_EvalCoord1fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EvalCoord1fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_EvalMesh2(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EvalMesh2(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex4fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex4fv(GLbyte * pc);
>+extern HIDDEN int __glXDisp_CheckFramebufferStatusEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_CheckFramebufferStatusEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetVertexAttribivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetVertexAttribivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetMinmax(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetMinmax(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_Normal3fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Normal3fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_End(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_End(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs2dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs2dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord3fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord3fvARB(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetProgramParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_TexSubImage2D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexSubImage2D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_DeleteRenderbuffersEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_DeleteRenderbuffersEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexGenfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexGenfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4bvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4bvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_FramebufferTexture3DEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_FramebufferTexture3DEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_BlendEquation(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_BlendEquation(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetError(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetError(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_TexCoord3dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord3dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Indexdv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Indexdv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PushName(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PushName(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord2dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord2dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramNamedParameter4fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramNamedParameter4fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord1svARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord1svARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_EndQueryARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EndQueryARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_DepthMask(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_DepthMask(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_StencilOp(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_StencilOp(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord3svARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord3svARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexEnvfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexEnvfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_LoadMatrixf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LoadMatrixf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color4bv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color4bv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_SecondaryColor3usvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SecondaryColor3usvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib2fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib2fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramLocalParameter4dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramLocalParameter4dvARB(GLbyte * pc);
>+extern HIDDEN int __glXDisp_DeleteLists(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_DeleteLists(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_LogicOp(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LogicOp(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord4fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord4fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib2dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib2dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_FramebufferRenderbufferEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_FramebufferRenderbufferEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib1dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib1dvNV(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GenTextures(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GenTextures(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_FramebufferTexture1DEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_FramebufferTexture1DEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramParameter4fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramParameter4fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos2sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos2sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color4ubv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color4ubv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_DrawBuffer(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_DrawBuffer(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord2fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord2fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord1sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord1sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_DepthFunc(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_DepthFunc(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PixelMapusv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PixelMapusv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PointParameterivNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PointParameterivNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_BlendFunc(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_BlendFunc(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord3dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord3dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramNamedParameter4dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramNamedParameter4dvNV(GLbyte * pc);
>+extern HIDDEN int __glXDisp_Flush(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_Flush(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_Color4uiv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color4uiv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos3sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos3sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_BindFramebufferEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_BindFramebufferEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PushAttrib(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PushAttrib(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4usvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4usvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexParameteriv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexParameteriv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_WindowPos3fvMESA(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_WindowPos3fvMESA(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib1svNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib1svNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos3fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos3fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CopyTexSubImage3D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyTexSubImage3D(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetColorTable(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetColorTable(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_Indexiv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Indexiv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CopyColorTable(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyColorTable(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetHistogramParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetHistogramParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_Frustum(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Frustum(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetString(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetString(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_TexEnvf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexEnvf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord3ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord3ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib1dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib1dvARB(GLbyte * pc);
>+extern HIDDEN int __glXDisp_DeleteTextures(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_DeleteTextures(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetTexLevelParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexLevelParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_ClearAccum(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ClearAccum(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetVertexAttribfvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetVertexAttribfvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_SecondaryColor3ivEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SecondaryColor3ivEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord4iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord4iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PolygonOffset(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PolygonOffset(GLbyte * pc);
>+extern HIDDEN void __glXDisp_SampleMaskSGIS(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SampleMaskSGIS(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4ubvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4ubvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CopyTexImage2D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyTexImage2D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Lightfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Lightfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ClearDepth(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ClearDepth(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ColorSubTable(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ColorSubTable(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color4fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color4fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord4ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord4ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Lightiv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Lightiv(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetQueryObjectuivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetQueryObjectuivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetTexParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GenRenderbuffersEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GenRenderbuffersEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_VertexAttrib2dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib2dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs2svNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs2svNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib2fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib2fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Rectdv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Rectdv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4NivARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4NivARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Materialiv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Materialiv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_SecondaryColor3fvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SecondaryColor3fvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PolygonMode(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PolygonMode(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CompressedTexSubImage1DARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CompressedTexSubImage1DARB(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetVertexAttribivNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetVertexAttribivNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_TexGeni(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexGeni(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexGenf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexGenf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexGend(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexGend(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetPolygonStipple(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetPolygonStipple(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetVertexAttribfvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetVertexAttribfvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_VertexAttrib2svNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib2svNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs1fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs1fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4NuivARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4NuivARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color4sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color4sv(GLbyte * pc);
>+extern HIDDEN int __glXDisp_IsProgramNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_IsProgramNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_PixelZoom(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PixelZoom(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ColorTableParameterfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ColorTableParameterfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PixelMapuiv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PixelMapuiv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color3dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color3dv(GLbyte * pc);
>+extern HIDDEN int __glXDisp_IsTexture(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_IsTexture(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_DeleteQueriesARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_DeleteQueriesARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetMapdv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetMapdv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_SamplePatternSGIS(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SamplePatternSGIS(GLbyte * pc);
>+extern HIDDEN int __glXDisp_PixelStoref(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_PixelStoref(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_IsQueryARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_IsQueryARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_EvalCoord2dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EvalCoord2dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib3svARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib3svARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ColorMaterial(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ColorMaterial(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CompressedTexSubImage3DARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CompressedTexSubImage3DARB(GLbyte * pc);
>+extern HIDDEN int __glXDisp_IsFramebufferEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_IsFramebufferEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetVertexAttribdvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetVertexAttribdvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetSeparableFilter(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetSeparableFilter(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_RequestResidentProgramsNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RequestResidentProgramsNV(GLbyte * pc);
>+extern HIDDEN int __glXDisp_FeedbackBuffer(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_FeedbackBuffer(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_RasterPos2iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos2iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexImage1D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexImage1D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_FrontFace(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_FrontFace(GLbyte * pc);
>+extern HIDDEN void __glXDisp_SecondaryColor3ubvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SecondaryColor3ubvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ExecuteProgramNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ExecuteProgramNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Normal3dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Normal3dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Lightf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Lightf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MatrixMode(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MatrixMode(GLbyte * pc);
>+extern HIDDEN void __glXDisp_FramebufferTexture2DEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_FramebufferTexture2DEXT(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetPixelMapusv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetPixelMapusv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_Lighti(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Lighti(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetFramebufferAttachmentParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetFramebufferAttachmentParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_MultiTexCoord4dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord4dvARB(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetDoublev(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetDoublev(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_MultMatrixd(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultMatrixd(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultMatrixf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultMatrixf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord4fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord4fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TrackMatrixNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TrackMatrixNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos4sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos4sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4NsvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4NsvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib3fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib3fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ClearColor(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ClearColor(GLbyte * pc);
>+extern HIDDEN void __glXDisp_DeleteFramebuffersEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_DeleteFramebuffersEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexEnviv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexEnviv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexSubImage3D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexSubImage3D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_SecondaryColor3uivEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SecondaryColor3uivEXT(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetColorTableParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetColorTableParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_Bitmap(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Bitmap(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetTexLevelParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexLevelParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GenFramebuffersEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GenFramebuffersEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetProgramParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_Vertex2sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex2sv(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetIntegerv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetIntegerv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetProgramEnvParameterfvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramEnvParameterfvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetTrackMatrixivNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTrackMatrixivNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_VertexAttrib3svNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib3svNV(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetTexEnviv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexEnviv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_SeparableFilter2D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SeparableFilter2D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Map1d(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Map1d(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Map1f(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Map1f(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CompressedTexImage2DARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CompressedTexImage2DARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexImage2D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexImage2D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramParameters4fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramParameters4fvNV(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetProgramivNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramivNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetMinmaxParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetMinmaxParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_PixelTransferf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PixelTransferf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CopyTexImage1D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyTexImage1D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PushMatrix(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PushMatrix(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Fogiv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Fogiv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord1dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord1dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PixelTransferi(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PixelTransferi(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_VertexAttrib3fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib3fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Rotatef(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Rotatef(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Clear(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Clear(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ReadBuffer(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ReadBuffer(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ConvolutionParameteri(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ConvolutionParameteri(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Ortho(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Ortho(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ListBase(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ListBase(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ConvolutionParameterf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ConvolutionParameterf(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetColorTableParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetColorTableParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_ShadeModel(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ShadeModel(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs2fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs2fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Rectiv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Rectiv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib1fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib1fvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_SecondaryColor3dvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SecondaryColor3dvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex2fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex2fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_BindRenderbufferEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_BindRenderbufferEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex3sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex3sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramLocalParameter4fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramLocalParameter4fvARB(GLbyte * pc);
>+extern HIDDEN int __glXDisp_DeleteProgramsNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_DeleteProgramsNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_EvalMesh1(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EvalMesh1(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord1dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord1dvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex2iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex2iv(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetProgramStringNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramStringNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_LineWidth(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LineWidth(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexGendv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexGendv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ResetMinmax(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ResetMinmax(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GenTexturesEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GenTexturesEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetConvolutionParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetConvolutionParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_VertexAttribs4dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs4dvNV(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetMaterialfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetMaterialfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_CallList(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CallList(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Materialfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Materialfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord3fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord3fv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_FogCoordfvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_FogCoordfvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord1ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord1ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord2ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord2ivARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CopyTexSubImage2D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyTexSubImage2D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color3iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color3iv(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetProgramLocalParameterdvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramLocalParameterdvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetHistogramParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetHistogramParameteriv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetConvolutionFilter(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetConvolutionFilter(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetProgramivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramivARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_BlendFuncSeparateEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_BlendFuncSeparateEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramParameters4dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramParameters4dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_EvalPoint2(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EvalPoint2(GLbyte * pc);
>+extern HIDDEN void __glXDisp_EvalPoint1(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EvalPoint1(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PopMatrix(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PopMatrix(GLbyte * pc);
>+extern HIDDEN int __glXDisp_AreTexturesResidentEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_AreTexturesResidentEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetTexGeniv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexGeniv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_Map2d(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Map2d(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Map2f(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Map2f(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ProgramStringARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ProgramStringARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos4dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos4dv(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetCompressedTexImageARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetCompressedTexImageARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetTexGenfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexGenfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetHistogram(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetHistogram(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_ActiveStencilFaceEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ActiveStencilFaceEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Materialf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Materialf(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Materiali(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Materiali(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Indexsv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Indexsv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord4svARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord4svARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_LightModelfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LightModelfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexCoord2dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord2dv(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GenQueriesARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GenQueriesARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_EvalCoord1dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_EvalCoord1dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Translated(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Translated(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Translatef(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Translatef(GLbyte * pc);
>+extern HIDDEN void __glXDisp_StencilMask(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_StencilMask(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetLightiv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetLightiv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_IsList(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_IsList(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_RenderMode(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_RenderMode(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_LoadName(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LoadName(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs4ubvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs4ubvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CopyTexSubImage1D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyTexSubImage1D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CullFace(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CullFace(GLbyte * pc);
>+extern HIDDEN void __glXDisp_BindTexture(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_BindTexture(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs3svNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs3svNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_StencilFunc(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_StencilFunc(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CopyPixels(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyPixels(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Rectsv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Rectsv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_CopyConvolutionFilter2D(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyConvolutionFilter2D(GLbyte * pc);
>+extern HIDDEN void __glXDisp_TexParameterfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexParameterfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4uivARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4uivARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ClipPlane(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ClipPlane(GLbyte * pc);
>+extern HIDDEN int __glXDisp_IsTextureEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_IsTextureEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetPixelMapuiv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetPixelMapuiv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_Indexfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Indexfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_SecondaryColor3svEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_SecondaryColor3svEXT(GLbyte * pc);
>+extern HIDDEN void __glXDisp_IndexMask(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_IndexMask(GLbyte * pc);
>+extern HIDDEN void __glXDisp_BindProgramNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_BindProgramNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4svARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4svARB(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetFloatv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetFloatv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_TexCoord3sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord3sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_PopAttrib(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_PopAttrib(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Fogfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Fogfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_InitNames(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_InitNames(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Normal3sv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Normal3sv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Minmax(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Minmax(GLbyte * pc);
>+extern HIDDEN void __glXDisp_FogCoorddvEXT(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_FogCoorddvEXT(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetBooleanv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetBooleanv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_Hint(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Hint(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Color4dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Color4dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib2svARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib2svARB(GLbyte * pc);
>+extern HIDDEN int __glXDisp_AreProgramsResidentNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_AreProgramsResidentNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_CopyColorSubTable(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_CopyColorSubTable(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib4NubvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4NubvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttrib3dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib3dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex4iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex4iv(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetProgramEnvParameterdvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetProgramEnvParameterdvARB(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_TexCoord4dv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_TexCoord4dv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Begin(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Begin(GLbyte * pc);
>+extern HIDDEN void __glXDisp_LightModeli(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LightModeli(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Rectfv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Rectfv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_LightModelf(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LightModelf(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetTexParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetTexParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDisp_GetLightfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetLightfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_Disable(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Disable(GLbyte * pc);
>+extern HIDDEN void __glXDisp_MultiTexCoord2fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_MultiTexCoord2fvARB(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetRenderbufferParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetRenderbufferParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_DrawArrays(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_DrawArrays(GLbyte * pc);
>+extern HIDDEN void __glXDisp_ColorMask(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_ColorMask(GLbyte * pc);
>+extern HIDDEN void __glXDisp_RasterPos4iv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_RasterPos4iv(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Enable(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Enable(GLbyte * pc);
>+extern HIDDEN void __glXDisp_LineStipple(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_LineStipple(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs4svNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs4svNV(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GetMinmaxParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GetMinmaxParameterfv(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_VertexAttrib1fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib1fvARB(GLbyte * pc);
>+extern HIDDEN void __glXDisp_VertexAttribs1svNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttribs1svNV(GLbyte * pc);
>+extern HIDDEN void __glXDisp_Vertex3fv(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_Vertex3fv(GLbyte * pc);
>+extern HIDDEN int __glXDisp_GenProgramsNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN int __glXDispSwap_GenProgramsNV(struct __GLXclientStateRec *, GLbyte *);
>+extern HIDDEN void __glXDisp_VertexAttrib4dvNV(GLbyte * pc);
>+extern HIDDEN void __glXDispSwap_VertexAttrib4dvNV(GLbyte * pc);
>+
>+#  undef HIDDEN
>+
>+#endif /* !defined( _INDIRECT_DISPATCH_H_ ) */
>Index: xorg/GL/glx/indirect_dispatch_swap.c
>===================================================================
>RCS file: xorg/GL/glx/indirect_dispatch_swap.c
>diff -N xorg/GL/glx/indirect_dispatch_swap.c
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ xorg/GL/glx/indirect_dispatch_swap.c	12 Jan 2006 00:04:17 -0000
>@@ -0,0 +1,5806 @@
>+/* DO NOT EDIT - This file generated automatically by glX_proto_recv.py (from Mesa) script */
>+
>+/*
>+ * (C) Copyright IBM Corporation 2005
>+ * 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
>+ * IBM,
>+ * 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 <X11/Xmd.h>
>+#include <GL/gl.h>
>+#include <GL/glxproto.h>
>+#include <byteswap.h>
>+#include <inttypes.h>
>+#include "indirect_size.h"
>+#include "indirect_size_get.h"
>+#include "indirect_dispatch.h"
>+#include "glxserver.h"
>+#include "indirect_util.h"
>+#include "singlesize.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
>+#include "dispatch.h"
>+
>+#define __GLX_PAD(x)  (((x) + 3) & ~3)
>+
>+typedef struct {
>+    __GLX_PIXEL_3D_HDR;
>+} __GLXpixel3DHeader;
>+
>+extern GLboolean __glXErrorOccured( void );
>+extern void __glXClearErrorOccured( void );
>+
>+static const unsigned dummy_answer[2] = {0, 0};
>+
>+static GLenum
>+bswap_ENUM( const void * src )
>+{
>+    union { uint32_t dst; GLenum ret; } x;
>+    x.dst = bswap_32( *(uint32_t *) src );
>+    return x.ret;
>+}
>+
>+static GLintptr
>+bswap_CARD32( const void * src )
>+{
>+    union { uint32_t dst; GLintptr ret; } x;
>+    x.dst = bswap_32( *(uint32_t *) src );
>+    return x.ret;
>+}
>+
>+static GLshort
>+bswap_CARD16( const void * src )
>+{
>+    union { uint16_t dst; GLshort ret; } x;
>+    x.dst = bswap_16( *(uint16_t *) src );
>+    return x.ret;
>+}
>+
>+static GLfloat
>+bswap_FLOAT32( const void * src )
>+{
>+    union { uint32_t dst; GLfloat ret; } x;
>+    x.dst = bswap_32( *(uint32_t *) src );
>+    return x.ret;
>+}
>+
>+static GLclampd
>+bswap_FLOAT64( const void * src )
>+{
>+    union { uint64_t dst; GLclampd ret; } x;
>+    x.dst = bswap_64( *(uint64_t *) src );
>+    return x.ret;
>+}
>+
>+static void *
>+bswap_16_array( uint16_t * src, unsigned count )
>+{
>+    unsigned  i;
>+
>+    for ( i = 0 ; i < count ; i++ ) {
>+        uint16_t temp = bswap_16( src[i] );
>+        src[i] = temp;
>+    }
>+
>+    return src;
>+}
>+
>+static void *
>+bswap_32_array( uint32_t * src, unsigned count )
>+{
>+    unsigned  i;
>+
>+    for ( i = 0 ; i < count ; i++ ) {
>+        uint32_t temp = bswap_32( src[i] );
>+        src[i] = temp;
>+    }
>+
>+    return src;
>+}
>+
>+static void *
>+bswap_64_array( uint64_t * src, unsigned count )
>+{
>+    unsigned  i;
>+
>+    for ( i = 0 ; i < count ; i++ ) {
>+        uint64_t temp = bswap_64( src[i] );
>+        src[i] = temp;
>+    }
>+
>+    return src;
>+}
>+
>+int __glXDispSwap_NewList(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        CALL_NewList( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 )
>+        ) );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_EndList(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        CALL_EndList( GET_DISPATCH(), () );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_CallList(GLbyte * pc)
>+{
>+    CALL_CallList( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_CallLists(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+    const GLenum type =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLvoid * lists;
>+
>+    switch(type) {
>+    case GL_BYTE:
>+    case GL_UNSIGNED_BYTE:
>+    case GL_2_BYTES:
>+    case GL_3_BYTES:
>+    case GL_4_BYTES:
>+        lists = (const GLvoid *) (pc + 8); break;
>+    case GL_SHORT:
>+    case GL_UNSIGNED_SHORT:
>+        lists = (const GLvoid *) bswap_16_array( (uint16_t *) (pc + 8), n ); break;
>+    case GL_INT:
>+    case GL_UNSIGNED_INT:
>+    case GL_FLOAT:
>+        lists = (const GLvoid *) bswap_32_array( (uint32_t *) (pc + 8), n ); break;
>+    }
>+
>+    CALL_CallLists( GET_DISPATCH(), (
>+        n,
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        lists
>+    ) );
>+}
>+
>+int __glXDispSwap_DeleteLists(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        CALL_DeleteLists( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+             (GLsizei )bswap_CARD32 ( pc +  4 )
>+        ) );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GenLists(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLuint retval;
>+        retval = CALL_GenLists( GET_DISPATCH(), (
>+             (GLsizei )bswap_CARD32 ( pc +  0 )
>+        ) );
>+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_ListBase(GLbyte * pc)
>+{
>+    CALL_ListBase( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Begin(GLbyte * pc)
>+{
>+    CALL_Begin( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Bitmap(GLbyte * pc)
>+{
>+    const GLubyte * const bitmap = (const GLubyte *) (pc + 44);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
>+
>+    CALL_Bitmap( GET_DISPATCH(), (
>+         (GLsizei )bswap_CARD32 ( pc + 20 ),
>+         (GLsizei )bswap_CARD32 ( pc + 24 ),
>+         (GLfloat )bswap_FLOAT32( pc + 28 ),
>+         (GLfloat )bswap_FLOAT32( pc + 32 ),
>+         (GLfloat )bswap_FLOAT32( pc + 36 ),
>+         (GLfloat )bswap_FLOAT32( pc + 40 ),
>+        bitmap
>+    ) );
>+}
>+
>+void __glXDispSwap_Color3bv(GLbyte * pc)
>+{
>+    CALL_Color3bv( GET_DISPATCH(), (
>+         (const GLbyte *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDispSwap_Color3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Color3dv( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Color3fv(GLbyte * pc)
>+{
>+    CALL_Color3fv( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Color3iv(GLbyte * pc)
>+{
>+    CALL_Color3iv( GET_DISPATCH(), (
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Color3sv(GLbyte * pc)
>+{
>+    CALL_Color3sv( GET_DISPATCH(), (
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Color3ubv(GLbyte * pc)
>+{
>+    CALL_Color3ubv( GET_DISPATCH(), (
>+         (const GLubyte *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDispSwap_Color3uiv(GLbyte * pc)
>+{
>+    CALL_Color3uiv( GET_DISPATCH(), (
>+         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Color3usv(GLbyte * pc)
>+{
>+    CALL_Color3usv( GET_DISPATCH(), (
>+         (const GLushort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Color4bv(GLbyte * pc)
>+{
>+    CALL_Color4bv( GET_DISPATCH(), (
>+         (const GLbyte *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDispSwap_Color4dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Color4dv( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Color4fv(GLbyte * pc)
>+{
>+    CALL_Color4fv( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Color4iv(GLbyte * pc)
>+{
>+    CALL_Color4iv( GET_DISPATCH(), (
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Color4sv(GLbyte * pc)
>+{
>+    CALL_Color4sv( GET_DISPATCH(), (
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Color4ubv(GLbyte * pc)
>+{
>+    CALL_Color4ubv( GET_DISPATCH(), (
>+         (const GLubyte *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDispSwap_Color4uiv(GLbyte * pc)
>+{
>+    CALL_Color4uiv( GET_DISPATCH(), (
>+         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Color4usv(GLbyte * pc)
>+{
>+    CALL_Color4usv( GET_DISPATCH(), (
>+         (const GLushort *)bswap_16_array( (uint16_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_EdgeFlagv(GLbyte * pc)
>+{
>+    CALL_EdgeFlagv( GET_DISPATCH(), (
>+         (const GLboolean *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDispSwap_End(GLbyte * pc)
>+{
>+    CALL_End( GET_DISPATCH(), () );
>+}
>+
>+void __glXDispSwap_Indexdv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Indexdv( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Indexfv(GLbyte * pc)
>+{
>+    CALL_Indexfv( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Indexiv(GLbyte * pc)
>+{
>+    CALL_Indexiv( GET_DISPATCH(), (
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Indexsv(GLbyte * pc)
>+{
>+    CALL_Indexsv( GET_DISPATCH(), (
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Normal3bv(GLbyte * pc)
>+{
>+    CALL_Normal3bv( GET_DISPATCH(), (
>+         (const GLbyte *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDispSwap_Normal3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Normal3dv( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Normal3fv(GLbyte * pc)
>+{
>+    CALL_Normal3fv( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Normal3iv(GLbyte * pc)
>+{
>+    CALL_Normal3iv( GET_DISPATCH(), (
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Normal3sv(GLbyte * pc)
>+{
>+    CALL_Normal3sv( GET_DISPATCH(), (
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_RasterPos2dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_RasterPos2dv( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_RasterPos2fv(GLbyte * pc)
>+{
>+    CALL_RasterPos2fv( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_RasterPos2iv(GLbyte * pc)
>+{
>+    CALL_RasterPos2iv( GET_DISPATCH(), (
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_RasterPos2sv(GLbyte * pc)
>+{
>+    CALL_RasterPos2sv( GET_DISPATCH(), (
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_RasterPos3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_RasterPos3dv( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_RasterPos3fv(GLbyte * pc)
>+{
>+    CALL_RasterPos3fv( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_RasterPos3iv(GLbyte * pc)
>+{
>+    CALL_RasterPos3iv( GET_DISPATCH(), (
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_RasterPos3sv(GLbyte * pc)
>+{
>+    CALL_RasterPos3sv( GET_DISPATCH(), (
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_RasterPos4dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_RasterPos4dv( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_RasterPos4fv(GLbyte * pc)
>+{
>+    CALL_RasterPos4fv( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_RasterPos4iv(GLbyte * pc)
>+{
>+    CALL_RasterPos4iv( GET_DISPATCH(), (
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_RasterPos4sv(GLbyte * pc)
>+{
>+    CALL_RasterPos4sv( GET_DISPATCH(), (
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Rectdv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Rectdv( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc + 16), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Rectfv(GLbyte * pc)
>+{
>+    CALL_Rectfv( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 2 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Rectiv(GLbyte * pc)
>+{
>+    CALL_Rectiv( GET_DISPATCH(), (
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 2 ),
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  8), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Rectsv(GLbyte * pc)
>+{
>+    CALL_Rectsv( GET_DISPATCH(), (
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 2 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexCoord1dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_TexCoord1dv( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexCoord1fv(GLbyte * pc)
>+{
>+    CALL_TexCoord1fv( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexCoord1iv(GLbyte * pc)
>+{
>+    CALL_TexCoord1iv( GET_DISPATCH(), (
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexCoord1sv(GLbyte * pc)
>+{
>+    CALL_TexCoord1sv( GET_DISPATCH(), (
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexCoord2dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_TexCoord2dv( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexCoord2fv(GLbyte * pc)
>+{
>+    CALL_TexCoord2fv( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexCoord2iv(GLbyte * pc)
>+{
>+    CALL_TexCoord2iv( GET_DISPATCH(), (
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexCoord2sv(GLbyte * pc)
>+{
>+    CALL_TexCoord2sv( GET_DISPATCH(), (
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexCoord3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_TexCoord3dv( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexCoord3fv(GLbyte * pc)
>+{
>+    CALL_TexCoord3fv( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexCoord3iv(GLbyte * pc)
>+{
>+    CALL_TexCoord3iv( GET_DISPATCH(), (
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexCoord3sv(GLbyte * pc)
>+{
>+    CALL_TexCoord3sv( GET_DISPATCH(), (
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexCoord4dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_TexCoord4dv( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexCoord4fv(GLbyte * pc)
>+{
>+    CALL_TexCoord4fv( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexCoord4iv(GLbyte * pc)
>+{
>+    CALL_TexCoord4iv( GET_DISPATCH(), (
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexCoord4sv(GLbyte * pc)
>+{
>+    CALL_TexCoord4sv( GET_DISPATCH(), (
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Vertex2dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Vertex2dv( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Vertex2fv(GLbyte * pc)
>+{
>+    CALL_Vertex2fv( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Vertex2iv(GLbyte * pc)
>+{
>+    CALL_Vertex2iv( GET_DISPATCH(), (
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Vertex2sv(GLbyte * pc)
>+{
>+    CALL_Vertex2sv( GET_DISPATCH(), (
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Vertex3dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Vertex3dv( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Vertex3fv(GLbyte * pc)
>+{
>+    CALL_Vertex3fv( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Vertex3iv(GLbyte * pc)
>+{
>+    CALL_Vertex3iv( GET_DISPATCH(), (
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Vertex3sv(GLbyte * pc)
>+{
>+    CALL_Vertex3sv( GET_DISPATCH(), (
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Vertex4dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Vertex4dv( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Vertex4fv(GLbyte * pc)
>+{
>+    CALL_Vertex4fv( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Vertex4iv(GLbyte * pc)
>+{
>+    CALL_Vertex4iv( GET_DISPATCH(), (
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Vertex4sv(GLbyte * pc)
>+{
>+    CALL_Vertex4sv( GET_DISPATCH(), (
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ClipPlane(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 36);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_ClipPlane( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc + 32 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ColorMaterial(GLbyte * pc)
>+{
>+    CALL_ColorMaterial( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_CullFace(GLbyte * pc)
>+{
>+    CALL_CullFace( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Fogf(GLbyte * pc)
>+{
>+    CALL_Fogf( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Fogfv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 4), __glFogfv_size(pname) );
>+
>+    CALL_Fogfv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_Fogi(GLbyte * pc)
>+{
>+    CALL_Fogi( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Fogiv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 4), __glFogiv_size(pname) );
>+
>+    CALL_Fogiv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_FrontFace(GLbyte * pc)
>+{
>+    CALL_FrontFace( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Hint(GLbyte * pc)
>+{
>+    CALL_Hint( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Lightf(GLbyte * pc)
>+{
>+    CALL_Lightf( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Lightfv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glLightfv_size(pname) );
>+
>+    CALL_Lightfv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_Lighti(GLbyte * pc)
>+{
>+    CALL_Lighti( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Lightiv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glLightiv_size(pname) );
>+
>+    CALL_Lightiv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_LightModelf(GLbyte * pc)
>+{
>+    CALL_LightModelf( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_LightModelfv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 4), __glLightModelfv_size(pname) );
>+
>+    CALL_LightModelfv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_LightModeli(GLbyte * pc)
>+{
>+    CALL_LightModeli( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_LightModeliv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 4), __glLightModeliv_size(pname) );
>+
>+    CALL_LightModeliv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_LineStipple(GLbyte * pc)
>+{
>+    CALL_LineStipple( GET_DISPATCH(), (
>+         (GLint   )bswap_CARD32 ( pc +  0 ),
>+         (GLushort)bswap_CARD16 ( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_LineWidth(GLbyte * pc)
>+{
>+    CALL_LineWidth( GET_DISPATCH(), (
>+         (GLfloat )bswap_FLOAT32( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Materialf(GLbyte * pc)
>+{
>+    CALL_Materialf( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Materialfv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glMaterialfv_size(pname) );
>+
>+    CALL_Materialfv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_Materiali(GLbyte * pc)
>+{
>+    CALL_Materiali( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Materialiv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glMaterialiv_size(pname) );
>+
>+    CALL_Materialiv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_PointSize(GLbyte * pc)
>+{
>+    CALL_PointSize( GET_DISPATCH(), (
>+         (GLfloat )bswap_FLOAT32( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_PolygonMode(GLbyte * pc)
>+{
>+    CALL_PolygonMode( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_PolygonStipple(GLbyte * pc)
>+{
>+    const GLubyte * const mask = (const GLubyte *) (pc + 20);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
>+
>+    CALL_PolygonStipple( GET_DISPATCH(), (
>+        mask
>+    ) );
>+}
>+
>+void __glXDispSwap_Scissor(GLbyte * pc)
>+{
>+    CALL_Scissor( GET_DISPATCH(), (
>+         (GLint   )bswap_CARD32 ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLsizei )bswap_CARD32 ( pc +  8 ),
>+         (GLsizei )bswap_CARD32 ( pc + 12 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ShadeModel(GLbyte * pc)
>+{
>+    CALL_ShadeModel( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexParameterf(GLbyte * pc)
>+{
>+    CALL_TexParameterf( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexParameterfv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glTexParameterfv_size(pname) );
>+
>+    CALL_TexParameterfv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_TexParameteri(GLbyte * pc)
>+{
>+    CALL_TexParameteri( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexParameteriv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glTexParameteriv_size(pname) );
>+
>+    CALL_TexParameteriv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_TexImage1D(GLbyte * pc)
>+{
>+    const GLvoid * const pixels = (const GLvoid *) (pc + 52);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
>+
>+    CALL_TexImage1D( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc + 20 ),
>+         (GLint   )bswap_CARD32 ( pc + 24 ),
>+         (GLint   )bswap_CARD32 ( pc + 28 ),
>+         (GLsizei )bswap_CARD32 ( pc + 32 ),
>+         (GLint   )bswap_CARD32 ( pc + 40 ),
>+         (GLenum  )bswap_ENUM   ( pc + 44 ),
>+         (GLenum  )bswap_ENUM   ( pc + 48 ),
>+        pixels
>+    ) );
>+}
>+
>+void __glXDispSwap_TexImage2D(GLbyte * pc)
>+{
>+    const GLvoid * const pixels = (const GLvoid *) (pc + 52);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
>+
>+    CALL_TexImage2D( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc + 20 ),
>+         (GLint   )bswap_CARD32 ( pc + 24 ),
>+         (GLint   )bswap_CARD32 ( pc + 28 ),
>+         (GLsizei )bswap_CARD32 ( pc + 32 ),
>+         (GLsizei )bswap_CARD32 ( pc + 36 ),
>+         (GLint   )bswap_CARD32 ( pc + 40 ),
>+         (GLenum  )bswap_ENUM   ( pc + 44 ),
>+         (GLenum  )bswap_ENUM   ( pc + 48 ),
>+        pixels
>+    ) );
>+}
>+
>+void __glXDispSwap_TexEnvf(GLbyte * pc)
>+{
>+    CALL_TexEnvf( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexEnvfv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glTexEnvfv_size(pname) );
>+
>+    CALL_TexEnvfv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_TexEnvi(GLbyte * pc)
>+{
>+    CALL_TexEnvi( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexEnviv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glTexEnviv_size(pname) );
>+
>+    CALL_TexEnviv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_TexGend(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_TexGend( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLenum  )bswap_ENUM   ( pc + 12 ),
>+         (GLdouble)bswap_FLOAT64( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexGendv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLdouble * params;
>+
>+#ifdef __GLX_ALIGN64
>+    const GLuint compsize = __glTexGendv_size(pname);
>+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8)) - 4;
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, cmdlen);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    params = (const GLdouble *) bswap_64_array( (uint64_t *) (pc + 8), __glTexGendv_size(pname) );
>+
>+    CALL_TexGendv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_TexGenf(GLbyte * pc)
>+{
>+    CALL_TexGenf( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexGenfv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glTexGenfv_size(pname) );
>+
>+    CALL_TexGenfv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_TexGeni(GLbyte * pc)
>+{
>+    CALL_TexGeni( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexGeniv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glTexGeniv_size(pname) );
>+
>+    CALL_TexGeniv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_InitNames(GLbyte * pc)
>+{
>+    CALL_InitNames( GET_DISPATCH(), () );
>+}
>+
>+void __glXDispSwap_LoadName(GLbyte * pc)
>+{
>+    CALL_LoadName( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_PassThrough(GLbyte * pc)
>+{
>+    CALL_PassThrough( GET_DISPATCH(), (
>+         (GLfloat )bswap_FLOAT32( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_PopName(GLbyte * pc)
>+{
>+    CALL_PopName( GET_DISPATCH(), () );
>+}
>+
>+void __glXDispSwap_PushName(GLbyte * pc)
>+{
>+    CALL_PushName( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_DrawBuffer(GLbyte * pc)
>+{
>+    CALL_DrawBuffer( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Clear(GLbyte * pc)
>+{
>+    CALL_Clear( GET_DISPATCH(), (
>+         (GLbitfield)bswap_CARD32 ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ClearAccum(GLbyte * pc)
>+{
>+    CALL_ClearAccum( GET_DISPATCH(), (
>+         (GLfloat )bswap_FLOAT32( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 ),
>+         (GLfloat )bswap_FLOAT32( pc + 12 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ClearIndex(GLbyte * pc)
>+{
>+    CALL_ClearIndex( GET_DISPATCH(), (
>+         (GLfloat )bswap_FLOAT32( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ClearColor(GLbyte * pc)
>+{
>+    CALL_ClearColor( GET_DISPATCH(), (
>+         (GLclampf)bswap_FLOAT32( pc +  0 ),
>+         (GLclampf)bswap_FLOAT32( pc +  4 ),
>+         (GLclampf)bswap_FLOAT32( pc +  8 ),
>+         (GLclampf)bswap_FLOAT32( pc + 12 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ClearStencil(GLbyte * pc)
>+{
>+    CALL_ClearStencil( GET_DISPATCH(), (
>+         (GLint   )bswap_CARD32 ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ClearDepth(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_ClearDepth( GET_DISPATCH(), (
>+         (GLclampd)bswap_FLOAT64( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_StencilMask(GLbyte * pc)
>+{
>+    CALL_StencilMask( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ColorMask(GLbyte * pc)
>+{
>+    CALL_ColorMask( GET_DISPATCH(), (
>+        *(GLboolean *)(pc +  0),
>+        *(GLboolean *)(pc +  1),
>+        *(GLboolean *)(pc +  2),
>+        *(GLboolean *)(pc +  3)
>+    ) );
>+}
>+
>+void __glXDispSwap_DepthMask(GLbyte * pc)
>+{
>+    CALL_DepthMask( GET_DISPATCH(), (
>+        *(GLboolean *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDispSwap_IndexMask(GLbyte * pc)
>+{
>+    CALL_IndexMask( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Accum(GLbyte * pc)
>+{
>+    CALL_Accum( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Disable(GLbyte * pc)
>+{
>+    CALL_Disable( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Enable(GLbyte * pc)
>+{
>+    CALL_Enable( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_PopAttrib(GLbyte * pc)
>+{
>+    CALL_PopAttrib( GET_DISPATCH(), () );
>+}
>+
>+void __glXDispSwap_PushAttrib(GLbyte * pc)
>+{
>+    CALL_PushAttrib( GET_DISPATCH(), (
>+         (GLbitfield)bswap_CARD32 ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MapGrid1d(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 20);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_MapGrid1d( GET_DISPATCH(), (
>+         (GLint   )bswap_CARD32 ( pc + 16 ),
>+         (GLdouble)bswap_FLOAT64( pc +  0 ),
>+         (GLdouble)bswap_FLOAT64( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MapGrid1f(GLbyte * pc)
>+{
>+    CALL_MapGrid1f( GET_DISPATCH(), (
>+         (GLint   )bswap_CARD32 ( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MapGrid2d(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 40);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_MapGrid2d( GET_DISPATCH(), (
>+         (GLint   )bswap_CARD32 ( pc + 32 ),
>+         (GLdouble)bswap_FLOAT64( pc +  0 ),
>+         (GLdouble)bswap_FLOAT64( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 36 ),
>+         (GLdouble)bswap_FLOAT64( pc + 16 ),
>+         (GLdouble)bswap_FLOAT64( pc + 24 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MapGrid2f(GLbyte * pc)
>+{
>+    CALL_MapGrid2f( GET_DISPATCH(), (
>+         (GLint   )bswap_CARD32 ( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLfloat )bswap_FLOAT32( pc + 16 ),
>+         (GLfloat )bswap_FLOAT32( pc + 20 )
>+    ) );
>+}
>+
>+void __glXDispSwap_EvalCoord1dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_EvalCoord1dv( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_EvalCoord1fv(GLbyte * pc)
>+{
>+    CALL_EvalCoord1fv( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_EvalCoord2dv(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_EvalCoord2dv( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_EvalCoord2fv(GLbyte * pc)
>+{
>+    CALL_EvalCoord2fv( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_EvalMesh1(GLbyte * pc)
>+{
>+    CALL_EvalMesh1( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_EvalPoint1(GLbyte * pc)
>+{
>+    CALL_EvalPoint1( GET_DISPATCH(), (
>+         (GLint   )bswap_CARD32 ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_EvalMesh2(GLbyte * pc)
>+{
>+    CALL_EvalMesh2( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLint   )bswap_CARD32 ( pc + 16 )
>+    ) );
>+}
>+
>+void __glXDispSwap_EvalPoint2(GLbyte * pc)
>+{
>+    CALL_EvalPoint2( GET_DISPATCH(), (
>+         (GLint   )bswap_CARD32 ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_AlphaFunc(GLbyte * pc)
>+{
>+    CALL_AlphaFunc( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLclampf)bswap_FLOAT32( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_BlendFunc(GLbyte * pc)
>+{
>+    CALL_BlendFunc( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_LogicOp(GLbyte * pc)
>+{
>+    CALL_LogicOp( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_StencilFunc(GLbyte * pc)
>+{
>+    CALL_StencilFunc( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLuint  )bswap_CARD32 ( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_StencilOp(GLbyte * pc)
>+{
>+    CALL_StencilOp( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_DepthFunc(GLbyte * pc)
>+{
>+    CALL_DepthFunc( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_PixelZoom(GLbyte * pc)
>+{
>+    CALL_PixelZoom( GET_DISPATCH(), (
>+         (GLfloat )bswap_FLOAT32( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_PixelTransferf(GLbyte * pc)
>+{
>+    CALL_PixelTransferf( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_PixelTransferi(GLbyte * pc)
>+{
>+    CALL_PixelTransferi( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 )
>+    ) );
>+}
>+
>+int __glXDispSwap_PixelStoref(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        CALL_PixelStoref( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLfloat )bswap_FLOAT32( pc +  4 )
>+        ) );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_PixelStorei(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        CALL_PixelStorei( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLint   )bswap_CARD32 ( pc +  4 )
>+        ) );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_PixelMapfv(GLbyte * pc)
>+{
>+    const GLsizei mapsize =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    CALL_PixelMapfv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        mapsize,
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_PixelMapuiv(GLbyte * pc)
>+{
>+    const GLsizei mapsize =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    CALL_PixelMapuiv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        mapsize,
>+         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  8), 0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_PixelMapusv(GLbyte * pc)
>+{
>+    const GLsizei mapsize =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    CALL_PixelMapusv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        mapsize,
>+         (const GLushort *)bswap_16_array( (uint16_t *) (pc +  8), 0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ReadBuffer(GLbyte * pc)
>+{
>+    CALL_ReadBuffer( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_CopyPixels(GLbyte * pc)
>+{
>+    CALL_CopyPixels( GET_DISPATCH(), (
>+         (GLint   )bswap_CARD32 ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLsizei )bswap_CARD32 ( pc +  8 ),
>+         (GLsizei )bswap_CARD32 ( pc + 12 ),
>+         (GLenum  )bswap_ENUM   ( pc + 16 )
>+    ) );
>+}
>+
>+void __glXDispSwap_DrawPixels(GLbyte * pc)
>+{
>+    const GLvoid * const pixels = (const GLvoid *) (pc + 36);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
>+
>+    CALL_DrawPixels( GET_DISPATCH(), (
>+         (GLsizei )bswap_CARD32 ( pc + 20 ),
>+         (GLsizei )bswap_CARD32 ( pc + 24 ),
>+         (GLenum  )bswap_ENUM   ( pc + 28 ),
>+         (GLenum  )bswap_ENUM   ( pc + 32 ),
>+        pixels
>+    ) );
>+}
>+
>+int __glXDispSwap_GetBooleanv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+
>+        const GLuint compsize = __glGetBooleanv_size(pname);
>+        GLboolean answerBuffer[200];
>+        GLboolean * params = __glXGetAnswerBuffer(cl, compsize, answerBuffer, sizeof(answerBuffer), 1);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetBooleanv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            params
>+        ) );
>+        __glXSendReplySwap(cl->client, params, compsize, 1, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetClipPlane(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLdouble equation[4];
>+        CALL_GetClipPlane( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            equation
>+        ) );
>+        (void) bswap_64_array( (uint64_t *) equation, 4 );
>+        __glXSendReplySwap(cl->client, equation, 4, 8, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetDoublev(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+
>+        const GLuint compsize = __glGetDoublev_size(pname);
>+        GLdouble answerBuffer[200];
>+        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetDoublev( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            params
>+        ) );
>+        (void) bswap_64_array( (uint64_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetError(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLenum retval;
>+        retval = CALL_GetError( GET_DISPATCH(), () );
>+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetFloatv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+
>+        const GLuint compsize = __glGetFloatv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetFloatv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetIntegerv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+
>+        const GLuint compsize = __glGetIntegerv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetIntegerv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetLightfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetLightfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetLightfv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetLightiv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetLightiv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetLightiv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetMapdv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum target =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+        const GLenum query =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetMapdv_size(target,query);
>+        GLdouble answerBuffer[200];
>+        GLdouble * v = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (v == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetMapdv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            v
>+        ) );
>+        (void) bswap_64_array( (uint64_t *) v, compsize );
>+        __glXSendReplySwap(cl->client, v, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetMapfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum target =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+        const GLenum query =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetMapfv_size(target,query);
>+        GLfloat answerBuffer[200];
>+        GLfloat * v = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (v == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetMapfv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            v
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) v, compsize );
>+        __glXSendReplySwap(cl->client, v, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetMapiv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum target =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+        const GLenum query =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetMapiv_size(target,query);
>+        GLint answerBuffer[200];
>+        GLint * v = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (v == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetMapiv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            v
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) v, compsize );
>+        __glXSendReplySwap(cl->client, v, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetMaterialfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetMaterialfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetMaterialfv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetMaterialiv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetMaterialiv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetMaterialiv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetPixelMapfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum map =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+
>+        const GLuint compsize = __glGetPixelMapfv_size(map);
>+        GLfloat answerBuffer[200];
>+        GLfloat * values = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (values == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetPixelMapfv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            values
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) values, compsize );
>+        __glXSendReplySwap(cl->client, values, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetPixelMapuiv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum map =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+
>+        const GLuint compsize = __glGetPixelMapuiv_size(map);
>+        GLuint answerBuffer[200];
>+        GLuint * values = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (values == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetPixelMapuiv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            values
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) values, compsize );
>+        __glXSendReplySwap(cl->client, values, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetPixelMapusv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum map =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+
>+        const GLuint compsize = __glGetPixelMapusv_size(map);
>+        GLushort answerBuffer[200];
>+        GLushort * values = __glXGetAnswerBuffer(cl, compsize * 2, answerBuffer, sizeof(answerBuffer), 2);
>+
>+        if (values == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetPixelMapusv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+            values
>+        ) );
>+        (void) bswap_16_array( (uint16_t *) values, compsize );
>+        __glXSendReplySwap(cl->client, values, compsize, 2, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTexEnvfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetTexEnvfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetTexEnvfv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTexEnviv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetTexEnviv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetTexEnviv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTexGendv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetTexGendv_size(pname);
>+        GLdouble answerBuffer[200];
>+        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetTexGendv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_64_array( (uint64_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTexGenfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetTexGenfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetTexGenfv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTexGeniv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetTexGeniv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetTexGeniv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTexParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetTexParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetTexParameterfv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTexParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetTexParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetTexParameteriv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTexLevelParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  8 );
>+
>+        const GLuint compsize = __glGetTexLevelParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetTexLevelParameterfv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLint   )bswap_CARD32 ( pc +  4 ),
>+             (GLenum  )bswap_ENUM   ( pc +  8 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTexLevelParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  8 );
>+
>+        const GLuint compsize = __glGetTexLevelParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetTexLevelParameteriv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLint   )bswap_CARD32 ( pc +  4 ),
>+             (GLenum  )bswap_ENUM   ( pc +  8 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_IsEnabled(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = CALL_IsEnabled( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 )
>+        ) );
>+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_IsList(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = CALL_IsList( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 )
>+        ) );
>+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_DepthRange(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 16);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_DepthRange( GET_DISPATCH(), (
>+         (GLclampd)bswap_FLOAT64( pc +  0 ),
>+         (GLclampd)bswap_FLOAT64( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Frustum(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 48);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Frustum( GET_DISPATCH(), (
>+         (GLdouble)bswap_FLOAT64( pc +  0 ),
>+         (GLdouble)bswap_FLOAT64( pc +  8 ),
>+         (GLdouble)bswap_FLOAT64( pc + 16 ),
>+         (GLdouble)bswap_FLOAT64( pc + 24 ),
>+         (GLdouble)bswap_FLOAT64( pc + 32 ),
>+         (GLdouble)bswap_FLOAT64( pc + 40 )
>+    ) );
>+}
>+
>+void __glXDispSwap_LoadIdentity(GLbyte * pc)
>+{
>+    CALL_LoadIdentity( GET_DISPATCH(), () );
>+}
>+
>+void __glXDispSwap_LoadMatrixf(GLbyte * pc)
>+{
>+    CALL_LoadMatrixf( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 16 )
>+    ) );
>+}
>+
>+void __glXDispSwap_LoadMatrixd(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 128);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_LoadMatrixd( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 16 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MatrixMode(GLbyte * pc)
>+{
>+    CALL_MatrixMode( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MultMatrixf(GLbyte * pc)
>+{
>+    CALL_MultMatrixf( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 16 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MultMatrixd(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 128);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_MultMatrixd( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 16 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Ortho(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 48);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Ortho( GET_DISPATCH(), (
>+         (GLdouble)bswap_FLOAT64( pc +  0 ),
>+         (GLdouble)bswap_FLOAT64( pc +  8 ),
>+         (GLdouble)bswap_FLOAT64( pc + 16 ),
>+         (GLdouble)bswap_FLOAT64( pc + 24 ),
>+         (GLdouble)bswap_FLOAT64( pc + 32 ),
>+         (GLdouble)bswap_FLOAT64( pc + 40 )
>+    ) );
>+}
>+
>+void __glXDispSwap_PopMatrix(GLbyte * pc)
>+{
>+    CALL_PopMatrix( GET_DISPATCH(), () );
>+}
>+
>+void __glXDispSwap_PushMatrix(GLbyte * pc)
>+{
>+    CALL_PushMatrix( GET_DISPATCH(), () );
>+}
>+
>+void __glXDispSwap_Rotated(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 32);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Rotated( GET_DISPATCH(), (
>+         (GLdouble)bswap_FLOAT64( pc +  0 ),
>+         (GLdouble)bswap_FLOAT64( pc +  8 ),
>+         (GLdouble)bswap_FLOAT64( pc + 16 ),
>+         (GLdouble)bswap_FLOAT64( pc + 24 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Rotatef(GLbyte * pc)
>+{
>+    CALL_Rotatef( GET_DISPATCH(), (
>+         (GLfloat )bswap_FLOAT32( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 ),
>+         (GLfloat )bswap_FLOAT32( pc + 12 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Scaled(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Scaled( GET_DISPATCH(), (
>+         (GLdouble)bswap_FLOAT64( pc +  0 ),
>+         (GLdouble)bswap_FLOAT64( pc +  8 ),
>+         (GLdouble)bswap_FLOAT64( pc + 16 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Scalef(GLbyte * pc)
>+{
>+    CALL_Scalef( GET_DISPATCH(), (
>+         (GLfloat )bswap_FLOAT32( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Translated(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_Translated( GET_DISPATCH(), (
>+         (GLdouble)bswap_FLOAT64( pc +  0 ),
>+         (GLdouble)bswap_FLOAT64( pc +  8 ),
>+         (GLdouble)bswap_FLOAT64( pc + 16 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Translatef(GLbyte * pc)
>+{
>+    CALL_Translatef( GET_DISPATCH(), (
>+         (GLfloat )bswap_FLOAT32( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Viewport(GLbyte * pc)
>+{
>+    CALL_Viewport( GET_DISPATCH(), (
>+         (GLint   )bswap_CARD32 ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLsizei )bswap_CARD32 ( pc +  8 ),
>+         (GLsizei )bswap_CARD32 ( pc + 12 )
>+    ) );
>+}
>+
>+void __glXDispSwap_BindTexture(GLbyte * pc)
>+{
>+    CALL_BindTexture( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_Indexubv(GLbyte * pc)
>+{
>+    CALL_Indexubv( GET_DISPATCH(), (
>+         (const GLubyte *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDispSwap_PolygonOffset(GLbyte * pc)
>+{
>+    CALL_PolygonOffset( GET_DISPATCH(), (
>+         (GLfloat )bswap_FLOAT32( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 )
>+    ) );
>+}
>+
>+int __glXDispSwap_AreTexturesResident(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        GLboolean retval;
>+        GLboolean answerBuffer[200];
>+        GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
>+        retval = CALL_AreTexturesResident( GET_DISPATCH(), (
>+            n,
>+             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 ),
>+            residences
>+        ) );
>+        __glXSendReplySwap(cl->client, residences, n, 1, GL_TRUE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_CopyTexImage1D(GLbyte * pc)
>+{
>+    CALL_CopyTexImage1D( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLint   )bswap_CARD32 ( pc + 16 ),
>+         (GLsizei )bswap_CARD32 ( pc + 20 ),
>+         (GLint   )bswap_CARD32 ( pc + 24 )
>+    ) );
>+}
>+
>+void __glXDispSwap_CopyTexImage2D(GLbyte * pc)
>+{
>+    CALL_CopyTexImage2D( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLint   )bswap_CARD32 ( pc + 16 ),
>+         (GLsizei )bswap_CARD32 ( pc + 20 ),
>+         (GLsizei )bswap_CARD32 ( pc + 24 ),
>+         (GLint   )bswap_CARD32 ( pc + 28 )
>+    ) );
>+}
>+
>+void __glXDispSwap_CopyTexSubImage1D(GLbyte * pc)
>+{
>+    CALL_CopyTexSubImage1D( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLint   )bswap_CARD32 ( pc + 16 ),
>+         (GLsizei )bswap_CARD32 ( pc + 20 )
>+    ) );
>+}
>+
>+void __glXDispSwap_CopyTexSubImage2D(GLbyte * pc)
>+{
>+    CALL_CopyTexSubImage2D( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLint   )bswap_CARD32 ( pc + 16 ),
>+         (GLint   )bswap_CARD32 ( pc + 20 ),
>+         (GLsizei )bswap_CARD32 ( pc + 24 ),
>+         (GLsizei )bswap_CARD32 ( pc + 28 )
>+    ) );
>+}
>+
>+int __glXDispSwap_DeleteTextures(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        CALL_DeleteTextures( GET_DISPATCH(), (
>+            n,
>+             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
>+        ) );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GenTextures(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        GLuint answerBuffer[200];
>+        GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        CALL_GenTextures( GET_DISPATCH(), (
>+            n,
>+            textures
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) textures, n );
>+        __glXSendReplySwap(cl->client, textures, n, 4, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_IsTexture(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = CALL_IsTexture( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 )
>+        ) );
>+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_PrioritizeTextures(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+    CALL_PrioritizeTextures( GET_DISPATCH(), (
>+        n,
>+         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 ),
>+         (const GLclampf *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexSubImage1D(GLbyte * pc)
>+{
>+    const CARD32 ptr_is_null = *(CARD32 *)(pc + 52);
>+    const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 56);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
>+
>+    CALL_TexSubImage1D( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc + 20 ),
>+         (GLint   )bswap_CARD32 ( pc + 24 ),
>+         (GLint   )bswap_CARD32 ( pc + 28 ),
>+         (GLsizei )bswap_CARD32 ( pc + 36 ),
>+         (GLenum  )bswap_ENUM   ( pc + 44 ),
>+         (GLenum  )bswap_ENUM   ( pc + 48 ),
>+        pixels
>+    ) );
>+}
>+
>+void __glXDispSwap_TexSubImage2D(GLbyte * pc)
>+{
>+    const CARD32 ptr_is_null = *(CARD32 *)(pc + 52);
>+    const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 56);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
>+
>+    CALL_TexSubImage2D( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc + 20 ),
>+         (GLint   )bswap_CARD32 ( pc + 24 ),
>+         (GLint   )bswap_CARD32 ( pc + 28 ),
>+         (GLint   )bswap_CARD32 ( pc + 32 ),
>+         (GLsizei )bswap_CARD32 ( pc + 36 ),
>+         (GLsizei )bswap_CARD32 ( pc + 40 ),
>+         (GLenum  )bswap_ENUM   ( pc + 44 ),
>+         (GLenum  )bswap_ENUM   ( pc + 48 ),
>+        pixels
>+    ) );
>+}
>+
>+void __glXDispSwap_BlendColor(GLbyte * pc)
>+{
>+    CALL_BlendColor( GET_DISPATCH(), (
>+         (GLclampf)bswap_FLOAT32( pc +  0 ),
>+         (GLclampf)bswap_FLOAT32( pc +  4 ),
>+         (GLclampf)bswap_FLOAT32( pc +  8 ),
>+         (GLclampf)bswap_FLOAT32( pc + 12 )
>+    ) );
>+}
>+
>+void __glXDispSwap_BlendEquation(GLbyte * pc)
>+{
>+    CALL_BlendEquation( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ColorTable(GLbyte * pc)
>+{
>+    const GLvoid * const table = (const GLvoid *) (pc + 40);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
>+
>+    CALL_ColorTable( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc + 20 ),
>+         (GLenum  )bswap_ENUM   ( pc + 24 ),
>+         (GLsizei )bswap_CARD32 ( pc + 28 ),
>+         (GLenum  )bswap_ENUM   ( pc + 32 ),
>+         (GLenum  )bswap_ENUM   ( pc + 36 ),
>+        table
>+    ) );
>+}
>+
>+void __glXDispSwap_ColorTableParameterfv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glColorTableParameterfv_size(pname) );
>+
>+    CALL_ColorTableParameterfv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_ColorTableParameteriv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glColorTableParameteriv_size(pname) );
>+
>+    CALL_ColorTableParameteriv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_CopyColorTable(GLbyte * pc)
>+{
>+    CALL_CopyColorTable( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLsizei )bswap_CARD32 ( pc + 16 )
>+    ) );
>+}
>+
>+int __glXDispSwap_GetColorTableParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetColorTableParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetColorTableParameterfv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetColorTableParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetColorTableParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetColorTableParameteriv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_ColorSubTable(GLbyte * pc)
>+{
>+    const GLvoid * const data = (const GLvoid *) (pc + 40);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
>+
>+    CALL_ColorSubTable( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc + 20 ),
>+         (GLsizei )bswap_CARD32 ( pc + 24 ),
>+         (GLsizei )bswap_CARD32 ( pc + 28 ),
>+         (GLenum  )bswap_ENUM   ( pc + 32 ),
>+         (GLenum  )bswap_ENUM   ( pc + 36 ),
>+        data
>+    ) );
>+}
>+
>+void __glXDispSwap_CopyColorSubTable(GLbyte * pc)
>+{
>+    CALL_CopyColorSubTable( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLsizei )bswap_CARD32 ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLsizei )bswap_CARD32 ( pc + 16 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ConvolutionFilter1D(GLbyte * pc)
>+{
>+    const GLvoid * const image = (const GLvoid *) (pc + 44);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
>+
>+    CALL_ConvolutionFilter1D( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc + 20 ),
>+         (GLenum  )bswap_ENUM   ( pc + 24 ),
>+         (GLsizei )bswap_CARD32 ( pc + 28 ),
>+         (GLenum  )bswap_ENUM   ( pc + 36 ),
>+         (GLenum  )bswap_ENUM   ( pc + 40 ),
>+        image
>+    ) );
>+}
>+
>+void __glXDispSwap_ConvolutionFilter2D(GLbyte * pc)
>+{
>+    const GLvoid * const image = (const GLvoid *) (pc + 44);
>+    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
>+
>+    CALL_ConvolutionFilter2D( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc + 20 ),
>+         (GLenum  )bswap_ENUM   ( pc + 24 ),
>+         (GLsizei )bswap_CARD32 ( pc + 28 ),
>+         (GLsizei )bswap_CARD32 ( pc + 32 ),
>+         (GLenum  )bswap_ENUM   ( pc + 36 ),
>+         (GLenum  )bswap_ENUM   ( pc + 40 ),
>+        image
>+    ) );
>+}
>+
>+void __glXDispSwap_ConvolutionParameterf(GLbyte * pc)
>+{
>+    CALL_ConvolutionParameterf( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLfloat )bswap_FLOAT32( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ConvolutionParameterfv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glConvolutionParameterfv_size(pname) );
>+
>+    CALL_ConvolutionParameterfv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_ConvolutionParameteri(GLbyte * pc)
>+{
>+    CALL_ConvolutionParameteri( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ConvolutionParameteriv(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glConvolutionParameteriv_size(pname) );
>+
>+    CALL_ConvolutionParameteriv( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_CopyConvolutionFilter1D(GLbyte * pc)
>+{
>+    CALL_CopyConvolutionFilter1D( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLsizei )bswap_CARD32 ( pc + 16 )
>+    ) );
>+}
>+
>+void __glXDispSwap_CopyConvolutionFilter2D(GLbyte * pc)
>+{
>+    CALL_CopyConvolutionFilter2D( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLsizei )bswap_CARD32 ( pc + 16 ),
>+         (GLsizei )bswap_CARD32 ( pc + 20 )
>+    ) );
>+}
>+
>+int __glXDispSwap_GetConvolutionParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetConvolutionParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetConvolutionParameterfv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetConvolutionParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetConvolutionParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetConvolutionParameteriv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetHistogramParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetHistogramParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetHistogramParameterfv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetHistogramParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetHistogramParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetHistogramParameteriv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetMinmaxParameterfv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetMinmaxParameterfv_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetMinmaxParameterfv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetMinmaxParameteriv(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetMinmaxParameteriv_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetMinmaxParameteriv( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_Histogram(GLbyte * pc)
>+{
>+    CALL_Histogram( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLsizei )bswap_CARD32 ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+        *(GLboolean *)(pc + 12)
>+    ) );
>+}
>+
>+void __glXDispSwap_Minmax(GLbyte * pc)
>+{
>+    CALL_Minmax( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        *(GLboolean *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDispSwap_ResetHistogram(GLbyte * pc)
>+{
>+    CALL_ResetHistogram( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ResetMinmax(GLbyte * pc)
>+{
>+    CALL_ResetMinmax( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TexImage3D(GLbyte * pc)
>+{
>+    const CARD32 ptr_is_null = *(CARD32 *)(pc + 76);
>+    const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 80);
>+    __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_IMAGE_HEIGHT, (GLint) bswap_CARD32( & hdr->imageHeight )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_IMAGES,  (GLint) bswap_CARD32( & hdr->skipImages )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
>+
>+    CALL_TexImage3D( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc + 36 ),
>+         (GLint   )bswap_CARD32 ( pc + 40 ),
>+         (GLint   )bswap_CARD32 ( pc + 44 ),
>+         (GLsizei )bswap_CARD32 ( pc + 48 ),
>+         (GLsizei )bswap_CARD32 ( pc + 52 ),
>+         (GLsizei )bswap_CARD32 ( pc + 56 ),
>+         (GLint   )bswap_CARD32 ( pc + 64 ),
>+         (GLenum  )bswap_ENUM   ( pc + 68 ),
>+         (GLenum  )bswap_ENUM   ( pc + 72 ),
>+        pixels
>+    ) );
>+}
>+
>+void __glXDispSwap_TexSubImage3D(GLbyte * pc)
>+{
>+    const CARD32 ptr_is_null = *(CARD32 *)(pc + 84);
>+    const GLvoid * const pixels = (const GLvoid *) (ptr_is_null != 0) ? NULL : (pc + 88);
>+    __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc);
>+
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_IMAGE_HEIGHT, (GLint) bswap_CARD32( & hdr->imageHeight )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_IMAGES,  (GLint) bswap_CARD32( & hdr->skipImages )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
>+
>+    CALL_TexSubImage3D( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc + 36 ),
>+         (GLint   )bswap_CARD32 ( pc + 40 ),
>+         (GLint   )bswap_CARD32 ( pc + 44 ),
>+         (GLint   )bswap_CARD32 ( pc + 48 ),
>+         (GLint   )bswap_CARD32 ( pc + 52 ),
>+         (GLsizei )bswap_CARD32 ( pc + 60 ),
>+         (GLsizei )bswap_CARD32 ( pc + 64 ),
>+         (GLsizei )bswap_CARD32 ( pc + 68 ),
>+         (GLenum  )bswap_ENUM   ( pc + 76 ),
>+         (GLenum  )bswap_ENUM   ( pc + 80 ),
>+        pixels
>+    ) );
>+}
>+
>+void __glXDispSwap_CopyTexSubImage3D(GLbyte * pc)
>+{
>+    CALL_CopyTexSubImage3D( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLint   )bswap_CARD32 ( pc + 16 ),
>+         (GLint   )bswap_CARD32 ( pc + 20 ),
>+         (GLint   )bswap_CARD32 ( pc + 24 ),
>+         (GLsizei )bswap_CARD32 ( pc + 28 ),
>+         (GLsizei )bswap_CARD32 ( pc + 32 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ActiveTextureARB(GLbyte * pc)
>+{
>+    CALL_ActiveTextureARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MultiTexCoord1dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 12);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_MultiTexCoord1dvARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MultiTexCoord1fvARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord1fvARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MultiTexCoord1ivARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord1ivARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  4), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MultiTexCoord1svARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord1svARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MultiTexCoord2dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 20);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_MultiTexCoord2dvARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc + 16 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MultiTexCoord2fvARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord2fvARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MultiTexCoord2ivARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord2ivARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  4), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MultiTexCoord2svARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord2svARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MultiTexCoord3dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 28);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_MultiTexCoord3dvARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc + 24 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MultiTexCoord3fvARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord3fvARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MultiTexCoord3ivARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord3ivARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  4), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MultiTexCoord3svARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord3svARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MultiTexCoord4dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 36);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_MultiTexCoord4dvARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc + 32 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MultiTexCoord4fvARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord4fvARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MultiTexCoord4ivARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord4ivARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_MultiTexCoord4svARB(GLbyte * pc)
>+{
>+    CALL_MultiTexCoord4svARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_SampleCoverageARB(GLbyte * pc)
>+{
>+    CALL_SampleCoverageARB( GET_DISPATCH(), (
>+         (GLclampf)bswap_FLOAT32( pc +  0 ),
>+        *(GLboolean *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDispSwap_DrawBuffersARB(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+    CALL_DrawBuffersARB( GET_DISPATCH(), (
>+        n,
>+         (const GLenum *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
>+    ) );
>+}
>+
>+int __glXDispSwap_AreTexturesResidentEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        GLboolean retval;
>+        GLboolean answerBuffer[200];
>+        GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
>+        retval = CALL_AreTexturesResidentEXT( GET_DISPATCH(), (
>+            n,
>+             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 ),
>+            residences
>+        ) );
>+        __glXSendReplySwap(cl->client, residences, n, 1, GL_TRUE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GenTexturesEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        GLuint answerBuffer[200];
>+        GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        CALL_GenTexturesEXT( GET_DISPATCH(), (
>+            n,
>+            textures
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) textures, n );
>+        __glXSendReplySwap(cl->client, textures, n, 4, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_IsTextureEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = CALL_IsTextureEXT( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 )
>+        ) );
>+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_SampleMaskSGIS(GLbyte * pc)
>+{
>+    CALL_SampleMaskSGIS( GET_DISPATCH(), (
>+         (GLclampf)bswap_FLOAT32( pc +  0 ),
>+        *(GLboolean *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDispSwap_SamplePatternSGIS(GLbyte * pc)
>+{
>+    CALL_SamplePatternSGIS( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_PointParameterfEXT(GLbyte * pc)
>+{
>+    CALL_PointParameterfEXT( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLfloat )bswap_FLOAT32( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_PointParameterfvEXT(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+    const GLfloat * params;
>+
>+    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 4), __glPointParameterfvEXT_size(pname) );
>+
>+    CALL_PointParameterfvEXT( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_WindowPos3fvMESA(GLbyte * pc)
>+{
>+    CALL_WindowPos3fvMESA( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_BlendFuncSeparateEXT(GLbyte * pc)
>+{
>+    CALL_BlendFuncSeparateEXT( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLenum  )bswap_ENUM   ( pc + 12 )
>+    ) );
>+}
>+
>+void __glXDispSwap_FogCoordfvEXT(GLbyte * pc)
>+{
>+    CALL_FogCoordfvEXT( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_FogCoorddvEXT(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 8);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_FogCoorddvEXT( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_CompressedTexImage3DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize =  (GLsizei )bswap_CARD32 ( pc + 28 );
>+
>+    CALL_CompressedTexImage3DARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLsizei )bswap_CARD32 ( pc + 12 ),
>+         (GLsizei )bswap_CARD32 ( pc + 16 ),
>+         (GLsizei )bswap_CARD32 ( pc + 20 ),
>+         (GLint   )bswap_CARD32 ( pc + 24 ),
>+        imageSize,
>+         (const GLvoid *)(pc + 32)
>+    ) );
>+}
>+
>+void __glXDispSwap_CompressedTexImage2DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize =  (GLsizei )bswap_CARD32 ( pc + 24 );
>+
>+    CALL_CompressedTexImage2DARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLsizei )bswap_CARD32 ( pc + 12 ),
>+         (GLsizei )bswap_CARD32 ( pc + 16 ),
>+         (GLint   )bswap_CARD32 ( pc + 20 ),
>+        imageSize,
>+         (const GLvoid *)(pc + 28)
>+    ) );
>+}
>+
>+void __glXDispSwap_CompressedTexImage1DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize =  (GLsizei )bswap_CARD32 ( pc + 20 );
>+
>+    CALL_CompressedTexImage1DARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLsizei )bswap_CARD32 ( pc + 12 ),
>+         (GLint   )bswap_CARD32 ( pc + 16 ),
>+        imageSize,
>+         (const GLvoid *)(pc + 24)
>+    ) );
>+}
>+
>+void __glXDispSwap_CompressedTexSubImage3DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize =  (GLsizei )bswap_CARD32 ( pc + 36 );
>+
>+    CALL_CompressedTexSubImage3DARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLint   )bswap_CARD32 ( pc + 16 ),
>+         (GLsizei )bswap_CARD32 ( pc + 20 ),
>+         (GLsizei )bswap_CARD32 ( pc + 24 ),
>+         (GLsizei )bswap_CARD32 ( pc + 28 ),
>+         (GLenum  )bswap_ENUM   ( pc + 32 ),
>+        imageSize,
>+         (const GLvoid *)(pc + 40)
>+    ) );
>+}
>+
>+void __glXDispSwap_CompressedTexSubImage2DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize =  (GLsizei )bswap_CARD32 ( pc + 28 );
>+
>+    CALL_CompressedTexSubImage2DARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLint   )bswap_CARD32 ( pc + 12 ),
>+         (GLsizei )bswap_CARD32 ( pc + 16 ),
>+         (GLsizei )bswap_CARD32 ( pc + 20 ),
>+         (GLenum  )bswap_ENUM   ( pc + 24 ),
>+        imageSize,
>+         (const GLvoid *)(pc + 32)
>+    ) );
>+}
>+
>+void __glXDispSwap_CompressedTexSubImage1DARB(GLbyte * pc)
>+{
>+    const GLsizei imageSize =  (GLsizei )bswap_CARD32 ( pc + 20 );
>+
>+    CALL_CompressedTexSubImage1DARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 ),
>+         (GLint   )bswap_CARD32 ( pc +  8 ),
>+         (GLsizei )bswap_CARD32 ( pc + 12 ),
>+         (GLenum  )bswap_ENUM   ( pc + 16 ),
>+        imageSize,
>+         (const GLvoid *)(pc + 24)
>+    ) );
>+}
>+
>+void __glXDispSwap_SecondaryColor3bvEXT(GLbyte * pc)
>+{
>+    CALL_SecondaryColor3bvEXT( GET_DISPATCH(), (
>+         (const GLbyte *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDispSwap_SecondaryColor3dvEXT(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 24);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_SecondaryColor3dvEXT( GET_DISPATCH(), (
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_SecondaryColor3fvEXT(GLbyte * pc)
>+{
>+    CALL_SecondaryColor3fvEXT( GET_DISPATCH(), (
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_SecondaryColor3ivEXT(GLbyte * pc)
>+{
>+    CALL_SecondaryColor3ivEXT( GET_DISPATCH(), (
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_SecondaryColor3svEXT(GLbyte * pc)
>+{
>+    CALL_SecondaryColor3svEXT( GET_DISPATCH(), (
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_SecondaryColor3ubvEXT(GLbyte * pc)
>+{
>+    CALL_SecondaryColor3ubvEXT( GET_DISPATCH(), (
>+         (const GLubyte *)(pc +  0)
>+    ) );
>+}
>+
>+void __glXDispSwap_SecondaryColor3uivEXT(GLbyte * pc)
>+{
>+    CALL_SecondaryColor3uivEXT( GET_DISPATCH(), (
>+         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_SecondaryColor3usvEXT(GLbyte * pc)
>+{
>+    CALL_SecondaryColor3usvEXT( GET_DISPATCH(), (
>+         (const GLushort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+int __glXDispSwap_AreProgramsResidentNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        GLboolean retval;
>+        GLboolean answerBuffer[200];
>+        GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
>+        retval = CALL_AreProgramsResidentNV( GET_DISPATCH(), (
>+            n,
>+             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 ),
>+            residences
>+        ) );
>+        __glXSendReplySwap(cl->client, residences, n, 1, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_BindProgramNV(GLbyte * pc)
>+{
>+    CALL_BindProgramNV( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 )
>+    ) );
>+}
>+
>+int __glXDispSwap_DeleteProgramsNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        CALL_DeleteProgramsNV( GET_DISPATCH(), (
>+            n,
>+             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
>+        ) );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_ExecuteProgramNV(GLbyte * pc)
>+{
>+    CALL_ExecuteProgramNV( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 4 )
>+    ) );
>+}
>+
>+int __glXDispSwap_GenProgramsNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        GLuint answerBuffer[200];
>+        GLuint * programs = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        CALL_GenProgramsNV( GET_DISPATCH(), (
>+            n,
>+            programs
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) programs, n );
>+        __glXSendReplySwap(cl->client, programs, n, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetProgramParameterdvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLdouble params[4];
>+        CALL_GetProgramParameterdvNV( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLuint  )bswap_CARD32 ( pc +  4 ),
>+             (GLenum  )bswap_ENUM   ( pc +  8 ),
>+            params
>+        ) );
>+        (void) bswap_64_array( (uint64_t *) params, 4 );
>+        __glXSendReplySwap(cl->client, params, 4, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetProgramParameterfvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLfloat params[4];
>+        CALL_GetProgramParameterfvNV( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLuint  )bswap_CARD32 ( pc +  4 ),
>+             (GLenum  )bswap_ENUM   ( pc +  8 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, 4 );
>+        __glXSendReplySwap(cl->client, params, 4, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetProgramivNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetProgramivNV_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetProgramivNV( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetTrackMatrixivNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLint params[1];
>+        CALL_GetTrackMatrixivNV( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLuint  )bswap_CARD32 ( pc +  4 ),
>+             (GLenum  )bswap_ENUM   ( pc +  8 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, 1 );
>+        __glXSendReplySwap(cl->client, params, 1, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetVertexAttribdvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetVertexAttribdvARB_size(pname);
>+        GLdouble answerBuffer[200];
>+        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetVertexAttribdvARB( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_64_array( (uint64_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetVertexAttribfvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetVertexAttribfvARB_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetVertexAttribfvARB( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetVertexAttribivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetVertexAttribivARB_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetVertexAttribivARB( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_IsProgramNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = CALL_IsProgramNV( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 )
>+        ) );
>+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_LoadProgramNV(GLbyte * pc)
>+{
>+    const GLsizei len =  (GLsizei )bswap_CARD32 ( pc +  8 );
>+
>+    CALL_LoadProgramNV( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 ),
>+        len,
>+         (const GLubyte *)(pc + 12)
>+    ) );
>+}
>+
>+void __glXDispSwap_ProgramParameter4dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 40);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_ProgramParameter4dvNV( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  8), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ProgramParameter4fvNV(GLbyte * pc)
>+{
>+    CALL_ProgramParameter4fvNV( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ProgramParameters4dvNV(GLbyte * pc)
>+{
>+    const GLuint num =  (GLuint  )bswap_CARD32 ( pc +  8 );
>+
>+#ifdef __GLX_ALIGN64
>+    const GLuint cmdlen = 16 + __GLX_PAD((num * 32)) - 4;
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, cmdlen);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_ProgramParameters4dvNV( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 ),
>+        num,
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc + 12), 0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ProgramParameters4fvNV(GLbyte * pc)
>+{
>+    const GLuint num =  (GLuint  )bswap_CARD32 ( pc +  8 );
>+
>+    CALL_ProgramParameters4fvNV( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 ),
>+        num,
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc + 12), 0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_RequestResidentProgramsNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+    CALL_RequestResidentProgramsNV( GET_DISPATCH(), (
>+        n,
>+         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_TrackMatrixNV(GLbyte * pc)
>+{
>+    CALL_TrackMatrixNV( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLenum  )bswap_ENUM   ( pc + 12 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib1dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 12);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttrib1dvARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  8 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib1fvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib1fvARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib1svARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib1svARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib2dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 20);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttrib2dvARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc + 16 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib2fvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib2fvARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib2svARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib2svARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib3dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 28);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttrib3dvARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc + 24 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib3fvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib3fvARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib3svARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib3svARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib4dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 36);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttrib4dvARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc + 32 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib4fvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4fvARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib4svARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4svARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib4NubvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4NubvARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLubyte *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttribs1dvNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+#ifdef __GLX_ALIGN64
>+    const GLuint cmdlen = 12 + __GLX_PAD((n * 8)) - 4;
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, cmdlen);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttribs1dvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  8), 0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttribs1fvNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    CALL_VertexAttribs1fvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttribs1svNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    CALL_VertexAttribs1svNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  8), 0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttribs2dvNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+#ifdef __GLX_ALIGN64
>+    const GLuint cmdlen = 12 + __GLX_PAD((n * 16)) - 4;
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, cmdlen);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttribs2dvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  8), 0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttribs2fvNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    CALL_VertexAttribs2fvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttribs2svNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    CALL_VertexAttribs2svNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  8), 0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttribs3dvNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+#ifdef __GLX_ALIGN64
>+    const GLuint cmdlen = 12 + __GLX_PAD((n * 24)) - 4;
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, cmdlen);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttribs3dvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  8), 0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttribs3fvNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    CALL_VertexAttribs3fvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttribs3svNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    CALL_VertexAttribs3svNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  8), 0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttribs4dvNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+#ifdef __GLX_ALIGN64
>+    const GLuint cmdlen = 12 + __GLX_PAD((n * 32)) - 4;
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, cmdlen);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttribs4dvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  8), 0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttribs4fvNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    CALL_VertexAttribs4fvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttribs4svNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    CALL_VertexAttribs4svNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  8), 0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttribs4ubvNV(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    CALL_VertexAttribs4ubvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        n,
>+         (const GLubyte *)(pc +  8)
>+    ) );
>+}
>+
>+void __glXDispSwap_PointParameteriNV(GLbyte * pc)
>+{
>+    CALL_PointParameteriNV( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLint   )bswap_CARD32 ( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_PointParameterivNV(GLbyte * pc)
>+{
>+    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
>+    const GLint * params;
>+
>+    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 4), __glPointParameterivNV_size(pname) );
>+
>+    CALL_PointParameterivNV( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+        params
>+    ) );
>+}
>+
>+void __glXDispSwap_ActiveStencilFaceEXT(GLbyte * pc)
>+{
>+    CALL_ActiveStencilFaceEXT( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib4bvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4bvARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLbyte *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib4ivARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4ivARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib4ubvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4ubvARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLubyte *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib4usvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4usvARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLushort *)bswap_16_array( (uint16_t *) (pc +  4), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib4uivARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4uivARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib4NbvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4NbvARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLbyte *)(pc +  4)
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib4NsvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4NsvARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib4NivARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4NivARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLint *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib4NusvARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4NusvARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLushort *)bswap_16_array( (uint16_t *) (pc +  4), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib4NuivARB(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4NuivARB( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ProgramStringARB(GLbyte * pc)
>+{
>+    const GLsizei len =  (GLsizei )bswap_CARD32 ( pc +  8 );
>+
>+    CALL_ProgramStringARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+        len,
>+         (const GLvoid *)(pc + 12)
>+    ) );
>+}
>+
>+void __glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 40);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_ProgramEnvParameter4dvARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  8), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ProgramEnvParameter4fvARB(GLbyte * pc)
>+{
>+    CALL_ProgramEnvParameter4fvARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ProgramLocalParameter4dvARB(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 40);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_ProgramLocalParameter4dvARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  8), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ProgramLocalParameter4fvARB(GLbyte * pc)
>+{
>+    CALL_ProgramLocalParameter4fvARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 4 )
>+    ) );
>+}
>+
>+int __glXDispSwap_GetProgramEnvParameterdvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLdouble params[4];
>+        CALL_GetProgramEnvParameterdvARB( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLuint  )bswap_CARD32 ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_64_array( (uint64_t *) params, 4 );
>+        __glXSendReplySwap(cl->client, params, 4, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetProgramEnvParameterfvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLfloat params[4];
>+        CALL_GetProgramEnvParameterfvARB( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLuint  )bswap_CARD32 ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, 4 );
>+        __glXSendReplySwap(cl->client, params, 4, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetProgramLocalParameterdvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLdouble params[4];
>+        CALL_GetProgramLocalParameterdvARB( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLuint  )bswap_CARD32 ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_64_array( (uint64_t *) params, 4 );
>+        __glXSendReplySwap(cl->client, params, 4, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetProgramLocalParameterfvARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLfloat params[4];
>+        CALL_GetProgramLocalParameterfvARB( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLuint  )bswap_CARD32 ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, 4 );
>+        __glXSendReplySwap(cl->client, params, 4, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetProgramivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetProgramivARB_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetProgramivARB( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_ProgramNamedParameter4fvNV(GLbyte * pc)
>+{
>+    const GLsizei len =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+    CALL_ProgramNamedParameter4fvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+        len,
>+         (const GLubyte *)(pc + 24),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_ProgramNamedParameter4dvNV(GLbyte * pc)
>+{
>+    const GLsizei len =  (GLsizei )bswap_CARD32 ( pc + 36 );
>+
>+#ifdef __GLX_ALIGN64
>+    const GLuint cmdlen = 44 + __GLX_PAD(len) - 4;
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, cmdlen);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_ProgramNamedParameter4dvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc + 32 ),
>+        len,
>+         (const GLubyte *)(pc + 40),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
>+    ) );
>+}
>+
>+int __glXDispSwap_GetProgramNamedParameterfvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei len =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+        GLfloat params[4];
>+        CALL_GetProgramNamedParameterfvNV( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+            len,
>+             (const GLubyte *)(pc +  8),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, 4 );
>+        __glXSendReplySwap(cl->client, params, 4, 4, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetProgramNamedParameterdvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei len =  (GLsizei )bswap_CARD32 ( pc +  4 );
>+
>+        GLdouble params[4];
>+        CALL_GetProgramNamedParameterdvNV( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+            len,
>+             (const GLubyte *)(pc +  8),
>+            params
>+        ) );
>+        (void) bswap_64_array( (uint64_t *) params, 4 );
>+        __glXSendReplySwap(cl->client, params, 4, 8, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GenQueriesARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        GLuint answerBuffer[200];
>+        GLuint * ids = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        CALL_GenQueriesARB( GET_DISPATCH(), (
>+            n,
>+            ids
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) ids, n );
>+        __glXSendReplySwap(cl->client, ids, n, 4, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_DeleteQueriesARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        CALL_DeleteQueriesARB( GET_DISPATCH(), (
>+            n,
>+             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
>+        ) );
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_IsQueryARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = CALL_IsQueryARB( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 )
>+        ) );
>+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_BeginQueryARB(GLbyte * pc)
>+{
>+    CALL_BeginQueryARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_EndQueryARB(GLbyte * pc)
>+{
>+    CALL_EndQueryARB( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    ) );
>+}
>+
>+int __glXDispSwap_GetQueryivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetQueryivARB_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetQueryivARB( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetQueryObjectivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetQueryObjectivARB_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetQueryObjectivARB( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetQueryObjectuivARB(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_SINGLE_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetQueryObjectuivARB_size(pname);
>+        GLuint answerBuffer[200];
>+        GLuint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetQueryObjectuivARB( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetVertexAttribdvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetVertexAttribdvNV_size(pname);
>+        GLdouble answerBuffer[200];
>+        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetVertexAttribdvNV( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_64_array( (uint64_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 8, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetVertexAttribfvNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetVertexAttribfvNV_size(pname);
>+        GLfloat answerBuffer[200];
>+        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetVertexAttribfvNV( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_GetVertexAttribivNV(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
>+
>+        const GLuint compsize = __glGetVertexAttribivNV_size(pname);
>+        GLint answerBuffer[200];
>+        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
>+
>+        if (params == NULL) return BadAlloc;
>+        __glXClearErrorOccured();
>+
>+        CALL_GetVertexAttribivNV( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, compsize );
>+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_VertexAttrib1dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 12);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttrib1dvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  4), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib1fvNV(GLbyte * pc)
>+{
>+    CALL_VertexAttrib1fvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib1svNV(GLbyte * pc)
>+{
>+    CALL_VertexAttrib1svNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 1 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib2dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 20);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttrib2dvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  4), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib2fvNV(GLbyte * pc)
>+{
>+    CALL_VertexAttrib2fvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib2svNV(GLbyte * pc)
>+{
>+    CALL_VertexAttrib2svNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 2 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib3dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 28);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttrib3dvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  4), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib3fvNV(GLbyte * pc)
>+{
>+    CALL_VertexAttrib3fvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib3svNV(GLbyte * pc)
>+{
>+    CALL_VertexAttrib3svNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 3 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib4dvNV(GLbyte * pc)
>+{
>+#ifdef __GLX_ALIGN64
>+    if ((unsigned long)(pc) & 7) {
>+        (void) memmove(pc-4, pc, 36);
>+        pc -= 4;
>+    }
>+#endif
>+
>+    CALL_VertexAttrib4dvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  4), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib4fvNV(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4fvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib4svNV(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4svNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_VertexAttrib4ubvNV(GLbyte * pc)
>+{
>+    CALL_VertexAttrib4ubvNV( GET_DISPATCH(), (
>+         (GLuint  )bswap_CARD32 ( pc +  0 ),
>+         (const GLubyte *)(pc +  4)
>+    ) );
>+}
>+
>+int __glXDispSwap_IsRenderbufferEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = CALL_IsRenderbufferEXT( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 )
>+        ) );
>+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_BindRenderbufferEXT(GLbyte * pc)
>+{
>+    CALL_BindRenderbufferEXT( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_DeleteRenderbuffersEXT(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+    CALL_DeleteRenderbuffersEXT( GET_DISPATCH(), (
>+        n,
>+         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
>+    ) );
>+}
>+
>+int __glXDispSwap_GenRenderbuffersEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        GLuint answerBuffer[200];
>+        GLuint * renderbuffers = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        CALL_GenRenderbuffersEXT( GET_DISPATCH(), (
>+            n,
>+            renderbuffers
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) renderbuffers, n );
>+        __glXSendReplySwap(cl->client, renderbuffers, n, 4, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_RenderbufferStorageEXT(GLbyte * pc)
>+{
>+    CALL_RenderbufferStorageEXT( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLsizei )bswap_CARD32 ( pc +  8 ),
>+         (GLsizei )bswap_CARD32 ( pc + 12 )
>+    ) );
>+}
>+
>+int __glXDispSwap_GetRenderbufferParameterivEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLint params[1];
>+        CALL_GetRenderbufferParameterivEXT( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, 1 );
>+        __glXSendReplySwap(cl->client, params, 1, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_IsFramebufferEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLboolean retval;
>+        retval = CALL_IsFramebufferEXT( GET_DISPATCH(), (
>+             (GLuint  )bswap_CARD32 ( pc +  0 )
>+        ) );
>+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_BindFramebufferEXT(GLbyte * pc)
>+{
>+    CALL_BindFramebufferEXT( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLuint  )bswap_CARD32 ( pc +  4 )
>+    ) );
>+}
>+
>+void __glXDispSwap_DeleteFramebuffersEXT(GLbyte * pc)
>+{
>+    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+    CALL_DeleteFramebuffersEXT( GET_DISPATCH(), (
>+        n,
>+         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
>+    ) );
>+}
>+
>+int __glXDispSwap_GenFramebuffersEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
>+
>+        GLuint answerBuffer[200];
>+        GLuint * framebuffers = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
>+        CALL_GenFramebuffersEXT( GET_DISPATCH(), (
>+            n,
>+            framebuffers
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) framebuffers, n );
>+        __glXSendReplySwap(cl->client, framebuffers, n, 4, GL_TRUE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+int __glXDispSwap_CheckFramebufferStatusEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLenum retval;
>+        retval = CALL_CheckFramebufferStatusEXT( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 )
>+        ) );
>+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_FramebufferTexture1DEXT(GLbyte * pc)
>+{
>+    CALL_FramebufferTexture1DEXT( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLuint  )bswap_CARD32 ( pc + 12 ),
>+         (GLint   )bswap_CARD32 ( pc + 16 )
>+    ) );
>+}
>+
>+void __glXDispSwap_FramebufferTexture2DEXT(GLbyte * pc)
>+{
>+    CALL_FramebufferTexture2DEXT( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLuint  )bswap_CARD32 ( pc + 12 ),
>+         (GLint   )bswap_CARD32 ( pc + 16 )
>+    ) );
>+}
>+
>+void __glXDispSwap_FramebufferTexture3DEXT(GLbyte * pc)
>+{
>+    CALL_FramebufferTexture3DEXT( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLuint  )bswap_CARD32 ( pc + 12 ),
>+         (GLint   )bswap_CARD32 ( pc + 16 ),
>+         (GLint   )bswap_CARD32 ( pc + 20 )
>+    ) );
>+}
>+
>+void __glXDispSwap_FramebufferRenderbufferEXT(GLbyte * pc)
>+{
>+    CALL_FramebufferRenderbufferEXT( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 ),
>+         (GLenum  )bswap_ENUM   ( pc +  4 ),
>+         (GLenum  )bswap_ENUM   ( pc +  8 ),
>+         (GLuint  )bswap_CARD32 ( pc + 12 )
>+    ) );
>+}
>+
>+int __glXDispSwap_GetFramebufferAttachmentParameterivEXT(__GLXclientState *cl, GLbyte *pc)
>+{
>+    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
>+    int error;
>+    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
>+
>+    pc += __GLX_VENDPRIV_HDR_SIZE;
>+    if ( cx != NULL ) {
>+        GLint params[1];
>+        CALL_GetFramebufferAttachmentParameterivEXT( GET_DISPATCH(), (
>+             (GLenum  )bswap_ENUM   ( pc +  0 ),
>+             (GLenum  )bswap_ENUM   ( pc +  4 ),
>+             (GLenum  )bswap_ENUM   ( pc +  8 ),
>+            params
>+        ) );
>+        (void) bswap_32_array( (uint32_t *) params, 1 );
>+        __glXSendReplySwap(cl->client, params, 1, 4, GL_FALSE, 0);
>+        error = Success;
>+    }
>+
>+    return error;
>+}
>+
>+void __glXDispSwap_GenerateMipmapEXT(GLbyte * pc)
>+{
>+    CALL_GenerateMipmapEXT( GET_DISPATCH(), (
>+         (GLenum  )bswap_ENUM   ( pc +  0 )
>+    ) );
>+}
>+
>Index: xorg/GL/glx/indirect_reqsize.c
>===================================================================
>RCS file: xorg/GL/glx/indirect_reqsize.c
>diff -N xorg/GL/glx/indirect_reqsize.c
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ xorg/GL/glx/indirect_reqsize.c	12 Jan 2006 00:04:17 -0000
>@@ -0,0 +1,839 @@
>+/* DO NOT EDIT - This file generated automatically by glX_proto_size.py (from Mesa) script */
>+
>+/*
>+ * (C) Copyright IBM Corporation 2005
>+ * 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
>+ * IBM,
>+ * 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 <GL/gl.h>
>+#include "glxserver.h"
>+#include "indirect_size.h"
>+#include "indirect_reqsize.h"
>+
>+#if defined(linux)
>+#  include <byteswap.h>
>+#  define SWAP_32(v)  do { (v) = bswap_32(v); } while(0)
>+#else
>+#  include <X11/misc.h>
>+#  define SWAP_32(v)  do { char tmp; swapl(&v, tmp); } while(0)
>+#endif
>+
>+#define __GLX_PAD(x)  (((x) + 3) & ~3)
>+
>+#if defined(__CYGWIN__) || defined(__MINGW32__)
>+#  undef HAVE_ALIAS
>+#endif
>+#ifdef HAVE_ALIAS
>+#  define ALIAS2(from,to) \
>+    GLint __glX ## from ## ReqSize( const GLbyte * pc, Bool swap ) \
>+        __attribute__ ((alias( # to )));
>+#  define ALIAS(from,to) ALIAS2( from, __glX ## to ## ReqSize )
>+#else
>+#  define ALIAS(from,to) \
>+    GLint __glX ## from ## ReqSize( const GLbyte * pc, Bool swap ) \
>+    { return __glX ## to ## ReqSize( pc, swap ); }
>+#endif
>+
>+
>+int
>+__glXCallListsReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLsizei n          = *(GLsizei *)(pc + 0);
>+    GLenum type        = * (GLenum *)(pc + 4);
>+    GLsizei compsize;
>+
>+    if (swap) {
>+        SWAP_32( n );
>+        SWAP_32( type );
>+    }
>+
>+    compsize = __glCallLists_size(type);
>+    return __GLX_PAD((compsize * n));
>+}
>+
>+int
>+__glXBitmapReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLint row_length   = *  (GLint *)(pc +  4);
>+    GLint image_height = 0;
>+    GLint skip_images  = 0;
>+    GLint skip_rows    = *  (GLint *)(pc +  8);
>+    GLint alignment    = *  (GLint *)(pc + 16);
>+    GLsizei width      = *(GLsizei *)(pc + 20);
>+    GLsizei height     = *(GLsizei *)(pc + 24);
>+
>+    if (swap) {
>+        SWAP_32( row_length );
>+        SWAP_32( skip_rows );
>+        SWAP_32( alignment );
>+        SWAP_32( width );
>+        SWAP_32( height );
>+    }
>+
>+    return __glXImageSize(GL_COLOR_INDEX, GL_BITMAP, 0, width, height, 1,
>+                          image_height, row_length, skip_images,
>+                          skip_rows, alignment);
>+}
>+
>+int
>+__glXFogfvReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLenum pname       = * (GLenum *)(pc + 0);
>+    GLsizei compsize;
>+
>+    if (swap) {
>+        SWAP_32( pname );
>+    }
>+
>+    compsize = __glFogfv_size(pname);
>+    return __GLX_PAD((compsize * 4));
>+}
>+
>+int
>+__glXLightfvReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLenum pname       = * (GLenum *)(pc + 4);
>+    GLsizei compsize;
>+
>+    if (swap) {
>+        SWAP_32( pname );
>+    }
>+
>+    compsize = __glLightfv_size(pname);
>+    return __GLX_PAD((compsize * 4));
>+}
>+
>+int
>+__glXLightModelfvReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLenum pname       = * (GLenum *)(pc + 0);
>+    GLsizei compsize;
>+
>+    if (swap) {
>+        SWAP_32( pname );
>+    }
>+
>+    compsize = __glLightModelfv_size(pname);
>+    return __GLX_PAD((compsize * 4));
>+}
>+
>+int
>+__glXMaterialfvReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLenum pname       = * (GLenum *)(pc + 4);
>+    GLsizei compsize;
>+
>+    if (swap) {
>+        SWAP_32( pname );
>+    }
>+
>+    compsize = __glMaterialfv_size(pname);
>+    return __GLX_PAD((compsize * 4));
>+}
>+
>+int
>+__glXPolygonStippleReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLint row_length   = *  (GLint *)(pc +  4);
>+    GLint image_height = 0;
>+    GLint skip_images  = 0;
>+    GLint skip_rows    = *  (GLint *)(pc +  8);
>+    GLint alignment    = *  (GLint *)(pc + 16);
>+
>+    if (swap) {
>+        SWAP_32( row_length );
>+        SWAP_32( skip_rows );
>+        SWAP_32( alignment );
>+    }
>+
>+    return __glXImageSize(GL_COLOR_INDEX, GL_BITMAP, 0, 32, 32, 1,
>+                          image_height, row_length, skip_images,
>+                          skip_rows, alignment);
>+}
>+
>+int
>+__glXTexParameterfvReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLenum pname       = * (GLenum *)(pc + 4);
>+    GLsizei compsize;
>+
>+    if (swap) {
>+        SWAP_32( pname );
>+    }
>+
>+    compsize = __glTexParameterfv_size(pname);
>+    return __GLX_PAD((compsize * 4));
>+}
>+
>+int
>+__glXTexImage1DReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLint row_length   = *  (GLint *)(pc +  4);
>+    GLint image_height = 0;
>+    GLint skip_images  = 0;
>+    GLint skip_rows    = *  (GLint *)(pc +  8);
>+    GLint alignment    = *  (GLint *)(pc + 16);
>+    GLenum target      = * (GLenum *)(pc + 20);
>+    GLsizei width      = *(GLsizei *)(pc + 32);
>+    GLenum format      = * (GLenum *)(pc + 44);
>+    GLenum type        = * (GLenum *)(pc + 48);
>+
>+    if (swap) {
>+        SWAP_32( row_length );
>+        SWAP_32( skip_rows );
>+        SWAP_32( alignment );
>+        SWAP_32( target );
>+        SWAP_32( width );
>+        SWAP_32( format );
>+        SWAP_32( type );
>+    }
>+
>+    return __glXImageSize(format, type, target, width, 1, 1,
>+                          image_height, row_length, skip_images,
>+                          skip_rows, alignment);
>+}
>+
>+int
>+__glXTexImage2DReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLint row_length   = *  (GLint *)(pc +  4);
>+    GLint image_height = 0;
>+    GLint skip_images  = 0;
>+    GLint skip_rows    = *  (GLint *)(pc +  8);
>+    GLint alignment    = *  (GLint *)(pc + 16);
>+    GLenum target      = * (GLenum *)(pc + 20);
>+    GLsizei width      = *(GLsizei *)(pc + 32);
>+    GLsizei height     = *(GLsizei *)(pc + 36);
>+    GLenum format      = * (GLenum *)(pc + 44);
>+    GLenum type        = * (GLenum *)(pc + 48);
>+
>+    if (swap) {
>+        SWAP_32( row_length );
>+        SWAP_32( skip_rows );
>+        SWAP_32( alignment );
>+        SWAP_32( target );
>+        SWAP_32( width );
>+        SWAP_32( height );
>+        SWAP_32( format );
>+        SWAP_32( type );
>+    }
>+
>+    return __glXImageSize(format, type, target, width, height, 1,
>+                          image_height, row_length, skip_images,
>+                          skip_rows, alignment);
>+}
>+
>+int
>+__glXTexEnvfvReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLenum pname       = * (GLenum *)(pc + 4);
>+    GLsizei compsize;
>+
>+    if (swap) {
>+        SWAP_32( pname );
>+    }
>+
>+    compsize = __glTexEnvfv_size(pname);
>+    return __GLX_PAD((compsize * 4));
>+}
>+
>+int
>+__glXTexGendvReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLenum pname       = * (GLenum *)(pc + 4);
>+    GLsizei compsize;
>+
>+    if (swap) {
>+        SWAP_32( pname );
>+    }
>+
>+    compsize = __glTexGendv_size(pname);
>+    return __GLX_PAD((compsize * 8));
>+}
>+
>+int
>+__glXTexGenfvReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLenum pname       = * (GLenum *)(pc + 4);
>+    GLsizei compsize;
>+
>+    if (swap) {
>+        SWAP_32( pname );
>+    }
>+
>+    compsize = __glTexGenfv_size(pname);
>+    return __GLX_PAD((compsize * 4));
>+}
>+
>+int
>+__glXPixelMapfvReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLsizei mapsize    = *(GLsizei *)(pc + 4);
>+
>+    if (swap) {
>+        SWAP_32( mapsize );
>+    }
>+
>+    return __GLX_PAD((mapsize * 4));
>+}
>+
>+int
>+__glXPixelMapusvReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLsizei mapsize    = *(GLsizei *)(pc + 4);
>+
>+    if (swap) {
>+        SWAP_32( mapsize );
>+    }
>+
>+    return __GLX_PAD((mapsize * 2));
>+}
>+
>+int
>+__glXDrawPixelsReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLint row_length   = *  (GLint *)(pc +  4);
>+    GLint image_height = 0;
>+    GLint skip_images  = 0;
>+    GLint skip_rows    = *  (GLint *)(pc +  8);
>+    GLint alignment    = *  (GLint *)(pc + 16);
>+    GLsizei width      = *(GLsizei *)(pc + 20);
>+    GLsizei height     = *(GLsizei *)(pc + 24);
>+    GLenum format      = * (GLenum *)(pc + 28);
>+    GLenum type        = * (GLenum *)(pc + 32);
>+
>+    if (swap) {
>+        SWAP_32( row_length );
>+        SWAP_32( skip_rows );
>+        SWAP_32( alignment );
>+        SWAP_32( width );
>+        SWAP_32( height );
>+        SWAP_32( format );
>+        SWAP_32( type );
>+    }
>+
>+    return __glXImageSize(format, type, 0, width, height, 1,
>+                          image_height, row_length, skip_images,
>+                          skip_rows, alignment);
>+}
>+
>+int
>+__glXPrioritizeTexturesReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLsizei n          = *(GLsizei *)(pc + 0);
>+
>+    if (swap) {
>+        SWAP_32( n );
>+    }
>+
>+    return __GLX_PAD((n * 4) + (n * 4));
>+}
>+
>+int
>+__glXTexSubImage1DReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLint row_length   = *  (GLint *)(pc +  4);
>+    GLint image_height = 0;
>+    GLint skip_images  = 0;
>+    GLint skip_rows    = *  (GLint *)(pc +  8);
>+    GLint alignment    = *  (GLint *)(pc + 16);
>+    GLenum target      = * (GLenum *)(pc + 20);
>+    GLsizei width      = *(GLsizei *)(pc + 36);
>+    GLenum format      = * (GLenum *)(pc + 44);
>+    GLenum type        = * (GLenum *)(pc + 48);
>+
>+    if (swap) {
>+        SWAP_32( row_length );
>+        SWAP_32( skip_rows );
>+        SWAP_32( alignment );
>+        SWAP_32( target );
>+        SWAP_32( width );
>+        SWAP_32( format );
>+        SWAP_32( type );
>+    }
>+
>+    return __glXImageSize(format, type, target, width, 1, 1,
>+                          image_height, row_length, skip_images,
>+                          skip_rows, alignment);
>+}
>+
>+int
>+__glXTexSubImage2DReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLint row_length   = *  (GLint *)(pc +  4);
>+    GLint image_height = 0;
>+    GLint skip_images  = 0;
>+    GLint skip_rows    = *  (GLint *)(pc +  8);
>+    GLint alignment    = *  (GLint *)(pc + 16);
>+    GLenum target      = * (GLenum *)(pc + 20);
>+    GLsizei width      = *(GLsizei *)(pc + 36);
>+    GLsizei height     = *(GLsizei *)(pc + 40);
>+    GLenum format      = * (GLenum *)(pc + 44);
>+    GLenum type        = * (GLenum *)(pc + 48);
>+
>+    if (swap) {
>+        SWAP_32( row_length );
>+        SWAP_32( skip_rows );
>+        SWAP_32( alignment );
>+        SWAP_32( target );
>+        SWAP_32( width );
>+        SWAP_32( height );
>+        SWAP_32( format );
>+        SWAP_32( type );
>+    }
>+
>+    return __glXImageSize(format, type, target, width, height, 1,
>+                          image_height, row_length, skip_images,
>+                          skip_rows, alignment);
>+}
>+
>+int
>+__glXColorTableReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLint row_length   = *  (GLint *)(pc +  4);
>+    GLint image_height = 0;
>+    GLint skip_images  = 0;
>+    GLint skip_rows    = *  (GLint *)(pc +  8);
>+    GLint alignment    = *  (GLint *)(pc + 16);
>+    GLenum target      = * (GLenum *)(pc + 20);
>+    GLsizei width      = *(GLsizei *)(pc + 28);
>+    GLenum format      = * (GLenum *)(pc + 32);
>+    GLenum type        = * (GLenum *)(pc + 36);
>+
>+    if (swap) {
>+        SWAP_32( row_length );
>+        SWAP_32( skip_rows );
>+        SWAP_32( alignment );
>+        SWAP_32( target );
>+        SWAP_32( width );
>+        SWAP_32( format );
>+        SWAP_32( type );
>+    }
>+
>+    return __glXImageSize(format, type, target, width, 1, 1,
>+                          image_height, row_length, skip_images,
>+                          skip_rows, alignment);
>+}
>+
>+int
>+__glXColorTableParameterfvReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLenum pname       = * (GLenum *)(pc + 4);
>+    GLsizei compsize;
>+
>+    if (swap) {
>+        SWAP_32( pname );
>+    }
>+
>+    compsize = __glColorTableParameterfv_size(pname);
>+    return __GLX_PAD((compsize * 4));
>+}
>+
>+int
>+__glXColorSubTableReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLint row_length   = *  (GLint *)(pc +  4);
>+    GLint image_height = 0;
>+    GLint skip_images  = 0;
>+    GLint skip_rows    = *  (GLint *)(pc +  8);
>+    GLint alignment    = *  (GLint *)(pc + 16);
>+    GLenum target      = * (GLenum *)(pc + 20);
>+    GLsizei count      = *(GLsizei *)(pc + 28);
>+    GLenum format      = * (GLenum *)(pc + 32);
>+    GLenum type        = * (GLenum *)(pc + 36);
>+
>+    if (swap) {
>+        SWAP_32( row_length );
>+        SWAP_32( skip_rows );
>+        SWAP_32( alignment );
>+        SWAP_32( target );
>+        SWAP_32( count );
>+        SWAP_32( format );
>+        SWAP_32( type );
>+    }
>+
>+    return __glXImageSize(format, type, target, count, 1, 1,
>+                          image_height, row_length, skip_images,
>+                          skip_rows, alignment);
>+}
>+
>+int
>+__glXConvolutionFilter1DReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLint row_length   = *  (GLint *)(pc +  4);
>+    GLint image_height = 0;
>+    GLint skip_images  = 0;
>+    GLint skip_rows    = *  (GLint *)(pc +  8);
>+    GLint alignment    = *  (GLint *)(pc + 16);
>+    GLenum target      = * (GLenum *)(pc + 20);
>+    GLsizei width      = *(GLsizei *)(pc + 28);
>+    GLenum format      = * (GLenum *)(pc + 36);
>+    GLenum type        = * (GLenum *)(pc + 40);
>+
>+    if (swap) {
>+        SWAP_32( row_length );
>+        SWAP_32( skip_rows );
>+        SWAP_32( alignment );
>+        SWAP_32( target );
>+        SWAP_32( width );
>+        SWAP_32( format );
>+        SWAP_32( type );
>+    }
>+
>+    return __glXImageSize(format, type, target, width, 1, 1,
>+                          image_height, row_length, skip_images,
>+                          skip_rows, alignment);
>+}
>+
>+int
>+__glXConvolutionFilter2DReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLint row_length   = *  (GLint *)(pc +  4);
>+    GLint image_height = 0;
>+    GLint skip_images  = 0;
>+    GLint skip_rows    = *  (GLint *)(pc +  8);
>+    GLint alignment    = *  (GLint *)(pc + 16);
>+    GLenum target      = * (GLenum *)(pc + 20);
>+    GLsizei width      = *(GLsizei *)(pc + 28);
>+    GLsizei height     = *(GLsizei *)(pc + 32);
>+    GLenum format      = * (GLenum *)(pc + 36);
>+    GLenum type        = * (GLenum *)(pc + 40);
>+
>+    if (swap) {
>+        SWAP_32( row_length );
>+        SWAP_32( skip_rows );
>+        SWAP_32( alignment );
>+        SWAP_32( target );
>+        SWAP_32( width );
>+        SWAP_32( height );
>+        SWAP_32( format );
>+        SWAP_32( type );
>+    }
>+
>+    return __glXImageSize(format, type, target, width, height, 1,
>+                          image_height, row_length, skip_images,
>+                          skip_rows, alignment);
>+}
>+
>+int
>+__glXConvolutionParameterfvReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLenum pname       = * (GLenum *)(pc + 4);
>+    GLsizei compsize;
>+
>+    if (swap) {
>+        SWAP_32( pname );
>+    }
>+
>+    compsize = __glConvolutionParameterfv_size(pname);
>+    return __GLX_PAD((compsize * 4));
>+}
>+
>+int
>+__glXTexImage3DReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLint row_length   = *  (GLint *)(pc +  4);
>+    GLint image_height = *  (GLint *)(pc +  8);
>+    GLint skip_rows    = *  (GLint *)(pc + 16);
>+    GLint skip_images  = *  (GLint *)(pc + 20);
>+    GLint alignment    = *  (GLint *)(pc + 32);
>+    GLenum target      = * (GLenum *)(pc + 36);
>+    GLsizei width      = *(GLsizei *)(pc + 48);
>+    GLsizei height     = *(GLsizei *)(pc + 52);
>+    GLsizei depth      = *(GLsizei *)(pc + 56);
>+    GLenum format      = * (GLenum *)(pc + 68);
>+    GLenum type        = * (GLenum *)(pc + 72);
>+
>+    if (swap) {
>+        SWAP_32( row_length );
>+        SWAP_32( image_height );
>+        SWAP_32( skip_rows );
>+        SWAP_32( skip_images );
>+        SWAP_32( alignment );
>+        SWAP_32( target );
>+        SWAP_32( width );
>+        SWAP_32( height );
>+        SWAP_32( depth );
>+        SWAP_32( format );
>+        SWAP_32( type );
>+    }
>+
>+    return __glXImageSize(format, type, target, width, height, depth,
>+                          image_height, row_length, skip_images,
>+                          skip_rows, alignment);
>+}
>+
>+int
>+__glXTexSubImage3DReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLint row_length   = *  (GLint *)(pc +  4);
>+    GLint image_height = *  (GLint *)(pc +  8);
>+    GLint skip_rows    = *  (GLint *)(pc + 16);
>+    GLint skip_images  = *  (GLint *)(pc + 20);
>+    GLint alignment    = *  (GLint *)(pc + 32);
>+    GLenum target      = * (GLenum *)(pc + 36);
>+    GLsizei width      = *(GLsizei *)(pc + 60);
>+    GLsizei height     = *(GLsizei *)(pc + 64);
>+    GLsizei depth      = *(GLsizei *)(pc + 68);
>+    GLenum format      = * (GLenum *)(pc + 76);
>+    GLenum type        = * (GLenum *)(pc + 80);
>+
>+    if (swap) {
>+        SWAP_32( row_length );
>+        SWAP_32( image_height );
>+        SWAP_32( skip_rows );
>+        SWAP_32( skip_images );
>+        SWAP_32( alignment );
>+        SWAP_32( target );
>+        SWAP_32( width );
>+        SWAP_32( height );
>+        SWAP_32( depth );
>+        SWAP_32( format );
>+        SWAP_32( type );
>+    }
>+
>+    return __glXImageSize(format, type, target, width, height, depth,
>+                          image_height, row_length, skip_images,
>+                          skip_rows, alignment);
>+}
>+
>+int
>+__glXDrawBuffersARBReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLsizei n          = *(GLsizei *)(pc + 0);
>+
>+    if (swap) {
>+        SWAP_32( n );
>+    }
>+
>+    return __GLX_PAD((n * 4));
>+}
>+
>+int
>+__glXPointParameterfvEXTReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLenum pname       = * (GLenum *)(pc + 0);
>+    GLsizei compsize;
>+
>+    if (swap) {
>+        SWAP_32( pname );
>+    }
>+
>+    compsize = __glPointParameterfvEXT_size(pname);
>+    return __GLX_PAD((compsize * 4));
>+}
>+
>+int
>+__glXCompressedTexImage3DARBReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLsizei imageSize  = *(GLsizei *)(pc + 28);
>+
>+    if (swap) {
>+        SWAP_32( imageSize );
>+    }
>+
>+    return __GLX_PAD(imageSize);
>+}
>+
>+int
>+__glXCompressedTexImage2DARBReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLsizei imageSize  = *(GLsizei *)(pc + 24);
>+
>+    if (swap) {
>+        SWAP_32( imageSize );
>+    }
>+
>+    return __GLX_PAD(imageSize);
>+}
>+
>+int
>+__glXCompressedTexImage1DARBReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLsizei imageSize  = *(GLsizei *)(pc + 20);
>+
>+    if (swap) {
>+        SWAP_32( imageSize );
>+    }
>+
>+    return __GLX_PAD(imageSize);
>+}
>+
>+int
>+__glXCompressedTexSubImage3DARBReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLsizei imageSize  = *(GLsizei *)(pc + 36);
>+
>+    if (swap) {
>+        SWAP_32( imageSize );
>+    }
>+
>+    return __GLX_PAD(imageSize);
>+}
>+
>+int
>+__glXLoadProgramNVReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLsizei len        = *(GLsizei *)(pc + 8);
>+
>+    if (swap) {
>+        SWAP_32( len );
>+    }
>+
>+    return __GLX_PAD(len);
>+}
>+
>+int
>+__glXProgramParameters4dvNVReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLuint num         = * (GLuint *)(pc + 8);
>+
>+    if (swap) {
>+        SWAP_32( num );
>+    }
>+
>+    return __GLX_PAD((num * 32));
>+}
>+
>+int
>+__glXProgramParameters4fvNVReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLuint num         = * (GLuint *)(pc + 8);
>+
>+    if (swap) {
>+        SWAP_32( num );
>+    }
>+
>+    return __GLX_PAD((num * 16));
>+}
>+
>+int
>+__glXVertexAttribs1dvNVReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLsizei n          = *(GLsizei *)(pc + 4);
>+
>+    if (swap) {
>+        SWAP_32( n );
>+    }
>+
>+    return __GLX_PAD((n * 8));
>+}
>+
>+int
>+__glXVertexAttribs2dvNVReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLsizei n          = *(GLsizei *)(pc + 4);
>+
>+    if (swap) {
>+        SWAP_32( n );
>+    }
>+
>+    return __GLX_PAD((n * 16));
>+}
>+
>+int
>+__glXVertexAttribs3dvNVReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLsizei n          = *(GLsizei *)(pc + 4);
>+
>+    if (swap) {
>+        SWAP_32( n );
>+    }
>+
>+    return __GLX_PAD((n * 24));
>+}
>+
>+int
>+__glXVertexAttribs3fvNVReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLsizei n          = *(GLsizei *)(pc + 4);
>+
>+    if (swap) {
>+        SWAP_32( n );
>+    }
>+
>+    return __GLX_PAD((n * 12));
>+}
>+
>+int
>+__glXVertexAttribs3svNVReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLsizei n          = *(GLsizei *)(pc + 4);
>+
>+    if (swap) {
>+        SWAP_32( n );
>+    }
>+
>+    return __GLX_PAD((n * 6));
>+}
>+
>+int
>+__glXVertexAttribs4dvNVReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLsizei n          = *(GLsizei *)(pc + 4);
>+
>+    if (swap) {
>+        SWAP_32( n );
>+    }
>+
>+    return __GLX_PAD((n * 32));
>+}
>+
>+int
>+__glXProgramNamedParameter4fvNVReqSize( const GLbyte * pc, Bool swap )
>+{
>+    GLsizei len        = *(GLsizei *)(pc + 4);
>+
>+    if (swap) {
>+        SWAP_32( len );
>+    }
>+
>+    return __GLX_PAD(len);
>+}
>+
>+ALIAS( Fogiv, Fogfv )
>+ALIAS( Lightiv, Lightfv )
>+ALIAS( LightModeliv, LightModelfv )
>+ALIAS( Materialiv, Materialfv )
>+ALIAS( TexParameteriv, TexParameterfv )
>+ALIAS( TexEnviv, TexEnvfv )
>+ALIAS( TexGeniv, TexGenfv )
>+ALIAS( PixelMapuiv, PixelMapfv )
>+ALIAS( ColorTableParameteriv, ColorTableParameterfv )
>+ALIAS( ConvolutionParameteriv, ConvolutionParameterfv )
>+ALIAS( CompressedTexSubImage2DARB, CompressedTexImage3DARB )
>+ALIAS( CompressedTexSubImage1DARB, CompressedTexImage1DARB )
>+ALIAS( RequestResidentProgramsNV, DrawBuffersARB )
>+ALIAS( VertexAttribs1fvNV, PixelMapfv )
>+ALIAS( VertexAttribs1svNV, PixelMapusv )
>+ALIAS( VertexAttribs2fvNV, VertexAttribs1dvNV )
>+ALIAS( VertexAttribs2svNV, PixelMapfv )
>+ALIAS( VertexAttribs4fvNV, VertexAttribs2dvNV )
>+ALIAS( VertexAttribs4svNV, VertexAttribs1dvNV )
>+ALIAS( VertexAttribs4ubvNV, PixelMapfv )
>+ALIAS( PointParameterivNV, PointParameterfvEXT )
>+ALIAS( ProgramStringARB, LoadProgramNV )
>+ALIAS( ProgramNamedParameter4dvNV, CompressedTexSubImage3DARB )
>+ALIAS( DeleteRenderbuffersEXT, DrawBuffersARB )
>+ALIAS( DeleteFramebuffersEXT, DrawBuffersARB )
>Index: xorg/GL/glx/indirect_reqsize.h
>===================================================================
>RCS file: xorg/GL/glx/indirect_reqsize.h
>diff -N xorg/GL/glx/indirect_reqsize.h
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ xorg/GL/glx/indirect_reqsize.h	12 Jan 2006 00:04:17 -0000
>@@ -0,0 +1,121 @@
>+/* DO NOT EDIT - This file generated automatically by glX_proto_size.py (from Mesa) script */
>+
>+/*
>+ * (C) Copyright IBM Corporation 2005
>+ * 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
>+ * IBM,
>+ * 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.
>+ */
>+
>+#if !defined( _INDIRECT_REQSIZE_H_ )
>+#  define _INDIRECT_REQSIZE_H_
>+
>+#  if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__)
>+#    define HIDDEN  __attribute__((visibility("hidden")))
>+#  else
>+#    define HIDDEN
>+#  endif
>+
>+#  if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
>+#    define PURE __attribute__((pure))
>+#  else
>+#    define PURE
>+#  endif
>+
>+extern PURE HIDDEN int __glXCallListsReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXBitmapReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXFogfvReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXFogivReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXLightfvReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXLightivReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXLightModelfvReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXLightModelivReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXMaterialfvReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXMaterialivReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXPolygonStippleReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXTexParameterfvReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXTexParameterivReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXTexImage1DReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXTexImage2DReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXTexEnvfvReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXTexEnvivReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXTexGendvReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXTexGenfvReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXTexGenivReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXMap1dReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXMap1fReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXMap2dReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXMap2fReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXPixelMapfvReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXPixelMapuivReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXPixelMapusvReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXDrawPixelsReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXDrawArraysReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXPrioritizeTexturesReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXTexSubImage1DReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXTexSubImage2DReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXColorTableReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXColorTableParameterfvReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXColorTableParameterivReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXColorSubTableReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXConvolutionFilter1DReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXConvolutionFilter2DReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXConvolutionParameterfvReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXConvolutionParameterivReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXSeparableFilter2DReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXTexImage3DReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXTexSubImage3DReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXDrawBuffersARBReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXPointParameterfvEXTReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXCompressedTexImage3DARBReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXCompressedTexImage2DARBReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXCompressedTexImage1DARBReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXCompressedTexSubImage3DARBReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXCompressedTexSubImage2DARBReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXCompressedTexSubImage1DARBReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXLoadProgramNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXProgramParameters4dvNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXProgramParameters4fvNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXRequestResidentProgramsNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXVertexAttribs1dvNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXVertexAttribs1fvNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXVertexAttribs1svNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXVertexAttribs2dvNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXVertexAttribs2fvNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXVertexAttribs2svNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXVertexAttribs3dvNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXVertexAttribs3fvNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXVertexAttribs3svNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXVertexAttribs4dvNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXVertexAttribs4fvNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXVertexAttribs4svNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXVertexAttribs4ubvNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXPointParameterivNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXProgramStringARBReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXProgramNamedParameter4fvNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXProgramNamedParameter4dvNVReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXDeleteRenderbuffersEXTReqSize(const GLbyte *pc, Bool swap);
>+extern PURE HIDDEN int __glXDeleteFramebuffersEXTReqSize(const GLbyte *pc, Bool swap);
>+
>+#  undef HIDDEN
>+#  undef PURE
>+
>+#endif /* !defined( _INDIRECT_REQSIZE_H_ ) */
>Index: xorg/GL/glx/indirect_size_get.c
>===================================================================
>RCS file: xorg/GL/glx/indirect_size_get.c
>diff -N xorg/GL/glx/indirect_size_get.c
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ xorg/GL/glx/indirect_size_get.c	12 Jan 2006 00:04:17 -0000
>@@ -0,0 +1,1161 @@
>+/* DO NOT EDIT - This file generated automatically by glX_proto_size.py (from Mesa) script */
>+
>+/*
>+ * (C) Copyright IBM Corporation 2004
>+ * 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
>+ * IBM,
>+ * 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 <GL/gl.h>
>+#include "indirect_size_get.h"
>+#include "indirect_size.h"
>+
>+#  if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
>+#    define PURE __attribute__((pure))
>+#  else
>+#    define PURE
>+#  endif
>+
>+#  if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined(__MINGW32__)
>+#    define FASTCALL __attribute__((fastcall))
>+#  else
>+#    define FASTCALL
>+#  endif
>+
>+#  if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__)
>+#    define INTERNAL  __attribute__((visibility("internal")))
>+#  else
>+#    define INTERNAL
>+#  endif
>+
>+
>+#if defined(__CYGWIN__) || defined(__MINGW32__) || defined(__APPLE__)
>+#  undef HAVE_ALIAS
>+#endif
>+#ifdef HAVE_ALIAS
>+#  define ALIAS2(from,to) \
>+    INTERNAL PURE FASTCALL GLint __gl ## from ## _size( GLenum e ) \
>+        __attribute__ ((alias( # to )));
>+#  define ALIAS(from,to) ALIAS2( from, __gl ## to ## _size )
>+#else
>+#  define ALIAS(from,to) \
>+    INTERNAL PURE FASTCALL GLint __gl ## from ## _size( GLenum e ) \
>+    { return __gl ## to ## _size( e ); }
>+#endif
>+
>+
>+INTERNAL PURE FASTCALL GLint
>+__glCallLists_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_BYTE:
>+        case GL_UNSIGNED_BYTE:
>+            return 1;
>+        case GL_SHORT:
>+        case GL_UNSIGNED_SHORT:
>+        case GL_2_BYTES:
>+            return 2;
>+        case GL_3_BYTES:
>+            return 3;
>+        case GL_INT:
>+        case GL_UNSIGNED_INT:
>+        case GL_FLOAT:
>+        case GL_4_BYTES:
>+            return 4;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glFogfv_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_FOG_INDEX:
>+        case GL_FOG_DENSITY:
>+        case GL_FOG_START:
>+        case GL_FOG_END:
>+        case GL_FOG_MODE:
>+        case GL_FOG_OFFSET_VALUE_SGIX:
>+        case GL_FOG_DISTANCE_MODE_NV:
>+            return 1;
>+        case GL_FOG_COLOR:
>+            return 4;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glLightfv_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_SPOT_EXPONENT:
>+        case GL_SPOT_CUTOFF:
>+        case GL_CONSTANT_ATTENUATION:
>+        case GL_LINEAR_ATTENUATION:
>+        case GL_QUADRATIC_ATTENUATION:
>+            return 1;
>+        case GL_SPOT_DIRECTION:
>+            return 3;
>+        case GL_AMBIENT:
>+        case GL_DIFFUSE:
>+        case GL_SPECULAR:
>+        case GL_POSITION:
>+            return 4;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glLightModelfv_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_LIGHT_MODEL_LOCAL_VIEWER:
>+        case GL_LIGHT_MODEL_TWO_SIDE:
>+        case GL_LIGHT_MODEL_COLOR_CONTROL:
>+/*      case GL_LIGHT_MODEL_COLOR_CONTROL_EXT:*/
>+            return 1;
>+        case GL_LIGHT_MODEL_AMBIENT:
>+            return 4;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glMaterialfv_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_SHININESS:
>+            return 1;
>+        case GL_COLOR_INDEXES:
>+            return 3;
>+        case GL_AMBIENT:
>+        case GL_DIFFUSE:
>+        case GL_SPECULAR:
>+        case GL_EMISSION:
>+        case GL_AMBIENT_AND_DIFFUSE:
>+            return 4;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glTexParameterfv_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_TEXTURE_MAG_FILTER:
>+        case GL_TEXTURE_MIN_FILTER:
>+        case GL_TEXTURE_WRAP_S:
>+        case GL_TEXTURE_WRAP_T:
>+        case GL_TEXTURE_PRIORITY:
>+        case GL_TEXTURE_WRAP_R:
>+        case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
>+/*      case GL_SHADOW_AMBIENT_SGIX:*/
>+        case GL_TEXTURE_MIN_LOD:
>+        case GL_TEXTURE_MAX_LOD:
>+        case GL_TEXTURE_BASE_LEVEL:
>+        case GL_TEXTURE_MAX_LEVEL:
>+        case GL_TEXTURE_CLIPMAP_FRAME_SGIX:
>+        case GL_TEXTURE_LOD_BIAS_S_SGIX:
>+        case GL_TEXTURE_LOD_BIAS_T_SGIX:
>+        case GL_TEXTURE_LOD_BIAS_R_SGIX:
>+        case GL_GENERATE_MIPMAP:
>+/*      case GL_GENERATE_MIPMAP_SGIS:*/
>+        case GL_TEXTURE_COMPARE_SGIX:
>+        case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
>+        case GL_TEXTURE_MAX_CLAMP_S_SGIX:
>+        case GL_TEXTURE_MAX_CLAMP_T_SGIX:
>+        case GL_TEXTURE_MAX_CLAMP_R_SGIX:
>+        case GL_TEXTURE_MAX_ANISOTROPY_EXT:
>+        case GL_TEXTURE_LOD_BIAS:
>+/*      case GL_TEXTURE_LOD_BIAS_EXT:*/
>+        case GL_DEPTH_TEXTURE_MODE:
>+/*      case GL_DEPTH_TEXTURE_MODE_ARB:*/
>+        case GL_TEXTURE_COMPARE_MODE:
>+/*      case GL_TEXTURE_COMPARE_MODE_ARB:*/
>+        case GL_TEXTURE_COMPARE_FUNC:
>+/*      case GL_TEXTURE_COMPARE_FUNC_ARB:*/
>+        case GL_TEXTURE_UNSIGNED_REMAP_MODE_NV:
>+            return 1;
>+        case GL_TEXTURE_CLIPMAP_CENTER_SGIX:
>+        case GL_TEXTURE_CLIPMAP_OFFSET_SGIX:
>+            return 2;
>+        case GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX:
>+            return 3;
>+        case GL_TEXTURE_BORDER_COLOR:
>+        case GL_POST_TEXTURE_FILTER_BIAS_SGIX:
>+        case GL_POST_TEXTURE_FILTER_SCALE_SGIX:
>+            return 4;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glTexEnvfv_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_ALPHA_SCALE:
>+        case GL_TEXTURE_ENV_MODE:
>+        case GL_TEXTURE_LOD_BIAS:
>+        case GL_COMBINE_RGB:
>+        case GL_COMBINE_ALPHA:
>+        case GL_RGB_SCALE:
>+        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:
>+        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:
>+        case GL_COORD_REPLACE_ARB:
>+/*      case GL_COORD_REPLACE_NV:*/
>+            return 1;
>+        case GL_TEXTURE_ENV_COLOR:
>+            return 4;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glTexGendv_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_TEXTURE_GEN_MODE:
>+            return 1;
>+        case GL_OBJECT_PLANE:
>+        case GL_EYE_PLANE:
>+            return 4;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glMap1d_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_MAP1_INDEX:
>+        case GL_MAP1_TEXTURE_COORD_1:
>+            return 1;
>+        case GL_MAP1_TEXTURE_COORD_2:
>+            return 2;
>+        case GL_MAP1_NORMAL:
>+        case GL_MAP1_TEXTURE_COORD_3:
>+        case GL_MAP1_VERTEX_3:
>+            return 3;
>+        case GL_MAP1_COLOR_4:
>+        case GL_MAP1_TEXTURE_COORD_4:
>+        case GL_MAP1_VERTEX_4:
>+            return 4;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glMap2d_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_MAP2_INDEX:
>+        case GL_MAP2_TEXTURE_COORD_1:
>+            return 1;
>+        case GL_MAP2_TEXTURE_COORD_2:
>+            return 2;
>+        case GL_MAP2_NORMAL:
>+        case GL_MAP2_TEXTURE_COORD_3:
>+        case GL_MAP2_VERTEX_3:
>+            return 3;
>+        case GL_MAP2_COLOR_4:
>+        case GL_MAP2_TEXTURE_COORD_4:
>+        case GL_MAP2_VERTEX_4:
>+            return 4;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glGetBooleanv_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_CURRENT_INDEX:
>+        case GL_CURRENT_RASTER_INDEX:
>+        case GL_CURRENT_RASTER_POSITION_VALID:
>+        case GL_CURRENT_RASTER_DISTANCE:
>+        case GL_POINT_SMOOTH:
>+        case GL_POINT_SIZE:
>+        case GL_SMOOTH_POINT_SIZE_GRANULARITY:
>+        case GL_LINE_SMOOTH:
>+        case GL_LINE_WIDTH:
>+        case GL_LINE_WIDTH_GRANULARITY:
>+        case GL_LINE_STIPPLE:
>+        case GL_LINE_STIPPLE_PATTERN:
>+        case GL_LINE_STIPPLE_REPEAT:
>+        case GL_LIST_MODE:
>+        case GL_MAX_LIST_NESTING:
>+        case GL_LIST_BASE:
>+        case GL_LIST_INDEX:
>+        case GL_POLYGON_SMOOTH:
>+        case GL_POLYGON_STIPPLE:
>+        case GL_EDGE_FLAG:
>+        case GL_CULL_FACE:
>+        case GL_CULL_FACE_MODE:
>+        case GL_FRONT_FACE:
>+        case GL_LIGHTING:
>+        case GL_LIGHT_MODEL_LOCAL_VIEWER:
>+        case GL_LIGHT_MODEL_TWO_SIDE:
>+        case GL_SHADE_MODEL:
>+        case GL_COLOR_MATERIAL_FACE:
>+        case GL_COLOR_MATERIAL_PARAMETER:
>+        case GL_COLOR_MATERIAL:
>+        case GL_FOG:
>+        case GL_FOG_INDEX:
>+        case GL_FOG_DENSITY:
>+        case GL_FOG_START:
>+        case GL_FOG_END:
>+        case GL_FOG_MODE:
>+        case GL_DEPTH_TEST:
>+        case GL_DEPTH_WRITEMASK:
>+        case GL_DEPTH_CLEAR_VALUE:
>+        case GL_DEPTH_FUNC:
>+        case GL_STENCIL_TEST:
>+        case GL_STENCIL_CLEAR_VALUE:
>+        case GL_STENCIL_FUNC:
>+        case GL_STENCIL_VALUE_MASK:
>+        case GL_STENCIL_FAIL:
>+        case GL_STENCIL_PASS_DEPTH_FAIL:
>+        case GL_STENCIL_PASS_DEPTH_PASS:
>+        case GL_STENCIL_REF:
>+        case GL_STENCIL_WRITEMASK:
>+        case GL_MATRIX_MODE:
>+        case GL_NORMALIZE:
>+        case GL_MODELVIEW_STACK_DEPTH:
>+        case GL_PROJECTION_STACK_DEPTH:
>+        case GL_TEXTURE_STACK_DEPTH:
>+        case GL_ATTRIB_STACK_DEPTH:
>+        case GL_ALPHA_TEST:
>+        case GL_ALPHA_TEST_FUNC:
>+        case GL_ALPHA_TEST_REF:
>+        case GL_DITHER:
>+        case GL_BLEND_DST:
>+        case GL_BLEND_SRC:
>+        case GL_BLEND:
>+        case GL_LOGIC_OP_MODE:
>+        case GL_LOGIC_OP:
>+        case GL_AUX_BUFFERS:
>+        case GL_DRAW_BUFFER:
>+        case GL_READ_BUFFER:
>+        case GL_SCISSOR_TEST:
>+        case GL_INDEX_CLEAR_VALUE:
>+        case GL_INDEX_WRITEMASK:
>+        case GL_INDEX_MODE:
>+        case GL_RGBA_MODE:
>+        case GL_DOUBLEBUFFER:
>+        case GL_STEREO:
>+        case GL_RENDER_MODE:
>+        case GL_PERSPECTIVE_CORRECTION_HINT:
>+        case GL_POINT_SMOOTH_HINT:
>+        case GL_LINE_SMOOTH_HINT:
>+        case GL_POLYGON_SMOOTH_HINT:
>+        case GL_FOG_HINT:
>+        case GL_TEXTURE_GEN_S:
>+        case GL_TEXTURE_GEN_T:
>+        case GL_TEXTURE_GEN_R:
>+        case GL_TEXTURE_GEN_Q:
>+        case GL_PIXEL_MAP_I_TO_I:
>+        case GL_PIXEL_MAP_I_TO_I_SIZE:
>+        case GL_PIXEL_MAP_S_TO_S_SIZE:
>+        case GL_PIXEL_MAP_I_TO_R_SIZE:
>+        case GL_PIXEL_MAP_I_TO_G_SIZE:
>+        case GL_PIXEL_MAP_I_TO_B_SIZE:
>+        case GL_PIXEL_MAP_I_TO_A_SIZE:
>+        case GL_PIXEL_MAP_R_TO_R_SIZE:
>+        case GL_PIXEL_MAP_G_TO_G_SIZE:
>+        case GL_PIXEL_MAP_B_TO_B_SIZE:
>+        case GL_PIXEL_MAP_A_TO_A_SIZE:
>+        case GL_UNPACK_SWAP_BYTES:
>+        case GL_UNPACK_LSB_FIRST:
>+        case GL_UNPACK_ROW_LENGTH:
>+        case GL_UNPACK_SKIP_ROWS:
>+        case GL_UNPACK_SKIP_PIXELS:
>+        case GL_UNPACK_ALIGNMENT:
>+        case GL_PACK_SWAP_BYTES:
>+        case GL_PACK_LSB_FIRST:
>+        case GL_PACK_ROW_LENGTH:
>+        case GL_PACK_SKIP_ROWS:
>+        case GL_PACK_SKIP_PIXELS:
>+        case GL_PACK_ALIGNMENT:
>+        case GL_MAP_COLOR:
>+        case GL_MAP_STENCIL:
>+        case GL_INDEX_SHIFT:
>+        case GL_INDEX_OFFSET:
>+        case GL_RED_SCALE:
>+        case GL_RED_BIAS:
>+        case GL_ZOOM_X:
>+        case GL_ZOOM_Y:
>+        case GL_GREEN_SCALE:
>+        case GL_GREEN_BIAS:
>+        case GL_BLUE_SCALE:
>+        case GL_BLUE_BIAS:
>+        case GL_ALPHA_SCALE:
>+        case GL_ALPHA_BIAS:
>+        case GL_DEPTH_SCALE:
>+        case GL_DEPTH_BIAS:
>+        case GL_MAX_EVAL_ORDER:
>+        case GL_MAX_LIGHTS:
>+        case GL_MAX_CLIP_PLANES:
>+        case GL_MAX_TEXTURE_SIZE:
>+        case GL_MAX_PIXEL_MAP_TABLE:
>+        case GL_MAX_ATTRIB_STACK_DEPTH:
>+        case GL_MAX_MODELVIEW_STACK_DEPTH:
>+        case GL_MAX_NAME_STACK_DEPTH:
>+        case GL_MAX_PROJECTION_STACK_DEPTH:
>+        case GL_MAX_TEXTURE_STACK_DEPTH:
>+        case GL_SUBPIXEL_BITS:
>+        case GL_INDEX_BITS:
>+        case GL_RED_BITS:
>+        case GL_GREEN_BITS:
>+        case GL_BLUE_BITS:
>+        case GL_ALPHA_BITS:
>+        case GL_DEPTH_BITS:
>+        case GL_STENCIL_BITS:
>+        case GL_ACCUM_RED_BITS:
>+        case GL_ACCUM_GREEN_BITS:
>+        case GL_ACCUM_BLUE_BITS:
>+        case GL_ACCUM_ALPHA_BITS:
>+        case GL_NAME_STACK_DEPTH:
>+        case GL_AUTO_NORMAL:
>+        case GL_MAP1_COLOR_4:
>+        case GL_MAP1_INDEX:
>+        case GL_MAP1_NORMAL:
>+        case GL_MAP1_TEXTURE_COORD_1:
>+        case GL_MAP1_TEXTURE_COORD_2:
>+        case GL_MAP1_TEXTURE_COORD_3:
>+        case GL_MAP1_TEXTURE_COORD_4:
>+        case GL_MAP1_VERTEX_3:
>+        case GL_MAP1_VERTEX_4:
>+        case GL_MAP2_COLOR_4:
>+        case GL_MAP2_INDEX:
>+        case GL_MAP2_NORMAL:
>+        case GL_MAP2_TEXTURE_COORD_1:
>+        case GL_MAP2_TEXTURE_COORD_2:
>+        case GL_MAP2_TEXTURE_COORD_3:
>+        case GL_MAP2_TEXTURE_COORD_4:
>+        case GL_MAP2_VERTEX_3:
>+        case GL_MAP2_VERTEX_4:
>+        case GL_MAP1_GRID_SEGMENTS:
>+        case GL_TEXTURE_1D:
>+        case GL_TEXTURE_2D:
>+        case GL_POLYGON_OFFSET_UNITS:
>+        case GL_CLIP_PLANE0:
>+        case GL_CLIP_PLANE1:
>+        case GL_CLIP_PLANE2:
>+        case GL_CLIP_PLANE3:
>+        case GL_CLIP_PLANE4:
>+        case GL_CLIP_PLANE5:
>+        case GL_LIGHT0:
>+        case GL_LIGHT1:
>+        case GL_LIGHT2:
>+        case GL_LIGHT3:
>+        case GL_LIGHT4:
>+        case GL_LIGHT5:
>+        case GL_LIGHT6:
>+        case GL_LIGHT7:
>+        case GL_BLEND_EQUATION:
>+/*      case GL_BLEND_EQUATION_EXT:*/
>+        case GL_CONVOLUTION_1D:
>+        case GL_CONVOLUTION_2D:
>+        case GL_SEPARABLE_2D:
>+        case GL_MAX_CONVOLUTION_WIDTH:
>+/*      case GL_MAX_CONVOLUTION_WIDTH_EXT:*/
>+        case GL_MAX_CONVOLUTION_HEIGHT:
>+/*      case GL_MAX_CONVOLUTION_HEIGHT_EXT:*/
>+        case GL_POST_CONVOLUTION_RED_SCALE:
>+/*      case GL_POST_CONVOLUTION_RED_SCALE_EXT:*/
>+        case GL_POST_CONVOLUTION_GREEN_SCALE:
>+/*      case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:*/
>+        case GL_POST_CONVOLUTION_BLUE_SCALE:
>+/*      case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:*/
>+        case GL_POST_CONVOLUTION_ALPHA_SCALE:
>+/*      case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:*/
>+        case GL_POST_CONVOLUTION_RED_BIAS:
>+/*      case GL_POST_CONVOLUTION_RED_BIAS_EXT:*/
>+        case GL_POST_CONVOLUTION_GREEN_BIAS:
>+/*      case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:*/
>+        case GL_POST_CONVOLUTION_BLUE_BIAS:
>+/*      case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:*/
>+        case GL_POST_CONVOLUTION_ALPHA_BIAS:
>+/*      case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:*/
>+        case GL_HISTOGRAM:
>+        case GL_MINMAX:
>+        case GL_POLYGON_OFFSET_FACTOR:
>+        case GL_RESCALE_NORMAL:
>+/*      case GL_RESCALE_NORMAL_EXT:*/
>+        case GL_TEXTURE_BINDING_1D:
>+        case GL_TEXTURE_BINDING_2D:
>+        case GL_TEXTURE_BINDING_3D:
>+        case GL_PACK_SKIP_IMAGES:
>+        case GL_PACK_IMAGE_HEIGHT:
>+        case GL_UNPACK_SKIP_IMAGES:
>+        case GL_UNPACK_IMAGE_HEIGHT:
>+        case GL_TEXTURE_3D:
>+        case GL_VERTEX_ARRAY:
>+        case GL_NORMAL_ARRAY:
>+        case GL_COLOR_ARRAY:
>+        case GL_INDEX_ARRAY:
>+        case GL_TEXTURE_COORD_ARRAY:
>+        case GL_EDGE_FLAG_ARRAY:
>+        case GL_VERTEX_ARRAY_SIZE:
>+        case GL_VERTEX_ARRAY_TYPE:
>+        case GL_VERTEX_ARRAY_STRIDE:
>+        case GL_NORMAL_ARRAY_TYPE:
>+        case GL_NORMAL_ARRAY_STRIDE:
>+        case GL_COLOR_ARRAY_SIZE:
>+        case GL_COLOR_ARRAY_TYPE:
>+        case GL_COLOR_ARRAY_STRIDE:
>+        case GL_INDEX_ARRAY_TYPE:
>+        case GL_INDEX_ARRAY_STRIDE:
>+        case GL_TEXTURE_COORD_ARRAY_SIZE:
>+        case GL_TEXTURE_COORD_ARRAY_TYPE:
>+        case GL_TEXTURE_COORD_ARRAY_STRIDE:
>+        case GL_EDGE_FLAG_ARRAY_STRIDE:
>+        case GL_MULTISAMPLE:
>+/*      case GL_MULTISAMPLE_ARB:*/
>+        case GL_SAMPLE_ALPHA_TO_COVERAGE:
>+/*      case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:*/
>+        case GL_SAMPLE_ALPHA_TO_ONE:
>+/*      case GL_SAMPLE_ALPHA_TO_ONE_ARB:*/
>+        case GL_SAMPLE_COVERAGE:
>+/*      case GL_SAMPLE_COVERAGE_ARB:*/
>+        case GL_SAMPLE_BUFFERS:
>+/*      case GL_SAMPLE_BUFFERS_ARB:*/
>+        case GL_SAMPLES:
>+/*      case GL_SAMPLES_ARB:*/
>+        case GL_SAMPLE_COVERAGE_VALUE:
>+/*      case GL_SAMPLE_COVERAGE_VALUE_ARB:*/
>+        case GL_SAMPLE_COVERAGE_INVERT:
>+/*      case GL_SAMPLE_COVERAGE_INVERT_ARB:*/
>+        case GL_COLOR_MATRIX_STACK_DEPTH:
>+        case GL_MAX_COLOR_MATRIX_STACK_DEPTH:
>+        case GL_POST_COLOR_MATRIX_RED_SCALE:
>+        case GL_POST_COLOR_MATRIX_GREEN_SCALE:
>+        case GL_POST_COLOR_MATRIX_BLUE_SCALE:
>+        case GL_POST_COLOR_MATRIX_ALPHA_SCALE:
>+        case GL_POST_COLOR_MATRIX_RED_BIAS:
>+        case GL_POST_COLOR_MATRIX_GREEN_BIAS:
>+        case GL_POST_COLOR_MATRIX_BLUE_BIAS:
>+        case GL_POST_COLOR_MATRIX_ALPHA_BIAS:
>+        case GL_BLEND_DST_RGB:
>+        case GL_BLEND_SRC_RGB:
>+        case GL_BLEND_DST_ALPHA:
>+        case GL_BLEND_SRC_ALPHA:
>+        case GL_COLOR_TABLE:
>+        case GL_POST_CONVOLUTION_COLOR_TABLE:
>+        case GL_POST_COLOR_MATRIX_COLOR_TABLE:
>+        case GL_MAX_ELEMENTS_VERTICES:
>+        case GL_MAX_ELEMENTS_INDICES:
>+        case GL_CLIP_VOLUME_CLIPPING_HINT_EXT:
>+        case GL_OCCLUSION_TEST_HP:
>+        case GL_OCCLUSION_TEST_RESULT_HP:
>+        case GL_LIGHT_MODEL_COLOR_CONTROL:
>+        case GL_CURRENT_FOG_COORD:
>+        case GL_FOG_COORDINATE_ARRAY_TYPE:
>+        case GL_FOG_COORDINATE_ARRAY_STRIDE:
>+        case GL_FOG_COORD_ARRAY:
>+        case GL_COLOR_SUM_ARB:
>+        case GL_SECONDARY_COLOR_ARRAY_SIZE:
>+        case GL_SECONDARY_COLOR_ARRAY_TYPE:
>+        case GL_SECONDARY_COLOR_ARRAY_STRIDE:
>+        case GL_SECONDARY_COLOR_ARRAY:
>+        case GL_ACTIVE_TEXTURE:
>+/*      case GL_ACTIVE_TEXTURE_ARB:*/
>+        case GL_CLIENT_ACTIVE_TEXTURE:
>+/*      case GL_CLIENT_ACTIVE_TEXTURE_ARB:*/
>+        case GL_MAX_TEXTURE_UNITS:
>+/*      case GL_MAX_TEXTURE_UNITS_ARB:*/
>+        case GL_TEXTURE_COMPRESSION_HINT:
>+/*      case GL_TEXTURE_COMPRESSION_HINT_ARB:*/
>+        case GL_TEXTURE_RECTANGLE_ARB:
>+/*      case GL_TEXTURE_RECTANGLE_NV:*/
>+        case GL_TEXTURE_BINDING_RECTANGLE_ARB:
>+/*      case GL_TEXTURE_BINDING_RECTANGLE_NV:*/
>+        case GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB:
>+/*      case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:*/
>+        case GL_MAX_TEXTURE_LOD_BIAS:
>+        case GL_MAX_SHININESS_NV:
>+        case GL_MAX_SPOT_EXPONENT_NV:
>+        case GL_TEXTURE_CUBE_MAP:
>+/*      case GL_TEXTURE_CUBE_MAP_ARB:*/
>+        case GL_TEXTURE_BINDING_CUBE_MAP:
>+/*      case GL_TEXTURE_BINDING_CUBE_MAP_ARB:*/
>+        case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
>+/*      case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:*/
>+        case GL_MULTISAMPLE_FILTER_HINT_NV:
>+        case GL_FOG_DISTANCE_MODE_NV:
>+        case GL_VERTEX_PROGRAM_ARB:
>+        case GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB:
>+        case GL_MAX_PROGRAM_MATRICES_ARB:
>+        case GL_CURRENT_MATRIX_STACK_DEPTH_ARB:
>+        case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
>+        case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
>+        case GL_PROGRAM_ERROR_POSITION_ARB:
>+        case GL_DEPTH_CLAMP_NV:
>+        case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
>+/*      case GL_NUM_TEXTURE_COMPRESSED_FORMATS_ARB:*/
>+        case GL_MAX_VERTEX_UNITS_ARB:
>+        case GL_ACTIVE_VERTEX_UNITS_ARB:
>+        case GL_WEIGHT_SUM_UNITY_ARB:
>+        case GL_VERTEX_BLEND_ARB:
>+        case GL_CURRENT_WEIGHT_ARB:
>+        case GL_WEIGHT_ARRAY_TYPE_ARB:
>+        case GL_WEIGHT_ARRAY_STRIDE_ARB:
>+        case GL_WEIGHT_ARRAY_SIZE_ARB:
>+        case GL_WEIGHT_ARRAY_ARB:
>+        case GL_PACK_INVERT_MESA:
>+        case GL_FRAGMENT_PROGRAM_ARB:
>+        case GL_MAX_DRAW_BUFFERS_ARB:
>+/*      case GL_MAX_DRAW_BUFFERS_ATI:*/
>+        case GL_DRAW_BUFFER0_ARB:
>+/*      case GL_DRAW_BUFFER0_ATI:*/
>+        case GL_DRAW_BUFFER1_ARB:
>+/*      case GL_DRAW_BUFFER1_ATI:*/
>+        case GL_DRAW_BUFFER2_ARB:
>+/*      case GL_DRAW_BUFFER2_ATI:*/
>+        case GL_DRAW_BUFFER3_ARB:
>+/*      case GL_DRAW_BUFFER3_ATI:*/
>+        case GL_DRAW_BUFFER4_ARB:
>+/*      case GL_DRAW_BUFFER4_ATI:*/
>+        case GL_DRAW_BUFFER5_ARB:
>+/*      case GL_DRAW_BUFFER5_ATI:*/
>+        case GL_DRAW_BUFFER6_ARB:
>+/*      case GL_DRAW_BUFFER6_ATI:*/
>+        case GL_DRAW_BUFFER7_ARB:
>+/*      case GL_DRAW_BUFFER7_ATI:*/
>+        case GL_DRAW_BUFFER8_ARB:
>+/*      case GL_DRAW_BUFFER8_ATI:*/
>+        case GL_DRAW_BUFFER9_ARB:
>+/*      case GL_DRAW_BUFFER9_ATI:*/
>+        case GL_DRAW_BUFFER10_ARB:
>+/*      case GL_DRAW_BUFFER10_ATI:*/
>+        case GL_DRAW_BUFFER11_ARB:
>+/*      case GL_DRAW_BUFFER11_ATI:*/
>+        case GL_DRAW_BUFFER12_ARB:
>+/*      case GL_DRAW_BUFFER12_ATI:*/
>+        case GL_DRAW_BUFFER13_ARB:
>+/*      case GL_DRAW_BUFFER13_ATI:*/
>+        case GL_DRAW_BUFFER14_ARB:
>+/*      case GL_DRAW_BUFFER14_ATI:*/
>+        case GL_DRAW_BUFFER15_ARB:
>+/*      case GL_DRAW_BUFFER15_ATI:*/
>+        case GL_BLEND_EQUATION_ALPHA_EXT:
>+        case GL_MATRIX_PALETTE_ARB:
>+        case GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB:
>+        case GL_MAX_PALETTE_MATRICES_ARB:
>+        case GL_CURRENT_PALETTE_MATRIX_ARB:
>+        case GL_MATRIX_INDEX_ARRAY_ARB:
>+        case GL_CURRENT_MATRIX_INDEX_ARB:
>+        case GL_MATRIX_INDEX_ARRAY_SIZE_ARB:
>+        case GL_MATRIX_INDEX_ARRAY_TYPE_ARB:
>+        case GL_MATRIX_INDEX_ARRAY_STRIDE_ARB:
>+        case GL_POINT_SPRITE_ARB:
>+/*      case GL_POINT_SPRITE_NV:*/
>+        case GL_POINT_SPRITE_R_MODE_NV:
>+        case GL_MAX_VERTEX_ATTRIBS_ARB:
>+        case GL_DEPTH_BOUNDS_TEST_EXT:
>+        case GL_STENCIL_TEST_TWO_SIDE_EXT:
>+        case GL_ACTIVE_STENCIL_FACE_EXT:
>+        case GL_RASTER_POSITION_UNCLIPPED_IBM:
>+            return 1;
>+        case GL_SMOOTH_POINT_SIZE_RANGE:
>+        case GL_LINE_WIDTH_RANGE:
>+        case GL_POLYGON_MODE:
>+        case GL_DEPTH_RANGE:
>+        case GL_MAX_VIEWPORT_DIMS:
>+        case GL_MAP1_GRID_DOMAIN:
>+        case GL_MAP2_GRID_SEGMENTS:
>+        case GL_ALIASED_POINT_SIZE_RANGE:
>+        case GL_ALIASED_LINE_WIDTH_RANGE:
>+        case GL_DEPTH_BOUNDS_EXT:
>+            return 2;
>+        case GL_CURRENT_NORMAL:
>+            return 3;
>+        case GL_CURRENT_COLOR:
>+        case GL_CURRENT_TEXTURE_COORDS:
>+        case GL_CURRENT_RASTER_COLOR:
>+        case GL_CURRENT_RASTER_TEXTURE_COORDS:
>+        case GL_CURRENT_RASTER_POSITION:
>+        case GL_LIGHT_MODEL_AMBIENT:
>+        case GL_FOG_COLOR:
>+        case GL_ACCUM_CLEAR_VALUE:
>+        case GL_VIEWPORT:
>+        case GL_SCISSOR_BOX:
>+        case GL_COLOR_CLEAR_VALUE:
>+        case GL_COLOR_WRITEMASK:
>+        case GL_MAP2_GRID_DOMAIN:
>+        case GL_BLEND_COLOR:
>+/*      case GL_BLEND_COLOR_EXT:*/
>+        case GL_CURRENT_SECONDARY_COLOR:
>+            return 4;
>+        case GL_MODELVIEW_MATRIX:
>+        case GL_PROJECTION_MATRIX:
>+        case GL_TEXTURE_MATRIX:
>+        case GL_MODELVIEW0_ARB:
>+        case GL_COLOR_MATRIX:
>+        case GL_MODELVIEW1_ARB:
>+        case GL_CURRENT_MATRIX_ARB:
>+        case GL_MODELVIEW2_ARB:
>+        case GL_MODELVIEW3_ARB:
>+        case GL_MODELVIEW4_ARB:
>+        case GL_MODELVIEW5_ARB:
>+        case GL_MODELVIEW6_ARB:
>+        case GL_MODELVIEW7_ARB:
>+        case GL_MODELVIEW8_ARB:
>+        case GL_MODELVIEW9_ARB:
>+        case GL_MODELVIEW10_ARB:
>+        case GL_MODELVIEW11_ARB:
>+        case GL_MODELVIEW12_ARB:
>+        case GL_MODELVIEW13_ARB:
>+        case GL_MODELVIEW14_ARB:
>+        case GL_MODELVIEW15_ARB:
>+        case GL_MODELVIEW16_ARB:
>+        case GL_MODELVIEW17_ARB:
>+        case GL_MODELVIEW18_ARB:
>+        case GL_MODELVIEW19_ARB:
>+        case GL_MODELVIEW20_ARB:
>+        case GL_MODELVIEW21_ARB:
>+        case GL_MODELVIEW22_ARB:
>+        case GL_MODELVIEW23_ARB:
>+        case GL_MODELVIEW24_ARB:
>+        case GL_MODELVIEW25_ARB:
>+        case GL_MODELVIEW26_ARB:
>+        case GL_MODELVIEW27_ARB:
>+        case GL_MODELVIEW28_ARB:
>+        case GL_MODELVIEW29_ARB:
>+        case GL_MODELVIEW30_ARB:
>+        case GL_MODELVIEW31_ARB:
>+        case GL_TRANSPOSE_CURRENT_MATRIX_ARB:
>+            return 16;
>+        case GL_FOG_COORDINATE_SOURCE:
>+        case GL_COMPRESSED_TEXTURE_FORMATS:
>+            return __glGetBooleanv_variable_size( e );
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glGetTexParameterfv_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_TEXTURE_MAG_FILTER:
>+        case GL_TEXTURE_MIN_FILTER:
>+        case GL_TEXTURE_WRAP_S:
>+        case GL_TEXTURE_WRAP_T:
>+        case GL_TEXTURE_PRIORITY:
>+        case GL_TEXTURE_RESIDENT:
>+        case GL_TEXTURE_WRAP_R:
>+        case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
>+/*      case GL_SHADOW_AMBIENT_SGIX:*/
>+        case GL_TEXTURE_MIN_LOD:
>+        case GL_TEXTURE_MAX_LOD:
>+        case GL_TEXTURE_BASE_LEVEL:
>+        case GL_TEXTURE_MAX_LEVEL:
>+        case GL_TEXTURE_CLIPMAP_FRAME_SGIX:
>+        case GL_TEXTURE_LOD_BIAS_S_SGIX:
>+        case GL_TEXTURE_LOD_BIAS_T_SGIX:
>+        case GL_TEXTURE_LOD_BIAS_R_SGIX:
>+        case GL_GENERATE_MIPMAP:
>+/*      case GL_GENERATE_MIPMAP_SGIS:*/
>+        case GL_TEXTURE_COMPARE_SGIX:
>+        case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
>+        case GL_TEXTURE_MAX_CLAMP_S_SGIX:
>+        case GL_TEXTURE_MAX_CLAMP_T_SGIX:
>+        case GL_TEXTURE_MAX_CLAMP_R_SGIX:
>+        case GL_TEXTURE_MAX_ANISOTROPY_EXT:
>+        case GL_TEXTURE_LOD_BIAS:
>+/*      case GL_TEXTURE_LOD_BIAS_EXT:*/
>+        case GL_DEPTH_TEXTURE_MODE:
>+/*      case GL_DEPTH_TEXTURE_MODE_ARB:*/
>+        case GL_TEXTURE_COMPARE_MODE:
>+/*      case GL_TEXTURE_COMPARE_MODE_ARB:*/
>+        case GL_TEXTURE_COMPARE_FUNC:
>+/*      case GL_TEXTURE_COMPARE_FUNC_ARB:*/
>+        case GL_TEXTURE_UNSIGNED_REMAP_MODE_NV:
>+            return 1;
>+        case GL_TEXTURE_CLIPMAP_CENTER_SGIX:
>+        case GL_TEXTURE_CLIPMAP_OFFSET_SGIX:
>+            return 2;
>+        case GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX:
>+            return 3;
>+        case GL_TEXTURE_BORDER_COLOR:
>+        case GL_POST_TEXTURE_FILTER_BIAS_SGIX:
>+        case GL_POST_TEXTURE_FILTER_SCALE_SGIX:
>+            return 4;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glGetTexLevelParameterfv_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_TEXTURE_WIDTH:
>+        case GL_TEXTURE_HEIGHT:
>+        case GL_TEXTURE_COMPONENTS:
>+        case GL_TEXTURE_BORDER:
>+        case GL_TEXTURE_RED_SIZE:
>+/*      case GL_TEXTURE_RED_SIZE_EXT:*/
>+        case GL_TEXTURE_GREEN_SIZE:
>+/*      case GL_TEXTURE_GREEN_SIZE_EXT:*/
>+        case GL_TEXTURE_BLUE_SIZE:
>+/*      case GL_TEXTURE_BLUE_SIZE_EXT:*/
>+        case GL_TEXTURE_ALPHA_SIZE:
>+/*      case GL_TEXTURE_ALPHA_SIZE_EXT:*/
>+        case GL_TEXTURE_LUMINANCE_SIZE:
>+/*      case GL_TEXTURE_LUMINANCE_SIZE_EXT:*/
>+        case GL_TEXTURE_INTENSITY_SIZE:
>+/*      case GL_TEXTURE_INTENSITY_SIZE_EXT:*/
>+        case GL_TEXTURE_DEPTH:
>+        case GL_TEXTURE_INDEX_SIZE_EXT:
>+        case GL_TEXTURE_COMPRESSED_IMAGE_SIZE:
>+/*      case GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB:*/
>+        case GL_TEXTURE_COMPRESSED:
>+/*      case GL_TEXTURE_COMPRESSED_ARB:*/
>+        case GL_TEXTURE_DEPTH_SIZE:
>+/*      case GL_TEXTURE_DEPTH_SIZE_ARB:*/
>+            return 1;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glColorTableParameterfv_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_COLOR_TABLE_SCALE:
>+        case GL_COLOR_TABLE_BIAS:
>+            return 4;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glGetColorTableParameterfv_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_COLOR_TABLE_FORMAT:
>+/*      case GL_COLOR_TABLE_FORMAT_EXT:*/
>+        case GL_COLOR_TABLE_WIDTH:
>+/*      case GL_COLOR_TABLE_WIDTH_EXT:*/
>+        case GL_COLOR_TABLE_RED_SIZE:
>+/*      case GL_COLOR_TABLE_RED_SIZE_EXT:*/
>+        case GL_COLOR_TABLE_GREEN_SIZE:
>+/*      case GL_COLOR_TABLE_GREEN_SIZE_EXT:*/
>+        case GL_COLOR_TABLE_BLUE_SIZE:
>+/*      case GL_COLOR_TABLE_BLUE_SIZE_EXT:*/
>+        case GL_COLOR_TABLE_ALPHA_SIZE:
>+/*      case GL_COLOR_TABLE_ALPHA_SIZE_EXT:*/
>+        case GL_COLOR_TABLE_LUMINANCE_SIZE:
>+/*      case GL_COLOR_TABLE_LUMINANCE_SIZE_EXT:*/
>+        case GL_COLOR_TABLE_INTENSITY_SIZE:
>+/*      case GL_COLOR_TABLE_INTENSITY_SIZE_EXT:*/
>+            return 1;
>+        case GL_COLOR_TABLE_SCALE:
>+        case GL_COLOR_TABLE_BIAS:
>+            return 4;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glConvolutionParameterfv_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_CONVOLUTION_BORDER_MODE:
>+/*      case GL_CONVOLUTION_BORDER_MODE_EXT:*/
>+            return 1;
>+        case GL_CONVOLUTION_FILTER_SCALE:
>+/*      case GL_CONVOLUTION_FILTER_SCALE_EXT:*/
>+        case GL_CONVOLUTION_FILTER_BIAS:
>+/*      case GL_CONVOLUTION_FILTER_BIAS_EXT:*/
>+        case GL_CONVOLUTION_BORDER_COLOR:
>+/*      case GL_CONVOLUTION_BORDER_COLOR_HP:*/
>+            return 4;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glGetConvolutionParameterfv_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_CONVOLUTION_BORDER_MODE:
>+/*      case GL_CONVOLUTION_BORDER_MODE_EXT:*/
>+        case GL_CONVOLUTION_FORMAT:
>+/*      case GL_CONVOLUTION_FORMAT_EXT:*/
>+        case GL_CONVOLUTION_WIDTH:
>+/*      case GL_CONVOLUTION_WIDTH_EXT:*/
>+        case GL_CONVOLUTION_HEIGHT:
>+/*      case GL_CONVOLUTION_HEIGHT_EXT:*/
>+        case GL_MAX_CONVOLUTION_WIDTH:
>+/*      case GL_MAX_CONVOLUTION_WIDTH_EXT:*/
>+        case GL_MAX_CONVOLUTION_HEIGHT:
>+/*      case GL_MAX_CONVOLUTION_HEIGHT_EXT:*/
>+            return 1;
>+        case GL_CONVOLUTION_FILTER_SCALE:
>+/*      case GL_CONVOLUTION_FILTER_SCALE_EXT:*/
>+        case GL_CONVOLUTION_FILTER_BIAS:
>+/*      case GL_CONVOLUTION_FILTER_BIAS_EXT:*/
>+        case GL_CONVOLUTION_BORDER_COLOR:
>+/*      case GL_CONVOLUTION_BORDER_COLOR_HP:*/
>+            return 4;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glGetHistogramParameterfv_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_HISTOGRAM_WIDTH:
>+        case GL_HISTOGRAM_FORMAT:
>+        case GL_HISTOGRAM_RED_SIZE:
>+        case GL_HISTOGRAM_GREEN_SIZE:
>+        case GL_HISTOGRAM_BLUE_SIZE:
>+        case GL_HISTOGRAM_ALPHA_SIZE:
>+        case GL_HISTOGRAM_LUMINANCE_SIZE:
>+        case GL_HISTOGRAM_SINK:
>+            return 1;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glGetMinmaxParameterfv_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_MINMAX_FORMAT:
>+        case GL_MINMAX_SINK:
>+            return 1;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glPointParameterfvEXT_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_POINT_SIZE_MIN:
>+/*      case GL_POINT_SIZE_MIN_ARB:*/
>+/*      case GL_POINT_SIZE_MIN_SGIS:*/
>+        case GL_POINT_SIZE_MAX:
>+/*      case GL_POINT_SIZE_MAX_ARB:*/
>+/*      case GL_POINT_SIZE_MAX_SGIS:*/
>+        case GL_POINT_FADE_THRESHOLD_SIZE:
>+/*      case GL_POINT_FADE_THRESHOLD_SIZE_ARB:*/
>+/*      case GL_POINT_FADE_THRESHOLD_SIZE_SGIS:*/
>+        case GL_POINT_SPRITE_R_MODE_NV:
>+        case GL_POINT_SPRITE_COORD_ORIGIN:
>+            return 1;
>+        case GL_POINT_DISTANCE_ATTENUATION:
>+/*      case GL_POINT_DISTANCE_ATTENUATION_ARB:*/
>+/*      case GL_POINT_DISTANCE_ATTENUATION_SGIS:*/
>+            return 3;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glGetProgramivNV_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_PROGRAM_LENGTH_NV:
>+        case GL_PROGRAM_TARGET_NV:
>+        case GL_PROGRAM_RESIDENT_NV:
>+            return 1;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glGetVertexAttribdvARB_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_VERTEX_PROGRAM_ARB:
>+        case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB:
>+        case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB:
>+        case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB:
>+        case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB:
>+        case GL_CURRENT_VERTEX_ATTRIB_ARB:
>+            return 1;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glGetProgramivARB_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_PROGRAM_LENGTH_ARB:
>+        case GL_PROGRAM_BINDING_ARB:
>+        case GL_PROGRAM_ALU_INSTRUCTIONS_ARB:
>+        case GL_PROGRAM_TEX_INSTRUCTIONS_ARB:
>+        case GL_PROGRAM_TEX_INDIRECTIONS_ARB:
>+        case GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB:
>+        case GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB:
>+        case GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB:
>+        case GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB:
>+        case GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB:
>+        case GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB:
>+        case GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB:
>+        case GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB:
>+        case GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB:
>+        case GL_MAX_TEXTURE_COORDS_ARB:
>+        case GL_MAX_TEXTURE_IMAGE_UNITS_ARB:
>+        case GL_PROGRAM_FORMAT_ARB:
>+        case GL_PROGRAM_INSTRUCTIONS_ARB:
>+        case GL_MAX_PROGRAM_INSTRUCTIONS_ARB:
>+        case GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB:
>+        case GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB:
>+        case GL_PROGRAM_TEMPORARIES_ARB:
>+        case GL_MAX_PROGRAM_TEMPORARIES_ARB:
>+        case GL_PROGRAM_NATIVE_TEMPORARIES_ARB:
>+        case GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB:
>+        case GL_PROGRAM_PARAMETERS_ARB:
>+        case GL_MAX_PROGRAM_PARAMETERS_ARB:
>+        case GL_PROGRAM_NATIVE_PARAMETERS_ARB:
>+        case GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB:
>+        case GL_PROGRAM_ATTRIBS_ARB:
>+        case GL_MAX_PROGRAM_ATTRIBS_ARB:
>+        case GL_PROGRAM_NATIVE_ATTRIBS_ARB:
>+        case GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB:
>+        case GL_PROGRAM_ADDRESS_REGISTERS_ARB:
>+        case GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB:
>+        case GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB:
>+        case GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB:
>+        case GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB:
>+        case GL_MAX_PROGRAM_ENV_PARAMETERS_ARB:
>+        case GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB:
>+        case GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV:
>+        case GL_MAX_PROGRAM_CALL_DEPTH_NV:
>+        case GL_MAX_PROGRAM_IF_DEPTH_NV:
>+        case GL_MAX_PROGRAM_LOOP_DEPTH_NV:
>+        case GL_MAX_PROGRAM_LOOP_COUNT_NV:
>+            return 1;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glGetQueryivARB_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_QUERY_COUNTER_BITS_ARB:
>+        case GL_CURRENT_QUERY_ARB:
>+            return 1;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glGetQueryObjectivARB_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_QUERY_RESULT_ARB:
>+        case GL_QUERY_RESULT_AVAILABLE_ARB:
>+            return 1;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glGetVertexAttribdvNV_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_ATTRIB_ARRAY_SIZE_NV:
>+        case GL_ATTRIB_ARRAY_STRIDE_NV:
>+        case GL_ATTRIB_ARRAY_TYPE_NV:
>+        case GL_CURRENT_ATTRIB_NV:
>+            return 1;
>+        default: return 0;
>+    }
>+}
>+
>+INTERNAL PURE FASTCALL GLint
>+__glGetFramebufferAttachmentParameterivEXT_size( GLenum e )
>+{
>+    switch( e ) {
>+        case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT:
>+        case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT:
>+        case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT:
>+        case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT:
>+        case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT:
>+            return 1;
>+        default: return 0;
>+    }
>+}
>+
>+ALIAS( Fogiv, Fogfv )
>+ALIAS( Lightiv, Lightfv )
>+ALIAS( LightModeliv, LightModelfv )
>+ALIAS( Materialiv, Materialfv )
>+ALIAS( TexParameteriv, TexParameterfv )
>+ALIAS( TexEnviv, TexEnvfv )
>+ALIAS( TexGenfv, TexGendv )
>+ALIAS( TexGeniv, TexGendv )
>+ALIAS( Map1f, Map1d )
>+ALIAS( Map2f, Map2d )
>+ALIAS( GetDoublev, GetBooleanv )
>+ALIAS( GetFloatv, GetBooleanv )
>+ALIAS( GetIntegerv, GetBooleanv )
>+ALIAS( GetLightfv, Lightfv )
>+ALIAS( GetLightiv, Lightfv )
>+ALIAS( GetMaterialfv, Materialfv )
>+ALIAS( GetMaterialiv, Materialfv )
>+ALIAS( GetTexEnvfv, TexEnvfv )
>+ALIAS( GetTexEnviv, TexEnvfv )
>+ALIAS( GetTexGendv, TexGendv )
>+ALIAS( GetTexGenfv, TexGendv )
>+ALIAS( GetTexGeniv, TexGendv )
>+ALIAS( GetTexParameteriv, GetTexParameterfv )
>+ALIAS( GetTexLevelParameteriv, GetTexLevelParameterfv )
>+ALIAS( ColorTableParameteriv, ColorTableParameterfv )
>+ALIAS( GetColorTableParameteriv, GetColorTableParameterfv )
>+ALIAS( ConvolutionParameteriv, ConvolutionParameterfv )
>+ALIAS( GetConvolutionParameteriv, GetConvolutionParameterfv )
>+ALIAS( GetHistogramParameteriv, GetHistogramParameterfv )
>+ALIAS( GetMinmaxParameteriv, GetMinmaxParameterfv )
>+ALIAS( GetVertexAttribfvARB, GetVertexAttribdvARB )
>+ALIAS( GetVertexAttribivARB, GetVertexAttribdvARB )
>+ALIAS( PointParameterivNV, PointParameterfvEXT )
>+ALIAS( GetQueryObjectuivARB, GetQueryObjectivARB )
>+ALIAS( GetVertexAttribfvNV, GetVertexAttribdvNV )
>+ALIAS( GetVertexAttribivNV, GetVertexAttribdvNV )
>+
>+#  undef PURE
>+#  undef FASTCALL
>+#  undef INTERNAL
>Index: xorg/GL/glx/indirect_size_get.h
>===================================================================
>RCS file: xorg/GL/glx/indirect_size_get.h
>diff -N xorg/GL/glx/indirect_size_get.h
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ xorg/GL/glx/indirect_size_get.h	12 Jan 2006 00:04:17 -0000
>@@ -0,0 +1,99 @@
>+/* DO NOT EDIT - This file generated automatically by glX_proto_size.py (from Mesa) script */
>+
>+/*
>+ * (C) Copyright IBM Corporation 2004
>+ * 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
>+ * IBM,
>+ * 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.
>+ */
>+
>+#if !defined( _INDIRECT_SIZE_GET_H_ )
>+#  define _INDIRECT_SIZE_GET_H_
>+
>+/**
>+ * \file
>+ * Prototypes for functions used to determine the number of data elements in
>+ * various GLX protocol messages.
>+ *
>+ * \author Ian Romanick <idr@us.ibm.com>
>+ */
>+
>+#  if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
>+#    define PURE __attribute__((pure))
>+#  else
>+#    define PURE
>+#  endif
>+
>+#  if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined(__MINGW32__)
>+#    define FASTCALL __attribute__((fastcall))
>+#  else
>+#    define FASTCALL
>+#  endif
>+
>+#  if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__)
>+#    define INTERNAL  __attribute__((visibility("internal")))
>+#  else
>+#    define INTERNAL
>+#  endif
>+
>+extern INTERNAL PURE FASTCALL GLint __glGetBooleanv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetDoublev_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetFloatv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetIntegerv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetLightfv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetLightiv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetMaterialfv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetMaterialiv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetTexEnvfv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetTexEnviv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetTexGendv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetTexGenfv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetTexGeniv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetTexParameterfv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetTexParameteriv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetTexLevelParameterfv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetTexLevelParameteriv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetColorTableParameterfv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetColorTableParameteriv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetConvolutionParameterfv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetConvolutionParameteriv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetHistogramParameterfv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetHistogramParameteriv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetMinmaxParameterfv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetMinmaxParameteriv_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetProgramivNV_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribdvARB_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribfvARB_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribivARB_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetProgramivARB_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetQueryivARB_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetQueryObjectivARB_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetQueryObjectuivARB_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribdvNV_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribfvNV_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribivNV_size(GLenum);
>+extern INTERNAL PURE FASTCALL GLint __glGetFramebufferAttachmentParameterivEXT_size(GLenum);
>+
>+#  undef PURE
>+#  undef FASTCALL
>+#  undef INTERNAL
>+
>+#endif /* !defined( _INDIRECT_SIZE_GET_H_ ) */
>Index: xorg/GL/glx/indirect_util.c
>===================================================================
>RCS file: xorg/GL/glx/indirect_util.c
>diff -N xorg/GL/glx/indirect_util.c
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ xorg/GL/glx/indirect_util.c	12 Jan 2006 00:04:17 -0000
>@@ -0,0 +1,192 @@
>+/*
>+ * (C) Copyright IBM Corporation 2005
>+ * 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
>+ * IBM,
>+ * 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 <X11/Xmd.h>
>+#include <GL/gl.h>
>+#include <GL/glxproto.h>
>+#include <byteswap.h>
>+#include <inttypes.h>
>+#include "indirect_size.h"
>+#include "indirect_size_get.h"
>+#include "indirect_dispatch.h"
>+#include "glxserver.h"
>+#include "singlesize.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
>+#include "dispatch.h"
>+#include "glxext.h"
>+#include "indirect_util.h"
>+
>+
>+#define __GLX_PAD(a) (((a)+3)&~3)
>+
>+extern xGLXSingleReply __glXReply;
>+
>+
>+GLint
>+__glGetBooleanv_variable_size( GLenum e )
>+{
>+    if ( e == GL_COMPRESSED_TEXTURE_FORMATS ) {
>+	GLint temp;
>+
>+	CALL_GetIntegerv( GET_DISPATCH(),
>+			  (GL_NUM_COMPRESSED_TEXTURE_FORMATS, & temp) );
>+	return temp;
>+    }
>+    else {
>+	return 0;
>+    }
>+}
>+
>+
>+/**
>+ * Get a properly aligned buffer to hold reply data.
>+ *
>+ * \warning
>+ * This function assumes that \c local_buffer is already properly aligned.
>+ * It also assumes that \c alignment is a power of two.
>+ */
>+void *
>+__glXGetAnswerBuffer( __GLXclientState * cl, size_t required_size,
>+    void * local_buffer, size_t local_size, unsigned alignment )
>+{
>+    void * buffer = local_buffer;
>+    const unsigned mask = alignment - 1;
>+
>+    if ( local_size < required_size ) {
>+        const size_t worst_case_size = required_size + alignment;
>+        intptr_t  temp_buf;
>+
>+        if ( cl->returnBufSize < worst_case_size ) {
>+	    void * temp = xrealloc( cl->returnBuf, worst_case_size );
>+	    
>+	    if ( temp == NULL ) {
>+	        return NULL;
>+	    }
>+	    
>+	    cl->returnBuf = temp;
>+	    cl->returnBufSize = worst_case_size;
>+	}
>+	
>+	temp_buf = (intptr_t) cl->returnBuf;
>+	temp_buf = (temp_buf + mask) & ~mask;
>+	buffer = (void *) temp_buf;
>+    }
>+
>+    return buffer;
>+}
>+
>+
>+/**
>+ * Send a GLX reply to the client.
>+ *
>+ * Technically speaking, there are several different ways to encode a GLX
>+ * reply.  The primary difference is whether or not certain fields (e.g.,
>+ * retval, size, and "pad3") are set.  This function gets around that by
>+ * always setting all of the fields to "reasonable" values.  This does no
>+ * harm to clients, but it does make the server-side code much more compact.
>+ */
>+void
>+__glXSendReply( ClientPtr client, const void * data, size_t elements,
>+    size_t element_size, GLboolean always_array, CARD32 retval )
>+{
>+    size_t reply_ints = 0;
>+
>+    if ( __glXErrorOccured() ) {
>+        elements = 0;
>+    }
>+    else if ( (elements > 1) || always_array ) {
>+        reply_ints = ((elements * element_size) + 3) >> 2;
>+    }
>+
>+    __glXReply.length =         reply_ints;
>+    __glXReply.type =           X_Reply;
>+    __glXReply.sequenceNumber = client->sequence;
>+    __glXReply.size =           elements;
>+    __glXReply.retval =         retval;
>+
>+
>+    /* It is faster on almost always every architecture to just copy the 8
>+     * bytes, even when not necessary, than check to see of the value of
>+     * elements requires it.  Copying the data when not needed will do no
>+     * harm.
>+     */
>+
>+    (void) memcpy( & __glXReply.pad3, data, 8 );
>+    WriteToClient( client, sz_xGLXSingleReply, (char *) & __glXReply );
>+
>+    if ( reply_ints != 0 ) {
>+        WriteToClient( client, reply_ints * 4, (char *) data );
>+    }
>+}
>+
>+
>+/**
>+ * Send a GLX reply to the client.
>+ *
>+ * Technically speaking, there are several different ways to encode a GLX
>+ * reply.  The primary difference is whether or not certain fields (e.g.,
>+ * retval, size, and "pad3") are set.  This function gets around that by
>+ * always setting all of the fields to "reasonable" values.  This does no
>+ * harm to clients, but it does make the server-side code much more compact.
>+ *
>+ * \warning
>+ * This function assumes that values stored in \c data will be byte-swapped
>+ * by the caller if necessary.
>+ */
>+void
>+__glXSendReplySwap( ClientPtr client, const void * data, size_t elements,
>+    size_t element_size, GLboolean always_array, CARD32 retval )
>+{
>+    size_t reply_ints = 0;
>+
>+    if ( __glXErrorOccured() ) {
>+        elements = 0;
>+    }
>+    else if ( (elements > 1) || always_array ) {
>+        reply_ints = ((elements * element_size) + 3) >> 2;
>+    }
>+
>+    __glXReply.length =         bswap_32( reply_ints );
>+    __glXReply.type =           bswap_32( X_Reply );
>+    __glXReply.sequenceNumber = bswap_32( client->sequence );
>+    __glXReply.size =           bswap_32( elements );
>+    __glXReply.retval =         bswap_32( retval );
>+
>+
>+    /* It is faster on almost always every architecture to just copy the 8
>+     * bytes, even when not necessary, than check to see of the value of
>+     * elements requires it.  Copying the data when not needed will do no
>+     * harm.
>+     */
>+
>+    (void) memcpy( & __glXReply.pad3, data, 8 );
>+    WriteToClient( client, sz_xGLXSingleReply, (char *) & __glXReply );
>+
>+    if ( reply_ints != 0 ) {
>+        WriteToClient( client, reply_ints * 4, (char *) data );
>+    }
>+}
>Index: xorg/GL/glx/indirect_util.h
>===================================================================
>RCS file: xorg/GL/glx/indirect_util.h
>diff -N xorg/GL/glx/indirect_util.h
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ xorg/GL/glx/indirect_util.h	12 Jan 2006 00:04:17 -0000
>@@ -0,0 +1,43 @@
>+/*
>+ * (C) Copyright IBM Corporation 2005
>+ * 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
>+ * IBM,
>+ * 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.
>+ */
>+
>+#ifndef __GLX_INDIRECT_UTIL_H__
>+#define __GLX_INDIRECT_UTIL_H__
>+
>+extern GLint __glGetBooleanv_variable_size( GLenum e );
>+
>+extern void * __glXGetAnswerBuffer( __GLXclientState * cl,
>+    size_t required_size, void * local_buffer, size_t local_size,
>+    unsigned alignment );
>+
>+extern void __glXSendReply( ClientPtr client, const void * data,
>+    size_t elements, size_t element_size, GLboolean always_array,
>+    CARD32 retval );
>+
>+extern void __glXSendReplySwap( ClientPtr client, const void * data,
>+    size_t elements, size_t element_size, GLboolean always_array,
>+    CARD32 retval );
>+
>+#endif /* __GLX_INDIRECT_UTIL_H__ */
>Index: xorg/GL/glx/render2.c
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/render2.c,v
>retrieving revision 1.5
>diff -u -d -r1.5 render2.c
>--- xorg/GL/glx/render2.c	28 Sep 2005 03:37:22 -0000	1.5
>+++ xorg/GL/glx/render2.c	12 Jan 2006 00:04:17 -0000
>@@ -41,8 +41,12 @@
> 
> #include <glxserver.h>
> #include "unpack.h"
>-#include "g_disptab.h"
>-#include "g_disptab_EXT.h"
>+#include "indirect_size.h"
>+#include "indirect_dispatch.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
>+#include "dispatch.h"
> 
> 
> void __glXDisp_Map1f(GLbyte *pc)
>@@ -58,7 +62,7 @@
>     points = (GLfloat *)(pc + 16);
>     k = __glMap1f_size(target);
> 
>-    glMap1f(target, u1, u2, k, order, points);
>+    CALL_Map1f( GET_DISPATCH(), (target, u1, u2, k, order, points) );
> }
> 
> void __glXDisp_Map2f(GLbyte *pc)
>@@ -80,7 +84,7 @@
>     ustride = vorder * k;
>     vstride = k;
> 
>-    glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
>+   CALL_Map2f( GET_DISPATCH(), (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points) );
> }
> 
> void __glXDisp_Map1d(GLbyte *pc)
>@@ -122,7 +126,7 @@
> #else
>     points = (GLdouble*) pc;
> #endif
>-    glMap1d(target, u1, u2, k, order, points);
>+    CALL_Map1d( GET_DISPATCH(), (target, u1, u2, k, order, points) );
> }
> 
> void __glXDisp_Map2d(GLbyte *pc)
>@@ -170,17 +174,7 @@
> #else
>     points = (GLdouble*) pc;
> #endif
>-    glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
>-}
>-
>-void __glXDisp_CallLists(GLbyte *pc)
>-{
>-    GLenum type;
>-    GLsizei n;
>-
>-    type = *(GLenum *)(pc + 4);
>-    n = *(GLsizei *)(pc + 0);
>-    glCallLists(n, type, pc + 8);
>+    CALL_Map2d( GET_DISPATCH(), (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points) );
> }
> 
> void __glXDisp_DrawArrays(GLbyte *pc)
>@@ -214,36 +208,36 @@
> 
> 	switch (component) {
> 	  case GL_VERTEX_ARRAY:
>-	    glEnableClientState(GL_VERTEX_ARRAY);
>-	    glVertexPointer(numVals, datatype, stride, pc);
>+	    CALL_EnableClientState( GET_DISPATCH(), (GL_VERTEX_ARRAY) );
>+	    CALL_VertexPointer( GET_DISPATCH(), (numVals, datatype, stride, pc) );
> 	    break;
> 	  case GL_NORMAL_ARRAY:
>-	    glEnableClientState(GL_NORMAL_ARRAY);
>-	    glNormalPointer(datatype, stride, pc);
>+	    CALL_EnableClientState( GET_DISPATCH(), (GL_NORMAL_ARRAY) );
>+	    CALL_NormalPointer( GET_DISPATCH(), (datatype, stride, pc) );
> 	    break;
> 	  case GL_COLOR_ARRAY:
>-	    glEnableClientState(GL_COLOR_ARRAY);
>-	    glColorPointer(numVals, datatype, stride, pc);
>+	    CALL_EnableClientState( GET_DISPATCH(), (GL_COLOR_ARRAY) );
>+	    CALL_ColorPointer( GET_DISPATCH(), (numVals, datatype, stride, pc) );
> 	    break;
> 	  case GL_INDEX_ARRAY:
>-	    glEnableClientState(GL_INDEX_ARRAY);
>-	    glIndexPointer(datatype, stride, pc);
>+	    CALL_EnableClientState( GET_DISPATCH(), (GL_INDEX_ARRAY) );
>+	    CALL_IndexPointer( GET_DISPATCH(), (datatype, stride, pc) );
> 	    break;
> 	  case GL_TEXTURE_COORD_ARRAY:
>-	    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
>-	    glTexCoordPointer(numVals, datatype, stride, pc);
>+	    CALL_EnableClientState( GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY) );
>+	    CALL_TexCoordPointer( GET_DISPATCH(), (numVals, datatype, stride, pc) );
> 	    break;
> 	  case GL_EDGE_FLAG_ARRAY:
>-	    glEnableClientState(GL_EDGE_FLAG_ARRAY);
>-	    glEdgeFlagPointer(stride, (const GLboolean *)pc);
>+	    CALL_EnableClientState( GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY) );
>+	    CALL_EdgeFlagPointer( GET_DISPATCH(), (stride, (const GLboolean *)pc) );
> 	    break;
> 	  case GL_SECONDARY_COLOR_ARRAY:
>-	    glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
>-	    glSecondaryColorPointer(numVals, datatype, stride, pc);
>+	    CALL_EnableClientState( GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY) );
>+	    CALL_SecondaryColorPointerEXT( GET_DISPATCH(), (numVals, datatype, stride, pc) );
> 	    break;
> 	  case GL_FOG_COORD_ARRAY:
>-	    glEnableClientState(GL_FOG_COORD_ARRAY);
>-	    glFogCoordPointer(datatype, stride, pc);
>+	    CALL_EnableClientState( GET_DISPATCH(), (GL_FOG_COORD_ARRAY) );
>+	    CALL_FogCoordPointerEXT( GET_DISPATCH(), (datatype, stride, pc) );
> 	    break;
> 	  default:
> 	    break;
>@@ -252,17 +246,17 @@
> 	pc += __GLX_PAD(numVals * __glXTypeSize(datatype));
>     }
> 
>-    glDrawArrays(primType, 0, numVertexes);
>+    CALL_DrawArrays( GET_DISPATCH(), (primType, 0, numVertexes) );
> 
>     /* turn off anything we might have turned on */
>-    glDisableClientState(GL_VERTEX_ARRAY);
>-    glDisableClientState(GL_NORMAL_ARRAY);
>-    glDisableClientState(GL_COLOR_ARRAY);
>-    glDisableClientState(GL_INDEX_ARRAY);
>-    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
>-    glDisableClientState(GL_EDGE_FLAG_ARRAY);
>-    glDisableClientState(GL_SECONDARY_COLOR_ARRAY);
>-    glDisableClientState(GL_FOG_COORD_ARRAY);
>+    CALL_DisableClientState( GET_DISPATCH(), (GL_VERTEX_ARRAY) );
>+    CALL_DisableClientState( GET_DISPATCH(), (GL_NORMAL_ARRAY) );
>+    CALL_DisableClientState( GET_DISPATCH(), (GL_COLOR_ARRAY) );
>+    CALL_DisableClientState( GET_DISPATCH(), (GL_INDEX_ARRAY) );
>+    CALL_DisableClientState( GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY) );
>+    CALL_DisableClientState( GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY) );
>+    CALL_DisableClientState( GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY) );
>+    CALL_DisableClientState( GET_DISPATCH(), (GL_FOG_COORD_ARRAY) );
> }
> 
> void __glXDisp_DrawArraysEXT(GLbyte *pc)
>Index: xorg/GL/glx/render2swap.c
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/render2swap.c,v
>retrieving revision 1.4
>diff -u -d -r1.4 render2swap.c
>--- xorg/GL/glx/render2swap.c	28 Sep 2005 03:37:22 -0000	1.4
>+++ xorg/GL/glx/render2swap.c	12 Jan 2006 00:04:17 -0000
>@@ -41,8 +41,12 @@
> 
> #include "glxserver.h"
> #include "unpack.h"
>-#include "g_disptab.h"
>-#include "g_disptab_EXT.h"
>+#include "indirect_size.h"
>+#include "indirect_dispatch.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
>+#include "dispatch.h"
> 
> 
> void __glXDispSwap_Map1f(GLbyte *pc)
>@@ -74,7 +78,7 @@
>     }
>     __GLX_SWAP_FLOAT_ARRAY(points, compsize);
> 
>-    glMap1f(target, u1, u2, k, order, points);
>+    CALL_Map1f( GET_DISPATCH(), (target, u1, u2, k, order, points) );
> }
> 
> void __glXDispSwap_Map2f(GLbyte *pc)
>@@ -115,7 +119,7 @@
>     }
>     __GLX_SWAP_FLOAT_ARRAY(points, compsize);
> 
>-    glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
>+    CALL_Map2f( GET_DISPATCH(), (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points) );
> }
> 
> void __glXDispSwap_Map1d(GLbyte *pc)
>@@ -159,7 +163,7 @@
> #else
>     points = (GLdouble*) pc;
> #endif
>-    glMap1d(target, u1, u2, k, order, points);
>+    CALL_Map1d( GET_DISPATCH(), (target, u1, u2, k, order, points) );
> }
> 
> void __glXDispSwap_Map2d(GLbyte *pc)
>@@ -211,42 +215,7 @@
> #else
>     points = (GLdouble*) pc;
> #endif
>-    glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
>-}
>-
>-void __glXDispSwap_CallLists(GLbyte *pc)
>-{
>-    GLenum type;
>-    GLsizei n;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-    __GLX_SWAP_INT(pc + 4);
>-    __GLX_SWAP_INT(pc + 0);
>-    type = *(GLenum *)(pc + 4);
>-    n = *(GLsizei *)(pc + 0);
>-
>-    switch (type) {
>-      case GL_BYTE:
>-      case GL_UNSIGNED_BYTE:
>-      case GL_2_BYTES:
>-      case GL_3_BYTES:
>-      case GL_4_BYTES:
>-	break;
>-      case GL_SHORT:
>-      case GL_UNSIGNED_SHORT:
>-	__GLX_SWAP_SHORT_ARRAY(pc+8, n);
>-	break;
>-      case GL_INT:
>-      case GL_UNSIGNED_INT:
>-	__GLX_SWAP_INT_ARRAY(pc+8, n);
>-	break;
>-      case GL_FLOAT:
>-	__GLX_SWAP_FLOAT_ARRAY(pc+8, n);
>-	break;
>-    }
>-
>-    glCallLists(n, type, pc+8);
>+    CALL_Map2d( GET_DISPATCH(), (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points) );
> }
> 
> static void swapArray(GLint numVals, GLenum datatype,
>@@ -346,28 +315,28 @@
> 
>         switch (component) {
>           case GL_VERTEX_ARRAY:
>-	    glEnableClientState(GL_VERTEX_ARRAY);
>-	    glVertexPointer(numVals, datatype, stride, pc);
>+	    CALL_EnableClientState( GET_DISPATCH(), (GL_VERTEX_ARRAY) );
>+	    CALL_VertexPointer( GET_DISPATCH(), (numVals, datatype, stride, pc) );
>             break;
>           case GL_NORMAL_ARRAY:
>-	    glEnableClientState(GL_NORMAL_ARRAY);
>-	    glNormalPointer(datatype, stride, pc);
>+	    CALL_EnableClientState( GET_DISPATCH(), (GL_NORMAL_ARRAY) );
>+	    CALL_NormalPointer( GET_DISPATCH(), (datatype, stride, pc) );
>             break;
>           case GL_COLOR_ARRAY:
>-	    glEnableClientState(GL_COLOR_ARRAY);
>-	    glColorPointer(numVals, datatype, stride, pc);
>+	    CALL_EnableClientState( GET_DISPATCH(), (GL_COLOR_ARRAY) );
>+	    CALL_ColorPointer( GET_DISPATCH(), (numVals, datatype, stride, pc) );
>             break;
>           case GL_INDEX_ARRAY:
>-	    glEnableClientState(GL_INDEX_ARRAY);
>-	    glIndexPointer(datatype, stride, pc);
>+	    CALL_EnableClientState( GET_DISPATCH(), (GL_INDEX_ARRAY) );
>+	    CALL_IndexPointer( GET_DISPATCH(), (datatype, stride, pc) );
>             break;
>           case GL_TEXTURE_COORD_ARRAY:
>-	    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
>-	    glTexCoordPointer(numVals, datatype, stride, pc);
>+	    CALL_EnableClientState( GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY) );
>+	    CALL_TexCoordPointer( GET_DISPATCH(), (numVals, datatype, stride, pc) );
>             break;
>           case GL_EDGE_FLAG_ARRAY:
>-	    glEnableClientState(GL_EDGE_FLAG_ARRAY);
>-	    glEdgeFlagPointer(stride, (const GLboolean *)pc);
>+	    CALL_EnableClientState( GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY) );
>+	    CALL_EdgeFlagPointer( GET_DISPATCH(), (stride, (const GLboolean *)pc) );
>             break;
>           default:
>             break;
>@@ -376,15 +345,15 @@
>         pc += __GLX_PAD(numVals * __glXTypeSize(datatype));
>     }
> 
>-    glDrawArrays(primType, 0, numVertexes);
>+    CALL_DrawArrays( GET_DISPATCH(), (primType, 0, numVertexes) );
> 
>     /* turn off anything we might have turned on */
>-    glDisableClientState(GL_VERTEX_ARRAY);
>-    glDisableClientState(GL_NORMAL_ARRAY);
>-    glDisableClientState(GL_COLOR_ARRAY);
>-    glDisableClientState(GL_INDEX_ARRAY);
>-    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
>-    glDisableClientState(GL_EDGE_FLAG_ARRAY);
>+    CALL_DisableClientState( GET_DISPATCH(), (GL_VERTEX_ARRAY) );
>+    CALL_DisableClientState( GET_DISPATCH(), (GL_NORMAL_ARRAY) );
>+    CALL_DisableClientState( GET_DISPATCH(), (GL_COLOR_ARRAY) );
>+    CALL_DisableClientState( GET_DISPATCH(), (GL_INDEX_ARRAY) );
>+    CALL_DisableClientState( GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY) );
>+    CALL_DisableClientState( GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY) );
> }
> 
> void __glXDispSwap_DrawArraysEXT(GLbyte *pc)
>Index: xorg/GL/glx/renderpix.c
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/renderpix.c,v
>retrieving revision 1.4
>diff -u -d -r1.4 renderpix.c
>--- xorg/GL/glx/renderpix.c	1 Oct 2005 22:25:13 -0000	1.4
>+++ xorg/GL/glx/renderpix.c	12 Jan 2006 00:04:17 -0000
>@@ -41,247 +41,11 @@
> 
> #include "glxserver.h"
> #include "unpack.h"
>-#include "g_disptab.h"
>-#include "g_disptab_EXT.h"
>-
>-void __glXDisp_PolygonStipple(GLbyte *pc)
>-{
>-    __GLXpixelHeader *hdr = (__GLXpixelHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glPolygonStipple((GLubyte *)(hdr+1));
>-}
>-
>-void __glXDisp_Bitmap(GLbyte *pc)
>-{
>-    __GLXdispatchBitmapHeader *hdr = (__GLXdispatchBitmapHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glBitmap((GLsizei) hdr->width,
>-	     (GLsizei) hdr->height,
>-	     (GLfloat) hdr->xorig,
>-	     (GLfloat) hdr->yorig,
>-	     (GLfloat) hdr->xmove,
>-	     (GLfloat) hdr->ymove,
>-	     (GLubyte *)(hdr+1));
>-}
>-
>-void __glXDisp_TexImage1D(GLbyte *pc)
>-{
>-    __GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glTexImage1D(hdr->target,
>-		 (GLint) hdr->level,
>-		 (GLint) hdr->components,
>-		 (GLsizei) hdr->width,
>-		 (GLint) hdr->border,
>-		 hdr->format,
>-		 hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_TexImage2D(GLbyte *pc)
>-{
>-    __GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glTexImage2D(hdr->target,
>-		 (GLint) hdr->level,
>-		 (GLint) hdr->components,
>-		 (GLsizei) hdr->width,
>-		 (GLsizei) hdr->height,
>-		 (GLint) hdr->border,
>-		 hdr->format,
>-		 hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_TexImage3D(GLbyte *pc)
>-{
>-    __GLXdispatchTexImage3DHeader *hdr = (__GLXdispatchTexImage3DHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, hdr->imageHeight);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_IMAGES, hdr->skipImages);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glTexImage3D(hdr->target, hdr->level, hdr->internalformat, hdr->width,
>-		 hdr->height, hdr->depth, hdr->border, hdr->format, hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_DrawPixels(GLbyte *pc)
>-{
>-    __GLXdispatchDrawPixelsHeader *hdr = (__GLXdispatchDrawPixelsHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glDrawPixels((GLsizei) hdr->width,
>-		 (GLsizei) hdr->height,
>-		 hdr->format,
>-		 hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_TexSubImage1D(GLbyte *pc)
>-{
>-    __GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glTexSubImage1D(hdr->target,
>-		    (GLint) hdr->level,
>-		    (GLint) hdr->xoffset,
>-		    (GLsizei) hdr->width,
>-		    hdr->format,
>-		    hdr->type,
>-		    (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_TexSubImage2D(GLbyte *pc)
>-{
>-    __GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glTexSubImage2D(hdr->target,
>-		    (GLint) hdr->level,
>-		    (GLint) hdr->xoffset,
>-		    (GLint) hdr->yoffset,
>-		    (GLsizei) hdr->width,
>-		    (GLsizei) hdr->height,
>-		    hdr->format,
>-		    hdr->type,
>-		    (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_TexSubImage3D(GLbyte *pc)
>-{
>-    __GLXdispatchTexSubImage3DHeader *hdr =
>-				(__GLXdispatchTexSubImage3DHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, hdr->imageHeight);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_IMAGES, hdr->skipImages);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glTexSubImage3D(hdr->target, hdr->level, hdr->xoffset, hdr->yoffset,
>-		       hdr->zoffset, hdr->width, hdr->height, hdr->depth,
>-		       hdr->format, hdr->type, (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_ColorTable(GLbyte *pc)
>-{
>-   __GLXdispatchColorTableHeader *hdr =
>-				(__GLXdispatchColorTableHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glColorTable(hdr->target, hdr->internalformat,
>-		 hdr->width, hdr->format, hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_ColorSubTable(GLbyte *pc)
>-{
>-   __GLXdispatchColorSubTableHeader *hdr =
>-				(__GLXdispatchColorSubTableHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glColorSubTable(hdr->target, hdr->start, hdr->count, hdr->format,
>-		    hdr->type, (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_ConvolutionFilter1D(GLbyte *pc)
>-{
>-   __GLXdispatchConvolutionFilterHeader *hdr =
>-				(__GLXdispatchConvolutionFilterHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glConvolutionFilter1D(hdr->target, hdr->internalformat,
>-		 hdr->width, hdr->format, hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDisp_ConvolutionFilter2D(GLbyte *pc)
>-{
>-   __GLXdispatchConvolutionFilterHeader *hdr =
>-				 (__GLXdispatchConvolutionFilterHeader *) pc;
>-
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glConvolutionFilter2D(hdr->target, hdr->internalformat,
>-		 hdr->width, hdr->height, hdr->format, hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>+#include "indirect_dispatch.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
>+#include "dispatch.h"
> 
> void __glXDisp_SeparableFilter2D(GLbyte *pc)
> {
>@@ -291,12 +55,12 @@
> 
>     hdrlen = __GLX_PAD(__GLX_CONV_FILT_CMD_DISPATCH_HDR_SIZE);
> 
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, hdr->rowLength) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, hdr->skipRows) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, hdr->skipPixels) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, hdr->alignment) );
> 
>     /* XXX check this usage - internal code called
>     ** a version without the packing parameters
>@@ -306,7 +70,7 @@
> 			       hdr->alignment);
>     image1len = __GLX_PAD(image1len);
> 
>-    glSeparableFilter2D(hdr->target, hdr->internalformat,
>+    CALL_SeparableFilter2D( GET_DISPATCH(), (hdr->target, hdr->internalformat,
> 		 hdr->width, hdr->height, hdr->format, hdr->type,
>-		 ((GLubyte *)hdr+hdrlen), ((GLubyte *)hdr+hdrlen+image1len));
>+		 ((GLubyte *)hdr+hdrlen), ((GLubyte *)hdr+hdrlen+image1len)) );
> }
>Index: xorg/GL/glx/renderpixswap.c
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/renderpixswap.c,v
>retrieving revision 1.4
>diff -u -d -r1.4 renderpixswap.c
>--- xorg/GL/glx/renderpixswap.c	1 Oct 2005 22:25:13 -0000	1.4
>+++ xorg/GL/glx/renderpixswap.c	12 Jan 2006 00:04:17 -0000
>@@ -41,472 +41,11 @@
> 
> #include "glxserver.h"
> #include "unpack.h"
>-#include "g_disptab.h"
>-#include "g_disptab_EXT.h"
>-
>-void __glXDispSwap_PolygonStipple(GLbyte *pc)
>-{
>-    __GLXpixelHeader *hdr = (__GLXpixelHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glPolygonStipple((GLubyte *)(hdr+1));
>-}
>-
>-void __glXDispSwap_Bitmap(GLbyte *pc)
>-{
>-    __GLXdispatchBitmapHeader *hdr = (__GLXdispatchBitmapHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->height);
>-    __GLX_SWAP_FLOAT((GLbyte *)&hdr->xorig);
>-    __GLX_SWAP_FLOAT((GLbyte *)&hdr->yorig);
>-    __GLX_SWAP_FLOAT((GLbyte *)&hdr->xmove);
>-    __GLX_SWAP_FLOAT((GLbyte *)&hdr->ymove);
>-
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glBitmap((GLsizei) hdr->width,
>-	     (GLsizei) hdr->height,
>-	     (GLfloat) hdr->xorig,
>-	     (GLfloat) hdr->yorig,
>-	     (GLfloat) hdr->xmove,
>-	     (GLfloat) hdr->ymove,
>-	     (GLubyte *)(hdr+1));
>-}
>-
>-void __glXDispSwap_TexImage1D(GLbyte *pc)
>-{
>-    __GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->level);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->components);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->height);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->border);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glTexImage1D(hdr->target,
>-		 (GLint) hdr->level,
>-		 (GLint) hdr->components,
>-		 (GLsizei) hdr->width,
>-		 (GLint) hdr->border,
>-		 hdr->format,
>-		 hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_TexImage2D(GLbyte *pc)
>-{
>-    __GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->level);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->components);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->height);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->border);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glTexImage2D(hdr->target,
>-		 (GLint) hdr->level,
>-		 (GLint) hdr->components,
>-		 (GLsizei) hdr->width,
>-		 (GLsizei) hdr->height,
>-		 (GLint) hdr->border,
>-		 hdr->format,
>-		 hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_TexImage3D(GLbyte *pc)
>-{
>-    __GLXdispatchTexImage3DHeader *hdr = (__GLXdispatchTexImage3DHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->imageHeight);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->imageDepth);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipImages);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipVolumes);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->level);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->internalformat);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->height);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->depth);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->size4d);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->border);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, hdr->imageHeight);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_IMAGES, hdr->skipImages);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glTexImage3D(hdr->target, hdr->level, hdr->internalformat, hdr->width,
>-		 hdr->height, hdr->depth, hdr->border, hdr->format, hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_DrawPixels(GLbyte *pc)
>-{
>-    __GLXdispatchDrawPixelsHeader *hdr = (__GLXdispatchDrawPixelsHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->height);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glDrawPixels((GLsizei) hdr->width,
>-		 (GLsizei) hdr->height,
>-		 hdr->format,
>-		 hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_TexSubImage1D(GLbyte *pc)
>-{
>-    __GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->level);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->xoffset);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glTexSubImage1D(hdr->target,
>-		    (GLint) hdr->level,
>-		    (GLint) hdr->xoffset,
>-		    (GLsizei) hdr->width,
>-		    hdr->format,
>-		    hdr->type,
>-		    (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_TexSubImage2D(GLbyte *pc)
>-{
>-    __GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->level);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->xoffset);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->yoffset);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->height);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
>-
>-    glTexSubImage2D(hdr->target,
>-		    (GLint) hdr->level,
>-		    (GLint) hdr->xoffset,
>-		    (GLint) hdr->yoffset,
>-		    (GLsizei) hdr->width,
>-		    (GLsizei) hdr->height,
>-		    hdr->format,
>-		    hdr->type,
>-		    (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_TexSubImage3D(GLbyte *pc)
>-{
>-    __GLXdispatchTexSubImage3DHeader *hdr =
>-				(__GLXdispatchTexSubImage3DHeader *) pc;
>-
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->imageHeight);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->imageDepth);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipImages);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipVolumes);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->level);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->xoffset);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->yoffset);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->zoffset);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->height);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->depth);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->size4d);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, hdr->imageHeight);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_IMAGES, hdr->skipImages);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glTexSubImage3D(hdr->target, hdr->level, hdr->xoffset, hdr->yoffset,
>-		       hdr->zoffset, hdr->width, hdr->height, hdr->depth,
>-		       hdr->format, hdr->type, (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_ColorTable(GLbyte *pc)
>-{
>-    __GLXdispatchColorTableHeader *hdr =
>-				(__GLXdispatchColorTableHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->internalformat);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glColorTable(hdr->target, hdr->internalformat,
>-		 hdr->width, hdr->format, hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_ColorSubTable(GLbyte *pc)
>-{
>-    __GLXdispatchColorSubTableHeader *hdr =
>-				(__GLXdispatchColorSubTableHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->start);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->count);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glColorSubTable(hdr->target, hdr->start, hdr->count, hdr->format,
>-		    hdr->type, (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_ConvolutionFilter1D(GLbyte *pc)
>-{
>-    __GLXdispatchConvolutionFilterHeader *hdr =
>-				(__GLXdispatchConvolutionFilterHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->internalformat);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glConvolutionFilter2D(hdr->target, hdr->internalformat,
>-		 hdr->width, 1, hdr->format, hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>-
>-void __glXDispSwap_ConvolutionFilter2D(GLbyte *pc)
>-{
>-    __GLXdispatchConvolutionFilterHeader *hdr =
>-				(__GLXdispatchConvolutionFilterHeader *) pc;
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
>-
>-    __GLX_SWAP_INT((GLbyte *)&hdr->target);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->internalformat);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->width);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->height);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->format);
>-    __GLX_SWAP_INT((GLbyte *)&hdr->type);
>-
>-    /*
>-    ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>-    ** the pixel data.
>-    */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>-
>-    glConvolutionFilter2D(hdr->target, hdr->internalformat,
>-		 hdr->width, hdr->height, hdr->format, hdr->type,
>-		 (GLvoid *)(hdr+1));
>-}
>+#include "indirect_dispatch.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
>+#include "dispatch.h"
> 
> void __glXDispSwap_SeparableFilter2D(GLbyte *pc)
> {
>@@ -533,12 +72,12 @@
>     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
>     ** the pixel data.
>     */
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, !hdr->swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, hdr->rowLength) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, hdr->skipRows) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, hdr->skipPixels) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, hdr->alignment) );
> 
>     /* XXX check this usage - internal code called
>     ** a version without the packing parameters
>@@ -549,7 +88,7 @@
>     image1len = __GLX_PAD(image1len);
> 
> 
>-    glSeparableFilter2D(hdr->target, hdr->internalformat,
>+    CALL_SeparableFilter2D( GET_DISPATCH(), (hdr->target, hdr->internalformat,
> 		 hdr->width, hdr->height, hdr->format, hdr->type,
>-		 ((GLubyte *)hdr+hdrlen), ((GLubyte *)hdr+hdrlen+image1len));
>+		 ((GLubyte *)hdr+hdrlen), ((GLubyte *)hdr+hdrlen+image1len)) );
> }
>Index: xorg/GL/glx/rensize.c
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/rensize.c,v
>retrieving revision 1.8
>diff -u -d -r1.8 rensize.c
>--- xorg/GL/glx/rensize.c	1 Oct 2005 22:25:13 -0000	1.8
>+++ xorg/GL/glx/rensize.c	12 Jan 2006 00:04:17 -0000
>@@ -42,138 +42,20 @@
> #include "glxserver.h"
> #include "GL/glxproto.h"
> #include "unpack.h"
>-#include "impsize.h"
>+#include "indirect_size.h"
>+#include "indirect_reqsize.h"
> 
> #define SWAPL(a) \
>   (((a & 0xff000000U)>>24) | ((a & 0xff0000U)>>8) | \
>    ((a & 0xff00U)<<8) | ((a & 0xffU)<<24))
> 
>-int __glXCallListsReqSize(GLbyte *pc, Bool swap )
>-{
>-    GLsizei n = *(GLsizei *)(pc + 0);
>-    GLenum type = *(GLenum *)(pc + 4);
>-
>-    if (swap) {
>-	n = SWAPL( n );
>-	type = SWAPL( type );
>-    }
>-    return n * __glCallLists_size( type );
>-}
>-
>-int __glXFogivReqSize(GLbyte *pc, Bool swap )
>-{
>-    GLenum pname = *(GLenum *)(pc + 0);
>-    if (swap) {
>-	pname = SWAPL( pname );
>-    }
>-    return 4 * __glFogiv_size( pname );		/* defined in samplegl lib */
>-}
>-
>-int __glXFogfvReqSize(GLbyte *pc, Bool swap )
>-{
>-    return __glXFogivReqSize( pc, swap );
>-}
>-
>-int __glXLightfvReqSize(GLbyte *pc, Bool swap )
>-{
>-    GLenum pname = *(GLenum *)(pc + 4);
>-    if (swap) {
>-	pname = SWAPL( pname );
>-    }
>-    return 4 * __glLightfv_size( pname );	/* defined in samplegl lib */
>-}
>-
>-int __glXLightivReqSize(GLbyte *pc, Bool swap )
>-{
>-    return __glXLightfvReqSize( pc, swap );
>-}
>-
>-int __glXLightModelfvReqSize(GLbyte *pc, Bool swap )
>-{
>-    GLenum pname = *(GLenum *)(pc + 0);
>-    if (swap) {
>-	pname = SWAPL( pname );
>-    }
>-    return 4 * __glLightModelfv_size( pname );	/* defined in samplegl lib */
>-}
>-
>-int __glXLightModelivReqSize(GLbyte *pc, Bool swap )
>-{
>-    return __glXLightModelfvReqSize( pc, swap );
>-}
>-
>-int __glXMaterialfvReqSize(GLbyte *pc, Bool swap )
>-{
>-    GLenum pname = *(GLenum *)(pc + 4);
>-    if (swap) {
>-	pname = SWAPL( pname );
>-    }
>-    return 4 * __glMaterialfv_size( pname );	/* defined in samplegl lib */
>-}
>-
>-int __glXMaterialivReqSize(GLbyte *pc, Bool swap )
>-{
>-    return __glXMaterialfvReqSize( pc, swap );
>-}
>-
>-int __glXTexGendvReqSize(GLbyte *pc, Bool swap )
>-{
>-    GLenum pname = *(GLenum *)(pc + 4);
>-    if (swap) {
>-	pname = SWAPL( pname );
>-    }
>-    return 8 * __glTexGendv_size( pname );	/* defined in samplegl lib */
>-}
>-
>-int __glXTexGenfvReqSize(GLbyte *pc, Bool swap )
>-{
>-    GLenum pname = *(GLenum *)(pc + 4);
>-    if (swap) {
>-	pname = SWAPL( pname );
>-    }
>-    return 4 * __glTexGenfv_size( pname );	/* defined in samplegl lib */
>-}
>-
>-int __glXTexGenivReqSize(GLbyte *pc, Bool swap )
>-{
>-    return __glXTexGenfvReqSize( pc, swap );
>-}
>-
>-int __glXTexParameterfvReqSize(GLbyte *pc, Bool swap )
>-{
>-    GLenum pname = *(GLenum *)(pc + 4);
>-    if (swap) {
>-	pname = SWAPL( pname );
>-    }
>-    return 4 * __glTexParameterfv_size( pname ); /* defined in samplegl lib */
>-}
>-
>-int __glXTexParameterivReqSize(GLbyte *pc, Bool swap )
>-{
>-    return __glXTexParameterfvReqSize( pc, swap );
>-}
>-
>-int __glXTexEnvfvReqSize(GLbyte *pc, Bool swap )
>-{
>-    GLenum pname = *(GLenum *)(pc + 4);
>-    if (swap) {
>-	pname = SWAPL( pname );
>-    }
>-    return 4 * __glTexEnvfv_size( pname );	/* defined in samplegl lib */
>-}
>-
>-int __glXTexEnvivReqSize(GLbyte *pc, Bool swap )
>-{
>-    return __glXTexEnvfvReqSize( pc, swap );
>-}
>-
> static int Map1Size( GLint k, GLint order)
> {
>     if (order <= 0 || k < 0) return -1;
>     return k * order;
> }
> 
>-int __glXMap1dReqSize(GLbyte *pc, Bool swap )
>+int __glXMap1dReqSize( const GLbyte *pc, Bool swap )
> {
>     GLenum target;
>     GLint order, k;
>@@ -188,7 +70,7 @@
>     return 8 * Map1Size( k, order );
> }
> 
>-int __glXMap1fReqSize(GLbyte *pc, Bool swap )
>+int __glXMap1fReqSize( const GLbyte *pc, Bool swap )
> {
>     GLenum target;
>     GLint order, k;
>@@ -209,7 +91,7 @@
>     return k * majorOrder * minorOrder;
> }
> 
>-int __glXMap2dReqSize(GLbyte *pc, Bool swap )
>+int __glXMap2dReqSize( const GLbyte *pc, Bool swap )
> {
>     GLenum target;
>     GLint uorder, vorder, k;
>@@ -226,7 +108,7 @@
>     return 8 * Map2Size( k, uorder, vorder );
> }
> 
>-int __glXMap2fReqSize(GLbyte *pc, Bool swap )
>+int __glXMap2fReqSize( const GLbyte *pc, Bool swap )
> {
>     GLenum target;
>     GLint uorder, vorder, k;
>@@ -243,31 +125,6 @@
>     return 4 * Map2Size( k, uorder, vorder );
> }
> 
>-int __glXPixelMapfvReqSize(GLbyte *pc, Bool swap )
>-{
>-    GLint mapsize;
>-    mapsize = *(GLint *)(pc + 4);
>-    if (swap) {
>-	mapsize = SWAPL( mapsize );
>-    }
>-    return 4 * mapsize;
>-}
>-
>-int __glXPixelMapuivReqSize(GLbyte *pc, Bool swap )
>-{
>-    return __glXPixelMapfvReqSize( pc, swap );
>-}
>-
>-int __glXPixelMapusvReqSize(GLbyte *pc, Bool swap )
>-{
>-    GLint mapsize;
>-    mapsize = *(GLint *)(pc + 4);
>-    if (swap) {
>-	mapsize = SWAPL( mapsize );
>-    }
>-    return 2 * mapsize;
>-}
>-
> /**
>  * Calculate the size of an image.
>  * 
>@@ -451,110 +308,6 @@
> }
> 
> 
>-int __glXDrawPixelsReqSize(GLbyte *pc, Bool swap )
>-{
>-    __GLXdispatchDrawPixelsHeader *hdr = (__GLXdispatchDrawPixelsHeader *) pc;
>-    GLenum format = hdr->format;
>-    GLenum type = hdr->type;
>-    GLint w = hdr->width;
>-    GLint h = hdr->height;
>-    GLint rowLength = hdr->rowLength;
>-    GLint skipRows = hdr->skipRows;
>-    GLint alignment = hdr->alignment;
>-
>-    if (swap) {
>-	format = SWAPL( format );
>-	type = SWAPL( type );
>-	w = SWAPL( w );
>-	h = SWAPL( h );
>-	rowLength = SWAPL( rowLength );
>-	skipRows = SWAPL( skipRows );
>-	alignment = SWAPL( alignment );
>-    }
>-    return __glXImageSize( format, type, 0, w, h, 1,
>-			   0, rowLength, 0, skipRows, alignment );
>-}
>-
>-int __glXBitmapReqSize(GLbyte *pc, Bool swap )
>-{
>-    __GLXdispatchBitmapHeader *hdr = (__GLXdispatchBitmapHeader *) pc;
>-    GLint w = hdr->width;
>-    GLint h = hdr->height;
>-    GLint rowLength = hdr->rowLength;
>-    GLint skipRows = hdr->skipRows;
>-    GLint alignment = hdr->alignment;
>-
>-    if (swap) {
>-	w = SWAPL( w );
>-	h = SWAPL( h );
>-	rowLength = SWAPL( rowLength );
>-	skipRows = SWAPL( skipRows );
>-	alignment = SWAPL( alignment );
>-    }
>-    return __glXImageSize( GL_COLOR_INDEX, GL_BITMAP, 0, w, h, 1,
>-		      0, rowLength, 0, skipRows, alignment );
>-}
>-
>-int __glXTexImage1DReqSize(GLbyte *pc, Bool swap )
>-{
>-    __GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;
>-    GLenum target = hdr->target;
>-    GLenum format = hdr->format;
>-    GLenum type = hdr->type;
>-    GLint w = hdr->width;
>-    GLint rowLength = hdr->rowLength;
>-    GLint skipRows = hdr->skipRows;
>-    GLint alignment = hdr->alignment;
>-
>-    if (swap) {
>-	target = SWAPL( target );
>-	format = SWAPL( format );
>-	type = SWAPL( type );
>-	w = SWAPL( w );
>-	rowLength = SWAPL( rowLength );
>-	skipRows = SWAPL( skipRows );
>-	alignment = SWAPL( alignment );
>-    }
>-    if (target == GL_PROXY_TEXTURE_1D) {
>-	return 0;
>-    } else if (format == GL_STENCIL_INDEX || format == GL_DEPTH_COMPONENT) {
>-	return -1;
>-    }
>-    return __glXImageSize( format, type, 0, w, 1, 1,
>-			   0, rowLength, 0, skipRows, alignment );
>-}
>-
>-int __glXTexImage2DReqSize(GLbyte *pc, Bool swap )
>-{
>-    __GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;
>-    GLenum target = hdr->target;
>-    GLenum format = hdr->format;
>-    GLenum type = hdr->type;
>-    GLint w = hdr->width;
>-    GLint h = hdr->height;
>-    GLint rowLength = hdr->rowLength;
>-    GLint skipRows = hdr->skipRows;
>-    GLint alignment = hdr->alignment;
>-
>-    if (swap) {
>-	target = SWAPL( target );
>-	format = SWAPL( format );
>-	type = SWAPL( type );
>-	w = SWAPL( w );
>-	h = SWAPL( h );
>-	rowLength = SWAPL( rowLength );
>-	skipRows = SWAPL( skipRows );
>-	alignment = SWAPL( alignment );
>-    }
>-    if (target == GL_PROXY_TEXTURE_2D || target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {
>-	return 0;
>-    } else if (format == GL_STENCIL_INDEX || format == GL_DEPTH_COMPONENT) {
>-	return -1;
>-    }
>-    return __glXImageSize( format, type, 0, w, h, 1,
>-			   0, rowLength, 0, skipRows, alignment );
>-}
>-
> /* XXX this is used elsewhere - should it be exported from glxserver.h? */
> int __glXTypeSize(GLenum enm)
> {
>@@ -571,7 +324,7 @@
>   }
> }
> 
>-int __glXDrawArraysSize( GLbyte *pc, Bool swap )
>+int __glXDrawArraysSize( const GLbyte *pc, Bool swap )
> {
>     __GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *) pc;
>     __GLXdispatchDrawArraysComponentHeader *compHeader;
>@@ -638,217 +391,7 @@
> 	    (numVertexes * arrayElementSize));
> }
> 
>-int __glXPrioritizeTexturesReqSize(GLbyte *pc, Bool swap )
>-{
>-    GLint n = *(GLsizei *)(pc + 0);
>-    if (swap) n = SWAPL(n);
>-    return(8*n); /* 4*n for textures, 4*n for priorities */
>-}
>-
>-int __glXTexSubImage1DReqSize(GLbyte *pc, Bool swap )
>-{
>-    __GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;
>-    GLenum format = hdr->format;
>-    GLenum type = hdr->type;
>-    GLint w = hdr->width;
>-    GLint rowLength = hdr->rowLength;
>-    GLint skipRows = hdr->skipRows;
>-    GLint alignment = hdr->alignment;
>-
>-    if (swap) {
>-	format = SWAPL( format );
>-	type = SWAPL( type );
>-	w = SWAPL( w );
>-	rowLength = SWAPL( rowLength );
>-	skipRows = SWAPL( skipRows );
>-	alignment = SWAPL( alignment );
>-    }
>-    return __glXImageSize( format, type, 0, w, 1, 1,
>-			   0, rowLength, 0, skipRows, alignment );
>-}
>-
>-int __glXTexSubImage2DReqSize(GLbyte *pc, Bool swap )
>-{
>-    __GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;
>-    GLenum format = hdr->format;
>-    GLenum type = hdr->type;
>-    GLint w = hdr->width;
>-    GLint h = hdr->height;
>-    GLint rowLength = hdr->rowLength;
>-    GLint skipRows = hdr->skipRows;
>-    GLint alignment = hdr->alignment;
>-
>-    if (swap) {
>-	format = SWAPL( format );
>-	type = SWAPL( type );
>-	w = SWAPL( w );
>-	h = SWAPL( h );
>-	rowLength = SWAPL( rowLength );
>-	skipRows = SWAPL( skipRows );
>-	alignment = SWAPL( alignment );
>-    }
>-    return __glXImageSize( format, type, 0, w, h, 1,
>-			   0, rowLength, 0, skipRows, alignment );
>-}
>-
>-int __glXTexImage3DReqSize(GLbyte *pc, Bool swap )
>-{
>-    __GLXdispatchTexImage3DHeader *hdr = (__GLXdispatchTexImage3DHeader *) pc;
>-    GLenum target = hdr->target;
>-    GLenum format = hdr->format;
>-    GLenum type = hdr->type;
>-    GLint w = hdr->width;
>-    GLint h = hdr->height;
>-    GLint d = hdr->depth;
>-    GLint imageHeight = hdr->imageHeight;
>-    GLint rowLength = hdr->rowLength;
>-    GLint skipImages = hdr->skipImages;
>-    GLint skipRows = hdr->skipRows;
>-    GLint alignment = hdr->alignment;
>-    GLint nullImage = hdr->nullimage;
>-
>-    if (swap) {
>-	target = SWAPL( target );
>-	format = SWAPL( format );
>-	type = SWAPL( type );
>-	w = SWAPL( w );
>-	h = SWAPL( h );
>-	d = SWAPL( d );
>-	imageHeight = SWAPL( imageHeight );
>-	rowLength = SWAPL( rowLength );
>-	skipImages = SWAPL( skipImages );
>-	skipRows = SWAPL( skipRows );
>-	alignment = SWAPL( alignment );
>-    }
>-    if (target == GL_PROXY_TEXTURE_3D || nullImage) {
>-	return 0;
>-    } else {
>-	return __glXImageSize( format, type, target, w, h, d, imageHeight,
>-			       rowLength, skipImages, skipRows, alignment );
>-    }
>-}
>-
>-int __glXTexSubImage3DReqSize(GLbyte *pc, Bool swap )
>-{
>-    __GLXdispatchTexSubImage3DHeader *hdr =
>-					(__GLXdispatchTexSubImage3DHeader *) pc;
>-    GLenum target = hdr->target;
>-    GLenum format = hdr->format;
>-    GLenum type = hdr->type;
>-    GLint w = hdr->width;
>-    GLint h = hdr->height;
>-    GLint d = hdr->depth;
>-    GLint imageHeight = hdr->imageHeight;
>-    GLint rowLength = hdr->rowLength;
>-    GLint skipImages = hdr->skipImages;
>-    GLint skipRows = hdr->skipRows;
>-    GLint alignment = hdr->alignment;
>-
>-    if (swap) {
>-	target = SWAPL( target );
>-	format = SWAPL( format );
>-	type = SWAPL( type );
>-	w = SWAPL( w );
>-	h = SWAPL( h );
>-	d = SWAPL( d );
>-	imageHeight = SWAPL( imageHeight );
>-	rowLength = SWAPL( rowLength );
>-	skipImages = SWAPL( skipImages );
>-	skipRows = SWAPL( skipRows );
>-	alignment = SWAPL( alignment );
>-    }
>-    if (target == GL_PROXY_TEXTURE_3D) {
>-	return 0;
>-    } else {
>-	return __glXImageSize( format, type, target, w, h, d, imageHeight,
>-			       rowLength, skipImages, skipRows, alignment );
>-    }
>-}
>-
>-int __glXConvolutionFilter1DReqSize(GLbyte *pc, Bool swap )
>-{
>-    __GLXdispatchConvolutionFilterHeader *hdr =
>-			(__GLXdispatchConvolutionFilterHeader *) pc;
>-
>-    GLenum format = hdr->format;
>-    GLenum type = hdr->type;
>-    GLint w = hdr->width;
>-    GLint rowLength = hdr->rowLength;
>-    GLint alignment = hdr->alignment;
>-
>-    if (swap) {
>-	format = SWAPL( format );
>-	type = SWAPL( type );
>-	w = SWAPL( w );
>-	rowLength = SWAPL( rowLength );
>-	alignment = SWAPL( alignment );
>-    }
>-
>-    return __glXImageSize( format, type, 0, w, 1, 1, 
>-			   0, rowLength, 0, 0, alignment );
>-}
>-
>-int __glXConvolutionFilter2DReqSize(GLbyte *pc, Bool swap )
>-{
>-    __GLXdispatchConvolutionFilterHeader *hdr =
>-			(__GLXdispatchConvolutionFilterHeader *) pc;
>-
>-    GLenum format = hdr->format;
>-    GLenum type = hdr->type;
>-    GLint w = hdr->width;
>-    GLint h = hdr->height;
>-    GLint rowLength = hdr->rowLength;
>-    GLint skipRows = hdr->skipRows;
>-    GLint alignment = hdr->alignment;
>-
>-    if (swap) {
>-	format = SWAPL( format );
>-	type = SWAPL( type );
>-	w = SWAPL( w );
>-	h = SWAPL( h );
>-	rowLength = SWAPL( rowLength );
>-	skipRows = SWAPL( skipRows );
>-	alignment = SWAPL( alignment );
>-    }
>-
>-    return __glXImageSize( format, type, 0, w, h, 1,
>-			   0, rowLength, 0, skipRows, alignment );
>-}
>-
>-int __glXConvolutionParameterivSize(GLenum pname)
>-{
>-    switch (pname) {
>-      case GL_CONVOLUTION_BORDER_COLOR:
>-      case GL_CONVOLUTION_FILTER_SCALE:
>-      case GL_CONVOLUTION_FILTER_BIAS:
>-	return 4;
>-      case GL_CONVOLUTION_BORDER_MODE:
>-	return 1;
>-      default:
>-	return -1;
>-    }
>-}
>-
>-int __glXConvolutionParameterfvSize(GLenum pname)
>-{
>-    return __glXConvolutionParameterivSize(pname);
>-}
>-
>-int __glXConvolutionParameterivReqSize(GLbyte *pc, Bool swap )
>-{
>-    GLenum pname = *(GLenum *)(pc + 4);
>-    if (swap) {
>-	pname = SWAPL( pname );
>-    }
>-    return 4 * __glXConvolutionParameterivSize( pname );
>-}
>-
>-int __glXConvolutionParameterfvReqSize(GLbyte *pc, Bool swap )
>-{
>-    return __glXConvolutionParameterivReqSize( pc, swap );
>-}
>-
>-int __glXSeparableFilter2DReqSize(GLbyte *pc, Bool swap )
>+int __glXSeparableFilter2DReqSize( const GLbyte *pc, Bool swap )
> {
>     __GLXdispatchConvolutionFilterHeader *hdr =
> 			(__GLXdispatchConvolutionFilterHeader *) pc;
>@@ -879,109 +422,3 @@
>     return image1size + image2size;
> 
> }
>-
>-int __glXColorTableParameterfvSize(GLenum pname)
>-{
>-    /* currently, only scale and bias are supported; return RGBA */
>-    switch(pname) {
>-    case GL_COLOR_TABLE_SCALE:
>-    case GL_COLOR_TABLE_BIAS:
>-	return 4;
>-    default:
>-	return 0;
>-    }
>-}
>-
>-int __glXColorTableParameterivSize(GLenum pname)
>-{
>-    /* fv and iv are the same in this context */
>-    return __glXColorTableParameterfvSize(pname);
>-}
>-
>-int __glXColorTableReqSize(GLbyte *pc, Bool swap )
>-{
>-    __GLXdispatchColorTableHeader *hdr =
>-			(__GLXdispatchColorTableHeader *) pc;
>-
>-    GLenum target = hdr->target;
>-    GLenum format = hdr->format;
>-    GLenum type = hdr->type;
>-    GLint w = hdr->width;
>-    GLint rowLength = hdr->rowLength;
>-    GLint alignment = hdr->alignment;
>-
>-    switch (target) {
>-      case GL_PROXY_TEXTURE_1D:
>-      case GL_PROXY_TEXTURE_2D:
>-      case GL_PROXY_TEXTURE_3D:
>-      case GL_PROXY_COLOR_TABLE:
>-      case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE:
>-      case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE:
>-      case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
>-          return 0;
>-    }
>-
>-    if (swap) {
>-	format = SWAPL( format );
>-	type = SWAPL( type );
>-	w = SWAPL( w );
>-	rowLength = SWAPL( rowLength );
>-	alignment = SWAPL( alignment );
>-    }
>-
>-    return __glXImageSize( format, type, 0, w, 1, 1,
>-			   0, rowLength, 0, 0, alignment );
>-}
>-
>-int __glXColorSubTableReqSize(GLbyte *pc, Bool swap )
>-{
>-    __GLXdispatchColorSubTableHeader *hdr =
>-			(__GLXdispatchColorSubTableHeader *) pc;
>-
>-    GLenum format = hdr->format;
>-    GLenum type = hdr->type;
>-    GLint count = hdr->count;
>-    GLint rowLength = hdr->rowLength;
>-    GLint alignment = hdr->alignment;
>-
>-    if (swap) {
>-	format = SWAPL( format );
>-	type = SWAPL( type );
>-	count = SWAPL( count );
>-	rowLength = SWAPL( rowLength );
>-	alignment = SWAPL( alignment );
>-    }
>-
>-    return __glXImageSize( format, type, 0, count, 1, 1,
>-			   0, rowLength, 0, 0, alignment );
>-}
>-
>-int __glXColorTableParameterfvReqSize(GLbyte *pc, Bool swap )
>-{
>-    GLenum pname = *(GLenum *)(pc + 4);
>-    if (swap) {
>-	pname = SWAPL( pname );
>-    }
>-    return 4 * __glXColorTableParameterfvSize(pname);
>-}
>-
>-int __glXColorTableParameterivReqSize(GLbyte *pc, Bool swap )
>-{
>-    /* no difference between fv and iv versions */
>-    return __glXColorTableParameterfvReqSize(pc, swap);
>-}
>-
>-int __glXPointParameterfvARBReqSize(GLbyte *pc, Bool swap )
>-{
>-    GLenum pname = *(GLenum *)(pc + 0);
>-    if (swap) {
>-	pname = SWAPL( pname );
>-    }
>-    return 4 * __glPointParameterfvEXT_size( pname );
>-}
>-
>-int __glXPointParameterivReqSize(GLbyte *pc, Bool swap )
>-{
>-    /* no difference between fv and iv versions */
>-    return __glXPointParameterfvARBReqSize(pc, swap);
>-}
>Index: xorg/GL/glx/rensizetab.c
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/rensizetab.c,v
>retrieving revision 1.3
>diff -u -d -r1.3 rensizetab.c
>--- xorg/GL/glx/rensizetab.c	3 Jul 2005 07:01:02 -0000	1.3
>+++ xorg/GL/glx/rensizetab.c	12 Jan 2006 00:04:17 -0000
>@@ -39,6 +39,7 @@
> #endif
> 
> #include "glxserver.h"
>+#include "indirect_reqsize.h"
> #include "g_disptab_EXT.h"
> 
> __GLXrenderSizeData __glXRenderSizeTable[__GLX_MAX_RENDER_OPCODE_EXT - __GLX_MIN_RENDER_OPCODE_EXT + 1] = {
>@@ -272,7 +273,7 @@
> 	/* no such opcode      */       {   0,  0                         },
> 	/* no such opcode      */       {   0,  0                         },
> 	/* no such opcode      */       {   0,  0                         },
>-	/* WindowPos3fARB        230 */ {  16,  0                         },
>+	/* WindowPos3fvMESA      230 */ {  16,  0                         },
> };
> __GLXrenderSizeData __glXRenderSizeTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT - __GLX_MIN_RENDER_OPCODE_EXT + 1] = {
> 	/* ColorTable          2053 */  {  44,  __glXColorTableReqSize    },
>@@ -287,8 +288,8 @@
> 	/* no such opcode      */       {   0,  0                         },
> 	/* no such opcode      */       {   0,  0                         },
> 	/* no such opcode      */       {   0,  0                         },
>-	/* PointParameterfARB   2065 */ {  12,  0                         },
>-	/* PointParameterfvARB  2066 */ {   8,  __glXPointParameterfvARBReqSize },
>+	/* PointParameterfEXT   2065 */ {  12,  0                         },
>+	/* PointParameterfvEXT  2066 */ {   8,  __glXPointParameterfvEXTReqSize },
> 	/* no such opcode      */       {   0,  0                         },
> 	/* no such opcode      */       {   0,  0                         },
> 	/* no such opcode      */       {   0,  0                         },
>@@ -2443,6 +2444,6 @@
> 	/* no such opcode      */	{   0, 	0                         },
> 	/* no such opcode      */	{   0, 	0                         },
> 	/* ActiveStencilFaceEXT 4220 */ {   8,  0 },
>-	/* PointParameteri      4221 */	{  12, 	0 },
>-	/* PointParameteriv     4222 */	{   8, 	__glXPointParameterivReqSize },
>+	/* PointParameteriNV    4221 */	{  12, 	0 },
>+	/* PointParameterivNV   4222 */	{   8, 	__glXPointParameterivNVReqSize },
> };
>Index: xorg/GL/glx/single2.c
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/single2.c,v
>retrieving revision 1.8
>diff -u -d -r1.8 single2.c
>--- xorg/GL/glx/single2.c	3 Jul 2005 07:01:02 -0000	1.8
>+++ xorg/GL/glx/single2.c	12 Jan 2006 00:04:17 -0000
>@@ -42,9 +42,13 @@
> #include "glxserver.h"
> #include "glxutil.h"
> #include "glxext.h"
>+#include "indirect_dispatch.h"
> #include "unpack.h"
>-#include "g_disptab.h"
> #include "GL/glx_ansic.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
>+#include "dispatch.h"
> 
> int __glXDisp_FeedbackBuffer(__GLXclientState *cl, GLbyte *pc)
> {
>@@ -71,7 +75,7 @@
> 	}
> 	cx->feedbackBufSize = size;
>     }
>-    glFeedbackBuffer(size, type, cx->feedbackBuf);
>+    CALL_FeedbackBuffer( GET_DISPATCH(), (size, type, cx->feedbackBuf) );
>     __GLX_NOTE_UNFLUSHED_CMDS(cx);
>     return Success;
> }
>@@ -99,7 +103,7 @@
> 	}
> 	cx->selectBufSize = size;
>     }
>-    glSelectBuffer(size, cx->selectBuf);
>+    CALL_SelectBuffer( GET_DISPATCH(), (size, cx->selectBuf) );
>     __GLX_NOTE_UNFLUSHED_CMDS(cx);
>     return Success;
> }
>@@ -121,10 +125,10 @@
> 
>     pc += __GLX_SINGLE_HDR_SIZE;
>     newMode = *(GLenum*) pc;
>-    retval = glRenderMode(newMode);
>+    retval = CALL_RenderMode( GET_DISPATCH(), (newMode) );
> 
>     /* Check that render mode worked */
>-    glGetIntegerv(GL_RENDER_MODE, &newModeCheck);
>+    CALL_GetIntegerv( GET_DISPATCH(), (GL_RENDER_MODE, &newModeCheck) );
>     if (newModeCheck != newMode) {
> 	/* Render mode change failed.  Bail */
> 	newMode = newModeCheck;
>@@ -212,7 +216,7 @@
> 		return error;
> 	}
> 
>-	glFlush();
>+	CALL_Flush( GET_DISPATCH(), () );
> 	__GLX_NOTE_FLUSHED_CMDS(cx);
> 	return Success;
> }
>@@ -229,7 +233,7 @@
>     }
> 
>     /* Do a local glFinish */
>-    glFinish();
>+    CALL_Finish( GET_DISPATCH(), () );
>     __GLX_NOTE_FLUSHED_CMDS(cx);
> 
>     /* Send empty reply packet to indicate finish is finished */
>@@ -326,7 +330,7 @@
> 
>     pc += __GLX_SINGLE_HDR_SIZE;
>     name = *(GLenum *)(pc + 0);
>-    string = (const char *)glGetString(name);
>+    string = (const char *) CALL_GetString( GET_DISPATCH(), (name) );
>     client = cl->client;
> 
>     /*
>@@ -382,30 +386,3 @@
> {
>     return DoGetString(cl, pc, GL_FALSE);
> }
>-
>-int __glXDisp_GetClipPlane(__GLXclientState *cl, GLbyte *pc)
>-{
>-    __GLXcontext *cx;
>-    ClientPtr client = cl->client;
>-    int error;
>-    GLdouble answer[4];
>-
>-    cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-    if (!cx) {
>-	return error;
>-    }
>-    pc += __GLX_SINGLE_HDR_SIZE;
>-
>-    __glXClearErrorOccured();
>-    glGetClipPlane(*(GLenum   *)(pc + 0), answer);
>-    if (__glXErrorOccured()) {
>-	__GLX_BEGIN_REPLY(0);
>-	__GLX_SEND_HEADER();
>-    } else {
>-	__GLX_BEGIN_REPLY(32);
>-	__GLX_SEND_HEADER();
>-	__GLX_SEND_DOUBLE_ARRAY(4);
>-    }
>-    return Success;
>-}
>-
>Index: xorg/GL/glx/single2swap.c
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/single2swap.c,v
>retrieving revision 1.3
>diff -u -d -r1.3 single2swap.c
>--- xorg/GL/glx/single2swap.c	3 Jul 2005 07:01:02 -0000	1.3
>+++ xorg/GL/glx/single2swap.c	12 Jan 2006 00:04:17 -0000
>@@ -42,9 +42,13 @@
> #include "glxserver.h"
> #include "glxutil.h"
> #include "glxext.h"
>+#include "indirect_dispatch.h"
> #include "unpack.h"
>-#include "g_disptab.h"
> #include "GL/glx_ansic.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
>+#include "dispatch.h"
> 
> int __glXDispSwap_FeedbackBuffer(__GLXclientState *cl, GLbyte *pc)
> {
>@@ -75,7 +79,7 @@
> 	}
> 	cx->feedbackBufSize = size;
>     }
>-    glFeedbackBuffer(size, type, cx->feedbackBuf);
>+    CALL_FeedbackBuffer( GET_DISPATCH(), (size, type, cx->feedbackBuf) );
>     __GLX_NOTE_UNFLUSHED_CMDS(cx);
>     return Success;
> }
>@@ -106,7 +110,7 @@
> 	}
> 	cx->selectBufSize = size;
>     }
>-    glSelectBuffer(size, cx->selectBuf);
>+    CALL_SelectBuffer( GET_DISPATCH(), (size, cx->selectBuf) );
>     __GLX_NOTE_UNFLUSHED_CMDS(cx);
>     return Success;
> }
>@@ -132,10 +136,10 @@
>     pc += __GLX_SINGLE_HDR_SIZE;
>     __GLX_SWAP_INT(pc);
>     newMode = *(GLenum*) pc;
>-    retval = glRenderMode(newMode);
>+    retval = CALL_RenderMode( GET_DISPATCH(), (newMode) );
> 
>     /* Check that render mode worked */
>-    glGetIntegerv(GL_RENDER_MODE, &newModeCheck);
>+    CALL_GetIntegerv( GET_DISPATCH(), (GL_RENDER_MODE, &newModeCheck) );
>     if (newModeCheck != newMode) {
> 	/* Render mode change failed.  Bail */
> 	newMode = newModeCheck;
>@@ -232,7 +236,7 @@
> 		return error;
> 	}
> 
>-	glFlush();
>+	CALL_Flush( GET_DISPATCH(), () );
> 	__GLX_NOTE_FLUSHED_CMDS(cx);
> 	return Success;
> }
>@@ -251,7 +255,7 @@
>     }
> 
>     /* Do a local glFinish */
>-    glFinish();
>+    CALL_Finish( GET_DISPATCH(), () );
>     __GLX_NOTE_FLUSHED_CMDS(cx);
> 
>     /* Send empty reply packet to indicate finish is finished */
>@@ -268,36 +272,3 @@
> {
>     return DoGetString(cl, pc, GL_TRUE);
> }
>-
>-int __glXDispSwap_GetClipPlane(__GLXclientState *cl, GLbyte *pc)
>-{
>-    __GLXcontext *cx;
>-    ClientPtr client = cl->client;
>-    int error;
>-    GLdouble answer[4];
>-    __GLX_DECLARE_SWAP_VARIABLES;
>-    __GLX_DECLARE_SWAP_ARRAY_VARIABLES;
>-
>-    __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
>-    cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
>-    if (!cx) {
>-	return error;
>-    }
>-    pc += __GLX_SINGLE_HDR_SIZE;
>-    __GLX_SWAP_INT(pc + 0);
>-
>-    __glXClearErrorOccured();
>-    glGetClipPlane(*(GLenum   *)(pc + 0), answer);
>-    if (__glXErrorOccured()) {
>-	__GLX_BEGIN_REPLY(0);
>-	__GLX_SWAP_REPLY_HEADER();
>-	__GLX_SEND_HEADER();
>-    } else {
>-	__GLX_SWAP_DOUBLE_ARRAY((GLbyte *)answer, 4);
>-	__GLX_BEGIN_REPLY(32);
>-	__GLX_SWAP_REPLY_HEADER();
>-	__GLX_SEND_HEADER();
>-	__GLX_SEND_DOUBLE_ARRAY(4);
>-    }
>-    return Success;
>-}
>Index: xorg/GL/glx/singlepix.c
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/singlepix.c,v
>retrieving revision 1.3
>diff -u -d -r1.3 singlepix.c
>--- xorg/GL/glx/singlepix.c	3 Jul 2005 07:01:02 -0000	1.3
>+++ xorg/GL/glx/singlepix.c	12 Jan 2006 00:04:17 -0000
>@@ -43,8 +43,12 @@
> #include "glxext.h"
> #include "singlesize.h"
> #include "unpack.h"
>-#include "g_disptab.h"
>-#include "g_disptab_EXT.h"
>+#include "indirect_size_get.h"
>+#include "indirect_dispatch.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
>+#include "dispatch.h"
> 
> int __glXDisp_ReadPixels(__GLXclientState *cl, GLbyte *pc)
> {
>@@ -72,11 +76,11 @@
>     compsize = __glReadPixels_size(format,type,width,height);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
>-    glPixelStorei(GL_PACK_LSB_FIRST, lsbFirst);
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_LSB_FIRST, lsbFirst) );
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glReadPixels(
>+    CALL_ReadPixels( GET_DISPATCH(), (
> 		 *(GLint    *)(pc + 0),
> 		 *(GLint    *)(pc + 4),
> 		 *(GLsizei  *)(pc + 8),
>@@ -84,7 +88,7 @@
> 		 *(GLenum   *)(pc + 16),
> 		 *(GLenum   *)(pc + 20),
> 		 answer
>-		 );
>+		 ) );
> 
>     if (__glXErrorOccured()) {
> 	__GLX_BEGIN_REPLY(0);
>@@ -120,10 +124,10 @@
>     target = *(GLenum *)(pc + 0);
>     swapBytes = *(GLboolean *)(pc + 16);
> 
>-    glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, &width);
>-    glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, &height);
>+    CALL_GetTexLevelParameteriv( GET_DISPATCH(), (target, level, GL_TEXTURE_WIDTH, &width) );
>+    CALL_GetTexLevelParameteriv( GET_DISPATCH(), (target, level, GL_TEXTURE_HEIGHT, &height) );
>     if ( target == GL_TEXTURE_3D) {
>-	glGetTexLevelParameteriv(target, level, GL_TEXTURE_DEPTH, &depth);
>+	CALL_GetTexLevelParameteriv( GET_DISPATCH(), (target, level, GL_TEXTURE_DEPTH, &depth) );
>     }
>     /*
>      * The three queries above might fail if we're in a state where queries
>@@ -132,16 +136,16 @@
>     compsize = __glGetTexImage_size(target,level,format,type,width,height,depth);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, swapBytes) );
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetTexImage(
>+    CALL_GetTexImage( GET_DISPATCH(), (
> 		  *(GLenum   *)(pc + 0),
> 		  *(GLint    *)(pc + 4),
> 		  *(GLenum   *)(pc + 8),
> 		  *(GLenum   *)(pc + 12),
> 		  answer
>-		  );
>+		  ) );
> 
>     if (__glXErrorOccured()) {
> 	__GLX_BEGIN_REPLY(0);
>@@ -174,13 +178,11 @@
>     pc += __GLX_SINGLE_HDR_SIZE;
>     lsbFirst = *(GLboolean *)(pc + 0);
> 
>-    glPixelStorei(GL_PACK_LSB_FIRST, lsbFirst);
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_LSB_FIRST, lsbFirst) );
>     __GLX_GET_ANSWER_BUFFER(answer,cl,128,1);
> 
>     __glXClearErrorOccured();
>-    glGetPolygonStipple(
>-			(GLubyte  *) answer
>-			);
>+    CALL_GetPolygonStipple( GET_DISPATCH(), ((GLubyte  *) answer) );
> 
>     if (__glXErrorOccured()) {
> 	__GLX_BEGIN_REPLY(0);
>@@ -218,8 +220,8 @@
>     /* target must be SEPARABLE_2D, however I guess we can let the GL
>        barf on this one.... */
> 
>-    glGetConvolutionParameteriv(target, GL_CONVOLUTION_WIDTH, &width);
>-    glGetConvolutionParameteriv(target, GL_CONVOLUTION_HEIGHT, &height);
>+    CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_WIDTH, &width) );
>+    CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_HEIGHT, &height) );
>     /*
>      * The two queries above might fail if we're in a state where queries
>      * are illegal, but then width and height would still be zero anyway.
>@@ -232,17 +234,17 @@
>     compsize = __GLX_PAD(compsize);
>     compsize2 = __GLX_PAD(compsize2);
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, swapBytes) );
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize + compsize2,1);
>     __glXClearErrorOccured();
>-    glGetSeparableFilter(
>+    CALL_GetSeparableFilter( GET_DISPATCH(), (
> 		  *(GLenum   *)(pc + 0),
> 		  *(GLenum   *)(pc + 4),
> 		  *(GLenum   *)(pc + 8),
> 		  answer,
> 		  answer + compsize,
> 		  NULL
>-		  );
>+		  ) );
> 
>     if (__glXErrorOccured()) {
> 	__GLX_BEGIN_REPLY(0);
>@@ -280,11 +282,11 @@
>     target = *(GLenum *)(pc + 0);
>     swapBytes = *(GLboolean *)(pc + 12);
> 
>-    glGetConvolutionParameteriv(target, GL_CONVOLUTION_WIDTH, &width);
>+    CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_WIDTH, &width) );
>     if (target == GL_CONVOLUTION_1D) {
>         height = 1;
>     } else {
>-	glGetConvolutionParameteriv(target, GL_CONVOLUTION_HEIGHT, &height);
>+	CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_HEIGHT, &height) );
>     }
>     /*
>      * The two queries above might fail if we're in a state where queries
>@@ -293,15 +295,15 @@
>     compsize = __glGetTexImage_size(target,1,format,type,width,height,1);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, swapBytes) );
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetConvolutionFilter(
>+    CALL_GetConvolutionFilter( GET_DISPATCH(), (
> 		  *(GLenum   *)(pc + 0),
> 		  *(GLenum   *)(pc + 4),
> 		  *(GLenum   *)(pc + 8),
> 		  answer
>-		  );
>+		  ) );
> 
>     if (__glXErrorOccured()) {
> 	__GLX_BEGIN_REPLY(0);
>@@ -340,7 +342,7 @@
>     swapBytes = *(GLboolean *)(pc + 12);
>     reset = *(GLboolean *)(pc + 13);
> 
>-    glGetHistogramParameteriv(target, GL_HISTOGRAM_WIDTH, &width);
>+    CALL_GetHistogramParameteriv( GET_DISPATCH(), (target, GL_HISTOGRAM_WIDTH, &width) );
>     /*
>      * The one query above might fail if we're in a state where queries
>      * are illegal, but then width would still be zero anyway.
>@@ -348,10 +350,10 @@
>     compsize = __glGetTexImage_size(target,1,format,type,width,1,1);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, swapBytes) );
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetHistogram( target, reset, format, type, answer);
>+    CALL_GetHistogram( GET_DISPATCH(), (target, reset, format, type, answer) );
> 
>     if (__glXErrorOccured()) {
> 	__GLX_BEGIN_REPLY(0);
>@@ -391,10 +393,10 @@
>     compsize = __glGetTexImage_size(target,1,format,type,2,1,1);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, swapBytes) );
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetMinmax( target, reset, format, type, answer);
>+    CALL_GetMinmax( GET_DISPATCH(), (target, reset, format, type, answer) );
> 
>     if (__glXErrorOccured()) {
> 	__GLX_BEGIN_REPLY(0);
>@@ -430,7 +432,7 @@
>     type = *(GLenum *)(pc + 8);
>     swapBytes = *(GLboolean *)(pc + 12);
> 
>-    glGetColorTableParameteriv(target, GL_COLOR_TABLE_WIDTH, &width);
>+    CALL_GetColorTableParameteriv( GET_DISPATCH(), (target, GL_COLOR_TABLE_WIDTH, &width) );
>     /*
>      * The one query above might fail if we're in a state where queries
>      * are illegal, but then width would still be zero anyway.
>@@ -438,15 +440,15 @@
>     compsize = __glGetTexImage_size(target,1,format,type,width,1,1);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, swapBytes) );
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetColorTable(
>+    CALL_GetColorTable( GET_DISPATCH(), (
> 		  *(GLenum   *)(pc + 0),
> 		  *(GLenum   *)(pc + 4),
> 		  *(GLenum   *)(pc + 8),
> 		  answer
>-		  );
>+		  ) );
> 
>     if (__glXErrorOccured()) {
> 	__GLX_BEGIN_REPLY(0);
>Index: xorg/GL/glx/singlepixswap.c
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/singlepixswap.c,v
>retrieving revision 1.3
>diff -u -d -r1.3 singlepixswap.c
>--- xorg/GL/glx/singlepixswap.c	3 Jul 2005 07:01:02 -0000	1.3
>+++ xorg/GL/glx/singlepixswap.c	12 Jan 2006 00:04:17 -0000
>@@ -43,8 +43,12 @@
> #include "glxext.h"
> #include "singlesize.h"
> #include "unpack.h"
>-#include "g_disptab.h"
>-#include "g_disptab_EXT.h"
>+#include "indirect_dispatch.h"
>+#include "indirect_size_get.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
>+#include "dispatch.h"
> 
> int __glXDispSwap_ReadPixels(__GLXclientState *cl, GLbyte *pc)
> {
>@@ -81,18 +85,18 @@
>     compsize = __glReadPixels_size(format,type,width,height);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
>-    glPixelStorei(GL_PACK_LSB_FIRST, lsbFirst);
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_LSB_FIRST, lsbFirst) );
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glReadPixels(
>-		 *(GLint    *)(pc + 0),
>+    CALL_ReadPixels( GET_DISPATCH(),
>+		 (*(GLint    *)(pc + 0),
> 		 *(GLint    *)(pc + 4),
> 		 *(GLsizei  *)(pc + 8),
> 		 *(GLsizei  *)(pc + 12),
> 		 *(GLenum   *)(pc + 16),
> 		 *(GLenum   *)(pc + 20),
>-		 answer
>+		 answer)
> 		 );
> 
>     if (__glXErrorOccured()) {
>@@ -138,10 +142,10 @@
>     target = *(GLenum *)(pc + 0);
>     swapBytes = *(GLboolean *)(pc + 16);
> 
>-    glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, &width);
>-    glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, &height);
>+    CALL_GetTexLevelParameteriv( GET_DISPATCH(), (target, level, GL_TEXTURE_WIDTH, &width) );
>+    CALL_GetTexLevelParameteriv( GET_DISPATCH(), (target, level, GL_TEXTURE_HEIGHT, &height) );
>     if ( target == GL_TEXTURE_3D) {
>-	glGetTexLevelParameteriv(target, level, GL_TEXTURE_DEPTH, &depth);
>+	CALL_GetTexLevelParameteriv( GET_DISPATCH(), (target, level, GL_TEXTURE_DEPTH, &depth) );
>     }
>     /*
>      * The three queries above might fail if we're in a state where queries
>@@ -150,16 +154,16 @@
>     compsize = __glGetTexImage_size(target,level,format,type,width,height,depth);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) );
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetTexImage(
>+    CALL_GetTexImage( GET_DISPATCH(), (
> 		  *(GLenum   *)(pc + 0),
> 		  *(GLint    *)(pc + 4),
> 		  *(GLenum   *)(pc + 8),
> 		  *(GLenum   *)(pc + 12),
> 		  answer
>-		  );
>+		  ) );
> 
>     if (__glXErrorOccured()) {
> 	__GLX_BEGIN_REPLY(0);
>@@ -198,13 +202,11 @@
>     pc += __GLX_SINGLE_HDR_SIZE;
>     lsbFirst = *(GLboolean *)(pc + 0);
> 
>-    glPixelStorei(GL_PACK_LSB_FIRST, lsbFirst);
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_LSB_FIRST, lsbFirst) );
>     __GLX_GET_ANSWER_BUFFER(answer,cl,128,1);
> 
>     __glXClearErrorOccured();
>-    glGetPolygonStipple(
>-			(GLubyte  *) answer
>-			);
>+    CALL_GetPolygonStipple( GET_DISPATCH(), ((GLubyte  *) answer) );
>     if (__glXErrorOccured()) {
> 	__GLX_BEGIN_REPLY(0);
> 	__GLX_SWAP_REPLY_HEADER();
>@@ -248,8 +250,8 @@
>     /* target must be SEPARABLE_2D, however I guess we can let the GL
>        barf on this one.... */
> 
>-    glGetConvolutionParameteriv(target, GL_CONVOLUTION_WIDTH, &width);
>-    glGetConvolutionParameteriv(target, GL_CONVOLUTION_HEIGHT, &height);
>+    CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_WIDTH, &width) );
>+    CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_HEIGHT, &height) );
>     /*
>      * The two queries above might fail if we're in a state where queries
>      * are illegal, but then width and height would still be zero anyway.
>@@ -262,17 +264,17 @@
>     compsize = __GLX_PAD(compsize);
>     compsize2 = __GLX_PAD(compsize2);
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) );
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize + compsize2,1);
>     __glXClearErrorOccured();
>-    glGetSeparableFilter(
>+    CALL_GetSeparableFilter( GET_DISPATCH(), (
> 		  *(GLenum   *)(pc + 0),
> 		  *(GLenum   *)(pc + 4),
> 		  *(GLenum   *)(pc + 8),
> 		  answer,
> 		  answer + compsize,
> 		  NULL
>-		  );
>+		  ) );
> 
>     if (__glXErrorOccured()) {
> 	__GLX_BEGIN_REPLY(0);
>@@ -317,11 +319,11 @@
>     target = *(GLenum *)(pc + 0);
>     swapBytes = *(GLboolean *)(pc + 12);
> 
>-    glGetConvolutionParameteriv(target, GL_CONVOLUTION_WIDTH, &width);
>+    CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_WIDTH, &width) );
>     if (target == GL_CONVOLUTION_2D) {
>         height = 1;
>     } else {
>-	glGetConvolutionParameteriv(target, GL_CONVOLUTION_HEIGHT, &height);
>+	CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_HEIGHT, &height) );
>     }
>     /*
>      * The two queries above might fail if we're in a state where queries
>@@ -330,15 +332,15 @@
>     compsize = __glGetTexImage_size(target,1,format,type,width,height,1);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) );
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetConvolutionFilter(
>+    CALL_GetConvolutionFilter( GET_DISPATCH(), (
> 		  *(GLenum   *)(pc + 0),
> 		  *(GLenum   *)(pc + 4),
> 		  *(GLenum   *)(pc + 8),
> 		  answer
>-		  );
>+		  ) );
> 
>     if (__glXErrorOccured()) {
> 	__GLX_BEGIN_REPLY(0);
>@@ -384,7 +386,7 @@
>     swapBytes = *(GLboolean *)(pc + 12);
>     reset = *(GLboolean *)(pc + 13);
> 
>-    glGetHistogramParameteriv(target, GL_HISTOGRAM_WIDTH, &width);
>+    CALL_GetHistogramParameteriv( GET_DISPATCH(), (target, GL_HISTOGRAM_WIDTH, &width) );
>     /*
>      * The one query above might fail if we're in a state where queries
>      * are illegal, but then width would still be zero anyway.
>@@ -392,10 +394,10 @@
>     compsize = __glGetTexImage_size(target,1,format,type,width,1,1);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) );
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetHistogram( target, reset, format, type, answer);
>+    CALL_GetHistogram( GET_DISPATCH(), (target, reset, format, type, answer) );
> 
>     if (__glXErrorOccured()) {
> 	__GLX_BEGIN_REPLY(0);
>@@ -441,10 +443,10 @@
>     compsize = __glGetTexImage_size(target,1,format,type,2,1,1);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) );
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetMinmax( target, reset, format, type, answer);
>+    CALL_GetMinmax( GET_DISPATCH(), (target, reset, format, type, answer) );
> 
>     if (__glXErrorOccured()) {
> 	__GLX_BEGIN_REPLY(0);
>@@ -485,7 +487,7 @@
>     target = *(GLenum *)(pc + 0);
>     swapBytes = *(GLboolean *)(pc + 12);
> 
>-    glGetColorTableParameteriv(target, GL_COLOR_TABLE_WIDTH, &width);
>+    CALL_GetColorTableParameteriv( GET_DISPATCH(), (target, GL_COLOR_TABLE_WIDTH, &width) );
>     /*
>      * The one query above might fail if we're in a state where queries
>      * are illegal, but then width would still be zero anyway.
>@@ -493,15 +495,15 @@
>     compsize = __glGetTexImage_size(target,1,format,type,width,1,1);
>     if (compsize < 0) compsize = 0;
> 
>-    glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) );
>     __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
>     __glXClearErrorOccured();
>-    glGetColorTable(
>+    CALL_GetColorTable( GET_DISPATCH(), (
> 		  *(GLenum   *)(pc + 0),
> 		  *(GLenum   *)(pc + 4),
> 		  *(GLenum   *)(pc + 8),
> 		  answer
>-		  );
>+		  ) );
> 
>     if (__glXErrorOccured()) {
> 	__GLX_BEGIN_REPLY(0);
>Index: xorg/GL/glx/singlesize.c
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/singlesize.c,v
>retrieving revision 1.7
>diff -u -d -r1.7 singlesize.c
>--- xorg/GL/glx/singlesize.c	1 Oct 2005 22:25:13 -0000	1.7
>+++ xorg/GL/glx/singlesize.c	12 Jan 2006 00:04:17 -0000
>@@ -41,6 +41,11 @@
> #include <GL/gl.h>
> #include "glxserver.h"
> #include "singlesize.h"
>+#include "indirect_size_get.h"
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
>+#include "dispatch.h"
> 
> /*
> ** These routines compute the size of variable-size returned parameters.
>@@ -54,183 +59,6 @@
>     return __glXImageSize( format, type, 0, w, h, 1, 0, 0, 0, 0, 4 );
> }
> 
>-/**
>- * Determine the number of data elements that go with the specified \c pname
>- * to a \c glGetTexEnvfv or \c glGetTexEnviv call.
>- * 
>- * \todo
>- * Replace this function with a call to \c __glTexEnvfv_size.  Make that there
>- * aren't any values of \c pname that are valid for one but not the other.
>- */
>-GLint __glGetTexEnvfv_size(GLenum pname)
>-{
>-    switch (pname) {
>-      case GL_TEXTURE_ENV_MODE:
>-      case GL_TEXTURE_LOD_BIAS:
>-      case GL_COMBINE_RGB:
>-      case GL_COMBINE_ALPHA:
>-      case GL_SOURCE0_RGB:
>-      case GL_SOURCE1_RGB:
>-      case GL_SOURCE2_RGB:
>-      case GL_SOURCE0_ALPHA:
>-      case GL_SOURCE1_ALPHA:
>-      case GL_SOURCE2_ALPHA:
>-      case GL_OPERAND0_RGB:
>-      case GL_OPERAND1_RGB:
>-      case GL_OPERAND2_RGB:
>-      case GL_OPERAND0_ALPHA:
>-      case GL_OPERAND1_ALPHA:
>-      case GL_OPERAND2_ALPHA:
>-      case GL_RGB_SCALE:
>-      case GL_ALPHA_SCALE:
>-	
>-      /* GL_ARB_point_sprite / GL_NV_point_sprite */
>-      case GL_COORD_REPLACE_ARB:
>-
>-      /* GL_NV_texture_env_combine4 */
>-      case GL_SOURCE3_RGB_NV:
>-      case GL_SOURCE3_ALPHA_NV:
>-      case GL_OPERAND3_RGB_NV:
>-      case GL_OPERAND3_ALPHA_NV:
>-	return 1;
>-
>-      case GL_TEXTURE_ENV_COLOR:
>-	return 4;
>-      default:
>-	return -1;
>-    }
>-}
>-
>-
>-GLint __glGetTexEnviv_size(GLenum pname)
>-{
>-    return __glGetTexEnvfv_size(pname);
>-}
>-
>-GLint __glGetTexGenfv_size(GLenum pname)
>-{
>-    switch (pname) {
>-      case GL_TEXTURE_GEN_MODE:
>-	return 1;
>-      case GL_OBJECT_PLANE:
>-	return 4;
>-      case GL_EYE_PLANE:
>-	return 4;
>-      default:
>-	return -1;
>-    }
>-}
>-
>-GLint __glGetTexGendv_size(GLenum pname)
>-{
>-    return __glGetTexGenfv_size(pname);
>-}
>-
>-GLint __glGetTexGeniv_size(GLenum pname)
>-{
>-    return __glGetTexGenfv_size(pname);
>-}
>-
>-GLint __glGetTexParameterfv_size(GLenum pname)
>-{
>-    switch (pname) {
>-      case GL_TEXTURE_BORDER_COLOR:
>-	return 4;
>-
>-      case GL_TEXTURE_WRAP_S:
>-      case GL_TEXTURE_WRAP_T:
>-      case GL_TEXTURE_WRAP_R:
>-      case GL_TEXTURE_MIN_FILTER:
>-      case GL_TEXTURE_MAG_FILTER:
>-      case GL_TEXTURE_PRIORITY:
>-      case GL_TEXTURE_RESIDENT:
>-       
>-      /* GL_SGIS_texture_lod / GL_EXT_texture_lod / GL 1.2 */
>-      case GL_TEXTURE_MIN_LOD:
>-      case GL_TEXTURE_MAX_LOD:
>-      case GL_TEXTURE_BASE_LEVEL:
>-      case GL_TEXTURE_MAX_LEVEL:
>-
>-      /* GL_SGIX_texture_lod_bias */
>-      case GL_TEXTURE_LOD_BIAS_S_SGIX:
>-      case GL_TEXTURE_LOD_BIAS_T_SGIX:
>-      case GL_TEXTURE_LOD_BIAS_R_SGIX:
>-
>-      /* GL_ARB_shadow / GL 1.4 */
>-      case GL_TEXTURE_COMPARE_MODE:
>-      case GL_TEXTURE_COMPARE_FUNC:
>-
>-      /* GL_SGIS_generate_mipmap / GL 1.4 */
>-      case GL_GENERATE_MIPMAP:
>-
>-      /* GL_ARB_depth_texture / GL 1.4 */
>-      case GL_DEPTH_TEXTURE_MODE:
>-
>-      /* GL_EXT_texture_lod_bias / GL 1.4 */
>-      case GL_TEXTURE_LOD_BIAS:
>-
>-      /* GL_SGIX_shadow_ambient / GL_ARB_shadow_ambient */
>-      case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
>-
>-      /* GL_SGIX_shadow */
>-      case GL_TEXTURE_COMPARE_SGIX:
>-      case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
>-
>-      /* GL_SGIX_texture_coordinate_clamp */
>-      case GL_TEXTURE_MAX_CLAMP_S_SGIX:
>-      case GL_TEXTURE_MAX_CLAMP_T_SGIX:
>-      case GL_TEXTURE_MAX_CLAMP_R_SGIX:
>-
>-      /* GL_EXT_texture_filter_anisotropic */
>-      case GL_TEXTURE_MAX_ANISOTROPY_EXT:
>-
>-      /* GL_NV_texture_expand_normal */
>-      case GL_TEXTURE_UNSIGNED_REMAP_MODE_NV:
>-	return 1;
>-
>-      default:
>-	return -1;
>-    }
>-}
>-
>-GLint __glGetTexParameteriv_size(GLenum pname)
>-{
>-    return __glGetTexParameterfv_size(pname);
>-}
>-
>-GLint __glGetLightfv_size(GLenum pname)
>-{
>-    switch (pname) {
>-      case GL_AMBIENT:
>-	return 4;
>-      case GL_DIFFUSE:
>-	return 4;
>-      case GL_SPECULAR:
>-	return 4;
>-      case GL_POSITION:
>-	return 4;
>-      case GL_SPOT_DIRECTION:
>-	return 3;
>-      case GL_SPOT_EXPONENT:
>-	return 1;
>-      case GL_SPOT_CUTOFF:
>-	return 1;
>-      case GL_CONSTANT_ATTENUATION:
>-	return 1;
>-      case GL_LINEAR_ATTENUATION:
>-	return 1;
>-      case GL_QUADRATIC_ATTENUATION:
>-	return 1;
>-      default:
>-	return -1;
>-    }
>-}
>-
>-GLint __glGetLightiv_size(GLenum pname)
>-{
>-    return __glGetLightfv_size(pname);
>-}
>-
> GLint __glGetMap_size(GLenum target, GLenum query)
> {
>     GLint k, order=0, majorMinor[2];
>@@ -251,7 +79,7 @@
> 	switch (query) {
> 	  case GL_COEFF:
> 	    k = __glMap1d_size(target);
>-	    glGetMapiv(target, GL_ORDER, &order);
>+	    CALL_GetMapiv( GET_DISPATCH(), (target, GL_ORDER, &order) );
> 	    /*
> 	    ** The query above might fail, but then order will be zero anyway.
> 	    */
>@@ -275,7 +103,7 @@
> 	  case GL_COEFF:
> 	    k = __glMap2d_size(target);
> 	    majorMinor[0] = majorMinor[1] = 0;
>-	    glGetMapiv(target, GL_ORDER, majorMinor);
>+	    CALL_GetMapiv( GET_DISPATCH(), (target, GL_ORDER, majorMinor) );
> 	    /*
> 	    ** The query above might fail, but then majorMinor will be zeroes
> 	    */
>@@ -305,33 +133,6 @@
>     return __glGetMap_size(target, query);
> }
> 
>-GLint __glGetMaterialfv_size(GLenum pname)
>-{
>-    switch (pname) {
>-      case GL_SHININESS:
>-	return 1;
>-      case GL_COLOR_INDEXES:
>-	return 3;
>-      case GL_EMISSION:
>-	return 4;
>-      case GL_AMBIENT:
>-	return 4;
>-      case GL_DIFFUSE:
>-	return 4;
>-      case GL_SPECULAR:
>-	return 4;
>-      case GL_AMBIENT_AND_DIFFUSE:
>-	return 4;
>-      default:
>-	return -1;
>-    }
>-}
>-
>-GLint __glGetMaterialiv_size(GLenum pname)
>-{
>-    return __glGetMaterialfv_size(pname);
>-}
>-
> GLint __glGetPixelMap_size(GLenum map)
> {
>     GLint size;
>@@ -371,7 +172,7 @@
>       default:
> 	return -1;
>     }
>-    glGetIntegerv(query, &size);
>+    CALL_GetIntegerv( GET_DISPATCH(), (query, &size) );
>     return size;
> }
> 
>@@ -390,833 +191,9 @@
>     return __glGetPixelMap_size(map);
> }
> 
>-/*
>-** Return the number of words needed to pass back the requested
>-** value.
>-*/
>-GLint __glGet_size(GLenum sq)
>-{
>-    switch (sq) {
>-      case GL_MAX_TEXTURE_SIZE:
>-	return 1;
>-      case GL_SUBPIXEL_BITS:
>-	return 1;
>-      case GL_MAX_LIST_NESTING:
>-	return 1;
>-      case GL_MAP1_COLOR_4:
>-      case GL_MAP1_INDEX:
>-      case GL_MAP1_NORMAL:
>-      case GL_MAP1_TEXTURE_COORD_1:
>-      case GL_MAP1_TEXTURE_COORD_2:
>-      case GL_MAP1_TEXTURE_COORD_3:
>-      case GL_MAP1_TEXTURE_COORD_4:
>-      case GL_MAP1_VERTEX_3:
>-      case GL_MAP1_VERTEX_4:
>-	return 1;
>-      case GL_MAP2_COLOR_4:
>-      case GL_MAP2_INDEX:
>-      case GL_MAP2_NORMAL:
>-      case GL_MAP2_TEXTURE_COORD_1:
>-      case GL_MAP2_TEXTURE_COORD_2:
>-      case GL_MAP2_TEXTURE_COORD_3:
>-      case GL_MAP2_TEXTURE_COORD_4:
>-      case GL_MAP2_VERTEX_3:
>-      case GL_MAP2_VERTEX_4:
>-	return 1;
>-      case GL_AUTO_NORMAL:
>-	return 1;
>-      case GL_CURRENT_COLOR:
>-	return 4;
>-      case GL_CURRENT_INDEX:
>-	return 1;
>-      case GL_CURRENT_NORMAL:
>-	return 3;
>-      case GL_CURRENT_TEXTURE_COORDS:
>-	return 4;
>-      case GL_CURRENT_RASTER_INDEX:
>-	return 1;
>-      case GL_CURRENT_RASTER_COLOR:
>-	return 4;
>-      case GL_CURRENT_RASTER_TEXTURE_COORDS:
>-	return 4;
>-      case GL_CURRENT_RASTER_POSITION:
>-	return 4;
>-      case GL_CURRENT_RASTER_POSITION_VALID:
>-	return 1;
>-      case GL_CURRENT_RASTER_DISTANCE:
>-	return 1;
>-      case GL_POINT_SIZE:
>-	return 1;
>-      case GL_POINT_SIZE_RANGE:
>-      /* case GL_SMOOTH_POINT_SIZE_RANGE: */ /* alias */
>-	return 2;
>-      case GL_POINT_SIZE_GRANULARITY:
>-      /* case GL_SMOOTH_POINT_SIZE_GRANULARITY: */ /* alias */
>-	return 1;
>-      case GL_ALIASED_POINT_SIZE_RANGE:
>-	return 2;
>-      case GL_POINT_SMOOTH:
>-	return 1;
>-      case GL_LINE_SMOOTH:
>-	return 1;
>-      case GL_LINE_WIDTH:
>-	return 1;
>-      case GL_LINE_WIDTH_RANGE:
>-      /* case GL_SMOOTH_LINE_WIDTH_RANGE: */ /* alias */
>-	return 2;
>-      case GL_LINE_WIDTH_GRANULARITY:
>-      /* case GL_SMOOTH_LINE_WIDTH_GRANULARITY: */ /* alias */
>-	return 1;
>-      case GL_ALIASED_LINE_WIDTH_RANGE:
>-	return 2;
>-      case GL_LINE_STIPPLE_PATTERN:
>-	return 1;
>-      case GL_LINE_STIPPLE_REPEAT:
>-	return 1;
>-      case GL_LINE_STIPPLE:
>-	return 1;
>-      case GL_POLYGON_MODE:
>-	return 2;
>-      case GL_POLYGON_SMOOTH:
>-	return 1;
>-      case GL_POLYGON_STIPPLE:
>-	return 1;
>-      case GL_EDGE_FLAG:
>-	return 1;
>-      case GL_CULL_FACE:
>-	return 1;
>-      case GL_CULL_FACE_MODE:
>-	return 1;
>-      case GL_FRONT_FACE:
>-	return 1;
>-      case GL_LIGHTING:
>-	return 1;
>-      case GL_LIGHT_MODEL_LOCAL_VIEWER:
>-	return 1;
>-      case GL_LIGHT_MODEL_TWO_SIDE:
>-	return 1;
>-      case GL_LIGHT_MODEL_AMBIENT:
>-	return 4;
>-      case GL_LIGHT_MODEL_COLOR_CONTROL:
>-	return 1;
>-      case GL_COLOR_MATERIAL:
>-	return 1;
>-      case GL_COLOR_MATERIAL_FACE:
>-	return 1;
>-      case GL_COLOR_MATERIAL_PARAMETER:
>-	return 1;
>-      case GL_SHADE_MODEL:
>-	return 1;
>-      case GL_FOG:
>-	return 1;
>-      case GL_FOG_INDEX:
>-	return 1;
>-      case GL_FOG_DENSITY:
>-	return 1;
>-      case GL_FOG_START:
>-	return 1;
>-      case GL_FOG_END:
>-	return 1;
>-      case GL_FOG_MODE:
>-	return 1;
>-      case GL_FOG_COLOR:
>-	return 4;
>-      case GL_DEPTH_RANGE:
>-	return 2;
>-      case GL_DEPTH_TEST:
>-	return 1;
>-      case GL_DEPTH_WRITEMASK:
>-	return 1;
>-      case GL_DEPTH_CLEAR_VALUE:
>-	return 1;
>-      case GL_DEPTH_FUNC:
>-	return 1;
>-      case GL_ACCUM_CLEAR_VALUE:
>-	return 4;
>-      case GL_STENCIL_TEST:
>-	return 1;
>-      case GL_STENCIL_CLEAR_VALUE:
>-	return 1;
>-      case GL_STENCIL_FUNC:
>-	return 1;
>-      case GL_STENCIL_VALUE_MASK:
>-	return 1;
>-      case GL_STENCIL_FAIL:
>-	return 1;
>-      case GL_STENCIL_PASS_DEPTH_FAIL:
>-	return 1;
>-      case GL_STENCIL_PASS_DEPTH_PASS:
>-	return 1;
>-      case GL_STENCIL_REF:
>-	return 1;
>-      case GL_STENCIL_WRITEMASK:
>-	return 1;
>-      case GL_MATRIX_MODE:
>-	return 1;
>-      case GL_NORMALIZE:
>-	return 1;
>-      case GL_VIEWPORT:
>-	return 4;
>-      case GL_ATTRIB_STACK_DEPTH:
>-	return 1;
>-      case GL_MODELVIEW_STACK_DEPTH:
>-	return 1;
>-      case GL_PROJECTION_STACK_DEPTH:
>-	return 1;
>-      case GL_TEXTURE_STACK_DEPTH:
>-	return 1;
>-      case GL_MODELVIEW_MATRIX:
>-	return 16;
>-      case GL_PROJECTION_MATRIX:
>-	return 16;
>-      case GL_TEXTURE_MATRIX:
>-	return 16;
>-      case GL_ALPHA_TEST:
>-	return 1;
>-      case GL_ALPHA_TEST_FUNC:
>-	return 1;
>-      case GL_ALPHA_TEST_REF:
>-	return 1;
>-      case GL_DITHER:
>-	return 1;
>-      case GL_BLEND_DST:
>-	return 1;
>-      case GL_BLEND_SRC:
>-	return 1;
>-      case GL_BLEND:
>-	return 1;
>-      case GL_LOGIC_OP_MODE:
>-	return 1;
>-      case GL_LOGIC_OP:
>-	return 1;
>-      case GL_DRAW_BUFFER:
>-	return 1;
>-      case GL_READ_BUFFER:
>-	return 1;
>-      case GL_SCISSOR_TEST:
>-	return 1;
>-      case GL_SCISSOR_BOX:
>-	return 4;
>-      case GL_INDEX_CLEAR_VALUE:
>-	return 1;
>-      case GL_INDEX_MODE:
>-	return 1;
>-      case GL_INDEX_WRITEMASK:
>-	return 1;
>-      case GL_COLOR_CLEAR_VALUE:
>-	return 4;
>-      case GL_RGBA_MODE:
>-	return 1;
>-      case GL_COLOR_WRITEMASK:
>-	return 4;
>-      case GL_RENDER_MODE:
>-	return 1;
>-      case GL_PERSPECTIVE_CORRECTION_HINT:
>-	return 1;
>-      case GL_POINT_SMOOTH_HINT:
>-	return 1;
>-      case GL_LINE_SMOOTH_HINT:
>-	return 1;
>-      case GL_POLYGON_SMOOTH_HINT:
>-	return 1;
>-      case GL_FOG_HINT:
>-	return 1;
>-      case GL_LIST_BASE:
>-	return 1;
>-      case GL_LIST_INDEX:
>-	return 1;
>-      case GL_LIST_MODE:
>-	return 1;
>-      case GL_TEXTURE_GEN_S:
>-	return 1;
>-      case GL_TEXTURE_GEN_T:
>-	return 1;
>-      case GL_TEXTURE_GEN_R:
>-	return 1;
>-      case GL_TEXTURE_GEN_Q:
>-	return 1;
>-      case GL_PACK_SWAP_BYTES:
>-	return 1;
>-      case GL_PACK_LSB_FIRST:
>-	return 1;
>-      case GL_PACK_ROW_LENGTH:
>-	return 1;
>-      case GL_PACK_IMAGE_HEIGHT:
>-	return 1;
>-      case GL_PACK_SKIP_ROWS:
>-	return 1;
>-      case GL_PACK_SKIP_PIXELS:
>-	return 1;
>-      case GL_PACK_SKIP_IMAGES:
>-	return 1;
>-      case GL_PACK_ALIGNMENT:
>-	return 1;
>-      case GL_UNPACK_SWAP_BYTES:
>-	return 1;
>-      case GL_UNPACK_LSB_FIRST:
>-	return 1;
>-      case GL_UNPACK_ROW_LENGTH:
>-	return 1;
>-      case GL_UNPACK_IMAGE_HEIGHT:
>-	return 1;
>-      case GL_UNPACK_SKIP_ROWS:
>-	return 1;
>-      case GL_UNPACK_SKIP_PIXELS:
>-	return 1;
>-      case GL_UNPACK_SKIP_IMAGES:
>-	return 1;
>-      case GL_UNPACK_ALIGNMENT:
>-	return 1;
>-      case GL_MAP_COLOR:
>-	return 1;
>-      case GL_MAP_STENCIL:
>-	return 1;
>-      case GL_INDEX_SHIFT:
>-	return 1;
>-      case GL_INDEX_OFFSET:
>-	return 1;
>-      case GL_RED_SCALE:
>-      case GL_GREEN_SCALE:
>-      case GL_BLUE_SCALE:
>-      case GL_ALPHA_SCALE:
>-      case GL_DEPTH_SCALE:
>-	return 1;
>-      case GL_RED_BIAS:
>-      case GL_GREEN_BIAS:
>-      case GL_BLUE_BIAS:
>-      case GL_ALPHA_BIAS:
>-      case GL_DEPTH_BIAS:
>-	return 1;
>-      case GL_ZOOM_X:
>-      case GL_ZOOM_Y:
>-	return 1;
>-      case GL_PIXEL_MAP_I_TO_I_SIZE:	  case GL_PIXEL_MAP_S_TO_S_SIZE:
>-      case GL_PIXEL_MAP_I_TO_R_SIZE:	  case GL_PIXEL_MAP_I_TO_G_SIZE:
>-      case GL_PIXEL_MAP_I_TO_B_SIZE:	  case GL_PIXEL_MAP_I_TO_A_SIZE:
>-      case GL_PIXEL_MAP_R_TO_R_SIZE:	  case GL_PIXEL_MAP_G_TO_G_SIZE:
>-      case GL_PIXEL_MAP_B_TO_B_SIZE:	  case GL_PIXEL_MAP_A_TO_A_SIZE:
>-	return 1;
>-      case GL_MAX_EVAL_ORDER:
>-	return 1;
>-      case GL_MAX_LIGHTS:
>-	return 1;
>-      case GL_MAX_CLIP_PLANES:
>-	return 1;
>-      case GL_MAX_PIXEL_MAP_TABLE:
>-	return 1;
>-      case GL_MAX_ATTRIB_STACK_DEPTH:
>-	return 1;
>-      case GL_MAX_MODELVIEW_STACK_DEPTH:
>-	return 1;
>-      case GL_MAX_NAME_STACK_DEPTH:
>-	return 1;
>-      case GL_MAX_PROJECTION_STACK_DEPTH:
>-	return 1;
>-      case GL_MAX_TEXTURE_STACK_DEPTH:
>-	return 1;
>-      case GL_INDEX_BITS:
>-	return 1;
>-      case GL_RED_BITS:
>-	return 1;
>-      case GL_GREEN_BITS:
>-	return 1;
>-      case GL_BLUE_BITS:
>-	return 1;
>-      case GL_ALPHA_BITS:
>-	return 1;
>-      case GL_DEPTH_BITS:
>-	return 1;
>-      case GL_STENCIL_BITS:
>-	return 1;
>-      case GL_ACCUM_RED_BITS:
>-      case GL_ACCUM_GREEN_BITS:
>-      case GL_ACCUM_BLUE_BITS:
>-      case GL_ACCUM_ALPHA_BITS:
>-	return 1;
>-      case GL_MAP1_GRID_DOMAIN:
>-	return 2;
>-      case GL_MAP1_GRID_SEGMENTS:
>-	return 1;
>-      case GL_MAP2_GRID_DOMAIN:
>-	return 4;
>-      case GL_MAP2_GRID_SEGMENTS:
>-	return 2;
>-      case GL_TEXTURE_1D:
>-      case GL_TEXTURE_2D:
>-      case GL_TEXTURE_3D:
>-	return 1;
>-      case GL_NAME_STACK_DEPTH:
>-	return 1;
>-      case GL_MAX_VIEWPORT_DIMS:
>-	return 2;
>-      case GL_DOUBLEBUFFER:
>-	return 1;
>-      case GL_AUX_BUFFERS:
>-	return 1;
>-      case GL_STEREO:
>-	return 1;
>-      case GL_CLIP_PLANE0:	case GL_CLIP_PLANE1:
>-      case GL_CLIP_PLANE2:	case GL_CLIP_PLANE3:
>-      case GL_CLIP_PLANE4:	case GL_CLIP_PLANE5:
>-	return 1;
>-      case GL_LIGHT0:	case GL_LIGHT1:
>-      case GL_LIGHT2:	case GL_LIGHT3:
>-      case GL_LIGHT4:	case GL_LIGHT5:
>-      case GL_LIGHT6:	case GL_LIGHT7:
>-	return 1;
>-      case GL_VERTEX_ARRAY:
>-      case GL_VERTEX_ARRAY_SIZE:
>-      case GL_VERTEX_ARRAY_TYPE:
>-      case GL_VERTEX_ARRAY_STRIDE:
>-      case GL_NORMAL_ARRAY:
>-      case GL_NORMAL_ARRAY_TYPE:
>-      case GL_NORMAL_ARRAY_STRIDE:
>-      case GL_COLOR_ARRAY:
>-      case GL_COLOR_ARRAY_SIZE:
>-      case GL_COLOR_ARRAY_TYPE:
>-      case GL_COLOR_ARRAY_STRIDE:
>-      case GL_INDEX_ARRAY:
>-      case GL_INDEX_ARRAY_TYPE:
>-      case GL_INDEX_ARRAY_STRIDE:
>-      case GL_TEXTURE_COORD_ARRAY:
>-      case GL_TEXTURE_COORD_ARRAY_SIZE:
>-      case GL_TEXTURE_COORD_ARRAY_TYPE:
>-      case GL_TEXTURE_COORD_ARRAY_STRIDE:
>-      case GL_EDGE_FLAG_ARRAY:
>-      case GL_EDGE_FLAG_ARRAY_STRIDE:
>-	return 1;
>-      case GL_TEXTURE_BINDING_1D:
>-      case GL_TEXTURE_BINDING_2D:
>-      case GL_TEXTURE_BINDING_3D:
>-	return 1;
>-      case GL_BLEND_COLOR:
>-	return 4;
>-      case GL_BLEND_EQUATION:
>-	return 1;
>-      case GL_COLOR_MATRIX:
>-	return 16;
>-      case GL_COLOR_MATRIX_STACK_DEPTH:
>-	return 1;
>-      case GL_COLOR_TABLE:
>-      case GL_POST_CONVOLUTION_COLOR_TABLE:
>-      case GL_POST_COLOR_MATRIX_COLOR_TABLE:
>-      case GL_CONVOLUTION_1D:
>-      case GL_CONVOLUTION_2D:
>-      case GL_SEPARABLE_2D:
>-      case GL_HISTOGRAM:
>-      case GL_MINMAX:
>-	return 1;
>-      case GL_POLYGON_OFFSET_FACTOR:
>-      case GL_POLYGON_OFFSET_UNITS:
>-	return 1;
>-      case GL_POST_CONVOLUTION_RED_SCALE:
>-      case GL_POST_CONVOLUTION_GREEN_SCALE:
>-      case GL_POST_CONVOLUTION_BLUE_SCALE:
>-      case GL_POST_CONVOLUTION_ALPHA_SCALE:
>-      case GL_POST_CONVOLUTION_RED_BIAS:
>-      case GL_POST_CONVOLUTION_GREEN_BIAS:
>-      case GL_POST_CONVOLUTION_BLUE_BIAS:
>-      case GL_POST_CONVOLUTION_ALPHA_BIAS:
>-	return 1;
>-      case GL_POST_COLOR_MATRIX_RED_SCALE:
>-      case GL_POST_COLOR_MATRIX_GREEN_SCALE:
>-      case GL_POST_COLOR_MATRIX_BLUE_SCALE:
>-      case GL_POST_COLOR_MATRIX_ALPHA_SCALE:
>-      case GL_POST_COLOR_MATRIX_RED_BIAS:
>-      case GL_POST_COLOR_MATRIX_GREEN_BIAS:
>-      case GL_POST_COLOR_MATRIX_BLUE_BIAS:
>-      case GL_POST_COLOR_MATRIX_ALPHA_BIAS:
>-	return 1;
>-      case GL_RESCALE_NORMAL:
>-	return 1;
>-      case GL_MAX_ELEMENTS_INDICES:
>-      case GL_MAX_ELEMENTS_VERTICES:
>-         return 1;
>-      case GL_ACTIVE_TEXTURE_ARB:
>-      case GL_CLIENT_ACTIVE_TEXTURE_ARB:
>-      case GL_MAX_TEXTURE_UNITS_ARB:
>-	return 1;
>-      case GL_MAX_COLOR_MATRIX_STACK_DEPTH:
>-      case GL_MAX_CONVOLUTION_WIDTH:
>-      case GL_MAX_CONVOLUTION_HEIGHT:
>-	return 1;
>-      case GL_OCCLUSION_TEST_RESULT_HP:
>-      case GL_OCCLUSION_TEST_HP:
>-	return 1;
>-      case GL_PACK_INVERT_MESA:
>-	return 1;
>-      case GL_CULL_VERTEX_IBM:
>-	return 1;
>-      case GL_RASTER_POSITION_UNCLIPPED_IBM:
>-	return 1;
>-
>-      /* GL_ARB_texture_cube_map / GL 1.3 */
>-      case GL_TEXTURE_CUBE_MAP:
>-      case GL_TEXTURE_BINDING_CUBE_MAP:
>-      case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
>-
>-      /* GL_ARB_multisample / GL 1.3 */
>-      case GL_MULTISAMPLE:
>-      case GL_SAMPLE_ALPHA_TO_COVERAGE:
>-      case GL_SAMPLE_ALPHA_TO_ONE:
>-      case GL_SAMPLE_COVERAGE:
>-      case GL_SAMPLE_BUFFERS:
>-      case GL_SAMPLES:
>-      case GL_SAMPLE_COVERAGE_VALUE:
>-      case GL_SAMPLE_COVERAGE_INVERT:
>-
>-      /* GL_ARB_texture_comrpession / GL 1.3 */
>-      case GL_TEXTURE_COMPRESSION_HINT:
>-      case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
>-	
>-      /* GL_EXT_blend_func_separate / GL 1.4 */
>-      case GL_BLEND_DST_RGB:
>-      case GL_BLEND_SRC_RGB:
>-      case GL_BLEND_DST_ALPHA:
>-      case GL_BLEND_SRC_ALPHA:
>-
>-      /* GL_EXT_fog_coord / GL 1.4 */
>-      case GL_CURRENT_FOG_COORD:
>-      case GL_FOG_COORD_ARRAY_TYPE:
>-      case GL_FOG_COORD_ARRAY_STRIDE:
>-      case GL_FOG_COORD_ARRAY:
>-      case GL_FOG_COORD_SRC:
>-
>-      /* GL_EXT_secondary_color / GL 1.4 */
>-      case GL_COLOR_SUM:
>-      case GL_SECONDARY_COLOR_ARRAY_SIZE:
>-      case GL_SECONDARY_COLOR_ARRAY_TYPE:
>-      case GL_SECONDARY_COLOR_ARRAY_STRIDE:
>-      case GL_SECONDARY_COLOR_ARRAY:
>-
>-      /* GL_EXT_texture_lod_bias / GL 1.4 */
>-      case GL_MAX_TEXTURE_LOD_BIAS:
>-
>-      /* GL_ARB_point_sprite */
>-      case GL_POINT_SPRITE_ARB:
>-
>-      /* GL_ARB_vertex_blend */
>-      case GL_MAX_VERTEX_UNITS_ARB:
>-      case GL_ACTIVE_VERTEX_UNITS_ARB:
>-      case GL_WEIGHT_SUM_UNITY_ARB:
>-      case GL_VERTEX_BLEND_ARB:
>-      case GL_CURRENT_WEIGHT_ARB:
>-      case GL_WEIGHT_ARRAY_ARB:
>-      case GL_WEIGHT_ARRAY_TYPE_ARB:
>-      case GL_WEIGHT_ARRAY_STRIDE_ARB:
>-      case GL_WEIGHT_ARRAY_SIZE_ARB:
>-
>-      /* GL_ARB_matrix_palette */
>-      case GL_MATRIX_PALETTE_ARB:
>-      case GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB:
>-      case GL_MAX_PALETTE_MATRICES_ARB:
>-      case GL_CURRENT_PALETTE_MATRIX_ARB:
>-      case GL_CURRENT_MATRIX_INDEX_ARB:
>-      case GL_MATRIX_INDEX_ARRAY_ARB:
>-      case GL_MATRIX_INDEX_ARRAY_SIZE_ARB:
>-      case GL_MATRIX_INDEX_ARRAY_TYPE_ARB:
>-      case GL_MATRIX_INDEX_ARRAY_STRIDE_ARB:
>-
>-      /* GL_EXT_clip_volume_hint */
>-      case GL_CLIP_VOLUME_CLIPPING_HINT_EXT:
>-
>-      /* GL_EXT_depth_bounds_test */
>-      case GL_DEPTH_BOUNDS_TEST_EXT:
>-
>-      /* GL_EXT_stencil_two_size */
>-      case GL_STENCIL_TEST_TWO_SIDE_EXT:
>-      case GL_ACTIVE_STENCIL_FACE_EXT:
>-
>-      /* GL_EXT_vertex_weighting */
>-      case GL_VERTEX_WEIGHTING_EXT:
>-      case GL_MODELVIEW0_EXT:
>-      case GL_MODELVIEW1_EXT:
>-      case GL_CURRENT_VERTEX_WEIGHT_EXT:
>-      case GL_VERTEX_WEIGHT_ARRAY_EXT:
>-      case GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT:
>-      case GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT:
>-      case GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT:
>-      /* case GL_MODELVIEW0_STACK_DEPTH_EXT: */ /* alias */
>-      case GL_MODELVIEW1_STACK_DEPTH_EXT:
>-
>-      /* GL_EXT_blend_equation_separate */
>-      /* case GL_BLEND_EQUATION_RGB_EXT: */ /* alias */
>-      case GL_BLEND_EQUATION_ALPHA_EXT:
>-
>-      /* GL_ATI_vertex_streams */
>-      case GL_MAX_VERTEX_STREAMS_ATI:
>-
>-      /* GL_ATI_draw_buffers */
>-      case GL_MAX_DRAW_BUFFERS_ATI:
>-      case GL_DRAW_BUFFER0_ATI:
>-      case GL_DRAW_BUFFER1_ATI:
>-      case GL_DRAW_BUFFER2_ATI:
>-      case GL_DRAW_BUFFER3_ATI:
>-      case GL_DRAW_BUFFER4_ATI:
>-      case GL_DRAW_BUFFER5_ATI:
>-      case GL_DRAW_BUFFER6_ATI:
>-      case GL_DRAW_BUFFER7_ATI:
>-      case GL_DRAW_BUFFER8_ATI:
>-      case GL_DRAW_BUFFER9_ATI:
>-      case GL_DRAW_BUFFER10_ATI:
>-      case GL_DRAW_BUFFER11_ATI:
>-      case GL_DRAW_BUFFER12_ATI:
>-      case GL_DRAW_BUFFER13_ATI:
>-      case GL_DRAW_BUFFER14_ATI:
>-      case GL_DRAW_BUFFER15_ATI:
>-
>-      /* GL_ATI_separate_stencil */
>-      case GL_STENCIL_BACK_FUNC_ATI:
>-      case GL_STENCIL_BACK_FAIL_ATI:
>-      case GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI:
>-      case GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI:
>-
>-      /* GL_NV_depth_clamp */
>-      case GL_DEPTH_CLAMP_NV:
>-
>-      /* GL_NV_fog_distance */
>-      case GL_FOG_DISTANCE_MODE_NV:
>-
>-      /* GL_NV_light_max_exponent */
>-      case GL_MAX_SHININESS_NV:
>-      case GL_MAX_SPOT_EXPONENT_NV:
>-
>-      /* GL_NV_multisample_filter_hint */
>-      case GL_MULTISAMPLE_FILTER_HINT_NV:
>-
>-      /* GL_NV_point_sprite */
>-      /* case GL_POINT_SPRITE_NV: */ /* alias */
>-      case GL_POINT_SPRITE_R_MODE_NV:
>-
>-      /* GL_NV_primitive_restart */
>-      case GL_PRIMITIVE_RESTART_NV:
>-      case GL_PRIMITIVE_RESTART_INDEX_NV:
>-
>-      /* GL_NV_register_combiners */
>-      case GL_REGISTER_COMBINERS_NV:
>-      case GL_NUM_GENERAL_COMBINERS_NV:
>-      case GL_COLOR_SUM_CLAMP_NV:
>-      case GL_MAX_GENERAL_COMBINERS_NV:
>-
>-      /* GL_NV_register_combiners2 */
>-      case GL_PER_STAGE_CONSTANTS_NV:
>-
>-      /* GL_NV_texture_rectangle */
>-      case GL_TEXTURE_RECTANGLE_NV:
>-      case GL_TEXTURE_BINDING_RECTANGLE_NV:
>-      case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:
>-	return 1;
>-
>-      /* GL_EXT_depth_bounds_test */
>-      case GL_DEPTH_BOUNDS_EXT:
>-	return 2;
>-
>-      /* GL_EXT_secondary_color / GL 1.4 */
>-      case GL_CURRENT_SECONDARY_COLOR:
>-
>-      /* GL_NV_register_combiners */
>-      case GL_CONSTANT_COLOR0_NV:
>-      case GL_CONSTANT_COLOR1_NV:
>-	return 4;
>-
>-      /* GL_ARB_vertex_blend */
>-      /* case GL_MODELVIEW0_ARB: */ /* alias */
>-      /* case GL_MODELVIEW1_ARB: */ /* alias */
>-      case GL_MODELVIEW2_ARB:
>-      case GL_MODELVIEW3_ARB:
>-      case GL_MODELVIEW4_ARB:
>-      case GL_MODELVIEW5_ARB:
>-      case GL_MODELVIEW6_ARB:
>-      case GL_MODELVIEW7_ARB:
>-      case GL_MODELVIEW8_ARB:
>-      case GL_MODELVIEW9_ARB:
>-      case GL_MODELVIEW10_ARB:
>-      case GL_MODELVIEW11_ARB:
>-      case GL_MODELVIEW12_ARB:
>-      case GL_MODELVIEW13_ARB:
>-      case GL_MODELVIEW14_ARB:
>-      case GL_MODELVIEW15_ARB:
>-      case GL_MODELVIEW16_ARB:
>-      case GL_MODELVIEW17_ARB:
>-      case GL_MODELVIEW18_ARB:
>-      case GL_MODELVIEW19_ARB:
>-      case GL_MODELVIEW20_ARB:
>-      case GL_MODELVIEW21_ARB:
>-      case GL_MODELVIEW22_ARB:
>-      case GL_MODELVIEW23_ARB:
>-      case GL_MODELVIEW24_ARB:
>-      case GL_MODELVIEW25_ARB:
>-      case GL_MODELVIEW26_ARB:
>-      case GL_MODELVIEW27_ARB:
>-      case GL_MODELVIEW28_ARB:
>-      case GL_MODELVIEW29_ARB:
>-      case GL_MODELVIEW30_ARB:
>-      case GL_MODELVIEW31_ARB:
>-
>-      /* GL_EXT_vertex_weighting */
>-      /* case GL_MODELVIEW0_MATRIX_EXT: */ /* alias */
>-      case GL_MODELVIEW1_MATRIX_EXT:
>-	return 32;
>-
>-      /* GL_ARB_texture_comrpession / GL 1.3 */
>-      case GL_COMPRESSED_TEXTURE_FORMATS: {
>-	  GLint temp;
>-	  
>-	  glGetIntegerv( GL_NUM_COMPRESSED_TEXTURE_FORMATS, & temp );
>-	  return temp;
>-      }
>-
>-      default:
>-	return -1;
>-    }
>-}
>-
>-GLint __glGetDoublev_size(GLenum sq)
>-{
>-    return __glGet_size(sq);
>-}
>-
>-GLint __glGetFloatv_size(GLenum sq)
>-{
>-    return __glGet_size(sq);
>-}
>-
>-GLint __glGetIntegerv_size(GLenum sq)
>-{
>-    return __glGet_size(sq);
>-}
>-
>-GLint __glGetBooleanv_size(GLenum sq)
>-{
>-    return __glGet_size(sq);
>-}
>-
>-GLint __glGetTexLevelParameterfv_size(GLenum pname)
>-{
>-    switch (pname) {
>-      case GL_TEXTURE_WIDTH:
>-      case GL_TEXTURE_HEIGHT:
>-      case GL_TEXTURE_DEPTH:
>-      case GL_TEXTURE_COMPONENTS:
>-      case GL_TEXTURE_BORDER:
>-      case GL_TEXTURE_RED_SIZE:
>-      case GL_TEXTURE_GREEN_SIZE:
>-      case GL_TEXTURE_BLUE_SIZE:
>-      case GL_TEXTURE_ALPHA_SIZE:
>-      case GL_TEXTURE_LUMINANCE_SIZE:
>-      case GL_TEXTURE_INTENSITY_SIZE:
>-
>-      /* GL_ARB_texture_compression / GL 1.3 */
>-      case GL_TEXTURE_COMPRESSED_IMAGE_SIZE:
>-      case GL_TEXTURE_COMPRESSED:
>-
>-      /* GL_ARB_depth_texture / GL 1.4 */
>-      case GL_TEXTURE_DEPTH_SIZE:
>-	return 1;
>-
>-      default:
>-	return -1;
>-    }
>-}
>-
>-GLint __glGetTexLevelParameteriv_size(GLenum pname)
>-{
>-    return __glGetTexLevelParameterfv_size(pname);
>-}
>-
> GLint __glGetTexImage_size(GLenum target, GLint level, GLenum format,
> 			   GLenum type, GLint width, GLint height, GLint depth)
> {
>     return __glXImageSize( format, type, target, width, height, depth,
> 			   0, 0, 0, 0, 4 );
> }
>-
>-GLint __glGetConvolutionParameteriv_size(GLenum pname)
>-{
>-    switch (pname) {
>-      case GL_CONVOLUTION_BORDER_COLOR:
>-      case GL_CONVOLUTION_FILTER_SCALE:
>-      case GL_CONVOLUTION_FILTER_BIAS:
>-	return 4;
>-      case GL_CONVOLUTION_BORDER_MODE:
>-      case GL_CONVOLUTION_FORMAT:
>-      case GL_CONVOLUTION_WIDTH:
>-      case GL_CONVOLUTION_HEIGHT:
>-      case GL_MAX_CONVOLUTION_WIDTH:
>-      case GL_MAX_CONVOLUTION_HEIGHT:
>-	return 1;
>-      default:
>-	return -1;
>-    }
>-}
>-
>-GLint __glGetConvolutionParameterfv_size(GLenum pname)
>-{
>-    return __glGetConvolutionParameteriv_size(pname);
>-}
>-
>-
>-GLint __glGetHistogramParameterfv_size(GLenum pname)
>-{
>-    switch (pname) {
>-      case GL_HISTOGRAM_WIDTH:
>-      case GL_HISTOGRAM_FORMAT:
>-      case GL_HISTOGRAM_RED_SIZE:
>-      case GL_HISTOGRAM_GREEN_SIZE:
>-      case GL_HISTOGRAM_BLUE_SIZE:
>-      case GL_HISTOGRAM_ALPHA_SIZE:
>-      case GL_HISTOGRAM_LUMINANCE_SIZE:
>-      case GL_HISTOGRAM_SINK:
>-	return 1;
>-      default:
>-	return -1;
>-    }
>-}
>-
>-GLint __glGetHistogramParameteriv_size(GLenum pname)
>-{
>-    return __glGetHistogramParameterfv_size(pname);
>-}
>-
>-GLint __glGetMinmaxParameterfv_size(GLenum pname)
>-{
>-    switch (pname) {
>-      case GL_MINMAX_FORMAT:
>-      case GL_MINMAX_SINK:
>-	return 1;
>-      default:
>-	return -1;
>-    }
>-}
>-
>-GLint __glGetMinmaxParameteriv_size(GLenum pname)
>-{
>-    return __glGetMinmaxParameterfv_size(pname);
>-}
>-
>-GLint __glGetColorTableParameterfv_size(GLenum pname)
>-{
>-    switch(pname) {
>-
>-    case GL_COLOR_TABLE_SCALE: /* return RGBA */
>-    case GL_COLOR_TABLE_BIAS:
>-	return 4;
>-    case GL_COLOR_TABLE_FORMAT:
>-    case GL_COLOR_TABLE_WIDTH:
>-    case GL_COLOR_TABLE_RED_SIZE:
>-    case GL_COLOR_TABLE_GREEN_SIZE:
>-    case GL_COLOR_TABLE_BLUE_SIZE:
>-    case GL_COLOR_TABLE_ALPHA_SIZE:
>-    case GL_COLOR_TABLE_LUMINANCE_SIZE:
>-    case GL_COLOR_TABLE_INTENSITY_SIZE:
>-	return 1;
>-    default:
>-	return 0;
>-    }
>-}
>-
>-GLint __glGetColorTableParameteriv_size(GLenum pname)
>-{
>-    return __glGetColorTableParameterfv_size(pname);
>-}
>-
>Index: xorg/GL/glx/singlesize.h
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/singlesize.h,v
>retrieving revision 1.4
>diff -u -d -r1.4 singlesize.h
>--- xorg/GL/glx/singlesize.h	20 Oct 2005 23:24:47 -0000	1.4
>+++ xorg/GL/glx/singlesize.h	12 Jan 2006 00:04:17 -0000
>@@ -45,43 +45,16 @@
> 
> extern GLint __glReadPixels_size(GLenum format, GLenum type,
> 				 GLint width, GLint height);
>-extern GLint __glGetTexEnvfv_size(GLenum pname);
>-extern GLint __glGetTexEnviv_size(GLenum pname);
>-extern GLint __glGetTexGenfv_size(GLenum pname);
>-extern GLint __glGetTexGendv_size(GLenum pname);
>-extern GLint __glGetTexGeniv_size(GLenum pname);
>-extern GLint __glGetTexParameterfv_size(GLenum pname);
>-extern GLint __glGetTexParameteriv_size(GLenum pname);
>-extern GLint __glGetLightfv_size(GLenum pname);
>-extern GLint __glGetLightiv_size(GLenum pname);
> extern GLint __glGetMap_size(GLenum pname, GLenum query);
> extern GLint __glGetMapdv_size(GLenum target, GLenum query);
> extern GLint __glGetMapfv_size(GLenum target, GLenum query);
> extern GLint __glGetMapiv_size(GLenum target, GLenum query);
>-extern GLint __glGetMaterialfv_size(GLenum pname);
>-extern GLint __glGetMaterialiv_size(GLenum pname);
> extern GLint __glGetPixelMap_size(GLenum map);
> extern GLint __glGetPixelMapfv_size(GLenum map);
> extern GLint __glGetPixelMapuiv_size(GLenum map);
> extern GLint __glGetPixelMapusv_size(GLenum map);
>-extern GLint __glGet_size(GLenum sq);
>-extern GLint __glGetDoublev_size(GLenum sq);
>-extern GLint __glGetFloatv_size(GLenum sq);
>-extern GLint __glGetIntegerv_size(GLenum sq);
>-extern GLint __glGetBooleanv_size(GLenum sq);
>-extern GLint __glGetTexLevelParameterfv_size(GLenum pname);
>-extern GLint __glGetTexLevelParameteriv_size(GLenum pname);
> extern GLint __glGetTexImage_size(GLenum target, GLint level, GLenum format,
> 				  GLenum type, GLint width, GLint height,
> 				  GLint depth);
>-extern GLint __glGetColorTableParameterfv_size(GLenum pname);
>-extern GLint __glGetColorTableParameteriv_size(GLenum pname);
>-extern GLint __glGetConvolutionParameterfv_size(GLenum pname);
>-extern GLint __glGetConvolutionParameteriv_size(GLenum pname);
>-extern GLint __glGetHistogramParameterfv_size(GLenum pname);
>-extern GLint __glGetHistogramParameteriv_size(GLenum pname);
>-extern GLint __glGetMinmaxParameterfv_size(GLenum pname);
>-extern GLint __glGetMinmaxParameteriv_size(GLenum pname);
> 
> #endif /* _singlesize_h_ */
>-
>Index: xorg/GL/glx/xfont.c
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/glx/xfont.c,v
>retrieving revision 1.3
>diff -u -d -r1.3 xfont.c
>--- xorg/GL/glx/xfont.c	3 Jul 2005 07:01:02 -0000	1.3
>+++ xorg/GL/glx/xfont.c	12 Jan 2006 00:04:17 -0000
>@@ -41,8 +41,12 @@
> 
> #include "glxserver.h"
> #include "glxutil.h"
>+#include "unpack.h"
> #include "g_disptab.h"
>-#include <unpack.h>
>+#include "glapitable.h"
>+#include "glapi.h"
>+#include "glthread.h"
>+#include "dispatch.h"
> #include <GL/gl.h>
> #include <pixmapstr.h>
> #include <windowstr.h>
>@@ -96,8 +100,10 @@
> 	pglyph -= widthPadded;
> 	p += widthPadded;
>     }
>-    glBitmap(w, h, -pci->metrics.leftSideBearing, pci->metrics.descent,
>-	     pci->metrics.characterWidth, 0, allocbuf ? allocbuf : buf);
>+    CALL_Bitmap( GET_DISPATCH(), (w, h, -pci->metrics.leftSideBearing,
>+				  pci->metrics.descent,
>+				  pci->metrics.characterWidth, 0, 
>+				  allocbuf ? allocbuf : buf) );
> 
>     if (allocbuf) {
> 	__glXFree(allocbuf);
>@@ -120,12 +126,12 @@
>     int rv;				/* return value */
>     int encoding = (FONTLASTROW(pFont) == 0) ? Linear16Bit : TwoD16Bit;
>     
>-    glPixelStorei(GL_UNPACK_SWAP_BYTES, FALSE);
>-    glPixelStorei(GL_UNPACK_LSB_FIRST, BITMAP_BIT_ORDER == LSBFirst);
>-    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
>-    glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
>-    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
>-    glPixelStorei(GL_UNPACK_ALIGNMENT, GLYPHPADBYTES);
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, FALSE) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, BITMAP_BIT_ORDER == LSBFirst) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, 0) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, 0) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, 0) );
>+    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, GLYPHPADBYTES) );
>     for (i=0; i < count; i++) {
> 	chs[0] = (first + i) >> 8;	/* high byte is first byte */
> 	chs[1] = first + i;
>@@ -136,14 +142,14 @@
> 	/*
> 	** Define a display list containing just a glBitmap() call.
> 	*/
>-	glNewList(list_base + i, GL_COMPILE);
>+	CALL_NewList( GET_DISPATCH(), (list_base + i, GL_COMPILE) );
> 	if (nglyphs ) {
> 	    rv = __glXMakeBitmapFromGlyph(pFont, pci);
> 	    if (rv) {
> 		return rv;
> 	    }
> 	}
>-	glEndList();
>+	CALL_EndList( GET_DISPATCH(), () );
>     }
>     return Success;
> }
>@@ -166,7 +172,7 @@
> 	return error;
>     }
> 
>-    glGetIntegerv(GL_LIST_INDEX, (GLint*) &currentListIndex);
>+    CALL_GetIntegerv( GET_DISPATCH(), (GL_LIST_INDEX, (GLint*) &currentListIndex) );
>     if (currentListIndex != 0) {
> 	/*
> 	** A display list is currently being made.  It is an error
>Index: xorg/GL/mesa/Makefile.am
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/mesa/Makefile.am,v
>retrieving revision 1.3
>diff -u -d -r1.3 Makefile.am
>--- xorg/GL/mesa/Makefile.am	23 Jul 2005 02:00:40 -0000	1.3
>+++ xorg/GL/mesa/Makefile.am	12 Jan 2006 00:04:17 -0000
>@@ -1,10 +1,9 @@
>-SUBDIRS = glapi main math array_cache swrast swrast_setup tnl shader X
>+SUBDIRS = main math array_cache swrast swrast_setup tnl shader X
> 
> noinst_LTLIBRARIES = libGLcore.la
> 
> libGLcore_la_SOURCES = dummy.c
>-libGLcore_la_LIBADD = glapi/libglapi.la \
>-                      main/libmain.la \
>+libGLcore_la_LIBADD = main/libmain.la \
>                       math/libmath.la \
>                       array_cache/libac.la \
>                       swrast/libswrast.la \
>Index: xorg/GL/mesa/main/Makefile.am
>===================================================================
>RCS file: /cvs/xorg/xserver/xorg/GL/mesa/main/Makefile.am,v
>retrieving revision 1.8
>diff -u -d -r1.8 Makefile.am
>--- xorg/GL/mesa/main/Makefile.am	2 Dec 2005 06:02:36 -0000	1.8
>+++ xorg/GL/mesa/main/Makefile.am	12 Jan 2006 00:04:17 -0000
>@@ -34,7 +34,6 @@
>                     convolve.c \
>                     debug.c \
>                     depth.c \
>-                    dispatch.c \
>                     dlist.c \
>                     drawpix.c \
>                     enable.c \

Actions: View | Splinter Review

Attachments on bug 2996: 2408 | 2409 | 2410 | 2411 | 2416 | 3543 | 3544 | 4330

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.