glapi: Generate xserver glapi sources in the mesa tree

Instead of generating the glapi sources for the xserver and commiting
them to the xserver tree, we can keep them in the mesa tree and change
the xserver build to use the files from the mesa tree.

This makes the xserver glx build more robust as it reduces the chances
for mismatches of the glX API used in the xserver vs. in mesa.
(cherry picked from commit 7688791fc52f116eea421fda1d17aba5cf10977b)

9 files changed, 16857 insertions, 18 deletions

diff --git a/src/glx/x11/indirect_dispatch.c b/src/glx/x11/indirect_dispatch.c
new file mode 100644
index 00000000000..2afd3eb22f8
--- /dev/null
+++ b/src/glx/x11/indirect_dispatch.c
@@ -0,0 +1,5889 @@
+/* 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 <inttypes.h>
+#include "indirect_size.h"
+#include "indirect_size_get.h"
+#include "indirect_dispatch.h"
+#include "glxserver.h"
+#include "glxbyteorder.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,
+        type,
+        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(), (
+        pname,
+        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(), (
+        pname,
+        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),
+        pname,
+        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),
+        pname,
+        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(), (
+        pname,
+        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(), (
+        pname,
+        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),
+        pname,
+        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),
+        pname,
+        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),
+        pname,
+        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),
+        pname,
+        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),
+        pname,
+        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),
+        pname,
+        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),
+        pname,
+        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),
+        pname,
+        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),
+        pname,
+        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(), (
+            pname,
+            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(), (
+            pname,
+            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(), (
+            pname,
+            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(), (
+            pname,
+            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),
+            pname,
+            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),
+            pname,
+            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(), (
+            target,
+            query,
+            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(), (
+            target,
+            query,
+            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(), (
+            target,
+            query,
+            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),
+            pname,
+            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),
+            pname,
+            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(), (
+            map,
+            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(), (
+            map,
+            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(), (
+            map,
+            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),
+            pname,
+            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),
+            pname,
+            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),
+            pname,
+            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),
+            pname,
+            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),
+            pname,
+            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),
+            pname,
+            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),
+            pname,
+            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),
+            pname,
+            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),
+            pname,
+            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;
+}
+
+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_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)
+{
+    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_DeleteTextures( GET_DISPATCH(), (
+            n,
+             (const GLuint *)(pc +  4)
+        ) );
+        error = Success;
+    }
+
+    return error;
+}
+
+int __glXDisp_DeleteTexturesEXT(__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_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_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;
+}
+
+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_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),
+        pname,
+        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),
+        pname,
+        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),
+            pname,
+            params
+        ) );
+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+int __glXDisp_GetColorTableParameterfvSGI(__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 = __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),
+            pname,
+            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),
+            pname,
+            params
+        ) );
+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+int __glXDisp_GetColorTableParameterivSGI(__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 = __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),
+            pname,
+            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),
+        pname,
+        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),
+        pname,
+        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),
+            pname,
+            params
+        ) );
+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+int __glXDisp_GetConvolutionParameterfvEXT(__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 = __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),
+            pname,
+            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),
+            pname,
+            params
+        ) );
+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+int __glXDisp_GetConvolutionParameterivEXT(__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 = __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),
+            pname,
+            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),
+            pname,
+            params
+        ) );
+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+int __glXDisp_GetHistogramParameterfvEXT(__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 = __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),
+            pname,
+            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),
+            pname,
+            params
+        ) );
+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+int __glXDisp_GetHistogramParameterivEXT(__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 = __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),
+            pname,
+            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),
+            pname,
+            params
+        ) );
+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+int __glXDisp_GetMinmaxParameterfvEXT(__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 = __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),
+            pname,
+            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),
+            pname,
+            params
+        ) );
+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+int __glXDisp_GetMinmaxParameterivEXT(__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 = __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),
+            pname,
+            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_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_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_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_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_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_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)
+    ) );
+}
+
+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),
+            pname,
+            params
+        ) );
+        __glXSendReply(cl->client, params, compsize, 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),
+            pname,
+            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),
+            pname,
+            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),
+            pname,
+            params
+        ) );
+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+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)
+    ) );
+}
+
+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_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 +  0),
+         (const GLdouble *)(pc +  4)
+    ) );
+}
+
+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 +  0),
+         (const GLdouble *)(pc +  4)
+    ) );
+}
+
+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 +  0),
+         (const GLdouble *)(pc +  4)
+    ) );
+}
+
+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_VertexAttrib4NbvARB(GLbyte * pc)
+{
+    CALL_VertexAttrib4NbvARB( GET_DISPATCH(), (
+        *(GLuint   *)(pc +  0),
+         (const GLbyte *)(pc +  4)
+    ) );
+}
+
+void __glXDisp_VertexAttrib4NivARB(GLbyte * pc)
+{
+    CALL_VertexAttrib4NivARB( GET_DISPATCH(), (
+        *(GLuint   *)(pc +  0),
+         (const GLint *)(pc +  4)
+    ) );
+}
+
+void __glXDisp_VertexAttrib4NsvARB(GLbyte * pc)
+{
+    CALL_VertexAttrib4NsvARB( 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_VertexAttrib4NuivARB(GLbyte * pc)
+{
+    CALL_VertexAttrib4NuivARB( GET_DISPATCH(), (
+        *(GLuint   *)(pc +  0),
+         (const GLuint *)(pc +  4)
+    ) );
+}
+
+void __glXDisp_VertexAttrib4NusvARB(GLbyte * pc)
+{
+    CALL_VertexAttrib4NusvARB( GET_DISPATCH(), (
+        *(GLuint   *)(pc +  0),
+         (const GLushort *)(pc +  4)
+    ) );
+}
+
+void __glXDisp_VertexAttrib4bvARB(GLbyte * pc)
+{
+    CALL_VertexAttrib4bvARB( GET_DISPATCH(), (
+        *(GLuint   *)(pc +  0),
+         (const GLbyte *)(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 +  0),
+         (const GLdouble *)(pc +  4)
+    ) );
+}
+
+void __glXDisp_VertexAttrib4fvARB(GLbyte * pc)
+{
+    CALL_VertexAttrib4fvARB( GET_DISPATCH(), (
+        *(GLuint   *)(pc +  0),
+         (const GLfloat *)(pc +  4)
+    ) );
+}
+
+void __glXDisp_VertexAttrib4ivARB(GLbyte * pc)
+{
+    CALL_VertexAttrib4ivARB( GET_DISPATCH(), (
+        *(GLuint   *)(pc +  0),
+         (const GLint *)(pc +  4)
+    ) );
+}
+
+void __glXDisp_VertexAttrib4svARB(GLbyte * pc)
+{
+    CALL_VertexAttrib4svARB( GET_DISPATCH(), (
+        *(GLuint   *)(pc +  0),
+         (const GLshort *)(pc +  4)
+    ) );
+}
+
+void __glXDisp_VertexAttrib4ubvARB(GLbyte * pc)
+{
+    CALL_VertexAttrib4ubvARB( GET_DISPATCH(), (
+        *(GLuint   *)(pc +  0),
+         (const GLubyte *)(pc +  4)
+    ) );
+}
+
+void __glXDisp_VertexAttrib4uivARB(GLbyte * pc)
+{
+    CALL_VertexAttrib4uivARB( GET_DISPATCH(), (
+        *(GLuint   *)(pc +  0),
+         (const GLuint *)(pc +  4)
+    ) );
+}
+
+void __glXDisp_VertexAttrib4usvARB(GLbyte * pc)
+{
+    CALL_VertexAttrib4usvARB( GET_DISPATCH(), (
+        *(GLuint   *)(pc +  0),
+         (const GLushort *)(pc +  4)
+    ) );
+}
+
+void __glXDisp_BeginQueryARB(GLbyte * pc)
+{
+    CALL_BeginQueryARB( GET_DISPATCH(), (
+        *(GLenum   *)(pc +  0),
+        *(GLuint   *)(pc +  4)
+    ) );
+}
+
+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;
+}
+
+void __glXDisp_EndQueryARB(GLbyte * pc)
+{
+    CALL_EndQueryARB( GET_DISPATCH(), (
+        *(GLenum   *)(pc +  0)
+    ) );
+}
+
+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_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),
+            pname,
+            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),
+            pname,
+            params
+        ) );
+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+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),
+            pname,
+            params
+        ) );
+        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
+        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_DrawBuffersARB(GLbyte * pc)
+{
+    const GLsizei n = *(GLsizei  *)(pc +  0);
+
+    CALL_DrawBuffersARB( GET_DISPATCH(), (
+        n,
+         (const GLenum *)(pc +  4)
+    ) );
+}
+
+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(), (
+        pname,
+        params
+    ) );
+}
+
+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)
+    ) );
+}
+
+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_FogCoordfvEXT(GLbyte * pc)
+{
+    CALL_FogCoordfvEXT( 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_WindowPos3fvMESA(GLbyte * pc)
+{
+    CALL_WindowPos3fvMESA( GET_DISPATCH(), (
+         (const GLfloat *)(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_TRUE, 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),
+            pname,
+            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_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),
+            pname,
+            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),
+            pname,
+            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),
+            pname,
+            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_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_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)
+    ) );
+}
+
+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(), (
+        pname,
+        params
+    ) );
+}
+
+void __glXDisp_ActiveStencilFaceEXT(GLbyte * pc)
+{
+    CALL_ActiveStencilFaceEXT( GET_DISPATCH(), (
+        *(GLenum   *)(pc +  0)
+    ) );
+}
+
+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_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;
+}
+
+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)
+    ) );
+}
+
+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_BlendEquationSeparateEXT(GLbyte * pc)
+{
+    CALL_BlendEquationSeparateEXT( GET_DISPATCH(), (
+        *(GLenum   *)(pc +  0),
+        *(GLenum   *)(pc +  4)
+    ) );
+}
+
+void __glXDisp_BindFramebufferEXT(GLbyte * pc)
+{
+    CALL_BindFramebufferEXT( GET_DISPATCH(), (
+        *(GLenum   *)(pc +  0),
+        *(GLuint   *)(pc +  4)
+    ) );
+}
+
+void __glXDisp_BindRenderbufferEXT(GLbyte * pc)
+{
+    CALL_BindRenderbufferEXT( GET_DISPATCH(), (
+        *(GLenum   *)(pc +  0),
+        *(GLuint   *)(pc +  4)
+    ) );
+}
+
+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_DeleteFramebuffersEXT(GLbyte * pc)
+{
+    const GLsizei n = *(GLsizei  *)(pc +  0);
+
+    CALL_DeleteFramebuffersEXT( GET_DISPATCH(), (
+        n,
+         (const GLuint *)(pc +  4)
+    ) );
+}
+
+void __glXDisp_DeleteRenderbuffersEXT(GLbyte * pc)
+{
+    const GLsizei n = *(GLsizei  *)(pc +  0);
+
+    CALL_DeleteRenderbuffersEXT( GET_DISPATCH(), (
+        n,
+         (const GLuint *)(pc +  4)
+    ) );
+}
+
+void __glXDisp_FramebufferRenderbufferEXT(GLbyte * pc)
+{
+    CALL_FramebufferRenderbufferEXT( GET_DISPATCH(), (
+        *(GLenum   *)(pc +  0),
+        *(GLenum   *)(pc +  4),
+        *(GLenum   *)(pc +  8),
+        *(GLuint   *)(pc + 12)
+    ) );
+}
+
+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)
+    ) );
+}
+
+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_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_GenerateMipmapEXT(GLbyte * pc)
+{
+    CALL_GenerateMipmapEXT( GET_DISPATCH(), (
+        *(GLenum   *)(pc +  0)
+    ) );
+}
+
+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;
+}
+
+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;
+}
+
+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_RenderbufferStorageEXT(GLbyte * pc)
+{
+    CALL_RenderbufferStorageEXT( GET_DISPATCH(), (
+        *(GLenum   *)(pc +  0),
+        *(GLenum   *)(pc +  4),
+        *(GLsizei  *)(pc +  8),
+        *(GLsizei  *)(pc + 12)
+    ) );
+}
+
diff --git a/src/glx/x11/indirect_dispatch.h b/src/glx/x11/indirect_dispatch.h
new file mode 100644
index 00000000000..e81c382f0a1
--- /dev/null
+++ b/src/glx/x11/indirect_dispatch.h
@@ -0,0 +1,1047 @@
+/* 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_RasterPos4dv(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_RasterPos4dv(GLbyte * pc);
+extern HIDDEN void __glXDisp_PolygonStipple(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_PolygonStipple(GLbyte * pc);
+extern HIDDEN void __glXDisp_BlendEquationSeparateEXT(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_BlendEquationSeparateEXT(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 int __glXDisp_DestroyPixmap(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_DestroyPixmap(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_GetMapiv(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetMapiv(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_SwapBuffers(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_SwapBuffers(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN void __glXDisp_Indexubv(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_Indexubv(GLbyte * pc);
+extern HIDDEN int __glXDisp_Render(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_Render(struct __GLXclientStateRec *, GLbyte *);
+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 int __glXDisp_MakeContextCurrent(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_MakeContextCurrent(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_GetFBConfigs(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetFBConfigs(struct __GLXclientStateRec *, GLbyte *);
+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 int __glXDisp_VendorPrivate(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_VendorPrivate(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_CreateGLXPixmapWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN void __glXDisp_VertexAttrib1fvNV(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_VertexAttrib1fvNV(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_Scalef(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_Scalef(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_CopyTexSubImage2D(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_CopyTexSubImage2D(GLbyte * pc);
+extern HIDDEN void __glXDisp_DepthRange(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_DepthRange(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_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 int __glXDisp_GetConvolutionParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetConvolutionParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN void __glXDisp_Vertex2dv(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_Vertex2dv(GLbyte * pc);
+extern HIDDEN int __glXDisp_GetVisualConfigs(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetVisualConfigs(struct __GLXclientStateRec *, GLbyte *);
+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 int __glXDisp_CopyContext(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_CopyContext(struct __GLXclientStateRec *, GLbyte *);
+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_LineStipple(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_LineStipple(GLbyte * pc);
+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_LightModeli(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_LightModeli(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_CallLists(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_CallLists(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_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 int __glXDisp_DestroyContext(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_DestroyContext(struct __GLXclientStateRec *, GLbyte *);
+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_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 int __glXDisp_AreTexturesResident(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_AreTexturesResident(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_AreTexturesResidentEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_AreTexturesResidentEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_IsRenderbufferEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_IsRenderbufferEXT(struct __GLXclientStateRec *, GLbyte *);
+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_VertexAttribs4ubvNV(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_VertexAttribs4ubvNV(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_PushMatrix(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_PushMatrix(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_GetFBConfigsSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetFBConfigsSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_CreateNewContext(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_CreateNewContext(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_GetMinmax(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetMinmax(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_GetMinmaxEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetMinmaxEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN void __glXDisp_Normal3fv(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_Normal3fv(GLbyte * pc);
+extern HIDDEN void __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_ProgramEnvParameter4dvARB(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_BindTexture(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_BindTexture(GLbyte * pc);
+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 int __glXDisp_CreateContextWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_CreateContextWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN void __glXDisp_FramebufferTexture3DEXT(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_FramebufferTexture3DEXT(GLbyte * pc);
+extern HIDDEN int __glXDisp_CopySubBufferMESA(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_CopySubBufferMESA(struct __GLXclientStateRec *, GLbyte *);
+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 int __glXDisp_CreateGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_CreateGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
+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 void __glXDisp_Color4iv(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_Color4iv(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 int __glXDisp_QueryServerString(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_QueryServerString(struct __GLXclientStateRec *, GLbyte *);
+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 int __glXDisp_WaitX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_WaitX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN void __glXDisp_SecondaryColor3uivEXT(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_SecondaryColor3uivEXT(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 int __glXDisp_GenTexturesEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GenTexturesEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN void __glXDisp_FramebufferTexture1DEXT(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_FramebufferTexture1DEXT(GLbyte * pc);
+extern HIDDEN int __glXDisp_GetDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);
+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_TexGeniv(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_TexGeniv(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 int __glXDisp_WaitGL(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_WaitGL(struct __GLXclientStateRec *, GLbyte *);
+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 int __glXDisp_DestroyPbuffer(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_DestroyPbuffer(struct __GLXclientStateRec *, GLbyte *);
+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 int __glXDisp_QueryExtensionsString(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_QueryExtensionsString(struct __GLXclientStateRec *, GLbyte *);
+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_GetColorTableSGI(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetColorTableSGI(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN void __glXDisp_Indexiv(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_Indexiv(GLbyte * pc);
+extern HIDDEN int __glXDisp_CreateContext(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_CreateContext(struct __GLXclientStateRec *, GLbyte *);
+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 int __glXDisp_GetHistogramParameterfvEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetHistogramParameterfvEXT(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 int __glXDisp_CreateGLXPixmap(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_CreateGLXPixmap(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN void __glXDisp_TexEnvf(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_TexEnvf(GLbyte * pc);
+extern HIDDEN int __glXDisp_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);
+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_DeleteTexturesEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_DeleteTexturesEXT(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_QueryVersion(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_QueryVersion(struct __GLXclientStateRec *, GLbyte *);
+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 int __glXDisp_GetDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN void __glXDisp_SampleMaskSGIS(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_SampleMaskSGIS(GLbyte * pc);
+extern HIDDEN void __glXDisp_ColorTableParameteriv(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_ColorTableParameteriv(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 int __glXDisp_CreatePixmap(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_CreatePixmap(struct __GLXclientStateRec *, GLbyte *);
+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_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 void __glXDisp_VertexAttrib2dvNV(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_VertexAttrib2dvNV(GLbyte * pc);
+extern HIDDEN int __glXDisp_GetVertexAttribivNV(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetVertexAttribivNV(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_IsQueryARB(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_IsQueryARB(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 int __glXDisp_DestroyWindow(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_DestroyWindow(struct __GLXclientStateRec *, GLbyte *);
+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_IsTextureEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_IsTextureEXT(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 int __glXDisp_DestroyGLXPixmap(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_DestroyGLXPixmap(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 void __glXDisp_PrioritizeTextures(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_PrioritizeTextures(GLbyte * pc);
+extern HIDDEN int __glXDisp_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN void __glXDisp_VertexAttrib4usvARB(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_VertexAttrib4usvARB(GLbyte * pc);
+extern HIDDEN int __glXDisp_DestroyGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_DestroyGLXPbufferSGIX(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 int __glXDisp_GetSeparableFilterEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetSeparableFilterEXT(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 int __glXDisp_RenderLarge(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_RenderLarge(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN void __glXDisp_VertexAttrib4dvARB(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_VertexAttrib4dvARB(GLbyte * pc);
+extern HIDDEN void __glXDisp_PolygonOffset(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_PolygonOffset(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 int __glXDisp_ChangeDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_ChangeDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN void __glXDisp_MultiTexCoord4dvARB(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_MultiTexCoord4dvARB(GLbyte * pc);
+extern HIDDEN int __glXDisp_CreatePbuffer(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_CreatePbuffer(struct __GLXclientStateRec *, GLbyte *);
+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 int __glXDisp_IsDirect(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_IsDirect(struct __GLXclientStateRec *, GLbyte *);
+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 int __glXDisp_SwapIntervalSGI(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_SwapIntervalSGI(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_GetColorTableParameterfv(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetColorTableParameterfv(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_GetColorTableParameterfvSGI(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetColorTableParameterfvSGI(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 int __glXDisp_VendorPrivateWithReply(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_VendorPrivateWithReply(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_ChangeDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_ChangeDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_GetMinmaxParameteriv(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetMinmaxParameteriv(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_GetMinmaxParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetMinmaxParameterivEXT(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_RasterPos2dv(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_RasterPos2dv(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 void __glXDisp_SecondaryColor3ubvEXT(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_SecondaryColor3ubvEXT(GLbyte * pc);
+extern HIDDEN void __glXDisp_VertexAttrib3fvNV(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_VertexAttrib3fvNV(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 int __glXDisp_GetColorTableParameterivSGI(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetColorTableParameterivSGI(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_ReleaseTexImageEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_ReleaseTexImageEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN void __glXDisp_CallList(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_CallList(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_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 int __glXDisp_BindTexImageEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_BindTexImageEXT(struct __GLXclientStateRec *, GLbyte *);
+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_VertexAttrib2fvARB(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_VertexAttrib2fvARB(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_GetConvolutionParameterfv(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetConvolutionParameterfv(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_GetConvolutionParameterfvEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetConvolutionParameterfvEXT(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 int __glXDisp_UseXFont(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_UseXFont(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN void __glXDisp_ShadeModel(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_ShadeModel(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_DrawArrays(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_DrawArrays(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_GetHistogramParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetHistogramParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN void __glXDisp_Rotatef(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_Rotatef(GLbyte * pc);
+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_MakeCurrentReadSGI(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_MakeCurrentReadSGI(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_GetTexGeniv(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetTexGeniv(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_MakeCurrent(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_MakeCurrent(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 int __glXDisp_GetConvolutionFilter(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetConvolutionFilter(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_GetConvolutionFilterEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetConvolutionFilterEXT(struct __GLXclientStateRec *, GLbyte *);
+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 int __glXDisp_GetHistogramEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetHistogramEXT(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_CreateWindow(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_CreateWindow(struct __GLXclientStateRec *, GLbyte *);
+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_DrawBuffersARB(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_DrawBuffersARB(GLbyte * pc);
+extern HIDDEN void __glXDisp_LoadName(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_LoadName(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 int __glXDisp_QueryContextInfoEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_QueryContextInfoEXT(struct __GLXclientStateRec *, GLbyte *);
+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_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 int __glXDisp_QueryContext(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_QueryContext(struct __GLXclientStateRec *, GLbyte *);
+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 int __glXDisp_ClientInfo(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_ClientInfo(struct __GLXclientStateRec *, GLbyte *);
+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 int __glXDisp_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);
+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_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 int __glXDisp_GetMinmaxParameterfvEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_GetMinmaxParameterfvEXT(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_ ) */
diff --git a/src/glx/x11/indirect_dispatch_swap.c b/src/glx/x11/indirect_dispatch_swap.c
new file mode 100644
index 00000000000..f137cbe98ad
--- /dev/null
+++ b/src/glx/x11/indirect_dispatch_swap.c
@@ -0,0 +1,6051 @@
+/* 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 <inttypes.h>
+#include "indirect_size.h"
+#include "indirect_size_get.h"
+#include "indirect_dispatch.h"
+#include "glxserver.h"
+#include "glxbyteorder.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 GLsizei
+bswap_CARD32( const void * src )
+{
+    union { uint32_t dst; GLsizei 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 GLenum
+bswap_ENUM( const void * src )
+{
+    union { uint32_t dst; GLenum ret; } x;
+    x.dst = bswap_32( *(uint32_t *) src );
+    return x.ret;
+}
+
+static GLdouble
+bswap_FLOAT64( const void * src )
+{
+    union { uint64_t dst; GLdouble ret; } x;
+    x.dst = bswap_64( *(uint64_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 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;
+    default:
+        return;
+    }
+
+    CALL_CallLists( GET_DISPATCH(), (
+        n,
+        type,
+        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(), (
+        pname,
+        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(), (
+        pname,
+        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 ),
+        pname,
+        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 ),
+        pname,
+        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(), (
+        pname,
+        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(), (
+        pname,
+        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 ),
+        pname,
+        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 ),
+        pname,
+        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 ),
+        pname,
+        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 ),
+        pname,
+        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 ),
+        pname,
+        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 ),
+        pname,
+        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 ),
+        pname,
+        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 ),
+        pname,
+        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 ),
+        pname,
+        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(), (
+            pname,
+            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(), (
+            pname,
+            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(), (
+            pname,
+            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(), (
+            pname,
+            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 ),
+            pname,
+            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 ),
+            pname,
+            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(), (
+            target,
+            query,
+            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(), (
+            target,
+            query,
+            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(), (
+            target,
+            query,
+            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 ),
+            pname,
+            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 ),
+            pname,
+            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(), (
+            map,
+            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(), (
+            map,
+            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(), (
+            map,
+            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 ),
+            pname,
+            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 ),
+            pname,
+            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 ),
+            pname,
+            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 ),
+            pname,
+            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 ),
+            pname,
+            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 ),
+            pname,
+            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 ),
+            pname,
+            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 ),
+            pname,
+            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 ),
+            pname,
+            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;
+}
+
+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_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)
+{
+    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_DeleteTextures( GET_DISPATCH(), (
+            n,
+             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
+        ) );
+        error = Success;
+    }
+
+    return error;
+}
+
+int __glXDispSwap_DeleteTexturesEXT(__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_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_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;
+}
+
+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_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 ),
+        pname,
+        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 ),
+        pname,
+        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 ),
+            pname,
+            params
+        ) );
+        (void) bswap_32_array( (uint32_t *) params, compsize );
+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+int __glXDispSwap_GetColorTableParameterfvSGI(__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 = __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 ),
+            pname,
+            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 ),
+            pname,
+            params
+        ) );
+        (void) bswap_32_array( (uint32_t *) params, compsize );
+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+int __glXDispSwap_GetColorTableParameterivSGI(__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 = __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 ),
+            pname,
+            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 ),
+        pname,
+        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 ),
+        pname,
+        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 ),
+            pname,
+            params
+        ) );
+        (void) bswap_32_array( (uint32_t *) params, compsize );
+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+int __glXDispSwap_GetConvolutionParameterfvEXT(__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 = __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 ),
+            pname,
+            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 ),
+            pname,
+            params
+        ) );
+        (void) bswap_32_array( (uint32_t *) params, compsize );
+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+int __glXDispSwap_GetConvolutionParameterivEXT(__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 = __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 ),
+            pname,
+            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 ),
+            pname,
+            params
+        ) );
+        (void) bswap_32_array( (uint32_t *) params, compsize );
+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+int __glXDispSwap_GetHistogramParameterfvEXT(__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 = __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 ),
+            pname,
+            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 ),
+            pname,
+            params
+        ) );
+        (void) bswap_32_array( (uint32_t *) params, compsize );
+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+int __glXDispSwap_GetHistogramParameterivEXT(__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 = __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 ),
+            pname,
+            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 ),
+            pname,
+            params
+        ) );
+        (void) bswap_32_array( (uint32_t *) params, compsize );
+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+int __glXDispSwap_GetMinmaxParameterfvEXT(__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 = __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 ),
+            pname,
+            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 ),
+            pname,
+            params
+        ) );
+        (void) bswap_32_array( (uint32_t *) params, compsize );
+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+int __glXDispSwap_GetMinmaxParameterivEXT(__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 = __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 ),
+            pname,
+            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_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_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_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_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_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_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)
+    ) );
+}
+
+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 ),
+            pname,
+            params
+        ) );
+        (void) bswap_32_array( (uint32_t *) params, compsize );
+        __glXSendReplySwap(cl->client, params, compsize, 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 ),
+            pname,
+            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 ),
+            pname,
+            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 ),
+            pname,
+            params
+        ) );
+        (void) bswap_32_array( (uint32_t *) params, compsize );
+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+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 )
+    ) );
+}
+
+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_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 +  0 ),
+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  4), 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 +  0 ),
+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  4), 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 +  0 ),
+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  4), 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_VertexAttrib4NbvARB(GLbyte * pc)
+{
+    CALL_VertexAttrib4NbvARB( GET_DISPATCH(), (
+         (GLuint  )bswap_CARD32 ( pc +  0 ),
+         (const GLbyte *)(pc +  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_VertexAttrib4NsvARB(GLbyte * pc)
+{
+    CALL_VertexAttrib4NsvARB( 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_VertexAttrib4NuivARB(GLbyte * pc)
+{
+    CALL_VertexAttrib4NuivARB( GET_DISPATCH(), (
+         (GLuint  )bswap_CARD32 ( pc +  0 ),
+         (const GLuint *)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_VertexAttrib4bvARB(GLbyte * pc)
+{
+    CALL_VertexAttrib4bvARB( GET_DISPATCH(), (
+         (GLuint  )bswap_CARD32 ( pc +  0 ),
+         (const GLbyte *)(pc +  4)
+    ) );
+}
+
+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 +  0 ),
+         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  4), 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_VertexAttrib4ivARB(GLbyte * pc)
+{
+    CALL_VertexAttrib4ivARB( GET_DISPATCH(), (
+         (GLuint  )bswap_CARD32 ( pc +  0 ),
+         (const GLint *)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_VertexAttrib4ubvARB(GLbyte * pc)
+{
+    CALL_VertexAttrib4ubvARB( GET_DISPATCH(), (
+         (GLuint  )bswap_CARD32 ( pc +  0 ),
+         (const GLubyte *)(pc +  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_VertexAttrib4usvARB(GLbyte * pc)
+{
+    CALL_VertexAttrib4usvARB( GET_DISPATCH(), (
+         (GLuint  )bswap_CARD32 ( pc +  0 ),
+         (const GLushort *)bswap_16_array( (uint16_t *) (pc +  4), 4 )
+    ) );
+}
+
+void __glXDispSwap_BeginQueryARB(GLbyte * pc)
+{
+    CALL_BeginQueryARB( GET_DISPATCH(), (
+         (GLenum  )bswap_ENUM   ( pc +  0 ),
+         (GLuint  )bswap_CARD32 ( pc +  4 )
+    ) );
+}
+
+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;
+}
+
+void __glXDispSwap_EndQueryARB(GLbyte * pc)
+{
+    CALL_EndQueryARB( GET_DISPATCH(), (
+         (GLenum  )bswap_ENUM   ( pc +  0 )
+    ) );
+}
+
+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_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 ),
+            pname,
+            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 ),
+            pname,
+            params
+        ) );
+        (void) bswap_32_array( (uint32_t *) params, compsize );
+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
+        error = Success;
+    }
+
+    return error;
+}
+
+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 ),
+            pname,
+            params
+        ) );
+        (void) bswap_32_array( (uint32_t *) params, compsize );
+        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 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_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 )
+    ) );
+}
+
+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(), (
+        pname,
+        params
+    ) );
+}
+
+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 )
+    ) );
+}
+
+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_FogCoordfvEXT(GLbyte * pc)
+{
+    CALL_FogCoordfvEXT( GET_DISPATCH(), (
+         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 1 )
+    ) );
+}
+
+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_WindowPos3fvMESA(GLbyte * pc)
+{
+    CALL_WindowPos3fvMESA( GET_DISPATCH(), (
+         (const GLfloat *)bswap_32_array( (uint32_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_TRUE, 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 ),
+            pname,
+            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_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 ),
+            pname,
+            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 ),
+            pname,
+            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 ),
+            pname,
+            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_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_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)
+    ) );
+}
+
+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(), (
+        pname,
+        params
+    ) );
+}
+
+void __glXDispSwap_ActiveStencilFaceEXT(GLbyte * pc)
+{
+    CALL_ActiveStencilFaceEXT( GET_DISPATCH(), (
+         (GLenum  )bswap_ENUM   ( pc +  0 )
+    ) );
+}
+
+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_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;
+}
+
+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 )
+    ) );
+}
+
+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_BlendEquationSeparateEXT(GLbyte * pc)
+{
+    CALL_BlendEquationSeparateEXT( GET_DISPATCH(), (
+         (GLenum  )bswap_ENUM   ( pc +  0 ),
+         (GLenum  )bswap_ENUM   ( pc +  4 )
+    ) );
+}
+
+void __glXDispSwap_BindFramebufferEXT(GLbyte * pc)
+{
+    CALL_BindFramebufferEXT( GET_DISPATCH(), (
+         (GLenum  )bswap_ENUM   ( pc +  0 ),
+         (GLuint  )bswap_CARD32 ( pc +  4 )
+    ) );
+}
+
+void __glXDispSwap_BindRenderbufferEXT(GLbyte * pc)
+{
+    CALL_BindRenderbufferEXT( GET_DISPATCH(), (
+         (GLenum  )bswap_ENUM   ( pc +  0 ),
+         (GLuint  )bswap_CARD32 ( pc +  4 )
+    ) );
+}
+
+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_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 )
+    ) );
+}
+
+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 )
+    ) );
+}
+
+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 )
+    ) );
+}
+
+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 )
+    ) );
+}
+
+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_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_GenerateMipmapEXT(GLbyte * pc)
+{
+    CALL_GenerateMipmapEXT( GET_DISPATCH(), (
+         (GLenum  )bswap_ENUM   ( pc +  0 )
+    ) );
+}
+
+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;
+}
+
+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;
+}
+
+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_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 )
+    ) );
+}
+
diff --git a/src/glx/x11/indirect_reqsize.c b/src/glx/x11/indirect_reqsize.c
new file mode 100644
index 00000000000..954eecd9729
--- /dev/null
+++ b/src/glx/x11/indirect_reqsize.c
@@ -0,0 +1,832 @@
+/* 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 "glxbyteorder.h"
+#include "indirect_size.h"
+#include "indirect_reqsize.h"
+
+#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) {
+        n = bswap_32(n);
+        type = bswap_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) {
+        row_length = bswap_32(row_length);
+        skip_rows = bswap_32(skip_rows);
+        alignment = bswap_32(alignment);
+        width = bswap_32(width);
+        height = bswap_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) {
+        pname = bswap_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) {
+        pname = bswap_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) {
+        pname = bswap_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) {
+        pname = bswap_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) {
+        row_length = bswap_32(row_length);
+        skip_rows = bswap_32(skip_rows);
+        alignment = bswap_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) {
+        pname = bswap_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) {
+        row_length = bswap_32(row_length);
+        skip_rows = bswap_32(skip_rows);
+        alignment = bswap_32(alignment);
+        target = bswap_32(target);
+        width = bswap_32(width);
+        format = bswap_32(format);
+        type = bswap_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) {
+        row_length = bswap_32(row_length);
+        skip_rows = bswap_32(skip_rows);
+        alignment = bswap_32(alignment);
+        target = bswap_32(target);
+        width = bswap_32(width);
+        height = bswap_32(height);
+        format = bswap_32(format);
+        type = bswap_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) {
+        pname = bswap_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) {
+        pname = bswap_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) {
+        pname = bswap_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) {
+        mapsize = bswap_32(mapsize);
+    }
+
+    return __GLX_PAD((mapsize * 4));
+}
+
+int
+__glXPixelMapusvReqSize(const GLbyte *pc, Bool swap)
+{
+    GLsizei mapsize = *(GLsizei *) (pc + 4);
+
+    if (swap) {
+        mapsize = bswap_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) {
+        row_length = bswap_32(row_length);
+        skip_rows = bswap_32(skip_rows);
+        alignment = bswap_32(alignment);
+        width = bswap_32(width);
+        height = bswap_32(height);
+        format = bswap_32(format);
+        type = bswap_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) {
+        n = bswap_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) {
+        row_length = bswap_32(row_length);
+        skip_rows = bswap_32(skip_rows);
+        alignment = bswap_32(alignment);
+        target = bswap_32(target);
+        width = bswap_32(width);
+        format = bswap_32(format);
+        type = bswap_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) {
+        row_length = bswap_32(row_length);
+        skip_rows = bswap_32(skip_rows);
+        alignment = bswap_32(alignment);
+        target = bswap_32(target);
+        width = bswap_32(width);
+        height = bswap_32(height);
+        format = bswap_32(format);
+        type = bswap_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) {
+        row_length = bswap_32(row_length);
+        skip_rows = bswap_32(skip_rows);
+        alignment = bswap_32(alignment);
+        target = bswap_32(target);
+        width = bswap_32(width);
+        format = bswap_32(format);
+        type = bswap_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) {
+        pname = bswap_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) {
+        row_length = bswap_32(row_length);
+        skip_rows = bswap_32(skip_rows);
+        alignment = bswap_32(alignment);
+        target = bswap_32(target);
+        count = bswap_32(count);
+        format = bswap_32(format);
+        type = bswap_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) {
+        row_length = bswap_32(row_length);
+        skip_rows = bswap_32(skip_rows);
+        alignment = bswap_32(alignment);
+        target = bswap_32(target);
+        width = bswap_32(width);
+        format = bswap_32(format);
+        type = bswap_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) {
+        row_length = bswap_32(row_length);
+        skip_rows = bswap_32(skip_rows);
+        alignment = bswap_32(alignment);
+        target = bswap_32(target);
+        width = bswap_32(width);
+        height = bswap_32(height);
+        format = bswap_32(format);
+        type = bswap_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) {
+        pname = bswap_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) {
+        row_length = bswap_32(row_length);
+        image_height = bswap_32(image_height);
+        skip_rows = bswap_32(skip_rows);
+        skip_images = bswap_32(skip_images);
+        alignment = bswap_32(alignment);
+        target = bswap_32(target);
+        width = bswap_32(width);
+        height = bswap_32(height);
+        depth = bswap_32(depth);
+        format = bswap_32(format);
+        type = bswap_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) {
+        row_length = bswap_32(row_length);
+        image_height = bswap_32(image_height);
+        skip_rows = bswap_32(skip_rows);
+        skip_images = bswap_32(skip_images);
+        alignment = bswap_32(alignment);
+        target = bswap_32(target);
+        width = bswap_32(width);
+        height = bswap_32(height);
+        depth = bswap_32(depth);
+        format = bswap_32(format);
+        type = bswap_32(type);
+    }
+
+    return __glXImageSize(format, type, target, width, height, depth,
+                          image_height, row_length, skip_images,
+                          skip_rows, alignment);
+}
+
+int
+__glXCompressedTexImage1DARBReqSize(const GLbyte *pc, Bool swap)
+{
+    GLsizei imageSize = *(GLsizei *) (pc + 20);
+
+    if (swap) {
+        imageSize = bswap_32(imageSize);
+    }
+
+    return __GLX_PAD(imageSize);
+}
+
+int
+__glXCompressedTexImage2DARBReqSize(const GLbyte *pc, Bool swap)
+{
+    GLsizei imageSize = *(GLsizei *) (pc + 24);
+
+    if (swap) {
+        imageSize = bswap_32(imageSize);
+    }
+
+    return __GLX_PAD(imageSize);
+}
+
+int
+__glXCompressedTexImage3DARBReqSize(const GLbyte *pc, Bool swap)
+{
+    GLsizei imageSize = *(GLsizei *) (pc + 28);
+
+    if (swap) {
+        imageSize = bswap_32(imageSize);
+    }
+
+    return __GLX_PAD(imageSize);
+}
+
+int
+__glXCompressedTexSubImage3DARBReqSize(const GLbyte *pc, Bool swap)
+{
+    GLsizei imageSize = *(GLsizei *) (pc + 36);
+
+    if (swap) {
+        imageSize = bswap_32(imageSize);
+    }
+
+    return __GLX_PAD(imageSize);
+}
+
+int
+__glXProgramStringARBReqSize(const GLbyte *pc, Bool swap)
+{
+    GLsizei len = *(GLsizei *) (pc + 8);
+
+    if (swap) {
+        len = bswap_32(len);
+    }
+
+    return __GLX_PAD(len);
+}
+
+int
+__glXDrawBuffersARBReqSize(const GLbyte *pc, Bool swap)
+{
+    GLsizei n = *(GLsizei *) (pc + 0);
+
+    if (swap) {
+        n = bswap_32(n);
+    }
+
+    return __GLX_PAD((n * 4));
+}
+
+int
+__glXPointParameterfvEXTReqSize(const GLbyte *pc, Bool swap)
+{
+    GLenum pname = *(GLenum *) (pc + 0);
+    GLsizei compsize;
+
+    if (swap) {
+        pname = bswap_32(pname);
+    }
+
+    compsize = __glPointParameterfvEXT_size(pname);
+    return __GLX_PAD((compsize * 4));
+}
+
+int
+__glXProgramParameters4dvNVReqSize(const GLbyte *pc, Bool swap)
+{
+    GLuint num = *(GLuint *) (pc + 8);
+
+    if (swap) {
+        num = bswap_32(num);
+    }
+
+    return __GLX_PAD((num * 32));
+}
+
+int
+__glXProgramParameters4fvNVReqSize(const GLbyte *pc, Bool swap)
+{
+    GLuint num = *(GLuint *) (pc + 8);
+
+    if (swap) {
+        num = bswap_32(num);
+    }
+
+    return __GLX_PAD((num * 16));
+}
+
+int
+__glXVertexAttribs1dvNVReqSize(const GLbyte *pc, Bool swap)
+{
+    GLsizei n = *(GLsizei *) (pc + 4);
+
+    if (swap) {
+        n = bswap_32(n);
+    }
+
+    return __GLX_PAD((n * 8));
+}
+
+int
+__glXVertexAttribs2dvNVReqSize(const GLbyte *pc, Bool swap)
+{
+    GLsizei n = *(GLsizei *) (pc + 4);
+
+    if (swap) {
+        n = bswap_32(n);
+    }
+
+    return __GLX_PAD((n * 16));
+}
+
+int
+__glXVertexAttribs3dvNVReqSize(const GLbyte *pc, Bool swap)
+{
+    GLsizei n = *(GLsizei *) (pc + 4);
+
+    if (swap) {
+        n = bswap_32(n);
+    }
+
+    return __GLX_PAD((n * 24));
+}
+
+int
+__glXVertexAttribs3fvNVReqSize(const GLbyte *pc, Bool swap)
+{
+    GLsizei n = *(GLsizei *) (pc + 4);
+
+    if (swap) {
+        n = bswap_32(n);
+    }
+
+    return __GLX_PAD((n * 12));
+}
+
+int
+__glXVertexAttribs3svNVReqSize(const GLbyte *pc, Bool swap)
+{
+    GLsizei n = *(GLsizei *) (pc + 4);
+
+    if (swap) {
+        n = bswap_32(n);
+    }
+
+    return __GLX_PAD((n * 6));
+}
+
+int
+__glXVertexAttribs4dvNVReqSize(const GLbyte *pc, Bool swap)
+{
+    GLsizei n = *(GLsizei *) (pc + 4);
+
+    if (swap) {
+        n = bswap_32(n);
+    }
+
+    return __GLX_PAD((n * 32));
+}
+
+int
+__glXProgramNamedParameter4fvNVReqSize(const GLbyte *pc, Bool swap)
+{
+    GLsizei len = *(GLsizei *) (pc + 4);
+
+    if (swap) {
+        len = bswap_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(CompressedTexSubImage1DARB, CompressedTexImage1DARB)
+    ALIAS(CompressedTexSubImage2DARB, CompressedTexImage3DARB)
+    ALIAS(LoadProgramNV, ProgramStringARB)
+    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(ProgramNamedParameter4dvNV, CompressedTexSubImage3DARB)
+    ALIAS(DeleteFramebuffersEXT, DrawBuffersARB)
+    ALIAS(DeleteRenderbuffersEXT, DrawBuffersARB)
diff --git a/src/glx/x11/indirect_reqsize.h b/src/glx/x11/indirect_reqsize.h
new file mode 100644
index 00000000000..26211ee5cae
--- /dev/null
+++ b/src/glx/x11/indirect_reqsize.h
@@ -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 __glXCompressedTexImage1DARBReqSize(const GLbyte *pc, Bool swap);
+extern PURE HIDDEN int __glXCompressedTexImage2DARBReqSize(const GLbyte *pc, Bool swap);
+extern PURE HIDDEN int __glXCompressedTexImage3DARBReqSize(const GLbyte *pc, Bool swap);
+extern PURE HIDDEN int __glXCompressedTexSubImage1DARBReqSize(const GLbyte *pc, Bool swap);
+extern PURE HIDDEN int __glXCompressedTexSubImage2DARBReqSize(const GLbyte *pc, Bool swap);
+extern PURE HIDDEN int __glXCompressedTexSubImage3DARBReqSize(const GLbyte *pc, Bool swap);
+extern PURE HIDDEN int __glXProgramStringARBReqSize(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 __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 __glXProgramNamedParameter4dvNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE HIDDEN int __glXProgramNamedParameter4fvNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE HIDDEN int __glXDeleteFramebuffersEXTReqSize(const GLbyte *pc, Bool swap);
+extern PURE HIDDEN int __glXDeleteRenderbuffersEXTReqSize(const GLbyte *pc, Bool swap);
+
+#  undef HIDDEN
+#  undef PURE
+
+#endif /* !defined( _INDIRECT_REQSIZE_H_ ) */
diff --git a/src/glx/x11/indirect_size_get.c b/src/glx/x11/indirect_size_get.c
new file mode 100644
index 00000000000..e7eaf97cbb8
--- /dev/null
+++ b/src/glx/x11/indirect_size_get.c
@@ -0,0 +1,1206 @@
+/* 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 "glxserver.h"
+#include "indirect_util.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_CLIENT_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_MAX_CLIENT_ATTRIB_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_MAX_3D_TEXTURE_SIZE:
+    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_MAX_RENDERBUFFER_SIZE_EXT:
+    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_TEXTURE_MAX_ANISOTROPY_EXT:
+    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_COMPRESSED_TEXTURE_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_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:
+    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_COMPARE_REF_DEPTH_TO_TEXTURE_EXT:
+    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_MAX_TEXTURE_COORDS_ARB:
+    case GL_MAX_TEXTURE_IMAGE_UNITS_ARB:
+    case GL_DEPTH_BOUNDS_TEST_EXT:
+    case GL_MAX_ARRAY_TEXTURE_LAYERS_EXT:
+    case GL_STENCIL_TEST_TWO_SIDE_EXT:
+    case GL_ACTIVE_STENCIL_FACE_EXT:
+    case GL_TEXTURE_BINDING_1D_ARRAY_EXT:
+    case GL_TEXTURE_BINDING_2D_ARRAY_EXT:
+    case GL_DRAW_FRAMEBUFFER_BINDING_EXT:
+    case GL_RENDERBUFFER_BINDING_EXT:
+    case GL_READ_FRAMEBUFFER_BINDING_EXT:
+    case GL_MAX_COLOR_ATTACHMENTS_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
+__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_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
+__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
+__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
+__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
+__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
+__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(GetQueryObjectuivARB, GetQueryObjectivARB)
+    ALIAS(GetVertexAttribfvNV, GetVertexAttribdvNV)
+    ALIAS(GetVertexAttribivNV, GetVertexAttribdvNV)
+    ALIAS(PointParameterivNV, PointParameterfvEXT)
+#  undef PURE
+#  undef FASTCALL
+#  undef INTERNAL
diff --git a/src/glx/x11/indirect_size_get.h b/src/glx/x11/indirect_size_get.h
new file mode 100644
index 00000000000..4fcb55b4e1c
--- /dev/null
+++ b/src/glx/x11/indirect_size_get.h
@@ -0,0 +1,102 @@
+/* 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 <[email protected]>
+ */
+
+#  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 __glGetProgramivARB_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 __glGetQueryObjectivARB_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glGetQueryObjectuivARB_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glGetQueryivARB_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glGetProgramivNV_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_ ) */
diff --git a/src/glx/x11/indirect_table.c b/src/glx/x11/indirect_table.c
new file mode 100644
index 00000000000..cb3202605d6
--- /dev/null
+++ b/src/glx/x11/indirect_table.c
@@ -0,0 +1,1596 @@
+/* DO NOT EDIT - This file generated automatically by glX_server_table.py (from Mesa) script */
+
+/*
+ * (C) Copyright IBM Corporation 2005, 2006
+ * 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 <inttypes.h>
+#include "glxserver.h"
+#include "glxext.h"
+#include "indirect_dispatch.h"
+#include "indirect_reqsize.h"
+#include "g_disptab.h"
+#include "indirect_table.h"
+
+/*****************************************************************/
+/* tree depth = 3 */
+static const int_fast16_t Single_dispatch_tree[24] = {
+    /* [0] -> opcode range [0, 256], node depth 1 */
+    2,
+    5,
+    13,
+    16,
+    EMPTY_LEAF,
+
+    /* [5] -> opcode range [0, 64], node depth 2 */
+    2,
+    LEAF(0),
+    LEAF(16),
+    10,
+    EMPTY_LEAF,
+
+    /* [10] -> opcode range [32, 48], node depth 3 */
+    1,
+    LEAF(32),
+    EMPTY_LEAF,
+
+    /* [13] -> opcode range [64, 128], node depth 2 */
+    1,
+    EMPTY_LEAF,
+    LEAF(40),
+
+    /* [16] -> opcode range [128, 192], node depth 2 */
+    2,
+    LEAF(72),
+    LEAF(88),
+    21,
+    EMPTY_LEAF,
+
+    /* [21] -> opcode range [160, 176], node depth 3 */
+    1,
+    LEAF(104),
+    EMPTY_LEAF,
+
+};
+
+static const void *Single_function_table[112][2] = {
+    /* [  0] =     0 */ {NULL, NULL},
+    /* [  1] =     1 */ {__glXDisp_Render, __glXDispSwap_Render},
+    /* [  2] =     2 */ {__glXDisp_RenderLarge, __glXDispSwap_RenderLarge},
+    /* [  3] =     3 */ {__glXDisp_CreateContext, __glXDispSwap_CreateContext},
+    /* [  4] =     4 */ {__glXDisp_DestroyContext, __glXDispSwap_DestroyContext},
+    /* [  5] =     5 */ {__glXDisp_MakeCurrent, __glXDispSwap_MakeCurrent},
+    /* [  6] =     6 */ {__glXDisp_IsDirect, __glXDispSwap_IsDirect},
+    /* [  7] =     7 */ {__glXDisp_QueryVersion, __glXDispSwap_QueryVersion},
+    /* [  8] =     8 */ {__glXDisp_WaitGL, __glXDispSwap_WaitGL},
+    /* [  9] =     9 */ {__glXDisp_WaitX, __glXDispSwap_WaitX},
+    /* [ 10] =    10 */ {__glXDisp_CopyContext, __glXDispSwap_CopyContext},
+    /* [ 11] =    11 */ {__glXDisp_SwapBuffers, __glXDispSwap_SwapBuffers},
+    /* [ 12] =    12 */ {__glXDisp_UseXFont, __glXDispSwap_UseXFont},
+    /* [ 13] =    13 */ {__glXDisp_CreateGLXPixmap, __glXDispSwap_CreateGLXPixmap},
+    /* [ 14] =    14 */ {__glXDisp_GetVisualConfigs, __glXDispSwap_GetVisualConfigs},
+    /* [ 15] =    15 */ {__glXDisp_DestroyGLXPixmap, __glXDispSwap_DestroyGLXPixmap},
+    /* [ 16] =    16 */ {__glXDisp_VendorPrivate, __glXDispSwap_VendorPrivate},
+    /* [ 17] =    17 */ {__glXDisp_VendorPrivateWithReply, __glXDispSwap_VendorPrivateWithReply},
+    /* [ 18] =    18 */ {__glXDisp_QueryExtensionsString, __glXDispSwap_QueryExtensionsString},
+    /* [ 19] =    19 */ {__glXDisp_QueryServerString, __glXDispSwap_QueryServerString},
+    /* [ 20] =    20 */ {__glXDisp_ClientInfo, __glXDispSwap_ClientInfo},
+    /* [ 21] =    21 */ {__glXDisp_GetFBConfigs, __glXDispSwap_GetFBConfigs},
+    /* [ 22] =    22 */ {__glXDisp_CreatePixmap, __glXDispSwap_CreatePixmap},
+    /* [ 23] =    23 */ {__glXDisp_DestroyPixmap, __glXDispSwap_DestroyPixmap},
+    /* [ 24] =    24 */ {__glXDisp_CreateNewContext, __glXDispSwap_CreateNewContext},
+    /* [ 25] =    25 */ {__glXDisp_QueryContext, __glXDispSwap_QueryContext},
+    /* [ 26] =    26 */ {__glXDisp_MakeContextCurrent, __glXDispSwap_MakeContextCurrent},
+    /* [ 27] =    27 */ {__glXDisp_CreatePbuffer, __glXDispSwap_CreatePbuffer},
+    /* [ 28] =    28 */ {__glXDisp_DestroyPbuffer, __glXDispSwap_DestroyPbuffer},
+    /* [ 29] =    29 */ {__glXDisp_GetDrawableAttributes, __glXDispSwap_GetDrawableAttributes},
+    /* [ 30] =    30 */ {__glXDisp_ChangeDrawableAttributes, __glXDispSwap_ChangeDrawableAttributes},
+    /* [ 31] =    31 */ {__glXDisp_CreateWindow, __glXDispSwap_CreateWindow},
+    /* [ 32] =    32 */ {__glXDisp_DestroyWindow, __glXDispSwap_DestroyWindow},
+    /* [ 33] =    33 */ {NULL, NULL},
+    /* [ 34] =    34 */ {NULL, NULL},
+    /* [ 35] =    35 */ {NULL, NULL},
+    /* [ 36] =    36 */ {NULL, NULL},
+    /* [ 37] =    37 */ {NULL, NULL},
+    /* [ 38] =    38 */ {NULL, NULL},
+    /* [ 39] =    39 */ {NULL, NULL},
+    /* [ 40] =    96 */ {NULL, NULL},
+    /* [ 41] =    97 */ {NULL, NULL},
+    /* [ 42] =    98 */ {NULL, NULL},
+    /* [ 43] =    99 */ {NULL, NULL},
+    /* [ 44] =   100 */ {NULL, NULL},
+    /* [ 45] =   101 */ {__glXDisp_NewList, __glXDispSwap_NewList},
+    /* [ 46] =   102 */ {__glXDisp_EndList, __glXDispSwap_EndList},
+    /* [ 47] =   103 */ {__glXDisp_DeleteLists, __glXDispSwap_DeleteLists},
+    /* [ 48] =   104 */ {__glXDisp_GenLists, __glXDispSwap_GenLists},
+    /* [ 49] =   105 */ {__glXDisp_FeedbackBuffer, __glXDispSwap_FeedbackBuffer},
+    /* [ 50] =   106 */ {__glXDisp_SelectBuffer, __glXDispSwap_SelectBuffer},
+    /* [ 51] =   107 */ {__glXDisp_RenderMode, __glXDispSwap_RenderMode},
+    /* [ 52] =   108 */ {__glXDisp_Finish, __glXDispSwap_Finish},
+    /* [ 53] =   109 */ {__glXDisp_PixelStoref, __glXDispSwap_PixelStoref},
+    /* [ 54] =   110 */ {__glXDisp_PixelStorei, __glXDispSwap_PixelStorei},
+    /* [ 55] =   111 */ {__glXDisp_ReadPixels, __glXDispSwap_ReadPixels},
+    /* [ 56] =   112 */ {__glXDisp_GetBooleanv, __glXDispSwap_GetBooleanv},
+    /* [ 57] =   113 */ {__glXDisp_GetClipPlane, __glXDispSwap_GetClipPlane},
+    /* [ 58] =   114 */ {__glXDisp_GetDoublev, __glXDispSwap_GetDoublev},
+    /* [ 59] =   115 */ {__glXDisp_GetError, __glXDispSwap_GetError},
+    /* [ 60] =   116 */ {__glXDisp_GetFloatv, __glXDispSwap_GetFloatv},
+    /* [ 61] =   117 */ {__glXDisp_GetIntegerv, __glXDispSwap_GetIntegerv},
+    /* [ 62] =   118 */ {__glXDisp_GetLightfv, __glXDispSwap_GetLightfv},
+    /* [ 63] =   119 */ {__glXDisp_GetLightiv, __glXDispSwap_GetLightiv},
+    /* [ 64] =   120 */ {__glXDisp_GetMapdv, __glXDispSwap_GetMapdv},
+    /* [ 65] =   121 */ {__glXDisp_GetMapfv, __glXDispSwap_GetMapfv},
+    /* [ 66] =   122 */ {__glXDisp_GetMapiv, __glXDispSwap_GetMapiv},
+    /* [ 67] =   123 */ {__glXDisp_GetMaterialfv, __glXDispSwap_GetMaterialfv},
+    /* [ 68] =   124 */ {__glXDisp_GetMaterialiv, __glXDispSwap_GetMaterialiv},
+    /* [ 69] =   125 */ {__glXDisp_GetPixelMapfv, __glXDispSwap_GetPixelMapfv},
+    /* [ 70] =   126 */ {__glXDisp_GetPixelMapuiv, __glXDispSwap_GetPixelMapuiv},
+    /* [ 71] =   127 */ {__glXDisp_GetPixelMapusv, __glXDispSwap_GetPixelMapusv},
+    /* [ 72] =   128 */ {__glXDisp_GetPolygonStipple, __glXDispSwap_GetPolygonStipple},
+    /* [ 73] =   129 */ {__glXDisp_GetString, __glXDispSwap_GetString},
+    /* [ 74] =   130 */ {__glXDisp_GetTexEnvfv, __glXDispSwap_GetTexEnvfv},
+    /* [ 75] =   131 */ {__glXDisp_GetTexEnviv, __glXDispSwap_GetTexEnviv},
+    /* [ 76] =   132 */ {__glXDisp_GetTexGendv, __glXDispSwap_GetTexGendv},
+    /* [ 77] =   133 */ {__glXDisp_GetTexGenfv, __glXDispSwap_GetTexGenfv},
+    /* [ 78] =   134 */ {__glXDisp_GetTexGeniv, __glXDispSwap_GetTexGeniv},
+    /* [ 79] =   135 */ {__glXDisp_GetTexImage, __glXDispSwap_GetTexImage},
+    /* [ 80] =   136 */ {__glXDisp_GetTexParameterfv, __glXDispSwap_GetTexParameterfv},
+    /* [ 81] =   137 */ {__glXDisp_GetTexParameteriv, __glXDispSwap_GetTexParameteriv},
+    /* [ 82] =   138 */ {__glXDisp_GetTexLevelParameterfv, __glXDispSwap_GetTexLevelParameterfv},
+    /* [ 83] =   139 */ {__glXDisp_GetTexLevelParameteriv, __glXDispSwap_GetTexLevelParameteriv},
+    /* [ 84] =   140 */ {__glXDisp_IsEnabled, __glXDispSwap_IsEnabled},
+    /* [ 85] =   141 */ {__glXDisp_IsList, __glXDispSwap_IsList},
+    /* [ 86] =   142 */ {__glXDisp_Flush, __glXDispSwap_Flush},
+    /* [ 87] =   143 */ {__glXDisp_AreTexturesResident, __glXDispSwap_AreTexturesResident},
+    /* [ 88] =   144 */ {__glXDisp_DeleteTextures, __glXDispSwap_DeleteTextures},
+    /* [ 89] =   145 */ {__glXDisp_GenTextures, __glXDispSwap_GenTextures},
+    /* [ 90] =   146 */ {__glXDisp_IsTexture, __glXDispSwap_IsTexture},
+    /* [ 91] =   147 */ {__glXDisp_GetColorTable, __glXDispSwap_GetColorTable},
+    /* [ 92] =   148 */ {__glXDisp_GetColorTableParameterfv, __glXDispSwap_GetColorTableParameterfv},
+    /* [ 93] =   149 */ {__glXDisp_GetColorTableParameteriv, __glXDispSwap_GetColorTableParameteriv},
+    /* [ 94] =   150 */ {__glXDisp_GetConvolutionFilter, __glXDispSwap_GetConvolutionFilter},
+    /* [ 95] =   151 */ {__glXDisp_GetConvolutionParameterfv, __glXDispSwap_GetConvolutionParameterfv},
+    /* [ 96] =   152 */ {__glXDisp_GetConvolutionParameteriv, __glXDispSwap_GetConvolutionParameteriv},
+    /* [ 97] =   153 */ {__glXDisp_GetSeparableFilter, __glXDispSwap_GetSeparableFilter},
+    /* [ 98] =   154 */ {__glXDisp_GetHistogram, __glXDispSwap_GetHistogram},
+    /* [ 99] =   155 */ {__glXDisp_GetHistogramParameterfv, __glXDispSwap_GetHistogramParameterfv},
+    /* [ 100] =   156 */ {__glXDisp_GetHistogramParameteriv, __glXDispSwap_GetHistogramParameteriv},
+    /* [ 101] =   157 */ {__glXDisp_GetMinmax, __glXDispSwap_GetMinmax},
+    /* [ 102] =   158 */ {__glXDisp_GetMinmaxParameterfv, __glXDispSwap_GetMinmaxParameterfv},
+    /* [ 103] =   159 */ {__glXDisp_GetMinmaxParameteriv, __glXDispSwap_GetMinmaxParameteriv},
+    /* [ 104] =   160 */ {__glXDisp_GetCompressedTexImageARB, __glXDispSwap_GetCompressedTexImageARB},
+    /* [ 105] =   161 */ {__glXDisp_DeleteQueriesARB, __glXDispSwap_DeleteQueriesARB},
+    /* [ 106] =   162 */ {__glXDisp_GenQueriesARB, __glXDispSwap_GenQueriesARB},
+    /* [ 107] =   163 */ {__glXDisp_IsQueryARB, __glXDispSwap_IsQueryARB},
+    /* [ 108] =   164 */ {__glXDisp_GetQueryivARB, __glXDispSwap_GetQueryivARB},
+    /* [ 109] =   165 */ {__glXDisp_GetQueryObjectivARB, __glXDispSwap_GetQueryObjectivARB},
+    /* [ 110] =   166 */ {__glXDisp_GetQueryObjectuivARB, __glXDispSwap_GetQueryObjectuivARB},
+    /* [ 111] =   167 */ {NULL, NULL},
+};
+
+const struct __glXDispatchInfo Single_dispatch_info = {
+    8,
+    Single_dispatch_tree,
+    Single_function_table,
+    NULL,
+    NULL
+};
+
+/*****************************************************************/
+/* tree depth = 8 */
+static const int_fast16_t Render_dispatch_tree[95] = {
+    /* [0] -> opcode range [0, 8192], node depth 1 */
+    2,
+    5,
+    31,
+    54,
+    EMPTY_LEAF,
+
+    /* [5] -> opcode range [0, 2048], node depth 2 */
+    1,
+    8,
+    EMPTY_LEAF,
+
+    /* [8] -> opcode range [0, 1024], node depth 3 */
+    1,
+    11,
+    EMPTY_LEAF,
+
+    /* [11] -> opcode range [0, 512], node depth 4 */
+    1,
+    14,
+    EMPTY_LEAF,
+
+    /* [14] -> opcode range [0, 256], node depth 5 */
+    4,
+    LEAF(0),
+    LEAF(16),
+    LEAF(32),
+    LEAF(48),
+    LEAF(64),
+    LEAF(80),
+    LEAF(96),
+    LEAF(112),
+    LEAF(128),
+    LEAF(144),
+    LEAF(160),
+    LEAF(176),
+    LEAF(192),
+    LEAF(208),
+    LEAF(224),
+    EMPTY_LEAF,
+
+    /* [31] -> opcode range [2048, 4096], node depth 2 */
+    1,
+    34,
+    EMPTY_LEAF,
+
+    /* [34] -> opcode range [2048, 3072], node depth 3 */
+    1,
+    37,
+    EMPTY_LEAF,
+
+    /* [37] -> opcode range [2048, 2560], node depth 4 */
+    1,
+    40,
+    EMPTY_LEAF,
+
+    /* [40] -> opcode range [2048, 2304], node depth 5 */
+    1,
+    43,
+    EMPTY_LEAF,
+
+    /* [43] -> opcode range [2048, 2176], node depth 6 */
+    1,
+    46,
+    EMPTY_LEAF,
+
+    /* [46] -> opcode range [2048, 2112], node depth 7 */
+    1,
+    49,
+    EMPTY_LEAF,
+
+    /* [49] -> opcode range [2048, 2080], node depth 8 */
+    2,
+    LEAF(240),
+    LEAF(248),
+    LEAF(256),
+    EMPTY_LEAF,
+
+    /* [54] -> opcode range [4096, 6144], node depth 2 */
+    1,
+    57,
+    EMPTY_LEAF,
+
+    /* [57] -> opcode range [4096, 5120], node depth 3 */
+    1,
+    60,
+    EMPTY_LEAF,
+
+    /* [60] -> opcode range [4096, 4608], node depth 4 */
+    1,
+    63,
+    EMPTY_LEAF,
+
+    /* [63] -> opcode range [4096, 4352], node depth 5 */
+    4,
+    LEAF(264),
+    LEAF(280),
+    80,
+    EMPTY_LEAF,
+    EMPTY_LEAF,
+    LEAF(296),
+    LEAF(312),
+    LEAF(328),
+    LEAF(344),
+    EMPTY_LEAF,
+    83,
+    86,
+    EMPTY_LEAF,
+    89,
+    92,
+    EMPTY_LEAF,
+
+    /* [80] -> opcode range [4128, 4144], node depth 6 */
+    1,
+    LEAF(360),
+    EMPTY_LEAF,
+
+    /* [83] -> opcode range [4256, 4272], node depth 6 */
+    1,
+    EMPTY_LEAF,
+    LEAF(368),
+
+    /* [86] -> opcode range [4272, 4288], node depth 6 */
+    1,
+    LEAF(376),
+    EMPTY_LEAF,
+
+    /* [89] -> opcode range [4304, 4320], node depth 6 */
+    1,
+    EMPTY_LEAF,
+    LEAF(384),
+
+    /* [92] -> opcode range [4320, 4336], node depth 6 */
+    1,
+    LEAF(392),
+    EMPTY_LEAF,
+
+};
+
+static const void *Render_function_table[400][2] = {
+    /* [  0] =     0 */ {NULL, NULL},
+    /* [  1] =     1 */ {__glXDisp_CallList, __glXDispSwap_CallList},
+    /* [  2] =     2 */ {__glXDisp_CallLists, __glXDispSwap_CallLists},
+    /* [  3] =     3 */ {__glXDisp_ListBase, __glXDispSwap_ListBase},
+    /* [  4] =     4 */ {__glXDisp_Begin, __glXDispSwap_Begin},
+    /* [  5] =     5 */ {__glXDisp_Bitmap, __glXDispSwap_Bitmap},
+    /* [  6] =     6 */ {__glXDisp_Color3bv, __glXDispSwap_Color3bv},
+    /* [  7] =     7 */ {__glXDisp_Color3dv, __glXDispSwap_Color3dv},
+    /* [  8] =     8 */ {__glXDisp_Color3fv, __glXDispSwap_Color3fv},
+    /* [  9] =     9 */ {__glXDisp_Color3iv, __glXDispSwap_Color3iv},
+    /* [ 10] =    10 */ {__glXDisp_Color3sv, __glXDispSwap_Color3sv},
+    /* [ 11] =    11 */ {__glXDisp_Color3ubv, __glXDispSwap_Color3ubv},
+    /* [ 12] =    12 */ {__glXDisp_Color3uiv, __glXDispSwap_Color3uiv},
+    /* [ 13] =    13 */ {__glXDisp_Color3usv, __glXDispSwap_Color3usv},
+    /* [ 14] =    14 */ {__glXDisp_Color4bv, __glXDispSwap_Color4bv},
+    /* [ 15] =    15 */ {__glXDisp_Color4dv, __glXDispSwap_Color4dv},
+    /* [ 16] =    16 */ {__glXDisp_Color4fv, __glXDispSwap_Color4fv},
+    /* [ 17] =    17 */ {__glXDisp_Color4iv, __glXDispSwap_Color4iv},
+    /* [ 18] =    18 */ {__glXDisp_Color4sv, __glXDispSwap_Color4sv},
+    /* [ 19] =    19 */ {__glXDisp_Color4ubv, __glXDispSwap_Color4ubv},
+    /* [ 20] =    20 */ {__glXDisp_Color4uiv, __glXDispSwap_Color4uiv},
+    /* [ 21] =    21 */ {__glXDisp_Color4usv, __glXDispSwap_Color4usv},
+    /* [ 22] =    22 */ {__glXDisp_EdgeFlagv, __glXDispSwap_EdgeFlagv},
+    /* [ 23] =    23 */ {__glXDisp_End, __glXDispSwap_End},
+    /* [ 24] =    24 */ {__glXDisp_Indexdv, __glXDispSwap_Indexdv},
+    /* [ 25] =    25 */ {__glXDisp_Indexfv, __glXDispSwap_Indexfv},
+    /* [ 26] =    26 */ {__glXDisp_Indexiv, __glXDispSwap_Indexiv},
+    /* [ 27] =    27 */ {__glXDisp_Indexsv, __glXDispSwap_Indexsv},
+    /* [ 28] =    28 */ {__glXDisp_Normal3bv, __glXDispSwap_Normal3bv},
+    /* [ 29] =    29 */ {__glXDisp_Normal3dv, __glXDispSwap_Normal3dv},
+    /* [ 30] =    30 */ {__glXDisp_Normal3fv, __glXDispSwap_Normal3fv},
+    /* [ 31] =    31 */ {__glXDisp_Normal3iv, __glXDispSwap_Normal3iv},
+    /* [ 32] =    32 */ {__glXDisp_Normal3sv, __glXDispSwap_Normal3sv},
+    /* [ 33] =    33 */ {__glXDisp_RasterPos2dv, __glXDispSwap_RasterPos2dv},
+    /* [ 34] =    34 */ {__glXDisp_RasterPos2fv, __glXDispSwap_RasterPos2fv},
+    /* [ 35] =    35 */ {__glXDisp_RasterPos2iv, __glXDispSwap_RasterPos2iv},
+    /* [ 36] =    36 */ {__glXDisp_RasterPos2sv, __glXDispSwap_RasterPos2sv},
+    /* [ 37] =    37 */ {__glXDisp_RasterPos3dv, __glXDispSwap_RasterPos3dv},
+    /* [ 38] =    38 */ {__glXDisp_RasterPos3fv, __glXDispSwap_RasterPos3fv},
+    /* [ 39] =    39 */ {__glXDisp_RasterPos3iv, __glXDispSwap_RasterPos3iv},
+    /* [ 40] =    40 */ {__glXDisp_RasterPos3sv, __glXDispSwap_RasterPos3sv},
+    /* [ 41] =    41 */ {__glXDisp_RasterPos4dv, __glXDispSwap_RasterPos4dv},
+    /* [ 42] =    42 */ {__glXDisp_RasterPos4fv, __glXDispSwap_RasterPos4fv},
+    /* [ 43] =    43 */ {__glXDisp_RasterPos4iv, __glXDispSwap_RasterPos4iv},
+    /* [ 44] =    44 */ {__glXDisp_RasterPos4sv, __glXDispSwap_RasterPos4sv},
+    /* [ 45] =    45 */ {__glXDisp_Rectdv, __glXDispSwap_Rectdv},
+    /* [ 46] =    46 */ {__glXDisp_Rectfv, __glXDispSwap_Rectfv},
+    /* [ 47] =    47 */ {__glXDisp_Rectiv, __glXDispSwap_Rectiv},
+    /* [ 48] =    48 */ {__glXDisp_Rectsv, __glXDispSwap_Rectsv},
+    /* [ 49] =    49 */ {__glXDisp_TexCoord1dv, __glXDispSwap_TexCoord1dv},
+    /* [ 50] =    50 */ {__glXDisp_TexCoord1fv, __glXDispSwap_TexCoord1fv},
+    /* [ 51] =    51 */ {__glXDisp_TexCoord1iv, __glXDispSwap_TexCoord1iv},
+    /* [ 52] =    52 */ {__glXDisp_TexCoord1sv, __glXDispSwap_TexCoord1sv},
+    /* [ 53] =    53 */ {__glXDisp_TexCoord2dv, __glXDispSwap_TexCoord2dv},
+    /* [ 54] =    54 */ {__glXDisp_TexCoord2fv, __glXDispSwap_TexCoord2fv},
+    /* [ 55] =    55 */ {__glXDisp_TexCoord2iv, __glXDispSwap_TexCoord2iv},
+    /* [ 56] =    56 */ {__glXDisp_TexCoord2sv, __glXDispSwap_TexCoord2sv},
+    /* [ 57] =    57 */ {__glXDisp_TexCoord3dv, __glXDispSwap_TexCoord3dv},
+    /* [ 58] =    58 */ {__glXDisp_TexCoord3fv, __glXDispSwap_TexCoord3fv},
+    /* [ 59] =    59 */ {__glXDisp_TexCoord3iv, __glXDispSwap_TexCoord3iv},
+    /* [ 60] =    60 */ {__glXDisp_TexCoord3sv, __glXDispSwap_TexCoord3sv},
+    /* [ 61] =    61 */ {__glXDisp_TexCoord4dv, __glXDispSwap_TexCoord4dv},
+    /* [ 62] =    62 */ {__glXDisp_TexCoord4fv, __glXDispSwap_TexCoord4fv},
+    /* [ 63] =    63 */ {__glXDisp_TexCoord4iv, __glXDispSwap_TexCoord4iv},
+    /* [ 64] =    64 */ {__glXDisp_TexCoord4sv, __glXDispSwap_TexCoord4sv},
+    /* [ 65] =    65 */ {__glXDisp_Vertex2dv, __glXDispSwap_Vertex2dv},
+    /* [ 66] =    66 */ {__glXDisp_Vertex2fv, __glXDispSwap_Vertex2fv},
+    /* [ 67] =    67 */ {__glXDisp_Vertex2iv, __glXDispSwap_Vertex2iv},
+    /* [ 68] =    68 */ {__glXDisp_Vertex2sv, __glXDispSwap_Vertex2sv},
+    /* [ 69] =    69 */ {__glXDisp_Vertex3dv, __glXDispSwap_Vertex3dv},
+    /* [ 70] =    70 */ {__glXDisp_Vertex3fv, __glXDispSwap_Vertex3fv},
+    /* [ 71] =    71 */ {__glXDisp_Vertex3iv, __glXDispSwap_Vertex3iv},
+    /* [ 72] =    72 */ {__glXDisp_Vertex3sv, __glXDispSwap_Vertex3sv},
+    /* [ 73] =    73 */ {__glXDisp_Vertex4dv, __glXDispSwap_Vertex4dv},
+    /* [ 74] =    74 */ {__glXDisp_Vertex4fv, __glXDispSwap_Vertex4fv},
+    /* [ 75] =    75 */ {__glXDisp_Vertex4iv, __glXDispSwap_Vertex4iv},
+    /* [ 76] =    76 */ {__glXDisp_Vertex4sv, __glXDispSwap_Vertex4sv},
+    /* [ 77] =    77 */ {__glXDisp_ClipPlane, __glXDispSwap_ClipPlane},
+    /* [ 78] =    78 */ {__glXDisp_ColorMaterial, __glXDispSwap_ColorMaterial},
+    /* [ 79] =    79 */ {__glXDisp_CullFace, __glXDispSwap_CullFace},
+    /* [ 80] =    80 */ {__glXDisp_Fogf, __glXDispSwap_Fogf},
+    /* [ 81] =    81 */ {__glXDisp_Fogfv, __glXDispSwap_Fogfv},
+    /* [ 82] =    82 */ {__glXDisp_Fogi, __glXDispSwap_Fogi},
+    /* [ 83] =    83 */ {__glXDisp_Fogiv, __glXDispSwap_Fogiv},
+    /* [ 84] =    84 */ {__glXDisp_FrontFace, __glXDispSwap_FrontFace},
+    /* [ 85] =    85 */ {__glXDisp_Hint, __glXDispSwap_Hint},
+    /* [ 86] =    86 */ {__glXDisp_Lightf, __glXDispSwap_Lightf},
+    /* [ 87] =    87 */ {__glXDisp_Lightfv, __glXDispSwap_Lightfv},
+    /* [ 88] =    88 */ {__glXDisp_Lighti, __glXDispSwap_Lighti},
+    /* [ 89] =    89 */ {__glXDisp_Lightiv, __glXDispSwap_Lightiv},
+    /* [ 90] =    90 */ {__glXDisp_LightModelf, __glXDispSwap_LightModelf},
+    /* [ 91] =    91 */ {__glXDisp_LightModelfv, __glXDispSwap_LightModelfv},
+    /* [ 92] =    92 */ {__glXDisp_LightModeli, __glXDispSwap_LightModeli},
+    /* [ 93] =    93 */ {__glXDisp_LightModeliv, __glXDispSwap_LightModeliv},
+    /* [ 94] =    94 */ {__glXDisp_LineStipple, __glXDispSwap_LineStipple},
+    /* [ 95] =    95 */ {__glXDisp_LineWidth, __glXDispSwap_LineWidth},
+    /* [ 96] =    96 */ {__glXDisp_Materialf, __glXDispSwap_Materialf},
+    /* [ 97] =    97 */ {__glXDisp_Materialfv, __glXDispSwap_Materialfv},
+    /* [ 98] =    98 */ {__glXDisp_Materiali, __glXDispSwap_Materiali},
+    /* [ 99] =    99 */ {__glXDisp_Materialiv, __glXDispSwap_Materialiv},
+    /* [ 100] =   100 */ {__glXDisp_PointSize, __glXDispSwap_PointSize},
+    /* [ 101] =   101 */ {__glXDisp_PolygonMode, __glXDispSwap_PolygonMode},
+    /* [ 102] =   102 */ {__glXDisp_PolygonStipple, __glXDispSwap_PolygonStipple},
+    /* [ 103] =   103 */ {__glXDisp_Scissor, __glXDispSwap_Scissor},
+    /* [ 104] =   104 */ {__glXDisp_ShadeModel, __glXDispSwap_ShadeModel},
+    /* [ 105] =   105 */ {__glXDisp_TexParameterf, __glXDispSwap_TexParameterf},
+    /* [ 106] =   106 */ {__glXDisp_TexParameterfv, __glXDispSwap_TexParameterfv},
+    /* [ 107] =   107 */ {__glXDisp_TexParameteri, __glXDispSwap_TexParameteri},
+    /* [ 108] =   108 */ {__glXDisp_TexParameteriv, __glXDispSwap_TexParameteriv},
+    /* [ 109] =   109 */ {__glXDisp_TexImage1D, __glXDispSwap_TexImage1D},
+    /* [ 110] =   110 */ {__glXDisp_TexImage2D, __glXDispSwap_TexImage2D},
+    /* [ 111] =   111 */ {__glXDisp_TexEnvf, __glXDispSwap_TexEnvf},
+    /* [ 112] =   112 */ {__glXDisp_TexEnvfv, __glXDispSwap_TexEnvfv},
+    /* [ 113] =   113 */ {__glXDisp_TexEnvi, __glXDispSwap_TexEnvi},
+    /* [ 114] =   114 */ {__glXDisp_TexEnviv, __glXDispSwap_TexEnviv},
+    /* [ 115] =   115 */ {__glXDisp_TexGend, __glXDispSwap_TexGend},
+    /* [ 116] =   116 */ {__glXDisp_TexGendv, __glXDispSwap_TexGendv},
+    /* [ 117] =   117 */ {__glXDisp_TexGenf, __glXDispSwap_TexGenf},
+    /* [ 118] =   118 */ {__glXDisp_TexGenfv, __glXDispSwap_TexGenfv},
+    /* [ 119] =   119 */ {__glXDisp_TexGeni, __glXDispSwap_TexGeni},
+    /* [ 120] =   120 */ {__glXDisp_TexGeniv, __glXDispSwap_TexGeniv},
+    /* [ 121] =   121 */ {__glXDisp_InitNames, __glXDispSwap_InitNames},
+    /* [ 122] =   122 */ {__glXDisp_LoadName, __glXDispSwap_LoadName},
+    /* [ 123] =   123 */ {__glXDisp_PassThrough, __glXDispSwap_PassThrough},
+    /* [ 124] =   124 */ {__glXDisp_PopName, __glXDispSwap_PopName},
+    /* [ 125] =   125 */ {__glXDisp_PushName, __glXDispSwap_PushName},
+    /* [ 126] =   126 */ {__glXDisp_DrawBuffer, __glXDispSwap_DrawBuffer},
+    /* [ 127] =   127 */ {__glXDisp_Clear, __glXDispSwap_Clear},
+    /* [ 128] =   128 */ {__glXDisp_ClearAccum, __glXDispSwap_ClearAccum},
+    /* [ 129] =   129 */ {__glXDisp_ClearIndex, __glXDispSwap_ClearIndex},
+    /* [ 130] =   130 */ {__glXDisp_ClearColor, __glXDispSwap_ClearColor},
+    /* [ 131] =   131 */ {__glXDisp_ClearStencil, __glXDispSwap_ClearStencil},
+    /* [ 132] =   132 */ {__glXDisp_ClearDepth, __glXDispSwap_ClearDepth},
+    /* [ 133] =   133 */ {__glXDisp_StencilMask, __glXDispSwap_StencilMask},
+    /* [ 134] =   134 */ {__glXDisp_ColorMask, __glXDispSwap_ColorMask},
+    /* [ 135] =   135 */ {__glXDisp_DepthMask, __glXDispSwap_DepthMask},
+    /* [ 136] =   136 */ {__glXDisp_IndexMask, __glXDispSwap_IndexMask},
+    /* [ 137] =   137 */ {__glXDisp_Accum, __glXDispSwap_Accum},
+    /* [ 138] =   138 */ {__glXDisp_Disable, __glXDispSwap_Disable},
+    /* [ 139] =   139 */ {__glXDisp_Enable, __glXDispSwap_Enable},
+    /* [ 140] =   140 */ {NULL, NULL},
+    /* [ 141] =   141 */ {__glXDisp_PopAttrib, __glXDispSwap_PopAttrib},
+    /* [ 142] =   142 */ {__glXDisp_PushAttrib, __glXDispSwap_PushAttrib},
+    /* [ 143] =   143 */ {__glXDisp_Map1d, __glXDispSwap_Map1d},
+    /* [ 144] =   144 */ {__glXDisp_Map1f, __glXDispSwap_Map1f},
+    /* [ 145] =   145 */ {__glXDisp_Map2d, __glXDispSwap_Map2d},
+    /* [ 146] =   146 */ {__glXDisp_Map2f, __glXDispSwap_Map2f},
+    /* [ 147] =   147 */ {__glXDisp_MapGrid1d, __glXDispSwap_MapGrid1d},
+    /* [ 148] =   148 */ {__glXDisp_MapGrid1f, __glXDispSwap_MapGrid1f},
+    /* [ 149] =   149 */ {__glXDisp_MapGrid2d, __glXDispSwap_MapGrid2d},
+    /* [ 150] =   150 */ {__glXDisp_MapGrid2f, __glXDispSwap_MapGrid2f},
+    /* [ 151] =   151 */ {__glXDisp_EvalCoord1dv, __glXDispSwap_EvalCoord1dv},
+    /* [ 152] =   152 */ {__glXDisp_EvalCoord1fv, __glXDispSwap_EvalCoord1fv},
+    /* [ 153] =   153 */ {__glXDisp_EvalCoord2dv, __glXDispSwap_EvalCoord2dv},
+    /* [ 154] =   154 */ {__glXDisp_EvalCoord2fv, __glXDispSwap_EvalCoord2fv},
+    /* [ 155] =   155 */ {__glXDisp_EvalMesh1, __glXDispSwap_EvalMesh1},
+    /* [ 156] =   156 */ {__glXDisp_EvalPoint1, __glXDispSwap_EvalPoint1},
+    /* [ 157] =   157 */ {__glXDisp_EvalMesh2, __glXDispSwap_EvalMesh2},
+    /* [ 158] =   158 */ {__glXDisp_EvalPoint2, __glXDispSwap_EvalPoint2},
+    /* [ 159] =   159 */ {__glXDisp_AlphaFunc, __glXDispSwap_AlphaFunc},
+    /* [ 160] =   160 */ {__glXDisp_BlendFunc, __glXDispSwap_BlendFunc},
+    /* [ 161] =   161 */ {__glXDisp_LogicOp, __glXDispSwap_LogicOp},
+    /* [ 162] =   162 */ {__glXDisp_StencilFunc, __glXDispSwap_StencilFunc},
+    /* [ 163] =   163 */ {__glXDisp_StencilOp, __glXDispSwap_StencilOp},
+    /* [ 164] =   164 */ {__glXDisp_DepthFunc, __glXDispSwap_DepthFunc},
+    /* [ 165] =   165 */ {__glXDisp_PixelZoom, __glXDispSwap_PixelZoom},
+    /* [ 166] =   166 */ {__glXDisp_PixelTransferf, __glXDispSwap_PixelTransferf},
+    /* [ 167] =   167 */ {__glXDisp_PixelTransferi, __glXDispSwap_PixelTransferi},
+    /* [ 168] =   168 */ {__glXDisp_PixelMapfv, __glXDispSwap_PixelMapfv},
+    /* [ 169] =   169 */ {__glXDisp_PixelMapuiv, __glXDispSwap_PixelMapuiv},
+    /* [ 170] =   170 */ {__glXDisp_PixelMapusv, __glXDispSwap_PixelMapusv},
+    /* [ 171] =   171 */ {__glXDisp_ReadBuffer, __glXDispSwap_ReadBuffer},
+    /* [ 172] =   172 */ {__glXDisp_CopyPixels, __glXDispSwap_CopyPixels},
+    /* [ 173] =   173 */ {__glXDisp_DrawPixels, __glXDispSwap_DrawPixels},
+    /* [ 174] =   174 */ {__glXDisp_DepthRange, __glXDispSwap_DepthRange},
+    /* [ 175] =   175 */ {__glXDisp_Frustum, __glXDispSwap_Frustum},
+    /* [ 176] =   176 */ {__glXDisp_LoadIdentity, __glXDispSwap_LoadIdentity},
+    /* [ 177] =   177 */ {__glXDisp_LoadMatrixf, __glXDispSwap_LoadMatrixf},
+    /* [ 178] =   178 */ {__glXDisp_LoadMatrixd, __glXDispSwap_LoadMatrixd},
+    /* [ 179] =   179 */ {__glXDisp_MatrixMode, __glXDispSwap_MatrixMode},
+    /* [ 180] =   180 */ {__glXDisp_MultMatrixf, __glXDispSwap_MultMatrixf},
+    /* [ 181] =   181 */ {__glXDisp_MultMatrixd, __glXDispSwap_MultMatrixd},
+    /* [ 182] =   182 */ {__glXDisp_Ortho, __glXDispSwap_Ortho},
+    /* [ 183] =   183 */ {__glXDisp_PopMatrix, __glXDispSwap_PopMatrix},
+    /* [ 184] =   184 */ {__glXDisp_PushMatrix, __glXDispSwap_PushMatrix},
+    /* [ 185] =   185 */ {__glXDisp_Rotated, __glXDispSwap_Rotated},
+    /* [ 186] =   186 */ {__glXDisp_Rotatef, __glXDispSwap_Rotatef},
+    /* [ 187] =   187 */ {__glXDisp_Scaled, __glXDispSwap_Scaled},
+    /* [ 188] =   188 */ {__glXDisp_Scalef, __glXDispSwap_Scalef},
+    /* [ 189] =   189 */ {__glXDisp_Translated, __glXDispSwap_Translated},
+    /* [ 190] =   190 */ {__glXDisp_Translatef, __glXDispSwap_Translatef},
+    /* [ 191] =   191 */ {__glXDisp_Viewport, __glXDispSwap_Viewport},
+    /* [ 192] =   192 */ {__glXDisp_PolygonOffset, __glXDispSwap_PolygonOffset},
+    /* [ 193] =   193 */ {__glXDisp_DrawArrays, __glXDispSwap_DrawArrays},
+    /* [ 194] =   194 */ {__glXDisp_Indexubv, __glXDispSwap_Indexubv},
+    /* [ 195] =   195 */ {__glXDisp_ColorSubTable, __glXDispSwap_ColorSubTable},
+    /* [ 196] =   196 */ {__glXDisp_CopyColorSubTable, __glXDispSwap_CopyColorSubTable},
+    /* [ 197] =   197 */ {__glXDisp_ActiveTextureARB, __glXDispSwap_ActiveTextureARB},
+    /* [ 198] =   198 */ {__glXDisp_MultiTexCoord1dvARB, __glXDispSwap_MultiTexCoord1dvARB},
+    /* [ 199] =   199 */ {__glXDisp_MultiTexCoord1fvARB, __glXDispSwap_MultiTexCoord1fvARB},
+    /* [ 200] =   200 */ {__glXDisp_MultiTexCoord1ivARB, __glXDispSwap_MultiTexCoord1ivARB},
+    /* [ 201] =   201 */ {__glXDisp_MultiTexCoord1svARB, __glXDispSwap_MultiTexCoord1svARB},
+    /* [ 202] =   202 */ {__glXDisp_MultiTexCoord2dvARB, __glXDispSwap_MultiTexCoord2dvARB},
+    /* [ 203] =   203 */ {__glXDisp_MultiTexCoord2fvARB, __glXDispSwap_MultiTexCoord2fvARB},
+    /* [ 204] =   204 */ {__glXDisp_MultiTexCoord2ivARB, __glXDispSwap_MultiTexCoord2ivARB},
+    /* [ 205] =   205 */ {__glXDisp_MultiTexCoord2svARB, __glXDispSwap_MultiTexCoord2svARB},
+    /* [ 206] =   206 */ {__glXDisp_MultiTexCoord3dvARB, __glXDispSwap_MultiTexCoord3dvARB},
+    /* [ 207] =   207 */ {__glXDisp_MultiTexCoord3fvARB, __glXDispSwap_MultiTexCoord3fvARB},
+    /* [ 208] =   208 */ {__glXDisp_MultiTexCoord3ivARB, __glXDispSwap_MultiTexCoord3ivARB},
+    /* [ 209] =   209 */ {__glXDisp_MultiTexCoord3svARB, __glXDispSwap_MultiTexCoord3svARB},
+    /* [ 210] =   210 */ {__glXDisp_MultiTexCoord4dvARB, __glXDispSwap_MultiTexCoord4dvARB},
+    /* [ 211] =   211 */ {__glXDisp_MultiTexCoord4fvARB, __glXDispSwap_MultiTexCoord4fvARB},
+    /* [ 212] =   212 */ {__glXDisp_MultiTexCoord4ivARB, __glXDispSwap_MultiTexCoord4ivARB},
+    /* [ 213] =   213 */ {__glXDisp_MultiTexCoord4svARB, __glXDispSwap_MultiTexCoord4svARB},
+    /* [ 214] =   214 */ {__glXDisp_CompressedTexImage1DARB, __glXDispSwap_CompressedTexImage1DARB},
+    /* [ 215] =   215 */ {__glXDisp_CompressedTexImage2DARB, __glXDispSwap_CompressedTexImage2DARB},
+    /* [ 216] =   216 */ {__glXDisp_CompressedTexImage3DARB, __glXDispSwap_CompressedTexImage3DARB},
+    /* [ 217] =   217 */ {__glXDisp_CompressedTexSubImage1DARB, __glXDispSwap_CompressedTexSubImage1DARB},
+    /* [ 218] =   218 */ {__glXDisp_CompressedTexSubImage2DARB, __glXDispSwap_CompressedTexSubImage2DARB},
+    /* [ 219] =   219 */ {__glXDisp_CompressedTexSubImage3DARB, __glXDispSwap_CompressedTexSubImage3DARB},
+    /* [ 220] =   220 */ {NULL, NULL},
+    /* [ 221] =   221 */ {NULL, NULL},
+    /* [ 222] =   222 */ {NULL, NULL},
+    /* [ 223] =   223 */ {NULL, NULL},
+    /* [ 224] =   224 */ {NULL, NULL},
+    /* [ 225] =   225 */ {NULL, NULL},
+    /* [ 226] =   226 */ {NULL, NULL},
+    /* [ 227] =   227 */ {NULL, NULL},
+    /* [ 228] =   228 */ {NULL, NULL},
+    /* [ 229] =   229 */ {__glXDisp_SampleCoverageARB, __glXDispSwap_SampleCoverageARB},
+    /* [ 230] =   230 */ {__glXDisp_WindowPos3fvMESA, __glXDispSwap_WindowPos3fvMESA},
+    /* [ 231] =   231 */ {__glXDisp_BeginQueryARB, __glXDispSwap_BeginQueryARB},
+    /* [ 232] =   232 */ {__glXDisp_EndQueryARB, __glXDispSwap_EndQueryARB},
+    /* [ 233] =   233 */ {__glXDisp_DrawBuffersARB, __glXDispSwap_DrawBuffersARB},
+    /* [ 234] =   234 */ {NULL, NULL},
+    /* [ 235] =   235 */ {NULL, NULL},
+    /* [ 236] =   236 */ {NULL, NULL},
+    /* [ 237] =   237 */ {NULL, NULL},
+    /* [ 238] =   238 */ {NULL, NULL},
+    /* [ 239] =   239 */ {NULL, NULL},
+    /* [ 240] =  2048 */ {__glXDisp_SampleMaskSGIS, __glXDispSwap_SampleMaskSGIS},
+    /* [ 241] =  2049 */ {__glXDisp_SamplePatternSGIS, __glXDispSwap_SamplePatternSGIS},
+    /* [ 242] =  2050 */ {NULL, NULL},
+    /* [ 243] =  2051 */ {NULL, NULL},
+    /* [ 244] =  2052 */ {NULL, NULL},
+    /* [ 245] =  2053 */ {__glXDisp_ColorTable, __glXDispSwap_ColorTable},
+    /* [ 246] =  2054 */ {__glXDisp_ColorTableParameterfv, __glXDispSwap_ColorTableParameterfv},
+    /* [ 247] =  2055 */ {__glXDisp_ColorTableParameteriv, __glXDispSwap_ColorTableParameteriv},
+    /* [ 248] =  2056 */ {__glXDisp_CopyColorTable, __glXDispSwap_CopyColorTable},
+    /* [ 249] =  2057 */ {NULL, NULL},
+    /* [ 250] =  2058 */ {NULL, NULL},
+    /* [ 251] =  2059 */ {NULL, NULL},
+    /* [ 252] =  2060 */ {NULL, NULL},
+    /* [ 253] =  2061 */ {NULL, NULL},
+    /* [ 254] =  2062 */ {NULL, NULL},
+    /* [ 255] =  2063 */ {NULL, NULL},
+    /* [ 256] =  2064 */ {NULL, NULL},
+    /* [ 257] =  2065 */ {__glXDisp_PointParameterfEXT, __glXDispSwap_PointParameterfEXT},
+    /* [ 258] =  2066 */ {__glXDisp_PointParameterfvEXT, __glXDispSwap_PointParameterfvEXT},
+    /* [ 259] =  2067 */ {NULL, NULL},
+    /* [ 260] =  2068 */ {NULL, NULL},
+    /* [ 261] =  2069 */ {NULL, NULL},
+    /* [ 262] =  2070 */ {NULL, NULL},
+    /* [ 263] =  2071 */ {NULL, NULL},
+    /* [ 264] =  4096 */ {__glXDisp_BlendColor, __glXDispSwap_BlendColor},
+    /* [ 265] =  4097 */ {__glXDisp_BlendEquation, __glXDispSwap_BlendEquation},
+    /* [ 266] =  4098 */ {NULL, NULL},
+    /* [ 267] =  4099 */ {__glXDisp_TexSubImage1D, __glXDispSwap_TexSubImage1D},
+    /* [ 268] =  4100 */ {__glXDisp_TexSubImage2D, __glXDispSwap_TexSubImage2D},
+    /* [ 269] =  4101 */ {__glXDisp_ConvolutionFilter1D, __glXDispSwap_ConvolutionFilter1D},
+    /* [ 270] =  4102 */ {__glXDisp_ConvolutionFilter2D, __glXDispSwap_ConvolutionFilter2D},
+    /* [ 271] =  4103 */ {__glXDisp_ConvolutionParameterf, __glXDispSwap_ConvolutionParameterf},
+    /* [ 272] =  4104 */ {__glXDisp_ConvolutionParameterfv, __glXDispSwap_ConvolutionParameterfv},
+    /* [ 273] =  4105 */ {__glXDisp_ConvolutionParameteri, __glXDispSwap_ConvolutionParameteri},
+    /* [ 274] =  4106 */ {__glXDisp_ConvolutionParameteriv, __glXDispSwap_ConvolutionParameteriv},
+    /* [ 275] =  4107 */ {__glXDisp_CopyConvolutionFilter1D, __glXDispSwap_CopyConvolutionFilter1D},
+    /* [ 276] =  4108 */ {__glXDisp_CopyConvolutionFilter2D, __glXDispSwap_CopyConvolutionFilter2D},
+    /* [ 277] =  4109 */ {__glXDisp_SeparableFilter2D, __glXDispSwap_SeparableFilter2D},
+    /* [ 278] =  4110 */ {__glXDisp_Histogram, __glXDispSwap_Histogram},
+    /* [ 279] =  4111 */ {__glXDisp_Minmax, __glXDispSwap_Minmax},
+    /* [ 280] =  4112 */ {__glXDisp_ResetHistogram, __glXDispSwap_ResetHistogram},
+    /* [ 281] =  4113 */ {__glXDisp_ResetMinmax, __glXDispSwap_ResetMinmax},
+    /* [ 282] =  4114 */ {__glXDisp_TexImage3D, __glXDispSwap_TexImage3D},
+    /* [ 283] =  4115 */ {__glXDisp_TexSubImage3D, __glXDispSwap_TexSubImage3D},
+    /* [ 284] =  4116 */ {NULL, NULL},
+    /* [ 285] =  4117 */ {__glXDisp_BindTexture, __glXDispSwap_BindTexture},
+    /* [ 286] =  4118 */ {__glXDisp_PrioritizeTextures, __glXDispSwap_PrioritizeTextures},
+    /* [ 287] =  4119 */ {__glXDisp_CopyTexImage1D, __glXDispSwap_CopyTexImage1D},
+    /* [ 288] =  4120 */ {__glXDisp_CopyTexImage2D, __glXDispSwap_CopyTexImage2D},
+    /* [ 289] =  4121 */ {__glXDisp_CopyTexSubImage1D, __glXDispSwap_CopyTexSubImage1D},
+    /* [ 290] =  4122 */ {__glXDisp_CopyTexSubImage2D, __glXDispSwap_CopyTexSubImage2D},
+    /* [ 291] =  4123 */ {__glXDisp_CopyTexSubImage3D, __glXDispSwap_CopyTexSubImage3D},
+    /* [ 292] =  4124 */ {__glXDisp_FogCoordfvEXT, __glXDispSwap_FogCoordfvEXT},
+    /* [ 293] =  4125 */ {__glXDisp_FogCoorddvEXT, __glXDispSwap_FogCoorddvEXT},
+    /* [ 294] =  4126 */ {__glXDisp_SecondaryColor3bvEXT, __glXDispSwap_SecondaryColor3bvEXT},
+    /* [ 295] =  4127 */ {__glXDisp_SecondaryColor3svEXT, __glXDispSwap_SecondaryColor3svEXT},
+    /* [ 296] =  4176 */ {NULL, NULL},
+    /* [ 297] =  4177 */ {NULL, NULL},
+    /* [ 298] =  4178 */ {NULL, NULL},
+    /* [ 299] =  4179 */ {NULL, NULL},
+    /* [ 300] =  4180 */ {__glXDisp_BindProgramNV, __glXDispSwap_BindProgramNV},
+    /* [ 301] =  4181 */ {__glXDisp_ExecuteProgramNV, __glXDispSwap_ExecuteProgramNV},
+    /* [ 302] =  4182 */ {__glXDisp_RequestResidentProgramsNV, __glXDispSwap_RequestResidentProgramsNV},
+    /* [ 303] =  4183 */ {__glXDisp_LoadProgramNV, __glXDispSwap_LoadProgramNV},
+    /* [ 304] =  4184 */ {__glXDisp_ProgramEnvParameter4fvARB, __glXDispSwap_ProgramEnvParameter4fvARB},
+    /* [ 305] =  4185 */ {__glXDisp_ProgramEnvParameter4dvARB, __glXDispSwap_ProgramEnvParameter4dvARB},
+    /* [ 306] =  4186 */ {__glXDisp_ProgramParameters4fvNV, __glXDispSwap_ProgramParameters4fvNV},
+    /* [ 307] =  4187 */ {__glXDisp_ProgramParameters4dvNV, __glXDispSwap_ProgramParameters4dvNV},
+    /* [ 308] =  4188 */ {__glXDisp_TrackMatrixNV, __glXDispSwap_TrackMatrixNV},
+    /* [ 309] =  4189 */ {__glXDisp_VertexAttrib1svARB, __glXDispSwap_VertexAttrib1svARB},
+    /* [ 310] =  4190 */ {__glXDisp_VertexAttrib2svARB, __glXDispSwap_VertexAttrib2svARB},
+    /* [ 311] =  4191 */ {__glXDisp_VertexAttrib3svARB, __glXDispSwap_VertexAttrib3svARB},
+    /* [ 312] =  4192 */ {__glXDisp_VertexAttrib4svARB, __glXDispSwap_VertexAttrib4svARB},
+    /* [ 313] =  4193 */ {__glXDisp_VertexAttrib1fvARB, __glXDispSwap_VertexAttrib1fvARB},
+    /* [ 314] =  4194 */ {__glXDisp_VertexAttrib2fvARB, __glXDispSwap_VertexAttrib2fvARB},
+    /* [ 315] =  4195 */ {__glXDisp_VertexAttrib3fvARB, __glXDispSwap_VertexAttrib3fvARB},
+    /* [ 316] =  4196 */ {__glXDisp_VertexAttrib4fvARB, __glXDispSwap_VertexAttrib4fvARB},
+    /* [ 317] =  4197 */ {__glXDisp_VertexAttrib1dvARB, __glXDispSwap_VertexAttrib1dvARB},
+    /* [ 318] =  4198 */ {__glXDisp_VertexAttrib2dvARB, __glXDispSwap_VertexAttrib2dvARB},
+    /* [ 319] =  4199 */ {__glXDisp_VertexAttrib3dvARB, __glXDispSwap_VertexAttrib3dvARB},
+    /* [ 320] =  4200 */ {__glXDisp_VertexAttrib4dvARB, __glXDispSwap_VertexAttrib4dvARB},
+    /* [ 321] =  4201 */ {__glXDisp_VertexAttrib4NubvARB, __glXDispSwap_VertexAttrib4NubvARB},
+    /* [ 322] =  4202 */ {__glXDisp_VertexAttribs1svNV, __glXDispSwap_VertexAttribs1svNV},
+    /* [ 323] =  4203 */ {__glXDisp_VertexAttribs2svNV, __glXDispSwap_VertexAttribs2svNV},
+    /* [ 324] =  4204 */ {__glXDisp_VertexAttribs3svNV, __glXDispSwap_VertexAttribs3svNV},
+    /* [ 325] =  4205 */ {__glXDisp_VertexAttribs4svNV, __glXDispSwap_VertexAttribs4svNV},
+    /* [ 326] =  4206 */ {__glXDisp_VertexAttribs1fvNV, __glXDispSwap_VertexAttribs1fvNV},
+    /* [ 327] =  4207 */ {__glXDisp_VertexAttribs2fvNV, __glXDispSwap_VertexAttribs2fvNV},
+    /* [ 328] =  4208 */ {__glXDisp_VertexAttribs3fvNV, __glXDispSwap_VertexAttribs3fvNV},
+    /* [ 329] =  4209 */ {__glXDisp_VertexAttribs4fvNV, __glXDispSwap_VertexAttribs4fvNV},
+    /* [ 330] =  4210 */ {__glXDisp_VertexAttribs1dvNV, __glXDispSwap_VertexAttribs1dvNV},
+    /* [ 331] =  4211 */ {__glXDisp_VertexAttribs2dvNV, __glXDispSwap_VertexAttribs2dvNV},
+    /* [ 332] =  4212 */ {__glXDisp_VertexAttribs3dvNV, __glXDispSwap_VertexAttribs3dvNV},
+    /* [ 333] =  4213 */ {__glXDisp_VertexAttribs4dvNV, __glXDispSwap_VertexAttribs4dvNV},
+    /* [ 334] =  4214 */ {__glXDisp_VertexAttribs4ubvNV, __glXDispSwap_VertexAttribs4ubvNV},
+    /* [ 335] =  4215 */ {__glXDisp_ProgramLocalParameter4fvARB, __glXDispSwap_ProgramLocalParameter4fvARB},
+    /* [ 336] =  4216 */ {__glXDisp_ProgramLocalParameter4dvARB, __glXDispSwap_ProgramLocalParameter4dvARB},
+    /* [ 337] =  4217 */ {__glXDisp_ProgramStringARB, __glXDispSwap_ProgramStringARB},
+    /* [ 338] =  4218 */ {__glXDisp_ProgramNamedParameter4fvNV, __glXDispSwap_ProgramNamedParameter4fvNV},
+    /* [ 339] =  4219 */ {__glXDisp_ProgramNamedParameter4dvNV, __glXDispSwap_ProgramNamedParameter4dvNV},
+    /* [ 340] =  4220 */ {__glXDisp_ActiveStencilFaceEXT, __glXDispSwap_ActiveStencilFaceEXT},
+    /* [ 341] =  4221 */ {__glXDisp_PointParameteriNV, __glXDispSwap_PointParameteriNV},
+    /* [ 342] =  4222 */ {__glXDisp_PointParameterivNV, __glXDispSwap_PointParameterivNV},
+    /* [ 343] =  4223 */ {NULL, NULL},
+    /* [ 344] =  4224 */ {NULL, NULL},
+    /* [ 345] =  4225 */ {NULL, NULL},
+    /* [ 346] =  4226 */ {NULL, NULL},
+    /* [ 347] =  4227 */ {NULL, NULL},
+    /* [ 348] =  4228 */ {__glXDisp_BlendEquationSeparateEXT, __glXDispSwap_BlendEquationSeparateEXT},
+    /* [ 349] =  4229 */ {NULL, NULL},
+    /* [ 350] =  4230 */ {__glXDisp_VertexAttrib4bvARB, __glXDispSwap_VertexAttrib4bvARB},
+    /* [ 351] =  4231 */ {__glXDisp_VertexAttrib4ivARB, __glXDispSwap_VertexAttrib4ivARB},
+    /* [ 352] =  4232 */ {__glXDisp_VertexAttrib4ubvARB, __glXDispSwap_VertexAttrib4ubvARB},
+    /* [ 353] =  4233 */ {__glXDisp_VertexAttrib4usvARB, __glXDispSwap_VertexAttrib4usvARB},
+    /* [ 354] =  4234 */ {__glXDisp_VertexAttrib4uivARB, __glXDispSwap_VertexAttrib4uivARB},
+    /* [ 355] =  4235 */ {__glXDisp_VertexAttrib4NbvARB, __glXDispSwap_VertexAttrib4NbvARB},
+    /* [ 356] =  4236 */ {__glXDisp_VertexAttrib4NsvARB, __glXDispSwap_VertexAttrib4NsvARB},
+    /* [ 357] =  4237 */ {__glXDisp_VertexAttrib4NivARB, __glXDispSwap_VertexAttrib4NivARB},
+    /* [ 358] =  4238 */ {__glXDisp_VertexAttrib4NusvARB, __glXDispSwap_VertexAttrib4NusvARB},
+    /* [ 359] =  4239 */ {__glXDisp_VertexAttrib4NuivARB, __glXDispSwap_VertexAttrib4NuivARB},
+    /* [ 360] =  4128 */ {__glXDisp_SecondaryColor3ivEXT, __glXDispSwap_SecondaryColor3ivEXT},
+    /* [ 361] =  4129 */ {__glXDisp_SecondaryColor3fvEXT, __glXDispSwap_SecondaryColor3fvEXT},
+    /* [ 362] =  4130 */ {__glXDisp_SecondaryColor3dvEXT, __glXDispSwap_SecondaryColor3dvEXT},
+    /* [ 363] =  4131 */ {__glXDisp_SecondaryColor3ubvEXT, __glXDispSwap_SecondaryColor3ubvEXT},
+    /* [ 364] =  4132 */ {__glXDisp_SecondaryColor3usvEXT, __glXDispSwap_SecondaryColor3usvEXT},
+    /* [ 365] =  4133 */ {__glXDisp_SecondaryColor3uivEXT, __glXDispSwap_SecondaryColor3uivEXT},
+    /* [ 366] =  4134 */ {__glXDisp_BlendFuncSeparateEXT, __glXDispSwap_BlendFuncSeparateEXT},
+    /* [ 367] =  4135 */ {NULL, NULL},
+    /* [ 368] =  4264 */ {NULL, NULL},
+    /* [ 369] =  4265 */ {__glXDisp_VertexAttrib1svNV, __glXDispSwap_VertexAttrib1svNV},
+    /* [ 370] =  4266 */ {__glXDisp_VertexAttrib2svNV, __glXDispSwap_VertexAttrib2svNV},
+    /* [ 371] =  4267 */ {__glXDisp_VertexAttrib3svNV, __glXDispSwap_VertexAttrib3svNV},
+    /* [ 372] =  4268 */ {__glXDisp_VertexAttrib4svNV, __glXDispSwap_VertexAttrib4svNV},
+    /* [ 373] =  4269 */ {__glXDisp_VertexAttrib1fvNV, __glXDispSwap_VertexAttrib1fvNV},
+    /* [ 374] =  4270 */ {__glXDisp_VertexAttrib2fvNV, __glXDispSwap_VertexAttrib2fvNV},
+    /* [ 375] =  4271 */ {__glXDisp_VertexAttrib3fvNV, __glXDispSwap_VertexAttrib3fvNV},
+    /* [ 376] =  4272 */ {__glXDisp_VertexAttrib4fvNV, __glXDispSwap_VertexAttrib4fvNV},
+    /* [ 377] =  4273 */ {__glXDisp_VertexAttrib1dvNV, __glXDispSwap_VertexAttrib1dvNV},
+    /* [ 378] =  4274 */ {__glXDisp_VertexAttrib2dvNV, __glXDispSwap_VertexAttrib2dvNV},
+    /* [ 379] =  4275 */ {__glXDisp_VertexAttrib3dvNV, __glXDispSwap_VertexAttrib3dvNV},
+    /* [ 380] =  4276 */ {__glXDisp_VertexAttrib4dvNV, __glXDispSwap_VertexAttrib4dvNV},
+    /* [ 381] =  4277 */ {__glXDisp_VertexAttrib4ubvNV, __glXDispSwap_VertexAttrib4ubvNV},
+    /* [ 382] =  4278 */ {NULL, NULL},
+    /* [ 383] =  4279 */ {NULL, NULL},
+    /* [ 384] =  4312 */ {NULL, NULL},
+    /* [ 385] =  4313 */ {NULL, NULL},
+    /* [ 386] =  4314 */ {NULL, NULL},
+    /* [ 387] =  4315 */ {NULL, NULL},
+    /* [ 388] =  4316 */ {__glXDisp_BindRenderbufferEXT, __glXDispSwap_BindRenderbufferEXT},
+    /* [ 389] =  4317 */ {__glXDisp_DeleteRenderbuffersEXT, __glXDispSwap_DeleteRenderbuffersEXT},
+    /* [ 390] =  4318 */ {__glXDisp_RenderbufferStorageEXT, __glXDispSwap_RenderbufferStorageEXT},
+    /* [ 391] =  4319 */ {__glXDisp_BindFramebufferEXT, __glXDispSwap_BindFramebufferEXT},
+    /* [ 392] =  4320 */ {__glXDisp_DeleteFramebuffersEXT, __glXDispSwap_DeleteFramebuffersEXT},
+    /* [ 393] =  4321 */ {__glXDisp_FramebufferTexture1DEXT, __glXDispSwap_FramebufferTexture1DEXT},
+    /* [ 394] =  4322 */ {__glXDisp_FramebufferTexture2DEXT, __glXDispSwap_FramebufferTexture2DEXT},
+    /* [ 395] =  4323 */ {__glXDisp_FramebufferTexture3DEXT, __glXDispSwap_FramebufferTexture3DEXT},
+    /* [ 396] =  4324 */ {__glXDisp_FramebufferRenderbufferEXT, __glXDispSwap_FramebufferRenderbufferEXT},
+    /* [ 397] =  4325 */ {__glXDisp_GenerateMipmapEXT, __glXDispSwap_GenerateMipmapEXT},
+    /* [ 398] =  4326 */ {NULL, NULL},
+    /* [ 399] =  4327 */ {NULL, NULL},
+};
+
+static const int_fast16_t Render_size_table[400][2] = {
+    /* [  0] =     0 */ {  0, ~0},
+    /* [  1] =     1 */ {  8, ~0},
+    /* [  2] =     2 */ { 12,  0},
+    /* [  3] =     3 */ {  8, ~0},
+    /* [  4] =     4 */ {  8, ~0},
+    /* [  5] =     5 */ { 48,  1},
+    /* [  6] =     6 */ {  8, ~0},
+    /* [  7] =     7 */ { 28, ~0},
+    /* [  8] =     8 */ { 16, ~0},
+    /* [  9] =     9 */ { 16, ~0},
+    /* [ 10] =    10 */ { 12, ~0},
+    /* [ 11] =    11 */ {  8, ~0},
+    /* [ 12] =    12 */ { 16, ~0},
+    /* [ 13] =    13 */ { 12, ~0},
+    /* [ 14] =    14 */ {  8, ~0},
+    /* [ 15] =    15 */ { 36, ~0},
+    /* [ 16] =    16 */ { 20, ~0},
+    /* [ 17] =    17 */ { 20, ~0},
+    /* [ 18] =    18 */ { 12, ~0},
+    /* [ 19] =    19 */ {  8, ~0},
+    /* [ 20] =    20 */ { 20, ~0},
+    /* [ 21] =    21 */ { 12, ~0},
+    /* [ 22] =    22 */ {  8, ~0},
+    /* [ 23] =    23 */ {  4, ~0},
+    /* [ 24] =    24 */ { 12, ~0},
+    /* [ 25] =    25 */ {  8, ~0},
+    /* [ 26] =    26 */ {  8, ~0},
+    /* [ 27] =    27 */ {  8, ~0},
+    /* [ 28] =    28 */ {  8, ~0},
+    /* [ 29] =    29 */ { 28, ~0},
+    /* [ 30] =    30 */ { 16, ~0},
+    /* [ 31] =    31 */ { 16, ~0},
+    /* [ 32] =    32 */ { 12, ~0},
+    /* [ 33] =    33 */ { 20, ~0},
+    /* [ 34] =    34 */ { 12, ~0},
+    /* [ 35] =    35 */ { 12, ~0},
+    /* [ 36] =    36 */ {  8, ~0},
+    /* [ 37] =    37 */ { 28, ~0},
+    /* [ 38] =    38 */ { 16, ~0},
+    /* [ 39] =    39 */ { 16, ~0},
+    /* [ 40] =    40 */ { 12, ~0},
+    /* [ 41] =    41 */ { 36, ~0},
+    /* [ 42] =    42 */ { 20, ~0},
+    /* [ 43] =    43 */ { 20, ~0},
+    /* [ 44] =    44 */ { 12, ~0},
+    /* [ 45] =    45 */ { 36, ~0},
+    /* [ 46] =    46 */ { 20, ~0},
+    /* [ 47] =    47 */ { 20, ~0},
+    /* [ 48] =    48 */ { 12, ~0},
+    /* [ 49] =    49 */ { 12, ~0},
+    /* [ 50] =    50 */ {  8, ~0},
+    /* [ 51] =    51 */ {  8, ~0},
+    /* [ 52] =    52 */ {  8, ~0},
+    /* [ 53] =    53 */ { 20, ~0},
+    /* [ 54] =    54 */ { 12, ~0},
+    /* [ 55] =    55 */ { 12, ~0},
+    /* [ 56] =    56 */ {  8, ~0},
+    /* [ 57] =    57 */ { 28, ~0},
+    /* [ 58] =    58 */ { 16, ~0},
+    /* [ 59] =    59 */ { 16, ~0},
+    /* [ 60] =    60 */ { 12, ~0},
+    /* [ 61] =    61 */ { 36, ~0},
+    /* [ 62] =    62 */ { 20, ~0},
+    /* [ 63] =    63 */ { 20, ~0},
+    /* [ 64] =    64 */ { 12, ~0},
+    /* [ 65] =    65 */ { 20, ~0},
+    /* [ 66] =    66 */ { 12, ~0},
+    /* [ 67] =    67 */ { 12, ~0},
+    /* [ 68] =    68 */ {  8, ~0},
+    /* [ 69] =    69 */ { 28, ~0},
+    /* [ 70] =    70 */ { 16, ~0},
+    /* [ 71] =    71 */ { 16, ~0},
+    /* [ 72] =    72 */ { 12, ~0},
+    /* [ 73] =    73 */ { 36, ~0},
+    /* [ 74] =    74 */ { 20, ~0},
+    /* [ 75] =    75 */ { 20, ~0},
+    /* [ 76] =    76 */ { 12, ~0},
+    /* [ 77] =    77 */ { 40, ~0},
+    /* [ 78] =    78 */ { 12, ~0},
+    /* [ 79] =    79 */ {  8, ~0},
+    /* [ 80] =    80 */ { 12, ~0},
+    /* [ 81] =    81 */ {  8,  2},
+    /* [ 82] =    82 */ { 12, ~0},
+    /* [ 83] =    83 */ {  8,  3},
+    /* [ 84] =    84 */ {  8, ~0},
+    /* [ 85] =    85 */ { 12, ~0},
+    /* [ 86] =    86 */ { 16, ~0},
+    /* [ 87] =    87 */ { 12,  4},
+    /* [ 88] =    88 */ { 16, ~0},
+    /* [ 89] =    89 */ { 12,  5},
+    /* [ 90] =    90 */ { 12, ~0},
+    /* [ 91] =    91 */ {  8,  6},
+    /* [ 92] =    92 */ { 12, ~0},
+    /* [ 93] =    93 */ {  8,  7},
+    /* [ 94] =    94 */ { 12, ~0},
+    /* [ 95] =    95 */ {  8, ~0},
+    /* [ 96] =    96 */ { 16, ~0},
+    /* [ 97] =    97 */ { 12,  8},
+    /* [ 98] =    98 */ { 16, ~0},
+    /* [ 99] =    99 */ { 12,  9},
+    /* [100] =   100 */ {  8, ~0},
+    /* [101] =   101 */ { 12, ~0},
+    /* [102] =   102 */ { 24, 10},
+    /* [103] =   103 */ { 20, ~0},
+    /* [104] =   104 */ {  8, ~0},
+    /* [105] =   105 */ { 16, ~0},
+    /* [106] =   106 */ { 12, 11},
+    /* [107] =   107 */ { 16, ~0},
+    /* [108] =   108 */ { 12, 12},
+    /* [109] =   109 */ { 56, 13},
+    /* [110] =   110 */ { 56, 14},
+    /* [111] =   111 */ { 16, ~0},
+    /* [112] =   112 */ { 12, 15},
+    /* [113] =   113 */ { 16, ~0},
+    /* [114] =   114 */ { 12, 16},
+    /* [115] =   115 */ { 20, ~0},
+    /* [116] =   116 */ { 12, 17},
+    /* [117] =   117 */ { 16, ~0},
+    /* [118] =   118 */ { 12, 18},
+    /* [119] =   119 */ { 16, ~0},
+    /* [120] =   120 */ { 12, 19},
+    /* [121] =   121 */ {  4, ~0},
+    /* [122] =   122 */ {  8, ~0},
+    /* [123] =   123 */ {  8, ~0},
+    /* [124] =   124 */ {  4, ~0},
+    /* [125] =   125 */ {  8, ~0},
+    /* [126] =   126 */ {  8, ~0},
+    /* [127] =   127 */ {  8, ~0},
+    /* [128] =   128 */ { 20, ~0},
+    /* [129] =   129 */ {  8, ~0},
+    /* [130] =   130 */ { 20, ~0},
+    /* [131] =   131 */ {  8, ~0},
+    /* [132] =   132 */ { 12, ~0},
+    /* [133] =   133 */ {  8, ~0},
+    /* [134] =   134 */ {  8, ~0},
+    /* [135] =   135 */ {  8, ~0},
+    /* [136] =   136 */ {  8, ~0},
+    /* [137] =   137 */ { 12, ~0},
+    /* [138] =   138 */ {  8, ~0},
+    /* [139] =   139 */ {  8, ~0},
+    /* [140] =   140 */ {  0, ~0},
+    /* [141] =   141 */ {  4, ~0},
+    /* [142] =   142 */ {  8, ~0},
+    /* [143] =   143 */ { 28, 20},
+    /* [144] =   144 */ { 20, 21},
+    /* [145] =   145 */ { 48, 22},
+    /* [146] =   146 */ { 32, 23},
+    /* [147] =   147 */ { 24, ~0},
+    /* [148] =   148 */ { 16, ~0},
+    /* [149] =   149 */ { 44, ~0},
+    /* [150] =   150 */ { 28, ~0},
+    /* [151] =   151 */ { 12, ~0},
+    /* [152] =   152 */ {  8, ~0},
+    /* [153] =   153 */ { 20, ~0},
+    /* [154] =   154 */ { 12, ~0},
+    /* [155] =   155 */ { 16, ~0},
+    /* [156] =   156 */ {  8, ~0},
+    /* [157] =   157 */ { 24, ~0},
+    /* [158] =   158 */ { 12, ~0},
+    /* [159] =   159 */ { 12, ~0},
+    /* [160] =   160 */ { 12, ~0},
+    /* [161] =   161 */ {  8, ~0},
+    /* [162] =   162 */ { 16, ~0},
+    /* [163] =   163 */ { 16, ~0},
+    /* [164] =   164 */ {  8, ~0},
+    /* [165] =   165 */ { 12, ~0},
+    /* [166] =   166 */ { 12, ~0},
+    /* [167] =   167 */ { 12, ~0},
+    /* [168] =   168 */ { 12, 24},
+    /* [169] =   169 */ { 12, 25},
+    /* [170] =   170 */ { 12, 26},
+    /* [171] =   171 */ {  8, ~0},
+    /* [172] =   172 */ { 24, ~0},
+    /* [173] =   173 */ { 40, 27},
+    /* [174] =   174 */ { 20, ~0},
+    /* [175] =   175 */ { 52, ~0},
+    /* [176] =   176 */ {  4, ~0},
+    /* [177] =   177 */ { 68, ~0},
+    /* [178] =   178 */ {132, ~0},
+    /* [179] =   179 */ {  8, ~0},
+    /* [180] =   180 */ { 68, ~0},
+    /* [181] =   181 */ {132, ~0},
+    /* [182] =   182 */ { 52, ~0},
+    /* [183] =   183 */ {  4, ~0},
+    /* [184] =   184 */ {  4, ~0},
+    /* [185] =   185 */ { 36, ~0},
+    /* [186] =   186 */ { 20, ~0},
+    /* [187] =   187 */ { 28, ~0},
+    /* [188] =   188 */ { 16, ~0},
+    /* [189] =   189 */ { 28, ~0},
+    /* [190] =   190 */ { 16, ~0},
+    /* [191] =   191 */ { 20, ~0},
+    /* [192] =   192 */ { 12, ~0},
+    /* [193] =   193 */ { 16, 28},
+    /* [194] =   194 */ {  8, ~0},
+    /* [195] =   195 */ { 44, 29},
+    /* [196] =   196 */ { 24, ~0},
+    /* [197] =   197 */ {  8, ~0},
+    /* [198] =   198 */ { 16, ~0},
+    /* [199] =   199 */ { 12, ~0},
+    /* [200] =   200 */ { 12, ~0},
+    /* [201] =   201 */ { 12, ~0},
+    /* [202] =   202 */ { 24, ~0},
+    /* [203] =   203 */ { 16, ~0},
+    /* [204] =   204 */ { 16, ~0},
+    /* [205] =   205 */ { 12, ~0},
+    /* [206] =   206 */ { 32, ~0},
+    /* [207] =   207 */ { 20, ~0},
+    /* [208] =   208 */ { 20, ~0},
+    /* [209] =   209 */ { 16, ~0},
+    /* [210] =   210 */ { 40, ~0},
+    /* [211] =   211 */ { 24, ~0},
+    /* [212] =   212 */ { 24, ~0},
+    /* [213] =   213 */ { 16, ~0},
+    /* [214] =   214 */ { 28, 30},
+    /* [215] =   215 */ { 32, 31},
+    /* [216] =   216 */ { 36, 32},
+    /* [217] =   217 */ { 28, 33},
+    /* [218] =   218 */ { 36, 34},
+    /* [219] =   219 */ { 44, 35},
+    /* [220] =   220 */ {  0, ~0},
+    /* [221] =   221 */ {  0, ~0},
+    /* [222] =   222 */ {  0, ~0},
+    /* [223] =   223 */ {  0, ~0},
+    /* [224] =   224 */ {  0, ~0},
+    /* [225] =   225 */ {  0, ~0},
+    /* [226] =   226 */ {  0, ~0},
+    /* [227] =   227 */ {  0, ~0},
+    /* [228] =   228 */ {  0, ~0},
+    /* [229] =   229 */ { 12, ~0},
+    /* [230] =   230 */ { 16, ~0},
+    /* [231] =   231 */ { 12, ~0},
+    /* [232] =   232 */ {  8, ~0},
+    /* [233] =   233 */ {  8, 36},
+    /* [234] =   234 */ {  0, ~0},
+    /* [235] =   235 */ {  0, ~0},
+    /* [236] =   236 */ {  0, ~0},
+    /* [237] =   237 */ {  0, ~0},
+    /* [238] =   238 */ {  0, ~0},
+    /* [239] =   239 */ {  0, ~0},
+    /* [240] =  2048 */ { 12, ~0},
+    /* [241] =  2049 */ {  8, ~0},
+    /* [242] =  2050 */ {  0, ~0},
+    /* [243] =  2051 */ {  0, ~0},
+    /* [244] =  2052 */ {  0, ~0},
+    /* [245] =  2053 */ { 44, 37},
+    /* [246] =  2054 */ { 12, 38},
+    /* [247] =  2055 */ { 12, 39},
+    /* [248] =  2056 */ { 24, ~0},
+    /* [249] =  2057 */ {  0, ~0},
+    /* [250] =  2058 */ {  0, ~0},
+    /* [251] =  2059 */ {  0, ~0},
+    /* [252] =  2060 */ {  0, ~0},
+    /* [253] =  2061 */ {  0, ~0},
+    /* [254] =  2062 */ {  0, ~0},
+    /* [255] =  2063 */ {  0, ~0},
+    /* [256] =  2064 */ {  0, ~0},
+    /* [257] =  2065 */ { 12, ~0},
+    /* [258] =  2066 */ {  8, 40},
+    /* [259] =  2067 */ {  0, ~0},
+    /* [260] =  2068 */ {  0, ~0},
+    /* [261] =  2069 */ {  0, ~0},
+    /* [262] =  2070 */ {  0, ~0},
+    /* [263] =  2071 */ {  0, ~0},
+    /* [264] =  4096 */ { 20, ~0},
+    /* [265] =  4097 */ {  8, ~0},
+    /* [266] =  4098 */ {  0, ~0},
+    /* [267] =  4099 */ { 60, 41},
+    /* [268] =  4100 */ { 60, 42},
+    /* [269] =  4101 */ { 48, 43},
+    /* [270] =  4102 */ { 48, 44},
+    /* [271] =  4103 */ { 16, ~0},
+    /* [272] =  4104 */ { 12, 45},
+    /* [273] =  4105 */ { 16, ~0},
+    /* [274] =  4106 */ { 12, 46},
+    /* [275] =  4107 */ { 24, ~0},
+    /* [276] =  4108 */ { 28, ~0},
+    /* [277] =  4109 */ { 32, 47},
+    /* [278] =  4110 */ { 20, ~0},
+    /* [279] =  4111 */ { 16, ~0},
+    /* [280] =  4112 */ {  8, ~0},
+    /* [281] =  4113 */ {  8, ~0},
+    /* [282] =  4114 */ { 84, 48},
+    /* [283] =  4115 */ { 92, 49},
+    /* [284] =  4116 */ {  0, ~0},
+    /* [285] =  4117 */ { 12, ~0},
+    /* [286] =  4118 */ {  8, 50},
+    /* [287] =  4119 */ { 32, ~0},
+    /* [288] =  4120 */ { 36, ~0},
+    /* [289] =  4121 */ { 28, ~0},
+    /* [290] =  4122 */ { 36, ~0},
+    /* [291] =  4123 */ { 40, ~0},
+    /* [292] =  4124 */ {  8, ~0},
+    /* [293] =  4125 */ { 12, ~0},
+    /* [294] =  4126 */ {  8, ~0},
+    /* [295] =  4127 */ { 12, ~0},
+    /* [296] =  4176 */ {  0, ~0},
+    /* [297] =  4177 */ {  0, ~0},
+    /* [298] =  4178 */ {  0, ~0},
+    /* [299] =  4179 */ {  0, ~0},
+    /* [300] =  4180 */ { 12, ~0},
+    /* [301] =  4181 */ { 28, ~0},
+    /* [302] =  4182 */ {  8, 51},
+    /* [303] =  4183 */ { 16, 52},
+    /* [304] =  4184 */ { 28, ~0},
+    /* [305] =  4185 */ { 44, ~0},
+    /* [306] =  4186 */ { 16, 53},
+    /* [307] =  4187 */ { 16, 54},
+    /* [308] =  4188 */ { 20, ~0},
+    /* [309] =  4189 */ { 12, ~0},
+    /* [310] =  4190 */ { 12, ~0},
+    /* [311] =  4191 */ { 16, ~0},
+    /* [312] =  4192 */ { 16, ~0},
+    /* [313] =  4193 */ { 12, ~0},
+    /* [314] =  4194 */ { 16, ~0},
+    /* [315] =  4195 */ { 20, ~0},
+    /* [316] =  4196 */ { 24, ~0},
+    /* [317] =  4197 */ { 16, ~0},
+    /* [318] =  4198 */ { 24, ~0},
+    /* [319] =  4199 */ { 32, ~0},
+    /* [320] =  4200 */ { 40, ~0},
+    /* [321] =  4201 */ { 12, ~0},
+    /* [322] =  4202 */ { 12, 55},
+    /* [323] =  4203 */ { 12, 56},
+    /* [324] =  4204 */ { 12, 57},
+    /* [325] =  4205 */ { 12, 58},
+    /* [326] =  4206 */ { 12, 59},
+    /* [327] =  4207 */ { 12, 60},
+    /* [328] =  4208 */ { 12, 61},
+    /* [329] =  4209 */ { 12, 62},
+    /* [330] =  4210 */ { 12, 63},
+    /* [331] =  4211 */ { 12, 64},
+    /* [332] =  4212 */ { 12, 65},
+    /* [333] =  4213 */ { 12, 66},
+    /* [334] =  4214 */ { 12, 67},
+    /* [335] =  4215 */ { 28, ~0},
+    /* [336] =  4216 */ { 44, ~0},
+    /* [337] =  4217 */ { 16, 68},
+    /* [338] =  4218 */ { 28, 69},
+    /* [339] =  4219 */ { 44, 70},
+    /* [340] =  4220 */ {  8, ~0},
+    /* [341] =  4221 */ { 12, ~0},
+    /* [342] =  4222 */ {  8, 71},
+    /* [343] =  4223 */ {  0, ~0},
+    /* [344] =  4224 */ {  0, ~0},
+    /* [345] =  4225 */ {  0, ~0},
+    /* [346] =  4226 */ {  0, ~0},
+    /* [347] =  4227 */ {  0, ~0},
+    /* [348] =  4228 */ { 12, ~0},
+    /* [349] =  4229 */ {  0, ~0},
+    /* [350] =  4230 */ { 12, ~0},
+    /* [351] =  4231 */ { 24, ~0},
+    /* [352] =  4232 */ { 12, ~0},
+    /* [353] =  4233 */ { 16, ~0},
+    /* [354] =  4234 */ { 24, ~0},
+    /* [355] =  4235 */ { 12, ~0},
+    /* [356] =  4236 */ { 16, ~0},
+    /* [357] =  4237 */ { 24, ~0},
+    /* [358] =  4238 */ { 16, ~0},
+    /* [359] =  4239 */ { 24, ~0},
+    /* [360] =  4128 */ { 16, ~0},
+    /* [361] =  4129 */ { 16, ~0},
+    /* [362] =  4130 */ { 28, ~0},
+    /* [363] =  4131 */ {  8, ~0},
+    /* [364] =  4132 */ { 12, ~0},
+    /* [365] =  4133 */ { 16, ~0},
+    /* [366] =  4134 */ { 20, ~0},
+    /* [367] =  4135 */ {  0, ~0},
+    /* [368] =  4264 */ {  0, ~0},
+    /* [369] =  4265 */ { 12, ~0},
+    /* [370] =  4266 */ { 12, ~0},
+    /* [371] =  4267 */ { 16, ~0},
+    /* [372] =  4268 */ { 16, ~0},
+    /* [373] =  4269 */ { 12, ~0},
+    /* [374] =  4270 */ { 16, ~0},
+    /* [375] =  4271 */ { 20, ~0},
+    /* [376] =  4272 */ { 24, ~0},
+    /* [377] =  4273 */ { 16, ~0},
+    /* [378] =  4274 */ { 24, ~0},
+    /* [379] =  4275 */ { 32, ~0},
+    /* [380] =  4276 */ { 40, ~0},
+    /* [381] =  4277 */ { 12, ~0},
+    /* [382] =  4278 */ {  0, ~0},
+    /* [383] =  4279 */ {  0, ~0},
+    /* [384] =  4312 */ {  0, ~0},
+    /* [385] =  4313 */ {  0, ~0},
+    /* [386] =  4314 */ {  0, ~0},
+    /* [387] =  4315 */ {  0, ~0},
+    /* [388] =  4316 */ { 12, ~0},
+    /* [389] =  4317 */ {  8, 72},
+    /* [390] =  4318 */ { 20, ~0},
+    /* [391] =  4319 */ { 12, ~0},
+    /* [392] =  4320 */ {  8, 73},
+    /* [393] =  4321 */ { 24, ~0},
+    /* [394] =  4322 */ { 24, ~0},
+    /* [395] =  4323 */ { 28, ~0},
+    /* [396] =  4324 */ { 20, ~0},
+    /* [397] =  4325 */ {  8, ~0},
+    /* [398] =  4326 */ {  0, ~0},
+    /* [399] =  4327 */ {  0, ~0},
+};
+
+static const gl_proto_size_func Render_size_func_table[74] = {
+   __glXCallListsReqSize,
+   __glXBitmapReqSize,
+   __glXFogfvReqSize,
+   __glXFogivReqSize,
+   __glXLightfvReqSize,
+   __glXLightivReqSize,
+   __glXLightModelfvReqSize,
+   __glXLightModelivReqSize,
+   __glXMaterialfvReqSize,
+   __glXMaterialivReqSize,
+   __glXPolygonStippleReqSize,
+   __glXTexParameterfvReqSize,
+   __glXTexParameterivReqSize,
+   __glXTexImage1DReqSize,
+   __glXTexImage2DReqSize,
+   __glXTexEnvfvReqSize,
+   __glXTexEnvivReqSize,
+   __glXTexGendvReqSize,
+   __glXTexGenfvReqSize,
+   __glXTexGenivReqSize,
+   __glXMap1dReqSize,
+   __glXMap1fReqSize,
+   __glXMap2dReqSize,
+   __glXMap2fReqSize,
+   __glXPixelMapfvReqSize,
+   __glXPixelMapuivReqSize,
+   __glXPixelMapusvReqSize,
+   __glXDrawPixelsReqSize,
+   __glXDrawArraysReqSize,
+   __glXColorSubTableReqSize,
+   __glXCompressedTexImage1DARBReqSize,
+   __glXCompressedTexImage2DARBReqSize,
+   __glXCompressedTexImage3DARBReqSize,
+   __glXCompressedTexSubImage1DARBReqSize,
+   __glXCompressedTexSubImage2DARBReqSize,
+   __glXCompressedTexSubImage3DARBReqSize,
+   __glXDrawBuffersARBReqSize,
+   __glXColorTableReqSize,
+   __glXColorTableParameterfvReqSize,
+   __glXColorTableParameterivReqSize,
+   __glXPointParameterfvEXTReqSize,
+   __glXTexSubImage1DReqSize,
+   __glXTexSubImage2DReqSize,
+   __glXConvolutionFilter1DReqSize,
+   __glXConvolutionFilter2DReqSize,
+   __glXConvolutionParameterfvReqSize,
+   __glXConvolutionParameterivReqSize,
+   __glXSeparableFilter2DReqSize,
+   __glXTexImage3DReqSize,
+   __glXTexSubImage3DReqSize,
+   __glXPrioritizeTexturesReqSize,
+   __glXRequestResidentProgramsNVReqSize,
+   __glXLoadProgramNVReqSize,
+   __glXProgramParameters4fvNVReqSize,
+   __glXProgramParameters4dvNVReqSize,
+   __glXVertexAttribs1svNVReqSize,
+   __glXVertexAttribs2svNVReqSize,
+   __glXVertexAttribs3svNVReqSize,
+   __glXVertexAttribs4svNVReqSize,
+   __glXVertexAttribs1fvNVReqSize,
+   __glXVertexAttribs2fvNVReqSize,
+   __glXVertexAttribs3fvNVReqSize,
+   __glXVertexAttribs4fvNVReqSize,
+   __glXVertexAttribs1dvNVReqSize,
+   __glXVertexAttribs2dvNVReqSize,
+   __glXVertexAttribs3dvNVReqSize,
+   __glXVertexAttribs4dvNVReqSize,
+   __glXVertexAttribs4ubvNVReqSize,
+   __glXProgramStringARBReqSize,
+   __glXProgramNamedParameter4fvNVReqSize,
+   __glXProgramNamedParameter4dvNVReqSize,
+   __glXPointParameterivNVReqSize,
+   __glXDeleteRenderbuffersEXTReqSize,
+   __glXDeleteFramebuffersEXTReqSize,
+};
+
+const struct __glXDispatchInfo Render_dispatch_info = {
+    13,
+    Render_dispatch_tree,
+    Render_function_table,
+    Render_size_table,
+    Render_size_func_table
+};
+
+/*****************************************************************/
+/* tree depth = 12 */
+static const int_fast16_t VendorPriv_dispatch_tree[152] = {
+    /* [0] -> opcode range [0, 131072], node depth 1 */
+    2,
+    5,
+    EMPTY_LEAF,
+    119,
+    EMPTY_LEAF,
+
+    /* [5] -> opcode range [0, 32768], node depth 2 */
+    1,
+    8,
+    EMPTY_LEAF,
+
+    /* [8] -> opcode range [0, 16384], node depth 3 */
+    1,
+    11,
+    EMPTY_LEAF,
+
+    /* [11] -> opcode range [0, 8192], node depth 4 */
+    2,
+    16,
+    EMPTY_LEAF,
+    78,
+    EMPTY_LEAF,
+
+    /* [16] -> opcode range [0, 2048], node depth 5 */
+    2,
+    21,
+    EMPTY_LEAF,
+    36,
+    EMPTY_LEAF,
+
+    /* [21] -> opcode range [0, 512], node depth 6 */
+    1,
+    24,
+    EMPTY_LEAF,
+
+    /* [24] -> opcode range [0, 256], node depth 7 */
+    1,
+    27,
+    EMPTY_LEAF,
+
+    /* [27] -> opcode range [0, 128], node depth 8 */
+    1,
+    30,
+    EMPTY_LEAF,
+
+    /* [30] -> opcode range [0, 64], node depth 9 */
+    1,
+    33,
+    EMPTY_LEAF,
+
+    /* [33] -> opcode range [0, 32], node depth 10 */
+    1,
+    LEAF(0),
+    EMPTY_LEAF,
+
+    /* [36] -> opcode range [1024, 1536], node depth 6 */
+    2,
+    41,
+    EMPTY_LEAF,
+    53,
+    67,
+
+    /* [41] -> opcode range [1024, 1152], node depth 7 */
+    1,
+    44,
+    EMPTY_LEAF,
+
+    /* [44] -> opcode range [1024, 1088], node depth 8 */
+    1,
+    47,
+    EMPTY_LEAF,
+
+    /* [47] -> opcode range [1024, 1056], node depth 9 */
+    1,
+    50,
+    EMPTY_LEAF,
+
+    /* [50] -> opcode range [1024, 1040], node depth 10 */
+    1,
+    LEAF(16),
+    EMPTY_LEAF,
+
+    /* [53] -> opcode range [1280, 1408], node depth 7 */
+    1,
+    56,
+    EMPTY_LEAF,
+
+    /* [56] -> opcode range [1280, 1344], node depth 8 */
+    2,
+    61,
+    LEAF(24),
+    EMPTY_LEAF,
+    64,
+
+    /* [61] -> opcode range [1280, 1296], node depth 9 */
+    1,
+    EMPTY_LEAF,
+    LEAF(40),
+
+    /* [64] -> opcode range [1328, 1344], node depth 9 */
+    1,
+    LEAF(48),
+    EMPTY_LEAF,
+
+    /* [67] -> opcode range [1408, 1536], node depth 7 */
+    1,
+    70,
+    EMPTY_LEAF,
+
+    /* [70] -> opcode range [1408, 1472], node depth 8 */
+    1,
+    73,
+    EMPTY_LEAF,
+
+    /* [73] -> opcode range [1408, 1440], node depth 9 */
+    2,
+    EMPTY_LEAF,
+    LEAF(56),
+    LEAF(64),
+    EMPTY_LEAF,
+
+    /* [78] -> opcode range [4096, 6144], node depth 5 */
+    2,
+    83,
+    EMPTY_LEAF,
+    101,
+    EMPTY_LEAF,
+
+    /* [83] -> opcode range [4096, 4608], node depth 6 */
+    1,
+    86,
+    EMPTY_LEAF,
+
+    /* [86] -> opcode range [4096, 4352], node depth 7 */
+    1,
+    89,
+    EMPTY_LEAF,
+
+    /* [89] -> opcode range [4096, 4224], node depth 8 */
+    1,
+    92,
+    EMPTY_LEAF,
+
+    /* [92] -> opcode range [4096, 4160], node depth 9 */
+    1,
+    95,
+    EMPTY_LEAF,
+
+    /* [95] -> opcode range [4096, 4128], node depth 10 */
+    1,
+    98,
+    EMPTY_LEAF,
+
+    /* [98] -> opcode range [4096, 4112], node depth 11 */
+    1,
+    LEAF(72),
+    EMPTY_LEAF,
+
+    /* [101] -> opcode range [5120, 5632], node depth 6 */
+    1,
+    104,
+    EMPTY_LEAF,
+
+    /* [104] -> opcode range [5120, 5376], node depth 7 */
+    1,
+    107,
+    EMPTY_LEAF,
+
+    /* [107] -> opcode range [5120, 5248], node depth 8 */
+    1,
+    110,
+    EMPTY_LEAF,
+
+    /* [110] -> opcode range [5120, 5184], node depth 9 */
+    1,
+    EMPTY_LEAF,
+    113,
+
+    /* [113] -> opcode range [5152, 5184], node depth 10 */
+    1,
+    116,
+    EMPTY_LEAF,
+
+    /* [116] -> opcode range [5152, 5168], node depth 11 */
+    1,
+    LEAF(80),
+    EMPTY_LEAF,
+
+    /* [119] -> opcode range [65536, 98304], node depth 2 */
+    1,
+    122,
+    EMPTY_LEAF,
+
+    /* [122] -> opcode range [65536, 81920], node depth 3 */
+    1,
+    125,
+    EMPTY_LEAF,
+
+    /* [125] -> opcode range [65536, 73728], node depth 4 */
+    1,
+    128,
+    EMPTY_LEAF,
+
+    /* [128] -> opcode range [65536, 69632], node depth 5 */
+    1,
+    131,
+    EMPTY_LEAF,
+
+    /* [131] -> opcode range [65536, 67584], node depth 6 */
+    1,
+    134,
+    EMPTY_LEAF,
+
+    /* [134] -> opcode range [65536, 66560], node depth 7 */
+    1,
+    137,
+    EMPTY_LEAF,
+
+    /* [137] -> opcode range [65536, 66048], node depth 8 */
+    1,
+    140,
+    EMPTY_LEAF,
+
+    /* [140] -> opcode range [65536, 65792], node depth 9 */
+    1,
+    143,
+    EMPTY_LEAF,
+
+    /* [143] -> opcode range [65536, 65664], node depth 10 */
+    1,
+    146,
+    EMPTY_LEAF,
+
+    /* [146] -> opcode range [65536, 65600], node depth 11 */
+    1,
+    149,
+    EMPTY_LEAF,
+
+    /* [149] -> opcode range [65536, 65568], node depth 12 */
+    1,
+    LEAF(88),
+    EMPTY_LEAF,
+
+};
+
+static const void *VendorPriv_function_table[104][2] = {
+    /* [  0] =     0 */ {NULL, NULL},
+    /* [  1] =     1 */ {__glXDisp_GetConvolutionFilterEXT, __glXDispSwap_GetConvolutionFilterEXT},
+    /* [  2] =     2 */ {__glXDisp_GetConvolutionParameterfvEXT, __glXDispSwap_GetConvolutionParameterfvEXT},
+    /* [  3] =     3 */ {__glXDisp_GetConvolutionParameterivEXT, __glXDispSwap_GetConvolutionParameterivEXT},
+    /* [  4] =     4 */ {__glXDisp_GetSeparableFilterEXT, __glXDispSwap_GetSeparableFilterEXT},
+    /* [  5] =     5 */ {__glXDisp_GetHistogramEXT, __glXDispSwap_GetHistogramEXT},
+    /* [  6] =     6 */ {__glXDisp_GetHistogramParameterfvEXT, __glXDispSwap_GetHistogramParameterfvEXT},
+    /* [  7] =     7 */ {__glXDisp_GetHistogramParameterivEXT, __glXDispSwap_GetHistogramParameterivEXT},
+    /* [  8] =     8 */ {__glXDisp_GetMinmaxEXT, __glXDispSwap_GetMinmaxEXT},
+    /* [  9] =     9 */ {__glXDisp_GetMinmaxParameterfvEXT, __glXDispSwap_GetMinmaxParameterfvEXT},
+    /* [ 10] =    10 */ {__glXDisp_GetMinmaxParameterivEXT, __glXDispSwap_GetMinmaxParameterivEXT},
+    /* [ 11] =    11 */ {__glXDisp_AreTexturesResidentEXT, __glXDispSwap_AreTexturesResidentEXT},
+    /* [ 12] =    12 */ {__glXDisp_DeleteTexturesEXT, __glXDispSwap_DeleteTexturesEXT},
+    /* [ 13] =    13 */ {__glXDisp_GenTexturesEXT, __glXDispSwap_GenTexturesEXT},
+    /* [ 14] =    14 */ {__glXDisp_IsTextureEXT, __glXDispSwap_IsTextureEXT},
+    /* [ 15] =    15 */ {NULL, NULL},
+    /* [ 16] =  1024 */ {__glXDisp_QueryContextInfoEXT, __glXDispSwap_QueryContextInfoEXT},
+    /* [ 17] =  1025 */ {NULL, NULL},
+    /* [ 18] =  1026 */ {NULL, NULL},
+    /* [ 19] =  1027 */ {NULL, NULL},
+    /* [ 20] =  1028 */ {NULL, NULL},
+    /* [ 21] =  1029 */ {NULL, NULL},
+    /* [ 22] =  1030 */ {NULL, NULL},
+    /* [ 23] =  1031 */ {NULL, NULL},
+    /* [ 24] =  1296 */ {__glXDisp_GetProgramEnvParameterfvARB, __glXDispSwap_GetProgramEnvParameterfvARB},
+    /* [ 25] =  1297 */ {__glXDisp_GetProgramEnvParameterdvARB, __glXDispSwap_GetProgramEnvParameterdvARB},
+    /* [ 26] =  1298 */ {__glXDisp_GetProgramivNV, __glXDispSwap_GetProgramivNV},
+    /* [ 27] =  1299 */ {__glXDisp_GetProgramStringNV, __glXDispSwap_GetProgramStringNV},
+    /* [ 28] =  1300 */ {__glXDisp_GetTrackMatrixivNV, __glXDispSwap_GetTrackMatrixivNV},
+    /* [ 29] =  1301 */ {__glXDisp_GetVertexAttribdvARB, __glXDispSwap_GetVertexAttribdvARB},
+    /* [ 30] =  1302 */ {__glXDisp_GetVertexAttribfvNV, __glXDispSwap_GetVertexAttribfvNV},
+    /* [ 31] =  1303 */ {__glXDisp_GetVertexAttribivNV, __glXDispSwap_GetVertexAttribivNV},
+    /* [ 32] =  1304 */ {__glXDisp_IsProgramNV, __glXDispSwap_IsProgramNV},
+    /* [ 33] =  1305 */ {__glXDisp_GetProgramLocalParameterfvARB, __glXDispSwap_GetProgramLocalParameterfvARB},
+    /* [ 34] =  1306 */ {__glXDisp_GetProgramLocalParameterdvARB, __glXDispSwap_GetProgramLocalParameterdvARB},
+    /* [ 35] =  1307 */ {__glXDisp_GetProgramivARB, __glXDispSwap_GetProgramivARB},
+    /* [ 36] =  1308 */ {__glXDisp_GetProgramStringARB, __glXDispSwap_GetProgramStringARB},
+    /* [ 37] =  1309 */ {NULL, NULL},
+    /* [ 38] =  1310 */ {__glXDisp_GetProgramNamedParameterfvNV, __glXDispSwap_GetProgramNamedParameterfvNV},
+    /* [ 39] =  1311 */ {__glXDisp_GetProgramNamedParameterdvNV, __glXDispSwap_GetProgramNamedParameterdvNV},
+    /* [ 40] =  1288 */ {NULL, NULL},
+    /* [ 41] =  1289 */ {NULL, NULL},
+    /* [ 42] =  1290 */ {NULL, NULL},
+    /* [ 43] =  1291 */ {NULL, NULL},
+    /* [ 44] =  1292 */ {NULL, NULL},
+    /* [ 45] =  1293 */ {__glXDisp_AreProgramsResidentNV, __glXDispSwap_AreProgramsResidentNV},
+    /* [ 46] =  1294 */ {__glXDisp_DeleteProgramsNV, __glXDispSwap_DeleteProgramsNV},
+    /* [ 47] =  1295 */ {__glXDisp_GenProgramsNV, __glXDispSwap_GenProgramsNV},
+    /* [ 48] =  1328 */ {NULL, NULL},
+    /* [ 49] =  1329 */ {NULL, NULL},
+    /* [ 50] =  1330 */ {__glXDisp_BindTexImageEXT, __glXDispSwap_BindTexImageEXT},
+    /* [ 51] =  1331 */ {__glXDisp_ReleaseTexImageEXT, __glXDispSwap_ReleaseTexImageEXT},
+    /* [ 52] =  1332 */ {NULL, NULL},
+    /* [ 53] =  1333 */ {NULL, NULL},
+    /* [ 54] =  1334 */ {NULL, NULL},
+    /* [ 55] =  1335 */ {NULL, NULL},
+    /* [ 56] =  1416 */ {NULL, NULL},
+    /* [ 57] =  1417 */ {NULL, NULL},
+    /* [ 58] =  1418 */ {NULL, NULL},
+    /* [ 59] =  1419 */ {NULL, NULL},
+    /* [ 60] =  1420 */ {NULL, NULL},
+    /* [ 61] =  1421 */ {NULL, NULL},
+    /* [ 62] =  1422 */ {__glXDisp_IsRenderbufferEXT, __glXDispSwap_IsRenderbufferEXT},
+    /* [ 63] =  1423 */ {__glXDisp_GenRenderbuffersEXT, __glXDispSwap_GenRenderbuffersEXT},
+    /* [ 64] =  1424 */ {__glXDisp_GetRenderbufferParameterivEXT, __glXDispSwap_GetRenderbufferParameterivEXT},
+    /* [ 65] =  1425 */ {__glXDisp_IsFramebufferEXT, __glXDispSwap_IsFramebufferEXT},
+    /* [ 66] =  1426 */ {__glXDisp_GenFramebuffersEXT, __glXDispSwap_GenFramebuffersEXT},
+    /* [ 67] =  1427 */ {__glXDisp_CheckFramebufferStatusEXT, __glXDispSwap_CheckFramebufferStatusEXT},
+    /* [ 68] =  1428 */ {__glXDisp_GetFramebufferAttachmentParameterivEXT, __glXDispSwap_GetFramebufferAttachmentParameterivEXT},
+    /* [ 69] =  1429 */ {NULL, NULL},
+    /* [ 70] =  1430 */ {NULL, NULL},
+    /* [ 71] =  1431 */ {NULL, NULL},
+    /* [ 72] =  4096 */ {NULL, NULL},
+    /* [ 73] =  4097 */ {NULL, NULL},
+    /* [ 74] =  4098 */ {__glXDisp_GetColorTableSGI, __glXDispSwap_GetColorTableSGI},
+    /* [ 75] =  4099 */ {__glXDisp_GetColorTableParameterfvSGI, __glXDispSwap_GetColorTableParameterfvSGI},
+    /* [ 76] =  4100 */ {__glXDisp_GetColorTableParameterivSGI, __glXDispSwap_GetColorTableParameterivSGI},
+    /* [ 77] =  4101 */ {NULL, NULL},
+    /* [ 78] =  4102 */ {NULL, NULL},
+    /* [ 79] =  4103 */ {NULL, NULL},
+    /* [ 80] =  5152 */ {NULL, NULL},
+    /* [ 81] =  5153 */ {NULL, NULL},
+    /* [ 82] =  5154 */ {__glXDisp_CopySubBufferMESA, __glXDispSwap_CopySubBufferMESA},
+    /* [ 83] =  5155 */ {NULL, NULL},
+    /* [ 84] =  5156 */ {NULL, NULL},
+    /* [ 85] =  5157 */ {NULL, NULL},
+    /* [ 86] =  5158 */ {NULL, NULL},
+    /* [ 87] =  5159 */ {NULL, NULL},
+    /* [ 88] = 65536 */ {__glXDisp_SwapIntervalSGI, __glXDispSwap_SwapIntervalSGI},
+    /* [ 89] = 65537 */ {__glXDisp_MakeCurrentReadSGI, __glXDispSwap_MakeCurrentReadSGI},
+    /* [ 90] = 65538 */ {NULL, NULL},
+    /* [ 91] = 65539 */ {NULL, NULL},
+    /* [ 92] = 65540 */ {__glXDisp_GetFBConfigsSGIX, __glXDispSwap_GetFBConfigsSGIX},
+    /* [ 93] = 65541 */ {__glXDisp_CreateContextWithConfigSGIX, __glXDispSwap_CreateContextWithConfigSGIX},
+    /* [ 94] = 65542 */ {__glXDisp_CreateGLXPixmapWithConfigSGIX, __glXDispSwap_CreateGLXPixmapWithConfigSGIX},
+    /* [ 95] = 65543 */ {__glXDisp_CreateGLXPbufferSGIX, __glXDispSwap_CreateGLXPbufferSGIX},
+    /* [ 96] = 65544 */ {__glXDisp_DestroyGLXPbufferSGIX, __glXDispSwap_DestroyGLXPbufferSGIX},
+    /* [ 97] = 65545 */ {__glXDisp_ChangeDrawableAttributesSGIX, __glXDispSwap_ChangeDrawableAttributesSGIX},
+    /* [ 98] = 65546 */ {__glXDisp_GetDrawableAttributesSGIX, __glXDispSwap_GetDrawableAttributesSGIX},
+    /* [ 99] = 65547 */ {NULL, NULL},
+    /* [ 100] = 65548 */ {NULL, NULL},
+    /* [ 101] = 65549 */ {NULL, NULL},
+    /* [ 102] = 65550 */ {NULL, NULL},
+    /* [ 103] = 65551 */ {NULL, NULL},
+};
+
+const struct __glXDispatchInfo VendorPriv_dispatch_info = {
+    17,
+    VendorPriv_dispatch_tree,
+    VendorPriv_function_table,
+    NULL,
+    NULL
+};
+
diff --git a/src/mesa/glapi/Makefile b/src/mesa/glapi/Makefile
index 7b240a21af4..6520f75e134 100644
--- a/src/mesa/glapi/Makefile
+++ b/src/mesa/glapi/Makefile
@@ -7,23 +7,20 @@
 TOP = ../../..
 include $(TOP)/configs/current
 
+GLX_DIR = ../../glx/x11
+
 OUTPUTS = glprocs.h glapitemp.h glapioffsets.h glapitable.h dispatch.h \
 	../main/enums.c \
 	../x86/glapi_x86.S \
 	../x86-64/glapi_x86-64.S \
 	../sparc/glapi_sparc.S \
 	../drivers/dri/common/extension_helper.h \
-	../../glx/x11/indirect.c \
-	../../glx/x11/indirect.h \
-	../../glx/x11/indirect_init.c \
-	../../glx/x11/indirect_size.h \
-	../../glx/x11/indirect_size.c
-
-
-#XORG_BASE = /home/idr/devel/graphics/Xorg/xserver/xorg
-GLX_DIR   = $(XORG_BASE)/GL/glx
-
-SERVER_OUTPUTS = $(GLX_DIR)/indirect_dispatch.c \
+	$(GLX_DIR)/indirect.c \
+	$(GLX_DIR)/indirect.h \
+	$(GLX_DIR)/indirect_init.c \
+	$(GLX_DIR)/indirect_size.h \
+	$(GLX_DIR)/indirect_size.c \
+	$(GLX_DIR)/indirect_dispatch.c \
 	$(GLX_DIR)/indirect_dispatch_swap.c \
 	$(GLX_DIR)/indirect_dispatch.h \
 	$(GLX_DIR)/indirect_reqsize.c \
@@ -41,8 +38,6 @@ COMMON_GLX = $(COMMON) glX_API.xml glX_XML.py glX_proto_common.py
 
 all: $(OUTPUTS)
 
-server: $(SERVER_OUTPUTS)
-
 glprocs.h: gl_procs.py $(COMMON)
 	$(PYTHON2) $(PYTHON_FLAGS) $< > $@
 
@@ -74,20 +69,20 @@ dispatch.h: gl_table.py $(COMMON)
 ../drivers/dri/common/extension_helper.h: extension_helper.py $(COMMON)
 	$(PYTHON2) $(PYTHON_FLAGS) $< > $@
 
-../../glx/x11/indirect.c: glX_proto_send.py $(COMMON_GLX)
+$(GLX_DIR)/indirect.c: glX_proto_send.py $(COMMON_GLX)
 	$(PYTHON2) $(PYTHON_FLAGS) $< -m proto | $(INDENT) $(INDENT_FLAGS) > $@
 
-../../glx/x11/indirect.h: glX_proto_send.py $(COMMON_GLX)
+$(GLX_DIR)/indirect.h: glX_proto_send.py $(COMMON_GLX)
 	$(PYTHON2) $(PYTHON_FLAGS) $< -m init_h > $@
 
-../../glx/x11/indirect_init.c: glX_proto_send.py $(COMMON_GLX)
+$(GLX_DIR)/indirect_init.c: glX_proto_send.py $(COMMON_GLX)
 	$(PYTHON2) $(PYTHON_FLAGS) $< -m init_c > $@
 
-../../glx/x11/indirect_size.h: glX_proto_size.py $(COMMON_GLX)
+$(GLX_DIR)/indirect_size.h: glX_proto_size.py $(COMMON_GLX)
 	$(PYTHON2) $(PYTHON_FLAGS) $< -m size_h --only-set -h _INDIRECT_SIZE_H_ \
 	  | $(INDENT) $(INDENT_FLAGS) > $@
 
-../../glx/x11/indirect_size.c: glX_proto_size.py $(COMMON_GLX)
+$(GLX_DIR)/indirect_size.c: glX_proto_size.py $(COMMON_GLX)
 	$(PYTHON2) $(PYTHON_FLAGS) $< -m size_c --only-set \
 	  | $(INDENT) $(INDENT_FLAGS) > $@