Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1

Summary: Imported nx-X11-3.1.0-1.tar.gz
Keywords:

Imported nx-X11-3.1.0-1.tar.gz
into Git repository

1 files changed, 3387 insertions, 0 deletions

diff --git a/nx-X11/programs/Xserver/GL/glx/g_renderswap.c b/nx-X11/programs/Xserver/GL/glx/g_renderswap.c
new file mode 100644
index 000000000..f485a2690
--- /dev/null
+++ b/nx-X11/programs/Xserver/GL/glx/g_renderswap.c
@@ -0,0 +1,3387 @@
+/* $XFree86: xc/programs/Xserver/GL/glx/g_renderswap.c,v 1.8 2004/01/28 18:11:50 alanh Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: This software was created using the
+** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+** not been independently verified as being compliant with the OpenGL(R)
+** version 1.2.1 Specification.
+*/
+
+#define NEED_REPLIES
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "glxserver.h"
+#include "glxext.h"
+#include "g_disptab.h"
+#include "g_disptab_EXT.h"
+#include "unpack.h"
+#include "impsize.h"
+#include "singlesize.h"
+
+void __glXDispSwap_CallList(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glCallList( 
+		*(GLuint   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_ListBase(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glListBase( 
+		*(GLuint   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Begin(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glBegin( 
+		*(GLenum   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Color3bv(GLbyte *pc)
+{
+	glColor3bv( 
+		(GLbyte   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Color3dv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 24);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
+
+	glColor3dv( 
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Color3fv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
+
+	glColor3fv( 
+		(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Color3iv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT_ARRAY(pc + 0, 3);
+
+	glColor3iv( 
+		(GLint    *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Color3sv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
+
+	glColor3sv( 
+		(GLshort  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Color3ubv(GLbyte *pc)
+{
+	glColor3ubv( 
+		(GLubyte  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Color3uiv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT_ARRAY(pc + 0, 3);
+
+	glColor3uiv( 
+		(GLuint   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Color3usv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
+
+	glColor3usv( 
+		(GLushort *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Color4bv(GLbyte *pc)
+{
+	glColor4bv( 
+		(GLbyte   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Color4dv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 32);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
+
+	glColor4dv( 
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Color4fv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
+
+	glColor4fv( 
+		(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Color4iv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT_ARRAY(pc + 0, 4);
+
+	glColor4iv( 
+		(GLint    *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Color4sv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
+
+	glColor4sv( 
+		(GLshort  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Color4ubv(GLbyte *pc)
+{
+	glColor4ubv( 
+		(GLubyte  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Color4uiv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT_ARRAY(pc + 0, 4);
+
+	glColor4uiv( 
+		(GLuint   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Color4usv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
+
+	glColor4usv( 
+		(GLushort *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_EdgeFlagv(GLbyte *pc)
+{
+	glEdgeFlagv( 
+		(GLboolean *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_End(GLbyte *pc)
+{
+	glEnd( 
+	);
+}
+
+void __glXDispSwap_Indexdv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 8);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
+
+	glIndexdv( 
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Indexfv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);
+
+	glIndexfv( 
+		(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Indexiv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT_ARRAY(pc + 0, 1);
+
+	glIndexiv( 
+		(GLint    *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Indexsv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 1);
+
+	glIndexsv( 
+		(GLshort  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Normal3bv(GLbyte *pc)
+{
+	glNormal3bv( 
+		(GLbyte   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Normal3dv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 24);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
+
+	glNormal3dv( 
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Normal3fv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
+
+	glNormal3fv( 
+		(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Normal3iv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT_ARRAY(pc + 0, 3);
+
+	glNormal3iv( 
+		(GLint    *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Normal3sv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
+
+	glNormal3sv( 
+		(GLshort  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_RasterPos2dv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 16);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
+
+	glRasterPos2dv( 
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_RasterPos2fv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
+
+	glRasterPos2fv( 
+		(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_RasterPos2iv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT_ARRAY(pc + 0, 2);
+
+	glRasterPos2iv( 
+		(GLint    *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_RasterPos2sv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
+
+	glRasterPos2sv( 
+		(GLshort  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_RasterPos3dv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 24);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
+
+	glRasterPos3dv( 
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_RasterPos3fv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
+
+	glRasterPos3fv( 
+		(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_RasterPos3iv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT_ARRAY(pc + 0, 3);
+
+	glRasterPos3iv( 
+		(GLint    *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_RasterPos3sv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
+
+	glRasterPos3sv( 
+		(GLshort  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_RasterPos4dv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 32);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
+
+	glRasterPos4dv( 
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_RasterPos4fv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
+
+	glRasterPos4fv( 
+		(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_RasterPos4iv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT_ARRAY(pc + 0, 4);
+
+	glRasterPos4iv( 
+		(GLint    *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_RasterPos4sv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
+
+	glRasterPos4sv( 
+		(GLshort  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Rectdv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 32);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 16, 2);
+
+	glRectdv( 
+		(GLdouble *)(pc + 0),
+		(GLdouble *)(pc + 16)
+	);
+}
+
+void __glXDispSwap_Rectfv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
+	__GLX_SWAP_FLOAT_ARRAY(pc + 8, 2);
+
+	glRectfv( 
+		(GLfloat  *)(pc + 0),
+		(GLfloat  *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_Rectiv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT_ARRAY(pc + 0, 2);
+	__GLX_SWAP_INT_ARRAY(pc + 8, 2);
+
+	glRectiv( 
+		(GLint    *)(pc + 0),
+		(GLint    *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_Rectsv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
+	__GLX_SWAP_SHORT_ARRAY(pc + 4, 2);
+
+	glRectsv( 
+		(GLshort  *)(pc + 0),
+		(GLshort  *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_TexCoord1dv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 8);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
+
+	glTexCoord1dv( 
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_TexCoord1fv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);
+
+	glTexCoord1fv( 
+		(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_TexCoord1iv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT_ARRAY(pc + 0, 1);
+
+	glTexCoord1iv( 
+		(GLint    *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_TexCoord1sv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 1);
+
+	glTexCoord1sv( 
+		(GLshort  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_TexCoord2dv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 16);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
+
+	glTexCoord2dv( 
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_TexCoord2fv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
+
+	glTexCoord2fv( 
+		(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_TexCoord2iv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT_ARRAY(pc + 0, 2);
+
+	glTexCoord2iv( 
+		(GLint    *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_TexCoord2sv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
+
+	glTexCoord2sv( 
+		(GLshort  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_TexCoord3dv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 24);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
+
+	glTexCoord3dv( 
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_TexCoord3fv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
+
+	glTexCoord3fv( 
+		(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_TexCoord3iv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT_ARRAY(pc + 0, 3);
+
+	glTexCoord3iv( 
+		(GLint    *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_TexCoord3sv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
+
+	glTexCoord3sv( 
+		(GLshort  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_TexCoord4dv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 32);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
+
+	glTexCoord4dv( 
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_TexCoord4fv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
+
+	glTexCoord4fv( 
+		(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_TexCoord4iv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT_ARRAY(pc + 0, 4);
+
+	glTexCoord4iv( 
+		(GLint    *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_TexCoord4sv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
+
+	glTexCoord4sv( 
+		(GLshort  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Vertex2dv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 16);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
+
+	glVertex2dv( 
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Vertex2fv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
+
+	glVertex2fv( 
+		(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Vertex2iv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT_ARRAY(pc + 0, 2);
+
+	glVertex2iv( 
+		(GLint    *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Vertex2sv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 2);
+
+	glVertex2sv( 
+		(GLshort  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Vertex3dv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 24);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
+
+	glVertex3dv( 
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Vertex3fv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 3);
+
+	glVertex3fv( 
+		(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Vertex3iv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT_ARRAY(pc + 0, 3);
+
+	glVertex3iv( 
+		(GLint    *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Vertex3sv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 3);
+
+	glVertex3sv( 
+		(GLshort  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Vertex4dv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 32);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
+
+	glVertex4dv( 
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Vertex4fv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 4);
+
+	glVertex4fv( 
+		(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Vertex4iv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT_ARRAY(pc + 0, 4);
+
+	glVertex4iv( 
+		(GLint    *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Vertex4sv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_SHORT_ARRAY(pc + 0, 4);
+
+	glVertex4sv( 
+		(GLshort  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_ClipPlane(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 36);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_INT(pc + 32);
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
+
+	glClipPlane( 
+		*(GLenum   *)(pc + 32),
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_ColorMaterial(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+
+	glColorMaterial( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_CullFace(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glCullFace( 
+		*(GLenum   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Fogf(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT(pc + 4);
+
+	glFogf( 
+		*(GLenum   *)(pc + 0),
+		*(GLfloat  *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_Fogfv(GLbyte *pc)
+{
+	GLenum pname;
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	pname = *(GLenum *)(pc + 0);
+	compsize = __glFogfv_size(pname);
+	if (compsize < 0) compsize = 0;
+	__GLX_SWAP_FLOAT_ARRAY(pc + 4, compsize);
+
+	glFogfv( 
+		*(GLenum   *)(pc + 0),
+		(GLfloat  *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_Fogi(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+
+	glFogi( 
+		*(GLenum   *)(pc + 0),
+		*(GLint    *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_Fogiv(GLbyte *pc)
+{
+	GLenum pname;
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	pname = *(GLenum *)(pc + 0);
+	compsize = __glFogiv_size(pname);
+	if (compsize < 0) compsize = 0;
+	__GLX_SWAP_INT_ARRAY(pc + 4, compsize);
+
+	glFogiv( 
+		*(GLenum   *)(pc + 0),
+		(GLint    *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_FrontFace(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glFrontFace( 
+		*(GLenum   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Hint(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+
+	glHint( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_Lightf(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_FLOAT(pc + 8);
+
+	glLightf( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		*(GLfloat  *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_Lightfv(GLbyte *pc)
+{
+	GLenum pname;
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 4);
+	pname = *(GLenum *)(pc + 4);
+	compsize = __glLightfv_size(pname);
+	if (compsize < 0) compsize = 0;
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
+
+	glLightfv( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		(GLfloat  *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_Lighti(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+
+	glLighti( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		*(GLint    *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_Lightiv(GLbyte *pc)
+{
+	GLenum pname;
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 4);
+	pname = *(GLenum *)(pc + 4);
+	compsize = __glLightiv_size(pname);
+	if (compsize < 0) compsize = 0;
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
+
+	glLightiv( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		(GLint    *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_LightModelf(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT(pc + 4);
+
+	glLightModelf( 
+		*(GLenum   *)(pc + 0),
+		*(GLfloat  *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_LightModelfv(GLbyte *pc)
+{
+	GLenum pname;
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	pname = *(GLenum *)(pc + 0);
+	compsize = __glLightModelfv_size(pname);
+	if (compsize < 0) compsize = 0;
+	__GLX_SWAP_FLOAT_ARRAY(pc + 4, compsize);
+
+	glLightModelfv( 
+		*(GLenum   *)(pc + 0),
+		(GLfloat  *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_LightModeli(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+
+	glLightModeli( 
+		*(GLenum   *)(pc + 0),
+		*(GLint    *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_LightModeliv(GLbyte *pc)
+{
+	GLenum pname;
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	pname = *(GLenum *)(pc + 0);
+	compsize = __glLightModeliv_size(pname);
+	if (compsize < 0) compsize = 0;
+	__GLX_SWAP_INT_ARRAY(pc + 4, compsize);
+
+	glLightModeliv( 
+		*(GLenum   *)(pc + 0),
+		(GLint    *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_LineStipple(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_SHORT(pc + 4);
+
+	glLineStipple( 
+		*(GLint    *)(pc + 0),
+		*(GLushort *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_LineWidth(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_FLOAT(pc + 0);
+
+	glLineWidth( 
+		*(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Materialf(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_FLOAT(pc + 8);
+
+	glMaterialf( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		*(GLfloat  *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_Materialfv(GLbyte *pc)
+{
+	GLenum pname;
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 4);
+	pname = *(GLenum *)(pc + 4);
+	compsize = __glMaterialfv_size(pname);
+	if (compsize < 0) compsize = 0;
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
+
+	glMaterialfv( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		(GLfloat  *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_Materiali(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+
+	glMateriali( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		*(GLint    *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_Materialiv(GLbyte *pc)
+{
+	GLenum pname;
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 4);
+	pname = *(GLenum *)(pc + 4);
+	compsize = __glMaterialiv_size(pname);
+	if (compsize < 0) compsize = 0;
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
+
+	glMaterialiv( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		(GLint    *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_PointSize(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_FLOAT(pc + 0);
+
+	glPointSize( 
+		*(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_PolygonMode(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+
+	glPolygonMode( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_Scissor(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+	__GLX_SWAP_INT(pc + 12);
+
+	glScissor( 
+		*(GLint    *)(pc + 0),
+		*(GLint    *)(pc + 4),
+		*(GLsizei  *)(pc + 8),
+		*(GLsizei  *)(pc + 12)
+	);
+}
+
+void __glXDispSwap_ShadeModel(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glShadeModel( 
+		*(GLenum   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_TexParameterf(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_FLOAT(pc + 8);
+
+	glTexParameterf( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		*(GLfloat  *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_TexParameterfv(GLbyte *pc)
+{
+	GLenum pname;
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 4);
+	pname = *(GLenum *)(pc + 4);
+	compsize = __glTexParameterfv_size(pname);
+	if (compsize < 0) compsize = 0;
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
+
+	glTexParameterfv( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		(GLfloat  *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_TexParameteri(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+
+	glTexParameteri( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		*(GLint    *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_TexParameteriv(GLbyte *pc)
+{
+	GLenum pname;
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 4);
+	pname = *(GLenum *)(pc + 4);
+	compsize = __glTexParameteriv_size(pname);
+	if (compsize < 0) compsize = 0;
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
+
+	glTexParameteriv( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		(GLint    *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_TexEnvf(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_FLOAT(pc + 8);
+
+	glTexEnvf( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		*(GLfloat  *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_TexEnvfv(GLbyte *pc)
+{
+	GLenum pname;
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 4);
+	pname = *(GLenum *)(pc + 4);
+	compsize = __glTexEnvfv_size(pname);
+	if (compsize < 0) compsize = 0;
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
+
+	glTexEnvfv( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		(GLfloat  *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_TexEnvi(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+
+	glTexEnvi( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		*(GLint    *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_TexEnviv(GLbyte *pc)
+{
+	GLenum pname;
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 4);
+	pname = *(GLenum *)(pc + 4);
+	compsize = __glTexEnviv_size(pname);
+	if (compsize < 0) compsize = 0;
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
+
+	glTexEnviv( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		(GLint    *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_TexGend(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 16);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_INT(pc + 8);
+	__GLX_SWAP_INT(pc + 12);
+	__GLX_SWAP_DOUBLE(pc + 0);
+
+	glTexGend( 
+		*(GLenum   *)(pc + 8),
+		*(GLenum   *)(pc + 12),
+		*(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_TexGendv(GLbyte *pc)
+{
+	GLenum pname;
+#ifdef __GLX_ALIGN64
+	GLint cmdlen;
+#endif
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 4);
+	pname = *(GLenum *)(pc + 4);
+	compsize = __glTexGendv_size(pname);
+	if (compsize < 0) compsize = 0;
+
+#ifdef __GLX_ALIGN64
+	cmdlen = __GLX_PAD(8+compsize*8);
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, cmdlen);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 8, compsize);
+
+	glTexGendv( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		(GLdouble *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_TexGenf(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_FLOAT(pc + 8);
+
+	glTexGenf( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		*(GLfloat  *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_TexGenfv(GLbyte *pc)
+{
+	GLenum pname;
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 4);
+	pname = *(GLenum *)(pc + 4);
+	compsize = __glTexGenfv_size(pname);
+	if (compsize < 0) compsize = 0;
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
+
+	glTexGenfv( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		(GLfloat  *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_TexGeni(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+
+	glTexGeni( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		*(GLint    *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_TexGeniv(GLbyte *pc)
+{
+	GLenum pname;
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 4);
+	pname = *(GLenum *)(pc + 4);
+	compsize = __glTexGeniv_size(pname);
+	if (compsize < 0) compsize = 0;
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
+
+	glTexGeniv( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		(GLint    *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_InitNames(GLbyte *pc)
+{
+	glInitNames( 
+	);
+}
+
+void __glXDispSwap_LoadName(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glLoadName( 
+		*(GLuint   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_PassThrough(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_FLOAT(pc + 0);
+
+	glPassThrough( 
+		*(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_PopName(GLbyte *pc)
+{
+	glPopName( 
+	);
+}
+
+void __glXDispSwap_PushName(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glPushName( 
+		*(GLuint   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_DrawBuffer(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glDrawBuffer( 
+		*(GLenum   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Clear(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glClear( 
+		*(GLbitfield *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_ClearAccum(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_FLOAT(pc + 0);
+	__GLX_SWAP_FLOAT(pc + 4);
+	__GLX_SWAP_FLOAT(pc + 8);
+	__GLX_SWAP_FLOAT(pc + 12);
+
+	glClearAccum( 
+		*(GLfloat  *)(pc + 0),
+		*(GLfloat  *)(pc + 4),
+		*(GLfloat  *)(pc + 8),
+		*(GLfloat  *)(pc + 12)
+	);
+}
+
+void __glXDispSwap_ClearIndex(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_FLOAT(pc + 0);
+
+	glClearIndex( 
+		*(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_ClearColor(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_FLOAT(pc + 0);
+	__GLX_SWAP_FLOAT(pc + 4);
+	__GLX_SWAP_FLOAT(pc + 8);
+	__GLX_SWAP_FLOAT(pc + 12);
+
+	glClearColor( 
+		*(GLclampf *)(pc + 0),
+		*(GLclampf *)(pc + 4),
+		*(GLclampf *)(pc + 8),
+		*(GLclampf *)(pc + 12)
+	);
+}
+
+void __glXDispSwap_ClearStencil(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glClearStencil( 
+		*(GLint    *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_ClearDepth(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 8);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE(pc + 0);
+
+	glClearDepth( 
+		*(GLclampd *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_StencilMask(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glStencilMask( 
+		*(GLuint   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_ColorMask(GLbyte *pc)
+{
+	glColorMask( 
+		*(GLboolean *)(pc + 0),
+		*(GLboolean *)(pc + 1),
+		*(GLboolean *)(pc + 2),
+		*(GLboolean *)(pc + 3)
+	);
+}
+
+void __glXDispSwap_DepthMask(GLbyte *pc)
+{
+	glDepthMask( 
+		*(GLboolean *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_IndexMask(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glIndexMask( 
+		*(GLuint   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Accum(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT(pc + 4);
+
+	glAccum( 
+		*(GLenum   *)(pc + 0),
+		*(GLfloat  *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_Disable(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glDisable( 
+		*(GLenum   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Enable(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glEnable( 
+		*(GLenum   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_PopAttrib(GLbyte *pc)
+{
+	glPopAttrib( 
+	);
+}
+
+void __glXDispSwap_PushAttrib(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glPushAttrib( 
+		*(GLbitfield *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_MapGrid1d(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 20);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_INT(pc + 16);
+	__GLX_SWAP_DOUBLE(pc + 0);
+	__GLX_SWAP_DOUBLE(pc + 8);
+
+	glMapGrid1d( 
+		*(GLint    *)(pc + 16),
+		*(GLdouble *)(pc + 0),
+		*(GLdouble *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_MapGrid1f(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT(pc + 4);
+	__GLX_SWAP_FLOAT(pc + 8);
+
+	glMapGrid1f( 
+		*(GLint    *)(pc + 0),
+		*(GLfloat  *)(pc + 4),
+		*(GLfloat  *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_MapGrid2d(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 40);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_INT(pc + 32);
+	__GLX_SWAP_DOUBLE(pc + 0);
+	__GLX_SWAP_DOUBLE(pc + 8);
+	__GLX_SWAP_INT(pc + 36);
+	__GLX_SWAP_DOUBLE(pc + 16);
+	__GLX_SWAP_DOUBLE(pc + 24);
+
+	glMapGrid2d( 
+		*(GLint    *)(pc + 32),
+		*(GLdouble *)(pc + 0),
+		*(GLdouble *)(pc + 8),
+		*(GLint    *)(pc + 36),
+		*(GLdouble *)(pc + 16),
+		*(GLdouble *)(pc + 24)
+	);
+}
+
+void __glXDispSwap_MapGrid2f(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT(pc + 4);
+	__GLX_SWAP_FLOAT(pc + 8);
+	__GLX_SWAP_INT(pc + 12);
+	__GLX_SWAP_FLOAT(pc + 16);
+	__GLX_SWAP_FLOAT(pc + 20);
+
+	glMapGrid2f( 
+		*(GLint    *)(pc + 0),
+		*(GLfloat  *)(pc + 4),
+		*(GLfloat  *)(pc + 8),
+		*(GLint    *)(pc + 12),
+		*(GLfloat  *)(pc + 16),
+		*(GLfloat  *)(pc + 20)
+	);
+}
+
+void __glXDispSwap_EvalCoord1dv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 8);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
+
+	glEvalCoord1dv( 
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_EvalCoord1fv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 1);
+
+	glEvalCoord1fv( 
+		(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_EvalCoord2dv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 16);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
+
+	glEvalCoord2dv( 
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_EvalCoord2fv(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 2);
+
+	glEvalCoord2fv( 
+		(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_EvalMesh1(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+
+	glEvalMesh1( 
+		*(GLenum   *)(pc + 0),
+		*(GLint    *)(pc + 4),
+		*(GLint    *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_EvalPoint1(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glEvalPoint1( 
+		*(GLint    *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_EvalMesh2(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+	__GLX_SWAP_INT(pc + 12);
+	__GLX_SWAP_INT(pc + 16);
+
+	glEvalMesh2( 
+		*(GLenum   *)(pc + 0),
+		*(GLint    *)(pc + 4),
+		*(GLint    *)(pc + 8),
+		*(GLint    *)(pc + 12),
+		*(GLint    *)(pc + 16)
+	);
+}
+
+void __glXDispSwap_EvalPoint2(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+
+	glEvalPoint2( 
+		*(GLint    *)(pc + 0),
+		*(GLint    *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_AlphaFunc(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT(pc + 4);
+
+	glAlphaFunc( 
+		*(GLenum   *)(pc + 0),
+		*(GLclampf *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_BlendFunc(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+
+	glBlendFunc( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_LogicOp(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glLogicOp( 
+		*(GLenum   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_StencilFunc(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+
+	glStencilFunc( 
+		*(GLenum   *)(pc + 0),
+		*(GLint    *)(pc + 4),
+		*(GLuint   *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_StencilOp(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+
+	glStencilOp( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		*(GLenum   *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_DepthFunc(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glDepthFunc( 
+		*(GLenum   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_PixelZoom(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_FLOAT(pc + 0);
+	__GLX_SWAP_FLOAT(pc + 4);
+
+	glPixelZoom( 
+		*(GLfloat  *)(pc + 0),
+		*(GLfloat  *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_PixelTransferf(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT(pc + 4);
+
+	glPixelTransferf( 
+		*(GLenum   *)(pc + 0),
+		*(GLfloat  *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_PixelTransferi(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+
+	glPixelTransferi( 
+		*(GLenum   *)(pc + 0),
+		*(GLint    *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_PixelMapfv(GLbyte *pc)
+{
+	GLint mapsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 4);
+	mapsize = *(GLint *)(pc + 4);
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT_ARRAY(pc + 8, mapsize);
+
+	glPixelMapfv( 
+		*(GLenum   *)(pc + 0),
+		*(GLint    *)(pc + 4),
+		(GLfloat  *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_PixelMapuiv(GLbyte *pc)
+{
+	GLint mapsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 4);
+	mapsize = *(GLint *)(pc + 4);
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT_ARRAY(pc + 8, mapsize);
+
+	glPixelMapuiv( 
+		*(GLenum   *)(pc + 0),
+		*(GLint    *)(pc + 4),
+		(GLuint   *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_PixelMapusv(GLbyte *pc)
+{
+	GLint mapsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 4);
+	mapsize = *(GLint *)(pc + 4);
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_SHORT_ARRAY(pc + 8, mapsize);
+
+	glPixelMapusv( 
+		*(GLenum   *)(pc + 0),
+		*(GLint    *)(pc + 4),
+		(GLushort *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_ReadBuffer(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glReadBuffer( 
+		*(GLenum   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_CopyPixels(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+	__GLX_SWAP_INT(pc + 12);
+	__GLX_SWAP_INT(pc + 16);
+
+	glCopyPixels( 
+		*(GLint    *)(pc + 0),
+		*(GLint    *)(pc + 4),
+		*(GLsizei  *)(pc + 8),
+		*(GLsizei  *)(pc + 12),
+		*(GLenum   *)(pc + 16)
+	);
+}
+
+void __glXDispSwap_DepthRange(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 16);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE(pc + 0);
+	__GLX_SWAP_DOUBLE(pc + 8);
+
+	glDepthRange( 
+		*(GLclampd *)(pc + 0),
+		*(GLclampd *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_Frustum(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 48);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE(pc + 0);
+	__GLX_SWAP_DOUBLE(pc + 8);
+	__GLX_SWAP_DOUBLE(pc + 16);
+	__GLX_SWAP_DOUBLE(pc + 24);
+	__GLX_SWAP_DOUBLE(pc + 32);
+	__GLX_SWAP_DOUBLE(pc + 40);
+
+	glFrustum( 
+		*(GLdouble *)(pc + 0),
+		*(GLdouble *)(pc + 8),
+		*(GLdouble *)(pc + 16),
+		*(GLdouble *)(pc + 24),
+		*(GLdouble *)(pc + 32),
+		*(GLdouble *)(pc + 40)
+	);
+}
+
+void __glXDispSwap_LoadIdentity(GLbyte *pc)
+{
+	glLoadIdentity( 
+	);
+}
+
+void __glXDispSwap_LoadMatrixf(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 16);
+
+	glLoadMatrixf( 
+		(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_LoadMatrixd(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 128);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 16);
+
+	glLoadMatrixd( 
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_MatrixMode(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glMatrixMode( 
+		*(GLenum   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_MultMatrixf(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_FLOAT_ARRAY(pc + 0, 16);
+
+	glMultMatrixf( 
+		(GLfloat  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_MultMatrixd(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 128);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 16);
+
+	glMultMatrixd( 
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_Ortho(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 48);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE(pc + 0);
+	__GLX_SWAP_DOUBLE(pc + 8);
+	__GLX_SWAP_DOUBLE(pc + 16);
+	__GLX_SWAP_DOUBLE(pc + 24);
+	__GLX_SWAP_DOUBLE(pc + 32);
+	__GLX_SWAP_DOUBLE(pc + 40);
+
+	glOrtho( 
+		*(GLdouble *)(pc + 0),
+		*(GLdouble *)(pc + 8),
+		*(GLdouble *)(pc + 16),
+		*(GLdouble *)(pc + 24),
+		*(GLdouble *)(pc + 32),
+		*(GLdouble *)(pc + 40)
+	);
+}
+
+void __glXDispSwap_PopMatrix(GLbyte *pc)
+{
+	glPopMatrix( 
+	);
+}
+
+void __glXDispSwap_PushMatrix(GLbyte *pc)
+{
+	glPushMatrix( 
+	);
+}
+
+void __glXDispSwap_Rotated(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 32);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE(pc + 0);
+	__GLX_SWAP_DOUBLE(pc + 8);
+	__GLX_SWAP_DOUBLE(pc + 16);
+	__GLX_SWAP_DOUBLE(pc + 24);
+
+	glRotated( 
+		*(GLdouble *)(pc + 0),
+		*(GLdouble *)(pc + 8),
+		*(GLdouble *)(pc + 16),
+		*(GLdouble *)(pc + 24)
+	);
+}
+
+void __glXDispSwap_Rotatef(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_FLOAT(pc + 0);
+	__GLX_SWAP_FLOAT(pc + 4);
+	__GLX_SWAP_FLOAT(pc + 8);
+	__GLX_SWAP_FLOAT(pc + 12);
+
+	glRotatef( 
+		*(GLfloat  *)(pc + 0),
+		*(GLfloat  *)(pc + 4),
+		*(GLfloat  *)(pc + 8),
+		*(GLfloat  *)(pc + 12)
+	);
+}
+
+void __glXDispSwap_Scaled(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 24);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE(pc + 0);
+	__GLX_SWAP_DOUBLE(pc + 8);
+	__GLX_SWAP_DOUBLE(pc + 16);
+
+	glScaled( 
+		*(GLdouble *)(pc + 0),
+		*(GLdouble *)(pc + 8),
+		*(GLdouble *)(pc + 16)
+	);
+}
+
+void __glXDispSwap_Scalef(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_FLOAT(pc + 0);
+	__GLX_SWAP_FLOAT(pc + 4);
+	__GLX_SWAP_FLOAT(pc + 8);
+
+	glScalef( 
+		*(GLfloat  *)(pc + 0),
+		*(GLfloat  *)(pc + 4),
+		*(GLfloat  *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_Translated(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 24);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_DOUBLE(pc + 0);
+	__GLX_SWAP_DOUBLE(pc + 8);
+	__GLX_SWAP_DOUBLE(pc + 16);
+
+	glTranslated( 
+		*(GLdouble *)(pc + 0),
+		*(GLdouble *)(pc + 8),
+		*(GLdouble *)(pc + 16)
+	);
+}
+
+void __glXDispSwap_Translatef(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_FLOAT(pc + 0);
+	__GLX_SWAP_FLOAT(pc + 4);
+	__GLX_SWAP_FLOAT(pc + 8);
+
+	glTranslatef( 
+		*(GLfloat  *)(pc + 0),
+		*(GLfloat  *)(pc + 4),
+		*(GLfloat  *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_Viewport(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+	__GLX_SWAP_INT(pc + 12);
+
+	glViewport( 
+		*(GLint    *)(pc + 0),
+		*(GLint    *)(pc + 4),
+		*(GLsizei  *)(pc + 8),
+		*(GLsizei  *)(pc + 12)
+	);
+}
+
+void __glXDispSwap_PolygonOffset(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_FLOAT(pc + 0);
+	__GLX_SWAP_FLOAT(pc + 4);
+
+	glPolygonOffset( 
+		*(GLfloat  *)(pc + 0),
+		*(GLfloat  *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_CopyTexImage1D(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+	__GLX_SWAP_INT(pc + 12);
+	__GLX_SWAP_INT(pc + 16);
+	__GLX_SWAP_INT(pc + 20);
+	__GLX_SWAP_INT(pc + 24);
+
+	glCopyTexImage1D( 
+		*(GLenum   *)(pc + 0),
+		*(GLint    *)(pc + 4),
+		*(GLenum   *)(pc + 8),
+		*(GLint    *)(pc + 12),
+		*(GLint    *)(pc + 16),
+		*(GLsizei  *)(pc + 20),
+		*(GLint    *)(pc + 24)
+	);
+}
+
+void __glXDispSwap_CopyTexImage2D(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+	__GLX_SWAP_INT(pc + 12);
+	__GLX_SWAP_INT(pc + 16);
+	__GLX_SWAP_INT(pc + 20);
+	__GLX_SWAP_INT(pc + 24);
+	__GLX_SWAP_INT(pc + 28);
+
+	glCopyTexImage2D( 
+		*(GLenum   *)(pc + 0),
+		*(GLint    *)(pc + 4),
+		*(GLenum   *)(pc + 8),
+		*(GLint    *)(pc + 12),
+		*(GLint    *)(pc + 16),
+		*(GLsizei  *)(pc + 20),
+		*(GLsizei  *)(pc + 24),
+		*(GLint    *)(pc + 28)
+	);
+}
+
+void __glXDispSwap_CopyTexSubImage1D(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+	__GLX_SWAP_INT(pc + 12);
+	__GLX_SWAP_INT(pc + 16);
+	__GLX_SWAP_INT(pc + 20);
+
+	glCopyTexSubImage1D( 
+		*(GLenum   *)(pc + 0),
+		*(GLint    *)(pc + 4),
+		*(GLint    *)(pc + 8),
+		*(GLint    *)(pc + 12),
+		*(GLint    *)(pc + 16),
+		*(GLsizei  *)(pc + 20)
+	);
+}
+
+void __glXDispSwap_CopyTexSubImage2D(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+	__GLX_SWAP_INT(pc + 12);
+	__GLX_SWAP_INT(pc + 16);
+	__GLX_SWAP_INT(pc + 20);
+	__GLX_SWAP_INT(pc + 24);
+	__GLX_SWAP_INT(pc + 28);
+
+	glCopyTexSubImage2D( 
+		*(GLenum   *)(pc + 0),
+		*(GLint    *)(pc + 4),
+		*(GLint    *)(pc + 8),
+		*(GLint    *)(pc + 12),
+		*(GLint    *)(pc + 16),
+		*(GLint    *)(pc + 20),
+		*(GLsizei  *)(pc + 24),
+		*(GLsizei  *)(pc + 28)
+	);
+}
+
+void __glXDispSwap_BindTexture(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+
+	glBindTexture( 
+		*(GLenum   *)(pc + 0),
+		*(GLuint   *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_PrioritizeTextures(GLbyte *pc)
+{
+	GLsizei n;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	n = *(GLsizei *)(pc + 0);
+	__GLX_SWAP_INT_ARRAY(pc + 4, n);
+	__GLX_SWAP_FLOAT_ARRAY(pc + 4+n*4, n);
+
+	glPrioritizeTextures( 
+		*(GLsizei  *)(pc + 0),
+		(GLuint   *)(pc + 4),
+		(GLclampf *)(pc + 4+n*4)
+	);
+}
+
+void __glXDispSwap_Indexubv(GLbyte *pc)
+{
+	glIndexubv( 
+		(GLubyte  *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_BlendColor(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_FLOAT(pc + 0);
+	__GLX_SWAP_FLOAT(pc + 4);
+	__GLX_SWAP_FLOAT(pc + 8);
+	__GLX_SWAP_FLOAT(pc + 12);
+
+	glBlendColor( 
+		*(GLclampf *)(pc + 0),
+		*(GLclampf *)(pc + 4),
+		*(GLclampf *)(pc + 8),
+		*(GLclampf *)(pc + 12)
+	);
+}
+
+void __glXDispSwap_BlendEquation(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glBlendEquation( 
+		*(GLenum   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_ColorTableParameterfv(GLbyte *pc)
+{
+	GLenum pname;
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 4);
+	pname = *(GLenum *)(pc + 4);
+	compsize = __glColorTableParameterfv_size(pname);
+	if (compsize < 0) compsize = 0;
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
+
+	glColorTableParameterfv( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		(GLfloat  *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_ColorTableParameteriv(GLbyte *pc)
+{
+	GLenum pname;
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 4);
+	pname = *(GLenum *)(pc + 4);
+	compsize = __glColorTableParameteriv_size(pname);
+	if (compsize < 0) compsize = 0;
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
+
+	glColorTableParameteriv( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		(GLint    *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_CopyColorTable(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+	__GLX_SWAP_INT(pc + 12);
+	__GLX_SWAP_INT(pc + 16);
+
+	glCopyColorTable( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		*(GLint    *)(pc + 8),
+		*(GLint    *)(pc + 12),
+		*(GLsizei  *)(pc + 16)
+	);
+}
+
+void __glXDispSwap_CopyColorSubTable(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+	__GLX_SWAP_INT(pc + 12);
+	__GLX_SWAP_INT(pc + 16);
+
+	glCopyColorSubTable( 
+		*(GLenum   *)(pc + 0),
+		*(GLsizei  *)(pc + 4),
+		*(GLint    *)(pc + 8),
+		*(GLint    *)(pc + 12),
+		*(GLsizei  *)(pc + 16)
+	);
+}
+
+void __glXDispSwap_ConvolutionParameterf(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_FLOAT(pc + 8);
+
+	glConvolutionParameterf( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		*(GLfloat  *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_ConvolutionParameterfv(GLbyte *pc)
+{
+	GLenum pname;
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 4);
+	pname = *(GLenum *)(pc + 4);
+	compsize = __glConvolutionParameterfv_size(pname);
+	if (compsize < 0) compsize = 0;
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT_ARRAY(pc + 8, compsize);
+
+	glConvolutionParameterfv( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		(GLfloat  *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_ConvolutionParameteri(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+
+	glConvolutionParameteri( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		*(GLint    *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_ConvolutionParameteriv(GLbyte *pc)
+{
+	GLenum pname;
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 4);
+	pname = *(GLenum *)(pc + 4);
+	compsize = __glConvolutionParameteriv_size(pname);
+	if (compsize < 0) compsize = 0;
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT_ARRAY(pc + 8, compsize);
+
+	glConvolutionParameteriv( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		(GLint    *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_CopyConvolutionFilter1D(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+	__GLX_SWAP_INT(pc + 12);
+	__GLX_SWAP_INT(pc + 16);
+
+	glCopyConvolutionFilter1D( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		*(GLint    *)(pc + 8),
+		*(GLint    *)(pc + 12),
+		*(GLsizei  *)(pc + 16)
+	);
+}
+
+void __glXDispSwap_CopyConvolutionFilter2D(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+	__GLX_SWAP_INT(pc + 12);
+	__GLX_SWAP_INT(pc + 16);
+	__GLX_SWAP_INT(pc + 20);
+
+	glCopyConvolutionFilter2D( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		*(GLint    *)(pc + 8),
+		*(GLint    *)(pc + 12),
+		*(GLsizei  *)(pc + 16),
+		*(GLsizei  *)(pc + 20)
+	);
+}
+
+void __glXDispSwap_Histogram(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+
+	glHistogram( 
+		*(GLenum   *)(pc + 0),
+		*(GLsizei  *)(pc + 4),
+		*(GLenum   *)(pc + 8),
+		*(GLboolean *)(pc + 12)
+	);
+}
+
+void __glXDispSwap_Minmax(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+
+	glMinmax( 
+		*(GLenum   *)(pc + 0),
+		*(GLenum   *)(pc + 4),
+		*(GLboolean *)(pc + 8)
+	);
+}
+
+void __glXDispSwap_ResetHistogram(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glResetHistogram( 
+		*(GLenum   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_ResetMinmax(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glResetMinmax( 
+		*(GLenum   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_CopyTexSubImage3D(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+	__GLX_SWAP_INT(pc + 8);
+	__GLX_SWAP_INT(pc + 12);
+	__GLX_SWAP_INT(pc + 16);
+	__GLX_SWAP_INT(pc + 20);
+	__GLX_SWAP_INT(pc + 24);
+	__GLX_SWAP_INT(pc + 28);
+	__GLX_SWAP_INT(pc + 32);
+
+	glCopyTexSubImage3D( 
+		*(GLenum   *)(pc + 0),
+		*(GLint    *)(pc + 4),
+		*(GLint    *)(pc + 8),
+		*(GLint    *)(pc + 12),
+		*(GLint    *)(pc + 16),
+		*(GLint    *)(pc + 20),
+		*(GLint    *)(pc + 24),
+		*(GLsizei  *)(pc + 28),
+		*(GLsizei  *)(pc + 32)
+	);
+}
+
+void __glXDispSwap_ActiveTextureARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glActiveTextureARB( 
+		*(GLenum   *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_MultiTexCoord1dvARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 12);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_INT(pc + 8);
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 1);
+
+	glMultiTexCoord1dvARB( 
+		*(GLenum   *)(pc + 8),
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_MultiTexCoord1fvARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 1);
+
+	glMultiTexCoord1fvARB( 
+		*(GLenum   *)(pc + 0),
+		(GLfloat  *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_MultiTexCoord1ivARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT_ARRAY(pc + 4, 1);
+
+	glMultiTexCoord1ivARB( 
+		*(GLenum   *)(pc + 0),
+		(GLint    *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_MultiTexCoord1svARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_SHORT_ARRAY(pc + 4, 1);
+
+	glMultiTexCoord1svARB( 
+		*(GLenum   *)(pc + 0),
+		(GLshort  *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_MultiTexCoord2dvARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 20);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_INT(pc + 16);
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 2);
+
+	glMultiTexCoord2dvARB( 
+		*(GLenum   *)(pc + 16),
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_MultiTexCoord2fvARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 2);
+
+	glMultiTexCoord2fvARB( 
+		*(GLenum   *)(pc + 0),
+		(GLfloat  *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_MultiTexCoord2ivARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT_ARRAY(pc + 4, 2);
+
+	glMultiTexCoord2ivARB( 
+		*(GLenum   *)(pc + 0),
+		(GLint    *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_MultiTexCoord2svARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_SHORT_ARRAY(pc + 4, 2);
+
+	glMultiTexCoord2svARB( 
+		*(GLenum   *)(pc + 0),
+		(GLshort  *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_MultiTexCoord3dvARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 28);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_INT(pc + 24);
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 3);
+
+	glMultiTexCoord3dvARB( 
+		*(GLenum   *)(pc + 24),
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_MultiTexCoord3fvARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 3);
+
+	glMultiTexCoord3fvARB( 
+		*(GLenum   *)(pc + 0),
+		(GLfloat  *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_MultiTexCoord3ivARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT_ARRAY(pc + 4, 3);
+
+	glMultiTexCoord3ivARB( 
+		*(GLenum   *)(pc + 0),
+		(GLint    *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_MultiTexCoord3svARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_SHORT_ARRAY(pc + 4, 3);
+
+	glMultiTexCoord3svARB( 
+		*(GLenum   *)(pc + 0),
+		(GLshort  *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_MultiTexCoord4dvARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+#ifdef __GLX_ALIGN64
+	if ((unsigned long)(pc) & 7) {
+	    __GLX_MEM_COPY(pc-4, pc, 36);
+	    pc -= 4;
+	}
+#endif
+	__GLX_SWAP_INT(pc + 32);
+	__GLX_SWAP_DOUBLE_ARRAY(pc + 0, 4);
+
+	glMultiTexCoord4dvARB( 
+		*(GLenum   *)(pc + 32),
+		(GLdouble *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_MultiTexCoord4fvARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT_ARRAY(pc + 4, 4);
+
+	glMultiTexCoord4fvARB( 
+		*(GLenum   *)(pc + 0),
+		(GLfloat  *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_MultiTexCoord4ivARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_INT_ARRAY(pc + 4, 4);
+
+	glMultiTexCoord4ivARB( 
+		*(GLenum   *)(pc + 0),
+		(GLint    *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_MultiTexCoord4svARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_SHORT_ARRAY(pc + 4, 4);
+
+	glMultiTexCoord4svARB( 
+		*(GLenum   *)(pc + 0),
+		(GLshort  *)(pc + 4)
+	);
+}
+
+
+/*
+ * Extensions
+ */
+
+#ifndef MISSING_GL_EXTS
+
+void __glXDispSwap_PointParameterfARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_SWAP_INT(pc + 0);
+	__GLX_SWAP_FLOAT(pc + 4);
+	glPointParameterfARB(
+		*(GLenum *)(pc + 0),
+		*(GLfloat *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_PointParameterfvARB(GLbyte *pc)
+{
+	GLenum pname;
+	GLint compsize;
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+	pname = *(GLenum *)(pc + 0);
+	compsize = __glPointParameterfvEXT_size(pname);
+	if (compsize < 0) compsize = 0;
+	__GLX_SWAP_FLOAT_ARRAY(pc + 4, compsize);
+
+	glPointParameterfvARB(
+		*(GLenum *)(pc + 0),
+		(GLfloat *)(pc + 4)
+	);
+}
+
+void __glXDispSwap_ActiveStencilFaceEXT(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+
+	__GLX_SWAP_INT(pc + 0);
+
+	glActiveStencilFaceEXT(
+		*(GLenum *)(pc + 0)
+	);
+}
+
+void __glXDispSwap_WindowPos3fARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_SWAP_FLOAT(pc + 0);
+	__GLX_SWAP_FLOAT(pc + 4);
+	__GLX_SWAP_FLOAT(pc + 8);
+	glWindowPos3fARB(
+		*(GLfloat *)(pc + 0),
+		*(GLfloat *)(pc + 4),
+		*(GLfloat *)(pc + 8)
+	);
+}
+#endif /* !MISSING_GL_EXTS */
+
+void __glXDispSwap_SampleCoverageARB(GLbyte *pc)
+{
+	__GLX_DECLARE_SWAP_VARIABLES;
+	__GLX_SWAP_FLOAT(pc + 0);
+	__GLX_SWAP_INT(pc + 4);
+
+	glSampleCoverageARB(
+		*(GLfloat *)(pc + 0),
+		*(GLboolean *)(pc + 4)
+	);
+}