/* $XFree86: xc/programs/Xserver/GL/glx/g_render.c,v 1.4 2001/03/21 16:29:35 dawes Exp $ */
/* DO NOT EDIT - THIS FILE IS AUTOMATICALLY GENERATED */
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
** 
** http://oss.sgi.com/projects/FreeB
** 
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
** 
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
** 
** Additional Notice Provisions: This software was created using the
** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
** not been independently verified as being compliant with the OpenGL(R)
** version 1.2.1 Specification.
*/

#define NEED_REPLIES
#include "glxserver.h"
#include "g_disptab.h"
#include "glapitable.h"
#include "glxext.h"
#include "g_disptab_EXT.h"
#include "unpack.h"
#include "impsize.h"
#include "singlesize.h"

void __glXDisp_CallList(GLbyte *pc)
{
	(*__glRenderTable->CallList)( 
		*(GLuint   *)(pc + 0)
	);
}

void __glXDisp_ListBase(GLbyte *pc)
{
	(*__glRenderTable->ListBase)( 
		*(GLuint   *)(pc + 0)
	);
}

void __glXDisp_Begin(GLbyte *pc)
{
	(*__glRenderTable->Begin)( 
		*(GLenum   *)(pc + 0)
	);
}

#define __GLX_SWAP_GLbyte(ptr)
#define __GLX_SWAP_GLshort(ptr)  __GLX_SWAP_SHORT(ptr)
#define __GLX_SWAP_GLint(ptr)    __GLX_SWAP_INT(ptr)
#define __GLX_SWAP_GLubyte(ptr)
#define __GLX_SWAP_GLushort(ptr) __GLX_SWAP_SHORT(ptr)
#define __GLX_SWAP_GLuint(ptr)   __GLX_SWAP_INT(ptr)
#define __GLX_SWAP_GLdouble(ptr) __GLX_SWAP_DOUBLE(ptr)
#define __GLX_SWAP_GLfloat(ptr)  __GLX_SWAP_FLOAT(ptr)

#define __GLX_SWAP_GLbyte_ARRAY(ptr,count)   (void) swapEnd; (void) swapPC; (void) sw;
#define __GLX_SWAP_GLshort_ARRAY(ptr,count)  __GLX_SWAP_SHORT_ARRAY(ptr,count)
#define __GLX_SWAP_GLint_ARRAY(ptr,count)    __GLX_SWAP_INT_ARRAY(ptr,count)
#define __GLX_SWAP_GLenum_ARRAY(ptr,count)   __GLX_SWAP_INT_ARRAY(ptr,count)
#define __GLX_SWAP_GLubyte_ARRAY(ptr,count)  (void) swapEnd; (void) swapPC; (void) sw;
#define __GLX_SWAP_GLushort_ARRAY(ptr,count) __GLX_SWAP_SHORT_ARRAY(ptr,count)
#define __GLX_SWAP_GLuint_ARRAY(ptr,count)   __GLX_SWAP_INT_ARRAY(ptr,count)
#define __GLX_SWAP_GLdouble_ARRAY(ptr,count) __GLX_SWAP_DOUBLE_ARRAY(ptr,count)
#define __GLX_SWAP_GLfloat_ARRAY(ptr,count)  __GLX_SWAP_FLOAT_ARRAY(ptr,count)

#ifdef __GLX_ALIGN64
/* If type is not GLdouble, the compiler should optimize this away.
 */
# define GLX_DO_ALIGN_MAGIC(count, type) \
	do { if ( (sizeof(type) == 8) && ((unsigned long)(pc) & 7)) { \
	    __GLX_MEM_COPY(pc-4, pc, (count * sizeof( type ) ); \
	    pc -= 4; \
	} } while( 0 )
#else
# define GLX_DO_ALIGN_MAGIC(count, type)
#endif

#define dispatch_template_1( name, func, type ) \
    void __glXDisp_ ## name ( GLbyte * pc ) \
    { \
	GLX_DO_ALIGN_MAGIC( 1, type ); \
	func ( (type *) pc ); \
    } \
    void __glXDispSwap_ ## name ( GLbyte * pc ) \
    { \
	__GLX_DECLARE_SWAP_VARIABLES; \
	GLX_DO_ALIGN_MAGIC( 1, type ); \
	__GLX_SWAP_ ## type ( pc ); \
	func ( (type *) pc ); \
    }

#define dispatch_template_3( name, func, type ) \
    void __glXDisp_ ## name ( GLbyte * pc ) \
    { \
	GLX_DO_ALIGN_MAGIC( 3, type ); \
	func ( (type *) pc ); \
    } \
    void __glXDispSwap_ ## name ( GLbyte * pc ) \
    { \
	__GLX_DECLARE_SWAP_VARIABLES; \
	__GLX_DECLARE_SWAP_ARRAY_VARIABLES; \
	GLX_DO_ALIGN_MAGIC( 3, type ); \
	__GLX_SWAP_ ## type ## _ARRAY(pc, 3); \
	func ( (type *) pc ); \
    }

#define dispatch_template_4( name, func, type ) \
    void __glXDisp_ ## name ( GLbyte * pc ) \
    { \
	GLX_DO_ALIGN_MAGIC( 4, type ); \
	func ( (type *) pc ); \
    } \
    void __glXDispSwap_ ## name ( GLbyte * pc ) \
    { \
	__GLX_DECLARE_SWAP_VARIABLES; \
	__GLX_DECLARE_SWAP_ARRAY_VARIABLES; \
	GLX_DO_ALIGN_MAGIC( 4, type ); \
	__GLX_SWAP_ ## type ## _ARRAY(pc, 4); \
	func ( (type *) pc ); \
    }

#define dispatch_template_4s( name, func, type ) \
    void __glXDisp_ ## name ( GLbyte * pc ) \
    { \
	GLX_DO_ALIGN_MAGIC( 4, type ); \
	func ( ((type *) pc)[0], ((type *) pc)[1], \
		     ((type *) pc)[2], ((type *) pc)[3] ); \
    } \
    void __glXDispSwap_ ## name ( GLbyte * pc ) \
    { \
	__GLX_DECLARE_SWAP_VARIABLES; \
	__GLX_DECLARE_SWAP_ARRAY_VARIABLES; \
	GLX_DO_ALIGN_MAGIC( 4, type ); \
	__GLX_SWAP_ ## type ## _ARRAY(pc, 4); \
	func ( ((type *) pc)[0], ((type *) pc)[1], \
		     ((type *) pc)[2], ((type *) pc)[3] ); \
    }

/**
 * \bug All of the enum1 templates need to be updated to handle the case where
 * \c type is \c GLdouble.  When the type is a double, the data comes before
 * the enum.  This is also the reason the invocation of the
 * \c GLX_DO_ALIGN_MAGIC macro was removed.
 */
#define dispatch_template_enum1_1s( name, func, type ) \
    void __glXDisp_ ## name ( GLbyte * pc ) \
    { \
	func ( *(GLenum *) (pc + 0), \
		     *(type *)   (pc + 4) ); \
    } \
    void __glXDispSwap_ ## name ( GLbyte * pc ) \
    { \
	__GLX_DECLARE_SWAP_VARIABLES; \
	__GLX_SWAP_INT      (pc + 0); \
	__GLX_SWAP_ ## type (pc + 4); \
	func ( *(GLenum *) (pc + 0), \
		     *(type *)   (pc + 4) ); \
    }

#define dispatch_template_enum1_Vv( name, func, type ) \
    void __glXDisp_ ## name ( GLbyte * pc ) \
    { \
	func ( *(GLenum *) (pc + 0), \
		      (type *)   (pc + 4) ); \
    } \
    void __glXDispSwap_ ## name ( GLbyte * pc ) \
    { \
	GLenum pname; GLint compsize; \
	__GLX_DECLARE_SWAP_VARIABLES; \
	__GLX_DECLARE_SWAP_ARRAY_VARIABLES; \
	__GLX_SWAP_INT(pc + 0); \
	pname = *(GLenum *)(pc + 0); \
	compsize = __gl ## name ## _size(pname); \
	if (compsize < 0) compsize = 0; \
	__GLX_SWAP_ ## type ## _ARRAY(pc + 4, compsize); \
	func ( *(GLenum *) (pc + 0), \
		      (type *)   (pc + 4) ); \
    }

dispatch_template_1( FogCoordfv,         (*__glRenderTable->FogCoordfvEXT), GLfloat )
dispatch_template_1( FogCoorddv,         (*__glRenderTable->FogCoorddvEXT), GLdouble )
dispatch_template_3( SecondaryColor3bv,  (*__glRenderTable->SecondaryColor3bvEXT), GLbyte )
dispatch_template_3( SecondaryColor3sv,  (*__glRenderTable->SecondaryColor3svEXT), GLshort )
dispatch_template_3( SecondaryColor3iv,  (*__glRenderTable->SecondaryColor3ivEXT), GLint )
dispatch_template_3( SecondaryColor3ubv, (*__glRenderTable->SecondaryColor3ubvEXT), GLubyte )
dispatch_template_3( SecondaryColor3usv, (*__glRenderTable->SecondaryColor3usvEXT), GLushort )
dispatch_template_3( SecondaryColor3uiv, (*__glRenderTable->SecondaryColor3uivEXT), GLuint )
dispatch_template_3( SecondaryColor3fv,  (*__glRenderTable->SecondaryColor3fvEXT), GLfloat )
dispatch_template_3( SecondaryColor3dv,  (*__glRenderTable->SecondaryColor3dvEXT), GLdouble )

dispatch_template_4s( BlendFuncSeparate,  (*__glRenderTable->BlendFuncSeparateEXT), GLenum )

void __glXDisp_Color3bv(GLbyte *pc)
{
	(*__glRenderTable->Color3bv)( 
		(GLbyte   *)(pc + 0)
	);
}

void __glXDisp_Color3dv(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 24);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->Color3dv)( 
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_Color3fv(GLbyte *pc)
{
	(*__glRenderTable->Color3fv)( 
		(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_Color3iv(GLbyte *pc)
{
	(*__glRenderTable->Color3iv)( 
		(GLint    *)(pc + 0)
	);
}

void __glXDisp_Color3sv(GLbyte *pc)
{
	(*__glRenderTable->Color3sv)( 
		(GLshort  *)(pc + 0)
	);
}

void __glXDisp_Color3ubv(GLbyte *pc)
{
	(*__glRenderTable->Color3ubv)( 
		(GLubyte  *)(pc + 0)
	);
}

void __glXDisp_Color3uiv(GLbyte *pc)
{
	(*__glRenderTable->Color3uiv)( 
		(GLuint   *)(pc + 0)
	);
}

void __glXDisp_Color3usv(GLbyte *pc)
{
	(*__glRenderTable->Color3usv)( 
		(GLushort *)(pc + 0)
	);
}

void __glXDisp_Color4bv(GLbyte *pc)
{
	(*__glRenderTable->Color4bv)( 
		(GLbyte   *)(pc + 0)
	);
}

void __glXDisp_Color4dv(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 32);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->Color4dv)( 
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_Color4fv(GLbyte *pc)
{
	(*__glRenderTable->Color4fv)( 
		(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_Color4iv(GLbyte *pc)
{
	(*__glRenderTable->Color4iv)( 
		(GLint    *)(pc + 0)
	);
}

void __glXDisp_Color4sv(GLbyte *pc)
{
	(*__glRenderTable->Color4sv)( 
		(GLshort  *)(pc + 0)
	);
}

void __glXDisp_Color4ubv(GLbyte *pc)
{
	(*__glRenderTable->Color4ubv)( 
		(GLubyte  *)(pc + 0)
	);
}

void __glXDisp_Color4uiv(GLbyte *pc)
{
	(*__glRenderTable->Color4uiv)( 
		(GLuint   *)(pc + 0)
	);
}

void __glXDisp_Color4usv(GLbyte *pc)
{
	(*__glRenderTable->Color4usv)( 
		(GLushort *)(pc + 0)
	);
}

void __glXDisp_EdgeFlagv(GLbyte *pc)
{
	(*__glRenderTable->EdgeFlagv)( 
		(GLboolean *)(pc + 0)
	);
}

void __glXDisp_End(GLbyte *pc)
{
	(*__glRenderTable->End)( 
	);
}

void __glXDisp_Indexdv(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 8);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->Indexdv)( 
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_Indexfv(GLbyte *pc)
{
	(*__glRenderTable->Indexfv)( 
		(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_Indexiv(GLbyte *pc)
{
	(*__glRenderTable->Indexiv)( 
		(GLint    *)(pc + 0)
	);
}

void __glXDisp_Indexsv(GLbyte *pc)
{
	(*__glRenderTable->Indexsv)( 
		(GLshort  *)(pc + 0)
	);
}

void __glXDisp_Normal3bv(GLbyte *pc)
{
	(*__glRenderTable->Normal3bv)( 
		(GLbyte   *)(pc + 0)
	);
}

void __glXDisp_Normal3dv(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 24);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->Normal3dv)( 
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_Normal3fv(GLbyte *pc)
{
	(*__glRenderTable->Normal3fv)( 
		(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_Normal3iv(GLbyte *pc)
{
	(*__glRenderTable->Normal3iv)( 
		(GLint    *)(pc + 0)
	);
}

void __glXDisp_Normal3sv(GLbyte *pc)
{
	(*__glRenderTable->Normal3sv)( 
		(GLshort  *)(pc + 0)
	);
}

void __glXDisp_RasterPos2dv(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 16);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->RasterPos2dv)( 
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_RasterPos2fv(GLbyte *pc)
{
	(*__glRenderTable->RasterPos2fv)( 
		(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_RasterPos2iv(GLbyte *pc)
{
	(*__glRenderTable->RasterPos2iv)( 
		(GLint    *)(pc + 0)
	);
}

void __glXDisp_RasterPos2sv(GLbyte *pc)
{
	(*__glRenderTable->RasterPos2sv)( 
		(GLshort  *)(pc + 0)
	);
}

void __glXDisp_RasterPos3dv(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 24);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->RasterPos3dv)( 
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_RasterPos3fv(GLbyte *pc)
{
	(*__glRenderTable->RasterPos3fv)( 
		(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_RasterPos3iv(GLbyte *pc)
{
	(*__glRenderTable->RasterPos3iv)( 
		(GLint    *)(pc + 0)
	);
}

void __glXDisp_RasterPos3sv(GLbyte *pc)
{
	(*__glRenderTable->RasterPos3sv)( 
		(GLshort  *)(pc + 0)
	);
}

void __glXDisp_RasterPos4dv(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 32);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->RasterPos4dv)( 
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_RasterPos4fv(GLbyte *pc)
{
	(*__glRenderTable->RasterPos4fv)( 
		(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_RasterPos4iv(GLbyte *pc)
{
	(*__glRenderTable->RasterPos4iv)( 
		(GLint    *)(pc + 0)
	);
}

void __glXDisp_RasterPos4sv(GLbyte *pc)
{
	(*__glRenderTable->RasterPos4sv)( 
		(GLshort  *)(pc + 0)
	);
}

void __glXDisp_Rectdv(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 32);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->Rectdv)( 
		(GLdouble *)(pc + 0),
		(GLdouble *)(pc + 16)
	);
}

void __glXDisp_Rectfv(GLbyte *pc)
{
	(*__glRenderTable->Rectfv)( 
		(GLfloat  *)(pc + 0),
		(GLfloat  *)(pc + 8)
	);
}

void __glXDisp_Rectiv(GLbyte *pc)
{
	(*__glRenderTable->Rectiv)( 
		(GLint    *)(pc + 0),
		(GLint    *)(pc + 8)
	);
}

void __glXDisp_Rectsv(GLbyte *pc)
{
	(*__glRenderTable->Rectsv)( 
		(GLshort  *)(pc + 0),
		(GLshort  *)(pc + 4)
	);
}

void __glXDisp_TexCoord1dv(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 8);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->TexCoord1dv)( 
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_TexCoord1fv(GLbyte *pc)
{
	(*__glRenderTable->TexCoord1fv)( 
		(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_TexCoord1iv(GLbyte *pc)
{
	(*__glRenderTable->TexCoord1iv)( 
		(GLint    *)(pc + 0)
	);
}

void __glXDisp_TexCoord1sv(GLbyte *pc)
{
	(*__glRenderTable->TexCoord1sv)( 
		(GLshort  *)(pc + 0)
	);
}

void __glXDisp_TexCoord2dv(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 16);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->TexCoord2dv)( 
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_TexCoord2fv(GLbyte *pc)
{
	(*__glRenderTable->TexCoord2fv)( 
		(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_TexCoord2iv(GLbyte *pc)
{
	(*__glRenderTable->TexCoord2iv)( 
		(GLint    *)(pc + 0)
	);
}

void __glXDisp_TexCoord2sv(GLbyte *pc)
{
	(*__glRenderTable->TexCoord2sv)( 
		(GLshort  *)(pc + 0)
	);
}

void __glXDisp_TexCoord3dv(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 24);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->TexCoord3dv)( 
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_TexCoord3fv(GLbyte *pc)
{
	(*__glRenderTable->TexCoord3fv)( 
		(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_TexCoord3iv(GLbyte *pc)
{
	(*__glRenderTable->TexCoord3iv)( 
		(GLint    *)(pc + 0)
	);
}

void __glXDisp_TexCoord3sv(GLbyte *pc)
{
	(*__glRenderTable->TexCoord3sv)( 
		(GLshort  *)(pc + 0)
	);
}

void __glXDisp_TexCoord4dv(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 32);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->TexCoord4dv)( 
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_TexCoord4fv(GLbyte *pc)
{
	(*__glRenderTable->TexCoord4fv)( 
		(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_TexCoord4iv(GLbyte *pc)
{
	(*__glRenderTable->TexCoord4iv)( 
		(GLint    *)(pc + 0)
	);
}

void __glXDisp_TexCoord4sv(GLbyte *pc)
{
	(*__glRenderTable->TexCoord4sv)( 
		(GLshort  *)(pc + 0)
	);
}

void __glXDisp_Vertex2dv(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 16);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->Vertex2dv)( 
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_Vertex2fv(GLbyte *pc)
{
	(*__glRenderTable->Vertex2fv)( 
		(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_Vertex2iv(GLbyte *pc)
{
	(*__glRenderTable->Vertex2iv)( 
		(GLint    *)(pc + 0)
	);
}

void __glXDisp_Vertex2sv(GLbyte *pc)
{
	(*__glRenderTable->Vertex2sv)( 
		(GLshort  *)(pc + 0)
	);
}

void __glXDisp_Vertex3dv(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 24);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->Vertex3dv)( 
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_Vertex3fv(GLbyte *pc)
{
	(*__glRenderTable->Vertex3fv)( 
		(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_Vertex3iv(GLbyte *pc)
{
	(*__glRenderTable->Vertex3iv)( 
		(GLint    *)(pc + 0)
	);
}

void __glXDisp_Vertex3sv(GLbyte *pc)
{
	(*__glRenderTable->Vertex3sv)( 
		(GLshort  *)(pc + 0)
	);
}

void __glXDisp_Vertex4dv(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 32);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->Vertex4dv)( 
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_Vertex4fv(GLbyte *pc)
{
	(*__glRenderTable->Vertex4fv)( 
		(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_Vertex4iv(GLbyte *pc)
{
	(*__glRenderTable->Vertex4iv)( 
		(GLint    *)(pc + 0)
	);
}

void __glXDisp_Vertex4sv(GLbyte *pc)
{
	(*__glRenderTable->Vertex4sv)( 
		(GLshort  *)(pc + 0)
	);
}

void __glXDisp_ClipPlane(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 36);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->ClipPlane)( 
		*(GLenum   *)(pc + 32),
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_ColorMaterial(GLbyte *pc)
{
	(*__glRenderTable->ColorMaterial)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4)
	);
}

void __glXDisp_CullFace(GLbyte *pc)
{
	(*__glRenderTable->CullFace)( 
		*(GLenum   *)(pc + 0)
	);
}

void __glXDisp_Fogf(GLbyte *pc)
{
	(*__glRenderTable->Fogf)( 
		*(GLenum   *)(pc + 0),
		*(GLfloat  *)(pc + 4)
	);
}

void __glXDisp_Fogfv(GLbyte *pc)
{
	(*__glRenderTable->Fogfv)( 
		*(GLenum   *)(pc + 0),
		(GLfloat  *)(pc + 4)
	);
}

void __glXDisp_Fogi(GLbyte *pc)
{
	(*__glRenderTable->Fogi)( 
		*(GLenum   *)(pc + 0),
		*(GLint    *)(pc + 4)
	);
}

void __glXDisp_Fogiv(GLbyte *pc)
{
	(*__glRenderTable->Fogiv)( 
		*(GLenum   *)(pc + 0),
		(GLint    *)(pc + 4)
	);
}

void __glXDisp_FrontFace(GLbyte *pc)
{
	(*__glRenderTable->FrontFace)( 
		*(GLenum   *)(pc + 0)
	);
}

void __glXDisp_Hint(GLbyte *pc)
{
	(*__glRenderTable->Hint)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4)
	);
}

void __glXDisp_Lightf(GLbyte *pc)
{
	(*__glRenderTable->Lightf)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		*(GLfloat  *)(pc + 8)
	);
}

void __glXDisp_Lightfv(GLbyte *pc)
{
	(*__glRenderTable->Lightfv)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		(GLfloat  *)(pc + 8)
	);
}

void __glXDisp_Lighti(GLbyte *pc)
{
	(*__glRenderTable->Lighti)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		*(GLint    *)(pc + 8)
	);
}

void __glXDisp_Lightiv(GLbyte *pc)
{
	(*__glRenderTable->Lightiv)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		(GLint    *)(pc + 8)
	);
}

void __glXDisp_LightModelf(GLbyte *pc)
{
	(*__glRenderTable->LightModelf)( 
		*(GLenum   *)(pc + 0),
		*(GLfloat  *)(pc + 4)
	);
}

void __glXDisp_LightModelfv(GLbyte *pc)
{
	(*__glRenderTable->LightModelfv)( 
		*(GLenum   *)(pc + 0),
		(GLfloat  *)(pc + 4)
	);
}

void __glXDisp_LightModeli(GLbyte *pc)
{
	(*__glRenderTable->LightModeli)( 
		*(GLenum   *)(pc + 0),
		*(GLint    *)(pc + 4)
	);
}

void __glXDisp_LightModeliv(GLbyte *pc)
{
	(*__glRenderTable->LightModeliv)( 
		*(GLenum   *)(pc + 0),
		(GLint    *)(pc + 4)
	);
}

void __glXDisp_LineStipple(GLbyte *pc)
{
	(*__glRenderTable->LineStipple)( 
		*(GLint    *)(pc + 0),
		*(GLushort *)(pc + 4)
	);
}

void __glXDisp_LineWidth(GLbyte *pc)
{
	(*__glRenderTable->LineWidth)( 
		*(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_Materialf(GLbyte *pc)
{
	(*__glRenderTable->Materialf)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		*(GLfloat  *)(pc + 8)
	);
}

void __glXDisp_Materialfv(GLbyte *pc)
{
	(*__glRenderTable->Materialfv)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		(GLfloat  *)(pc + 8)
	);
}

void __glXDisp_Materiali(GLbyte *pc)
{
	(*__glRenderTable->Materiali)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		*(GLint    *)(pc + 8)
	);
}

void __glXDisp_Materialiv(GLbyte *pc)
{
	(*__glRenderTable->Materialiv)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		(GLint    *)(pc + 8)
	);
}

void __glXDisp_PointSize(GLbyte *pc)
{
	(*__glRenderTable->PointSize)( 
		*(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_PolygonMode(GLbyte *pc)
{
	(*__glRenderTable->PolygonMode)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4)
	);
}

void __glXDisp_Scissor(GLbyte *pc)
{
	(*__glRenderTable->Scissor)( 
		*(GLint    *)(pc + 0),
		*(GLint    *)(pc + 4),
		*(GLsizei  *)(pc + 8),
		*(GLsizei  *)(pc + 12)
	);
}

void __glXDisp_ShadeModel(GLbyte *pc)
{
	(*__glRenderTable->ShadeModel)( 
		*(GLenum   *)(pc + 0)
	);
}

void __glXDisp_TexParameterf(GLbyte *pc)
{
	(*__glRenderTable->TexParameterf)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		*(GLfloat  *)(pc + 8)
	);
}

void __glXDisp_TexParameterfv(GLbyte *pc)
{
	(*__glRenderTable->TexParameterfv)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		(GLfloat  *)(pc + 8)
	);
}

void __glXDisp_TexParameteri(GLbyte *pc)
{
	(*__glRenderTable->TexParameteri)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		*(GLint    *)(pc + 8)
	);
}

void __glXDisp_TexParameteriv(GLbyte *pc)
{
	(*__glRenderTable->TexParameteriv)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		(GLint    *)(pc + 8)
	);
}

void __glXDisp_TexEnvf(GLbyte *pc)
{
	(*__glRenderTable->TexEnvf)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		*(GLfloat  *)(pc + 8)
	);
}

void __glXDisp_TexEnvfv(GLbyte *pc)
{
	(*__glRenderTable->TexEnvfv)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		(GLfloat  *)(pc + 8)
	);
}

void __glXDisp_TexEnvi(GLbyte *pc)
{
	(*__glRenderTable->TexEnvi)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		*(GLint    *)(pc + 8)
	);
}

void __glXDisp_TexEnviv(GLbyte *pc)
{
	(*__glRenderTable->TexEnviv)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		(GLint    *)(pc + 8)
	);
}

void __glXDisp_TexGend(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 16);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->TexGend)( 
		*(GLenum   *)(pc + 8),
		*(GLenum   *)(pc + 12),
		*(GLdouble *)(pc + 0)
	);
}

void __glXDisp_TexGendv(GLbyte *pc)
{
	GLenum pname;
	GLint cmdlen;
	GLint compsize;

	pname = *(GLenum *)(pc + 4);
	compsize = __glTexGendv_size(pname);
	if (compsize < 0) compsize = 0;
	cmdlen = __GLX_PAD(8+compsize*8);

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, cmdlen);
	    pc -= 4;
	}
#endif

	(*__glRenderTable->TexGendv)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		(GLdouble *)(pc + 8)
	);
}

void __glXDisp_TexGenf(GLbyte *pc)
{
	(*__glRenderTable->TexGenf)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		*(GLfloat  *)(pc + 8)
	);
}

void __glXDisp_TexGenfv(GLbyte *pc)
{
	(*__glRenderTable->TexGenfv)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		(GLfloat  *)(pc + 8)
	);
}

void __glXDisp_TexGeni(GLbyte *pc)
{
	(*__glRenderTable->TexGeni)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		*(GLint    *)(pc + 8)
	);
}

void __glXDisp_TexGeniv(GLbyte *pc)
{
	(*__glRenderTable->TexGeniv)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		(GLint    *)(pc + 8)
	);
}

void __glXDisp_InitNames(GLbyte *pc)
{
	(*__glRenderTable->InitNames)( 
	);
}

void __glXDisp_LoadName(GLbyte *pc)
{
	(*__glRenderTable->LoadName)( 
		*(GLuint   *)(pc + 0)
	);
}

void __glXDisp_PassThrough(GLbyte *pc)
{
	(*__glRenderTable->PassThrough)( 
		*(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_PopName(GLbyte *pc)
{
	(*__glRenderTable->PopName)( 
	);
}

void __glXDisp_PushName(GLbyte *pc)
{
	(*__glRenderTable->PushName)( 
		*(GLuint   *)(pc + 0)
	);
}

void __glXDisp_DrawBuffer(GLbyte *pc)
{
	(*__glRenderTable->DrawBuffer)( 
		*(GLenum   *)(pc + 0)
	);
}

void __glXDisp_Clear(GLbyte *pc)
{
	(*__glRenderTable->Clear)( 
		*(GLbitfield *)(pc + 0)
	);
}

void __glXDisp_ClearAccum(GLbyte *pc)
{
	(*__glRenderTable->ClearAccum)( 
		*(GLfloat  *)(pc + 0),
		*(GLfloat  *)(pc + 4),
		*(GLfloat  *)(pc + 8),
		*(GLfloat  *)(pc + 12)
	);
}

void __glXDisp_ClearIndex(GLbyte *pc)
{
	(*__glRenderTable->ClearIndex)( 
		*(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_ClearColor(GLbyte *pc)
{
	(*__glRenderTable->ClearColor)( 
		*(GLclampf *)(pc + 0),
		*(GLclampf *)(pc + 4),
		*(GLclampf *)(pc + 8),
		*(GLclampf *)(pc + 12)
	);
}

void __glXDisp_ClearStencil(GLbyte *pc)
{
	(*__glRenderTable->ClearStencil)( 
		*(GLint    *)(pc + 0)
	);
}

void __glXDisp_ClearDepth(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 8);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->ClearDepth)( 
		*(GLclampd *)(pc + 0)
	);
}

void __glXDisp_StencilMask(GLbyte *pc)
{
	(*__glRenderTable->StencilMask)( 
		*(GLuint   *)(pc + 0)
	);
}

void __glXDisp_ColorMask(GLbyte *pc)
{
	(*__glRenderTable->ColorMask)( 
		*(GLboolean *)(pc + 0),
		*(GLboolean *)(pc + 1),
		*(GLboolean *)(pc + 2),
		*(GLboolean *)(pc + 3)
	);
}

void __glXDisp_DepthMask(GLbyte *pc)
{
	(*__glRenderTable->DepthMask)( 
		*(GLboolean *)(pc + 0)
	);
}

void __glXDisp_IndexMask(GLbyte *pc)
{
	(*__glRenderTable->IndexMask)( 
		*(GLuint   *)(pc + 0)
	);
}

void __glXDisp_Accum(GLbyte *pc)
{
	(*__glRenderTable->Accum)( 
		*(GLenum   *)(pc + 0),
		*(GLfloat  *)(pc + 4)
	);
}

void __glXDisp_Disable(GLbyte *pc)
{
	(*__glRenderTable->Disable)( 
		*(GLenum   *)(pc + 0)
	);
}

void __glXDisp_Enable(GLbyte *pc)
{
	(*__glRenderTable->Enable)( 
		*(GLenum   *)(pc + 0)
	);
}

void __glXDisp_PopAttrib(GLbyte *pc)
{
	(*__glRenderTable->PopAttrib)( 
	);
}

void __glXDisp_PushAttrib(GLbyte *pc)
{
	(*__glRenderTable->PushAttrib)( 
		*(GLbitfield *)(pc + 0)
	);
}

void __glXDisp_MapGrid1d(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 20);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->MapGrid1d)( 
		*(GLint    *)(pc + 16),
		*(GLdouble *)(pc + 0),
		*(GLdouble *)(pc + 8)
	);
}

void __glXDisp_MapGrid1f(GLbyte *pc)
{
	(*__glRenderTable->MapGrid1f)( 
		*(GLint    *)(pc + 0),
		*(GLfloat  *)(pc + 4),
		*(GLfloat  *)(pc + 8)
	);
}

void __glXDisp_MapGrid2d(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 40);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->MapGrid2d)( 
		*(GLint    *)(pc + 32),
		*(GLdouble *)(pc + 0),
		*(GLdouble *)(pc + 8),
		*(GLint    *)(pc + 36),
		*(GLdouble *)(pc + 16),
		*(GLdouble *)(pc + 24)
	);
}

void __glXDisp_MapGrid2f(GLbyte *pc)
{
	(*__glRenderTable->MapGrid2f)( 
		*(GLint    *)(pc + 0),
		*(GLfloat  *)(pc + 4),
		*(GLfloat  *)(pc + 8),
		*(GLint    *)(pc + 12),
		*(GLfloat  *)(pc + 16),
		*(GLfloat  *)(pc + 20)
	);
}

void __glXDisp_EvalCoord1dv(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 8);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->EvalCoord1dv)( 
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_EvalCoord1fv(GLbyte *pc)
{
	(*__glRenderTable->EvalCoord1fv)( 
		(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_EvalCoord2dv(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 16);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->EvalCoord2dv)( 
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_EvalCoord2fv(GLbyte *pc)
{
	(*__glRenderTable->EvalCoord2fv)( 
		(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_EvalMesh1(GLbyte *pc)
{
	(*__glRenderTable->EvalMesh1)( 
		*(GLenum   *)(pc + 0),
		*(GLint    *)(pc + 4),
		*(GLint    *)(pc + 8)
	);
}

void __glXDisp_EvalPoint1(GLbyte *pc)
{
	(*__glRenderTable->EvalPoint1)( 
		*(GLint    *)(pc + 0)
	);
}

void __glXDisp_EvalMesh2(GLbyte *pc)
{
	(*__glRenderTable->EvalMesh2)( 
		*(GLenum   *)(pc + 0),
		*(GLint    *)(pc + 4),
		*(GLint    *)(pc + 8),
		*(GLint    *)(pc + 12),
		*(GLint    *)(pc + 16)
	);
}

void __glXDisp_EvalPoint2(GLbyte *pc)
{
	(*__glRenderTable->EvalPoint2)( 
		*(GLint    *)(pc + 0),
		*(GLint    *)(pc + 4)
	);
}

void __glXDisp_AlphaFunc(GLbyte *pc)
{
	(*__glRenderTable->AlphaFunc)( 
		*(GLenum   *)(pc + 0),
		*(GLclampf *)(pc + 4)
	);
}

void __glXDisp_BlendFunc(GLbyte *pc)
{
	(*__glRenderTable->BlendFunc)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4)
	);
}

void __glXDisp_LogicOp(GLbyte *pc)
{
	(*__glRenderTable->LogicOp)( 
		*(GLenum   *)(pc + 0)
	);
}

void __glXDisp_StencilFunc(GLbyte *pc)
{
	(*__glRenderTable->StencilFunc)( 
		*(GLenum   *)(pc + 0),
		*(GLint    *)(pc + 4),
		*(GLuint   *)(pc + 8)
	);
}

void __glXDisp_StencilOp(GLbyte *pc)
{
	(*__glRenderTable->StencilOp)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		*(GLenum   *)(pc + 8)
	);
}

void __glXDisp_DepthFunc(GLbyte *pc)
{
	(*__glRenderTable->DepthFunc)( 
		*(GLenum   *)(pc + 0)
	);
}

void __glXDisp_PixelZoom(GLbyte *pc)
{
	(*__glRenderTable->PixelZoom)( 
		*(GLfloat  *)(pc + 0),
		*(GLfloat  *)(pc + 4)
	);
}

void __glXDisp_PixelTransferf(GLbyte *pc)
{
	(*__glRenderTable->PixelTransferf)( 
		*(GLenum   *)(pc + 0),
		*(GLfloat  *)(pc + 4)
	);
}

void __glXDisp_PixelTransferi(GLbyte *pc)
{
	(*__glRenderTable->PixelTransferi)( 
		*(GLenum   *)(pc + 0),
		*(GLint    *)(pc + 4)
	);
}

void __glXDisp_PixelMapfv(GLbyte *pc)
{
	(*__glRenderTable->PixelMapfv)( 
		*(GLenum   *)(pc + 0),
		*(GLint    *)(pc + 4),
		(GLfloat  *)(pc + 8)
	);
}

void __glXDisp_PixelMapuiv(GLbyte *pc)
{
	(*__glRenderTable->PixelMapuiv)( 
		*(GLenum   *)(pc + 0),
		*(GLint    *)(pc + 4),
		(GLuint   *)(pc + 8)
	);
}

void __glXDisp_PixelMapusv(GLbyte *pc)
{
	(*__glRenderTable->PixelMapusv)( 
		*(GLenum   *)(pc + 0),
		*(GLint    *)(pc + 4),
		(GLushort *)(pc + 8)
	);
}

void __glXDisp_ReadBuffer(GLbyte *pc)
{
	(*__glRenderTable->ReadBuffer)( 
		*(GLenum   *)(pc + 0)
	);
}

void __glXDisp_CopyPixels(GLbyte *pc)
{
	(*__glRenderTable->CopyPixels)( 
		*(GLint    *)(pc + 0),
		*(GLint    *)(pc + 4),
		*(GLsizei  *)(pc + 8),
		*(GLsizei  *)(pc + 12),
		*(GLenum   *)(pc + 16)
	);
}

void __glXDisp_DepthRange(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 16);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->DepthRange)( 
		*(GLclampd *)(pc + 0),
		*(GLclampd *)(pc + 8)
	);
}

void __glXDisp_Frustum(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 48);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->Frustum)( 
		*(GLdouble *)(pc + 0),
		*(GLdouble *)(pc + 8),
		*(GLdouble *)(pc + 16),
		*(GLdouble *)(pc + 24),
		*(GLdouble *)(pc + 32),
		*(GLdouble *)(pc + 40)
	);
}

void __glXDisp_LoadIdentity(GLbyte *pc)
{
	(*__glRenderTable->LoadIdentity)( 
	);
}

void __glXDisp_LoadMatrixf(GLbyte *pc)
{
	(*__glRenderTable->LoadMatrixf)( 
		(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_LoadMatrixd(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 128);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->LoadMatrixd)( 
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_MatrixMode(GLbyte *pc)
{
	(*__glRenderTable->MatrixMode)( 
		*(GLenum   *)(pc + 0)
	);
}

void __glXDisp_MultMatrixf(GLbyte *pc)
{
	(*__glRenderTable->MultMatrixf)( 
		(GLfloat  *)(pc + 0)
	);
}

void __glXDisp_MultMatrixd(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 128);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->MultMatrixd)( 
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_Ortho(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 48);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->Ortho)( 
		*(GLdouble *)(pc + 0),
		*(GLdouble *)(pc + 8),
		*(GLdouble *)(pc + 16),
		*(GLdouble *)(pc + 24),
		*(GLdouble *)(pc + 32),
		*(GLdouble *)(pc + 40)
	);
}

void __glXDisp_PopMatrix(GLbyte *pc)
{
	(*__glRenderTable->PopMatrix)( 
	);
}

void __glXDisp_PushMatrix(GLbyte *pc)
{
	(*__glRenderTable->PushMatrix)( 
	);
}

void __glXDisp_Rotated(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 32);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->Rotated)( 
		*(GLdouble *)(pc + 0),
		*(GLdouble *)(pc + 8),
		*(GLdouble *)(pc + 16),
		*(GLdouble *)(pc + 24)
	);
}

void __glXDisp_Rotatef(GLbyte *pc)
{
	(*__glRenderTable->Rotatef)( 
		*(GLfloat  *)(pc + 0),
		*(GLfloat  *)(pc + 4),
		*(GLfloat  *)(pc + 8),
		*(GLfloat  *)(pc + 12)
	);
}

void __glXDisp_Scaled(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 24);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->Scaled)( 
		*(GLdouble *)(pc + 0),
		*(GLdouble *)(pc + 8),
		*(GLdouble *)(pc + 16)
	);
}

void __glXDisp_Scalef(GLbyte *pc)
{
	(*__glRenderTable->Scalef)( 
		*(GLfloat  *)(pc + 0),
		*(GLfloat  *)(pc + 4),
		*(GLfloat  *)(pc + 8)
	);
}

void __glXDisp_Translated(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 24);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->Translated)( 
		*(GLdouble *)(pc + 0),
		*(GLdouble *)(pc + 8),
		*(GLdouble *)(pc + 16)
	);
}

void __glXDisp_Translatef(GLbyte *pc)
{
	(*__glRenderTable->Translatef)( 
		*(GLfloat  *)(pc + 0),
		*(GLfloat  *)(pc + 4),
		*(GLfloat  *)(pc + 8)
	);
}

void __glXDisp_Viewport(GLbyte *pc)
{
	(*__glRenderTable->Viewport)( 
		*(GLint    *)(pc + 0),
		*(GLint    *)(pc + 4),
		*(GLsizei  *)(pc + 8),
		*(GLsizei  *)(pc + 12)
	);
}

void __glXDisp_PolygonOffset(GLbyte *pc)
{
	(*__glRenderTable->PolygonOffset)( 
		*(GLfloat  *)(pc + 0),
		*(GLfloat  *)(pc + 4)
	);
}

void __glXDisp_CopyTexImage1D(GLbyte *pc)
{
	(*__glRenderTable->CopyTexImage1D)( 
		*(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)
{
	(*__glRenderTable->CopyTexImage2D)( 
		*(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)
{
	(*__glRenderTable->CopyTexSubImage1D)( 
		*(GLenum   *)(pc + 0),
		*(GLint    *)(pc + 4),
		*(GLint    *)(pc + 8),
		*(GLint    *)(pc + 12),
		*(GLint    *)(pc + 16),
		*(GLsizei  *)(pc + 20)
	);
}

void __glXDisp_CopyTexSubImage2D(GLbyte *pc)
{
	(*__glRenderTable->CopyTexSubImage2D)( 
		*(GLenum   *)(pc + 0),
		*(GLint    *)(pc + 4),
		*(GLint    *)(pc + 8),
		*(GLint    *)(pc + 12),
		*(GLint    *)(pc + 16),
		*(GLint    *)(pc + 20),
		*(GLsizei  *)(pc + 24),
		*(GLsizei  *)(pc + 28)
	);
}

void __glXDisp_BindTexture(GLbyte *pc)
{
	(*__glRenderTable->BindTexture)( 
		*(GLenum   *)(pc + 0),
		*(GLuint   *)(pc + 4)
	);
}

void __glXDisp_PrioritizeTextures(GLbyte *pc)
{
	GLsizei n;

	n = *(GLsizei *)(pc + 0);

	(*__glRenderTable->PrioritizeTextures)( 
		*(GLsizei  *)(pc + 0),
		(GLuint   *)(pc + 4),
		(GLclampf *)(pc + 4+n*4)
	);
}

void __glXDisp_Indexubv(GLbyte *pc)
{
	(*__glRenderTable->Indexubv)( 
		(GLubyte  *)(pc + 0)
	);
}

void __glXDisp_BlendColor(GLbyte *pc)
{
	(*__glRenderTable->BlendColor)( 
		*(GLclampf *)(pc + 0),
		*(GLclampf *)(pc + 4),
		*(GLclampf *)(pc + 8),
		*(GLclampf *)(pc + 12)
	);
}

void __glXDisp_BlendEquation(GLbyte *pc)
{
	(*__glRenderTable->BlendEquation)( 
		*(GLenum   *)(pc + 0)
	);
}

void __glXDisp_ColorTableParameterfv(GLbyte *pc)
{
	(*__glRenderTable->ColorTableParameterfv)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		(GLfloat  *)(pc + 8)
	);
}

void __glXDisp_ColorTableParameteriv(GLbyte *pc)
{
	(*__glRenderTable->ColorTableParameteriv)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		(GLint    *)(pc + 8)
	);
}

void __glXDisp_CopyColorTable(GLbyte *pc)
{
	(*__glRenderTable->CopyColorTable)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		*(GLint    *)(pc + 8),
		*(GLint    *)(pc + 12),
		*(GLsizei  *)(pc + 16)
	);
}

void __glXDisp_CopyColorSubTable(GLbyte *pc)
{
	(*__glRenderTable->CopyColorSubTable)( 
		*(GLenum   *)(pc + 0),
		*(GLsizei  *)(pc + 4),
		*(GLint    *)(pc + 8),
		*(GLint    *)(pc + 12),
		*(GLsizei  *)(pc + 16)
	);
}

void __glXDisp_ConvolutionParameterf(GLbyte *pc)
{
	(*__glRenderTable->ConvolutionParameterf)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		*(GLfloat  *)(pc + 8)
	);
}

void __glXDisp_ConvolutionParameterfv(GLbyte *pc)
{
	(*__glRenderTable->ConvolutionParameterfv)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		(GLfloat  *)(pc + 8)
	);
}

void __glXDisp_ConvolutionParameteri(GLbyte *pc)
{
	(*__glRenderTable->ConvolutionParameteri)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		*(GLint    *)(pc + 8)
	);
}

void __glXDisp_ConvolutionParameteriv(GLbyte *pc)
{
	(*__glRenderTable->ConvolutionParameteriv)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		(GLint    *)(pc + 8)
	);
}

void __glXDisp_CopyConvolutionFilter1D(GLbyte *pc)
{
	(*__glRenderTable->CopyConvolutionFilter1D)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		*(GLint    *)(pc + 8),
		*(GLint    *)(pc + 12),
		*(GLsizei  *)(pc + 16)
	);
}

void __glXDisp_CopyConvolutionFilter2D(GLbyte *pc)
{
	(*__glRenderTable->CopyConvolutionFilter2D)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		*(GLint    *)(pc + 8),
		*(GLint    *)(pc + 12),
		*(GLsizei  *)(pc + 16),
		*(GLsizei  *)(pc + 20)
	);
}

void __glXDisp_Histogram(GLbyte *pc)
{
	(*__glRenderTable->Histogram)( 
		*(GLenum   *)(pc + 0),
		*(GLsizei  *)(pc + 4),
		*(GLenum   *)(pc + 8),
		*(GLboolean *)(pc + 12)
	);
}

void __glXDisp_Minmax(GLbyte *pc)
{
	(*__glRenderTable->Minmax)( 
		*(GLenum   *)(pc + 0),
		*(GLenum   *)(pc + 4),
		*(GLboolean *)(pc + 8)
	);
}

void __glXDisp_ResetHistogram(GLbyte *pc)
{
	(*__glRenderTable->ResetHistogram)( 
		*(GLenum   *)(pc + 0)
	);
}

void __glXDisp_ResetMinmax(GLbyte *pc)
{
	(*__glRenderTable->ResetMinmax)( 
		*(GLenum   *)(pc + 0)
	);
}

void __glXDisp_CopyTexSubImage3D(GLbyte *pc)
{
	(*__glRenderTable->CopyTexSubImage3D)( 
		*(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)
{
	(*__glRenderTable->ActiveTextureARB)( 
		*(GLenum   *)(pc + 0)
	);
}

void __glXDisp_MultiTexCoord1dvARB(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 12);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->MultiTexCoord1dvARB)( 
		*(GLenum   *)(pc + 8),
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_MultiTexCoord1fvARB(GLbyte *pc)
{
	(*__glRenderTable->MultiTexCoord1fvARB)( 
		*(GLenum   *)(pc + 0),
		(GLfloat  *)(pc + 4)
	);
}

void __glXDisp_MultiTexCoord1ivARB(GLbyte *pc)
{
	(*__glRenderTable->MultiTexCoord1ivARB)( 
		*(GLenum   *)(pc + 0),
		(GLint    *)(pc + 4)
	);
}

void __glXDisp_MultiTexCoord1svARB(GLbyte *pc)
{
	(*__glRenderTable->MultiTexCoord1svARB)( 
		*(GLenum   *)(pc + 0),
		(GLshort  *)(pc + 4)
	);
}

void __glXDisp_MultiTexCoord2dvARB(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 20);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->MultiTexCoord2dvARB)( 
		*(GLenum   *)(pc + 16),
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_MultiTexCoord2fvARB(GLbyte *pc)
{
	(*__glRenderTable->MultiTexCoord2fvARB)( 
		*(GLenum   *)(pc + 0),
		(GLfloat  *)(pc + 4)
	);
}

void __glXDisp_MultiTexCoord2ivARB(GLbyte *pc)
{
	(*__glRenderTable->MultiTexCoord2ivARB)( 
		*(GLenum   *)(pc + 0),
		(GLint    *)(pc + 4)
	);
}

void __glXDisp_MultiTexCoord2svARB(GLbyte *pc)
{
	(*__glRenderTable->MultiTexCoord2svARB)( 
		*(GLenum   *)(pc + 0),
		(GLshort  *)(pc + 4)
	);
}

void __glXDisp_MultiTexCoord3dvARB(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 28);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->MultiTexCoord3dvARB)( 
		*(GLenum   *)(pc + 24),
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_MultiTexCoord3fvARB(GLbyte *pc)
{
	(*__glRenderTable->MultiTexCoord3fvARB)( 
		*(GLenum   *)(pc + 0),
		(GLfloat  *)(pc + 4)
	);
}

void __glXDisp_MultiTexCoord3ivARB(GLbyte *pc)
{
	(*__glRenderTable->MultiTexCoord3ivARB)( 
		*(GLenum   *)(pc + 0),
		(GLint    *)(pc + 4)
	);
}

void __glXDisp_MultiTexCoord3svARB(GLbyte *pc)
{
	(*__glRenderTable->MultiTexCoord3svARB)( 
		*(GLenum   *)(pc + 0),
		(GLshort  *)(pc + 4)
	);
}

void __glXDisp_MultiTexCoord4dvARB(GLbyte *pc)
{

#ifdef __GLX_ALIGN64
	if ((unsigned long)(pc) & 7) {
	    __GLX_MEM_COPY(pc-4, pc, 36);
	    pc -= 4;
	}
#endif
	(*__glRenderTable->MultiTexCoord4dvARB)( 
		*(GLenum   *)(pc + 32),
		(GLdouble *)(pc + 0)
	);
}

void __glXDisp_MultiTexCoord4fvARB(GLbyte *pc)
{
	(*__glRenderTable->MultiTexCoord4fvARB)( 
		*(GLenum   *)(pc + 0),
		(GLfloat  *)(pc + 4)
	);
}

void __glXDisp_MultiTexCoord4ivARB(GLbyte *pc)
{
	(*__glRenderTable->MultiTexCoord4ivARB)( 
		*(GLenum   *)(pc + 0),
		(GLint    *)(pc + 4)
	);
}

void __glXDisp_MultiTexCoord4svARB(GLbyte *pc)
{
	(*__glRenderTable->MultiTexCoord4svARB)( 
		*(GLenum   *)(pc + 0),
		(GLshort  *)(pc + 4)
	);
}


/*
 * Extensions
 */

void __glXDisp_PointParameterfARB(GLbyte *pc)
{
	(*__glRenderTable->PointParameterfEXT)(
		*(GLenum *)(pc + 0),
		*(GLfloat *)(pc + 4)
	);
}


void __glXDisp_PointParameterfvARB(GLbyte *pc)
{
	(*__glRenderTable->PointParameterfvEXT)(
		*(GLenum *)(pc + 0),
		(GLfloat *)(pc + 4)
	);
}

dispatch_template_enum1_1s(PointParameteri,  (*__glRenderTable->PointParameteriNV), GLint)
dispatch_template_enum1_Vv(PointParameteriv, (*__glRenderTable->PointParameterivNV), GLint)

void __glXDisp_ActiveStencilFaceEXT(GLbyte *pc) 
{
	(*__glRenderTable->ActiveStencilFaceEXT)(
		*(GLenum *)(pc + 0)
	);
}

void __glXDisp_WindowPos3fARB(GLbyte *pc)
{
	(*__glRenderTable->WindowPos3fMESA)(
		*(GLfloat *)(pc + 0),
		*(GLfloat *)(pc + 4),
		*(GLfloat *)(pc + 8)
	);
}

void __glXDisp_SampleCoverageARB(GLbyte *pc)
{
	(*__glRenderTable->SampleCoverageARB)(
		*(GLfloat *)(pc + 0),
		*(GLboolean *)(pc + 4)
	);
}