/* DO NOT EDIT - This file generated automatically by glX_proto_recv.py (from Mesa) script */

/*
 * (C) Copyright IBM Corporation 2005
 * All Rights Reserved.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sub license,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
 * IBM,
 * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <X11/Xmd.h>
#include <GL/gl.h>
#include <GL/glxproto.h>
#include <inttypes.h>
#include "indirect_size.h"
#include "indirect_size_get.h"
#include "indirect_dispatch.h"
#include "glxserver.h"
#include "glxbyteorder.h"
#include "indirect_util.h"
#include "singlesize.h"
#include "glapi.h"
#include "glapitable.h"
#include "glthread.h"
#include "dispatch.h"

#define __GLX_PAD(x)  (((x) + 3) & ~3)

typedef struct {
    __GLX_PIXEL_3D_HDR;
} __GLXpixel3DHeader;

extern GLboolean __glXErrorOccured(void);
extern void __glXClearErrorOccured(void);

static const unsigned dummy_answer[2] = { 0, 0 };

int
__glXDisp_NewList(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        CALL_NewList(GET_DISPATCH(), (*(GLuint *) (pc + 0), *(GLenum *) (pc + 4)
                     ));
        error = Success;
    }

    return error;
}

int
__glXDisp_EndList(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        CALL_EndList(GET_DISPATCH(), ());
        error = Success;
    }

    return error;
}

void
__glXDisp_CallList(GLbyte * pc)
{
    CALL_CallList(GET_DISPATCH(), (*(GLuint *) (pc + 0)
                  ));
}

void
__glXDisp_CallLists(GLbyte * pc)
{
    const GLsizei n = *(GLsizei *) (pc + 0);
    const GLenum type = *(GLenum *) (pc + 4);
    const GLvoid *lists = (const GLvoid *) (pc + 8);

    lists = (const GLvoid *) (pc + 8);

    CALL_CallLists(GET_DISPATCH(), (n, type, lists));
}

int
__glXDisp_DeleteLists(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        CALL_DeleteLists(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                          *(GLsizei *) (pc + 4)
                         ));
        error = Success;
    }

    return error;
}

int
__glXDisp_GenLists(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        GLuint retval;

        retval = CALL_GenLists(GET_DISPATCH(), (*(GLsizei *) (pc + 0)
                               ));
        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
        error = Success;
    }

    return error;
}

void
__glXDisp_ListBase(GLbyte * pc)
{
    CALL_ListBase(GET_DISPATCH(), (*(GLuint *) (pc + 0)
                  ));
}

void
__glXDisp_Begin(GLbyte * pc)
{
    CALL_Begin(GET_DISPATCH(), (*(GLenum *) (pc + 0)
               ));
}

void
__glXDisp_Bitmap(GLbyte * pc)
{
    const GLubyte *const bitmap = (const GLubyte *) ((pc + 44));
    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);

    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));

    CALL_Bitmap(GET_DISPATCH(), (*(GLsizei *) (pc + 20),
                                 *(GLsizei *) (pc + 24),
                                 *(GLfloat *) (pc + 28),
                                 *(GLfloat *) (pc + 32),
                                 *(GLfloat *) (pc + 36),
                                 *(GLfloat *) (pc + 40), bitmap));
}

void
__glXDisp_Color3bv(GLbyte * pc)
{
    CALL_Color3bv(GET_DISPATCH(), ((const GLbyte *) (pc + 0)
                  ));
}

void
__glXDisp_Color3dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 24);
        pc -= 4;
    }
#endif

    CALL_Color3dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                  ));
}

void
__glXDisp_Color3fv(GLbyte * pc)
{
    CALL_Color3fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                  ));
}

void
__glXDisp_Color3iv(GLbyte * pc)
{
    CALL_Color3iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
                  ));
}

void
__glXDisp_Color3sv(GLbyte * pc)
{
    CALL_Color3sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
                  ));
}

void
__glXDisp_Color3ubv(GLbyte * pc)
{
    CALL_Color3ubv(GET_DISPATCH(), ((const GLubyte *) (pc + 0)
                   ));
}

void
__glXDisp_Color3uiv(GLbyte * pc)
{
    CALL_Color3uiv(GET_DISPATCH(), ((const GLuint *) (pc + 0)
                   ));
}

void
__glXDisp_Color3usv(GLbyte * pc)
{
    CALL_Color3usv(GET_DISPATCH(), ((const GLushort *) (pc + 0)
                   ));
}

void
__glXDisp_Color4bv(GLbyte * pc)
{
    CALL_Color4bv(GET_DISPATCH(), ((const GLbyte *) (pc + 0)
                  ));
}

void
__glXDisp_Color4dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 32);
        pc -= 4;
    }
#endif

    CALL_Color4dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                  ));
}

void
__glXDisp_Color4fv(GLbyte * pc)
{
    CALL_Color4fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                  ));
}

void
__glXDisp_Color4iv(GLbyte * pc)
{
    CALL_Color4iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
                  ));
}

void
__glXDisp_Color4sv(GLbyte * pc)
{
    CALL_Color4sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
                  ));
}

void
__glXDisp_Color4ubv(GLbyte * pc)
{
    CALL_Color4ubv(GET_DISPATCH(), ((const GLubyte *) (pc + 0)
                   ));
}

void
__glXDisp_Color4uiv(GLbyte * pc)
{
    CALL_Color4uiv(GET_DISPATCH(), ((const GLuint *) (pc + 0)
                   ));
}

void
__glXDisp_Color4usv(GLbyte * pc)
{
    CALL_Color4usv(GET_DISPATCH(), ((const GLushort *) (pc + 0)
                   ));
}

void
__glXDisp_EdgeFlagv(GLbyte * pc)
{
    CALL_EdgeFlagv(GET_DISPATCH(), ((const GLboolean *) (pc + 0)
                   ));
}

void
__glXDisp_End(GLbyte * pc)
{
    CALL_End(GET_DISPATCH(), ());
}

void
__glXDisp_Indexdv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 8);
        pc -= 4;
    }
#endif

    CALL_Indexdv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                 ));
}

void
__glXDisp_Indexfv(GLbyte * pc)
{
    CALL_Indexfv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                 ));
}

void
__glXDisp_Indexiv(GLbyte * pc)
{
    CALL_Indexiv(GET_DISPATCH(), ((const GLint *) (pc + 0)
                 ));
}

void
__glXDisp_Indexsv(GLbyte * pc)
{
    CALL_Indexsv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
                 ));
}

void
__glXDisp_Normal3bv(GLbyte * pc)
{
    CALL_Normal3bv(GET_DISPATCH(), ((const GLbyte *) (pc + 0)
                   ));
}

void
__glXDisp_Normal3dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 24);
        pc -= 4;
    }
#endif

    CALL_Normal3dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                   ));
}

void
__glXDisp_Normal3fv(GLbyte * pc)
{
    CALL_Normal3fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                   ));
}

void
__glXDisp_Normal3iv(GLbyte * pc)
{
    CALL_Normal3iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
                   ));
}

void
__glXDisp_Normal3sv(GLbyte * pc)
{
    CALL_Normal3sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
                   ));
}

void
__glXDisp_RasterPos2dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 16);
        pc -= 4;
    }
#endif

    CALL_RasterPos2dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                      ));
}

void
__glXDisp_RasterPos2fv(GLbyte * pc)
{
    CALL_RasterPos2fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                      ));
}

void
__glXDisp_RasterPos2iv(GLbyte * pc)
{
    CALL_RasterPos2iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
                      ));
}

void
__glXDisp_RasterPos2sv(GLbyte * pc)
{
    CALL_RasterPos2sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
                      ));
}

void
__glXDisp_RasterPos3dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 24);
        pc -= 4;
    }
#endif

    CALL_RasterPos3dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                      ));
}

void
__glXDisp_RasterPos3fv(GLbyte * pc)
{
    CALL_RasterPos3fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                      ));
}

void
__glXDisp_RasterPos3iv(GLbyte * pc)
{
    CALL_RasterPos3iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
                      ));
}

void
__glXDisp_RasterPos3sv(GLbyte * pc)
{
    CALL_RasterPos3sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
                      ));
}

void
__glXDisp_RasterPos4dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 32);
        pc -= 4;
    }
#endif

    CALL_RasterPos4dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                      ));
}

void
__glXDisp_RasterPos4fv(GLbyte * pc)
{
    CALL_RasterPos4fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                      ));
}

void
__glXDisp_RasterPos4iv(GLbyte * pc)
{
    CALL_RasterPos4iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
                      ));
}

void
__glXDisp_RasterPos4sv(GLbyte * pc)
{
    CALL_RasterPos4sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
                      ));
}

void
__glXDisp_Rectdv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 32);
        pc -= 4;
    }
#endif

    CALL_Rectdv(GET_DISPATCH(), ((const GLdouble *) (pc + 0),
                                 (const GLdouble *) (pc + 16)
                ));
}

void
__glXDisp_Rectfv(GLbyte * pc)
{
    CALL_Rectfv(GET_DISPATCH(), ((const GLfloat *) (pc + 0),
                                 (const GLfloat *) (pc + 8)
                ));
}

void
__glXDisp_Rectiv(GLbyte * pc)
{
    CALL_Rectiv(GET_DISPATCH(), ((const GLint *) (pc + 0),
                                 (const GLint *) (pc + 8)
                ));
}

void
__glXDisp_Rectsv(GLbyte * pc)
{
    CALL_Rectsv(GET_DISPATCH(), ((const GLshort *) (pc + 0),
                                 (const GLshort *) (pc + 4)
                ));
}

void
__glXDisp_TexCoord1dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 8);
        pc -= 4;
    }
#endif

    CALL_TexCoord1dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                     ));
}

void
__glXDisp_TexCoord1fv(GLbyte * pc)
{
    CALL_TexCoord1fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                     ));
}

void
__glXDisp_TexCoord1iv(GLbyte * pc)
{
    CALL_TexCoord1iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
                     ));
}

void
__glXDisp_TexCoord1sv(GLbyte * pc)
{
    CALL_TexCoord1sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
                     ));
}

void
__glXDisp_TexCoord2dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 16);
        pc -= 4;
    }
#endif

    CALL_TexCoord2dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                     ));
}

void
__glXDisp_TexCoord2fv(GLbyte * pc)
{
    CALL_TexCoord2fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                     ));
}

void
__glXDisp_TexCoord2iv(GLbyte * pc)
{
    CALL_TexCoord2iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
                     ));
}

void
__glXDisp_TexCoord2sv(GLbyte * pc)
{
    CALL_TexCoord2sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
                     ));
}

void
__glXDisp_TexCoord3dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 24);
        pc -= 4;
    }
#endif

    CALL_TexCoord3dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                     ));
}

void
__glXDisp_TexCoord3fv(GLbyte * pc)
{
    CALL_TexCoord3fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                     ));
}

void
__glXDisp_TexCoord3iv(GLbyte * pc)
{
    CALL_TexCoord3iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
                     ));
}

void
__glXDisp_TexCoord3sv(GLbyte * pc)
{
    CALL_TexCoord3sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
                     ));
}

void
__glXDisp_TexCoord4dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 32);
        pc -= 4;
    }
#endif

    CALL_TexCoord4dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                     ));
}

void
__glXDisp_TexCoord4fv(GLbyte * pc)
{
    CALL_TexCoord4fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                     ));
}

void
__glXDisp_TexCoord4iv(GLbyte * pc)
{
    CALL_TexCoord4iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
                     ));
}

void
__glXDisp_TexCoord4sv(GLbyte * pc)
{
    CALL_TexCoord4sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
                     ));
}

void
__glXDisp_Vertex2dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 16);
        pc -= 4;
    }
#endif

    CALL_Vertex2dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                   ));
}

void
__glXDisp_Vertex2fv(GLbyte * pc)
{
    CALL_Vertex2fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                   ));
}

void
__glXDisp_Vertex2iv(GLbyte * pc)
{
    CALL_Vertex2iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
                   ));
}

void
__glXDisp_Vertex2sv(GLbyte * pc)
{
    CALL_Vertex2sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
                   ));
}

void
__glXDisp_Vertex3dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 24);
        pc -= 4;
    }
#endif

    CALL_Vertex3dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                   ));
}

void
__glXDisp_Vertex3fv(GLbyte * pc)
{
    CALL_Vertex3fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                   ));
}

void
__glXDisp_Vertex3iv(GLbyte * pc)
{
    CALL_Vertex3iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
                   ));
}

void
__glXDisp_Vertex3sv(GLbyte * pc)
{
    CALL_Vertex3sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
                   ));
}

void
__glXDisp_Vertex4dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 32);
        pc -= 4;
    }
#endif

    CALL_Vertex4dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                   ));
}

void
__glXDisp_Vertex4fv(GLbyte * pc)
{
    CALL_Vertex4fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                   ));
}

void
__glXDisp_Vertex4iv(GLbyte * pc)
{
    CALL_Vertex4iv(GET_DISPATCH(), ((const GLint *) (pc + 0)
                   ));
}

void
__glXDisp_Vertex4sv(GLbyte * pc)
{
    CALL_Vertex4sv(GET_DISPATCH(), ((const GLshort *) (pc + 0)
                   ));
}

void
__glXDisp_ClipPlane(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 36);
        pc -= 4;
    }
#endif

    CALL_ClipPlane(GET_DISPATCH(), (*(GLenum *) (pc + 32),
                                    (const GLdouble *) (pc + 0)
                   ));
}

void
__glXDisp_ColorMaterial(GLbyte * pc)
{
    CALL_ColorMaterial(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                        *(GLenum *) (pc + 4)
                       ));
}

void
__glXDisp_CullFace(GLbyte * pc)
{
    CALL_CullFace(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                  ));
}

void
__glXDisp_Fogf(GLbyte * pc)
{
    CALL_Fogf(GET_DISPATCH(), (*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4)
              ));
}

void
__glXDisp_Fogfv(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 0);
    const GLfloat *params;

    params = (const GLfloat *) (pc + 4);

    CALL_Fogfv(GET_DISPATCH(), (pname, params));
}

void
__glXDisp_Fogi(GLbyte * pc)
{
    CALL_Fogi(GET_DISPATCH(), (*(GLenum *) (pc + 0), *(GLint *) (pc + 4)
              ));
}

void
__glXDisp_Fogiv(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 0);
    const GLint *params;

    params = (const GLint *) (pc + 4);

    CALL_Fogiv(GET_DISPATCH(), (pname, params));
}

void
__glXDisp_FrontFace(GLbyte * pc)
{
    CALL_FrontFace(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                   ));
}

void
__glXDisp_Hint(GLbyte * pc)
{
    CALL_Hint(GET_DISPATCH(), (*(GLenum *) (pc + 0), *(GLenum *) (pc + 4)
              ));
}

void
__glXDisp_Lightf(GLbyte * pc)
{
    CALL_Lightf(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                 *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8)
                ));
}

void
__glXDisp_Lightfv(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 4);
    const GLfloat *params;

    params = (const GLfloat *) (pc + 8);

    CALL_Lightfv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}

void
__glXDisp_Lighti(GLbyte * pc)
{
    CALL_Lighti(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                 *(GLenum *) (pc + 4), *(GLint *) (pc + 8)
                ));
}

void
__glXDisp_Lightiv(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 4);
    const GLint *params;

    params = (const GLint *) (pc + 8);

    CALL_Lightiv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}

void
__glXDisp_LightModelf(GLbyte * pc)
{
    CALL_LightModelf(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                      *(GLfloat *) (pc + 4)
                     ));
}

void
__glXDisp_LightModelfv(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 0);
    const GLfloat *params;

    params = (const GLfloat *) (pc + 4);

    CALL_LightModelfv(GET_DISPATCH(), (pname, params));
}

void
__glXDisp_LightModeli(GLbyte * pc)
{
    CALL_LightModeli(GET_DISPATCH(), (*(GLenum *) (pc + 0), *(GLint *) (pc + 4)
                     ));
}

void
__glXDisp_LightModeliv(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 0);
    const GLint *params;

    params = (const GLint *) (pc + 4);

    CALL_LightModeliv(GET_DISPATCH(), (pname, params));
}

void
__glXDisp_LineStipple(GLbyte * pc)
{
    CALL_LineStipple(GET_DISPATCH(), (*(GLint *) (pc + 0),
                                      *(GLushort *) (pc + 4)
                     ));
}

void
__glXDisp_LineWidth(GLbyte * pc)
{
    CALL_LineWidth(GET_DISPATCH(), (*(GLfloat *) (pc + 0)
                   ));
}

void
__glXDisp_Materialf(GLbyte * pc)
{
    CALL_Materialf(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                    *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8)
                   ));
}

void
__glXDisp_Materialfv(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 4);
    const GLfloat *params;

    params = (const GLfloat *) (pc + 8);

    CALL_Materialfv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}

void
__glXDisp_Materiali(GLbyte * pc)
{
    CALL_Materiali(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                    *(GLenum *) (pc + 4), *(GLint *) (pc + 8)
                   ));
}

void
__glXDisp_Materialiv(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 4);
    const GLint *params;

    params = (const GLint *) (pc + 8);

    CALL_Materialiv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}

void
__glXDisp_PointSize(GLbyte * pc)
{
    CALL_PointSize(GET_DISPATCH(), (*(GLfloat *) (pc + 0)
                   ));
}

void
__glXDisp_PolygonMode(GLbyte * pc)
{
    CALL_PolygonMode(GET_DISPATCH(), (*(GLenum *) (pc + 0), *(GLenum *) (pc + 4)
                     ));
}

void
__glXDisp_PolygonStipple(GLbyte * pc)
{
    const GLubyte *const mask = (const GLubyte *) ((pc + 20));
    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);

    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));

    CALL_PolygonStipple(GET_DISPATCH(), (mask));
}

void
__glXDisp_Scissor(GLbyte * pc)
{
    CALL_Scissor(GET_DISPATCH(), (*(GLint *) (pc + 0),
                                  *(GLint *) (pc + 4),
                                  *(GLsizei *) (pc + 8), *(GLsizei *) (pc + 12)
                 ));
}

void
__glXDisp_ShadeModel(GLbyte * pc)
{
    CALL_ShadeModel(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                    ));
}

void
__glXDisp_TexParameterf(GLbyte * pc)
{
    CALL_TexParameterf(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                        *(GLenum *) (pc + 4),
                                        *(GLfloat *) (pc + 8)
                       ));
}

void
__glXDisp_TexParameterfv(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 4);
    const GLfloat *params;

    params = (const GLfloat *) (pc + 8);

    CALL_TexParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}

void
__glXDisp_TexParameteri(GLbyte * pc)
{
    CALL_TexParameteri(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                        *(GLenum *) (pc + 4),
                                        *(GLint *) (pc + 8)
                       ));
}

void
__glXDisp_TexParameteriv(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 4);
    const GLint *params;

    params = (const GLint *) (pc + 8);

    CALL_TexParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}

void
__glXDisp_TexImage1D(GLbyte * pc)
{
    const GLvoid *const pixels = (const GLvoid *) ((pc + 52));
    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);

    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));

    CALL_TexImage1D(GET_DISPATCH(), (*(GLenum *) (pc + 20),
                                     *(GLint *) (pc + 24),
                                     *(GLint *) (pc + 28),
                                     *(GLsizei *) (pc + 32),
                                     *(GLint *) (pc + 40),
                                     *(GLenum *) (pc + 44),
                                     *(GLenum *) (pc + 48), pixels));
}

void
__glXDisp_TexImage2D(GLbyte * pc)
{
    const GLvoid *const pixels = (const GLvoid *) ((pc + 52));
    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);

    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));

    CALL_TexImage2D(GET_DISPATCH(), (*(GLenum *) (pc + 20),
                                     *(GLint *) (pc + 24),
                                     *(GLint *) (pc + 28),
                                     *(GLsizei *) (pc + 32),
                                     *(GLsizei *) (pc + 36),
                                     *(GLint *) (pc + 40),
                                     *(GLenum *) (pc + 44),
                                     *(GLenum *) (pc + 48), pixels));
}

void
__glXDisp_TexEnvf(GLbyte * pc)
{
    CALL_TexEnvf(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                  *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8)
                 ));
}

void
__glXDisp_TexEnvfv(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 4);
    const GLfloat *params;

    params = (const GLfloat *) (pc + 8);

    CALL_TexEnvfv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}

void
__glXDisp_TexEnvi(GLbyte * pc)
{
    CALL_TexEnvi(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                  *(GLenum *) (pc + 4), *(GLint *) (pc + 8)
                 ));
}

void
__glXDisp_TexEnviv(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 4);
    const GLint *params;

    params = (const GLint *) (pc + 8);

    CALL_TexEnviv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}

void
__glXDisp_TexGend(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 16);
        pc -= 4;
    }
#endif

    CALL_TexGend(GET_DISPATCH(), (*(GLenum *) (pc + 8),
                                  *(GLenum *) (pc + 12), *(GLdouble *) (pc + 0)
                 ));
}

void
__glXDisp_TexGendv(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 4);
    const GLdouble *params;

#ifdef __GLX_ALIGN64
    const GLuint compsize = __glTexGendv_size(pname);
    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8)) - 4;

    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, cmdlen);
        pc -= 4;
    }
#endif

    params = (const GLdouble *) (pc + 8);

    CALL_TexGendv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}

void
__glXDisp_TexGenf(GLbyte * pc)
{
    CALL_TexGenf(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                  *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8)
                 ));
}

void
__glXDisp_TexGenfv(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 4);
    const GLfloat *params;

    params = (const GLfloat *) (pc + 8);

    CALL_TexGenfv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}

void
__glXDisp_TexGeni(GLbyte * pc)
{
    CALL_TexGeni(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                  *(GLenum *) (pc + 4), *(GLint *) (pc + 8)
                 ));
}

void
__glXDisp_TexGeniv(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 4);
    const GLint *params;

    params = (const GLint *) (pc + 8);

    CALL_TexGeniv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
}

void
__glXDisp_InitNames(GLbyte * pc)
{
    CALL_InitNames(GET_DISPATCH(), ());
}

void
__glXDisp_LoadName(GLbyte * pc)
{
    CALL_LoadName(GET_DISPATCH(), (*(GLuint *) (pc + 0)
                  ));
}

void
__glXDisp_PassThrough(GLbyte * pc)
{
    CALL_PassThrough(GET_DISPATCH(), (*(GLfloat *) (pc + 0)
                     ));
}

void
__glXDisp_PopName(GLbyte * pc)
{
    CALL_PopName(GET_DISPATCH(), ());
}

void
__glXDisp_PushName(GLbyte * pc)
{
    CALL_PushName(GET_DISPATCH(), (*(GLuint *) (pc + 0)
                  ));
}

void
__glXDisp_DrawBuffer(GLbyte * pc)
{
    CALL_DrawBuffer(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                    ));
}

void
__glXDisp_Clear(GLbyte * pc)
{
    CALL_Clear(GET_DISPATCH(), (*(GLbitfield *) (pc + 0)
               ));
}

void
__glXDisp_ClearAccum(GLbyte * pc)
{
    CALL_ClearAccum(GET_DISPATCH(), (*(GLfloat *) (pc + 0),
                                     *(GLfloat *) (pc + 4),
                                     *(GLfloat *) (pc + 8),
                                     *(GLfloat *) (pc + 12)
                    ));
}

void
__glXDisp_ClearIndex(GLbyte * pc)
{
    CALL_ClearIndex(GET_DISPATCH(), (*(GLfloat *) (pc + 0)
                    ));
}

void
__glXDisp_ClearColor(GLbyte * pc)
{
    CALL_ClearColor(GET_DISPATCH(), (*(GLclampf *) (pc + 0),
                                     *(GLclampf *) (pc + 4),
                                     *(GLclampf *) (pc + 8),
                                     *(GLclampf *) (pc + 12)
                    ));
}

void
__glXDisp_ClearStencil(GLbyte * pc)
{
    CALL_ClearStencil(GET_DISPATCH(), (*(GLint *) (pc + 0)
                      ));
}

void
__glXDisp_ClearDepth(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 8);
        pc -= 4;
    }
#endif

    CALL_ClearDepth(GET_DISPATCH(), (*(GLclampd *) (pc + 0)
                    ));
}

void
__glXDisp_StencilMask(GLbyte * pc)
{
    CALL_StencilMask(GET_DISPATCH(), (*(GLuint *) (pc + 0)
                     ));
}

void
__glXDisp_ColorMask(GLbyte * pc)
{
    CALL_ColorMask(GET_DISPATCH(), (*(GLboolean *) (pc + 0),
                                    *(GLboolean *) (pc + 1),
                                    *(GLboolean *) (pc + 2),
                                    *(GLboolean *) (pc + 3)
                   ));
}

void
__glXDisp_DepthMask(GLbyte * pc)
{
    CALL_DepthMask(GET_DISPATCH(), (*(GLboolean *) (pc + 0)
                   ));
}

void
__glXDisp_IndexMask(GLbyte * pc)
{
    CALL_IndexMask(GET_DISPATCH(), (*(GLuint *) (pc + 0)
                   ));
}

void
__glXDisp_Accum(GLbyte * pc)
{
    CALL_Accum(GET_DISPATCH(), (*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4)
               ));
}

void
__glXDisp_Disable(GLbyte * pc)
{
    CALL_Disable(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                 ));
}

void
__glXDisp_Enable(GLbyte * pc)
{
    CALL_Enable(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                ));
}

void
__glXDisp_PopAttrib(GLbyte * pc)
{
    CALL_PopAttrib(GET_DISPATCH(), ());
}

void
__glXDisp_PushAttrib(GLbyte * pc)
{
    CALL_PushAttrib(GET_DISPATCH(), (*(GLbitfield *) (pc + 0)
                    ));
}

void
__glXDisp_MapGrid1d(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 20);
        pc -= 4;
    }
#endif

    CALL_MapGrid1d(GET_DISPATCH(), (*(GLint *) (pc + 16),
                                    *(GLdouble *) (pc + 0),
                                    *(GLdouble *) (pc + 8)
                   ));
}

void
__glXDisp_MapGrid1f(GLbyte * pc)
{
    CALL_MapGrid1f(GET_DISPATCH(), (*(GLint *) (pc + 0),
                                    *(GLfloat *) (pc + 4), *(GLfloat *) (pc + 8)
                   ));
}

void
__glXDisp_MapGrid2d(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 40);
        pc -= 4;
    }
#endif

    CALL_MapGrid2d(GET_DISPATCH(), (*(GLint *) (pc + 32),
                                    *(GLdouble *) (pc + 0),
                                    *(GLdouble *) (pc + 8),
                                    *(GLint *) (pc + 36),
                                    *(GLdouble *) (pc + 16),
                                    *(GLdouble *) (pc + 24)
                   ));
}

void
__glXDisp_MapGrid2f(GLbyte * pc)
{
    CALL_MapGrid2f(GET_DISPATCH(), (*(GLint *) (pc + 0),
                                    *(GLfloat *) (pc + 4),
                                    *(GLfloat *) (pc + 8),
                                    *(GLint *) (pc + 12),
                                    *(GLfloat *) (pc + 16),
                                    *(GLfloat *) (pc + 20)
                   ));
}

void
__glXDisp_EvalCoord1dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 8);
        pc -= 4;
    }
#endif

    CALL_EvalCoord1dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                      ));
}

void
__glXDisp_EvalCoord1fv(GLbyte * pc)
{
    CALL_EvalCoord1fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                      ));
}

void
__glXDisp_EvalCoord2dv(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 16);
        pc -= 4;
    }
#endif

    CALL_EvalCoord2dv(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                      ));
}

void
__glXDisp_EvalCoord2fv(GLbyte * pc)
{
    CALL_EvalCoord2fv(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                      ));
}

void
__glXDisp_EvalMesh1(GLbyte * pc)
{
    CALL_EvalMesh1(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                    *(GLint *) (pc + 4), *(GLint *) (pc + 8)
                   ));
}

void
__glXDisp_EvalPoint1(GLbyte * pc)
{
    CALL_EvalPoint1(GET_DISPATCH(), (*(GLint *) (pc + 0)
                    ));
}

void
__glXDisp_EvalMesh2(GLbyte * pc)
{
    CALL_EvalMesh2(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                    *(GLint *) (pc + 4),
                                    *(GLint *) (pc + 8),
                                    *(GLint *) (pc + 12), *(GLint *) (pc + 16)
                   ));
}

void
__glXDisp_EvalPoint2(GLbyte * pc)
{
    CALL_EvalPoint2(GET_DISPATCH(), (*(GLint *) (pc + 0), *(GLint *) (pc + 4)
                    ));
}

void
__glXDisp_AlphaFunc(GLbyte * pc)
{
    CALL_AlphaFunc(GET_DISPATCH(), (*(GLenum *) (pc + 0), *(GLclampf *) (pc + 4)
                   ));
}

void
__glXDisp_BlendFunc(GLbyte * pc)
{
    CALL_BlendFunc(GET_DISPATCH(), (*(GLenum *) (pc + 0), *(GLenum *) (pc + 4)
                   ));
}

void
__glXDisp_LogicOp(GLbyte * pc)
{
    CALL_LogicOp(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                 ));
}

void
__glXDisp_StencilFunc(GLbyte * pc)
{
    CALL_StencilFunc(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                      *(GLint *) (pc + 4), *(GLuint *) (pc + 8)
                     ));
}

void
__glXDisp_StencilOp(GLbyte * pc)
{
    CALL_StencilOp(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                    *(GLenum *) (pc + 4), *(GLenum *) (pc + 8)
                   ));
}

void
__glXDisp_DepthFunc(GLbyte * pc)
{
    CALL_DepthFunc(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                   ));
}

void
__glXDisp_PixelZoom(GLbyte * pc)
{
    CALL_PixelZoom(GET_DISPATCH(), (*(GLfloat *) (pc + 0), *(GLfloat *) (pc + 4)
                   ));
}

void
__glXDisp_PixelTransferf(GLbyte * pc)
{
    CALL_PixelTransferf(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                         *(GLfloat *) (pc + 4)
                        ));
}

void
__glXDisp_PixelTransferi(GLbyte * pc)
{
    CALL_PixelTransferi(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                         *(GLint *) (pc + 4)
                        ));
}

int
__glXDisp_PixelStoref(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        CALL_PixelStoref(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                          *(GLfloat *) (pc + 4)
                         ));
        error = Success;
    }

    return error;
}

int
__glXDisp_PixelStorei(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        CALL_PixelStorei(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                          *(GLint *) (pc + 4)
                         ));
        error = Success;
    }

    return error;
}

void
__glXDisp_PixelMapfv(GLbyte * pc)
{
    const GLsizei mapsize = *(GLsizei *) (pc + 4);

    CALL_PixelMapfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                     mapsize, (const GLfloat *) (pc + 8)
                    ));
}

void
__glXDisp_PixelMapuiv(GLbyte * pc)
{
    const GLsizei mapsize = *(GLsizei *) (pc + 4);

    CALL_PixelMapuiv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                      mapsize, (const GLuint *) (pc + 8)
                     ));
}

void
__glXDisp_PixelMapusv(GLbyte * pc)
{
    const GLsizei mapsize = *(GLsizei *) (pc + 4);

    CALL_PixelMapusv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                      mapsize, (const GLushort *) (pc + 8)
                     ));
}

void
__glXDisp_ReadBuffer(GLbyte * pc)
{
    CALL_ReadBuffer(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                    ));
}

void
__glXDisp_CopyPixels(GLbyte * pc)
{
    CALL_CopyPixels(GET_DISPATCH(), (*(GLint *) (pc + 0),
                                     *(GLint *) (pc + 4),
                                     *(GLsizei *) (pc + 8),
                                     *(GLsizei *) (pc + 12),
                                     *(GLenum *) (pc + 16)
                    ));
}

void
__glXDisp_DrawPixels(GLbyte * pc)
{
    const GLvoid *const pixels = (const GLvoid *) ((pc + 36));
    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);

    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));

    CALL_DrawPixels(GET_DISPATCH(), (*(GLsizei *) (pc + 20),
                                     *(GLsizei *) (pc + 24),
                                     *(GLenum *) (pc + 28),
                                     *(GLenum *) (pc + 32), pixels));
}

int
__glXDisp_GetBooleanv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 0);

        const GLuint compsize = __glGetBooleanv_size(pname);
        GLboolean answerBuffer[200];
        GLboolean *params =
            __glXGetAnswerBuffer(cl, compsize, answerBuffer,
                                 sizeof(answerBuffer), 1);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetBooleanv(GET_DISPATCH(), (pname, params));
        __glXSendReply(cl->client, params, compsize, 1, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetClipPlane(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        GLdouble equation[4];

        CALL_GetClipPlane(GET_DISPATCH(), (*(GLenum *) (pc + 0), equation));
        __glXSendReply(cl->client, equation, 4, 8, GL_TRUE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetDoublev(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 0);

        const GLuint compsize = __glGetDoublev_size(pname);
        GLdouble answerBuffer[200];
        GLdouble *params =
            __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
                                 sizeof(answerBuffer), 8);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetDoublev(GET_DISPATCH(), (pname, params));
        __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetError(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        GLenum retval;

        retval = CALL_GetError(GET_DISPATCH(), ());
        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetFloatv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 0);

        const GLuint compsize = __glGetFloatv_size(pname);
        GLfloat answerBuffer[200];
        GLfloat *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetFloatv(GET_DISPATCH(), (pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetIntegerv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 0);

        const GLuint compsize = __glGetIntegerv_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetIntegerv(GET_DISPATCH(), (pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetLightfv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetLightfv_size(pname);
        GLfloat answerBuffer[200];
        GLfloat *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetLightfv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetLightiv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetLightiv_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetLightiv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetMapdv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum target = *(GLenum *) (pc + 0);
        const GLenum query = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetMapdv_size(target, query);
        GLdouble answerBuffer[200];
        GLdouble *v =
            __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
                                 sizeof(answerBuffer), 8);

        if (v == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetMapdv(GET_DISPATCH(), (target, query, v));
        __glXSendReply(cl->client, v, compsize, 8, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetMapfv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum target = *(GLenum *) (pc + 0);
        const GLenum query = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetMapfv_size(target, query);
        GLfloat answerBuffer[200];
        GLfloat *v =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (v == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetMapfv(GET_DISPATCH(), (target, query, v));
        __glXSendReply(cl->client, v, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetMapiv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum target = *(GLenum *) (pc + 0);
        const GLenum query = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetMapiv_size(target, query);
        GLint answerBuffer[200];
        GLint *v =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (v == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetMapiv(GET_DISPATCH(), (target, query, v));
        __glXSendReply(cl->client, v, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetMaterialfv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetMaterialfv_size(pname);
        GLfloat answerBuffer[200];
        GLfloat *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetMaterialfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                            pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetMaterialiv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetMaterialiv_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetMaterialiv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                            pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetPixelMapfv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum map = *(GLenum *) (pc + 0);

        const GLuint compsize = __glGetPixelMapfv_size(map);
        GLfloat answerBuffer[200];
        GLfloat *values =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (values == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetPixelMapfv(GET_DISPATCH(), (map, values));
        __glXSendReply(cl->client, values, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetPixelMapuiv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum map = *(GLenum *) (pc + 0);

        const GLuint compsize = __glGetPixelMapuiv_size(map);
        GLuint answerBuffer[200];
        GLuint *values =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (values == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetPixelMapuiv(GET_DISPATCH(), (map, values));
        __glXSendReply(cl->client, values, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetPixelMapusv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum map = *(GLenum *) (pc + 0);

        const GLuint compsize = __glGetPixelMapusv_size(map);
        GLushort answerBuffer[200];
        GLushort *values =
            __glXGetAnswerBuffer(cl, compsize * 2, answerBuffer,
                                 sizeof(answerBuffer), 2);

        if (values == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetPixelMapusv(GET_DISPATCH(), (map, values));
        __glXSendReply(cl->client, values, compsize, 2, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetTexEnvfv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetTexEnvfv_size(pname);
        GLfloat answerBuffer[200];
        GLfloat *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetTexEnvfv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetTexEnviv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetTexEnviv_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetTexEnviv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetTexGendv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetTexGendv_size(pname);
        GLdouble answerBuffer[200];
        GLdouble *params =
            __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
                                 sizeof(answerBuffer), 8);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetTexGendv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
        __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetTexGenfv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetTexGenfv_size(pname);
        GLfloat answerBuffer[200];
        GLfloat *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetTexGenfv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetTexGeniv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetTexGeniv_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetTexGeniv(GET_DISPATCH(), (*(GLenum *) (pc + 0), pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetTexParameterfv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetTexParameterfv_size(pname);
        GLfloat answerBuffer[200];
        GLfloat *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetTexParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetTexParameteriv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetTexParameteriv_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetTexParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetTexLevelParameterfv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 8);

        const GLuint compsize = __glGetTexLevelParameterfv_size(pname);
        GLfloat answerBuffer[200];
        GLfloat *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetTexLevelParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                     *(GLint *) (pc + 4),
                                                     pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetTexLevelParameteriv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 8);

        const GLuint compsize = __glGetTexLevelParameteriv_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetTexLevelParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                     *(GLint *) (pc + 4),
                                                     pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_IsEnabled(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        GLboolean retval;

        retval = CALL_IsEnabled(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                                ));
        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
        error = Success;
    }

    return error;
}

int
__glXDisp_IsList(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        GLboolean retval;

        retval = CALL_IsList(GET_DISPATCH(), (*(GLuint *) (pc + 0)
                             ));
        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
        error = Success;
    }

    return error;
}

void
__glXDisp_DepthRange(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 16);
        pc -= 4;
    }
#endif

    CALL_DepthRange(GET_DISPATCH(), (*(GLclampd *) (pc + 0),
                                     *(GLclampd *) (pc + 8)
                    ));
}

void
__glXDisp_Frustum(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 48);
        pc -= 4;
    }
#endif

    CALL_Frustum(GET_DISPATCH(), (*(GLdouble *) (pc + 0),
                                  *(GLdouble *) (pc + 8),
                                  *(GLdouble *) (pc + 16),
                                  *(GLdouble *) (pc + 24),
                                  *(GLdouble *) (pc + 32),
                                  *(GLdouble *) (pc + 40)
                 ));
}

void
__glXDisp_LoadIdentity(GLbyte * pc)
{
    CALL_LoadIdentity(GET_DISPATCH(), ());
}

void
__glXDisp_LoadMatrixf(GLbyte * pc)
{
    CALL_LoadMatrixf(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                     ));
}

void
__glXDisp_LoadMatrixd(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 128);
        pc -= 4;
    }
#endif

    CALL_LoadMatrixd(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                     ));
}

void
__glXDisp_MatrixMode(GLbyte * pc)
{
    CALL_MatrixMode(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                    ));
}

void
__glXDisp_MultMatrixf(GLbyte * pc)
{
    CALL_MultMatrixf(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                     ));
}

void
__glXDisp_MultMatrixd(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 128);
        pc -= 4;
    }
#endif

    CALL_MultMatrixd(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                     ));
}

void
__glXDisp_Ortho(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 48);
        pc -= 4;
    }
#endif

    CALL_Ortho(GET_DISPATCH(), (*(GLdouble *) (pc + 0),
                                *(GLdouble *) (pc + 8),
                                *(GLdouble *) (pc + 16),
                                *(GLdouble *) (pc + 24),
                                *(GLdouble *) (pc + 32), *(GLdouble *) (pc + 40)
               ));
}

void
__glXDisp_PopMatrix(GLbyte * pc)
{
    CALL_PopMatrix(GET_DISPATCH(), ());
}

void
__glXDisp_PushMatrix(GLbyte * pc)
{
    CALL_PushMatrix(GET_DISPATCH(), ());
}

void
__glXDisp_Rotated(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 32);
        pc -= 4;
    }
#endif

    CALL_Rotated(GET_DISPATCH(), (*(GLdouble *) (pc + 0),
                                  *(GLdouble *) (pc + 8),
                                  *(GLdouble *) (pc + 16),
                                  *(GLdouble *) (pc + 24)
                 ));
}

void
__glXDisp_Rotatef(GLbyte * pc)
{
    CALL_Rotatef(GET_DISPATCH(), (*(GLfloat *) (pc + 0),
                                  *(GLfloat *) (pc + 4),
                                  *(GLfloat *) (pc + 8), *(GLfloat *) (pc + 12)
                 ));
}

void
__glXDisp_Scaled(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 24);
        pc -= 4;
    }
#endif

    CALL_Scaled(GET_DISPATCH(), (*(GLdouble *) (pc + 0),
                                 *(GLdouble *) (pc + 8), *(GLdouble *) (pc + 16)
                ));
}

void
__glXDisp_Scalef(GLbyte * pc)
{
    CALL_Scalef(GET_DISPATCH(), (*(GLfloat *) (pc + 0),
                                 *(GLfloat *) (pc + 4), *(GLfloat *) (pc + 8)
                ));
}

void
__glXDisp_Translated(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 24);
        pc -= 4;
    }
#endif

    CALL_Translated(GET_DISPATCH(), (*(GLdouble *) (pc + 0),
                                     *(GLdouble *) (pc + 8),
                                     *(GLdouble *) (pc + 16)
                    ));
}

void
__glXDisp_Translatef(GLbyte * pc)
{
    CALL_Translatef(GET_DISPATCH(), (*(GLfloat *) (pc + 0),
                                     *(GLfloat *) (pc + 4),
                                     *(GLfloat *) (pc + 8)
                    ));
}

void
__glXDisp_Viewport(GLbyte * pc)
{
    CALL_Viewport(GET_DISPATCH(), (*(GLint *) (pc + 0),
                                   *(GLint *) (pc + 4),
                                   *(GLsizei *) (pc + 8), *(GLsizei *) (pc + 12)
                  ));
}

void
__glXDisp_BindTexture(GLbyte * pc)
{
    CALL_BindTexture(GET_DISPATCH(), (*(GLenum *) (pc + 0), *(GLuint *) (pc + 4)
                     ));
}

void
__glXDisp_Indexubv(GLbyte * pc)
{
    CALL_Indexubv(GET_DISPATCH(), ((const GLubyte *) (pc + 0)
                  ));
}

void
__glXDisp_PolygonOffset(GLbyte * pc)
{
    CALL_PolygonOffset(GET_DISPATCH(), (*(GLfloat *) (pc + 0),
                                        *(GLfloat *) (pc + 4)
                       ));
}

int
__glXDisp_AreTexturesResident(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLsizei n = *(GLsizei *) (pc + 0);

        GLboolean retval;
        GLboolean answerBuffer[200];
        GLboolean *residences =
            __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
        retval =
            CALL_AreTexturesResident(GET_DISPATCH(),
                                     (n, (const GLuint *) (pc + 4),
                                      residences));
        __glXSendReply(cl->client, residences, n, 1, GL_TRUE, retval);
        error = Success;
    }

    return error;
}

int
__glXDisp_AreTexturesResidentEXT(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLsizei n = *(GLsizei *) (pc + 0);

        GLboolean retval;
        GLboolean answerBuffer[200];
        GLboolean *residences =
            __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
        retval =
            CALL_AreTexturesResident(GET_DISPATCH(),
                                     (n, (const GLuint *) (pc + 4),
                                      residences));
        __glXSendReply(cl->client, residences, n, 1, GL_TRUE, retval);
        error = Success;
    }

    return error;
}

void
__glXDisp_CopyTexImage1D(GLbyte * pc)
{
    CALL_CopyTexImage1D(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                         *(GLint *) (pc + 4),
                                         *(GLenum *) (pc + 8),
                                         *(GLint *) (pc + 12),
                                         *(GLint *) (pc + 16),
                                         *(GLsizei *) (pc + 20),
                                         *(GLint *) (pc + 24)
                        ));
}

void
__glXDisp_CopyTexImage2D(GLbyte * pc)
{
    CALL_CopyTexImage2D(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                         *(GLint *) (pc + 4),
                                         *(GLenum *) (pc + 8),
                                         *(GLint *) (pc + 12),
                                         *(GLint *) (pc + 16),
                                         *(GLsizei *) (pc + 20),
                                         *(GLsizei *) (pc + 24),
                                         *(GLint *) (pc + 28)
                        ));
}

void
__glXDisp_CopyTexSubImage1D(GLbyte * pc)
{
    CALL_CopyTexSubImage1D(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                            *(GLint *) (pc + 4),
                                            *(GLint *) (pc + 8),
                                            *(GLint *) (pc + 12),
                                            *(GLint *) (pc + 16),
                                            *(GLsizei *) (pc + 20)
                           ));
}

void
__glXDisp_CopyTexSubImage2D(GLbyte * pc)
{
    CALL_CopyTexSubImage2D(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                            *(GLint *) (pc + 4),
                                            *(GLint *) (pc + 8),
                                            *(GLint *) (pc + 12),
                                            *(GLint *) (pc + 16),
                                            *(GLint *) (pc + 20),
                                            *(GLsizei *) (pc + 24),
                                            *(GLsizei *) (pc + 28)
                           ));
}

int
__glXDisp_DeleteTextures(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLsizei n = *(GLsizei *) (pc + 0);

        CALL_DeleteTextures(GET_DISPATCH(), (n, (const GLuint *) (pc + 4)
                            ));
        error = Success;
    }

    return error;
}

int
__glXDisp_DeleteTexturesEXT(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLsizei n = *(GLsizei *) (pc + 0);

        CALL_DeleteTextures(GET_DISPATCH(), (n, (const GLuint *) (pc + 4)
                            ));
        error = Success;
    }

    return error;
}

int
__glXDisp_GenTextures(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLsizei n = *(GLsizei *) (pc + 0);

        GLuint answerBuffer[200];
        GLuint *textures =
            __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
                                 4);
        CALL_GenTextures(GET_DISPATCH(), (n, textures));
        __glXSendReply(cl->client, textures, n, 4, GL_TRUE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GenTexturesEXT(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLsizei n = *(GLsizei *) (pc + 0);

        GLuint answerBuffer[200];
        GLuint *textures =
            __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
                                 4);
        CALL_GenTextures(GET_DISPATCH(), (n, textures));
        __glXSendReply(cl->client, textures, n, 4, GL_TRUE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_IsTexture(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        GLboolean retval;

        retval = CALL_IsTexture(GET_DISPATCH(), (*(GLuint *) (pc + 0)
                                ));
        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
        error = Success;
    }

    return error;
}

int
__glXDisp_IsTextureEXT(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        GLboolean retval;

        retval = CALL_IsTexture(GET_DISPATCH(), (*(GLuint *) (pc + 0)
                                ));
        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
        error = Success;
    }

    return error;
}

void
__glXDisp_PrioritizeTextures(GLbyte * pc)
{
    const GLsizei n = *(GLsizei *) (pc + 0);

    CALL_PrioritizeTextures(GET_DISPATCH(), (n,
                                             (const GLuint *) (pc + 4),
                                             (const GLclampf *) (pc + 4)
                            ));
}

void
__glXDisp_TexSubImage1D(GLbyte * pc)
{
    const GLvoid *const pixels = (const GLvoid *) ((pc + 56));
    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);

    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));

    CALL_TexSubImage1D(GET_DISPATCH(), (*(GLenum *) (pc + 20),
                                        *(GLint *) (pc + 24),
                                        *(GLint *) (pc + 28),
                                        *(GLsizei *) (pc + 36),
                                        *(GLenum *) (pc + 44),
                                        *(GLenum *) (pc + 48), pixels));
}

void
__glXDisp_TexSubImage2D(GLbyte * pc)
{
    const GLvoid *const pixels = (const GLvoid *) ((pc + 56));
    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);

    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));

    CALL_TexSubImage2D(GET_DISPATCH(), (*(GLenum *) (pc + 20),
                                        *(GLint *) (pc + 24),
                                        *(GLint *) (pc + 28),
                                        *(GLint *) (pc + 32),
                                        *(GLsizei *) (pc + 36),
                                        *(GLsizei *) (pc + 40),
                                        *(GLenum *) (pc + 44),
                                        *(GLenum *) (pc + 48), pixels));
}

void
__glXDisp_BlendColor(GLbyte * pc)
{
    CALL_BlendColor(GET_DISPATCH(), (*(GLclampf *) (pc + 0),
                                     *(GLclampf *) (pc + 4),
                                     *(GLclampf *) (pc + 8),
                                     *(GLclampf *) (pc + 12)
                    ));
}

void
__glXDisp_BlendEquation(GLbyte * pc)
{
    CALL_BlendEquation(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                       ));
}

void
__glXDisp_ColorTable(GLbyte * pc)
{
    const GLvoid *const table = (const GLvoid *) ((pc + 40));
    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);

    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));

    CALL_ColorTable(GET_DISPATCH(), (*(GLenum *) (pc + 20),
                                     *(GLenum *) (pc + 24),
                                     *(GLsizei *) (pc + 28),
                                     *(GLenum *) (pc + 32),
                                     *(GLenum *) (pc + 36), table));
}

void
__glXDisp_ColorTableParameterfv(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 4);
    const GLfloat *params;

    params = (const GLfloat *) (pc + 8);

    CALL_ColorTableParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                pname, params));
}

void
__glXDisp_ColorTableParameteriv(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 4);
    const GLint *params;

    params = (const GLint *) (pc + 8);

    CALL_ColorTableParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                pname, params));
}

void
__glXDisp_CopyColorTable(GLbyte * pc)
{
    CALL_CopyColorTable(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                         *(GLenum *) (pc + 4),
                                         *(GLint *) (pc + 8),
                                         *(GLint *) (pc + 12),
                                         *(GLsizei *) (pc + 16)
                        ));
}

int
__glXDisp_GetColorTableParameterfv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetColorTableParameterfv_size(pname);
        GLfloat answerBuffer[200];
        GLfloat *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetColorTableParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                       pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetColorTableParameterfvSGI(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetColorTableParameterfv_size(pname);
        GLfloat answerBuffer[200];
        GLfloat *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetColorTableParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                       pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetColorTableParameteriv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetColorTableParameteriv_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetColorTableParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                       pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetColorTableParameterivSGI(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetColorTableParameteriv_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetColorTableParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                       pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

void
__glXDisp_ColorSubTable(GLbyte * pc)
{
    const GLvoid *const data = (const GLvoid *) ((pc + 40));
    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);

    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));

    CALL_ColorSubTable(GET_DISPATCH(), (*(GLenum *) (pc + 20),
                                        *(GLsizei *) (pc + 24),
                                        *(GLsizei *) (pc + 28),
                                        *(GLenum *) (pc + 32),
                                        *(GLenum *) (pc + 36), data));
}

void
__glXDisp_CopyColorSubTable(GLbyte * pc)
{
    CALL_CopyColorSubTable(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                            *(GLsizei *) (pc + 4),
                                            *(GLint *) (pc + 8),
                                            *(GLint *) (pc + 12),
                                            *(GLsizei *) (pc + 16)
                           ));
}

void
__glXDisp_ConvolutionFilter1D(GLbyte * pc)
{
    const GLvoid *const image = (const GLvoid *) ((pc + 44));
    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);

    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));

    CALL_ConvolutionFilter1D(GET_DISPATCH(), (*(GLenum *) (pc + 20),
                                              *(GLenum *) (pc + 24),
                                              *(GLsizei *) (pc + 28),
                                              *(GLenum *) (pc + 36),
                                              *(GLenum *) (pc + 40), image));
}

void
__glXDisp_ConvolutionFilter2D(GLbyte * pc)
{
    const GLvoid *const image = (const GLvoid *) ((pc + 44));
    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);

    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));

    CALL_ConvolutionFilter2D(GET_DISPATCH(), (*(GLenum *) (pc + 20),
                                              *(GLenum *) (pc + 24),
                                              *(GLsizei *) (pc + 28),
                                              *(GLsizei *) (pc + 32),
                                              *(GLenum *) (pc + 36),
                                              *(GLenum *) (pc + 40), image));
}

void
__glXDisp_ConvolutionParameterf(GLbyte * pc)
{
    CALL_ConvolutionParameterf(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                *(GLenum *) (pc + 4),
                                                *(GLfloat *) (pc + 8)
                               ));
}

void
__glXDisp_ConvolutionParameterfv(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 4);
    const GLfloat *params;

    params = (const GLfloat *) (pc + 8);

    CALL_ConvolutionParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                 pname, params));
}

void
__glXDisp_ConvolutionParameteri(GLbyte * pc)
{
    CALL_ConvolutionParameteri(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                *(GLenum *) (pc + 4),
                                                *(GLint *) (pc + 8)
                               ));
}

void
__glXDisp_ConvolutionParameteriv(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 4);
    const GLint *params;

    params = (const GLint *) (pc + 8);

    CALL_ConvolutionParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                 pname, params));
}

void
__glXDisp_CopyConvolutionFilter1D(GLbyte * pc)
{
    CALL_CopyConvolutionFilter1D(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                  *(GLenum *) (pc + 4),
                                                  *(GLint *) (pc + 8),
                                                  *(GLint *) (pc + 12),
                                                  *(GLsizei *) (pc + 16)
                                 ));
}

void
__glXDisp_CopyConvolutionFilter2D(GLbyte * pc)
{
    CALL_CopyConvolutionFilter2D(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                  *(GLenum *) (pc + 4),
                                                  *(GLint *) (pc + 8),
                                                  *(GLint *) (pc + 12),
                                                  *(GLsizei *) (pc + 16),
                                                  *(GLsizei *) (pc + 20)
                                 ));
}

int
__glXDisp_GetConvolutionParameterfv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetConvolutionParameterfv_size(pname);
        GLfloat answerBuffer[200];
        GLfloat *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetConvolutionParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                        pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetConvolutionParameterfvEXT(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetConvolutionParameterfv_size(pname);
        GLfloat answerBuffer[200];
        GLfloat *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetConvolutionParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                        pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetConvolutionParameteriv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetConvolutionParameteriv_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetConvolutionParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                        pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetConvolutionParameterivEXT(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetConvolutionParameteriv_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetConvolutionParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                        pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetHistogramParameterfv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetHistogramParameterfv_size(pname);
        GLfloat answerBuffer[200];
        GLfloat *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetHistogramParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                      pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetHistogramParameterfvEXT(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetHistogramParameterfv_size(pname);
        GLfloat answerBuffer[200];
        GLfloat *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetHistogramParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                      pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetHistogramParameteriv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetHistogramParameteriv_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetHistogramParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                      pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetHistogramParameterivEXT(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetHistogramParameteriv_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetHistogramParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                      pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetMinmaxParameterfv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetMinmaxParameterfv_size(pname);
        GLfloat answerBuffer[200];
        GLfloat *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetMinmaxParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                   pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetMinmaxParameterfvEXT(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetMinmaxParameterfv_size(pname);
        GLfloat answerBuffer[200];
        GLfloat *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetMinmaxParameterfv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                   pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetMinmaxParameteriv(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetMinmaxParameteriv_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetMinmaxParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                   pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetMinmaxParameterivEXT(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetMinmaxParameteriv_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetMinmaxParameteriv(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                   pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

void
__glXDisp_Histogram(GLbyte * pc)
{
    CALL_Histogram(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                    *(GLsizei *) (pc + 4),
                                    *(GLenum *) (pc + 8),
                                    *(GLboolean *) (pc + 12)
                   ));
}

void
__glXDisp_Minmax(GLbyte * pc)
{
    CALL_Minmax(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                 *(GLenum *) (pc + 4), *(GLboolean *) (pc + 8)
                ));
}

void
__glXDisp_ResetHistogram(GLbyte * pc)
{
    CALL_ResetHistogram(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                        ));
}

void
__glXDisp_ResetMinmax(GLbyte * pc)
{
    CALL_ResetMinmax(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                     ));
}

void
__glXDisp_TexImage3D(GLbyte * pc)
{
    const CARD32 ptr_is_null = *(CARD32 *) (pc + 76);
    const GLvoid *const pixels =
        (const GLvoid *) ((ptr_is_null != 0) ? NULL : (pc + 80));
    __GLXpixel3DHeader *const hdr = (__GLXpixel3DHeader *) (pc);

    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_IMAGES, (GLint) hdr->skipImages));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));

    CALL_TexImage3D(GET_DISPATCH(), (*(GLenum *) (pc + 36),
                                     *(GLint *) (pc + 40),
                                     *(GLint *) (pc + 44),
                                     *(GLsizei *) (pc + 48),
                                     *(GLsizei *) (pc + 52),
                                     *(GLsizei *) (pc + 56),
                                     *(GLint *) (pc + 64),
                                     *(GLenum *) (pc + 68),
                                     *(GLenum *) (pc + 72), pixels));
}

void
__glXDisp_TexSubImage3D(GLbyte * pc)
{
    const GLvoid *const pixels = (const GLvoid *) ((pc + 88));
    __GLXpixel3DHeader *const hdr = (__GLXpixel3DHeader *) (pc);

    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes));
    CALL_PixelStorei(GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_IMAGES, (GLint) hdr->skipImages));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels));
    CALL_PixelStorei(GET_DISPATCH(),
                     (GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment));

    CALL_TexSubImage3D(GET_DISPATCH(), (*(GLenum *) (pc + 36),
                                        *(GLint *) (pc + 40),
                                        *(GLint *) (pc + 44),
                                        *(GLint *) (pc + 48),
                                        *(GLint *) (pc + 52),
                                        *(GLsizei *) (pc + 60),
                                        *(GLsizei *) (pc + 64),
                                        *(GLsizei *) (pc + 68),
                                        *(GLenum *) (pc + 76),
                                        *(GLenum *) (pc + 80), pixels));
}

void
__glXDisp_CopyTexSubImage3D(GLbyte * pc)
{
    CALL_CopyTexSubImage3D(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                            *(GLint *) (pc + 4),
                                            *(GLint *) (pc + 8),
                                            *(GLint *) (pc + 12),
                                            *(GLint *) (pc + 16),
                                            *(GLint *) (pc + 20),
                                            *(GLint *) (pc + 24),
                                            *(GLsizei *) (pc + 28),
                                            *(GLsizei *) (pc + 32)
                           ));
}

void
__glXDisp_ActiveTextureARB(GLbyte * pc)
{
    CALL_ActiveTextureARB(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                          ));
}

void
__glXDisp_MultiTexCoord1dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 12);
        pc -= 4;
    }
#endif

    CALL_MultiTexCoord1dvARB(GET_DISPATCH(), (*(GLenum *) (pc + 8),
                                              (const GLdouble *) (pc + 0)
                             ));
}

void
__glXDisp_MultiTexCoord1fvARB(GLbyte * pc)
{
    CALL_MultiTexCoord1fvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                              (const GLfloat *) (pc + 4)
                             ));
}

void
__glXDisp_MultiTexCoord1ivARB(GLbyte * pc)
{
    CALL_MultiTexCoord1ivARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                              (const GLint *) (pc + 4)
                             ));
}

void
__glXDisp_MultiTexCoord1svARB(GLbyte * pc)
{
    CALL_MultiTexCoord1svARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                              (const GLshort *) (pc + 4)
                             ));
}

void
__glXDisp_MultiTexCoord2dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 20);
        pc -= 4;
    }
#endif

    CALL_MultiTexCoord2dvARB(GET_DISPATCH(), (*(GLenum *) (pc + 16),
                                              (const GLdouble *) (pc + 0)
                             ));
}

void
__glXDisp_MultiTexCoord2fvARB(GLbyte * pc)
{
    CALL_MultiTexCoord2fvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                              (const GLfloat *) (pc + 4)
                             ));
}

void
__glXDisp_MultiTexCoord2ivARB(GLbyte * pc)
{
    CALL_MultiTexCoord2ivARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                              (const GLint *) (pc + 4)
                             ));
}

void
__glXDisp_MultiTexCoord2svARB(GLbyte * pc)
{
    CALL_MultiTexCoord2svARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                              (const GLshort *) (pc + 4)
                             ));
}

void
__glXDisp_MultiTexCoord3dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 28);
        pc -= 4;
    }
#endif

    CALL_MultiTexCoord3dvARB(GET_DISPATCH(), (*(GLenum *) (pc + 24),
                                              (const GLdouble *) (pc + 0)
                             ));
}

void
__glXDisp_MultiTexCoord3fvARB(GLbyte * pc)
{
    CALL_MultiTexCoord3fvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                              (const GLfloat *) (pc + 4)
                             ));
}

void
__glXDisp_MultiTexCoord3ivARB(GLbyte * pc)
{
    CALL_MultiTexCoord3ivARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                              (const GLint *) (pc + 4)
                             ));
}

void
__glXDisp_MultiTexCoord3svARB(GLbyte * pc)
{
    CALL_MultiTexCoord3svARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                              (const GLshort *) (pc + 4)
                             ));
}

void
__glXDisp_MultiTexCoord4dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 36);
        pc -= 4;
    }
#endif

    CALL_MultiTexCoord4dvARB(GET_DISPATCH(), (*(GLenum *) (pc + 32),
                                              (const GLdouble *) (pc + 0)
                             ));
}

void
__glXDisp_MultiTexCoord4fvARB(GLbyte * pc)
{
    CALL_MultiTexCoord4fvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                              (const GLfloat *) (pc + 4)
                             ));
}

void
__glXDisp_MultiTexCoord4ivARB(GLbyte * pc)
{
    CALL_MultiTexCoord4ivARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                              (const GLint *) (pc + 4)
                             ));
}

void
__glXDisp_MultiTexCoord4svARB(GLbyte * pc)
{
    CALL_MultiTexCoord4svARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                              (const GLshort *) (pc + 4)
                             ));
}

void
__glXDisp_SampleCoverageARB(GLbyte * pc)
{
    CALL_SampleCoverageARB(GET_DISPATCH(), (*(GLclampf *) (pc + 0),
                                            *(GLboolean *) (pc + 4)
                           ));
}

void
__glXDisp_CompressedTexImage1DARB(GLbyte * pc)
{
    const GLsizei imageSize = *(GLsizei *) (pc + 20);

    CALL_CompressedTexImage1DARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                  *(GLint *) (pc + 4),
                                                  *(GLenum *) (pc + 8),
                                                  *(GLsizei *) (pc + 12),
                                                  *(GLint *) (pc + 16),
                                                  imageSize,
                                                  (const GLvoid *) (pc + 24)
                                 ));
}

void
__glXDisp_CompressedTexImage2DARB(GLbyte * pc)
{
    const GLsizei imageSize = *(GLsizei *) (pc + 24);

    CALL_CompressedTexImage2DARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                  *(GLint *) (pc + 4),
                                                  *(GLenum *) (pc + 8),
                                                  *(GLsizei *) (pc + 12),
                                                  *(GLsizei *) (pc + 16),
                                                  *(GLint *) (pc + 20),
                                                  imageSize,
                                                  (const GLvoid *) (pc + 28)
                                 ));
}

void
__glXDisp_CompressedTexImage3DARB(GLbyte * pc)
{
    const GLsizei imageSize = *(GLsizei *) (pc + 28);

    CALL_CompressedTexImage3DARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                  *(GLint *) (pc + 4),
                                                  *(GLenum *) (pc + 8),
                                                  *(GLsizei *) (pc + 12),
                                                  *(GLsizei *) (pc + 16),
                                                  *(GLsizei *) (pc + 20),
                                                  *(GLint *) (pc + 24),
                                                  imageSize,
                                                  (const GLvoid *) (pc + 32)
                                 ));
}

void
__glXDisp_CompressedTexSubImage1DARB(GLbyte * pc)
{
    const GLsizei imageSize = *(GLsizei *) (pc + 20);

    CALL_CompressedTexSubImage1DARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                     *(GLint *) (pc + 4),
                                                     *(GLint *) (pc + 8),
                                                     *(GLsizei *) (pc + 12),
                                                     *(GLenum *) (pc + 16),
                                                     imageSize,
                                                     (const GLvoid *) (pc + 24)
                                    ));
}

void
__glXDisp_CompressedTexSubImage2DARB(GLbyte * pc)
{
    const GLsizei imageSize = *(GLsizei *) (pc + 28);

    CALL_CompressedTexSubImage2DARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                     *(GLint *) (pc + 4),
                                                     *(GLint *) (pc + 8),
                                                     *(GLint *) (pc + 12),
                                                     *(GLsizei *) (pc + 16),
                                                     *(GLsizei *) (pc + 20),
                                                     *(GLenum *) (pc + 24),
                                                     imageSize,
                                                     (const GLvoid *) (pc + 32)
                                    ));
}

void
__glXDisp_CompressedTexSubImage3DARB(GLbyte * pc)
{
    const GLsizei imageSize = *(GLsizei *) (pc + 36);

    CALL_CompressedTexSubImage3DARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                     *(GLint *) (pc + 4),
                                                     *(GLint *) (pc + 8),
                                                     *(GLint *) (pc + 12),
                                                     *(GLint *) (pc + 16),
                                                     *(GLsizei *) (pc + 20),
                                                     *(GLsizei *) (pc + 24),
                                                     *(GLsizei *) (pc + 28),
                                                     *(GLenum *) (pc + 32),
                                                     imageSize,
                                                     (const GLvoid *) (pc + 40)
                                    ));
}

int
__glXDisp_GetProgramEnvParameterdvARB(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        GLdouble params[4];

        CALL_GetProgramEnvParameterdvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                          *(GLuint *) (pc + 4),
                                                          params));
        __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetProgramEnvParameterfvARB(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        GLfloat params[4];

        CALL_GetProgramEnvParameterfvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                          *(GLuint *) (pc + 4),
                                                          params));
        __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetProgramLocalParameterdvARB(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        GLdouble params[4];

        CALL_GetProgramLocalParameterdvARB(GET_DISPATCH(),
                                           (*(GLenum *) (pc + 0),
                                            *(GLuint *) (pc + 4), params));
        __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetProgramLocalParameterfvARB(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        GLfloat params[4];

        CALL_GetProgramLocalParameterfvARB(GET_DISPATCH(),
                                           (*(GLenum *) (pc + 0),
                                            *(GLuint *) (pc + 4), params));
        __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetProgramivARB(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetProgramivARB_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetProgramivARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                              pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetVertexAttribdvARB(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetVertexAttribdvARB_size(pname);
        GLdouble answerBuffer[200];
        GLdouble *params =
            __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
                                 sizeof(answerBuffer), 8);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetVertexAttribdvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                                   pname, params));
        __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetVertexAttribfvARB(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetVertexAttribfvARB_size(pname);
        GLfloat answerBuffer[200];
        GLfloat *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetVertexAttribfvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                                   pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetVertexAttribivARB(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetVertexAttribivARB_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetVertexAttribivARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                                   pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

void
__glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 40);
        pc -= 4;
    }
#endif

    CALL_ProgramEnvParameter4dvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                    *(GLuint *) (pc + 4),
                                                    (const GLdouble *) (pc + 8)
                                   ));
}

void
__glXDisp_ProgramEnvParameter4fvARB(GLbyte * pc)
{
    CALL_ProgramEnvParameter4fvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                    *(GLuint *) (pc + 4),
                                                    (const GLfloat *) (pc + 8)
                                   ));
}

void
__glXDisp_ProgramLocalParameter4dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 40);
        pc -= 4;
    }
#endif

    CALL_ProgramLocalParameter4dvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                      *(GLuint *) (pc + 4),
                                                      (const GLdouble *) (pc +
                                                                          8)
                                     ));
}

void
__glXDisp_ProgramLocalParameter4fvARB(GLbyte * pc)
{
    CALL_ProgramLocalParameter4fvARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                      *(GLuint *) (pc + 4),
                                                      (const GLfloat *) (pc + 8)
                                     ));
}

void
__glXDisp_ProgramStringARB(GLbyte * pc)
{
    const GLsizei len = *(GLsizei *) (pc + 8);

    CALL_ProgramStringARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                           *(GLenum *) (pc + 4),
                                           len, (const GLvoid *) (pc + 12)
                          ));
}

void
__glXDisp_VertexAttrib1dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 12);
        pc -= 4;
    }
#endif

    CALL_VertexAttrib1dvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             (const GLdouble *) (pc + 4)
                            ));
}

void
__glXDisp_VertexAttrib1fvARB(GLbyte * pc)
{
    CALL_VertexAttrib1fvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             (const GLfloat *) (pc + 4)
                            ));
}

void
__glXDisp_VertexAttrib1svARB(GLbyte * pc)
{
    CALL_VertexAttrib1svARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             (const GLshort *) (pc + 4)
                            ));
}

void
__glXDisp_VertexAttrib2dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 20);
        pc -= 4;
    }
#endif

    CALL_VertexAttrib2dvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             (const GLdouble *) (pc + 4)
                            ));
}

void
__glXDisp_VertexAttrib2fvARB(GLbyte * pc)
{
    CALL_VertexAttrib2fvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             (const GLfloat *) (pc + 4)
                            ));
}

void
__glXDisp_VertexAttrib2svARB(GLbyte * pc)
{
    CALL_VertexAttrib2svARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             (const GLshort *) (pc + 4)
                            ));
}

void
__glXDisp_VertexAttrib3dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 28);
        pc -= 4;
    }
#endif

    CALL_VertexAttrib3dvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             (const GLdouble *) (pc + 4)
                            ));
}

void
__glXDisp_VertexAttrib3fvARB(GLbyte * pc)
{
    CALL_VertexAttrib3fvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             (const GLfloat *) (pc + 4)
                            ));
}

void
__glXDisp_VertexAttrib3svARB(GLbyte * pc)
{
    CALL_VertexAttrib3svARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             (const GLshort *) (pc + 4)
                            ));
}

void
__glXDisp_VertexAttrib4NbvARB(GLbyte * pc)
{
    CALL_VertexAttrib4NbvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                              (const GLbyte *) (pc + 4)
                             ));
}

void
__glXDisp_VertexAttrib4NivARB(GLbyte * pc)
{
    CALL_VertexAttrib4NivARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                              (const GLint *) (pc + 4)
                             ));
}

void
__glXDisp_VertexAttrib4NsvARB(GLbyte * pc)
{
    CALL_VertexAttrib4NsvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                              (const GLshort *) (pc + 4)
                             ));
}

void
__glXDisp_VertexAttrib4NubvARB(GLbyte * pc)
{
    CALL_VertexAttrib4NubvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                               (const GLubyte *) (pc + 4)
                              ));
}

void
__glXDisp_VertexAttrib4NuivARB(GLbyte * pc)
{
    CALL_VertexAttrib4NuivARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                               (const GLuint *) (pc + 4)
                              ));
}

void
__glXDisp_VertexAttrib4NusvARB(GLbyte * pc)
{
    CALL_VertexAttrib4NusvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                               (const GLushort *) (pc + 4)
                              ));
}

void
__glXDisp_VertexAttrib4bvARB(GLbyte * pc)
{
    CALL_VertexAttrib4bvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             (const GLbyte *) (pc + 4)
                            ));
}

void
__glXDisp_VertexAttrib4dvARB(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 36);
        pc -= 4;
    }
#endif

    CALL_VertexAttrib4dvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             (const GLdouble *) (pc + 4)
                            ));
}

void
__glXDisp_VertexAttrib4fvARB(GLbyte * pc)
{
    CALL_VertexAttrib4fvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             (const GLfloat *) (pc + 4)
                            ));
}

void
__glXDisp_VertexAttrib4ivARB(GLbyte * pc)
{
    CALL_VertexAttrib4ivARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             (const GLint *) (pc + 4)
                            ));
}

void
__glXDisp_VertexAttrib4svARB(GLbyte * pc)
{
    CALL_VertexAttrib4svARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             (const GLshort *) (pc + 4)
                            ));
}

void
__glXDisp_VertexAttrib4ubvARB(GLbyte * pc)
{
    CALL_VertexAttrib4ubvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                              (const GLubyte *) (pc + 4)
                             ));
}

void
__glXDisp_VertexAttrib4uivARB(GLbyte * pc)
{
    CALL_VertexAttrib4uivARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                              (const GLuint *) (pc + 4)
                             ));
}

void
__glXDisp_VertexAttrib4usvARB(GLbyte * pc)
{
    CALL_VertexAttrib4usvARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                              (const GLushort *) (pc + 4)
                             ));
}

void
__glXDisp_BeginQueryARB(GLbyte * pc)
{
    CALL_BeginQueryARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                        *(GLuint *) (pc + 4)
                       ));
}

int
__glXDisp_DeleteQueriesARB(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLsizei n = *(GLsizei *) (pc + 0);

        CALL_DeleteQueriesARB(GET_DISPATCH(), (n, (const GLuint *) (pc + 4)
                              ));
        error = Success;
    }

    return error;
}

void
__glXDisp_EndQueryARB(GLbyte * pc)
{
    CALL_EndQueryARB(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                     ));
}

int
__glXDisp_GenQueriesARB(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLsizei n = *(GLsizei *) (pc + 0);

        GLuint answerBuffer[200];
        GLuint *ids =
            __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
                                 4);
        CALL_GenQueriesARB(GET_DISPATCH(), (n, ids));
        __glXSendReply(cl->client, ids, n, 4, GL_TRUE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetQueryObjectivARB(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetQueryObjectivARB_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetQueryObjectivARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                                  pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetQueryObjectuivARB(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetQueryObjectuivARB_size(pname);
        GLuint answerBuffer[200];
        GLuint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetQueryObjectuivARB(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                                   pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetQueryivARB(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetQueryivARB_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetQueryivARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                            pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_IsQueryARB(__GLXclientState * cl, GLbyte * pc)
{
    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_SINGLE_HDR_SIZE;
    if (cx != NULL) {
        GLboolean retval;

        retval = CALL_IsQueryARB(GET_DISPATCH(), (*(GLuint *) (pc + 0)
                                 ));
        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
        error = Success;
    }

    return error;
}

void
__glXDisp_DrawBuffersARB(GLbyte * pc)
{
    const GLsizei n = *(GLsizei *) (pc + 0);

    CALL_DrawBuffersARB(GET_DISPATCH(), (n, (const GLenum *) (pc + 4)
                        ));
}

void
__glXDisp_ClampColorARB(GLbyte * pc)
{
    CALL_ClampColorARB(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                        *(GLenum *) (pc + 4)
                       ));
}

void
__glXDisp_RenderbufferStorageMultisample(GLbyte * pc)
{
    CALL_RenderbufferStorageMultisample(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                         *(GLsizei *) (pc + 4),
                                                         *(GLenum *) (pc + 8),
                                                         *(GLsizei *) (pc + 12),
                                                         *(GLsizei *) (pc + 16)
                                        ));
}

void
__glXDisp_SampleMaskSGIS(GLbyte * pc)
{
    CALL_SampleMaskSGIS(GET_DISPATCH(), (*(GLclampf *) (pc + 0),
                                         *(GLboolean *) (pc + 4)
                        ));
}

void
__glXDisp_SamplePatternSGIS(GLbyte * pc)
{
    CALL_SamplePatternSGIS(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                           ));
}

void
__glXDisp_PointParameterfEXT(GLbyte * pc)
{
    CALL_PointParameterfEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                             *(GLfloat *) (pc + 4)
                            ));
}

void
__glXDisp_PointParameterfvEXT(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 0);
    const GLfloat *params;

    params = (const GLfloat *) (pc + 4);

    CALL_PointParameterfvEXT(GET_DISPATCH(), (pname, params));
}

void
__glXDisp_SecondaryColor3bvEXT(GLbyte * pc)
{
    CALL_SecondaryColor3bvEXT(GET_DISPATCH(), ((const GLbyte *) (pc + 0)
                              ));
}

void
__glXDisp_SecondaryColor3dvEXT(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 24);
        pc -= 4;
    }
#endif

    CALL_SecondaryColor3dvEXT(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                              ));
}

void
__glXDisp_SecondaryColor3fvEXT(GLbyte * pc)
{
    CALL_SecondaryColor3fvEXT(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                              ));
}

void
__glXDisp_SecondaryColor3ivEXT(GLbyte * pc)
{
    CALL_SecondaryColor3ivEXT(GET_DISPATCH(), ((const GLint *) (pc + 0)
                              ));
}

void
__glXDisp_SecondaryColor3svEXT(GLbyte * pc)
{
    CALL_SecondaryColor3svEXT(GET_DISPATCH(), ((const GLshort *) (pc + 0)
                              ));
}

void
__glXDisp_SecondaryColor3ubvEXT(GLbyte * pc)
{
    CALL_SecondaryColor3ubvEXT(GET_DISPATCH(), ((const GLubyte *) (pc + 0)
                               ));
}

void
__glXDisp_SecondaryColor3uivEXT(GLbyte * pc)
{
    CALL_SecondaryColor3uivEXT(GET_DISPATCH(), ((const GLuint *) (pc + 0)
                               ));
}

void
__glXDisp_SecondaryColor3usvEXT(GLbyte * pc)
{
    CALL_SecondaryColor3usvEXT(GET_DISPATCH(), ((const GLushort *) (pc + 0)
                               ));
}

void
__glXDisp_FogCoorddvEXT(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 8);
        pc -= 4;
    }
#endif

    CALL_FogCoorddvEXT(GET_DISPATCH(), ((const GLdouble *) (pc + 0)
                       ));
}

void
__glXDisp_FogCoordfvEXT(GLbyte * pc)
{
    CALL_FogCoordfvEXT(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                       ));
}

void
__glXDisp_BlendFuncSeparateEXT(GLbyte * pc)
{
    CALL_BlendFuncSeparateEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                               *(GLenum *) (pc + 4),
                                               *(GLenum *) (pc + 8),
                                               *(GLenum *) (pc + 12)
                              ));
}

void
__glXDisp_WindowPos3fvMESA(GLbyte * pc)
{
    CALL_WindowPos3fvMESA(GET_DISPATCH(), ((const GLfloat *) (pc + 0)
                          ));
}

int
__glXDisp_AreProgramsResidentNV(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLsizei n = *(GLsizei *) (pc + 0);

        GLboolean retval;
        GLboolean answerBuffer[200];
        GLboolean *residences =
            __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
        retval =
            CALL_AreProgramsResidentNV(GET_DISPATCH(),
                                       (n, (const GLuint *) (pc + 4),
                                        residences));
        __glXSendReply(cl->client, residences, n, 1, GL_FALSE, retval);
        error = Success;
    }

    return error;
}

void
__glXDisp_BindProgramNV(GLbyte * pc)
{
    CALL_BindProgramNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                        *(GLuint *) (pc + 4)
                       ));
}

int
__glXDisp_DeleteProgramsNV(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLsizei n = *(GLsizei *) (pc + 0);

        CALL_DeleteProgramsNV(GET_DISPATCH(), (n, (const GLuint *) (pc + 4)
                              ));
        error = Success;
    }

    return error;
}

void
__glXDisp_ExecuteProgramNV(GLbyte * pc)
{
    CALL_ExecuteProgramNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                           *(GLuint *) (pc + 4),
                                           (const GLfloat *) (pc + 8)
                          ));
}

int
__glXDisp_GenProgramsNV(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLsizei n = *(GLsizei *) (pc + 0);

        GLuint answerBuffer[200];
        GLuint *programs =
            __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
                                 4);
        CALL_GenProgramsNV(GET_DISPATCH(), (n, programs));
        __glXSendReply(cl->client, programs, n, 4, GL_TRUE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetProgramParameterdvNV(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        GLdouble params[4];

        CALL_GetProgramParameterdvNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                      *(GLuint *) (pc + 4),
                                                      *(GLenum *) (pc + 8),
                                                      params));
        __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetProgramParameterfvNV(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        GLfloat params[4];

        CALL_GetProgramParameterfvNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                      *(GLuint *) (pc + 4),
                                                      *(GLenum *) (pc + 8),
                                                      params));
        __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetProgramivNV(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetProgramivNV_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetProgramivNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetTrackMatrixivNV(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        GLint params[1];

        CALL_GetTrackMatrixivNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                 *(GLuint *) (pc + 4),
                                                 *(GLenum *) (pc + 8), params));
        __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetVertexAttribdvNV(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetVertexAttribdvNV_size(pname);
        GLdouble answerBuffer[200];
        GLdouble *params =
            __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
                                 sizeof(answerBuffer), 8);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetVertexAttribdvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                                  pname, params));
        __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetVertexAttribfvNV(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetVertexAttribfvNV_size(pname);
        GLfloat answerBuffer[200];
        GLfloat *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetVertexAttribfvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                                  pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetVertexAttribivNV(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLenum pname = *(GLenum *) (pc + 4);

        const GLuint compsize = __glGetVertexAttribivNV_size(pname);
        GLint answerBuffer[200];
        GLint *params =
            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
                                 sizeof(answerBuffer), 4);

        if (params == NULL)
            return BadAlloc;
        __glXClearErrorOccured();

        CALL_GetVertexAttribivNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                                  pname, params));
        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_IsProgramNV(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        GLboolean retval;

        retval = CALL_IsProgramNV(GET_DISPATCH(), (*(GLuint *) (pc + 0)
                                  ));
        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
        error = Success;
    }

    return error;
}

void
__glXDisp_LoadProgramNV(GLbyte * pc)
{
    const GLsizei len = *(GLsizei *) (pc + 8);

    CALL_LoadProgramNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                        *(GLuint *) (pc + 4),
                                        len, (const GLubyte *) (pc + 12)
                       ));
}

void
__glXDisp_ProgramParameters4dvNV(GLbyte * pc)
{
    const GLsizei num = *(GLsizei *) (pc + 8);

#ifdef __GLX_ALIGN64
    const GLuint cmdlen = 16 + __GLX_PAD((num * 32)) - 4;

    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, cmdlen);
        pc -= 4;
    }
#endif

    CALL_ProgramParameters4dvNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                 *(GLuint *) (pc + 4),
                                                 num,
                                                 (const GLdouble *) (pc + 12)
                                ));
}

void
__glXDisp_ProgramParameters4fvNV(GLbyte * pc)
{
    const GLsizei num = *(GLsizei *) (pc + 8);

    CALL_ProgramParameters4fvNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                 *(GLuint *) (pc + 4),
                                                 num,
                                                 (const GLfloat *) (pc + 12)
                                ));
}

void
__glXDisp_RequestResidentProgramsNV(GLbyte * pc)
{
    const GLsizei n = *(GLsizei *) (pc + 0);

    CALL_RequestResidentProgramsNV(GET_DISPATCH(), (n, (const GLuint *) (pc + 4)
                                   ));
}

void
__glXDisp_TrackMatrixNV(GLbyte * pc)
{
    CALL_TrackMatrixNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                        *(GLuint *) (pc + 4),
                                        *(GLenum *) (pc + 8),
                                        *(GLenum *) (pc + 12)
                       ));
}

void
__glXDisp_VertexAttrib1dvNV(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 12);
        pc -= 4;
    }
#endif

    CALL_VertexAttrib1dvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                            (const GLdouble *) (pc + 4)
                           ));
}

void
__glXDisp_VertexAttrib1fvNV(GLbyte * pc)
{
    CALL_VertexAttrib1fvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                            (const GLfloat *) (pc + 4)
                           ));
}

void
__glXDisp_VertexAttrib1svNV(GLbyte * pc)
{
    CALL_VertexAttrib1svNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                            (const GLshort *) (pc + 4)
                           ));
}

void
__glXDisp_VertexAttrib2dvNV(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 20);
        pc -= 4;
    }
#endif

    CALL_VertexAttrib2dvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                            (const GLdouble *) (pc + 4)
                           ));
}

void
__glXDisp_VertexAttrib2fvNV(GLbyte * pc)
{
    CALL_VertexAttrib2fvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                            (const GLfloat *) (pc + 4)
                           ));
}

void
__glXDisp_VertexAttrib2svNV(GLbyte * pc)
{
    CALL_VertexAttrib2svNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                            (const GLshort *) (pc + 4)
                           ));
}

void
__glXDisp_VertexAttrib3dvNV(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 28);
        pc -= 4;
    }
#endif

    CALL_VertexAttrib3dvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                            (const GLdouble *) (pc + 4)
                           ));
}

void
__glXDisp_VertexAttrib3fvNV(GLbyte * pc)
{
    CALL_VertexAttrib3fvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                            (const GLfloat *) (pc + 4)
                           ));
}

void
__glXDisp_VertexAttrib3svNV(GLbyte * pc)
{
    CALL_VertexAttrib3svNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                            (const GLshort *) (pc + 4)
                           ));
}

void
__glXDisp_VertexAttrib4dvNV(GLbyte * pc)
{
#ifdef __GLX_ALIGN64
    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, 36);
        pc -= 4;
    }
#endif

    CALL_VertexAttrib4dvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                            (const GLdouble *) (pc + 4)
                           ));
}

void
__glXDisp_VertexAttrib4fvNV(GLbyte * pc)
{
    CALL_VertexAttrib4fvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                            (const GLfloat *) (pc + 4)
                           ));
}

void
__glXDisp_VertexAttrib4svNV(GLbyte * pc)
{
    CALL_VertexAttrib4svNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                            (const GLshort *) (pc + 4)
                           ));
}

void
__glXDisp_VertexAttrib4ubvNV(GLbyte * pc)
{
    CALL_VertexAttrib4ubvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             (const GLubyte *) (pc + 4)
                            ));
}

void
__glXDisp_VertexAttribs1dvNV(GLbyte * pc)
{
    const GLsizei n = *(GLsizei *) (pc + 4);

#ifdef __GLX_ALIGN64
    const GLuint cmdlen = 12 + __GLX_PAD((n * 8)) - 4;

    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, cmdlen);
        pc -= 4;
    }
#endif

    CALL_VertexAttribs1dvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             n, (const GLdouble *) (pc + 8)
                            ));
}

void
__glXDisp_VertexAttribs1fvNV(GLbyte * pc)
{
    const GLsizei n = *(GLsizei *) (pc + 4);

    CALL_VertexAttribs1fvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             n, (const GLfloat *) (pc + 8)
                            ));
}

void
__glXDisp_VertexAttribs1svNV(GLbyte * pc)
{
    const GLsizei n = *(GLsizei *) (pc + 4);

    CALL_VertexAttribs1svNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             n, (const GLshort *) (pc + 8)
                            ));
}

void
__glXDisp_VertexAttribs2dvNV(GLbyte * pc)
{
    const GLsizei n = *(GLsizei *) (pc + 4);

#ifdef __GLX_ALIGN64
    const GLuint cmdlen = 12 + __GLX_PAD((n * 16)) - 4;

    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, cmdlen);
        pc -= 4;
    }
#endif

    CALL_VertexAttribs2dvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             n, (const GLdouble *) (pc + 8)
                            ));
}

void
__glXDisp_VertexAttribs2fvNV(GLbyte * pc)
{
    const GLsizei n = *(GLsizei *) (pc + 4);

    CALL_VertexAttribs2fvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             n, (const GLfloat *) (pc + 8)
                            ));
}

void
__glXDisp_VertexAttribs2svNV(GLbyte * pc)
{
    const GLsizei n = *(GLsizei *) (pc + 4);

    CALL_VertexAttribs2svNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             n, (const GLshort *) (pc + 8)
                            ));
}

void
__glXDisp_VertexAttribs3dvNV(GLbyte * pc)
{
    const GLsizei n = *(GLsizei *) (pc + 4);

#ifdef __GLX_ALIGN64
    const GLuint cmdlen = 12 + __GLX_PAD((n * 24)) - 4;

    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, cmdlen);
        pc -= 4;
    }
#endif

    CALL_VertexAttribs3dvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             n, (const GLdouble *) (pc + 8)
                            ));
}

void
__glXDisp_VertexAttribs3fvNV(GLbyte * pc)
{
    const GLsizei n = *(GLsizei *) (pc + 4);

    CALL_VertexAttribs3fvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             n, (const GLfloat *) (pc + 8)
                            ));
}

void
__glXDisp_VertexAttribs3svNV(GLbyte * pc)
{
    const GLsizei n = *(GLsizei *) (pc + 4);

    CALL_VertexAttribs3svNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             n, (const GLshort *) (pc + 8)
                            ));
}

void
__glXDisp_VertexAttribs4dvNV(GLbyte * pc)
{
    const GLsizei n = *(GLsizei *) (pc + 4);

#ifdef __GLX_ALIGN64
    const GLuint cmdlen = 12 + __GLX_PAD((n * 32)) - 4;

    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, cmdlen);
        pc -= 4;
    }
#endif

    CALL_VertexAttribs4dvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             n, (const GLdouble *) (pc + 8)
                            ));
}

void
__glXDisp_VertexAttribs4fvNV(GLbyte * pc)
{
    const GLsizei n = *(GLsizei *) (pc + 4);

    CALL_VertexAttribs4fvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             n, (const GLfloat *) (pc + 8)
                            ));
}

void
__glXDisp_VertexAttribs4svNV(GLbyte * pc)
{
    const GLsizei n = *(GLsizei *) (pc + 4);

    CALL_VertexAttribs4svNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                             n, (const GLshort *) (pc + 8)
                            ));
}

void
__glXDisp_VertexAttribs4ubvNV(GLbyte * pc)
{
    const GLsizei n = *(GLsizei *) (pc + 4);

    CALL_VertexAttribs4ubvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                              n, (const GLubyte *) (pc + 8)
                             ));
}

void
__glXDisp_PointParameteriNV(GLbyte * pc)
{
    CALL_PointParameteriNV(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                            *(GLint *) (pc + 4)
                           ));
}

void
__glXDisp_PointParameterivNV(GLbyte * pc)
{
    const GLenum pname = *(GLenum *) (pc + 0);
    const GLint *params;

    params = (const GLint *) (pc + 4);

    CALL_PointParameterivNV(GET_DISPATCH(), (pname, params));
}

void
__glXDisp_ActiveStencilFaceEXT(GLbyte * pc)
{
    CALL_ActiveStencilFaceEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                              ));
}

int
__glXDisp_GetProgramNamedParameterdvNV(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLsizei len = *(GLsizei *) (pc + 4);

        GLdouble params[4];

        CALL_GetProgramNamedParameterdvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                                           len,
                                                           (const GLubyte *) (pc
                                                                              +
                                                                              8),
                                                           params));
        __glXSendReply(cl->client, params, 4, 8, GL_TRUE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetProgramNamedParameterfvNV(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLsizei len = *(GLsizei *) (pc + 4);

        GLfloat params[4];

        CALL_GetProgramNamedParameterfvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                                           len,
                                                           (const GLubyte *) (pc
                                                                              +
                                                                              8),
                                                           params));
        __glXSendReply(cl->client, params, 4, 4, GL_TRUE, 0);
        error = Success;
    }

    return error;
}

void
__glXDisp_ProgramNamedParameter4dvNV(GLbyte * pc)
{
    const GLsizei len = *(GLsizei *) (pc + 36);

#ifdef __GLX_ALIGN64
    const GLuint cmdlen = 44 + __GLX_PAD(len) - 4;

    if ((unsigned long) (pc) & 7) {
        (void) memmove(pc - 4, pc, cmdlen);
        pc -= 4;
    }
#endif

    CALL_ProgramNamedParameter4dvNV(GET_DISPATCH(), (*(GLuint *) (pc + 32),
                                                     len,
                                                     (const GLubyte *) (pc +
                                                                        40),
                                                     (const GLdouble *) (pc + 0)
                                    ));
}

void
__glXDisp_ProgramNamedParameter4fvNV(GLbyte * pc)
{
    const GLsizei len = *(GLsizei *) (pc + 4);

    CALL_ProgramNamedParameter4fvNV(GET_DISPATCH(), (*(GLuint *) (pc + 0),
                                                     len,
                                                     (const GLubyte *) (pc +
                                                                        24),
                                                     (const GLfloat *) (pc + 8)
                                    ));
}

void
__glXDisp_BlendEquationSeparateEXT(GLbyte * pc)
{
    CALL_BlendEquationSeparateEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                   *(GLenum *) (pc + 4)
                                  ));
}

void
__glXDisp_BindFramebufferEXT(GLbyte * pc)
{
    CALL_BindFramebufferEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                             *(GLuint *) (pc + 4)
                            ));
}

void
__glXDisp_BindRenderbufferEXT(GLbyte * pc)
{
    CALL_BindRenderbufferEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                              *(GLuint *) (pc + 4)
                             ));
}

int
__glXDisp_CheckFramebufferStatusEXT(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        GLenum retval;

        retval =
            CALL_CheckFramebufferStatusEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                                           ));
        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
        error = Success;
    }

    return error;
}

void
__glXDisp_DeleteFramebuffersEXT(GLbyte * pc)
{
    const GLsizei n = *(GLsizei *) (pc + 0);

    CALL_DeleteFramebuffersEXT(GET_DISPATCH(), (n, (const GLuint *) (pc + 4)
                               ));
}

void
__glXDisp_DeleteRenderbuffersEXT(GLbyte * pc)
{
    const GLsizei n = *(GLsizei *) (pc + 0);

    CALL_DeleteRenderbuffersEXT(GET_DISPATCH(), (n, (const GLuint *) (pc + 4)
                                ));
}

void
__glXDisp_FramebufferRenderbufferEXT(GLbyte * pc)
{
    CALL_FramebufferRenderbufferEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                     *(GLenum *) (pc + 4),
                                                     *(GLenum *) (pc + 8),
                                                     *(GLuint *) (pc + 12)
                                    ));
}

void
__glXDisp_FramebufferTexture1DEXT(GLbyte * pc)
{
    CALL_FramebufferTexture1DEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                  *(GLenum *) (pc + 4),
                                                  *(GLenum *) (pc + 8),
                                                  *(GLuint *) (pc + 12),
                                                  *(GLint *) (pc + 16)
                                 ));
}

void
__glXDisp_FramebufferTexture2DEXT(GLbyte * pc)
{
    CALL_FramebufferTexture2DEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                  *(GLenum *) (pc + 4),
                                                  *(GLenum *) (pc + 8),
                                                  *(GLuint *) (pc + 12),
                                                  *(GLint *) (pc + 16)
                                 ));
}

void
__glXDisp_FramebufferTexture3DEXT(GLbyte * pc)
{
    CALL_FramebufferTexture3DEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                  *(GLenum *) (pc + 4),
                                                  *(GLenum *) (pc + 8),
                                                  *(GLuint *) (pc + 12),
                                                  *(GLint *) (pc + 16),
                                                  *(GLint *) (pc + 20)
                                 ));
}

int
__glXDisp_GenFramebuffersEXT(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLsizei n = *(GLsizei *) (pc + 0);

        GLuint answerBuffer[200];
        GLuint *framebuffers =
            __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
                                 4);
        CALL_GenFramebuffersEXT(GET_DISPATCH(), (n, framebuffers));
        __glXSendReply(cl->client, framebuffers, n, 4, GL_TRUE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GenRenderbuffersEXT(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        const GLsizei n = *(GLsizei *) (pc + 0);

        GLuint answerBuffer[200];
        GLuint *renderbuffers =
            __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
                                 4);
        CALL_GenRenderbuffersEXT(GET_DISPATCH(), (n, renderbuffers));
        __glXSendReply(cl->client, renderbuffers, n, 4, GL_TRUE, 0);
        error = Success;
    }

    return error;
}

void
__glXDisp_GenerateMipmapEXT(GLbyte * pc)
{
    CALL_GenerateMipmapEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0)
                           ));
}

int
__glXDisp_GetFramebufferAttachmentParameterivEXT(__GLXclientState * cl,
                                                 GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        GLint params[1];

        CALL_GetFramebufferAttachmentParameterivEXT(GET_DISPATCH(),
                                                    (*(GLenum *) (pc + 0),
                                                     *(GLenum *) (pc + 4),
                                                     *(GLenum *) (pc + 8),
                                                     params));
        __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_GetRenderbufferParameterivEXT(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        GLint params[1];

        CALL_GetRenderbufferParameterivEXT(GET_DISPATCH(),
                                           (*(GLenum *) (pc + 0),
                                            *(GLenum *) (pc + 4), params));
        __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
        error = Success;
    }

    return error;
}

int
__glXDisp_IsFramebufferEXT(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        GLboolean retval;

        retval = CALL_IsFramebufferEXT(GET_DISPATCH(), (*(GLuint *) (pc + 0)
                                       ));
        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
        error = Success;
    }

    return error;
}

int
__glXDisp_IsRenderbufferEXT(__GLXclientState * cl, GLbyte * pc)
{
    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
    int error;
    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);

    pc += __GLX_VENDPRIV_HDR_SIZE;
    if (cx != NULL) {
        GLboolean retval;

        retval = CALL_IsRenderbufferEXT(GET_DISPATCH(), (*(GLuint *) (pc + 0)
                                        ));
        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
        error = Success;
    }

    return error;
}

void
__glXDisp_RenderbufferStorageEXT(GLbyte * pc)
{
    CALL_RenderbufferStorageEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                 *(GLenum *) (pc + 4),
                                                 *(GLsizei *) (pc + 8),
                                                 *(GLsizei *) (pc + 12)
                                ));
}

void
__glXDisp_BlitFramebufferEXT(GLbyte * pc)
{
    CALL_BlitFramebufferEXT(GET_DISPATCH(), (*(GLint *) (pc + 0),
                                             *(GLint *) (pc + 4),
                                             *(GLint *) (pc + 8),
                                             *(GLint *) (pc + 12),
                                             *(GLint *) (pc + 16),
                                             *(GLint *) (pc + 20),
                                             *(GLint *) (pc + 24),
                                             *(GLint *) (pc + 28),
                                             *(GLbitfield *) (pc + 32),
                                             *(GLenum *) (pc + 36)
                            ));
}

void
__glXDisp_FramebufferTextureLayerEXT(GLbyte * pc)
{
    CALL_FramebufferTextureLayerEXT(GET_DISPATCH(), (*(GLenum *) (pc + 0),
                                                     *(GLenum *) (pc + 4),
                                                     *(GLuint *) (pc + 8),
                                                     *(GLint *) (pc + 12),
                                                     *(GLint *) (pc + 16)
                                    ));
}
