Re-add mesa-6.4.1 which was accidentally deleted

40 files changed, 26153 insertions, 0 deletions

diff --git a/src/glx/x11/Makefile b/src/glx/x11/Makefile
new file mode 100644
index 00000000000..415ec02dd6b
--- /dev/null
+++ b/src/glx/x11/Makefile
@@ -0,0 +1,94 @@
+TOP = ../../..
+include $(TOP)/configs/current
+
+DEFINES += -DXF86VIDMODE -D_REENTRANT -UIN_DRI_DRIVER
+
+C_SOURCES = \
+	  $(TOP)/src/mesa/glapi/glapi.c \
+	  $(TOP)/src/mesa/glapi/glthread.c \
+	  $(TOP)/src/mesa/main/dispatch.c \
+	  glcontextmodes.c \
+	  clientattrib.c \
+	  compsize.c \
+	  eval.c \
+	  glxcmds.c \
+	  glxext.c \
+	  glxextensions.c \
+	  indirect.c \
+	  indirect_init.c \
+	  indirect_size.c \
+	  indirect_window_pos.c \
+	  indirect_transpose_matrix.c \
+	  indirect_vertex_array.c \
+	  indirect_vertex_program.c \
+	  pixel.c \
+	  pixelstore.c \
+	  render2.c \
+	  renderpix.c \
+	  single2.c \
+	  singlepix.c \
+	  vertarr.c \
+	  xfont.c \
+	  glx_pbuffer.c \
+	  glx_query.c \
+	  glx_texture_compression.c \
+	  dri_glx.c \
+	  XF86dri.c \
+
+X86_SOURCES = $(TOP)/src/mesa/x86/glapi_x86.S
+X86-64_SOURCES = $(TOP)/src/mesa/x86-64/glapi_x86-64.S
+
+# ASM_SOURCES = $(X86_SOURCES)
+
+OBJECTS = $(C_SOURCES:.c=.o) \
+	  $(ASM_SOURCES:.S=.o)
+
+INCLUDES = -I. \
+	-I$(TOP)/include \
+	-I$(TOP)/include/GL/internal \
+	-I$(TOP)/src/mesa/main \
+	-I$(TOP)/src/mesa/glapi \
+	-I$(TOP)/src/mesa/drivers/dri/common \
+        `pkg-config --cflags libdrm` \
+	$(X11_INCLUDES)
+
+
+##### RULES #####
+
+.c.o:
+	$(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES) $< -o $@
+
+.S.o:
+	$(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES)  $< -o $@
+
+##### TARGETS #####
+
+default: depend $(LIB_DIR)/$(GL_LIB_NAME)
+
+glcontextmodes.c:
+	ln -s $(TOP)/src/mesa/drivers/dri/common/glcontextmodes.c .
+
+# Make libGL
+$(LIB_DIR)/$(GL_LIB_NAME):  $(OBJECTS) Makefile
+	$(TOP)/bin/mklib -o $(GL_LIB) -linker '$(CC)' \
+		-major 1 -minor 2 $(MKLIB_OPTIONS) \
+		-install $(LIB_DIR) $(GL_LIB_DEPS) $(OBJECTS)
+
+
+depend: $(C_SOURCES) $(ASM_SOURCES) Makefile
+	touch depend
+	$(MKDEP) $(MKDEP_OPTIONS) $(INCLUDES) $(C_SOURCES) $(ASM_SOURCES) 
+
+
+# Emacs tags
+tags:
+	etags `find . -name \*.[ch]` `find ../include`
+
+
+# Remove .o and backup files
+clean:
+	-rm -f $(LIB_DIR)/libGL.so*
+	-rm -f *.o *~
+	-rm -f depend
+
+include depend
diff --git a/src/glx/x11/XF86dri.c b/src/glx/x11/XF86dri.c
new file mode 100644
index 00000000000..03fa4e57bce
--- /dev/null
+++ b/src/glx/x11/XF86dri.c
@@ -0,0 +1,617 @@
+/* $XFree86: xc/lib/GL/dri/XF86dri.c,v 1.13 2002/10/30 12:51:25 alanh Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+Copyright 2000 VA Linux Systems, Inc.
+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 PRECISION INSIGHT AND/OR ITS 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.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Kevin E. Martin <[email protected]>
+ *   Jens Owen <[email protected]>
+ *   Rickard E. (Rik) Faith <[email protected]>
+ *
+ */
+
+/* THIS IS NOT AN X CONSORTIUM STANDARD */
+
+#define NEED_REPLIES
+#include <X11/Xlibint.h>
+#include <X11/extensions/Xext.h>
+#include <X11/extensions/extutil.h>
+#include "glheader.h"
+#include "xf86dristr.h"
+
+static XExtensionInfo _xf86dri_info_data;
+static XExtensionInfo *xf86dri_info = &_xf86dri_info_data;
+static char xf86dri_extension_name[] = XF86DRINAME;
+
+#define XF86DRICheckExtension(dpy,i,val) \
+  XextCheckExtension (dpy, i, xf86dri_extension_name, val)
+
+/*****************************************************************************
+ *                                                                           *
+ *			   private utility routines                          *
+ *                                                                           *
+ *****************************************************************************/
+
+static int close_display(Display *dpy, XExtCodes *extCodes);
+static /* const */ XExtensionHooks xf86dri_extension_hooks = {
+    NULL,				/* create_gc */
+    NULL,				/* copy_gc */
+    NULL,				/* flush_gc */
+    NULL,				/* free_gc */
+    NULL,				/* create_font */
+    NULL,				/* free_font */
+    close_display,			/* close_display */
+    NULL,				/* wire_to_event */
+    NULL,				/* event_to_wire */
+    NULL,				/* error */
+    NULL,				/* error_string */
+};
+
+static XEXT_GENERATE_FIND_DISPLAY (find_display, xf86dri_info, 
+				   xf86dri_extension_name, 
+				   &xf86dri_extension_hooks, 
+				   0, NULL)
+
+static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86dri_info)
+
+
+/*****************************************************************************
+ *                                                                           *
+ *		    public XFree86-DRI Extension routines                    *
+ *                                                                           *
+ *****************************************************************************/
+
+#if 0
+#include <stdio.h>
+#define TRACE(msg)  fprintf(stderr,"XF86DRI%s\n", msg);
+#else
+#define TRACE(msg)
+#endif
+
+
+PUBLIC Bool XF86DRIQueryExtension (dpy, event_basep, error_basep)
+    Display *dpy;
+    int *event_basep, *error_basep;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+
+    TRACE("QueryExtension...");
+    if (XextHasExtension(info)) {
+	*event_basep = info->codes->first_event;
+	*error_basep = info->codes->first_error;
+        TRACE("QueryExtension... return True");
+	return True;
+    } else {
+        TRACE("QueryExtension... return False");
+	return False;
+    }
+}
+
+PUBLIC Bool XF86DRIQueryVersion(dpy, majorVersion, minorVersion, patchVersion)
+    Display* dpy;
+    int* majorVersion; 
+    int* minorVersion;
+    int* patchVersion;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIQueryVersionReply rep;
+    xXF86DRIQueryVersionReq *req;
+
+    TRACE("QueryVersion...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIQueryVersion, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIQueryVersion;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("QueryVersion... return False");
+	return False;
+    }
+    *majorVersion = rep.majorVersion;
+    *minorVersion = rep.minorVersion;
+    *patchVersion = rep.patchVersion;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("QueryVersion... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRIQueryDirectRenderingCapable(dpy, screen, isCapable)
+    Display* dpy;
+    int screen;
+    Bool* isCapable;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIQueryDirectRenderingCapableReply rep;
+    xXF86DRIQueryDirectRenderingCapableReq *req;
+
+    TRACE("QueryDirectRenderingCapable...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIQueryDirectRenderingCapable, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIQueryDirectRenderingCapable;
+    req->screen = screen;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("QueryDirectRenderingCapable... return False");
+	return False;
+    }
+    *isCapable = rep.isCapable;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("QueryDirectRenderingCapable... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRIOpenConnection(dpy, screen, hSAREA, busIdString)
+    Display* dpy;
+    int screen;
+    drm_handle_t * hSAREA;
+    char **busIdString;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIOpenConnectionReply rep;
+    xXF86DRIOpenConnectionReq *req;
+
+    TRACE("OpenConnection...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIOpenConnection, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIOpenConnection;
+    req->screen = screen;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("OpenConnection... return False");
+	return False;
+    }
+
+    *hSAREA = rep.hSAREALow;
+#ifdef LONG64
+    *hSAREA |= ((drm_handle_t)rep.hSAREAHigh) << 32;
+#endif
+
+    if (rep.length) {
+        if (!(*busIdString = (char *)Xcalloc(rep.busIdStringLength + 1, 1))) {
+            _XEatData(dpy, ((rep.busIdStringLength+3) & ~3));
+            UnlockDisplay(dpy);
+            SyncHandle();
+            TRACE("OpenConnection... return False");
+            return False;
+        }
+	_XReadPad(dpy, *busIdString, rep.busIdStringLength);
+    } else {
+        *busIdString = NULL;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("OpenConnection... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRIAuthConnection(dpy, screen, magic)
+    Display* dpy;
+    int screen;
+    drm_magic_t magic;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIAuthConnectionReq *req;
+    xXF86DRIAuthConnectionReply rep;
+
+    TRACE("AuthConnection...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIAuthConnection, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIAuthConnection;
+    req->screen = screen;
+    req->magic = magic;
+    rep.authenticated = 0;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse) || !rep.authenticated) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("AuthConnection... return False");
+	return False;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("AuthConnection... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRICloseConnection(dpy, screen)
+    Display* dpy;
+    int screen;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRICloseConnectionReq *req;
+
+    TRACE("CloseConnection...");
+
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRICloseConnection, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRICloseConnection;
+    req->screen = screen;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("CloseConnection... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRIGetClientDriverName(dpy, screen, ddxDriverMajorVersion, 
+	ddxDriverMinorVersion, ddxDriverPatchVersion, clientDriverName)
+    Display* dpy;
+    int screen;
+    int* ddxDriverMajorVersion;
+    int* ddxDriverMinorVersion;
+    int* ddxDriverPatchVersion;
+    char** clientDriverName;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIGetClientDriverNameReply rep;
+    xXF86DRIGetClientDriverNameReq *req;
+
+    TRACE("GetClientDriverName...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIGetClientDriverName, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIGetClientDriverName;
+    req->screen = screen;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("GetClientDriverName... return False");
+	return False;
+    }
+
+    *ddxDriverMajorVersion = rep.ddxDriverMajorVersion;
+    *ddxDriverMinorVersion = rep.ddxDriverMinorVersion;
+    *ddxDriverPatchVersion = rep.ddxDriverPatchVersion;
+
+    if (rep.length) {
+        if (!(*clientDriverName = (char *)Xcalloc(rep.clientDriverNameLength + 1, 1))) {
+            _XEatData(dpy, ((rep.clientDriverNameLength+3) & ~3));
+            UnlockDisplay(dpy);
+            SyncHandle();
+            TRACE("GetClientDriverName... return False");
+            return False;
+        }
+	_XReadPad(dpy, *clientDriverName, rep.clientDriverNameLength);
+    } else {
+        *clientDriverName = NULL;
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("GetClientDriverName... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRICreateContextWithConfig(dpy, screen, configID, context,
+	hHWContext)
+    Display* dpy;
+    int screen;
+    int configID;
+    XID* context;
+    drm_context_t * hHWContext;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRICreateContextReply rep;
+    xXF86DRICreateContextReq *req;
+
+    TRACE("CreateContext...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRICreateContext, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRICreateContext;
+    req->visual = configID;
+    req->screen = screen;
+    *context = XAllocID(dpy);
+    req->context = *context;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("CreateContext... return False");
+	return False;
+    }
+    *hHWContext = rep.hHWContext;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("CreateContext... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRICreateContext(dpy, screen, visual, context, hHWContext)
+    Display* dpy;
+    int screen;
+    Visual* visual;
+    XID* context;
+    drm_context_t * hHWContext;
+{
+    return XF86DRICreateContextWithConfig( dpy, screen, visual->visualid,
+					   context, hHWContext );
+}
+
+PUBLIC GLboolean XF86DRIDestroyContext( __DRInativeDisplay * ndpy, int screen, 
+    __DRIid context )
+{
+    Display * const dpy = (Display *) ndpy;
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIDestroyContextReq *req;
+
+    TRACE("DestroyContext...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIDestroyContext, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIDestroyContext;
+    req->screen = screen;
+    req->context = context;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("DestroyContext... return True");
+    return True;
+}
+
+PUBLIC GLboolean XF86DRICreateDrawable( __DRInativeDisplay * ndpy, int screen, 
+    __DRIid drawable, drm_drawable_t * hHWDrawable )
+{
+    Display * const dpy = (Display *) ndpy;
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRICreateDrawableReply rep;
+    xXF86DRICreateDrawableReq *req;
+
+    TRACE("CreateDrawable...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRICreateDrawable, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRICreateDrawable;
+    req->screen = screen;
+    req->drawable = drawable;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("CreateDrawable... return False");
+	return False;
+    }
+    *hHWDrawable = rep.hHWDrawable;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("CreateDrawable... return True");
+    return True;
+}
+
+PUBLIC GLboolean XF86DRIDestroyDrawable( __DRInativeDisplay * ndpy, int screen,
+    __DRIid drawable )
+{
+    Display * const dpy = (Display *) ndpy;
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIDestroyDrawableReq *req;
+
+    TRACE("DestroyDrawable...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIDestroyDrawable, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIDestroyDrawable;
+    req->screen = screen;
+    req->drawable = drawable;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("DestroyDrawable... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRIGetDrawableInfo(Display* dpy, int screen, Drawable drawable,
+    unsigned int* index, unsigned int* stamp,
+    int* X, int* Y, int* W, int* H,
+    int* numClipRects, drm_clip_rect_t ** pClipRects,
+    int* backX, int* backY,
+    int* numBackClipRects, drm_clip_rect_t ** pBackClipRects )
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIGetDrawableInfoReply rep;
+    xXF86DRIGetDrawableInfoReq *req;
+    int total_rects;
+
+    TRACE("GetDrawableInfo...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIGetDrawableInfo, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIGetDrawableInfo;
+    req->screen = screen;
+    req->drawable = drawable;
+
+    if (!_XReply(dpy, (xReply *)&rep, 1, xFalse)) 
+    {
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("GetDrawableInfo... return False");
+	return False;
+    }
+    *index = rep.drawableTableIndex;
+    *stamp = rep.drawableTableStamp;
+    *X = (int)rep.drawableX;
+    *Y = (int)rep.drawableY;
+    *W = (int)rep.drawableWidth;
+    *H = (int)rep.drawableHeight;
+    *numClipRects = rep.numClipRects;
+    total_rects = *numClipRects;
+
+    *backX = rep.backX;
+    *backY = rep.backY;
+    *numBackClipRects = rep.numBackClipRects;
+    total_rects += *numBackClipRects;
+
+#if 0
+    /* Because of the fix in Xserver/GL/dri/xf86dri.c, this check breaks
+     * backwards compatibility (Because of the >> 2 shift) but the fix
+     * enables multi-threaded apps to work.
+     */
+    if (rep.length !=  ((((SIZEOF(xXF86DRIGetDrawableInfoReply) - 
+		       SIZEOF(xGenericReply) + 
+		       total_rects * sizeof(drm_clip_rect_t)) + 3) & ~3) >> 2)) {
+        _XEatData(dpy, rep.length);
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("GetDrawableInfo... return False");
+        return False;
+    }
+#endif
+
+    if (*numClipRects) {
+       int len = sizeof(drm_clip_rect_t) * (*numClipRects);
+
+       *pClipRects = (drm_clip_rect_t *)Xcalloc(len, 1);
+       if (*pClipRects) 
+	  _XRead(dpy, (char*)*pClipRects, len);
+    } else {
+        *pClipRects = NULL;
+    }
+
+    if (*numBackClipRects) {
+       int len = sizeof(drm_clip_rect_t) * (*numBackClipRects);
+
+       *pBackClipRects = (drm_clip_rect_t *)Xcalloc(len, 1);
+       if (*pBackClipRects) 
+	  _XRead(dpy, (char*)*pBackClipRects, len);
+    } else {
+        *pBackClipRects = NULL;
+    }
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("GetDrawableInfo... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRIGetDeviceInfo(dpy, screen, hFrameBuffer, 
+	fbOrigin, fbSize, fbStride, devPrivateSize, pDevPrivate)
+    Display* dpy;
+    int screen;
+    drm_handle_t * hFrameBuffer;
+    int* fbOrigin;
+    int* fbSize;
+    int* fbStride;
+    int* devPrivateSize;
+    void** pDevPrivate;
+{
+    XExtDisplayInfo *info = find_display (dpy);
+    xXF86DRIGetDeviceInfoReply rep;
+    xXF86DRIGetDeviceInfoReq *req;
+
+    TRACE("GetDeviceInfo...");
+    XF86DRICheckExtension (dpy, info, False);
+
+    LockDisplay(dpy);
+    GetReq(XF86DRIGetDeviceInfo, req);
+    req->reqType = info->codes->major_opcode;
+    req->driReqType = X_XF86DRIGetDeviceInfo;
+    req->screen = screen;
+    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+        TRACE("GetDeviceInfo... return False");
+	return False;
+    }
+
+    *hFrameBuffer = rep.hFrameBufferLow;
+#ifdef LONG64
+    *hFrameBuffer |= ((drm_handle_t)rep.hFrameBufferHigh) << 32;
+#endif
+
+    *fbOrigin = rep.framebufferOrigin;
+    *fbSize = rep.framebufferSize;
+    *fbStride = rep.framebufferStride;
+    *devPrivateSize = rep.devPrivateSize;
+
+    if (rep.length) {
+        if (!(*pDevPrivate = (void *)Xcalloc(rep.devPrivateSize, 1))) {
+            _XEatData(dpy, ((rep.devPrivateSize+3) & ~3));
+            UnlockDisplay(dpy);
+            SyncHandle();
+            TRACE("GetDeviceInfo... return False");
+            return False;
+        }
+	_XRead(dpy, (char*)*pDevPrivate, rep.devPrivateSize);
+    } else {
+        *pDevPrivate = NULL;
+    }
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    TRACE("GetDeviceInfo... return True");
+    return True;
+}
+
+PUBLIC Bool XF86DRIOpenFullScreen(dpy, screen, drawable)
+    Display* dpy;
+    int screen;
+    Drawable drawable;
+{
+    /* This function and the underlying X protocol are deprecated.
+     */
+    (void) dpy;
+    (void) screen;
+    (void) drawable;
+    return False;
+}
+
+PUBLIC Bool XF86DRICloseFullScreen(dpy, screen, drawable)
+    Display* dpy;
+    int screen;
+    Drawable drawable;
+{
+    /* This function and the underlying X protocol are deprecated.
+     */
+    (void) dpy;
+    (void) screen;
+    (void) drawable;
+    return True;
+}
diff --git a/src/glx/x11/clientattrib.c b/src/glx/x11/clientattrib.c
new file mode 100644
index 00000000000..bfb263ced14
--- /dev/null
+++ b/src/glx/x11/clientattrib.c
@@ -0,0 +1,141 @@
+/* $XFree86: xc/lib/GL/glx/clientattrib.c,v 1.5 2001/03/21 16:04:39 dawes Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include <assert.h>
+#include "glxclient.h"
+#include "indirect.h"
+#include "indirect_vertex_array.h"
+
+/*****************************************************************************/
+
+static void
+do_enable_disable(GLenum array, GLboolean val )
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    unsigned index = 0;
+
+    if ( array == GL_TEXTURE_COORD_ARRAY ) {
+	index = __glXGetActiveTextureUnit( state );
+    }
+
+    if ( ! __glXSetArrayEnable( state, array, index, val ) ) {
+	__glXSetError(gc, GL_INVALID_ENUM);
+    }
+}
+
+void __indirect_glEnableClientState(GLenum array)
+{
+    do_enable_disable( array, GL_TRUE );
+}
+
+void __indirect_glDisableClientState(GLenum array)
+{
+    do_enable_disable( array, GL_FALSE );
+}
+
+/************************************************************************/
+
+void __indirect_glPushClientAttrib(GLuint mask)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    __GLXattribute **spp = gc->attributes.stackPointer, *sp;
+
+    if (spp < &gc->attributes.stack[__GL_CLIENT_ATTRIB_STACK_DEPTH]) {
+	if (!(sp = *spp)) {
+	    sp = (__GLXattribute *)Xmalloc(sizeof(__GLXattribute));
+	    *spp = sp;
+	}
+	sp->mask = mask;
+	gc->attributes.stackPointer = spp + 1;
+	if (mask & GL_CLIENT_PIXEL_STORE_BIT) {
+	    sp->storePack = state->storePack;
+	    sp->storeUnpack = state->storeUnpack;
+	}
+	if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) {
+	    __glXPushArrayState( state );
+	}
+    } else {
+	__glXSetError(gc, GL_STACK_OVERFLOW);
+	return;
+    }
+}
+
+void __indirect_glPopClientAttrib(void)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    __GLXattribute **spp = gc->attributes.stackPointer, *sp;
+    GLuint mask;
+
+    if (spp > &gc->attributes.stack[0]) {
+	--spp;
+	sp = *spp;
+	assert(sp != 0);
+	mask = sp->mask;
+	gc->attributes.stackPointer = spp;
+
+	if (mask & GL_CLIENT_PIXEL_STORE_BIT) {
+	    state->storePack = sp->storePack;
+	    state->storeUnpack = sp->storeUnpack;
+	}
+	if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) {
+	    __glXPopArrayState( state );
+	}
+
+	sp->mask = 0;
+    } else {
+	__glXSetError(gc, GL_STACK_UNDERFLOW);
+	return;
+    }
+}
+
+void __glFreeAttributeState(__GLXcontext *gc)
+{
+    __GLXattribute *sp, **spp;
+
+    for (spp = &gc->attributes.stack[0];
+         spp < &gc->attributes.stack[__GL_CLIENT_ATTRIB_STACK_DEPTH];
+	 spp++) {
+	sp = *spp;
+        if (sp) {
+            XFree((char *)sp);
+        } else {
+            break;
+	}
+    }
+}
diff --git a/src/glx/x11/compsize.c b/src/glx/x11/compsize.c
new file mode 100644
index 00000000000..193570c8486
--- /dev/null
+++ b/src/glx/x11/compsize.c
@@ -0,0 +1,190 @@
+/* $XFree86: xc/lib/GL/glx/compsize.c,v 1.6 2004/01/28 18:11:38 alanh Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include <GL/gl.h>
+#include "indirect_size.h"
+
+/*
+** Return the number of elements per group of a specified format
+*/
+GLint __glElementsPerGroup(GLenum format, GLenum type) 
+{
+    /*
+    ** To make row length computation valid for image extraction,
+    ** packed pixel types assume elements per group equals one.
+    */
+    switch(type) {
+    case GL_UNSIGNED_BYTE_3_3_2:
+    case GL_UNSIGNED_BYTE_2_3_3_REV:
+    case GL_UNSIGNED_SHORT_5_6_5:
+    case GL_UNSIGNED_SHORT_5_6_5_REV:
+    case GL_UNSIGNED_SHORT_4_4_4_4:
+    case GL_UNSIGNED_SHORT_4_4_4_4_REV:
+    case GL_UNSIGNED_SHORT_5_5_5_1:
+    case GL_UNSIGNED_SHORT_1_5_5_5_REV:
+    case GL_UNSIGNED_SHORT_8_8_APPLE:
+    case GL_UNSIGNED_SHORT_8_8_REV_APPLE:
+    case GL_UNSIGNED_SHORT_15_1_MESA:
+    case GL_UNSIGNED_SHORT_1_15_REV_MESA:
+    case GL_UNSIGNED_INT_8_8_8_8:
+    case GL_UNSIGNED_INT_8_8_8_8_REV:
+    case GL_UNSIGNED_INT_10_10_10_2:
+    case GL_UNSIGNED_INT_2_10_10_10_REV:
+    case GL_UNSIGNED_INT_24_8_NV:
+    case GL_UNSIGNED_INT_24_8_MESA:
+    case GL_UNSIGNED_INT_8_24_REV_MESA:
+      return 1;
+    default:
+      break;
+    }
+
+    switch(format) {
+      case GL_RGB:
+      case GL_BGR:
+	return 3;
+      case GL_422_EXT:
+      case GL_422_REV_EXT:
+      case GL_422_AVERAGE_EXT:
+      case GL_422_REV_AVERAGE_EXT:
+      case GL_YCBCR_422_APPLE:
+      case GL_LUMINANCE_ALPHA:
+	return 2;
+      case GL_RGBA:
+      case GL_BGRA:
+      case GL_ABGR_EXT:
+	return 4;
+      case GL_COLOR_INDEX:
+      case GL_STENCIL_INDEX:
+      case GL_DEPTH_COMPONENT:
+      case GL_RED:
+      case GL_GREEN:
+      case GL_BLUE:
+      case GL_ALPHA:
+      case GL_LUMINANCE:
+      case GL_INTENSITY:
+	return 1;
+      default:
+	return 0;
+    }
+}
+
+/*
+** Return the number of bytes per element, based on the element type (other
+** than GL_BITMAP).
+*/
+GLint __glBytesPerElement(GLenum type) 
+{
+    switch(type) {
+      case GL_UNSIGNED_SHORT:
+      case GL_SHORT:
+      case GL_UNSIGNED_SHORT_5_6_5:
+      case GL_UNSIGNED_SHORT_5_6_5_REV:
+      case GL_UNSIGNED_SHORT_4_4_4_4:
+      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
+      case GL_UNSIGNED_SHORT_5_5_5_1:
+      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
+      case GL_UNSIGNED_SHORT_8_8_APPLE:
+      case GL_UNSIGNED_SHORT_8_8_REV_APPLE:
+      case GL_UNSIGNED_SHORT_15_1_MESA:
+      case GL_UNSIGNED_SHORT_1_15_REV_MESA:
+	return 2;
+      case GL_UNSIGNED_BYTE:
+      case GL_BYTE:
+      case GL_UNSIGNED_BYTE_3_3_2:
+      case GL_UNSIGNED_BYTE_2_3_3_REV:
+	return 1;
+      case GL_INT:
+      case GL_UNSIGNED_INT:
+      case GL_FLOAT:
+      case GL_UNSIGNED_INT_8_8_8_8:
+      case GL_UNSIGNED_INT_8_8_8_8_REV:
+      case GL_UNSIGNED_INT_10_10_10_2:
+      case GL_UNSIGNED_INT_2_10_10_10_REV:
+      case GL_UNSIGNED_INT_24_8_NV:
+      case GL_UNSIGNED_INT_24_8_MESA:
+      case GL_UNSIGNED_INT_8_24_REV_MESA:
+	return 4;
+      default:
+	return 0;
+    }
+}
+
+/*
+** Compute memory required for internal packed array of data of given type
+** and format.
+*/
+GLint __glImageSize(GLsizei width, GLsizei height, GLsizei depth,
+		    GLenum format, GLenum type, GLenum target)
+{
+    int bytes_per_row;
+    int components;
+
+    switch( target ) {
+    case GL_PROXY_TEXTURE_1D:
+    case GL_PROXY_TEXTURE_2D:
+    case GL_PROXY_TEXTURE_3D:
+    case GL_PROXY_TEXTURE_4D_SGIS:
+    case GL_PROXY_TEXTURE_CUBE_MAP:
+    case GL_PROXY_TEXTURE_RECTANGLE_ARB:
+    case GL_PROXY_HISTOGRAM:
+    case GL_PROXY_COLOR_TABLE:
+    case GL_PROXY_TEXTURE_COLOR_TABLE_SGI:
+    case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE:
+    case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE:
+    case GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP:
+	return 0;
+    }
+
+    if (width < 0 || height < 0 || depth < 0) {
+	return 0;
+    }
+
+    /*
+    ** Zero is returned if either format or type are invalid.
+    */
+    components = __glElementsPerGroup(format,type);
+    if (type == GL_BITMAP) {
+	if (format == GL_COLOR_INDEX || format == GL_STENCIL_INDEX) {
+	    bytes_per_row = (width + 7) >> 3;
+	} else {
+	    return 0;
+	}
+    } else {
+	bytes_per_row = __glBytesPerElement(type) * width;
+    }
+
+    return bytes_per_row * height * depth * components;
+}
diff --git a/src/glx/x11/dri_glx.c b/src/glx/x11/dri_glx.c
new file mode 100644
index 00000000000..516ca508c5d
--- /dev/null
+++ b/src/glx/x11/dri_glx.c
@@ -0,0 +1,461 @@
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+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 PRECISION INSIGHT AND/OR ITS 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.
+
+**************************************************************************/
+/* $XFree86: xc/lib/GL/dri/dri_glx.c,v 1.14 2003/07/16 00:54:00 dawes Exp $ */
+
+/*
+ * Authors:
+ *   Kevin E. Martin <[email protected]>
+ *   Brian Paul <[email protected]>
+ *
+ */
+
+#ifdef GLX_DIRECT_RENDERING
+
+#include <unistd.h>
+#include <X11/Xlibint.h>
+#include <X11/extensions/Xext.h>
+#include <X11/extensions/extutil.h>
+#include "glxclient.h"
+#include "xf86dri.h"
+#include "sarea.h"
+#include <stdio.h>
+#include <dlfcn.h>
+#include "dri_glx.h"
+#include <sys/types.h>
+#include <stdarg.h>
+
+#ifndef RTLD_NOW
+#define RTLD_NOW 0
+#endif
+#ifndef RTLD_GLOBAL
+#define RTLD_GLOBAL 0
+#endif
+
+
+#ifndef DEFAULT_DRIVER_DIR
+/* this is normally defined in the Imakefile */
+#define DEFAULT_DRIVER_DIR "/usr/X11R6/lib/modules/dri"
+#endif
+
+static __DRIdriver *Drivers = NULL;
+
+
+/*
+ * printf wrappers
+ */
+
+static void InfoMessageF(const char *f, ...)
+{
+    va_list args;
+    const char *env;
+
+    if ((env = getenv("LIBGL_DEBUG")) && strstr(env, "verbose")) {
+	fprintf(stderr, "libGL: ");
+	va_start(args, f);
+	vfprintf(stderr, f, args);
+	va_end(args);
+    }
+}
+
+static void ErrorMessageF(const char *f, ...)
+{
+    va_list args;
+
+    if (getenv("LIBGL_DEBUG")) {
+	fprintf(stderr, "libGL error: ");
+	va_start(args, f);
+	vfprintf(stderr, f, args);
+	va_end(args);
+    }
+}
+
+
+/**
+ * Extract the ith directory path out of a colon-separated list of paths.  No
+ * more than \c dirLen characters, including the terminating \c NUL, will be
+ * written to \c dir.
+ *
+ * \param index  Index of path to extract (starting at zero)
+ * \param paths  The colon-separated list of paths
+ * \param dirLen Maximum length of result to store in \c dir
+ * \param dir    Buffer to hold the extracted directory path
+ *
+ * \returns
+ * The number of characters that would have been written to \c dir had there
+ * been enough room.  This does not include the terminating \c NUL.  When
+ * extraction fails, zero will be returned.
+ * 
+ * \todo
+ * It seems like this function could be rewritten to use \c strchr.
+ */
+static size_t
+ExtractDir(int index, const char *paths, int dirLen, char *dir)
+{
+   int i, len;
+   const char *start, *end;
+
+   /* find ith colon */
+   start = paths;
+   i = 0;
+   while (i < index) {
+      if (*start == ':') {
+         i++;
+         start++;
+      }
+      else if (*start == 0) {
+         /* end of string and couldn't find ith colon */
+         dir[0] = 0;
+         return 0;
+      }
+      else {
+         start++;
+      }
+   }
+
+   while (*start == ':')
+      start++;
+
+   /* find next colon, or end of string */
+   end = start + 1;
+   while (*end != ':' && *end != 0) {
+      end++;
+   }
+
+   /* copy string between <start> and <end> into result string */
+   len = end - start;
+   if (len > dirLen - 1)
+      len = dirLen - 1;
+   strncpy(dir, start, len);
+   dir[len] = 0;
+
+   return( end - start );
+}
+
+
+/**
+ * Versioned name of the expected \c __driCreateNewScreen function.
+ * 
+ * The version of the last incompatible loader/driver inteface change is
+ * appended to the name of the \c __driCreateNewScreen function.  This
+ * prevents loaders from trying to load drivers that are too old.
+ * 
+ * \todo
+ * Create a macro or something so that this is automatically updated.
+ */
+static const char createNewScreenName[] = "__driCreateNewScreen_20050727";
+
+
+/**
+ * Try to \c dlopen the named driver.
+ *
+ * This function adds the "_dri.so" suffix to the driver name and searches the
+ * directories specified by the \c LIBGL_DRIVERS_PATH environment variable in
+ * order to find the driver.
+ *
+ * \param driverName - a name like "tdfx", "i810", "mga", etc.
+ *
+ * \returns
+ * A handle from \c dlopen, or \c NULL if driver file not found.
+ */
+static __DRIdriver *OpenDriver(const char *driverName)
+{
+   char *libPaths = NULL;
+   char libDir[1000];
+   int i;
+   __DRIdriver *driver;
+
+   /* First, search Drivers list to see if we've already opened this driver */
+   for (driver = Drivers; driver; driver = driver->next) {
+      if (strcmp(driver->name, driverName) == 0) {
+         /* found it */
+         return driver;
+      }
+   }
+
+   if (geteuid() == getuid()) {
+      /* don't allow setuid apps to use LIBGL_DRIVERS_PATH */
+      libPaths = getenv("LIBGL_DRIVERS_PATH");
+      if (!libPaths)
+         libPaths = getenv("LIBGL_DRIVERS_DIR"); /* deprecated */
+   }
+   if (!libPaths)
+      libPaths = DEFAULT_DRIVER_DIR;
+
+   for ( i = 0 ; ExtractDir(i, libPaths, 1000, libDir) != 0 ; i++ ) {
+      char realDriverName[200];
+      void *handle = NULL;
+
+      
+      /* If TLS support is enabled, try to open the TLS version of the driver
+       * binary first.  If that fails, try the non-TLS version.
+       */
+#ifdef GLX_USE_TLS
+      snprintf(realDriverName, 200, "%s/tls/%s_dri.so", libDir, driverName);
+      InfoMessageF("OpenDriver: trying %s\n", realDriverName);
+      handle = dlopen(realDriverName, RTLD_NOW | RTLD_GLOBAL);
+#endif
+
+      if ( handle == NULL ) {
+	 snprintf(realDriverName, 200, "%s/%s_dri.so", libDir, driverName);
+	 InfoMessageF("OpenDriver: trying %s\n", realDriverName);
+	 handle = dlopen(realDriverName, RTLD_NOW | RTLD_GLOBAL);
+      }
+
+      if ( handle != NULL ) {
+         /* allocate __DRIdriver struct */
+         driver = (__DRIdriver *) Xmalloc(sizeof(__DRIdriver));
+         if (!driver)
+            return NULL; /* out of memory! */
+         /* init the struct */
+         driver->name = __glXstrdup(driverName);
+         if (!driver->name) {
+            Xfree(driver);
+            return NULL; /* out of memory! */
+         }
+
+         driver->createNewScreenFunc = (PFNCREATENEWSCREENFUNC)
+            dlsym(handle, createNewScreenName);
+
+         if ( driver->createNewScreenFunc == NULL ) {
+            /* If the driver doesn't have this symbol then something's
+             * really, really wrong.
+             */
+            ErrorMessageF("%s not defined in %s_dri.so!\n"
+			  "Your driver may be too old for this libGL.\n",
+			  createNewScreenName, driverName);
+            Xfree(driver);
+            dlclose(handle);
+            continue;
+         }
+         driver->handle = handle;
+         /* put at head of linked list */
+         driver->next = Drivers;
+         Drivers = driver;
+         return driver;
+      }
+      else {
+	 ErrorMessageF("dlopen %s failed (%s)\n", realDriverName, dlerror());
+      }
+   }
+
+   ErrorMessageF("unable to find driver: %s_dri.so\n", driverName);
+   return NULL;
+}
+
+
+/*
+ * Given a display pointer and screen number, determine the name of
+ * the DRI driver for the screen. (I.e. "r128", "tdfx", etc).
+ * Return True for success, False for failure.
+ */
+static Bool GetDriverName(Display *dpy, int scrNum, char **driverName)
+{
+   int directCapable;
+   Bool b;
+   int driverMajor, driverMinor, driverPatch;
+
+   *driverName = NULL;
+
+   if (!XF86DRIQueryDirectRenderingCapable(dpy, scrNum, &directCapable)) {
+      ErrorMessageF("XF86DRIQueryDirectRenderingCapable failed\n");
+      return False;
+   }
+   if (!directCapable) {
+      ErrorMessageF("XF86DRIQueryDirectRenderingCapable returned false\n");
+      return False;
+   }
+
+   b = XF86DRIGetClientDriverName(dpy, scrNum, &driverMajor, &driverMinor,
+                                  &driverPatch, driverName);
+   if (!b) {
+      ErrorMessageF("Cannot determine driver name for screen %d\n", scrNum);
+      return False;
+   }
+
+   InfoMessageF("XF86DRIGetClientDriverName: %d.%d.%d %s (screen %d)\n",
+	     driverMajor, driverMinor, driverPatch, *driverName, scrNum);
+
+   return True;
+}
+
+
+/*
+ * Given a display pointer and screen number, return a __DRIdriver handle.
+ * Return NULL if anything goes wrong.
+ */
+__DRIdriver *driGetDriver(Display *dpy, int scrNum)
+{
+   char *driverName;
+   if (GetDriverName(dpy, scrNum, &driverName)) {
+      __DRIdriver *ret;
+      ret = OpenDriver(driverName);
+      if (driverName)
+     	 Xfree(driverName);
+      return ret;
+   }
+   return NULL;
+}
+
+
+/*
+ * Exported function for querying the DRI driver for a given screen.
+ *
+ * The returned char pointer points to a static array that will be
+ * overwritten by subsequent calls.
+ */
+const char *glXGetScreenDriver (Display *dpy, int scrNum) {
+   static char ret[32];
+   char *driverName;
+   if (GetDriverName(dpy, scrNum, &driverName)) {
+      int len;
+      if (!driverName)
+	 return NULL;
+      len = strlen (driverName);
+      if (len >= 31)
+	 return NULL;
+      memcpy (ret, driverName, len+1);
+      Xfree(driverName);
+      return ret;
+   }
+   return NULL;
+}
+
+
+/*
+ * Exported function for obtaining a driver's option list (UTF-8 encoded XML).
+ *
+ * The returned char pointer points directly into the driver. Therefore
+ * it should be treated as a constant.
+ *
+ * If the driver was not found or does not support configuration NULL is
+ * returned.
+ *
+ * Note: The driver remains opened after this function returns.
+ */
+const char *glXGetDriverConfig (const char *driverName) {
+   __DRIdriver *driver = OpenDriver (driverName);
+   if (driver)
+      return dlsym (driver->handle, "__driConfigOptions");
+   else
+      return NULL;
+}
+
+
+/* This function isn't currently used.
+ */
+static void driDestroyDisplay(Display *dpy, void *private)
+{
+    __DRIdisplayPrivate *pdpyp = (__DRIdisplayPrivate *)private;
+
+    if (pdpyp) {
+        const int numScreens = ScreenCount(dpy);
+        int i;
+        for (i = 0; i < numScreens; i++) {
+            if (pdpyp->libraryHandles[i])
+                dlclose(pdpyp->libraryHandles[i]);
+        }
+        Xfree(pdpyp->libraryHandles);
+	Xfree(pdpyp);
+    }
+}
+
+
+/*
+ * Allocate, initialize and return a __DRIdisplayPrivate object.
+ * This is called from __glXInitialize() when we are given a new
+ * display pointer.
+ */
+void *driCreateDisplay(Display *dpy, __DRIdisplay *pdisp)
+{
+    const int numScreens = ScreenCount(dpy);
+    __DRIdisplayPrivate *pdpyp;
+    int eventBase, errorBase;
+    int major, minor, patch;
+    int scrn;
+
+    /* Initialize these fields to NULL in case we fail.
+     * If we don't do this we may later get segfaults trying to free random
+     * addresses when the display is closed.
+     */
+    pdisp->private = NULL;
+    pdisp->destroyDisplay = NULL;
+
+    if (!XF86DRIQueryExtension(dpy, &eventBase, &errorBase)) {
+	return NULL;
+    }
+
+    if (!XF86DRIQueryVersion(dpy, &major, &minor, &patch)) {
+	return NULL;
+    }
+
+    pdpyp = (__DRIdisplayPrivate *)Xmalloc(sizeof(__DRIdisplayPrivate));
+    if (!pdpyp) {
+	return NULL;
+    }
+
+    pdpyp->driMajor = major;
+    pdpyp->driMinor = minor;
+    pdpyp->driPatch = patch;
+
+    pdisp->destroyDisplay = driDestroyDisplay;
+
+    /* allocate array of pointers to createNewScreen funcs */
+    pdisp->createNewScreen = (PFNCREATENEWSCREENFUNC *)
+      Xmalloc(numScreens * sizeof(void *));
+    if (!pdisp->createNewScreen) {
+       Xfree(pdpyp);
+       return NULL;
+    }
+
+    /* allocate array of library handles */
+    pdpyp->libraryHandles = (void **) Xmalloc(numScreens * sizeof(void*));
+    if (!pdpyp->libraryHandles) {
+       Xfree(pdisp->createNewScreen);
+       Xfree(pdpyp);
+       return NULL;
+    }
+
+    /* dynamically discover DRI drivers for all screens, saving each
+     * driver's "__driCreateScreen" function pointer.  That's the bootstrap
+     * entrypoint for all DRI drivers.
+     */
+    for (scrn = 0; scrn < numScreens; scrn++) {
+        __DRIdriver *driver = driGetDriver(dpy, scrn);
+        if (driver) {
+           pdisp->createNewScreen[scrn] = driver->createNewScreenFunc;
+           pdpyp->libraryHandles[scrn] = driver->handle;
+        }
+        else {
+           pdisp->createNewScreen[scrn] = NULL;
+           pdpyp->libraryHandles[scrn] = NULL;
+        }
+    }
+
+    return (void *)pdpyp;
+}
+
+#endif /* GLX_DIRECT_RENDERING */
diff --git a/src/glx/x11/dri_glx.h b/src/glx/x11/dri_glx.h
new file mode 100644
index 00000000000..75561685c81
--- /dev/null
+++ b/src/glx/x11/dri_glx.h
@@ -0,0 +1,61 @@
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+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 PRECISION INSIGHT AND/OR ITS 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.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Kevin E. Martin <[email protected]>
+ *   Brian Paul <[email protected]>
+ *
+ */
+
+#ifndef _DRI_GLX_H_
+#define _DRI_GLX_H_
+
+#ifdef GLX_DIRECT_RENDERING
+
+struct __DRIdisplayPrivateRec {
+    /*
+    ** XFree86-DRI version information
+    */
+    int driMajor;
+    int driMinor;
+    int driPatch;
+
+    /*
+    ** Array of library handles [indexed by screen number]
+    */
+    void **libraryHandles;
+};
+
+typedef struct __DRIdisplayPrivateRec  __DRIdisplayPrivate;
+typedef struct __DRIscreenPrivateRec   __DRIscreenPrivate;
+typedef struct __DRIvisualPrivateRec   __DRIvisualPrivate;
+typedef struct __DRIcontextPrivateRec  __DRIcontextPrivate;
+typedef struct __DRIdrawablePrivateRec __DRIdrawablePrivate;
+
+#endif
+#endif /* _DRI_GLX_H_ */
diff --git a/src/glx/x11/eval.c b/src/glx/x11/eval.c
new file mode 100644
index 00000000000..0f94e6da6fd
--- /dev/null
+++ b/src/glx/x11/eval.c
@@ -0,0 +1,132 @@
+/* $XFree86$ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include "packrender.h"
+
+/*
+** Routines to pack evaluator maps into the transport buffer.  Maps are
+** allowed to have extra arbitrary data, so these routines extract just
+** the information that the GL needs.
+*/
+
+void __glFillMap1f(GLint k, GLint order, GLint stride, 
+		   const GLfloat *points, GLubyte *pc)
+{
+    if (stride == k) {
+	/* Just copy the data */
+	__GLX_PUT_FLOAT_ARRAY(0, points, order * k);
+    } else {
+	GLint i;
+
+	for (i = 0; i < order; i++) {
+	    __GLX_PUT_FLOAT_ARRAY(0, points, k);
+	    points += stride;
+	    pc += k * __GLX_SIZE_FLOAT32;
+	}
+    }
+}
+
+void __glFillMap1d(GLint k, GLint order, GLint stride, 
+		   const GLdouble *points, GLubyte *pc)
+{
+    if (stride == k) {
+	/* Just copy the data */
+	__GLX_PUT_DOUBLE_ARRAY(0, points, order * k);
+    } else {
+	GLint i;
+	for (i = 0; i < order; i++) {
+            __GLX_PUT_DOUBLE_ARRAY(0, points, k);
+	    points += stride;
+	    pc += k * __GLX_SIZE_FLOAT64;
+	}
+    }
+}
+
+void __glFillMap2f(GLint k, GLint majorOrder, GLint minorOrder, 
+		   GLint majorStride, GLint minorStride,
+		   const GLfloat *points, GLfloat *data)
+{
+    GLint i, j, x;
+
+    if ((minorStride == k) && (majorStride == minorOrder*k)) {
+	/* Just copy the data */
+	__GLX_MEM_COPY(data, points, majorOrder * majorStride *
+		       __GLX_SIZE_FLOAT32);
+	return;
+    }
+    for (i = 0; i < majorOrder; i++) {
+	for (j = 0; j < minorOrder; j++) {
+	    for (x = 0; x < k; x++) {
+		data[x] = points[x];
+	    }
+	    points += minorStride;
+	    data += k;
+	}
+	points += majorStride - minorStride * minorOrder;
+    }
+}
+
+void __glFillMap2d(GLint k, GLint majorOrder, GLint minorOrder, 
+		   GLint majorStride, GLint minorStride,
+		   const GLdouble *points, GLdouble *data)
+{
+    int i,j,x;
+
+    if ((minorStride == k) && (majorStride == minorOrder*k)) {
+	/* Just copy the data */
+	__GLX_MEM_COPY(data, points, majorOrder * majorStride *
+		       __GLX_SIZE_FLOAT64);
+	return;
+    }
+
+#ifdef __GLX_ALIGN64
+    x = k * __GLX_SIZE_FLOAT64;
+#endif
+    for (i = 0; i<majorOrder; i++) {
+	for (j = 0; j<minorOrder; j++) {
+#ifdef __GLX_ALIGN64
+	    __GLX_MEM_COPY(data, points, x);
+#else
+	    for (x = 0; x<k; x++) {
+		data[x] = points[x];
+	    }
+#endif
+	    points += minorStride;
+	    data += k;
+	}
+	points += majorStride - minorStride * minorOrder;
+    }
+}
diff --git a/src/glx/x11/glcontextmodes.c b/src/glx/x11/glcontextmodes.c
new file mode 120000
index 00000000000..ca6b8c0b58a
--- /dev/null
+++ b/src/glx/x11/glcontextmodes.c
@@ -0,0 +1 @@
+../../../src/mesa/drivers/dri/common/glcontextmodes.c
\ No newline at end of file
diff --git a/src/glx/x11/glx_pbuffer.c b/src/glx/x11/glx_pbuffer.c
new file mode 100644
index 00000000000..83c550559c0
--- /dev/null
+++ b/src/glx/x11/glx_pbuffer.c
@@ -0,0 +1,556 @@
+/*
+ * (C) Copyright IBM Corporation 2004
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on 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.
+ */
+
+/**
+ * \file glx_pbuffer.c
+ * Implementation of pbuffer related functions.
+ * 
+ * \author Ian Romanick <[email protected]>
+ */
+
+#include <inttypes.h>
+#include "glxclient.h"
+#include <X11/extensions/extutil.h>
+#include <X11/extensions/Xext.h>
+#include <assert.h>
+#include <string.h>
+#include "glapi.h"
+#include "glxextensions.h"
+#include "glcontextmodes.h"
+#include "glheader.h"
+
+static void ChangeDrawableAttribute( Display * dpy, GLXDrawable drawable,
+    const CARD32 * attribs, size_t num_attribs );
+
+static void DestroyPbuffer( Display * dpy, GLXDrawable drawable );
+
+static GLXDrawable CreatePbuffer( Display *dpy,
+    const __GLcontextModes * fbconfig, unsigned int width, unsigned int height,
+    const int *attrib_list, GLboolean size_in_attribs );
+
+static int GetDrawableAttribute( Display *dpy, GLXDrawable drawable,
+    int attribute, unsigned int *value );
+
+
+/**
+ * Change a drawable's attribute.
+ *
+ * This function is used to implement \c glXSelectEvent and
+ * \c glXSelectEventSGIX.
+ *
+ * \note
+ * This function dynamically determines whether to use the SGIX_pbuffer
+ * version of the protocol or the GLX 1.3 version of the protocol.
+ *
+ * \todo
+ * This function needs to be modified to work with direct-rendering drivers.
+ */
+static void
+ChangeDrawableAttribute( Display * dpy, GLXDrawable drawable,
+			 const CARD32 * attribs, size_t num_attribs )
+{
+   __GLXdisplayPrivate *priv = __glXInitialize(dpy);
+   CARD32 * output;
+
+
+   if ( (dpy == NULL) || (drawable == 0) ) {
+      return;
+   }
+
+
+   LockDisplay(dpy);
+
+   if ( (priv->majorVersion > 1) || (priv->minorVersion >= 3) ) {
+      xGLXChangeDrawableAttributesReq *req;
+
+      GetReqExtra( GLXChangeDrawableAttributes, 8 + (8 * num_attribs), req );
+      output = (CARD32 *) (req + 1);
+
+      req->reqType = __glXSetupForCommand(dpy);
+      req->glxCode = X_GLXChangeDrawableAttributes;
+      req->drawable = drawable;
+      req->numAttribs = (CARD32) num_attribs;
+   }
+   else {
+      xGLXVendorPrivateWithReplyReq *vpreq;
+
+      GetReqExtra( GLXVendorPrivateWithReply, 4 + (8 * num_attribs), vpreq );
+      output = (CARD32 *) (vpreq + 1);
+
+      vpreq->reqType = __glXSetupForCommand(dpy);
+      vpreq->glxCode = X_GLXVendorPrivateWithReply;
+      vpreq->vendorCode = X_GLXvop_ChangeDrawableAttributesSGIX;
+
+      output[0] = (CARD32) drawable;
+      output++;
+   }
+
+   (void) memcpy( output, attribs, sizeof( CARD32 ) * 2 * num_attribs );
+
+   UnlockDisplay(dpy);
+   SyncHandle();
+
+   return;
+}
+
+
+/**
+ * Destroy a pbuffer.
+ *
+ * This function is used to implement \c glXDestroyPbuffer and
+ * \c glXDestroyGLXPbufferSGIX.
+ *
+ * \note
+ * This function dynamically determines whether to use the SGIX_pbuffer
+ * version of the protocol or the GLX 1.3 version of the protocol.
+ * 
+ * \todo
+ * This function needs to be modified to work with direct-rendering drivers.
+ */
+static void
+DestroyPbuffer( Display * dpy, GLXDrawable drawable )
+{
+   __GLXdisplayPrivate *priv = __glXInitialize(dpy);
+
+   if ( (dpy == NULL) || (drawable == 0) ) {
+      return;
+   }
+
+
+   LockDisplay(dpy);
+
+   if ( (priv->majorVersion > 1) || (priv->minorVersion >= 3) ) {
+      xGLXDestroyPbufferReq * req;
+
+      GetReqExtra( GLXDestroyPbuffer, 4, req );
+      req->reqType = __glXSetupForCommand(dpy);
+      req->glxCode = X_GLXDestroyPbuffer;
+      req->pbuffer = (GLXPbuffer) drawable;
+   }
+   else {
+      xGLXVendorPrivateWithReplyReq *vpreq;
+      CARD32 * data;
+
+      GetReqExtra( GLXVendorPrivateWithReply, 4, vpreq );
+      data = (CARD32 *) (vpreq + 1);
+
+      data[0] = (CARD32) drawable;
+
+      vpreq->reqType = __glXSetupForCommand(dpy);
+      vpreq->glxCode = X_GLXVendorPrivateWithReply;
+      vpreq->vendorCode = X_GLXvop_DestroyGLXPbufferSGIX;
+   }
+
+   UnlockDisplay(dpy);
+   SyncHandle();
+
+   return;
+}
+
+
+/**
+ * Get a drawable's attribute.
+ *
+ * This function is used to implement \c glXGetSelectedEvent and
+ * \c glXGetSelectedEventSGIX.
+ *
+ * \note
+ * This function dynamically determines whether to use the SGIX_pbuffer
+ * version of the protocol or the GLX 1.3 version of the protocol.
+ *
+ * \todo
+ * The number of attributes returned is likely to be small, probably less than
+ * 10.  Given that, this routine should try to use an array on the stack to
+ * capture the reply rather than always calling Xmalloc.
+ *
+ * \todo
+ * This function needs to be modified to work with direct-rendering drivers.
+ */
+static int
+GetDrawableAttribute( Display *dpy, GLXDrawable drawable,
+		      int attribute, unsigned int *value )
+{
+   __GLXdisplayPrivate *priv = __glXInitialize(dpy);
+   xGLXGetDrawableAttributesReply reply;
+   CARD32 * data;
+   unsigned int length;
+   unsigned int i;
+   unsigned int num_attributes;
+   GLboolean use_glx_1_3 = ((priv->majorVersion > 1)
+			    || (priv->minorVersion >= 3));
+
+
+   if ( (dpy == NULL) || (drawable == 0) ) {
+      return 0;
+   }
+
+   
+   LockDisplay(dpy);
+
+   if ( use_glx_1_3 ) {
+      xGLXGetDrawableAttributesReq *req;
+
+      GetReqExtra( GLXGetDrawableAttributes, 4, req );
+      req->reqType = __glXSetupForCommand(dpy);
+      req->glxCode = X_GLXGetDrawableAttributes;
+      req->drawable = drawable;
+   }
+   else {
+      xGLXVendorPrivateWithReplyReq *vpreq;
+
+      GetReqExtra( GLXVendorPrivateWithReply, 4, vpreq );
+      data = (CARD32 *) (vpreq + 1);
+      data[0] = (CARD32) drawable;
+
+      vpreq->reqType = __glXSetupForCommand(dpy);
+      vpreq->glxCode = X_GLXVendorPrivateWithReply;
+      vpreq->vendorCode = X_GLXvop_GetDrawableAttributesSGIX;
+   }
+
+   _XReply(dpy, (xReply*) &reply, 0, False);
+
+   length = reply.length;
+   num_attributes = (use_glx_1_3) ? reply.numAttribs : length / 2;
+   data = (CARD32 *) Xmalloc( length * sizeof(CARD32) );
+   if ( data == NULL ) {
+      /* Throw data on the floor */
+      _XEatData(dpy, length);
+   } else {
+      _XRead(dpy, (char *)data, length * sizeof(CARD32) );
+   }
+
+   UnlockDisplay(dpy);
+   SyncHandle();
+
+
+   /* Search the set of returned attributes for the attribute requested by
+    * the caller.
+    */
+
+   for ( i = 0 ; i < num_attributes ; i++ ) {
+      if ( data[i*2] == attribute ) {
+	 *value = data[ (i*2) + 1 ];
+	 break;
+      }
+   }
+
+   Xfree( data );
+
+   return 0;
+}
+
+
+/**
+ * Create a non-pbuffer GLX drawable.
+ *
+ * \todo
+ * This function needs to be modified to work with direct-rendering drivers.
+ */
+static GLXDrawable
+CreateDrawable( Display *dpy, const __GLcontextModes * fbconfig,
+		Drawable drawable, const int *attrib_list,
+		CARD8 glxCode )
+{
+   xGLXCreateWindowReq * req;
+   CARD32 * data;
+   unsigned int i;
+
+   i = 0;
+   if (attrib_list) {
+       while (attrib_list[i * 2] != None)
+	   i++;
+   }
+
+   LockDisplay(dpy);
+   GetReqExtra( GLXCreateWindow, 8 * i, req );
+   data = (CARD32 *) (req + 1);
+
+   req->reqType = __glXSetupForCommand(dpy);
+   req->glxCode = glxCode;
+   req->screen = (CARD32) fbconfig->screen;
+   req->fbconfig = fbconfig->fbconfigID;
+   req->window = (GLXPbuffer) drawable;
+   req->glxwindow = (GLXWindow) XAllocID(dpy);
+   req->numAttribs = (CARD32) i;
+
+   memcpy( data, attrib_list, 8 * i );
+   
+   UnlockDisplay(dpy);
+   SyncHandle();
+   
+   return (GLXDrawable)req->glxwindow;
+}
+
+
+/**
+ * Destroy a non-pbuffer GLX drawable.
+ *
+ * \todo
+ * This function needs to be modified to work with direct-rendering drivers.
+ */
+static void
+DestroyDrawable( Display * dpy, GLXDrawable drawable, CARD32 glxCode )
+{
+   xGLXDestroyPbufferReq * req;
+
+   if ( (dpy == NULL) || (drawable == 0) ) {
+      return;
+   }
+
+
+   LockDisplay(dpy);
+
+   GetReqExtra( GLXDestroyPbuffer, 4, req );
+   req->reqType = __glXSetupForCommand(dpy);
+   req->glxCode = glxCode;
+   req->pbuffer = (GLXPbuffer) drawable;
+
+   UnlockDisplay(dpy);
+   SyncHandle();
+
+   return;
+}
+
+
+/**
+ * Create a pbuffer.
+ *
+ * This function is used to implement \c glXCreatePbuffer and
+ * \c glXCreateGLXPbufferSGIX.
+ *
+ * \note
+ * This function dynamically determines whether to use the SGIX_pbuffer
+ * version of the protocol or the GLX 1.3 version of the protocol.
+ *
+ * \todo
+ * This function needs to be modified to work with direct-rendering drivers.
+ */
+static GLXDrawable
+CreatePbuffer( Display *dpy, const __GLcontextModes * fbconfig,
+	       unsigned int width, unsigned int height, 
+	       const int *attrib_list, GLboolean size_in_attribs )
+{
+   __GLXdisplayPrivate *priv = __glXInitialize(dpy);
+   GLXDrawable id = 0;
+   CARD32 * data;
+   unsigned int  i;
+
+   i = 0;
+   if (attrib_list) {
+       while (attrib_list[i * 2])
+	   i++;
+   }
+
+   LockDisplay(dpy);
+   id = XAllocID(dpy);
+
+   if ( (priv->majorVersion > 1) || (priv->minorVersion >= 3) ) {
+      xGLXCreatePbufferReq * req;
+      unsigned int extra = (size_in_attribs) ? 0 : 2;
+
+      GetReqExtra( GLXCreatePbuffer, (8 * (i + extra)), req );
+      data = (CARD32 *) (req + 1);
+
+      req->reqType = __glXSetupForCommand(dpy);
+      req->glxCode = X_GLXCreatePbuffer;
+      req->screen = (CARD32) fbconfig->screen;
+      req->fbconfig = fbconfig->fbconfigID;
+      req->pbuffer = (GLXPbuffer) id;
+      req->numAttribs = (CARD32) (i + extra);
+
+      if ( ! size_in_attribs ) {
+	 data[(2 * i) + 0] = GLX_PBUFFER_WIDTH;
+	 data[(2 * i) + 1] = width;
+	 data[(2 * i) + 2] = GLX_PBUFFER_HEIGHT;
+	 data[(2 * i) + 3] = height;
+	 data += 4;
+      }
+   }
+   else {
+      xGLXVendorPrivateReq *vpreq;
+
+      GetReqExtra( GLXVendorPrivate, 20 + (8 * i), vpreq );
+      data = (CARD32 *) (vpreq + 1);
+
+      vpreq->reqType = __glXSetupForCommand(dpy);
+      vpreq->glxCode = X_GLXVendorPrivate;
+      vpreq->vendorCode = X_GLXvop_CreateGLXPbufferSGIX;
+
+      data[0] = (CARD32) fbconfig->screen;
+      data[1] = (CARD32) fbconfig->fbconfigID;
+      data[2] = (CARD32) id;
+      data[3] = (CARD32) width;
+      data[4] = (CARD32) height;
+      data += 5;
+   }
+
+   (void) memcpy( data, attrib_list, sizeof(CARD32) * 2 * i );
+
+   UnlockDisplay(dpy);
+   SyncHandle();
+
+   return id;
+}
+
+
+/**
+ * Create a new pbuffer.
+ */
+PUBLIC GLXPbufferSGIX
+glXCreateGLXPbufferSGIX(Display *dpy, GLXFBConfigSGIX config,
+			unsigned int width, unsigned int height,
+			int *attrib_list)
+{
+   return (GLXPbufferSGIX) CreatePbuffer( dpy, (__GLcontextModes *) config,
+					  width, height,
+					  attrib_list, GL_FALSE );
+}
+
+
+/**
+ * Create a new pbuffer.
+ */
+PUBLIC GLXPbuffer
+glXCreatePbuffer(Display *dpy, GLXFBConfig config, const int *attrib_list)
+{
+   return (GLXPbuffer) CreatePbuffer( dpy, (__GLcontextModes *) config,
+				      0, 0,
+				      attrib_list, GL_TRUE );
+}
+
+
+/**
+ * Destroy an existing pbuffer.
+ */
+PUBLIC void
+glXDestroyPbuffer(Display *dpy, GLXPbuffer pbuf)
+{
+   DestroyPbuffer( dpy, pbuf );
+}
+
+
+/**
+ * Query an attribute of a drawable.
+ */
+PUBLIC void
+glXQueryDrawable(Display *dpy, GLXDrawable drawable,
+		 int attribute, unsigned int *value)
+{
+   GetDrawableAttribute( dpy, drawable, attribute, value );
+}
+
+
+/**
+ * Query an attribute of a pbuffer.
+ */
+PUBLIC int
+glXQueryGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX drawable,
+		       int attribute, unsigned int *value)
+{
+   return GetDrawableAttribute( dpy, drawable, attribute, value );
+}
+
+
+/**
+ * Select the event mask for a drawable.
+ */
+PUBLIC void
+glXSelectEvent(Display *dpy, GLXDrawable drawable, unsigned long mask)
+{
+   CARD32 attribs[2];
+
+   attribs[0] = (CARD32) GLX_EVENT_MASK;
+   attribs[1] = (CARD32) mask;
+
+   ChangeDrawableAttribute( dpy, drawable, attribs, 1 );
+}
+
+
+/**
+ * Get the selected event mask for a drawable.
+ */
+PUBLIC void
+glXGetSelectedEvent(Display *dpy, GLXDrawable drawable, unsigned long *mask)
+{
+   unsigned int value;
+
+
+   /* The non-sense with value is required because on LP64 platforms
+    * sizeof(unsigned int) != sizeof(unsigned long).  On little-endian
+    * we could just type-cast the pointer, but why?
+    */
+
+   GetDrawableAttribute( dpy, drawable, GLX_EVENT_MASK_SGIX, & value );
+   *mask = value;
+}
+
+
+PUBLIC GLXPixmap
+glXCreatePixmap( Display *dpy, GLXFBConfig config, Pixmap pixmap,
+		 const int *attrib_list )
+{
+   return CreateDrawable( dpy, (__GLcontextModes *) config,
+			  (Drawable) pixmap, attrib_list,
+			  X_GLXCreatePixmap );
+}
+
+
+PUBLIC GLXWindow
+glXCreateWindow( Display *dpy, GLXFBConfig config, Window win,
+		 const int *attrib_list )
+{
+   return CreateDrawable( dpy, (__GLcontextModes *) config,
+			  (Drawable) win, attrib_list,
+			  X_GLXCreateWindow );
+}
+
+
+PUBLIC void
+glXDestroyPixmap(Display *dpy, GLXPixmap pixmap)
+{
+   DestroyDrawable( dpy, (GLXDrawable) pixmap, X_GLXDestroyPixmap );
+}
+
+
+PUBLIC void
+glXDestroyWindow(Display *dpy, GLXWindow win)
+{
+   DestroyDrawable( dpy, (GLXDrawable) win, X_GLXDestroyWindow );
+}
+
+
+PUBLIC GLX_ALIAS_VOID(glXDestroyGLXPbufferSGIX,
+	  (Display *dpy, GLXPbufferSGIX pbuf),
+	  (dpy, pbuf),
+	  glXDestroyPbuffer)
+
+PUBLIC GLX_ALIAS_VOID(glXSelectEventSGIX,
+	  (Display *dpy, GLXDrawable drawable, unsigned long mask),
+	  (dpy, drawable, mask),
+	  glXSelectEvent)
+
+PUBLIC GLX_ALIAS_VOID(glXGetSelectedEventSGIX,
+	  (Display *dpy, GLXDrawable drawable, unsigned long *mask),
+	  (dpy, drawable, mask),
+	  glXGetSelectedEvent)
diff --git a/src/glx/x11/glx_query.c b/src/glx/x11/glx_query.c
new file mode 100644
index 00000000000..e93cd2afd43
--- /dev/null
+++ b/src/glx/x11/glx_query.c
@@ -0,0 +1,102 @@
+/*
+ * (C) Copyright IBM Corporation 2004
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on 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.
+ */
+
+/**
+ * \file glx_query.c
+ * Generic utility functions to query internal data from the server.
+ * 
+ * \author Ian Romanick <[email protected]>
+ */
+
+#include "glxclient.h"
+
+/**
+ * GLX protocol structure for the ficticious "GXLGenericGetString" request.
+ * 
+ * This is a non-existant protocol packet.  It just so happens that all of
+ * the real protocol packets used to request a string from the server have
+ * an identical binary layout.  The only difference between them is the
+ * meaning of the \c for_whom field and the value of the \c glxCode.
+ */
+typedef struct GLXGenericGetString {
+    CARD8 reqType;
+    CARD8 glxCode;
+    CARD16 length B16;
+    CARD32 for_whom B32;
+    CARD32 name B32;
+} xGLXGenericGetStringReq;
+
+/* These defines are only needed to make the GetReq macro happy.
+ */
+#define sz_xGLXGenericGetStringReq 12
+#define X_GLXGenericGetString 0
+
+/**
+ * Query the Server GLX string and cache it in the display private.
+ * This routine will allocate the necessay space for the string.
+ */
+char *
+__glXGetStringFromServer( Display * dpy, int opcode, CARD32 glxCode,
+			  CARD32 for_whom, CARD32 name )
+{
+    xGLXGenericGetStringReq *req;
+    xGLXSingleReply reply;
+    int length;
+    int numbytes;
+    char * buf;
+
+
+    LockDisplay( dpy );
+
+
+    /* All of the GLX protocol requests for getting a string from the server
+     * look the same.  The exact meaning of the for_whom field is usually
+     * either the screen number (for glXQueryServerString) or the context tag
+     * (for GLXSingle).
+     */
+
+    GetReq( GLXGenericGetString, req );
+    req->reqType = opcode;
+    req->glxCode = glxCode;
+    req->for_whom = for_whom;
+    req->name = name;
+
+    _XReply( dpy, (xReply *) & reply, 0, False );
+
+    length = reply.length * 4;
+    numbytes = reply.size;
+
+    buf = (char *) Xmalloc( numbytes );
+    if ( buf != NULL ) {
+        _XRead( dpy, buf, numbytes );
+	length -= numbytes;
+    }
+
+    _XEatData( dpy, length );
+
+    UnlockDisplay( dpy );
+    SyncHandle();
+
+    return buf;
+}
diff --git a/src/glx/x11/glx_texture_compression.c b/src/glx/x11/glx_texture_compression.c
new file mode 100644
index 00000000000..56768580177
--- /dev/null
+++ b/src/glx/x11/glx_texture_compression.c
@@ -0,0 +1,347 @@
+/*
+ * (C) Copyright IBM Corporation 2004
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on 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
+ * THE COPYRIGHT HOLDERS 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.
+ */
+
+/**
+ * \file glx_texture_compression.c
+ * Contains the routines required to implement GLX protocol for
+ * ARB_texture_compression and related extensions.
+ *
+ * \sa http://oss.sgi.com/projects/ogl-sample/registry/ARB/texture_compression.txt
+ *
+ * \author Ian Romanick <[email protected]>
+ */
+
+#include "packrender.h"
+#include "packsingle.h"
+#include "indirect.h"
+
+#include <assert.h>
+
+
+void
+__indirect_glGetCompressedTexImageARB( GLenum target, GLint level, 
+				    GLvoid * img )
+{
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    xGLXGetTexImageReply reply;
+    size_t image_bytes;
+
+    __GLX_SINGLE_LOAD_VARIABLES();
+    __GLX_SINGLE_BEGIN( X_GLsop_GetCompressedTexImage, 8 );
+    __GLX_SINGLE_PUT_LONG( 0, target );
+    __GLX_SINGLE_PUT_LONG( 4, level );
+    __GLX_SINGLE_READ_XREPLY();
+
+    image_bytes = reply.width;
+    assert( image_bytes <= ((4 * reply.length) - 0) );
+    assert( image_bytes >= ((4 * reply.length) - 3) );
+    
+    if ( image_bytes != 0 ) {
+	_XRead( dpy, (char *) img, image_bytes );
+	if ( image_bytes < (4 * reply.length) ) {
+	    _XEatData( dpy, (4 * reply.length) - image_bytes );
+	}
+    }
+
+    __GLX_SINGLE_END();
+}
+
+
+/**
+ * Internal function used for \c glCompressedTexImage1D and
+ * \c glCompressedTexImage2D.
+ */
+static void
+CompressedTexImage1D2D( GLenum target, GLint level,
+			GLenum internal_format, 
+			GLsizei width, GLsizei height,
+			GLint border, GLsizei image_size,
+			const GLvoid *data, CARD32 rop )
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if ( gc->currentDpy == NULL ) {
+	return;
+    }
+
+    if ( (target == GL_PROXY_TEXTURE_1D)
+	 || (target == GL_PROXY_TEXTURE_2D)
+	 || (target == GL_PROXY_TEXTURE_CUBE_MAP) ) {
+	compsize = 0;
+    }
+    else {
+	compsize = image_size;
+    }
+
+    cmdlen = __GLX_PAD( __GLX_COMPRESSED_TEXIMAGE_CMD_HDR_SIZE 
+			+ compsize );
+    if ( cmdlen <= gc->maxSmallRenderCommandSize ) {
+	__GLX_BEGIN_VARIABLE( rop, cmdlen );
+	__GLX_PUT_LONG( 4, target );
+	__GLX_PUT_LONG( 8, level );
+	__GLX_PUT_LONG( 12, internal_format );
+	__GLX_PUT_LONG( 16, width );
+	__GLX_PUT_LONG( 20, height );
+	__GLX_PUT_LONG( 24, border );
+	__GLX_PUT_LONG( 28, image_size );
+	if ( compsize != 0 ) {
+	    __GLX_PUT_CHAR_ARRAY( __GLX_COMPRESSED_TEXIMAGE_CMD_HDR_SIZE,
+				  data, image_size );
+	}
+	__GLX_END( cmdlen );
+    }
+    else {
+	assert( compsize != 0 );
+
+	__GLX_BEGIN_VARIABLE_LARGE( rop, cmdlen + 4 );
+	__GLX_PUT_LONG( 8, target );
+	__GLX_PUT_LONG( 12, level );
+	__GLX_PUT_LONG( 16, internal_format );
+	__GLX_PUT_LONG( 20, width );
+	__GLX_PUT_LONG( 24, height );
+	__GLX_PUT_LONG( 28, border );
+	__GLX_PUT_LONG( 32, image_size );
+	__glXSendLargeCommand( gc, gc->pc,
+			       __GLX_COMPRESSED_TEXIMAGE_CMD_HDR_SIZE + 4,
+			       data, image_size );
+    }
+}
+
+
+/**
+ * Internal function used for \c glCompressedTexSubImage1D and
+ * \c glCompressedTexSubImage2D.
+ */
+static void
+CompressedTexSubImage1D2D( GLenum target, GLint level,
+			   GLsizei xoffset, GLsizei yoffset,
+			   GLsizei width, GLsizei height,
+			   GLenum format, GLsizei image_size,
+			   const GLvoid *data, CARD32 rop )
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if ( gc->currentDpy == NULL ) {
+	return;
+    }
+
+    if ( target == GL_PROXY_TEXTURE_3D ) {
+	compsize = 0;
+    }
+    else {
+	compsize = image_size;
+    }
+
+    cmdlen = __GLX_PAD( __GLX_COMPRESSED_TEXSUBIMAGE_CMD_HDR_SIZE
+			+ compsize );
+    if ( cmdlen <= gc->maxSmallRenderCommandSize ) {
+	__GLX_BEGIN_VARIABLE( rop, cmdlen );
+	__GLX_PUT_LONG( 4, target );
+	__GLX_PUT_LONG( 8, level );
+	__GLX_PUT_LONG( 12, xoffset );
+	__GLX_PUT_LONG( 16, yoffset );
+	__GLX_PUT_LONG( 20, width );
+	__GLX_PUT_LONG( 24, height );
+	__GLX_PUT_LONG( 28, format );
+	__GLX_PUT_LONG( 32, image_size );
+	if ( compsize != 0 ) {
+	    __GLX_PUT_CHAR_ARRAY( __GLX_COMPRESSED_TEXSUBIMAGE_CMD_HDR_SIZE, 
+				  data, image_size );
+	}
+	__GLX_END( cmdlen );
+    }
+    else {
+	assert( compsize != 0 );
+
+	__GLX_BEGIN_VARIABLE_LARGE( rop, cmdlen + 4 );
+	__GLX_PUT_LONG( 8, target );
+	__GLX_PUT_LONG( 12, level );
+	__GLX_PUT_LONG( 16, xoffset );
+	__GLX_PUT_LONG( 20, yoffset );
+	__GLX_PUT_LONG( 24, width );
+	__GLX_PUT_LONG( 28, height );
+	__GLX_PUT_LONG( 32, format );
+	__GLX_PUT_LONG( 36, image_size );
+	__glXSendLargeCommand( gc, gc->pc,
+			       __GLX_COMPRESSED_TEXSUBIMAGE_CMD_HDR_SIZE + 4,
+			       data, image_size );
+    }
+}
+
+
+void
+__indirect_glCompressedTexImage1DARB( GLenum target, GLint level,
+				   GLenum internal_format, GLsizei width,
+				   GLint border, GLsizei image_size,
+				   const GLvoid *data )
+{
+    CompressedTexImage1D2D( target, level, internal_format, width, 0,
+			    border, image_size, data,
+			    X_GLrop_CompressedTexImage1D );
+}
+
+
+void
+__indirect_glCompressedTexImage2DARB( GLenum target, GLint level,
+				   GLenum internal_format,
+				   GLsizei width, GLsizei height,
+				   GLint border, GLsizei image_size,
+				   const GLvoid *data )
+{
+    CompressedTexImage1D2D( target, level, internal_format, width, height,
+			    border, image_size, data,
+			    X_GLrop_CompressedTexImage2D );
+}
+
+
+void
+__indirect_glCompressedTexImage3DARB( GLenum target, GLint level,
+				   GLenum internal_format,
+				   GLsizei width, GLsizei height, GLsizei depth,
+				   GLint border, GLsizei image_size,
+				   const GLvoid *data )
+{
+    __GLX_DECLARE_VARIABLES();
+    
+    __GLX_LOAD_VARIABLES();
+    if ( gc->currentDpy == NULL ) {
+	return;
+    }
+
+    cmdlen = __GLX_PAD( __GLX_COMPRESSED_TEXIMAGE_3D_CMD_HDR_SIZE
+			+ image_size );
+    if ( cmdlen <= gc->maxSmallRenderCommandSize ) {
+	__GLX_BEGIN_VARIABLE( X_GLrop_CompressedTexImage3D, cmdlen );
+	__GLX_PUT_LONG( 4, target );
+	__GLX_PUT_LONG( 8, level );
+	__GLX_PUT_LONG( 12, internal_format );
+	__GLX_PUT_LONG( 16, width );
+	__GLX_PUT_LONG( 20, height );
+	__GLX_PUT_LONG( 24, depth );
+	__GLX_PUT_LONG( 28, border );
+	__GLX_PUT_LONG( 32, image_size );
+	if ( image_size != 0 ) {
+	    __GLX_PUT_CHAR_ARRAY( __GLX_COMPRESSED_TEXIMAGE_3D_CMD_HDR_SIZE,
+				  data, image_size );
+	}
+	__GLX_END( cmdlen );
+    }
+    else {
+	__GLX_BEGIN_VARIABLE_LARGE( X_GLrop_CompressedTexImage3D,
+				    cmdlen + 4 );
+	__GLX_PUT_LONG( 8, target );
+	__GLX_PUT_LONG( 12, level );
+	__GLX_PUT_LONG( 16, internal_format );
+	__GLX_PUT_LONG( 20, width );
+	__GLX_PUT_LONG( 24, height );
+	__GLX_PUT_LONG( 28, depth );
+	__GLX_PUT_LONG( 32, border );
+	__GLX_PUT_LONG( 36, image_size );
+	__glXSendLargeCommand( gc, gc->pc,
+			       __GLX_COMPRESSED_TEXIMAGE_3D_CMD_HDR_SIZE + 4,
+			       data, image_size );
+    }
+}
+
+
+void
+__indirect_glCompressedTexSubImage1DARB( GLenum target, GLint level,
+				      GLint xoffset,
+				      GLsizei width,
+				      GLenum format, GLsizei image_size,
+				      const GLvoid *data )
+{
+    CompressedTexSubImage1D2D( target, level, xoffset, 0, width, 0,
+			       format, image_size, data,
+			       X_GLrop_CompressedTexSubImage1D );
+}
+
+
+void
+__indirect_glCompressedTexSubImage2DARB( GLenum target, GLint level,
+				      GLint xoffset, GLint yoffset,
+				      GLsizei width, GLsizei height,
+				      GLenum format, GLsizei image_size,
+				      const GLvoid *data )
+{
+    CompressedTexSubImage1D2D( target, level, xoffset, yoffset, width, height,
+			       format, image_size, data,
+			       X_GLrop_CompressedTexSubImage2D );
+}
+
+
+void
+__indirect_glCompressedTexSubImage3DARB( GLenum target, GLint level,
+				      GLint xoffset, GLint yoffset, GLint zoffset,
+				      GLsizei width, GLsizei height, GLsizei depth,
+				      GLenum format, GLsizei image_size,
+				      const GLvoid *data )
+{
+    __GLX_DECLARE_VARIABLES();
+    
+    __GLX_LOAD_VARIABLES();
+    if ( gc->currentDpy == NULL ) {
+	return;
+    }
+
+    cmdlen = __GLX_PAD( __GLX_COMPRESSED_TEXSUBIMAGE_3D_CMD_HDR_SIZE
+			+ image_size );
+    if ( cmdlen <= gc->maxSmallRenderCommandSize ) {
+	__GLX_BEGIN_VARIABLE( X_GLrop_CompressedTexSubImage3D, cmdlen );
+	__GLX_PUT_LONG( 4, target );
+	__GLX_PUT_LONG( 8, level );
+	__GLX_PUT_LONG( 12, xoffset );
+	__GLX_PUT_LONG( 16, yoffset );
+	__GLX_PUT_LONG( 20, zoffset );
+	__GLX_PUT_LONG( 24, width );
+	__GLX_PUT_LONG( 28, height );
+	__GLX_PUT_LONG( 32, depth );
+	__GLX_PUT_LONG( 36, format );
+	__GLX_PUT_LONG( 40, image_size );
+	if ( image_size != 0 ) {
+	    __GLX_PUT_CHAR_ARRAY( __GLX_COMPRESSED_TEXSUBIMAGE_3D_CMD_HDR_SIZE,
+				  data, image_size );
+	}
+	__GLX_END( cmdlen );
+    }
+    else {
+	__GLX_BEGIN_VARIABLE_LARGE( X_GLrop_CompressedTexSubImage3D,
+				    cmdlen + 4 );
+	__GLX_PUT_LONG( 8, target );
+	__GLX_PUT_LONG( 12, level );
+	__GLX_PUT_LONG( 16, xoffset );
+	__GLX_PUT_LONG( 20, yoffset );
+	__GLX_PUT_LONG( 24, zoffset );
+	__GLX_PUT_LONG( 28, width );
+	__GLX_PUT_LONG( 32, height );
+	__GLX_PUT_LONG( 36, depth );
+	__GLX_PUT_LONG( 40, format );
+	__GLX_PUT_LONG( 44, image_size );
+	__glXSendLargeCommand( gc, gc->pc,
+			       __GLX_COMPRESSED_TEXSUBIMAGE_3D_CMD_HDR_SIZE + 4,
+			       data, image_size );
+    }
+}
diff --git a/src/glx/x11/glxclient.h b/src/glx/x11/glxclient.h
new file mode 100644
index 00000000000..bc9a94c5d5b
--- /dev/null
+++ b/src/glx/x11/glxclient.h
@@ -0,0 +1,690 @@
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+*/
+/* $XFree86: xc/lib/GL/glx/glxclient.h,v 1.21 2004/02/09 23:46:31 alanh Exp $ */
+
+/**
+ * \file glxclient.h
+ * Direct rendering support added by Precision Insight, Inc.
+ *
+ * \author Kevin E. Martin <[email protected]>
+ */
+
+#ifndef _GLX_client_h_
+#define _GLX_client_h_
+#define NEED_REPLIES
+#define NEED_EVENTS
+#include <X11/Xproto.h>
+#include <X11/Xlibint.h>
+#define GLX_GLXEXT_PROTOTYPES
+#include <GL/glx.h>
+#include <GL/glxext.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#ifdef WIN32
+#include <stdint.h>
+#endif
+#include "GL/glxint.h"
+#include "GL/glxproto.h"
+#include "GL/internal/glcore.h"
+#include "glapitable.h"
+#include "glxextensions.h"
+#if defined( USE_XTHREADS )
+# include <X11/Xthreads.h>
+#elif defined( PTHREADS )
+# include <pthread.h>
+#endif
+
+#define GLX_MAJOR_VERSION	1	/* current version numbers */
+#define GLX_MINOR_VERSION	4
+
+#define __GLX_MAX_TEXTURE_UNITS 32
+
+typedef struct __GLXcontextRec __GLXcontext;
+typedef struct __GLXdisplayPrivateRec __GLXdisplayPrivate;
+typedef struct _glapi_table __GLapi;
+
+/************************************************************************/
+
+#ifdef GLX_DIRECT_RENDERING
+
+#include <GL/internal/dri_interface.h>
+
+
+/**
+ * Display dependent methods.  This structure is initialized during the
+ * \c driCreateDisplay call.
+ */
+struct __DRIdisplayRec {
+    /**
+     * Method to destroy the private DRI display data.
+     */
+    void (*destroyDisplay)(Display *dpy, void *displayPrivate);
+
+    /**
+     * Opaque pointer to private per display direct rendering data.
+     * \c NULL if direct rendering is not supported on this display.
+     */
+    struct __DRIdisplayPrivateRec *private;
+
+    /**
+     * Array of pointers to methods to create and initialize the private DRI
+     * screen data.
+     */
+    PFNCREATENEWSCREENFUNC * createNewScreen;
+};
+
+
+/*
+** We keep a linked list of these structures, one per DRI device driver.
+*/
+struct __DRIdriverRec {
+   const char *name;
+   void *handle;
+   PFNCREATENEWSCREENFUNC createNewScreenFunc;
+   struct __DRIdriverRec *next;
+};
+
+/*
+** Function to create and DRI display data and initialize the display
+** dependent methods.
+*/
+extern void *driCreateDisplay(Display *dpy, __DRIdisplay *pdisp);
+
+extern  __DRIdriver *driGetDriver(Display *dpy, int scrNum);
+
+extern void DRI_glXUseXFont( Font font, int first, int count, int listbase );
+
+/*
+** Functions to obtain driver configuration information from a direct
+** rendering client application
+*/
+extern const char *glXGetScreenDriver (Display *dpy, int scrNum);
+
+extern const char *glXGetDriverConfig (const char *driverName);
+
+extern Bool __glXWindowExists(Display *dpy, GLXDrawable draw);
+
+#endif
+
+/************************************************************************/
+
+#define __GL_CLIENT_ATTRIB_STACK_DEPTH 16
+
+typedef struct __GLXpixelStoreModeRec {
+    GLboolean swapEndian;
+    GLboolean lsbFirst;
+    GLuint rowLength;
+    GLuint imageHeight;
+    GLuint imageDepth;
+    GLuint skipRows;
+    GLuint skipPixels;
+    GLuint skipImages;
+    GLuint alignment;
+} __GLXpixelStoreMode;
+
+
+typedef struct __GLXattributeRec {
+    GLuint mask;
+
+    /**
+     * Pixel storage state.  Most of the pixel store mode state is kept
+     * here and used by the client code to manage the packing and
+     * unpacking of data sent to/received from the server.
+     */
+    __GLXpixelStoreMode storePack, storeUnpack;
+
+    /**
+     * Is EXT_vertex_array / GL 1.1 DrawArrays protocol specifically
+     * disabled?
+     */
+    GLboolean NoDrawArraysProtocol;
+    
+    /**
+     * Vertex Array storage state.  The vertex array component
+     * state is stored here and is used to manage the packing of
+     * DrawArrays data sent to the server.
+     */
+    struct array_state_vector * array_state;
+} __GLXattribute;
+
+typedef struct __GLXattributeMachineRec {
+	__GLXattribute *stack[__GL_CLIENT_ATTRIB_STACK_DEPTH];
+	__GLXattribute **stackPointer;
+} __GLXattributeMachine;
+
+/**
+ * GLX state that needs to be kept on the client.  One of these records
+ * exist for each context that has been made current by this client.
+ */
+struct __GLXcontextRec {
+    /**
+     * \name Drawing command buffer.
+     *
+     * Drawing commands are packed into this buffer before being sent as a
+     * single GLX protocol request.  The buffer is sent when it overflows or
+     * is flushed by \c __glXFlushRenderBuffer.  \c pc is the next location
+     * in the buffer to be filled.  \c limit is described above in the buffer
+     * slop discussion.
+     *
+     * Commands that require large amounts of data to be transfered will
+     * also use this buffer to hold a header that describes the large
+     * command.
+     *
+     * These must be the first 6 fields since they are static initialized
+     * in the dummy context in glxext.c
+     */
+    /*@{*/
+    GLubyte *buf;
+    GLubyte *pc;
+    GLubyte *limit;
+    GLubyte *bufEnd;
+    GLint bufSize;
+    /*@}*/
+
+    /**
+     * The XID of this rendering context.  When the context is created a
+     * new XID is allocated.  This is set to None when the context is
+     * destroyed but is still current to some thread. In this case the
+     * context will be freed on next MakeCurrent.
+     */
+    XID xid;
+
+    /**
+     * The XID of the \c shareList context.
+     */
+    XID share_xid;
+
+    /**
+     * Visual id.
+     * 
+     * \deprecated
+     * This filed has been largely been replaced by the \c mode field, but
+     * the work is not quite done.
+     */
+    VisualID vid;
+
+    /**
+     * Screen number.
+     */
+    GLint screen;
+
+    /**
+     * \c GL_TRUE if the context was created with ImportContext, which
+     * means the server-side context was created by another X client.
+     */
+    GLboolean imported;
+
+    /**
+     * The context tag returned by MakeCurrent when this context is made
+     * current. This tag is used to identify the context that a thread has
+     * current so that proper server context management can be done.  It is
+     * used for all context specific commands (i.e., \c Render, \c RenderLarge,
+     * \c WaitX, \c WaitGL, \c UseXFont, and \c MakeCurrent (for the old
+     * context)).
+     */
+    GLXContextTag currentContextTag;
+
+    /**
+     * \name Rendering mode
+     *
+     * The rendering mode is kept on the client as well as the server.
+     * When \c glRenderMode is called, the buffer associated with the
+     * previous rendering mode (feedback or select) is filled.
+     */
+    /*@{*/
+    GLenum renderMode;
+    GLfloat *feedbackBuf;
+    GLuint *selectBuf;
+    /*@}*/
+
+    /**
+     * This is \c GL_TRUE if the pixel unpack modes are such that an image
+     * can be unpacked from the clients memory by just copying.  It may
+     * still be true that the server will have to do some work.  This
+     * just promises that a straight copy will fetch the correct bytes.
+     */
+    GLboolean fastImageUnpack;
+
+    /**
+     * Fill newImage with the unpacked form of \c oldImage getting it
+     * ready for transport to the server.
+     */
+    void (*fillImage)(__GLXcontext*, GLint, GLint, GLint, GLint, GLenum,
+		      GLenum, const GLvoid*, GLubyte*, GLubyte*);
+
+    /**
+     * Client side attribs.
+     */
+    __GLXattributeMachine attributes;
+
+    /**
+     * Client side error code.  This is set when client side gl API
+     * routines need to set an error because of a bad enumerant or
+     * running out of memory, etc.
+     */
+    GLenum error;
+
+    /**
+     * Whether this context does direct rendering.
+     */
+    Bool isDirect;
+
+    /**
+     * \c dpy of current display for this context.  Will be \c NULL if not
+     * current to any display, or if this is the "dummy context".
+     */
+    Display *currentDpy;
+
+    /**
+     * The current drawable for this context.  Will be None if this
+     * context is not current to any drawable.  currentReadable is below.
+     */
+    GLXDrawable currentDrawable;
+
+    /**
+     * \name GL Constant Strings
+     *
+     * Constant strings that describe the server implementation
+     * These pertain to GL attributes, not to be confused with
+     * GLX versioning attributes.
+     */
+    /*@{*/
+    GLubyte *vendor;
+    GLubyte *renderer;
+    GLubyte *version;
+    GLubyte *extensions;
+    /*@}*/
+
+    /**
+     * Record the dpy this context was created on for later freeing
+     */
+    Display *createDpy;
+
+    /**
+     * Maximum small render command size.  This is the smaller of 64k and
+     * the size of the above buffer.
+     */
+    GLint maxSmallRenderCommandSize;
+
+    /**
+     * Major opcode for the extension.  Copied here so a lookup isn't
+     * needed.
+     */
+    GLint majorOpcode;
+
+#ifdef GLX_DIRECT_RENDERING
+    /**
+     * Per context direct rendering interface functions and data.
+     */
+    __DRIcontext driContext;
+#endif
+    
+    /**
+     * \c GLXFBConfigID used to create this context.  May be \c None.  This
+     * field has been replaced by the \c mode field.
+     *
+     * \since Internal API version 20030317.
+     *
+     * \deprecated
+     * This filed has been largely been replaced by the \c mode field, but
+     * the work is not quite done.
+     */
+    GLXFBConfigID  fbconfigID;
+
+    /**
+     * The current read-drawable for this context.  Will be None if this
+     * context is not current to any drawable.
+     *
+     * \since Internal API version 20030606.
+     */
+    GLXDrawable currentReadable;
+
+   /** 
+    * Pointer to client-state data that is private to libGL.  This is only
+    * used for indirect rendering contexts.
+    *
+    * No internal API version change was made for this change.  Client-side
+    * drivers should NEVER use this data or even care that it exists.
+    */
+   void * client_state_private;
+
+   /**
+    * Stored value for \c glXQueryContext attribute \c GLX_RENDER_TYPE.
+    */
+   int renderType;
+    
+   /**
+    * \name Raw server GL version
+    *
+    * True core GL version supported by the server.  This is the raw value
+    * returned by the server, and it may not reflect what is actually
+    * supported (or reported) by the client-side library.
+    */
+    /*@{*/
+   int server_major;        /**< Major version number. */
+   int server_minor;        /**< Minor version number. */
+    /*@}*/
+
+    char gl_extension_bits[ __GL_EXT_BYTES ];
+};
+
+#define __glXSetError(gc,code) \
+    if (!(gc)->error) {	       \
+	(gc)->error = code;    \
+    }
+
+extern void __glFreeAttributeState(__GLXcontext *);
+
+/************************************************************************/
+
+/**
+ * The size of the largest drawing command known to the implementation
+ * that will use the GLXRender GLX command.  In this case it is
+ * \c glPolygonStipple.
+ */
+#define __GLX_MAX_SMALL_RENDER_CMD_SIZE	156
+
+/**
+ * To keep the implementation fast, the code uses a "limit" pointer
+ * to determine when the drawing command buffer is too full to hold
+ * another fixed size command.  This constant defines the amount of
+ * space that must always be available in the drawing command buffer
+ * at all times for the implementation to work.  It is important that
+ * the number be just large enough, but not so large as to reduce the
+ * efficacy of the buffer.  The "+32" is just to keep the code working
+ * in case somebody counts wrong.
+ */
+#define __GLX_BUFFER_LIMIT_SIZE	(__GLX_MAX_SMALL_RENDER_CMD_SIZE + 32)
+
+/**
+ * This implementation uses a smaller threshold for switching
+ * to the RenderLarge protocol than the protcol requires so that
+ * large copies don't occur.
+ */
+#define __GLX_RENDER_CMD_SIZE_LIMIT	4096
+
+/**
+ * One of these records exists per screen of the display.  It contains
+ * a pointer to the config data for that screen (if the screen supports GL).
+ */
+typedef struct __GLXscreenConfigsRec {
+    /**
+     * GLX extension string reported by the X-server.
+     */
+    const char *serverGLXexts;
+
+    /**
+     * GLX extension string to be reported to applications.  This is the
+     * set of extensions that the application can actually use.
+     */
+    char *effectiveGLXexts;
+
+#ifdef GLX_DIRECT_RENDERING
+    /**
+     * Per screen direct rendering interface functions and data.
+     */
+    __DRIscreen driScreen;
+#endif
+
+    /**
+     * Linked list of configurations for this screen.
+     */
+    __GLcontextModes *configs;
+
+    /**
+     * Per-screen dynamic GLX extension tracking.  The \c direct_support
+     * field only contains enough bits for 64 extensions.  Should libGL
+     * ever need to track more than 64 GLX extensions, we can safely grow
+     * this field.  The \c __GLXscreenConfigs structure is not used outside
+     * libGL.
+     */
+    /*@{*/
+    unsigned char direct_support[8];
+    GLboolean ext_list_first_time;
+    /*@}*/
+
+} __GLXscreenConfigs;
+
+/**
+ * Per display private data.  One of these records exists for each display
+ * that is using the OpenGL (GLX) extension.
+ */
+struct __GLXdisplayPrivateRec {
+    /**
+     * Back pointer to the display
+     */
+    Display *dpy;
+
+    /**
+     * The \c majorOpcode is common to all connections to the same server.
+     * It is also copied into the context structure.
+     */
+    int majorOpcode;
+
+    /**
+     * \name Server Version
+     *
+     * Major and minor version returned by the server during initialization.
+     */
+    /*@{*/
+    int majorVersion, minorVersion;
+    /*@}*/
+
+    /**
+     * \name Storage for the servers GLX vendor and versions strings.
+     * 
+     * These are the same for all screens on this display. These fields will
+     * be filled in on demand.
+     */
+    /*@{*/
+    const char *serverGLXvendor;
+    const char *serverGLXversion;
+    /*@}*/
+
+    /**
+     * Configurations of visuals for all screens on this display.
+     * Also, per screen data which now includes the server \c GLX_EXTENSION
+     * string.
+     */
+    __GLXscreenConfigs *screenConfigs;
+
+#ifdef GLX_DIRECT_RENDERING
+    /**
+     * Per display direct rendering interface functions and data.
+     */
+    __DRIdisplay driDisplay;
+#endif
+};
+
+void __glXFreeContext(__GLXcontext*);
+
+extern GLubyte *__glXFlushRenderBuffer(__GLXcontext*, GLubyte*);
+
+extern void __glXSendLargeChunk(__GLXcontext *gc, GLint requestNumber, 
+				GLint totalRequests,
+				const GLvoid * data, GLint dataLen);
+
+extern void __glXSendLargeCommand(__GLXcontext *, const GLvoid *, GLint,
+				  const GLvoid *, GLint);
+
+/* Initialize the GLX extension for dpy */
+extern __GLXdisplayPrivate *__glXInitialize(Display*);
+
+/************************************************************************/
+
+extern int __glXDebug;
+
+/* This is per-thread storage in an MT environment */
+#if defined( USE_XTHREADS ) || defined( PTHREADS )
+
+extern void __glXSetCurrentContext(__GLXcontext *c);
+
+# if defined( GLX_USE_TLS )
+
+extern __thread void * __glX_tls_Context
+    __attribute__((tls_model("initial-exec")));
+
+#  define __glXGetCurrentContext()	__glX_tls_Context
+
+# else
+
+extern __GLXcontext *__glXGetCurrentContext(void);
+
+# endif /* defined( GLX_USE_TLS ) */
+
+#else
+
+extern __GLXcontext *__glXcurrentContext;
+#define __glXGetCurrentContext()	__glXcurrentContext
+#define __glXSetCurrentContext(gc)	__glXcurrentContext = gc
+
+#endif /* defined( USE_XTHREADS ) || defined( PTHREADS ) */
+
+
+/*
+** Global lock for all threads in this address space using the GLX
+** extension
+*/
+#if defined( USE_XTHREADS )
+extern xmutex_rec __glXmutex;
+#define __glXLock()    xmutex_lock(&__glXmutex)
+#define __glXUnlock()  xmutex_unlock(&__glXmutex)
+#elif defined( PTHREADS )
+extern pthread_mutex_t __glXmutex;
+#define __glXLock()    pthread_mutex_lock(&__glXmutex)
+#define __glXUnlock()  pthread_mutex_unlock(&__glXmutex)
+#else
+#define __glXLock()
+#define __glXUnlock()
+#endif
+
+/*
+** Setup for a command.  Initialize the extension for dpy if necessary.
+*/
+extern CARD8 __glXSetupForCommand(Display *dpy);
+
+/************************************************************************/
+
+/*
+** Data conversion and packing support.
+*/
+
+extern const GLuint __glXDefaultPixelStore[9];
+
+/* Send an image to the server using RenderLarge. */
+extern void __glXSendLargeImage(__GLXcontext *gc, GLint compsize, GLint dim,
+    GLint width, GLint height, GLint depth, GLenum format, GLenum type,
+    const GLvoid *src, GLubyte *pc, GLubyte *modes);
+
+/* Return the size, in bytes, of some pixel data */
+extern GLint __glImageSize(GLint, GLint, GLint, GLenum, GLenum, GLenum);
+
+/* Return the number of elements per group of a specified format*/
+extern GLint __glElementsPerGroup(GLenum format, GLenum type);
+
+/* Return the number of bytes per element, based on the element type (other
+** than GL_BITMAP).
+*/
+extern GLint __glBytesPerElement(GLenum type);
+
+/*
+** Fill the transport buffer with the data from the users buffer,
+** applying some of the pixel store modes (unpack modes) to the data
+** first.  As a side effect of this call, the "modes" field is
+** updated to contain the modes needed by the server to decode the
+** sent data.
+*/
+extern void __glFillImage(__GLXcontext*, GLint, GLint, GLint, GLint, GLenum,
+			  GLenum, const GLvoid*, GLubyte*, GLubyte*);
+
+/* Copy map data with a stride into a packed buffer */
+extern void __glFillMap1f(GLint, GLint, GLint, const GLfloat *, GLubyte *);
+extern void __glFillMap1d(GLint, GLint, GLint, const GLdouble *, GLubyte *);
+extern void __glFillMap2f(GLint, GLint, GLint, GLint, GLint,
+			  const GLfloat *, GLfloat *);
+extern void __glFillMap2d(GLint, GLint, GLint, GLint, GLint,
+			  const GLdouble *, GLdouble *);
+
+/*
+** Empty an image out of the reply buffer into the clients memory applying
+** the pack modes to pack back into the clients requested format.
+*/
+extern void __glEmptyImage(__GLXcontext*, GLint, GLint, GLint, GLint, GLenum,
+		           GLenum, const GLubyte *, GLvoid *);
+
+
+/*
+** Allocate and Initialize Vertex Array client state 
+*/
+extern void __glXInitVertexArrayState(__GLXcontext*);
+
+/*
+** Inform the Server of the major and minor numbers and of the client
+** libraries extension string.
+*/
+extern void __glXClientInfo (  Display *dpy, int opcode );
+
+/************************************************************************/
+
+/*
+** Declarations that should be in Xlib
+*/
+#ifdef __GL_USE_OUR_PROTOTYPES
+extern void _XFlush(Display*);
+extern Status _XReply(Display*, xReply*, int, Bool);
+extern void _XRead(Display*, void*, long);
+extern void _XSend(Display*, const void*, long);
+#endif
+
+
+extern void __glXInitializeVisualConfigFromTags( __GLcontextModes *config,
+    int count, const INT32 *bp, Bool tagged_only, Bool fbconfig_style_tags );
+
+extern char * __glXGetStringFromServer( Display * dpy, int opcode,
+    CARD32 glxCode, CARD32 for_whom, CARD32 name );
+
+extern char *__glXstrdup(const char *str);
+
+
+extern const char __glXGLClientVersion[];
+extern const char __glXGLClientExtensions[];
+
+/* Determine the internal API version */
+extern int __glXGetInternalVersion(void);
+
+/* Get the unadjusted system time */
+extern int __glXGetUST( int64_t * ust );
+
+#endif /* !__GLX_client_h__ */
diff --git a/src/glx/x11/glxcmds.c b/src/glx/x11/glxcmds.c
new file mode 100644
index 00000000000..6a31f24dd8c
--- /dev/null
+++ b/src/glx/x11/glxcmds.c
@@ -0,0 +1,2969 @@
+/* $XFree86: xc/lib/GL/glx/glxcmds.c,v 1.30 2004/01/30 20:33:06 alanh Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+/**
+ * \file glxcmds.c
+ * Client-side GLX interface.
+ */
+
+#include <inttypes.h>
+#include "glxclient.h"
+#include <X11/extensions/extutil.h>
+#include <X11/extensions/Xext.h>
+#include <assert.h>
+#include <string.h>
+#include "glapi.h"
+#ifdef GLX_DIRECT_RENDERING
+#include "indirect_init.h"
+#include <X11/extensions/xf86vmode.h>
+#include "xf86dri.h"
+#endif
+#include "glxextensions.h"
+#include "glcontextmodes.h"
+#include "glheader.h"
+#include <sys/time.h>
+
+static const char __glXGLXClientVendorName[] = "SGI";
+static const char __glXGLXClientVersion[] = "1.4";
+
+
+/****************************************************************************/
+/**
+ * Get the __DRIdrawable for the drawable associated with a GLXContext
+ * 
+ * \param dpy       The display associated with \c drawable.
+ * \param drawable  GLXDrawable whose __DRIdrawable part is to be retrieved.
+ * \returns  A pointer to the context's __DRIdrawable on success, or NULL if
+ *           the drawable is not associated with a direct-rendering context.
+ */
+
+#ifdef GLX_DIRECT_RENDERING
+static __DRIdrawable *
+GetDRIDrawable( Display *dpy, GLXDrawable drawable, int * const scrn_num )
+{
+    __GLXdisplayPrivate * const priv = __glXInitialize(dpy);
+
+    if ( (priv != NULL) && (priv->driDisplay.private != NULL) ) {
+	const unsigned  screen_count = ScreenCount(dpy);
+	unsigned   i;
+
+	for ( i = 0 ; i < screen_count ; i++ ) {
+	    __DRIscreen * const psc = &priv->screenConfigs[i].driScreen;
+	    __DRIdrawable * const pdraw = (psc->private != NULL)
+	       ? (*psc->getDrawable)(dpy, drawable, psc->private) : NULL;
+
+	    if ( pdraw != NULL ) {
+		if ( scrn_num != NULL ) {
+		    *scrn_num = i;
+		}
+		return pdraw;
+	    }
+	}
+    }
+
+    return NULL;
+}
+#endif
+
+
+/**
+ * Get the GLX per-screen data structure associated with a GLX context.
+ * 
+ * \param dpy   Display for which the GLX per-screen information is to be
+ *              retrieved.
+ * \param scrn  Screen on \c dpy for which the GLX per-screen information is
+ *              to be retrieved.
+ * \returns A pointer to the GLX per-screen data if \c dpy and \c scrn
+ *          specify a valid GLX screen, or NULL otherwise.
+ * 
+ * \todo Should this function validate that \c scrn is within the screen
+ *       number range for \c dpy?
+ */
+
+static __GLXscreenConfigs *
+GetGLXScreenConfigs(Display *dpy, int scrn)
+{
+    __GLXdisplayPrivate * const priv = __glXInitialize(dpy);
+
+    return (priv->screenConfigs != NULL) ? &priv->screenConfigs[scrn] : NULL;
+}
+
+
+static int
+GetGLXPrivScreenConfig( Display *dpy, int scrn, __GLXdisplayPrivate ** ppriv,
+			__GLXscreenConfigs ** ppsc )
+{
+    /* Initialize the extension, if needed .  This has the added value
+     * of initializing/allocating the display private 
+     */
+    
+    if ( dpy == NULL ) {
+	return GLX_NO_EXTENSION;
+    }
+
+    *ppriv = __glXInitialize(dpy);
+    if ( *ppriv == NULL ) {
+	return GLX_NO_EXTENSION;
+    }
+
+    /* Check screen number to see if its valid */
+    if ((scrn < 0) || (scrn >= ScreenCount(dpy))) {
+	return GLX_BAD_SCREEN;
+    }
+
+    /* Check to see if the GL is supported on this screen */
+    *ppsc = &((*ppriv)->screenConfigs[scrn]);
+    if ( (*ppsc)->configs == NULL ) {
+	/* No support for GL on this screen regardless of visual */
+	return GLX_BAD_VISUAL;
+    }
+
+    return Success;
+}
+
+
+/**
+ * Determine if a \c GLXFBConfig supplied by the application is valid.
+ *
+ * \param dpy     Application supplied \c Display pointer.
+ * \param config  Application supplied \c GLXFBConfig.
+ *
+ * \returns If the \c GLXFBConfig is valid, the a pointer to the matching
+ *          \c __GLcontextModes structure is returned.  Otherwise, \c NULL
+ *          is returned.
+ */
+static __GLcontextModes *
+ValidateGLXFBConfig( Display * dpy, GLXFBConfig config )
+{
+    __GLXdisplayPrivate * const priv = __glXInitialize(dpy);
+    const unsigned num_screens = ScreenCount(dpy);
+    unsigned   i;
+    const __GLcontextModes * modes;
+
+
+    if ( priv != NULL ) {
+	for ( i = 0 ; i < num_screens ; i++ ) {
+	    for ( modes = priv->screenConfigs[i].configs
+		  ; modes != NULL
+		  ; modes = modes->next ) {
+		if ( modes == (__GLcontextModes *) config ) {
+		    return (__GLcontextModes *) config;
+		}
+	    }
+	}
+    }
+
+    return NULL;
+}
+
+
+/**
+ * \todo It should be possible to move the allocate of \c client_state_private
+ * later in the function for direct-rendering contexts.  Direct-rendering
+ * contexts don't need to track client state, so they don't need that memory
+ * at all.
+ * 
+ * \todo Eliminate \c __glXInitVertexArrayState.  Replace it with a new
+ * function called \c __glXAllocateClientState that allocates the memory and
+ * does all the initialization (including the pixel pack / unpack).
+ */
+static
+GLXContext AllocateGLXContext( Display *dpy )
+{
+     GLXContext gc;
+     int bufSize;
+     CARD8 opcode;
+    __GLXattribute *state;
+
+    if (!dpy)
+        return NULL;
+
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode) {
+	return NULL;
+    }
+
+    /* Allocate our context record */
+    gc = (GLXContext) Xmalloc(sizeof(struct __GLXcontextRec));
+    if (!gc) {
+	/* Out of memory */
+	return NULL;
+    }
+    memset(gc, 0, sizeof(struct __GLXcontextRec));
+
+    state = Xmalloc(sizeof(struct __GLXattributeRec));
+    if (state == NULL) {
+	/* Out of memory */
+	Xfree(gc);
+	return NULL;
+    }
+    gc->client_state_private = state;
+    memset(gc->client_state_private, 0, sizeof(struct __GLXattributeRec));
+    state->NoDrawArraysProtocol = (getenv("LIBGL_NO_DRAWARRAYS") != NULL);
+
+    /*
+    ** Create a temporary buffer to hold GLX rendering commands.  The size
+    ** of the buffer is selected so that the maximum number of GLX rendering
+    ** commands can fit in a single X packet and still have room in the X
+    ** packet for the GLXRenderReq header.
+    */
+
+    bufSize = (XMaxRequestSize(dpy) * 4) - sz_xGLXRenderReq;
+    gc->buf = (GLubyte *) Xmalloc(bufSize);
+    if (!gc->buf) {
+	Xfree(gc->client_state_private);
+	Xfree(gc);
+	return NULL;
+    }
+    gc->bufSize = bufSize;
+
+    /* Fill in the new context */
+    gc->renderMode = GL_RENDER;
+
+    state->storePack.alignment = 4;
+    state->storeUnpack.alignment = 4;
+
+    gc->attributes.stackPointer = &gc->attributes.stack[0];
+
+    /*
+    ** PERFORMANCE NOTE: A mode dependent fill image can speed things up.
+    ** Other code uses the fastImageUnpack bit, but it is never set
+    ** to GL_TRUE.
+    */
+    gc->fastImageUnpack = GL_FALSE;
+    gc->fillImage = __glFillImage;
+    gc->isDirect = GL_FALSE;
+    gc->pc = gc->buf;
+    gc->bufEnd = gc->buf + bufSize;
+    if (__glXDebug) {
+	/*
+	** Set limit register so that there will be one command per packet
+	*/
+	gc->limit = gc->buf;
+    } else {
+	gc->limit = gc->buf + bufSize - __GLX_BUFFER_LIMIT_SIZE;
+    }
+    gc->createDpy = dpy;
+    gc->majorOpcode = opcode;
+
+    /*
+    ** Constrain the maximum drawing command size allowed to be
+    ** transfered using the X_GLXRender protocol request.  First
+    ** constrain by a software limit, then constrain by the protocl
+    ** limit.
+    */
+    if (bufSize > __GLX_RENDER_CMD_SIZE_LIMIT) {
+        bufSize = __GLX_RENDER_CMD_SIZE_LIMIT;
+    }
+    if (bufSize > __GLX_MAX_RENDER_CMD_SIZE) {
+        bufSize = __GLX_MAX_RENDER_CMD_SIZE;
+    }
+    gc->maxSmallRenderCommandSize = bufSize;
+    return gc;
+}
+
+
+/**
+ * Create a new context.  Exactly one of \c vis and \c fbconfig should be
+ * non-NULL.
+ * 
+ * \param use_glx_1_3  For FBConfigs, should GLX 1.3 protocol or
+ *                     SGIX_fbconfig protocol be used?
+ * \param renderType   For FBConfigs, what is the rendering type?
+ */
+
+static GLXContext
+CreateContext(Display *dpy, XVisualInfo *vis,
+	      const __GLcontextModes * const fbconfig,
+	      GLXContext shareList,
+	      Bool allowDirect, GLXContextID contextID,
+	      Bool use_glx_1_3, int renderType)
+{
+    GLXContext gc;
+
+    if ( dpy == NULL )
+       return NULL;
+
+    gc = AllocateGLXContext(dpy);
+    if (!gc)
+	return NULL;
+
+    if (None == contextID) {
+	if ( (vis == NULL) && (fbconfig == NULL) )
+	    return NULL;
+
+#ifdef GLX_DIRECT_RENDERING
+	if (allowDirect) {
+	    int screen = (fbconfig == NULL) ? vis->screen : fbconfig->screen;
+	    __GLXscreenConfigs * const psc = GetGLXScreenConfigs(dpy, screen);
+	    const __GLcontextModes * mode;
+
+	    /* The value of fbconfig cannot change because it is tested
+	     * later in the function.
+	     */
+	    if ( fbconfig == NULL ) {
+		/* FIXME: Is it possible for the __GLcontextModes structure
+		 * FIXME: to not be found?
+		 */
+		mode = _gl_context_modes_find_visual( psc->configs,
+						      vis->visualid );
+		assert( mode != NULL );
+		assert( mode->screen == screen );
+	    }
+	    else {
+		mode = fbconfig;
+	    }
+
+	    if (psc && psc->driScreen.private) {
+		void * const shared = (shareList != NULL)
+		    ? shareList->driContext.private : NULL;
+		gc->driContext.private = 
+		  (*psc->driScreen.createNewContext)( dpy, mode, renderType,
+						      shared,
+						      &gc->driContext );
+		if (gc->driContext.private) {
+		    gc->isDirect = GL_TRUE;
+		    gc->screen = mode->screen;
+		    gc->vid = mode->visualID;
+		    gc->fbconfigID = mode->fbconfigID;
+		    gc->driContext.mode = mode;
+		}
+	    }
+	}
+#endif
+
+	LockDisplay(dpy);
+	if ( fbconfig == NULL ) {
+	    xGLXCreateContextReq *req;
+
+	    /* Send the glXCreateContext request */
+	    GetReq(GLXCreateContext,req);
+	    req->reqType = gc->majorOpcode;
+	    req->glxCode = X_GLXCreateContext;
+	    req->context = gc->xid = XAllocID(dpy);
+	    req->visual = vis->visualid;
+	    req->screen = vis->screen;
+	    req->shareList = shareList ? shareList->xid : None;
+	    req->isDirect = gc->isDirect;
+	}
+	else if ( use_glx_1_3 ) {
+	    xGLXCreateNewContextReq *req;
+
+	    /* Send the glXCreateNewContext request */
+	    GetReq(GLXCreateNewContext,req);
+	    req->reqType = gc->majorOpcode;
+	    req->glxCode = X_GLXCreateNewContext;
+	    req->context = gc->xid = XAllocID(dpy);
+	    req->fbconfig = fbconfig->fbconfigID;
+	    req->screen = fbconfig->screen;
+	    req->renderType = renderType;
+	    req->shareList = shareList ? shareList->xid : None;
+	    req->isDirect = gc->isDirect;
+	}
+	else {
+	    xGLXVendorPrivateWithReplyReq *vpreq;
+	    xGLXCreateContextWithConfigSGIXReq *req;
+
+	    /* Send the glXCreateNewContext request */
+	    GetReqExtra(GLXVendorPrivateWithReply,
+			sz_xGLXCreateContextWithConfigSGIXReq-sz_xGLXVendorPrivateWithReplyReq,vpreq);
+	    req = (xGLXCreateContextWithConfigSGIXReq *)vpreq;
+	    req->reqType = gc->majorOpcode;
+	    req->glxCode = X_GLXVendorPrivateWithReply;
+	    req->vendorCode = X_GLXvop_CreateContextWithConfigSGIX;
+	    req->context = gc->xid = XAllocID(dpy);
+	    req->fbconfig = fbconfig->fbconfigID;
+	    req->screen = fbconfig->screen;
+	    req->renderType = renderType;
+	    req->shareList = shareList ? shareList->xid : None;
+	    req->isDirect = gc->isDirect;
+	}
+
+	UnlockDisplay(dpy);
+	SyncHandle();
+	gc->imported = GL_FALSE;
+    }
+    else {
+	gc->xid = contextID;
+	gc->imported = GL_TRUE;
+    }
+
+    return gc;
+}
+
+PUBLIC GLXContext glXCreateContext(Display *dpy, XVisualInfo *vis,
+				   GLXContext shareList, Bool allowDirect)
+{
+   return CreateContext(dpy, vis, NULL, shareList, allowDirect, None,
+			False, 0);
+}
+
+void __glXFreeContext(__GLXcontext *gc)
+{
+    if (gc->vendor) XFree((char *) gc->vendor);
+    if (gc->renderer) XFree((char *) gc->renderer);
+    if (gc->version) XFree((char *) gc->version);
+    if (gc->extensions) XFree((char *) gc->extensions);
+    __glFreeAttributeState(gc);
+    XFree((char *) gc->buf);
+    Xfree((char *) gc->client_state_private);
+    XFree((char *) gc);
+    
+}
+
+/*
+** Destroy the named context
+*/
+static void 
+DestroyContext(Display *dpy, GLXContext gc)
+{
+    xGLXDestroyContextReq *req;
+    GLXContextID xid;
+    CARD8 opcode;
+    GLboolean imported;
+
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode || !gc) {
+	return;
+    }
+
+    __glXLock();
+    xid = gc->xid;
+    imported = gc->imported;
+    gc->xid = None;
+
+#ifdef GLX_DIRECT_RENDERING
+    /* Destroy the direct rendering context */
+    if (gc->isDirect) {
+	if (gc->driContext.private) {
+	    (*gc->driContext.destroyContext)(dpy, gc->screen,
+					     gc->driContext.private);
+	    gc->driContext.private = NULL;
+	}
+    }
+#endif
+
+    if (gc->currentDpy) {
+	/* Have to free later cuz it's in use now */
+	__glXUnlock();
+    } else {
+	/* Destroy the handle if not current to anybody */
+	__glXUnlock();
+	__glXFreeContext(gc);
+    }
+
+    if (!imported) {
+	/* 
+	** This dpy also created the server side part of the context.
+	** Send the glXDestroyContext request.
+	*/
+	LockDisplay(dpy);
+	GetReq(GLXDestroyContext,req);
+	req->reqType = opcode;
+	req->glxCode = X_GLXDestroyContext;
+	req->context = xid;
+	UnlockDisplay(dpy);
+	SyncHandle();
+    }
+}
+
+PUBLIC void glXDestroyContext(Display *dpy, GLXContext gc)
+{
+    DestroyContext(dpy, gc);
+}
+
+/*
+** Return the major and minor version #s for the GLX extension
+*/
+PUBLIC Bool glXQueryVersion(Display *dpy, int *major, int *minor)
+{
+    __GLXdisplayPrivate *priv;
+
+    /* Init the extension.  This fetches the major and minor version. */
+    priv = __glXInitialize(dpy);
+    if (!priv) return GL_FALSE;
+
+    if (major) *major = priv->majorVersion;
+    if (minor) *minor = priv->minorVersion;
+    return GL_TRUE;
+}
+
+/*
+** Query the existance of the GLX extension
+*/
+PUBLIC Bool glXQueryExtension(Display *dpy, int *errorBase, int *eventBase)
+{
+    int major_op, erb, evb;
+    Bool rv;
+
+    rv = XQueryExtension(dpy, GLX_EXTENSION_NAME, &major_op, &evb, &erb);
+    if (rv) {
+	if (errorBase) *errorBase = erb;
+	if (eventBase) *eventBase = evb;
+    }
+    return rv;
+}
+
+/*
+** Put a barrier in the token stream that forces the GL to finish its
+** work before X can proceed.
+*/
+PUBLIC void glXWaitGL(void)
+{
+    xGLXWaitGLReq *req;
+    GLXContext gc = __glXGetCurrentContext();
+    Display *dpy = gc->currentDpy;
+
+    if (!dpy) return;
+
+    /* Flush any pending commands out */
+    __glXFlushRenderBuffer(gc, gc->pc);
+
+#ifdef GLX_DIRECT_RENDERING
+    if (gc->isDirect) {
+/* This bit of ugliness unwraps the glFinish function */
+#ifdef glFinish
+#undef glFinish
+#endif
+	glFinish();
+	return;
+    }
+#endif
+
+    /* Send the glXWaitGL request */
+    LockDisplay(dpy);
+    GetReq(GLXWaitGL,req);
+    req->reqType = gc->majorOpcode;
+    req->glxCode = X_GLXWaitGL;
+    req->contextTag = gc->currentContextTag;
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+/*
+** Put a barrier in the token stream that forces X to finish its
+** work before GL can proceed.
+*/
+PUBLIC void glXWaitX(void)
+{
+    xGLXWaitXReq *req;
+    GLXContext gc = __glXGetCurrentContext();
+    Display *dpy = gc->currentDpy;
+
+    if (!dpy) return;
+
+    /* Flush any pending commands out */
+    __glXFlushRenderBuffer(gc, gc->pc);
+
+#ifdef GLX_DIRECT_RENDERING
+    if (gc->isDirect) {
+	XSync(dpy, False);
+	return;
+    }
+#endif
+
+    /*
+    ** Send the glXWaitX request.
+    */
+    LockDisplay(dpy);
+    GetReq(GLXWaitX,req);
+    req->reqType = gc->majorOpcode;
+    req->glxCode = X_GLXWaitX;
+    req->contextTag = gc->currentContextTag;
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+PUBLIC void glXUseXFont(Font font, int first, int count, int listBase)
+{
+    xGLXUseXFontReq *req;
+    GLXContext gc = __glXGetCurrentContext();
+    Display *dpy = gc->currentDpy;
+
+    if (!dpy) return;
+
+    /* Flush any pending commands out */
+    (void) __glXFlushRenderBuffer(gc, gc->pc);
+
+#ifdef GLX_DIRECT_RENDERING
+    if (gc->isDirect) {
+      DRI_glXUseXFont(font, first, count, listBase);
+      return;
+    }
+#endif
+
+    /* Send the glXUseFont request */
+    LockDisplay(dpy);
+    GetReq(GLXUseXFont,req);
+    req->reqType = gc->majorOpcode;
+    req->glxCode = X_GLXUseXFont;
+    req->contextTag = gc->currentContextTag;
+    req->font = font;
+    req->first = first;
+    req->count = count;
+    req->listBase = listBase;
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+/************************************************************************/
+
+/*
+** Copy the source context to the destination context using the
+** attribute "mask".
+*/
+PUBLIC void glXCopyContext(Display *dpy, GLXContext source,
+			   GLXContext dest, unsigned long mask)
+{
+    xGLXCopyContextReq *req;
+    GLXContext gc = __glXGetCurrentContext();
+    GLXContextTag tag;
+    CARD8 opcode;
+
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode) {
+	return;
+    }
+
+#ifdef GLX_DIRECT_RENDERING
+    if (gc->isDirect) {
+	/* NOT_DONE: This does not work yet */
+    }
+#endif
+
+    /*
+    ** If the source is the current context, send its tag so that the context
+    ** can be flushed before the copy.
+    */
+    if (source == gc && dpy == gc->currentDpy) {
+	tag = gc->currentContextTag;
+    } else {
+	tag = 0;
+    }
+
+    /* Send the glXCopyContext request */
+    LockDisplay(dpy);
+    GetReq(GLXCopyContext,req);
+    req->reqType = opcode;
+    req->glxCode = X_GLXCopyContext;
+    req->source = source ? source->xid : None;
+    req->dest = dest ? dest->xid : None;
+    req->mask = mask;
+    req->contextTag = tag;
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+
+/**
+ * Determine if a context uses direct rendering.
+ *
+ * \param dpy        Display where the context was created.
+ * \param contextID  ID of the context to be tested.
+ *
+ * \returns \c GL_TRUE if the context is direct rendering or not.
+ */
+static Bool __glXIsDirect(Display *dpy, GLXContextID contextID)
+{
+    xGLXIsDirectReq *req;
+    xGLXIsDirectReply reply;
+    CARD8 opcode;
+
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode) {
+	return GL_FALSE;
+    }
+
+    /* Send the glXIsDirect request */
+    LockDisplay(dpy);
+    GetReq(GLXIsDirect,req);
+    req->reqType = opcode;
+    req->glxCode = X_GLXIsDirect;
+    req->context = contextID;
+    _XReply(dpy, (xReply*) &reply, 0, False);
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+    return reply.isDirect;
+}
+
+/**
+ * \todo
+ * Shouldn't this function \b always return \c GL_FALSE when
+ * \c GLX_DIRECT_RENDERING is not defined?  Do we really need to bother with
+ * the GLX protocol here at all?
+ */
+PUBLIC Bool glXIsDirect(Display *dpy, GLXContext gc)
+{
+    if (!gc) {
+	return GL_FALSE;
+#ifdef GLX_DIRECT_RENDERING
+    } else if (gc->isDirect) {
+	return GL_TRUE;
+#endif
+    }
+    return __glXIsDirect(dpy, gc->xid);
+}
+
+PUBLIC GLXPixmap glXCreateGLXPixmap(Display *dpy, XVisualInfo *vis, 
+				    Pixmap pixmap)
+{
+    xGLXCreateGLXPixmapReq *req;
+    GLXPixmap xid;
+    CARD8 opcode;
+
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode) {
+	return None;
+    }
+
+    /* Send the glXCreateGLXPixmap request */
+    LockDisplay(dpy);
+    GetReq(GLXCreateGLXPixmap,req);
+    req->reqType = opcode;
+    req->glxCode = X_GLXCreateGLXPixmap;
+    req->screen = vis->screen;
+    req->visual = vis->visualid;
+    req->pixmap = pixmap;
+    req->glxpixmap = xid = XAllocID(dpy);
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return xid;
+}
+
+/*
+** Destroy the named pixmap
+*/
+PUBLIC void glXDestroyGLXPixmap(Display *dpy, GLXPixmap glxpixmap)
+{
+    xGLXDestroyGLXPixmapReq *req;
+    CARD8 opcode;
+
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode) {
+	return;
+    }
+    
+    /* Send the glXDestroyGLXPixmap request */
+    LockDisplay(dpy);
+    GetReq(GLXDestroyGLXPixmap,req);
+    req->reqType = opcode;
+    req->glxCode = X_GLXDestroyGLXPixmap;
+    req->glxpixmap = glxpixmap;
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+PUBLIC void glXSwapBuffers(Display *dpy, GLXDrawable drawable)
+{
+    xGLXSwapBuffersReq *req;
+    GLXContext gc;
+    GLXContextTag tag;
+    CARD8 opcode;
+#ifdef GLX_DIRECT_RENDERING
+    __DRIdrawable *pdraw = GetDRIDrawable( dpy, drawable, NULL );
+
+    if ( pdraw != NULL ) {
+	(*pdraw->swapBuffers)(dpy, pdraw->private);
+	return;
+    }
+#endif
+
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode) {
+	return;
+    }
+
+    /*
+    ** The calling thread may or may not have a current context.  If it
+    ** does, send the context tag so the server can do a flush.
+    */
+    gc = __glXGetCurrentContext();
+    if ((gc != NULL) && (dpy == gc->currentDpy) && 
+ 	((drawable == gc->currentDrawable) || (drawable == gc->currentReadable)) ) {
+	tag = gc->currentContextTag;
+    } else {
+	tag = 0;
+    }
+
+    /* Send the glXSwapBuffers request */
+    LockDisplay(dpy);
+    GetReq(GLXSwapBuffers,req);
+    req->reqType = opcode;
+    req->glxCode = X_GLXSwapBuffers;
+    req->drawable = drawable;
+    req->contextTag = tag;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    XFlush(dpy);
+}
+
+
+/*
+** Return configuration information for the given display, screen and
+** visual combination.
+*/
+PUBLIC int glXGetConfig(Display *dpy, XVisualInfo *vis, int attribute,
+			int *value_return)
+{
+    __GLXdisplayPrivate *priv;
+    __GLXscreenConfigs *psc;
+    int   status;
+
+    status = GetGLXPrivScreenConfig( dpy, vis->screen, & priv, & psc );
+    if ( status == Success ) {
+	const __GLcontextModes * const modes = _gl_context_modes_find_visual(
+					     psc->configs, vis->visualid );
+
+	/* Lookup attribute after first finding a match on the visual */
+	if ( modes != NULL ) {
+	    return _gl_get_context_mode_data( modes, attribute, value_return );
+	}
+	
+	status = GLX_BAD_VISUAL;
+    }
+
+    /*
+    ** If we can't find the config for this visual, this visual is not
+    ** supported by the OpenGL implementation on the server.
+    */
+    if ( (status == GLX_BAD_VISUAL) && (attribute == GLX_USE_GL) ) {
+	*value_return = GL_FALSE;
+	status = Success;
+    }
+
+    return status;
+}
+
+/************************************************************************/
+
+static void
+init_fbconfig_for_chooser( __GLcontextModes * config,
+			   GLboolean fbconfig_style_tags )
+{
+    memset( config, 0, sizeof( __GLcontextModes ) );
+    config->visualID = (XID) GLX_DONT_CARE;
+    config->visualType = GLX_DONT_CARE;
+
+    /* glXChooseFBConfig specifies different defaults for these two than
+     * glXChooseVisual.
+     */
+    if ( fbconfig_style_tags ) {
+	config->rgbMode = GL_TRUE;
+	config->doubleBufferMode = GLX_DONT_CARE;
+    }
+
+    config->visualRating = GLX_DONT_CARE;
+    config->transparentPixel = GLX_NONE;
+    config->transparentRed = GLX_DONT_CARE;
+    config->transparentGreen = GLX_DONT_CARE;
+    config->transparentBlue = GLX_DONT_CARE;
+    config->transparentAlpha = GLX_DONT_CARE;
+    config->transparentIndex = GLX_DONT_CARE;
+
+    config->drawableType = GLX_WINDOW_BIT;
+    config->renderType = (config->rgbMode) ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
+    config->xRenderable = GLX_DONT_CARE;
+    config->fbconfigID = (GLXFBConfigID)(GLX_DONT_CARE);
+
+    config->swapMethod = GLX_DONT_CARE;
+}
+
+#define MATCH_DONT_CARE( param ) \
+	do { \
+	    if ( (a-> param != GLX_DONT_CARE) \
+		 && (a-> param != b-> param) ) { \
+		return False; \
+	    } \
+	} while ( 0 )
+
+#define MATCH_MINIMUM( param ) \
+	do { \
+	    if ( (a-> param != GLX_DONT_CARE) \
+		 && (a-> param > b-> param) ) { \
+		return False; \
+	    } \
+	} while ( 0 )
+
+#define MATCH_EXACT( param ) \
+	do { \
+	    if ( a-> param != b-> param) { \
+		return False; \
+	    } \
+	} while ( 0 )
+
+/**
+ * Determine if two GLXFBConfigs are compatible.
+ *
+ * \param a  Application specified config to test.
+ * \param b  Server specified config to test against \c a.
+ */
+static Bool
+fbconfigs_compatible( const __GLcontextModes * const a,
+		      const __GLcontextModes * const b )
+{
+    MATCH_DONT_CARE( doubleBufferMode );
+    MATCH_DONT_CARE( visualType );
+    MATCH_DONT_CARE( visualRating );
+    MATCH_DONT_CARE( xRenderable );
+    MATCH_DONT_CARE( fbconfigID );
+    MATCH_DONT_CARE( swapMethod );
+
+    MATCH_MINIMUM( rgbBits );
+    MATCH_MINIMUM( numAuxBuffers );
+    MATCH_MINIMUM( redBits );
+    MATCH_MINIMUM( greenBits );
+    MATCH_MINIMUM( blueBits );
+    MATCH_MINIMUM( alphaBits );
+    MATCH_MINIMUM( depthBits );
+    MATCH_MINIMUM( stencilBits );
+    MATCH_MINIMUM( accumRedBits );
+    MATCH_MINIMUM( accumGreenBits );
+    MATCH_MINIMUM( accumBlueBits );
+    MATCH_MINIMUM( accumAlphaBits );
+    MATCH_MINIMUM( sampleBuffers );
+    MATCH_MINIMUM( maxPbufferWidth );
+    MATCH_MINIMUM( maxPbufferHeight );
+    MATCH_MINIMUM( maxPbufferPixels );
+    MATCH_MINIMUM( samples );
+
+    MATCH_DONT_CARE( stereoMode );
+    MATCH_EXACT( level );
+
+    if ( ((a->drawableType & b->drawableType) == 0)
+	 || ((a->renderType & b->renderType) == 0) ) {
+	return False;
+    }
+
+
+    /* There is a bug in a few of the XFree86 DDX drivers.  They contain
+     * visuals with a "transparent type" of 0 when they really mean GLX_NONE.
+     * Technically speaking, it is a bug in the DDX driver, but there is
+     * enough of an installed base to work around the problem here.  In any
+     * case, 0 is not a valid value of the transparent type, so we'll treat 0 
+     * from the app as GLX_DONT_CARE. We'll consider GLX_NONE from the app and
+     * 0 from the server to be a match to maintain backward compatibility with
+     * the (broken) drivers.
+     */
+
+    if ( a->transparentPixel != GLX_DONT_CARE
+         && a->transparentPixel != 0 ) {
+        if ( a->transparentPixel == GLX_NONE ) {
+            if ( b->transparentPixel != GLX_NONE && b->transparentPixel != 0 )
+                return False;
+        } else {
+            MATCH_EXACT( transparentPixel );
+        }
+
+	switch ( a->transparentPixel ) {
+	  case GLX_TRANSPARENT_RGB:
+	    MATCH_DONT_CARE( transparentRed );
+	    MATCH_DONT_CARE( transparentGreen );
+	    MATCH_DONT_CARE( transparentBlue );
+	    MATCH_DONT_CARE( transparentAlpha );
+	    break;
+
+	  case GLX_TRANSPARENT_INDEX:
+	    MATCH_DONT_CARE( transparentIndex );
+	    break;
+
+	  default:
+	    break;
+	}
+    }
+
+    return True;
+}
+
+
+/* There's some trickly language in the GLX spec about how this is supposed
+ * to work.  Basically, if a given component size is either not specified
+ * or the requested size is zero, it is supposed to act like PERFER_SMALLER.
+ * Well, that's really hard to do with the code as-is.  This behavior is
+ * closer to correct, but still not technically right.
+ */
+#define PREFER_LARGER_OR_ZERO(comp) \
+    do { \
+	if ( ((*a)-> comp) != ((*b)-> comp) ) { \
+	    if ( ((*a)-> comp) == 0 ) { \
+		return -1; \
+	    } \
+	    else if ( ((*b)-> comp) == 0 ) { \
+		return 1; \
+	    } \
+	    else { \
+		return ((*b)-> comp) - ((*a)-> comp) ; \
+	    } \
+	} \
+    } while( 0 )
+
+#define PREFER_LARGER(comp) \
+    do { \
+	if ( ((*a)-> comp) != ((*b)-> comp) ) { \
+	    return ((*b)-> comp) - ((*a)-> comp) ; \
+	} \
+    } while( 0 )
+
+#define PREFER_SMALLER(comp) \
+    do { \
+	if ( ((*a)-> comp) != ((*b)-> comp) ) { \
+	    return ((*a)-> comp) - ((*b)-> comp) ; \
+	} \
+    } while( 0 )
+
+/**
+ * Compare two GLXFBConfigs.  This function is intended to be used as the
+ * compare function passed in to qsort.
+ * 
+ * \returns If \c a is a "better" config, according to the specification of
+ *          SGIX_fbconfig, a number less than zero is returned.  If \c b is
+ *          better, then a number greater than zero is return.  If both are
+ *          equal, zero is returned.
+ * \sa qsort, glXChooseVisual, glXChooseFBConfig, glXChooseFBConfigSGIX
+ */
+static int
+fbconfig_compare( const __GLcontextModes * const * const a,
+		  const __GLcontextModes * const * const b )
+{
+    /* The order of these comparisons must NOT change.  It is defined by
+     * the GLX 1.3 spec and ARB_multisample.
+     */
+
+    PREFER_SMALLER( visualSelectGroup );
+
+    /* The sort order for the visualRating is GLX_NONE, GLX_SLOW, and
+     * GLX_NON_CONFORMANT_CONFIG.  It just so happens that this is the
+     * numerical sort order of the enums (0x8000, 0x8001, and 0x800D).
+     */
+    PREFER_SMALLER( visualRating );
+
+    /* This isn't quite right.  It is supposed to compare the sum of the
+     * components the user specifically set minimums for.
+     */
+    PREFER_LARGER_OR_ZERO( redBits );
+    PREFER_LARGER_OR_ZERO( greenBits );
+    PREFER_LARGER_OR_ZERO( blueBits );
+    PREFER_LARGER_OR_ZERO( alphaBits );
+
+    PREFER_SMALLER( rgbBits );
+
+    if ( ((*a)->doubleBufferMode != (*b)->doubleBufferMode) ) {
+	/* Prefer single-buffer.
+	 */
+	return ( !(*a)->doubleBufferMode ) ? -1 : 1;
+    }
+
+    PREFER_SMALLER( numAuxBuffers );
+
+    PREFER_LARGER_OR_ZERO( depthBits );
+    PREFER_SMALLER( stencilBits );
+
+    /* This isn't quite right.  It is supposed to compare the sum of the
+     * components the user specifically set minimums for.
+     */
+    PREFER_LARGER_OR_ZERO( accumRedBits );
+    PREFER_LARGER_OR_ZERO( accumGreenBits );
+    PREFER_LARGER_OR_ZERO( accumBlueBits );
+    PREFER_LARGER_OR_ZERO( accumAlphaBits );
+
+    PREFER_SMALLER( visualType );
+
+    /* None of the multisample specs say where this comparison should happen,
+     * so I put it near the end.
+     */
+    PREFER_SMALLER( sampleBuffers );
+    PREFER_SMALLER( samples );
+
+    /* None of the pbuffer or fbconfig specs say that this comparison needs
+     * to happen at all, but it seems like it should.
+     */
+    PREFER_LARGER( maxPbufferWidth );
+    PREFER_LARGER( maxPbufferHeight );
+    PREFER_LARGER( maxPbufferPixels );
+
+    return 0;
+}
+
+
+/**
+ * Selects and sorts a subset of the supplied configs based on the attributes.
+ * This function forms to basis of \c glXChooseVisual, \c glXChooseFBConfig,
+ * and \c glXChooseFBConfigSGIX.
+ * 
+ * \param configs   Array of pointers to possible configs.  The elements of
+ *                  this array that do not meet the criteria will be set to
+ *                  NULL.  The remaining elements will be sorted according to
+ *                  the various visual / FBConfig selection rules.
+ * \param num_configs  Number of elements in the \c configs array.
+ * \param attribList   Attributes used select from \c configs.  This array is
+ *                     terminated by a \c None tag.  The array can either take
+ *                     the form expected by \c glXChooseVisual (where boolean
+ *                     tags do not have a value) or by \c glXChooseFBConfig
+ *                     (where every tag has a value).
+ * \param fbconfig_style_tags  Selects whether \c attribList is in
+ *                             \c glXChooseVisual style or
+ *                             \c glXChooseFBConfig style.
+ * \returns The number of valid elements left in \c configs.
+ * 
+ * \sa glXChooseVisual, glXChooseFBConfig, glXChooseFBConfigSGIX
+ */
+static int
+choose_visual( __GLcontextModes ** configs, int num_configs,
+	       const int *attribList, GLboolean fbconfig_style_tags )
+{
+    __GLcontextModes    test_config;
+    int   base;
+    int   i;
+
+    /* This is a fairly direct implementation of the selection method
+     * described by GLX_SGIX_fbconfig.  Start by culling out all the
+     * configs that are not compatible with the selected parameter
+     * list.
+     */
+
+    init_fbconfig_for_chooser( & test_config, fbconfig_style_tags );
+    __glXInitializeVisualConfigFromTags( & test_config, 512,
+					 (const INT32 *) attribList,
+					 GL_TRUE, fbconfig_style_tags );
+
+    base = 0;
+    for ( i = 0 ; i < num_configs ; i++ ) {
+	if ( fbconfigs_compatible( & test_config, configs[i] ) ) {
+	    configs[ base ] = configs[ i ];
+	    base++;
+	}
+    }
+
+    if ( base == 0 ) {
+	return 0;
+    }
+ 
+    if ( base < num_configs ) {
+	(void) memset( & configs[ base ], 0, 
+		       sizeof( void * ) * (num_configs - base) );
+    }
+
+    /* After the incompatible configs are removed, the resulting
+     * list is sorted according to the rules set out in the various
+     * specifications.
+     */
+    
+    qsort( configs, base, sizeof( __GLcontextModes * ),
+	   (int (*)(const void*, const void*)) fbconfig_compare );
+    return base;
+}
+
+
+
+
+/*
+** Return the visual that best matches the template.  Return None if no
+** visual matches the template.
+*/
+PUBLIC XVisualInfo *glXChooseVisual(Display *dpy, int screen, int *attribList)
+{
+    XVisualInfo *visualList = NULL;
+    __GLXdisplayPrivate *priv;
+    __GLXscreenConfigs *psc;
+    __GLcontextModes  test_config;
+    __GLcontextModes *modes;
+    const __GLcontextModes *best_config = NULL;
+
+    /*
+    ** Get a list of all visuals, return if list is empty
+    */
+    if ( GetGLXPrivScreenConfig( dpy, screen, & priv, & psc ) != Success ) {
+	return None;
+    }
+   
+
+    /*
+    ** Build a template from the defaults and the attribute list
+    ** Free visual list and return if an unexpected token is encountered
+    */
+    init_fbconfig_for_chooser( & test_config, GL_FALSE );
+    __glXInitializeVisualConfigFromTags( & test_config, 512, 
+					 (const INT32 *) attribList,
+					 GL_TRUE, GL_FALSE );
+
+    /*
+    ** Eliminate visuals that don't meet minimum requirements
+    ** Compute a score for those that do
+    ** Remember which visual, if any, got the highest score
+    */
+    for ( modes = psc->configs ; modes != NULL ; modes = modes->next ) {
+	if ( fbconfigs_compatible( & test_config, modes )
+	     && ((best_config == NULL)
+		 || (fbconfig_compare( (const __GLcontextModes * const * const)&modes, &best_config ) < 0)) ) {
+	    best_config = modes;
+	}
+    }
+
+    /*
+    ** If no visual is acceptable, return None
+    ** Otherwise, create an XVisualInfo list with just the selected X visual
+    ** and return this.
+    */
+    if (best_config != NULL) {
+	XVisualInfo visualTemplate;
+	int  i;
+
+	visualTemplate.screen = screen;
+	visualTemplate.visualid = best_config->visualID;
+	visualList = XGetVisualInfo( dpy, VisualScreenMask|VisualIDMask,
+				     &visualTemplate, &i );
+    }
+
+    return visualList;
+}
+
+
+PUBLIC const char *glXQueryExtensionsString( Display *dpy, int screen )
+{
+    __GLXscreenConfigs *psc;
+    __GLXdisplayPrivate *priv;
+
+    if ( GetGLXPrivScreenConfig( dpy, screen, & priv, & psc ) != Success ) {
+	return NULL;
+    }
+
+    if (!psc->effectiveGLXexts) {
+        if (!psc->serverGLXexts) {
+	    psc->serverGLXexts = __glXGetStringFromServer(dpy, priv->majorOpcode,
+					  	   X_GLXQueryServerString,
+					  	   screen, GLX_EXTENSIONS);
+	}
+
+	__glXCalculateUsableExtensions(psc,
+#ifdef GLX_DIRECT_RENDERING
+				       (psc->driScreen.private != NULL),
+#else
+				       GL_FALSE,
+#endif
+				       priv->minorVersion);
+    }
+
+    return psc->effectiveGLXexts;
+}
+
+PUBLIC const char *glXGetClientString( Display *dpy, int name )
+{
+    switch(name) {
+	case GLX_VENDOR:
+	    return (__glXGLXClientVendorName);
+	case GLX_VERSION:
+	    return (__glXGLXClientVersion);
+	case GLX_EXTENSIONS:
+	    return (__glXGetClientExtensions());
+	default:
+	    return NULL;
+    }
+}
+
+PUBLIC const char *glXQueryServerString( Display *dpy, int screen, int name )
+{
+    __GLXscreenConfigs *psc;
+    __GLXdisplayPrivate *priv;
+    const char ** str;
+
+
+    if ( GetGLXPrivScreenConfig( dpy, screen, & priv, & psc ) != Success ) {
+	return NULL;
+    }
+
+    switch(name) {
+	case GLX_VENDOR:
+	    str = & priv->serverGLXvendor;
+	    break;
+	case GLX_VERSION:
+	    str = & priv->serverGLXversion;
+	    break;
+	case GLX_EXTENSIONS:
+	    str = & psc->serverGLXexts;
+	    break;
+	default:
+	    return NULL;
+    }
+
+    if ( *str == NULL ) {
+	*str = __glXGetStringFromServer(dpy, priv->majorOpcode,
+					X_GLXQueryServerString, screen, name);
+    }
+    
+    return *str;
+}
+
+void __glXClientInfo (  Display *dpy, int opcode  )
+{
+    xGLXClientInfoReq *req;
+    int size;
+    char * ext_str = __glXGetClientGLExtensionString();
+
+    /* Send the glXClientInfo request */
+    LockDisplay(dpy);
+    GetReq(GLXClientInfo,req);
+    req->reqType = opcode;
+    req->glxCode = X_GLXClientInfo;
+    req->major = GLX_MAJOR_VERSION;
+    req->minor = GLX_MINOR_VERSION;
+
+    size = strlen( ext_str ) + 1;
+    req->length += (size + 3) >> 2;
+    req->numbytes = size;
+    Data(dpy, ext_str, size);
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    
+    Xfree( ext_str );
+}
+
+
+/*
+** EXT_import_context
+*/
+
+PUBLIC Display *glXGetCurrentDisplay(void)
+{
+    GLXContext gc = __glXGetCurrentContext();
+    if (NULL == gc) return NULL;
+    return gc->currentDpy;
+}
+
+PUBLIC GLX_ALIAS(Display *, glXGetCurrentDisplayEXT, (void), (),
+	  glXGetCurrentDisplay)
+
+/**
+ * Used internally by libGL to send \c xGLXQueryContextinfoExtReq requests
+ * to the X-server.
+ * 
+ * \param dpy  Display where \c ctx was created.
+ * \param ctx  Context to query.
+ * \returns  \c Success on success.  \c GLX_BAD_CONTEXT if \c ctx is invalid,
+ *           or zero if the request failed due to internal problems (i.e.,
+ *           unable to allocate temporary memory, etc.)
+ * 
+ * \note
+ * This function dynamically determines whether to use the EXT_import_context
+ * version of the protocol or the GLX 1.3 version of the protocol.
+ */
+static int __glXQueryContextInfo(Display *dpy, GLXContext ctx)
+{
+    __GLXdisplayPrivate *priv = __glXInitialize(dpy);
+    xGLXQueryContextReply reply;
+    CARD8 opcode;
+    GLuint numValues;
+    int retval;
+
+    if (ctx == NULL) {
+	return GLX_BAD_CONTEXT;
+    }
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode) {
+	return 0;
+    }
+
+    /* Send the glXQueryContextInfoEXT request */
+    LockDisplay(dpy);
+
+    if ( (priv->majorVersion > 1) || (priv->minorVersion >= 3) ) {
+	xGLXQueryContextReq *req;
+
+	GetReq(GLXQueryContext, req);
+
+	req->reqType = opcode;
+	req->glxCode = X_GLXQueryContext;
+	req->context = (unsigned int)(ctx->xid);
+    }
+    else {
+	xGLXVendorPrivateReq *vpreq;
+	xGLXQueryContextInfoEXTReq *req;
+
+	GetReqExtra( GLXVendorPrivate,
+		     sz_xGLXQueryContextInfoEXTReq - sz_xGLXVendorPrivateReq,
+		     vpreq );
+	req = (xGLXQueryContextInfoEXTReq *)vpreq;
+	req->reqType = opcode;
+	req->glxCode = X_GLXVendorPrivateWithReply;
+	req->vendorCode = X_GLXvop_QueryContextInfoEXT;
+	req->context = (unsigned int)(ctx->xid);
+    }
+
+    _XReply(dpy, (xReply*) &reply, 0, False);
+
+    numValues = reply.n;
+    if (numValues == 0)
+	retval = Success;
+    else if (numValues > __GLX_MAX_CONTEXT_PROPS)
+	retval = 0;
+    else
+    {
+	int *propList, *pProp;
+	int nPropListBytes;
+	int i;
+
+	nPropListBytes = numValues << 3;
+	propList = (int *) Xmalloc(nPropListBytes);
+	if (NULL == propList) {
+	    retval = 0;
+	} else {
+	    _XRead(dpy, (char *)propList, nPropListBytes);
+	    pProp = propList;
+	    for (i=0; i < numValues; i++) {
+		switch (*pProp++) {
+		case GLX_SHARE_CONTEXT_EXT:
+		    ctx->share_xid = *pProp++;
+		    break;
+		case GLX_VISUAL_ID_EXT:
+		    ctx->vid = *pProp++;
+		    break;
+		case GLX_SCREEN:
+		    ctx->screen = *pProp++;
+		    break;
+		case GLX_FBCONFIG_ID:
+		    ctx->fbconfigID = *pProp++;
+		    break;
+		case GLX_RENDER_TYPE:
+		    ctx->renderType = *pProp++;
+		    break;
+		default:
+		    pProp++;
+		    continue;
+		}
+	    }
+	    Xfree((char *)propList);
+	    retval = Success;
+	}
+    }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return retval;
+}
+
+PUBLIC int
+glXQueryContext(Display *dpy, GLXContext ctx, int attribute, int *value)
+{
+    int retVal;
+
+    /* get the information from the server if we don't have it already */
+    if (!ctx->isDirect && (ctx->vid == None)) {
+	retVal = __glXQueryContextInfo(dpy, ctx);
+	if (Success != retVal) return retVal;
+    }
+    switch (attribute) {
+    case GLX_SHARE_CONTEXT_EXT:
+	*value = (int)(ctx->share_xid);
+	break;
+    case GLX_VISUAL_ID_EXT:
+	*value = (int)(ctx->vid);
+	break;
+    case GLX_SCREEN:
+	*value = (int)(ctx->screen);
+	break;
+    case GLX_FBCONFIG_ID:
+	*value = (int)(ctx->fbconfigID);
+	break;
+    case GLX_RENDER_TYPE:
+	*value = (int)(ctx->renderType);
+	break;
+    default:
+	return GLX_BAD_ATTRIBUTE;
+    }
+    return Success;
+}
+
+PUBLIC GLX_ALIAS( int, glXQueryContextInfoEXT,
+	   (Display *dpy, GLXContext ctx, int attribute, int *value),
+	   (dpy, ctx, attribute, value),
+	   glXQueryContext )
+
+PUBLIC GLXContextID glXGetContextIDEXT(const GLXContext ctx)
+{
+    return ctx->xid;
+}
+
+PUBLIC GLXContext glXImportContextEXT(Display *dpy, GLXContextID contextID)
+{
+    GLXContext ctx;
+
+    if (contextID == None) {
+	return NULL;
+    }
+    if (__glXIsDirect(dpy, contextID)) {
+	return NULL;
+    }
+
+    ctx = CreateContext(dpy, NULL, NULL, NULL, False, contextID, False, 0);
+    if (NULL != ctx) {
+	if (Success != __glXQueryContextInfo(dpy, ctx)) {
+	   return NULL;
+	}
+    }
+    return ctx;
+}
+
+PUBLIC void glXFreeContextEXT(Display *dpy, GLXContext ctx)
+{
+    DestroyContext(dpy, ctx);
+}
+
+
+
+/*
+ * GLX 1.3 functions - these are just stubs for now!
+ */
+
+PUBLIC GLXFBConfig *glXChooseFBConfig(Display *dpy, int screen,
+				      const int *attribList, int *nitems)
+{
+    __GLcontextModes ** config_list;
+    int   list_size;
+
+
+    config_list = (__GLcontextModes **) 
+	glXGetFBConfigs( dpy, screen, & list_size );
+
+    if ( (config_list != NULL) && (list_size > 0) && (attribList != NULL) ) {
+	list_size = choose_visual( config_list, list_size, attribList,
+				   GL_TRUE );
+	if ( list_size == 0 ) {
+	    XFree( config_list );
+	    config_list = NULL;
+	}
+    }
+
+    *nitems = list_size;
+    return (GLXFBConfig *) config_list;
+}
+
+
+PUBLIC GLXContext glXCreateNewContext(Display *dpy, GLXFBConfig config,
+				      int renderType, GLXContext shareList,
+				      Bool allowDirect)
+{
+    return CreateContext( dpy, NULL, (__GLcontextModes *) config, shareList,
+			  allowDirect, None, True, renderType );
+}
+
+
+PUBLIC GLXDrawable glXGetCurrentReadDrawable(void)
+{
+    GLXContext gc = __glXGetCurrentContext();
+    return gc->currentReadable;
+}
+
+
+PUBLIC GLXFBConfig *glXGetFBConfigs(Display *dpy, int screen, int *nelements)
+{
+    __GLXdisplayPrivate *priv = __glXInitialize(dpy);
+    __GLcontextModes ** config = NULL;
+    int   i;
+
+    if ( (priv->screenConfigs != NULL)
+	 && (screen >= 0) && (screen <= ScreenCount(dpy))
+	 && (priv->screenConfigs[screen].configs != NULL)
+	 && (priv->screenConfigs[screen].configs->fbconfigID != GLX_DONT_CARE) ) {
+	unsigned num_configs = 0;
+	__GLcontextModes * modes;
+
+
+	for ( modes = priv->screenConfigs[screen].configs
+	      ; modes != NULL
+	      ; modes = modes->next ) {
+	    if ( modes->fbconfigID != GLX_DONT_CARE ) {
+		num_configs++;
+	    }
+	}
+
+	config = (__GLcontextModes **) Xmalloc( sizeof(__GLcontextModes *)
+						* num_configs );
+	if ( config != NULL ) {
+	    *nelements = num_configs;
+	    i = 0;
+	    for ( modes = priv->screenConfigs[screen].configs
+		  ; modes != NULL
+		  ; modes = modes->next ) {
+		config[i] = modes;
+		i++;
+	    }
+	}
+    }
+    return (GLXFBConfig *) config;
+}
+
+
+PUBLIC int glXGetFBConfigAttrib(Display *dpy, GLXFBConfig config,
+				int attribute, int *value)
+{
+    __GLcontextModes * const modes = ValidateGLXFBConfig( dpy, config );
+
+    return (modes != NULL)
+	? _gl_get_context_mode_data( modes, attribute, value )
+	: GLXBadFBConfig;
+}
+
+
+PUBLIC XVisualInfo *glXGetVisualFromFBConfig(Display *dpy, GLXFBConfig config)
+{
+    XVisualInfo visualTemplate;
+    __GLcontextModes * fbconfig = (__GLcontextModes *) config;
+    int  count;
+
+    /*
+    ** Get a list of all visuals, return if list is empty
+    */
+    visualTemplate.visualid = fbconfig->visualID;
+    return XGetVisualInfo(dpy,VisualIDMask,&visualTemplate,&count);
+}
+
+
+/*
+** GLX_SGI_make_current_read
+*/
+
+PUBLIC GLX_ALIAS(GLXDrawable, glXGetCurrentReadDrawableSGI, (void), (),
+	  glXGetCurrentReadDrawable)
+
+
+/*
+** GLX_SGI_swap_control
+*/
+PUBLIC int glXSwapIntervalSGI(int interval)
+{
+   xGLXVendorPrivateReq *req;
+   GLXContext gc = __glXGetCurrentContext();
+   Display * dpy;
+   CARD32 * interval_ptr;
+   CARD8 opcode;
+
+   if ( gc == NULL ) {
+      return GLX_BAD_CONTEXT;
+   }
+   
+   if ( interval <= 0 ) {
+      return GLX_BAD_VALUE;
+   }
+
+#ifdef GLX_DIRECT_RENDERING
+   if ( gc->isDirect ) {
+       __GLXscreenConfigs * const psc = GetGLXScreenConfigs( gc->currentDpy,
+							     gc->screen );
+       __DRIdrawable * const pdraw = GetDRIDrawable( gc->currentDpy,
+						     gc->currentDrawable,
+						     NULL );
+       if ( __glXExtensionBitIsEnabled( psc, SGI_swap_control_bit )
+	    && (pdraw != NULL) ) {
+	   pdraw->swap_interval = interval;
+	   return 0;
+       }
+       else {
+	   return GLX_BAD_CONTEXT;
+       }
+   }
+#endif
+   dpy = gc->currentDpy;
+   opcode = __glXSetupForCommand(dpy);
+   if (!opcode) {
+      return 0;
+   }
+
+   /* Send the glXSwapIntervalSGI request */
+   LockDisplay(dpy);
+   GetReqExtra(GLXVendorPrivate,sizeof(CARD32),req);
+   req->reqType = opcode;
+   req->glxCode = X_GLXVendorPrivate;
+   req->vendorCode = X_GLXvop_SwapIntervalSGI;
+   req->contextTag = gc->currentContextTag;
+
+   interval_ptr = (CARD32 *) req + 1;
+   *interval_ptr = interval;
+
+   UnlockDisplay(dpy);
+   SyncHandle();
+   XFlush(dpy);
+
+   return 0;
+}
+
+
+/*
+** GLX_MESA_swap_control
+*/
+PUBLIC GLint glXSwapIntervalMESA(unsigned interval)
+{
+#ifdef GLX_DIRECT_RENDERING
+   GLXContext gc = __glXGetCurrentContext();
+
+   if ( interval < 0 ) {
+      return GLX_BAD_VALUE;
+   }
+
+   if ( (gc != NULL) && gc->isDirect ) {
+      __GLXscreenConfigs * const psc = GetGLXScreenConfigs( gc->currentDpy,
+							    gc->screen );
+      
+      if ( (psc != NULL) && (psc->driScreen.private != NULL)
+	   && __glXExtensionBitIsEnabled( psc, MESA_swap_control_bit ) ) {
+	 __DRIdrawable * const pdraw = 
+	     (*psc->driScreen.getDrawable)(gc->currentDpy,
+					   gc->currentDrawable,
+					   psc->driScreen.private);
+	 if ( pdraw != NULL ) {
+	    pdraw->swap_interval = interval;
+	    return 0;
+	 }
+      }
+   }
+#else
+   (void) interval;
+#endif
+
+   return GLX_BAD_CONTEXT;
+}
+ 
+PUBLIC GLint glXGetSwapIntervalMESA( void )
+{
+#ifdef GLX_DIRECT_RENDERING
+   GLXContext gc = __glXGetCurrentContext();
+
+   if ( (gc != NULL) && gc->isDirect ) {
+      __GLXscreenConfigs * const psc = GetGLXScreenConfigs( gc->currentDpy,
+							    gc->screen );
+      
+      if ( (psc != NULL) && (psc->driScreen.private != NULL)
+	   && __glXExtensionBitIsEnabled( psc, MESA_swap_control_bit ) ) {
+	 __DRIdrawable * const pdraw = 
+	     (*psc->driScreen.getDrawable)(gc->currentDpy,
+					   gc->currentDrawable,
+					   psc->driScreen.private);
+	 if ( pdraw != NULL ) {
+	    return pdraw->swap_interval;
+	 }
+      }
+   }
+#endif
+
+   return 0;
+}
+
+
+/*
+** GLX_MESA_swap_frame_usage
+*/
+
+PUBLIC GLint glXBeginFrameTrackingMESA(Display *dpy, GLXDrawable drawable)
+{
+   int   status = GLX_BAD_CONTEXT;
+#ifdef GLX_DIRECT_RENDERING
+   int screen;
+   __DRIdrawable * const pdraw = GetDRIDrawable(dpy, drawable, & screen);
+   __GLXscreenConfigs * const psc = GetGLXScreenConfigs(dpy, screen);
+
+   if ( (pdraw != NULL) && (pdraw->frameTracking != NULL)
+	&& __glXExtensionBitIsEnabled( psc, MESA_swap_frame_usage_bit ) ) {
+      status = pdraw->frameTracking( dpy, pdraw->private, GL_TRUE );
+   }
+#else
+   (void) dpy;
+   (void) drawable;
+#endif
+   return status;
+}
+
+    
+PUBLIC GLint glXEndFrameTrackingMESA(Display *dpy, GLXDrawable drawable)
+{
+   int   status = GLX_BAD_CONTEXT;
+#ifdef GLX_DIRECT_RENDERING
+   int screen;
+   __DRIdrawable * const pdraw = GetDRIDrawable(dpy, drawable, & screen);
+   __GLXscreenConfigs * const psc = GetGLXScreenConfigs(dpy, screen);
+
+   if ( (pdraw != NULL) && (pdraw->frameTracking != NULL)
+	&& __glXExtensionBitIsEnabled( psc, MESA_swap_frame_usage_bit ) ) {
+      status = pdraw->frameTracking( dpy, pdraw->private, GL_FALSE );
+   }
+#else
+   (void) dpy;
+   (void) drawable;
+#endif
+   return status;
+}
+
+
+PUBLIC GLint glXGetFrameUsageMESA(Display *dpy, GLXDrawable drawable,
+				  GLfloat *usage)
+{
+   int   status = GLX_BAD_CONTEXT;
+#ifdef GLX_DIRECT_RENDERING
+   int screen;
+   __DRIdrawable * const pdraw = GetDRIDrawable(dpy, drawable, & screen);
+   __GLXscreenConfigs * const psc = GetGLXScreenConfigs(dpy, screen);
+
+   if ( (pdraw != NULL ) && (pdraw->queryFrameTracking != NULL)
+	&& __glXExtensionBitIsEnabled( psc, MESA_swap_frame_usage_bit ) ) {
+      int64_t sbc, missedFrames;
+      float   lastMissedUsage;
+
+      status = pdraw->queryFrameTracking( dpy, pdraw->private, &sbc,
+					  &missedFrames, &lastMissedUsage,
+					  usage );
+   }
+#else
+   (void) dpy;
+   (void) drawable;
+   (void) usage;
+#endif
+   return status;
+}
+
+
+PUBLIC GLint glXQueryFrameTrackingMESA(Display *dpy, GLXDrawable drawable,
+				       int64_t *sbc, int64_t *missedFrames,
+				       GLfloat *lastMissedUsage)
+{
+   int   status = GLX_BAD_CONTEXT;
+#ifdef GLX_DIRECT_RENDERING
+   int screen;
+   __DRIdrawable * const pdraw = GetDRIDrawable(dpy, drawable, & screen);
+   __GLXscreenConfigs * const psc = GetGLXScreenConfigs(dpy, screen);
+
+   if ( (pdraw != NULL ) && (pdraw->queryFrameTracking != NULL)
+	&& __glXExtensionBitIsEnabled( psc, MESA_swap_frame_usage_bit ) ) {
+      float   usage;
+
+      status = pdraw->queryFrameTracking( dpy, pdraw->private, sbc,
+					  missedFrames, lastMissedUsage,
+					  & usage );
+   }
+#else
+   (void) dpy;
+   (void) drawable;
+   (void) sbc;
+   (void) missedFrames;
+   (void) lastMissedUsage;
+#endif
+   return status;
+}
+
+
+/*
+** GLX_SGI_video_sync
+*/
+PUBLIC int glXGetVideoSyncSGI(unsigned int *count)
+{
+   /* FIXME: Looking at the GLX_SGI_video_sync spec in the extension registry,
+    * FIXME: there should be a GLX encoding for this call.  I can find no
+    * FIXME: documentation for the GLX encoding.
+    */
+#ifdef GLX_DIRECT_RENDERING
+   GLXContext gc = __glXGetCurrentContext();
+
+
+   if ( (gc != NULL) && gc->isDirect ) {
+      __GLXscreenConfigs * const psc = GetGLXScreenConfigs( gc->currentDpy,
+							    gc->screen );
+      if ( __glXExtensionBitIsEnabled( psc, SGI_video_sync_bit )
+	   && psc->driScreen.private && psc->driScreen.getMSC) {
+	 int       ret;
+	 int64_t   temp;
+
+	 ret = psc->driScreen.getMSC( psc->driScreen.private, & temp );
+	 *count = (unsigned) temp;
+	 return (ret == 0) ? 0 : GLX_BAD_CONTEXT;
+      }
+   }
+#else
+    (void) count;
+#endif
+   return GLX_BAD_CONTEXT;
+}
+
+PUBLIC int glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count)
+{
+#ifdef GLX_DIRECT_RENDERING
+   GLXContext gc = __glXGetCurrentContext();
+
+   if ( divisor <= 0 || remainder < 0 )
+     return GLX_BAD_VALUE;
+
+   if ( (gc != NULL) && gc->isDirect ) {
+      __GLXscreenConfigs * const psc = GetGLXScreenConfigs( gc->currentDpy,
+							    gc->screen );
+      if ( __glXExtensionBitIsEnabled( psc, SGI_video_sync_bit )
+	   && psc->driScreen.private ) {
+	 __DRIdrawable * const pdraw = 
+	     (*psc->driScreen.getDrawable)(gc->currentDpy,
+					   gc->currentDrawable,
+					   psc->driScreen.private);
+	 if ( (pdraw != NULL) && (pdraw->waitForMSC != NULL) ) {
+	    int       ret;
+	    int64_t   msc;
+	    int64_t   sbc;
+
+	    ret = (*pdraw->waitForMSC)( gc->currentDpy, pdraw->private,
+					0, divisor, remainder,
+					& msc, & sbc );
+	    *count = (unsigned) msc;
+	    return (ret == 0) ? 0 : GLX_BAD_CONTEXT;
+	 }
+      }
+   }
+#else
+   (void) count;
+#endif
+   return GLX_BAD_CONTEXT;
+}
+
+
+/*
+** GLX_SGIS_video_source
+*/
+#if defined(_VL_H)
+
+PUBLIC GLXVideoSourceSGIX glXCreateGLXVideoSourceSGIX(Display *dpy,
+                                     int screen, VLServer server, VLPath path,
+                                     int nodeClass, VLNode drainNode)
+{
+   (void) dpy;
+   (void) screen;
+   (void) server;
+   (void) path;
+   (void) nodeClass;
+   (void) drainNode;
+   return 0;
+}
+
+PUBLIC void glXDestroyGLXVideoSourceSGIX(Display *dpy, GLXVideoSourceSGIX src)
+{
+   (void) dpy;
+   (void) src;
+}
+
+#endif
+
+
+/*
+** GLX_SGIX_fbconfig
+** Many of these functions are aliased to GLX 1.3 entry points in the 
+** GLX_functions table.
+*/
+
+PUBLIC GLX_ALIAS(int, glXGetFBConfigAttribSGIX,
+	  (Display *dpy, GLXFBConfigSGIX config, int attribute, int *value),
+	  (dpy, config, attribute, value),
+	  glXGetFBConfigAttrib)
+
+PUBLIC GLX_ALIAS(GLXFBConfigSGIX *, glXChooseFBConfigSGIX,
+	  (Display *dpy, int screen, int *attrib_list, int *nelements),
+	  (dpy, screen, attrib_list, nelements),
+	  glXChooseFBConfig)
+
+PUBLIC GLX_ALIAS(XVisualInfo *, glXGetVisualFromFBConfigSGIX,
+	  (Display * dpy, GLXFBConfigSGIX config),
+	  (dpy, config),
+	  glXGetVisualFromFBConfig)
+
+PUBLIC GLXPixmap glXCreateGLXPixmapWithConfigSGIX(Display *dpy,
+                            GLXFBConfigSGIX config, Pixmap pixmap)
+{
+    xGLXVendorPrivateWithReplyReq *vpreq;
+    xGLXCreateGLXPixmapWithConfigSGIXReq *req;
+    GLXPixmap xid = None;
+    CARD8 opcode;
+    const __GLcontextModes * const fbconfig = (__GLcontextModes *) config;
+    __GLXscreenConfigs * psc;
+
+
+    if ( (dpy == NULL) || (config == NULL) ) {
+	return None;
+    }
+
+    psc = GetGLXScreenConfigs( dpy, fbconfig->screen );
+    if ( (psc != NULL) 
+	 && __glXExtensionBitIsEnabled( psc, SGIX_fbconfig_bit ) ) {
+	opcode = __glXSetupForCommand(dpy);
+	if (!opcode) {
+	    return None;
+	}
+
+	/* Send the glXCreateGLXPixmapWithConfigSGIX request */
+	LockDisplay(dpy);
+	GetReqExtra(GLXVendorPrivateWithReply,
+		    sz_xGLXCreateGLXPixmapWithConfigSGIXReq-sz_xGLXVendorPrivateWithReplyReq,vpreq);
+	req = (xGLXCreateGLXPixmapWithConfigSGIXReq *)vpreq;
+	req->reqType = opcode;
+	req->glxCode = X_GLXVendorPrivateWithReply;
+	req->vendorCode = X_GLXvop_CreateGLXPixmapWithConfigSGIX;
+	req->screen = fbconfig->screen;
+	req->fbconfig = fbconfig->fbconfigID;
+	req->pixmap = pixmap;
+	req->glxpixmap = xid = XAllocID(dpy);
+	UnlockDisplay(dpy);
+	SyncHandle();
+    }
+
+    return xid;
+}
+
+PUBLIC GLXContext glXCreateContextWithConfigSGIX(Display *dpy,
+                             GLXFBConfigSGIX config, int renderType,
+                             GLXContext shareList, Bool allowDirect)
+{
+    GLXContext gc = NULL;
+    const __GLcontextModes * const fbconfig = (__GLcontextModes *) config;
+    __GLXscreenConfigs * psc;
+
+
+    if ( (dpy == NULL) || (config == NULL) ) {
+	return None;
+    }
+
+    psc = GetGLXScreenConfigs( dpy, fbconfig->screen );
+    if ( (psc != NULL) 
+	 && __glXExtensionBitIsEnabled( psc, SGIX_fbconfig_bit ) ) {
+	gc = CreateContext( dpy, NULL, (__GLcontextModes *) config, shareList,
+			    allowDirect, None, False, renderType );
+    }
+
+    return gc;
+}
+
+
+PUBLIC GLXFBConfigSGIX glXGetFBConfigFromVisualSGIX(Display *dpy,
+						    XVisualInfo *vis)
+{
+    __GLXdisplayPrivate *priv;
+    __GLXscreenConfigs *psc;
+
+    if ( (GetGLXPrivScreenConfig( dpy, vis->screen, & priv, & psc ) != Success)
+	 && __glXExtensionBitIsEnabled( psc, SGIX_fbconfig_bit )
+	 && (psc->configs->fbconfigID != GLX_DONT_CARE) ) {
+	return (GLXFBConfigSGIX) _gl_context_modes_find_visual( psc->configs,
+								vis->visualid );
+    }
+
+    return NULL;
+}
+
+
+/*
+** GLX_SGI_cushion
+*/
+PUBLIC void glXCushionSGI(Display *dpy, Window win, float cushion)
+{
+   (void) dpy;
+   (void) win;
+   (void) cushion;
+}
+
+
+/*
+** GLX_SGIX_video_resize
+*/
+PUBLIC int glXBindChannelToWindowSGIX(Display *dpy, int screen,
+				      int channel , Window window)
+{
+   (void) dpy;
+   (void) screen;
+   (void) channel;
+   (void) window;
+   return 0;
+}
+
+PUBLIC int glXChannelRectSGIX(Display *dpy, int screen, int channel,
+			      int x, int y, int w, int h)
+{
+   (void) dpy;
+   (void) screen;
+   (void) channel;
+   (void) x;
+   (void) y;
+   (void) w;
+   (void) h;
+   return 0;
+}
+
+PUBLIC int glXQueryChannelRectSGIX(Display *dpy, int screen, int channel,
+				   int *x, int *y, int *w, int *h)
+{
+   (void) dpy;
+   (void) screen;
+   (void) channel;
+   (void) x;
+   (void) y;
+   (void) w;
+   (void) h;
+   return 0;
+}
+
+int glXQueryChannelDeltasSGIX(Display *dpy, int screen, int channel,
+			      int *dx, int *dy, int *dw, int *dh)
+{
+   (void) dpy;
+   (void) screen;
+   (void) channel;
+   (void) dx;
+   (void) dy;
+   (void) dw;
+   (void) dh;
+   return 0;
+}
+
+PUBLIC int glXChannelRectSyncSGIX(Display *dpy, int screen,
+				  int channel, GLenum synctype)
+{
+   (void) dpy;
+   (void) screen;
+   (void) channel;
+   (void) synctype;
+   return 0;
+}
+
+
+#if defined(_DM_BUFFER_H_)
+
+PUBLIC Bool glXAssociateDMPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuffer,
+				      DMparams *params, DMbuffer dmbuffer)
+{
+   (void) dpy;
+   (void) pbuffer;
+   (void) params;
+   (void) dmbuffer;
+   return False;
+}
+
+#endif
+
+
+/*
+** GLX_SGIX_swap_group
+*/
+PUBLIC void glXJoinSwapGroupSGIX(Display *dpy, GLXDrawable drawable,
+				 GLXDrawable member)
+{
+   (void) dpy;
+   (void) drawable;
+   (void) member;
+}
+
+
+/*
+** GLX_SGIX_swap_barrier
+*/
+PUBLIC void glXBindSwapBarrierSGIX(Display *dpy, GLXDrawable drawable,
+				   int barrier)
+{
+   (void) dpy;
+   (void) drawable;
+   (void) barrier;
+}
+
+PUBLIC Bool glXQueryMaxSwapBarriersSGIX(Display *dpy, int screen, int *max)
+{
+   (void) dpy;
+   (void) screen;
+   (void) max;
+   return False;
+}
+
+
+/*
+** GLX_SUN_get_transparent_index
+*/
+PUBLIC Status glXGetTransparentIndexSUN(Display *dpy, Window overlay,
+					Window underlay, long *pTransparent)
+{
+   (void) dpy;
+   (void) overlay;
+   (void) underlay;
+   (void) pTransparent;
+   return 0;
+}
+
+
+/*
+** GLX_OML_sync_control
+*/
+PUBLIC Bool glXGetSyncValuesOML(Display *dpy, GLXDrawable drawable,
+				int64_t *ust, int64_t *msc, int64_t *sbc)
+{
+#ifdef GLX_DIRECT_RENDERING
+    __GLXdisplayPrivate * const priv = __glXInitialize(dpy);
+
+    if ( priv != NULL ) {
+	int   i;
+	__DRIdrawable * const pdraw = GetDRIDrawable( dpy, drawable, & i );
+	__GLXscreenConfigs * const psc = &priv->screenConfigs[i];
+
+	assert( (pdraw == NULL) || (i != -1) );
+	return ( (pdraw && pdraw->getSBC && psc->driScreen.getMSC)
+		 && __glXExtensionBitIsEnabled( psc, OML_sync_control_bit )
+		 && ((*psc->driScreen.getMSC)( psc->driScreen.private, msc ) == 0)
+		 && ((*pdraw->getSBC)( dpy, psc->driScreen.private, sbc ) == 0)
+		 && (__glXGetUST( ust ) == 0) );
+    }
+#else
+   (void) dpy;
+   (void) drawable;
+   (void) ust;
+   (void) msc;
+   (void) sbc;
+#endif
+   return False;
+}
+
+
+/**
+ * Determine the refresh rate of the specified drawable and display.
+ * 
+ * \param dpy          Display whose refresh rate is to be determined.
+ * \param drawable     Drawable whose refresh rate is to be determined.
+ * \param numerator    Numerator of the refresh rate.
+ * \param demoninator  Denominator of the refresh rate.
+ * \return  If the refresh rate for the specified display and drawable could
+ *          be calculated, True is returned.  Otherwise False is returned.
+ * 
+ * \note This function is implemented entirely client-side.  A lot of other
+ *       functionality is required to export GLX_OML_sync_control, so on
+ *       XFree86 this function can be called for direct-rendering contexts
+ *       when GLX_OML_sync_control appears in the client extension string.
+ */
+
+PUBLIC Bool glXGetMscRateOML(Display * dpy, GLXDrawable drawable,
+			     int32_t * numerator, int32_t * denominator)
+{
+#if defined( GLX_DIRECT_RENDERING ) && defined( XF86VIDMODE )
+   __GLXdisplayPrivate * const priv = __glXInitialize(dpy);
+
+
+   if ( priv != NULL ) {
+      XF86VidModeModeLine   mode_line;
+      int   dot_clock;
+      int   screen_num;
+      int   i;
+
+
+      GetDRIDrawable( dpy, drawable, & screen_num );
+      if ( (screen_num != -1)
+	   && XF86VidModeQueryVersion( dpy, & i, & i )
+	   && XF86VidModeGetModeLine( dpy, screen_num, & dot_clock,
+				      & mode_line ) ) {
+	 unsigned   n = dot_clock * 1000;
+	 unsigned   d = mode_line.vtotal * mode_line.htotal;
+
+# define V_INTERLACE 0x010
+# define V_DBLSCAN   0x020
+
+	 if ( (mode_line.flags & V_INTERLACE) ) {
+	    n *= 2;
+	 }
+	 else if ( (mode_line.flags & V_DBLSCAN) ) {
+	    d *= 2;
+	 }
+
+	 /* The OML_sync_control spec requires that if the refresh rate is a
+	  * whole number, that the returned numerator be equal to the refresh
+	  * rate and the denominator be 1.
+	  */
+
+	 if ( (n % d) == 0 ) {
+	    n /= d;
+	    d = 1;
+	 }
+	 else {
+	    static const unsigned f[] = { 13, 11, 7, 5, 3, 2, 0 };
+
+
+	    /* This is a poor man's way to reduce a fraction.  It's far from
+	     * perfect, but it will work well enough for this situation.
+	     */
+
+	    for ( i = 0 ; f[i] != 0 ; i++ ) {
+	       while ( ((n % f[i]) == 0) && ((d % f[i]) == 0) ) {
+		  d /= f[i];
+		  n /= f[i];
+	       }
+	    }
+	 }
+
+	 *numerator = n;
+	 *denominator = d;
+
+	 (void) drawable;
+	 return True;
+      }
+   }
+#else
+   (void) dpy;
+   (void) drawable;
+   (void) numerator;
+   (void) denominator;
+#endif
+   return False;
+}
+
+
+PUBLIC int64_t glXSwapBuffersMscOML(Display *dpy, GLXDrawable drawable,
+				    int64_t target_msc, int64_t divisor,
+				    int64_t remainder)
+{
+#ifdef GLX_DIRECT_RENDERING
+   int screen;
+   __DRIdrawable *pdraw = GetDRIDrawable( dpy, drawable, & screen );
+   __GLXscreenConfigs * const psc = GetGLXScreenConfigs( dpy, screen );
+
+   /* The OML_sync_control spec says these should "generate a GLX_BAD_VALUE
+    * error", but it also says "It [glXSwapBuffersMscOML] will return a value
+    * of -1 if the function failed because of errors detected in the input
+    * parameters"
+    */
+   if ( divisor < 0 || remainder < 0 || target_msc < 0 )
+      return -1;
+   if ( divisor > 0 && remainder >= divisor )
+      return -1;
+
+   if ( (pdraw != NULL) && (pdraw->swapBuffersMSC != NULL)
+       && __glXExtensionBitIsEnabled( psc, OML_sync_control_bit ) ) {
+      return (*pdraw->swapBuffersMSC)(dpy, pdraw->private, target_msc,
+				      divisor, remainder);
+   }
+#else
+   (void) dpy;
+   (void) drawable;
+   (void) target_msc;
+   (void) divisor;
+   (void) remainder;
+#endif
+   return 0;
+}
+
+
+PUBLIC Bool glXWaitForMscOML(Display * dpy, GLXDrawable drawable,
+			     int64_t target_msc, int64_t divisor,
+			     int64_t remainder, int64_t *ust,
+			     int64_t *msc, int64_t *sbc)
+{
+#ifdef GLX_DIRECT_RENDERING
+   int screen;
+   __DRIdrawable *pdraw = GetDRIDrawable( dpy, drawable, & screen );
+   __GLXscreenConfigs * const psc = GetGLXScreenConfigs( dpy, screen );
+   int  ret;
+
+   /* The OML_sync_control spec says these should "generate a GLX_BAD_VALUE
+    * error", but the return type in the spec is Bool.
+    */
+   if ( divisor < 0 || remainder < 0 || target_msc < 0 )
+      return False;
+   if ( divisor > 0 && remainder >= divisor )
+      return False;
+
+   if ( (pdraw != NULL) && (pdraw->waitForMSC != NULL)
+	&& __glXExtensionBitIsEnabled( psc, OML_sync_control_bit ) ) {
+      ret = (*pdraw->waitForMSC)( dpy, pdraw->private, target_msc,
+				  divisor, remainder, msc, sbc );
+
+      /* __glXGetUST returns zero on success and non-zero on failure.
+       * This function returns True on success and False on failure.
+       */
+      return ( (ret == 0) && (__glXGetUST( ust ) == 0) );
+   }
+#else
+   (void) dpy;
+   (void) drawable;
+   (void) target_msc;
+   (void) divisor;
+   (void) remainder;
+   (void) ust;
+   (void) msc;
+   (void) sbc;
+#endif
+   return False;
+}
+
+
+PUBLIC Bool glXWaitForSbcOML(Display * dpy, GLXDrawable drawable,
+			     int64_t target_sbc, int64_t *ust,
+			     int64_t *msc, int64_t *sbc )
+{
+#ifdef GLX_DIRECT_RENDERING
+   int screen;
+   __DRIdrawable *pdraw = GetDRIDrawable( dpy, drawable, & screen );
+   __GLXscreenConfigs * const psc = GetGLXScreenConfigs( dpy, screen );
+   int  ret;
+
+   /* The OML_sync_control spec says this should "generate a GLX_BAD_VALUE
+    * error", but the return type in the spec is Bool.
+    */
+   if ( target_sbc < 0 )
+      return False;
+
+   if ( (pdraw != NULL) && (pdraw->waitForSBC != NULL)
+	&& __glXExtensionBitIsEnabled( psc, OML_sync_control_bit )) {
+      ret = (*pdraw->waitForSBC)( dpy, pdraw->private, target_sbc, msc, sbc );
+
+      /* __glXGetUST returns zero on success and non-zero on failure.
+       * This function returns True on success and False on failure.
+       */
+      return( (ret == 0) && (__glXGetUST( ust ) == 0) );
+   }
+#else
+   (void) dpy;
+   (void) drawable;
+   (void) target_sbc;
+   (void) ust;
+   (void) msc;
+   (void) sbc;
+#endif
+   return False;
+}
+
+
+/**
+ * GLX_MESA_allocate_memory
+ */
+/*@{*/
+
+PUBLIC void *glXAllocateMemoryMESA(Display *dpy, int scrn,
+				   size_t size, float readFreq,
+				   float writeFreq, float priority)
+{
+#ifdef GLX_DIRECT_RENDERING
+   __GLXscreenConfigs * const psc = GetGLXScreenConfigs( dpy, scrn );
+
+   if ( __glXExtensionBitIsEnabled( psc, MESA_allocate_memory_bit ) ) {
+      if (psc && psc->driScreen.private && psc->driScreen.allocateMemory) {
+	 return (*psc->driScreen.allocateMemory)( dpy, scrn, size,
+						  readFreq, writeFreq,
+						  priority );
+      }
+   }
+#else
+   (void) dpy;
+   (void) scrn;
+   (void) size;
+   (void) readFreq;
+   (void) writeFreq;
+   (void) priority;
+#endif /* GLX_DIRECT_RENDERING */
+
+   return NULL;
+}
+
+
+PUBLIC void glXFreeMemoryMESA(Display *dpy, int scrn, void *pointer)
+{
+#ifdef GLX_DIRECT_RENDERING
+   __GLXscreenConfigs * const psc = GetGLXScreenConfigs( dpy, scrn );
+
+   if ( __glXExtensionBitIsEnabled( psc, MESA_allocate_memory_bit ) ) {
+      if (psc && psc->driScreen.private && psc->driScreen.freeMemory) {
+	 (*psc->driScreen.freeMemory)( dpy, scrn, pointer );
+      }
+   }
+#else
+   (void) dpy;
+   (void) scrn;
+   (void) pointer;
+#endif /* GLX_DIRECT_RENDERING */
+}
+
+
+PUBLIC GLuint glXGetMemoryOffsetMESA( Display *dpy, int scrn,
+				      const void *pointer )
+{
+#ifdef GLX_DIRECT_RENDERING
+   __GLXscreenConfigs * const psc = GetGLXScreenConfigs( dpy, scrn );
+
+   if ( __glXExtensionBitIsEnabled( psc, MESA_allocate_memory_bit ) ) {
+      if (psc && psc->driScreen.private && psc->driScreen.memoryOffset) {
+	 return (*psc->driScreen.memoryOffset)( dpy, scrn, pointer );
+      }
+   }
+#else
+   (void) dpy;
+   (void) scrn;
+   (void) pointer;
+#endif /* GLX_DIRECT_RENDERING */
+
+   return ~0L;
+}
+/*@}*/
+
+
+/**
+ * Mesa extension stubs.  These will help reduce portability problems.
+ */
+/*@{*/
+
+/**
+ * Release all buffers associated with the specified GLX drawable.
+ *
+ * \todo
+ * This function was intended for stand-alone Mesa.  The issue there is that
+ * the library doesn't get any notification when a window is closed.  In
+ * DRI there is a similar but slightly different issue.  When GLX 1.3 is
+ * supported, there are 3 different functions to destroy a drawable.  It
+ * should be possible to create GLX protocol (or have it determine which
+ * protocol to use based on the type of the drawable) to have one function
+ * do the work of 3.  For the direct-rendering case, this function could
+ * just call the driver's \c __DRIdrawableRec::destroyDrawable function.
+ * This would reduce the frequency with which \c __driGarbageCollectDrawables
+ * would need to be used.  This really should be done as part of the new DRI
+ * interface work.
+ *
+ * \sa http://oss.sgi.com/projects/ogl-sample/registry/MESA/release_buffers.txt
+ *     __driGarbageCollectDrawables
+ *     glXDestroyGLXPixmap
+ *     glXDestroyPbuffer glXDestroyPixmap glXDestroyWindow
+ *     glXDestroyGLXPbufferSGIX glXDestroyGLXVideoSourceSGIX
+ */
+PUBLIC Bool glXReleaseBuffersMESA( Display *dpy, GLXDrawable d )
+{
+   (void) dpy;
+   (void) d;
+   return False;
+}
+
+
+PUBLIC GLXPixmap glXCreateGLXPixmapMESA( Display *dpy, XVisualInfo *visual,
+					 Pixmap pixmap, Colormap cmap )
+{
+   (void) dpy;
+   (void) visual;
+   (void) pixmap;
+   (void) cmap;
+   return 0;
+}
+
+
+PUBLIC void glXCopySubBufferMESA(Display *dpy, GLXDrawable drawable,
+				 int x, int y, int width, int height)
+{
+   (void) dpy;
+   (void) drawable;
+   (void) x;
+   (void) y;
+   (void) width;
+   (void) height;
+}
+
+
+PUBLIC Bool glXSet3DfxModeMESA( int mode )
+{
+   (void) mode;
+   return GL_FALSE;
+}
+/*@}*/
+
+
+
+/**
+ * \c strdup is actually not a standard ANSI C or POSIX routine.
+ * Irix will not define it if ANSI mode is in effect.
+ * 
+ * \sa strdup
+ */
+char *
+__glXstrdup(const char *str)
+{
+   char *copy;
+   copy = (char *) Xmalloc(strlen(str) + 1);
+   if (!copy)
+      return NULL;
+   strcpy(copy, str);
+   return copy;
+}
+
+/*
+** glXGetProcAddress support
+*/
+
+struct name_address_pair {
+   const char *Name;
+   GLvoid *Address;
+};
+
+#define GLX_FUNCTION(f) { # f, (GLvoid *) f }
+#define GLX_FUNCTION2(n,f) { # n, (GLvoid *) f }
+
+static const struct name_address_pair GLX_functions[] = {
+   /*** GLX_VERSION_1_0 ***/
+   GLX_FUNCTION( glXChooseVisual ),
+   GLX_FUNCTION( glXCopyContext ),
+   GLX_FUNCTION( glXCreateContext ),
+   GLX_FUNCTION( glXCreateGLXPixmap ),
+   GLX_FUNCTION( glXDestroyContext ),
+   GLX_FUNCTION( glXDestroyGLXPixmap ),
+   GLX_FUNCTION( glXGetConfig ),
+   GLX_FUNCTION( glXGetCurrentContext ),
+   GLX_FUNCTION( glXGetCurrentDrawable ),
+   GLX_FUNCTION( glXIsDirect ),
+   GLX_FUNCTION( glXMakeCurrent ),
+   GLX_FUNCTION( glXQueryExtension ),
+   GLX_FUNCTION( glXQueryVersion ),
+   GLX_FUNCTION( glXSwapBuffers ),
+   GLX_FUNCTION( glXUseXFont ),
+   GLX_FUNCTION( glXWaitGL ),
+   GLX_FUNCTION( glXWaitX ),
+
+   /*** GLX_VERSION_1_1 ***/
+   GLX_FUNCTION( glXGetClientString ),
+   GLX_FUNCTION( glXQueryExtensionsString ),
+   GLX_FUNCTION( glXQueryServerString ),
+
+   /*** GLX_VERSION_1_2 ***/
+   GLX_FUNCTION( glXGetCurrentDisplay ),
+
+   /*** GLX_VERSION_1_3 ***/
+   GLX_FUNCTION( glXChooseFBConfig ),
+   GLX_FUNCTION( glXCreateNewContext ),
+   GLX_FUNCTION( glXCreatePbuffer ),
+   GLX_FUNCTION( glXCreatePixmap ),
+   GLX_FUNCTION( glXCreateWindow ),
+   GLX_FUNCTION( glXDestroyPbuffer ),
+   GLX_FUNCTION( glXDestroyPixmap ),
+   GLX_FUNCTION( glXDestroyWindow ),
+   GLX_FUNCTION( glXGetCurrentReadDrawable ),
+   GLX_FUNCTION( glXGetFBConfigAttrib ),
+   GLX_FUNCTION( glXGetFBConfigs ),
+   GLX_FUNCTION( glXGetSelectedEvent ),
+   GLX_FUNCTION( glXGetVisualFromFBConfig ),
+   GLX_FUNCTION( glXMakeContextCurrent ),
+   GLX_FUNCTION( glXQueryContext ),
+   GLX_FUNCTION( glXQueryDrawable ),
+   GLX_FUNCTION( glXSelectEvent ),
+
+   /*** GLX_SGI_swap_control ***/
+   GLX_FUNCTION( glXSwapIntervalSGI ),
+
+   /*** GLX_SGI_video_sync ***/
+   GLX_FUNCTION( glXGetVideoSyncSGI ),
+   GLX_FUNCTION( glXWaitVideoSyncSGI ),
+
+   /*** GLX_SGI_make_current_read ***/
+   GLX_FUNCTION2( glXMakeCurrentReadSGI, glXMakeContextCurrent ),
+   GLX_FUNCTION2( glXGetCurrentReadDrawableSGI, glXGetCurrentReadDrawable ),
+
+   /*** GLX_SGIX_video_source ***/
+#if defined(_VL_H)
+   GLX_FUNCTION( glXCreateGLXVideoSourceSGIX ),
+   GLX_FUNCTION( glXDestroyGLXVideoSourceSGIX ),
+#endif
+
+   /*** GLX_EXT_import_context ***/
+   GLX_FUNCTION( glXFreeContextEXT ),
+   GLX_FUNCTION( glXGetContextIDEXT ),
+   GLX_FUNCTION2( glXGetCurrentDisplayEXT, glXGetCurrentDisplay ),
+   GLX_FUNCTION( glXImportContextEXT ),
+   GLX_FUNCTION2( glXQueryContextInfoEXT, glXQueryContext ),
+
+   /*** GLX_SGIX_fbconfig ***/
+   GLX_FUNCTION2( glXGetFBConfigAttribSGIX, glXGetFBConfigAttrib ),
+   GLX_FUNCTION2( glXChooseFBConfigSGIX, glXChooseFBConfig ),
+   GLX_FUNCTION( glXCreateGLXPixmapWithConfigSGIX ),
+   GLX_FUNCTION( glXCreateContextWithConfigSGIX ),
+   GLX_FUNCTION2( glXGetVisualFromFBConfigSGIX, glXGetVisualFromFBConfig ),
+   GLX_FUNCTION( glXGetFBConfigFromVisualSGIX ),
+
+   /*** GLX_SGIX_pbuffer ***/
+   GLX_FUNCTION( glXCreateGLXPbufferSGIX ),
+   GLX_FUNCTION( glXDestroyGLXPbufferSGIX ),
+   GLX_FUNCTION( glXQueryGLXPbufferSGIX ),
+   GLX_FUNCTION( glXSelectEventSGIX ),
+   GLX_FUNCTION( glXGetSelectedEventSGIX ),
+
+   /*** GLX_SGI_cushion ***/
+   GLX_FUNCTION( glXCushionSGI ),
+
+   /*** GLX_SGIX_video_resize ***/
+   GLX_FUNCTION( glXBindChannelToWindowSGIX ),
+   GLX_FUNCTION( glXChannelRectSGIX ),
+   GLX_FUNCTION( glXQueryChannelRectSGIX ),
+   GLX_FUNCTION( glXQueryChannelDeltasSGIX ),
+   GLX_FUNCTION( glXChannelRectSyncSGIX ),
+
+   /*** GLX_SGIX_dmbuffer **/
+#if defined(_DM_BUFFER_H_)
+   GLX_FUNCTION( glXAssociateDMPbufferSGIX ),
+#endif
+
+   /*** GLX_SGIX_swap_group ***/
+   GLX_FUNCTION( glXJoinSwapGroupSGIX ),
+
+   /*** GLX_SGIX_swap_barrier ***/
+   GLX_FUNCTION( glXBindSwapBarrierSGIX ),
+   GLX_FUNCTION( glXQueryMaxSwapBarriersSGIX ),
+
+   /*** GLX_SUN_get_transparent_index ***/
+   GLX_FUNCTION( glXGetTransparentIndexSUN ),
+
+   /*** GLX_MESA_allocate_memory ***/
+   GLX_FUNCTION( glXAllocateMemoryMESA ),
+   GLX_FUNCTION( glXFreeMemoryMESA ),
+   GLX_FUNCTION( glXGetMemoryOffsetMESA ),
+
+   /*** GLX_MESA_copy_sub_buffer ***/
+   GLX_FUNCTION( glXCopySubBufferMESA ),
+
+   /*** GLX_MESA_pixmap_colormap ***/
+   GLX_FUNCTION( glXCreateGLXPixmapMESA ),
+
+   /*** GLX_MESA_release_buffers ***/
+   GLX_FUNCTION( glXReleaseBuffersMESA ),
+
+   /*** GLX_MESA_set_3dfx_mode ***/
+   GLX_FUNCTION( glXSet3DfxModeMESA ),
+
+   /*** GLX_MESA_swap_control ***/
+   GLX_FUNCTION( glXSwapIntervalMESA ),
+   GLX_FUNCTION( glXGetSwapIntervalMESA ),
+
+   /*** GLX_MESA_swap_frame_usage ***/
+   GLX_FUNCTION( glXBeginFrameTrackingMESA ),
+   GLX_FUNCTION( glXEndFrameTrackingMESA ),
+   GLX_FUNCTION( glXGetFrameUsageMESA ),
+   GLX_FUNCTION( glXQueryFrameTrackingMESA ),
+
+   /*** GLX_ARB_get_proc_address ***/
+   GLX_FUNCTION( glXGetProcAddressARB ),
+
+   /*** GLX 1.4 ***/
+   GLX_FUNCTION2( glXGetProcAddress, glXGetProcAddressARB ),
+
+   /*** GLX_OML_sync_control ***/
+   GLX_FUNCTION( glXWaitForSbcOML ),
+   GLX_FUNCTION( glXWaitForMscOML ),
+   GLX_FUNCTION( glXSwapBuffersMscOML ),
+   GLX_FUNCTION( glXGetMscRateOML ),
+   GLX_FUNCTION( glXGetSyncValuesOML ),
+
+#ifdef GLX_DIRECT_RENDERING
+   /*** DRI configuration ***/
+   GLX_FUNCTION( glXGetScreenDriver ),
+   GLX_FUNCTION( glXGetDriverConfig ),
+#endif
+
+   { NULL, NULL }   /* end of list */
+};
+
+
+static const GLvoid *
+get_glx_proc_address(const char *funcName)
+{
+   GLuint i;
+
+   /* try static functions */
+   for (i = 0; GLX_functions[i].Name; i++) {
+      if (strcmp(GLX_functions[i].Name, funcName) == 0)
+	 return GLX_functions[i].Address;
+   }
+
+   return NULL;
+}
+
+
+/**
+ * Get the address of a named GL function.  This is the pre-GLX 1.4 name for
+ * \c glXGetProcAddress.
+ *
+ * \param procName  Name of a GL or GLX function.
+ * \returns         A pointer to the named function
+ *
+ * \sa glXGetProcAddress
+ */
+PUBLIC void (*glXGetProcAddressARB(const GLubyte *procName))( void )
+{
+   typedef void (*gl_function)( void );
+   gl_function f;
+
+
+   /* Search the table of GLX and internal functions first.  If that
+    * fails and the supplied name could be a valid core GL name, try
+    * searching the core GL function table.  This check is done to prevent
+    * DRI based drivers from searching the core GL function table for
+    * internal API functions.
+    */
+
+   f = (gl_function) get_glx_proc_address((const char *) procName);
+   if ( (f == NULL) && (procName[0] == 'g') && (procName[1] == 'l')
+	&& (procName[2] != 'X') ) {
+      f = (gl_function) _glapi_get_proc_address((const char *) procName);
+   }
+
+   return f;
+}
+
+/**
+ * Get the address of a named GL function.  This is the GLX 1.4 name for
+ * \c glXGetProcAddressARB.
+ *
+ * \param procName  Name of a GL or GLX function.
+ * \returns         A pointer to the named function
+ *
+ * \sa glXGetProcAddressARB
+ */
+PUBLIC void (*glXGetProcAddress(const GLubyte *procName))( void )
+#if defined(__GNUC__) && !defined(GLX_ALIAS_UNSUPPORTED)
+    __attribute__ ((alias ("glXGetProcAddressARB")));
+#else
+{
+   return glXGetProcAddressARB(procName);
+}
+#endif /* __GNUC__ */
+
+
+#ifdef GLX_DIRECT_RENDERING
+/**
+ * Retrieves the verion of the internal libGL API in YYYYMMDD format.  This
+ * might be used by the DRI drivers to determine how new libGL is at runtime.
+ * Drivers should not call this function directly.  They should instead use
+ * \c glXGetProcAddress to obtain a pointer to the function.
+ * 
+ * \returns An 8-digit decimal number representing the internal libGL API in
+ *          YYYYMMDD format.
+ * 
+ * \sa glXGetProcAddress, PFNGLXGETINTERNALVERSIONPROC
+ *
+ * \since Internal API version 20021121.
+ */
+int __glXGetInternalVersion(void)
+{
+    /* History:
+     * 20021121 - Initial version
+     * 20021128 - Added __glXWindowExists() function
+     * 20021207 - Added support for dynamic GLX extensions,
+     *            GLX_SGI_swap_control, GLX_SGI_video_sync,
+     *            GLX_OML_sync_control, and GLX_MESA_swap_control.
+     *            Never officially released.  Do NOT test against
+     *            this version.  Use 20030317 instead.
+     * 20030317 - Added support GLX_SGIX_fbconfig,
+     *            GLX_MESA_swap_frame_usage, GLX_OML_swap_method,
+     *            GLX_{ARB,SGIS}_multisample, and
+     *            GLX_SGIX_visual_select_group.
+     * 20030606 - Added support for GLX_SGI_make_current_read.
+     * 20030813 - Made support for dynamic extensions multi-head aware.
+     * 20030818 - Added support for GLX_MESA_allocate_memory in place of the
+     *            deprecated GLX_NV_vertex_array_range & GLX_MESA_agp_offset
+     *            interfaces.
+     * 20031201 - Added support for the first round of DRI interface changes.
+     *            Do NOT test against this version!  It has binary
+     *            compatibility bugs, use 20040317 instead.
+     * 20040317 - Added the 'mode' field to __DRIcontextRec.
+     * 20040415 - Added support for bindContext3 and unbindContext3.
+     * 20040602 - Add __glXGetDrawableInfo.  I though that was there
+     *            months ago. :(
+     * 20050727 - Gut all the old interfaces.  This breaks compatability with
+     *            any DRI driver built to any previous version.
+     */
+    return 20050727;
+}
+
+
+
+static Bool windowExistsFlag;
+
+static int windowExistsErrorHandler(Display *dpy, XErrorEvent *xerr)
+{
+    if (xerr->error_code == BadWindow) {
+        windowExistsFlag = GL_FALSE;
+    }
+    return 0;
+}
+
+/**
+ * Determine if a window associated with a \c GLXDrawable exists on the
+ * X-server.  This function is not used internally by libGL.  It is provided
+ * as a utility function for DRI drivers.
+ * Drivers should not call this function directly.  They should instead use
+ * \c glXGetProcAddress to obtain a pointer to the function.
+ *
+ * \param dpy  Display associated with the drawable to be queried.
+ * \param draw \c GLXDrawable to test.
+ * 
+ * \returns \c GL_TRUE if a window exists that is associated with \c draw,
+ *          otherwise \c GL_FALSE is returned.
+ * 
+ * \warning This function is not currently thread-safe.
+ *
+ * \sa glXGetProcAddress
+ *
+ * \since Internal API version 20021128.
+ */
+Bool __glXWindowExists(Display *dpy, GLXDrawable draw)
+{
+    XWindowAttributes xwa;
+    int (*oldXErrorHandler)(Display *, XErrorEvent *);
+
+    XSync(dpy, GL_FALSE);
+    windowExistsFlag = GL_TRUE;
+    oldXErrorHandler = XSetErrorHandler(windowExistsErrorHandler);
+    XGetWindowAttributes(dpy, draw, &xwa); /* dummy request */
+    XSetErrorHandler(oldXErrorHandler);
+    return windowExistsFlag;
+}
+
+
+/**
+ * Get the unadjusted system time (UST).  Currently, the UST is measured in
+ * microseconds since Epoc.  The actual resolution of the UST may vary from
+ * system to system, and the units may vary from release to release.
+ * Drivers should not call this function directly.  They should instead use
+ * \c glXGetProcAddress to obtain a pointer to the function.
+ *
+ * \param ust Location to store the 64-bit UST
+ * \returns Zero on success or a negative errno value on failure.
+ * 
+ * \sa glXGetProcAddress, PFNGLXGETUSTPROC
+ *
+ * \since Internal API version 20030317.
+ */
+int __glXGetUST( int64_t * ust )
+{
+    struct timeval  tv;
+    
+    if ( ust == NULL ) {
+	return -EFAULT;
+    }
+
+    if ( gettimeofday( & tv, NULL ) == 0 ) {
+	ust[0] = (tv.tv_sec * 1000000) + tv.tv_usec;
+	return 0;
+    } else {
+	return -errno;
+    }
+}
+#endif /* GLX_DIRECT_RENDERING */
diff --git a/src/glx/x11/glxext.c b/src/glx/x11/glxext.c
new file mode 100644
index 00000000000..eb6e870e984
--- /dev/null
+++ b/src/glx/x11/glxext.c
@@ -0,0 +1,1864 @@
+/* $XFree86: xc/lib/GL/glx/glxext.c,v 1.22 2003/12/08 17:35:28 dawes Exp $ */
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+/**
+ * \file glxext.c
+ * GLX protocol interface boot-strap code.
+ *
+ * Direct rendering support added by Precision Insight, Inc.
+ *
+ * \author Kevin E. Martin <[email protected]>
+ */     
+
+#include "glxclient.h"
+#include <stdio.h>
+#include <X11/extensions/Xext.h>
+#include <X11/extensions/extutil.h>
+#include <assert.h>
+#include "indirect_init.h"
+#include "glapi.h"
+#include "glxextensions.h"
+#include "glcontextmodes.h"
+#include "glheader.h"
+
+#ifdef GLX_DIRECT_RENDERING
+#include <inttypes.h>
+#include <sys/mman.h>
+#include "xf86dri.h"
+#include "sarea.h"
+#include "dri_glx.h"
+#endif
+
+#ifdef USE_XCB
+#include <X11/xcl.h>
+#include <X11/XCB/xcb.h>
+#include <X11/XCB/glx.h>
+#endif
+
+#include <assert.h>
+
+#ifdef DEBUG
+void __glXDumpDrawBuffer(__GLXcontext *ctx);
+#endif
+
+#ifdef USE_SPARC_ASM
+/*
+ * This is where our dispatch table's bounds are.
+ * And the static mesa_init is taken directly from
+ * Mesa's 'sparc.c' initializer.
+ *
+ * We need something like this here, because this version
+ * of openGL/glx never initializes a Mesa context, and so
+ * the address of the dispatch table pointer never gets stuffed
+ * into the dispatch jump table otherwise.
+ *
+ * It matters only on SPARC, and only if you are using assembler
+ * code instead of C-code indirect dispatch.
+ *
+ * -- FEM, 04.xii.03
+ */
+extern unsigned int _mesa_sparc_glapi_begin;
+extern unsigned int _mesa_sparc_glapi_end;
+extern void __glapi_sparc_icache_flush(unsigned int *);
+static void _glx_mesa_init_sparc_glapi_relocs(void);
+static int _mesa_sparc_needs_init = 1;
+#define INIT_MESA_SPARC { \
+    if(_mesa_sparc_needs_init) { \
+      _glx_mesa_init_sparc_glapi_relocs(); \
+      _mesa_sparc_needs_init = 0; \
+  } \
+}
+#else
+#define INIT_MESA_SPARC
+#endif
+
+#ifdef GLX_DIRECT_RENDERING
+static __DRIscreen *__glXFindDRIScreen(__DRInativeDisplay *dpy, int scrn);
+#endif /* GLX_DIRECT_RENDERING */
+
+static Bool MakeContextCurrent(Display *dpy, GLXDrawable draw,
+    GLXDrawable read, GLXContext gc);
+
+/*
+** We setup some dummy structures here so that the API can be used
+** even if no context is current.
+*/
+
+static GLubyte dummyBuffer[__GLX_BUFFER_LIMIT_SIZE];
+
+/*
+** Dummy context used by small commands when there is no current context.
+** All the
+** gl and glx entry points are designed to operate as nop's when using
+** the dummy context structure.
+*/
+static __GLXcontext dummyContext = {
+    &dummyBuffer[0],
+    &dummyBuffer[0],
+    &dummyBuffer[0],
+    &dummyBuffer[__GLX_BUFFER_LIMIT_SIZE],
+    sizeof(dummyBuffer),
+};
+
+
+/*
+** All indirect rendering contexts will share the same indirect dispatch table.
+*/
+static __GLapi *IndirectAPI = NULL;
+
+
+/*
+ * Current context management and locking
+ */
+
+#if defined( USE_XTHREADS )
+
+/* thread safe */
+static GLboolean TSDinitialized = GL_FALSE;
+static xthread_key_t ContextTSD;
+
+__GLXcontext *__glXGetCurrentContext(void)
+{
+   if (!TSDinitialized) {
+      xthread_key_create(&ContextTSD, NULL);
+      TSDinitialized = GL_TRUE;
+      return &dummyContext;
+   }
+   else {
+      void *p;
+      xthread_get_specific(ContextTSD, &p);
+      if (!p)
+         return &dummyContext;
+      else
+         return (__GLXcontext *) p;
+   }
+}
+
+void __glXSetCurrentContext(__GLXcontext *c)
+{
+   if (!TSDinitialized) {
+      xthread_key_create(&ContextTSD, NULL);
+      TSDinitialized = GL_TRUE;
+   }
+   xthread_set_specific(ContextTSD, c);
+}
+
+
+/* Used by the __glXLock() and __glXUnlock() macros */
+xmutex_rec __glXmutex;
+
+#elif defined( PTHREADS )
+
+pthread_mutex_t __glXmutex = PTHREAD_MUTEX_INITIALIZER;
+
+# if defined( GLX_USE_TLS )
+
+/**
+ * Per-thread GLX context pointer.
+ * 
+ * \c __glXSetCurrentContext is written is such a way that this pointer can
+ * \b never be \c NULL.  This is important!  Because of this
+ * \c __glXGetCurrentContext can be implemented as trivial macro.
+ */
+__thread void * __glX_tls_Context __attribute__((tls_model("initial-exec")))
+    = &dummyContext;
+
+void __glXSetCurrentContext( __GLXcontext * c )
+{
+    __glX_tls_Context = (c != NULL) ? c : &dummyContext;
+}
+
+# else
+
+static pthread_once_t once_control = PTHREAD_ONCE_INIT;
+
+/**
+ * Per-thread data key.
+ * 
+ * Once \c init_thread_data has been called, the per-thread data key will
+ * take a value of \c NULL.  As each new thread is created the default
+ * value, in that thread, will be \c NULL.
+ */
+static pthread_key_t ContextTSD;
+
+/**
+ * Initialize the per-thread data key.
+ * 
+ * This function is called \b exactly once per-process (not per-thread!) to
+ * initialize the per-thread data key.  This is ideally done using the
+ * \c pthread_once mechanism.
+ */
+static void init_thread_data( void )
+{
+    if ( pthread_key_create( & ContextTSD, NULL ) != 0 ) {
+	perror( "pthread_key_create" );
+	exit( -1 );
+    }
+}
+
+void __glXSetCurrentContext( __GLXcontext * c )
+{
+    pthread_once( & once_control, init_thread_data );
+    pthread_setspecific( ContextTSD, c );
+}
+
+__GLXcontext * __glXGetCurrentContext( void )
+{
+    void * v;
+
+    pthread_once( & once_control, init_thread_data );
+
+    v = pthread_getspecific( ContextTSD );
+    return (v == NULL) ? & dummyContext : (__GLXcontext *) v;
+}
+
+# endif /* defined( GLX_USE_TLS ) */
+
+#elif defined( THREADS )
+
+#error Unknown threading method specified.
+
+#else
+
+/* not thread safe */
+__GLXcontext *__glXcurrentContext = &dummyContext;
+
+#endif
+
+
+/*
+** You can set this cell to 1 to force the gl drawing stuff to be
+** one command per packet
+*/
+int __glXDebug = 0;
+
+/*
+** forward prototype declarations
+*/
+int __glXCloseDisplay(Display *dpy, XExtCodes *codes);
+
+
+/************************************************************************/
+
+/* Extension required boiler plate */
+
+static char *__glXExtensionName = GLX_EXTENSION_NAME;
+XExtensionInfo *__glXExtensionInfo = NULL;
+
+static /* const */ char *error_list[] = {
+    "GLXBadContext",
+    "GLXBadContextState",
+    "GLXBadDrawable",
+    "GLXBadPixmap",
+    "GLXBadContextTag",
+    "GLXBadCurrentWindow",
+    "GLXBadRenderRequest",
+    "GLXBadLargeRequest",
+    "GLXUnsupportedPrivateRequest",
+};
+
+int __glXCloseDisplay(Display *dpy, XExtCodes *codes)
+{
+  GLXContext gc;
+
+  gc = __glXGetCurrentContext();
+  if (dpy == gc->currentDpy) {
+    __glXSetCurrentContext(&dummyContext);
+#ifdef GLX_DIRECT_RENDERING
+    _glapi_set_dispatch(NULL);  /* no-op functions */
+#endif
+    __glXFreeContext(gc);
+  }
+
+  return XextRemoveDisplay(__glXExtensionInfo, dpy);
+}
+
+
+static XEXT_GENERATE_ERROR_STRING(__glXErrorString, __glXExtensionName,
+				  __GLX_NUMBER_ERRORS, error_list)
+
+static /* const */ XExtensionHooks __glXExtensionHooks = {
+    NULL,				/* create_gc */
+    NULL,				/* copy_gc */
+    NULL,				/* flush_gc */
+    NULL,				/* free_gc */
+    NULL,				/* create_font */
+    NULL,				/* free_font */
+    __glXCloseDisplay,			/* close_display */
+    NULL,				/* wire_to_event */
+    NULL,				/* event_to_wire */
+    NULL,				/* error */
+    __glXErrorString,			/* error_string */
+};
+
+static
+XEXT_GENERATE_FIND_DISPLAY(__glXFindDisplay, __glXExtensionInfo,
+			   __glXExtensionName, &__glXExtensionHooks,
+			   __GLX_NUMBER_EVENTS, NULL)
+
+/************************************************************************/
+
+/*
+** Free the per screen configs data as well as the array of
+** __glXScreenConfigs.
+*/
+static void FreeScreenConfigs(__GLXdisplayPrivate *priv)
+{
+    __GLXscreenConfigs *psc;
+    GLint i, screens;
+
+    /* Free screen configuration information */
+    psc = priv->screenConfigs;
+    screens = ScreenCount(priv->dpy);
+    for (i = 0; i < screens; i++, psc++) {
+	if (psc->configs) {
+	    _gl_context_modes_destroy( psc->configs );
+	    if(psc->effectiveGLXexts)
+		Xfree(psc->effectiveGLXexts);
+
+	    psc->configs = NULL;	/* NOTE: just for paranoia */
+	}
+
+#ifdef GLX_DIRECT_RENDERING
+	/* Free the direct rendering per screen data */
+	if (psc->driScreen.private)
+	    (*psc->driScreen.destroyScreen)(priv->dpy, i,
+					    psc->driScreen.private);
+	psc->driScreen.private = NULL;
+#endif
+    }
+    XFree((char*) priv->screenConfigs);
+}
+
+/*
+** Release the private memory referred to in a display private
+** structure.  The caller will free the extension structure.
+*/
+static int __glXFreeDisplayPrivate(XExtData *extension)
+{
+    __GLXdisplayPrivate *priv;
+
+    priv = (__GLXdisplayPrivate*) extension->private_data;
+    FreeScreenConfigs(priv);
+    if(priv->serverGLXvendor) {
+	Xfree((char*)priv->serverGLXvendor);
+	priv->serverGLXvendor = 0x0; /* to protect against double free's */
+    }
+    if(priv->serverGLXversion) {
+	Xfree((char*)priv->serverGLXversion);
+	priv->serverGLXversion = 0x0; /* to protect against double free's */
+    }
+
+#if 0 /* GLX_DIRECT_RENDERING */
+    /* Free the direct rendering per display data */
+    if (priv->driDisplay.private)
+	(*priv->driDisplay.destroyDisplay)(priv->dpy,
+					   priv->driDisplay.private);
+    priv->driDisplay.private = NULL;
+#endif
+
+    Xfree((char*) priv);
+    return 0;
+}
+
+/************************************************************************/
+
+/*
+** Query the version of the GLX extension.  This procedure works even if
+** the client extension is not completely set up.
+*/
+static Bool QueryVersion(Display *dpy, int opcode, int *major, int *minor)
+{
+    xGLXQueryVersionReq *req;
+    xGLXQueryVersionReply reply;
+
+    /* Send the glXQueryVersion request */
+    LockDisplay(dpy);
+    GetReq(GLXQueryVersion,req);
+    req->reqType = opcode;
+    req->glxCode = X_GLXQueryVersion;
+    req->majorVersion = GLX_MAJOR_VERSION;
+    req->minorVersion = GLX_MINOR_VERSION;
+    _XReply(dpy, (xReply*) &reply, 0, False);
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+    if (reply.majorVersion != GLX_MAJOR_VERSION) {
+	/*
+	** The server does not support the same major release as this
+	** client.
+	*/
+	return GL_FALSE;
+    }
+    *major = reply.majorVersion;
+    *minor = min(reply.minorVersion, GLX_MINOR_VERSION);
+    return GL_TRUE;
+}
+
+
+void 
+__glXInitializeVisualConfigFromTags( __GLcontextModes *config, int count, 
+				     const INT32 *bp, Bool tagged_only,
+				     Bool fbconfig_style_tags )
+{
+    int i;
+
+    if (!tagged_only) {
+	/* Copy in the first set of properties */
+	config->visualID = *bp++;
+
+	config->visualType = _gl_convert_from_x_visual_type( *bp++ );
+
+	config->rgbMode = *bp++;
+
+	config->redBits = *bp++;
+	config->greenBits = *bp++;
+	config->blueBits = *bp++;
+	config->alphaBits = *bp++;
+	config->accumRedBits = *bp++;
+	config->accumGreenBits = *bp++;
+	config->accumBlueBits = *bp++;
+	config->accumAlphaBits = *bp++;
+
+	config->doubleBufferMode = *bp++;
+	config->stereoMode = *bp++;
+
+	config->rgbBits = *bp++;
+	config->depthBits = *bp++;
+	config->stencilBits = *bp++;
+	config->numAuxBuffers = *bp++;
+	config->level = *bp++;
+
+	count -= __GLX_MIN_CONFIG_PROPS;
+    }
+
+    /*
+    ** Additional properties may be in a list at the end
+    ** of the reply.  They are in pairs of property type
+    ** and property value.
+    */
+
+#define FETCH_OR_SET(tag) \
+    config-> tag = ( fbconfig_style_tags ) ? *bp++ : 1
+
+    for (i = 0; i < count; i += 2 ) {
+	switch(*bp++) {
+	  case GLX_RGBA:
+	    FETCH_OR_SET( rgbMode );
+	    break;
+	  case GLX_BUFFER_SIZE:
+	    config->rgbBits = *bp++;
+	    break;
+	  case GLX_LEVEL:
+	    config->level = *bp++;
+	    break;
+	  case GLX_DOUBLEBUFFER:
+	    FETCH_OR_SET( doubleBufferMode );
+	    break;
+	  case GLX_STEREO:
+	    FETCH_OR_SET( stereoMode );
+	    break;
+	  case GLX_AUX_BUFFERS:
+	    config->numAuxBuffers = *bp++;
+	    break;
+	  case GLX_RED_SIZE:
+	    config->redBits = *bp++;
+	    break;
+	  case GLX_GREEN_SIZE:
+	    config->greenBits = *bp++;
+	    break;
+	  case GLX_BLUE_SIZE:
+	    config->blueBits = *bp++;
+	    break;
+	  case GLX_ALPHA_SIZE:
+	    config->alphaBits = *bp++;
+	    break;
+	  case GLX_DEPTH_SIZE:
+	    config->depthBits = *bp++;
+	    break;
+	  case GLX_STENCIL_SIZE:
+	    config->stencilBits = *bp++;
+	    break;
+	  case GLX_ACCUM_RED_SIZE:
+	    config->accumRedBits = *bp++;
+	    break;
+	  case GLX_ACCUM_GREEN_SIZE:
+	    config->accumGreenBits = *bp++;
+	    break;
+	  case GLX_ACCUM_BLUE_SIZE:
+	    config->accumBlueBits = *bp++;
+	    break;
+	  case GLX_ACCUM_ALPHA_SIZE:
+	    config->accumAlphaBits = *bp++;
+	    break;
+	  case GLX_VISUAL_CAVEAT_EXT:
+	    config->visualRating = *bp++;    
+	    break;
+	  case GLX_X_VISUAL_TYPE:
+	    config->visualType = *bp++;
+	    break;
+	  case GLX_TRANSPARENT_TYPE:
+	    config->transparentPixel = *bp++;    
+	    break;
+	  case GLX_TRANSPARENT_INDEX_VALUE:
+	    config->transparentIndex = *bp++;    
+	    break;
+	  case GLX_TRANSPARENT_RED_VALUE:
+	    config->transparentRed = *bp++;    
+	    break;
+	  case GLX_TRANSPARENT_GREEN_VALUE:
+	    config->transparentGreen = *bp++;    
+	    break;
+	  case GLX_TRANSPARENT_BLUE_VALUE:
+	    config->transparentBlue = *bp++;    
+	    break;
+	  case GLX_TRANSPARENT_ALPHA_VALUE:
+	    config->transparentAlpha = *bp++;    
+	    break;
+	  case GLX_VISUAL_ID:
+	    config->visualID = *bp++;
+	    break;
+	  case GLX_DRAWABLE_TYPE:
+	    config->drawableType = *bp++;
+	    break;
+	  case GLX_RENDER_TYPE:
+	    config->renderType = *bp++;
+	    break;
+	  case GLX_X_RENDERABLE:
+	    config->xRenderable = *bp++;
+	    break;
+	  case GLX_FBCONFIG_ID:
+	    config->fbconfigID = *bp++;
+	    break;
+	  case GLX_MAX_PBUFFER_WIDTH:
+	    config->maxPbufferWidth = *bp++;
+	    break;
+	  case GLX_MAX_PBUFFER_HEIGHT:
+	    config->maxPbufferHeight = *bp++;
+	    break;
+	  case GLX_MAX_PBUFFER_PIXELS:
+	    config->maxPbufferPixels = *bp++;
+	    break;
+	  case GLX_OPTIMAL_PBUFFER_WIDTH_SGIX:
+	    config->optimalPbufferWidth = *bp++;
+	    break;
+	  case GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX:
+	    config->optimalPbufferHeight = *bp++;
+	    break;
+	  case GLX_VISUAL_SELECT_GROUP_SGIX:
+	    config->visualSelectGroup = *bp++;
+	    break;
+	  case GLX_SWAP_METHOD_OML:
+	    config->swapMethod = *bp++;
+	    break;
+	  case GLX_SAMPLE_BUFFERS_SGIS:
+	    config->sampleBuffers = *bp++;
+	    break;
+	  case GLX_SAMPLES_SGIS:
+	    config->samples = *bp++;
+	    break;
+	  case None:
+	    i = count;
+	    break;
+	  default:
+	    break;
+	}
+    }
+
+    config->renderType = (config->rgbMode) ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
+
+    config->haveAccumBuffer = ((config->accumRedBits +
+			       config->accumGreenBits +
+			       config->accumBlueBits +
+			       config->accumAlphaBits) > 0);
+    config->haveDepthBuffer = (config->depthBits > 0);
+    config->haveStencilBuffer = (config->stencilBits > 0);
+}
+
+
+#ifdef GLX_DIRECT_RENDERING
+static unsigned
+filter_modes( __GLcontextModes ** server_modes,
+	      const __GLcontextModes * driver_modes )
+{
+    __GLcontextModes * m;
+    __GLcontextModes ** prev_next;
+    const __GLcontextModes * check;
+    unsigned modes_count = 0;
+
+    if ( driver_modes == NULL ) {
+	fprintf(stderr, "libGL warning: 3D driver returned no fbconfigs.\n");
+	return 0;
+    }
+
+    /* For each mode in server_modes, check to see if a matching mode exists
+     * in driver_modes.  If not, then the mode is not available.
+     */
+
+    prev_next = server_modes;
+    for ( m = *prev_next ; m != NULL ; m = *prev_next ) {
+	GLboolean do_delete = GL_TRUE;
+
+	for ( check = driver_modes ; check != NULL ; check = check->next ) {
+	    if ( _gl_context_modes_are_same( m, check ) ) {
+		do_delete = GL_FALSE;
+		break;
+	    }
+	}
+
+	/* The 3D has to support all the modes that match the GLX visuals
+	 * sent from the X server.
+	 */
+	if ( do_delete && (m->visualID != 0) ) {
+	    do_delete = GL_FALSE;
+
+	    fprintf(stderr, "libGL warning: 3D driver claims to not support "
+		    "visual 0x%02x\n", m->visualID);
+	}
+
+	if ( do_delete ) {
+	    *prev_next = m->next;
+
+	    m->next = NULL;
+	    _gl_context_modes_destroy( m );
+	}
+	else {
+	    modes_count++;
+	    prev_next = & m->next;
+	}
+    }
+
+    return modes_count;
+}
+
+
+/**
+ * Implement \c __DRIinterfaceMethods::getProcAddress.
+ */
+static __DRIfuncPtr get_proc_address( const char * proc_name )
+{
+    if (strcmp( proc_name, "glxEnableExtension" ) == 0) {
+	return (__DRIfuncPtr) __glXScrEnableExtension;
+    }
+    
+    return NULL;
+}
+
+
+/**
+ * Table of functions exported by the loader to the driver.
+ */
+static const __DRIinterfaceMethods interface_methods = {
+    get_proc_address,
+
+    _gl_context_modes_create,
+    _gl_context_modes_destroy,
+      
+    __glXFindDRIScreen,
+    __glXWindowExists,
+      
+    XF86DRICreateContextWithConfig,
+    XF86DRIDestroyContext,
+
+    XF86DRICreateDrawable,
+    XF86DRIDestroyDrawable,
+    XF86DRIGetDrawableInfo,
+
+    __glXGetUST,
+    glXGetMscRateOML,
+};
+
+
+/**
+ * Perform the required libGL-side initialization and call the client-side
+ * driver's \c __driCreateNewScreen function.
+ * 
+ * \param dpy    Display pointer.
+ * \param scrn   Screen number on the display.
+ * \param psc    DRI screen information.
+ * \param driDpy DRI display information.
+ * \param createNewScreen  Pointer to the client-side driver's
+ *               \c __driCreateNewScreen function.
+ * \returns A pointer to the \c __DRIscreenPrivate structure returned by
+ *          the client-side driver on success, or \c NULL on failure.
+ * 
+ * \todo This function needs to be modified to remove context-modes from the
+ *       list stored in the \c __GLXscreenConfigsRec to match the list
+ *       returned by the client-side driver.
+ */
+static void *
+CallCreateNewScreen(Display *dpy, int scrn, __DRIscreen *psc,
+		    __DRIdisplay * driDpy,
+		    PFNCREATENEWSCREENFUNC createNewScreen)
+{
+    __DRIscreenPrivate *psp = NULL;
+#ifndef GLX_USE_APPLEGL
+    drm_handle_t hSAREA;
+    drmAddress pSAREA = MAP_FAILED;
+    char *BusID;
+    __DRIversion   ddx_version;
+    __DRIversion   dri_version;
+    __DRIversion   drm_version;
+    __DRIframebuffer  framebuffer;
+    int   fd = -1;
+    int   status;
+    const char * err_msg;
+    const char * err_extra;
+    int api_ver = __glXGetInternalVersion();
+
+
+    dri_version.major = driDpy->private->driMajor;
+    dri_version.minor = driDpy->private->driMinor;
+    dri_version.patch = driDpy->private->driPatch;
+
+
+    err_msg = "XF86DRIOpenConnection";
+    err_extra = NULL;
+
+    framebuffer.base = MAP_FAILED;
+    framebuffer.dev_priv = NULL;
+
+    if (XF86DRIOpenConnection(dpy, scrn, &hSAREA, &BusID)) {
+	fd = drmOpen(NULL,BusID);
+	Xfree(BusID); /* No longer needed */
+
+	err_msg = "open DRM";
+	err_extra = strerror( -fd );
+
+	if (fd >= 0) {
+	    drm_magic_t magic;
+
+	    err_msg = "drmGetMagic";
+	    err_extra = NULL;
+
+	    if (!drmGetMagic(fd, &magic)) {
+		drmVersionPtr version = drmGetVersion(fd);
+		if (version) {
+		    drm_version.major = version->version_major;
+		    drm_version.minor = version->version_minor;
+		    drm_version.patch = version->version_patchlevel;
+		    drmFreeVersion(version);
+		}
+		else {
+		    drm_version.major = -1;
+		    drm_version.minor = -1;
+		    drm_version.patch = -1;
+		}
+
+		err_msg = "XF86DRIAuthConnection";
+		if (XF86DRIAuthConnection(dpy, scrn, magic)) {
+		    char *driverName;
+
+		    /*
+		     * Get device name (like "tdfx") and the ddx version
+		     * numbers.  We'll check the version in each DRI driver's
+		     * "createNewScreen" function.
+		     */
+		    err_msg = "XF86DRIGetClientDriverName";
+		    if (XF86DRIGetClientDriverName(dpy, scrn,
+						   &ddx_version.major,
+						   &ddx_version.minor,
+						   &ddx_version.patch,
+						   &driverName)) {
+			drm_handle_t  hFB;
+			int        junk;
+
+			/* No longer needed. */
+			Xfree( driverName );
+
+
+			/*
+			 * Get device-specific info.  pDevPriv will point to a struct
+			 * (such as DRIRADEONRec in xfree86/driver/ati/radeon_dri.h)
+			 * that has information about the screen size, depth, pitch,
+			 * ancilliary buffers, DRM mmap handles, etc.
+			 */
+			err_msg = "XF86DRIGetDeviceInfo";
+			if (XF86DRIGetDeviceInfo(dpy, scrn,
+						 &hFB,
+						 &junk,
+						 &framebuffer.size,
+						 &framebuffer.stride,
+						 &framebuffer.dev_priv_size,
+						 &framebuffer.dev_priv)) {
+			    framebuffer.width = DisplayWidth(dpy, scrn);
+			    framebuffer.height = DisplayHeight(dpy, scrn);
+
+			    /*
+			     * Map the framebuffer region.
+			     */
+			    status = drmMap(fd, hFB, framebuffer.size, 
+					    (drmAddressPtr)&framebuffer.base);
+
+			    err_msg = "drmMap of framebuffer";
+			    err_extra = strerror( -status );
+
+			    if ( status == 0 ) {
+				/*
+				 * Map the SAREA region.  Further mmap regions
+				 * may be setup in each DRI driver's
+				 * "createNewScreen" function.
+				 */
+				status = drmMap(fd, hSAREA, SAREA_MAX, 
+						&pSAREA);
+
+				err_msg = "drmMap of sarea";
+				err_extra = strerror( -status );
+
+				if ( status == 0 ) {
+				    __GLcontextModes * driver_modes = NULL;
+				    __GLXscreenConfigs *configs = psc->screenConfigs;
+
+				    err_msg = "InitDriver";
+				    err_extra = NULL;
+				    psp = (*createNewScreen)(dpy, scrn,
+							     psc,
+							     configs->configs,
+							     & ddx_version,
+							     & dri_version,
+							     & drm_version,
+							     & framebuffer,
+							     pSAREA,
+							     fd,
+							     api_ver,
+							     & interface_methods,
+							     & driver_modes );
+
+				    filter_modes( & configs->configs,
+						  driver_modes );
+				    _gl_context_modes_destroy( driver_modes );
+				}
+			    }
+			}
+		    }
+		}
+	    }
+	}
+    }
+
+    if ( psp == NULL ) {
+	if ( pSAREA != MAP_FAILED ) {
+	    (void)drmUnmap(pSAREA, SAREA_MAX);
+	}
+
+	if ( framebuffer.base != MAP_FAILED ) {
+	    (void)drmUnmap((drmAddress)framebuffer.base, framebuffer.size);
+	}
+
+	if ( framebuffer.dev_priv != NULL ) {
+	    Xfree(framebuffer.dev_priv);
+	}
+
+	if ( fd >= 0 ) {
+	    (void)drmClose(fd);
+	}
+
+	(void)XF86DRICloseConnection(dpy, scrn);
+
+	if ( err_extra != NULL ) {
+	    fprintf(stderr, "libGL error: %s failed (%s)\n", err_msg,
+		    err_extra);
+	}
+	else {
+	    fprintf(stderr, "libGL error: %s failed\n", err_msg );
+	}
+
+        fprintf(stderr, "libGL error: reverting to (slow) indirect rendering\n");
+    }
+#endif /* !GLX_USE_APPLEGL */
+
+    return psp;
+}
+#endif /* GLX_DIRECT_RENDERING */
+
+
+/*
+** Allocate the memory for the per screen configs for each screen.
+** If that works then fetch the per screen configs data.
+*/
+static Bool AllocAndFetchScreenConfigs(Display *dpy, __GLXdisplayPrivate *priv)
+{
+    xGLXGetVisualConfigsReq *req;
+    xGLXGetFBConfigsReq *fb_req;
+    xGLXVendorPrivateWithReplyReq *vpreq;
+    xGLXGetFBConfigsSGIXReq *sgi_req;
+    xGLXGetVisualConfigsReply reply;
+    __GLXscreenConfigs *psc;
+    __GLcontextModes *config;
+    GLint i, j, nprops, screens;
+    INT32 buf[__GLX_TOTAL_CONFIG], *props;
+    unsigned supported_request = 0;
+    unsigned prop_size;
+
+    /*
+    ** First allocate memory for the array of per screen configs.
+    */
+    screens = ScreenCount(dpy);
+    psc = (__GLXscreenConfigs*) Xmalloc(screens * sizeof(__GLXscreenConfigs));
+    if (!psc) {
+	return GL_FALSE;
+    }
+    memset(psc, 0, screens * sizeof(__GLXscreenConfigs));
+    priv->screenConfigs = psc;
+    
+    priv->serverGLXversion = __glXGetStringFromServer(dpy, priv->majorOpcode,
+					 X_GLXQueryServerString,
+					 0, GLX_VERSION);
+    if ( priv->serverGLXversion == NULL ) {
+	FreeScreenConfigs(priv);
+	return GL_FALSE;
+    }
+
+    if ( atof( priv->serverGLXversion ) >= 1.3 ) {
+	supported_request = 1;
+    }
+
+    /*
+    ** Now fetch each screens configs structures.  If a screen supports
+    ** GL (by returning a numVisuals > 0) then allocate memory for our
+    ** config structure and then fill it in.
+    */
+    for (i = 0; i < screens; i++, psc++) {
+	if ( supported_request != 1 ) {
+	    psc->serverGLXexts = __glXGetStringFromServer(dpy, priv->majorOpcode,
+							  X_GLXQueryServerString,
+							  i, GLX_EXTENSIONS);
+	    if ( strstr( psc->serverGLXexts, "GLX_SGIX_fbconfig" ) != NULL ) {
+		supported_request = 2;
+	    }
+	    else {
+		supported_request = 3;
+	    }
+	}
+
+
+	LockDisplay(dpy);
+	switch( supported_request ) {
+	    case 1:
+	    GetReq(GLXGetFBConfigs,fb_req);
+	    fb_req->reqType = priv->majorOpcode;
+	    fb_req->glxCode = X_GLXGetFBConfigs;
+	    fb_req->screen = i;
+	    break;
+	   
+	    case 2:
+	    GetReqExtra(GLXVendorPrivateWithReply,
+			sz_xGLXGetFBConfigsSGIXReq-sz_xGLXVendorPrivateWithReplyReq,vpreq);
+	    sgi_req = (xGLXGetFBConfigsSGIXReq *) vpreq;
+	    sgi_req->reqType = priv->majorOpcode;
+	    sgi_req->glxCode = X_GLXVendorPrivateWithReply;
+	    sgi_req->vendorCode = X_GLXvop_GetFBConfigsSGIX;
+	    sgi_req->screen = i;
+	    break;
+
+	    case 3:
+	    GetReq(GLXGetVisualConfigs,req);
+	    req->reqType = priv->majorOpcode;
+	    req->glxCode = X_GLXGetVisualConfigs;
+	    req->screen = i;
+	    break;
+ 	}
+
+	if (!_XReply(dpy, (xReply*) &reply, 0, False)) {
+	    /* Something is busted. Punt. */
+	    UnlockDisplay(dpy);
+	    FreeScreenConfigs(priv);
+	    return GL_FALSE;
+	}
+
+	UnlockDisplay(dpy);
+	if (!reply.numVisuals) {
+	    /* This screen does not support GL rendering */
+	    UnlockDisplay(dpy);
+	    continue;
+	}
+
+	/* FIXME: Is the __GLX_MIN_CONFIG_PROPS test correct for
+	 * FIXME: FBconfigs? 
+	 */
+	/* Check number of properties */
+	nprops = reply.numProps;
+	if ((nprops < __GLX_MIN_CONFIG_PROPS) ||
+	    (nprops > __GLX_MAX_CONFIG_PROPS)) {
+	    /* Huh?  Not in protocol defined limits.  Punt */
+	    UnlockDisplay(dpy);
+	    SyncHandle();
+	    FreeScreenConfigs(priv);
+	    return GL_FALSE;
+	}
+
+	/* Allocate memory for our config structure */
+	psc->configs = _gl_context_modes_create(reply.numVisuals,
+						sizeof(__GLcontextModes));
+	if (!psc->configs) {
+	    UnlockDisplay(dpy);
+	    SyncHandle();
+	    FreeScreenConfigs(priv);
+	    return GL_FALSE;
+	}
+
+	/* Allocate memory for the properties, if needed */
+	if ( supported_request != 3 ) {
+	    nprops *= 2;
+	}
+
+	prop_size = nprops * __GLX_SIZE_INT32;
+
+	if (prop_size <= sizeof(buf)) {
+ 	    props = buf;
+ 	} else {
+	    props = (INT32 *) Xmalloc(prop_size);
+ 	} 
+
+	/* Read each config structure and convert it into our format */
+        config = psc->configs;
+	for (j = 0; j < reply.numVisuals; j++) {
+	    assert( config != NULL );
+	    _XRead(dpy, (char *)props, prop_size);
+
+	    if ( supported_request != 3 ) {
+		config->rgbMode = GL_TRUE;
+		config->drawableType = GLX_WINDOW_BIT;
+	    }
+	    else {
+		config->drawableType = GLX_WINDOW_BIT | GLX_PIXMAP_BIT;
+	    }
+
+	    __glXInitializeVisualConfigFromTags( config, nprops, props,
+						 (supported_request != 3),
+						 GL_TRUE );
+	    if ( config->fbconfigID == GLX_DONT_CARE ) {
+		config->fbconfigID = config->visualID;
+	    }
+	    config->screen = i;
+	    config = config->next;
+	}
+	if (props != buf) {
+	    Xfree((char *)props);
+	}
+	UnlockDisplay(dpy);
+
+#ifdef GLX_DIRECT_RENDERING
+        /* Initialize per screen dynamic client GLX extensions */
+	psc->ext_list_first_time = GL_TRUE;
+	/* Initialize the direct rendering per screen data and functions */
+	if (priv->driDisplay.private != NULL) {
+	    /* FIXME: Should it be some sort of an error if createNewScreen[i]
+	     * FIXME: is NULL?
+	     */
+	    if (priv->driDisplay.createNewScreen &&
+		priv->driDisplay.createNewScreen[i]) {
+
+		psc->driScreen.screenConfigs = (void *)psc;
+		psc->driScreen.private =
+		    CallCreateNewScreen(dpy, i, & psc->driScreen,
+					& priv->driDisplay,
+					priv->driDisplay.createNewScreen[i] );
+	    }
+	}
+#endif
+    }
+    SyncHandle();
+    return GL_TRUE;
+}
+
+/*
+** Initialize the client side extension code.
+*/
+__GLXdisplayPrivate *__glXInitialize(Display* dpy)
+{
+    XExtDisplayInfo *info = __glXFindDisplay(dpy);
+    XExtData **privList, *private, *found;
+    __GLXdisplayPrivate *dpyPriv;
+    XEDataObject dataObj;
+    int major, minor;
+
+#if defined(USE_XTHREADS)
+    {
+        static int firstCall = 1;
+        if (firstCall) {
+            /* initialize the GLX mutexes */
+            xmutex_init(&__glXmutex);
+            firstCall = 0;
+        }
+    }
+#endif
+
+    INIT_MESA_SPARC
+    /* The one and only long long lock */
+    __glXLock();
+
+    if (!XextHasExtension(info)) {
+	/* No GLX extension supported by this server. Oh well. */
+	__glXUnlock();
+	XMissingExtension(dpy, __glXExtensionName);
+	return 0;
+    }
+
+    /* See if a display private already exists.  If so, return it */
+    dataObj.display = dpy;
+    privList = XEHeadOfExtensionList(dataObj);
+    found = XFindOnExtensionList(privList, info->codes->extension);
+    if (found) {
+	__glXUnlock();
+	return (__GLXdisplayPrivate *) found->private_data;
+    }
+
+    /* See if the versions are compatible */
+    if (!QueryVersion(dpy, info->codes->major_opcode, &major, &minor)) {
+	/* The client and server do not agree on versions.  Punt. */
+	__glXUnlock();
+	return 0;
+    }
+
+    /*
+    ** Allocate memory for all the pieces needed for this buffer.
+    */
+    private = (XExtData *) Xmalloc(sizeof(XExtData));
+    if (!private) {
+	__glXUnlock();
+	return 0;
+    }
+    dpyPriv = (__GLXdisplayPrivate *) Xmalloc(sizeof(__GLXdisplayPrivate));
+    if (!dpyPriv) {
+	__glXUnlock();
+	Xfree((char*) private);
+	return 0;
+    }
+
+    /*
+    ** Init the display private and then read in the screen config
+    ** structures from the server.
+    */
+    dpyPriv->majorOpcode = info->codes->major_opcode;
+    dpyPriv->majorVersion = major;
+    dpyPriv->minorVersion = minor;
+    dpyPriv->dpy = dpy;
+
+    dpyPriv->serverGLXvendor = 0x0; 
+    dpyPriv->serverGLXversion = 0x0;
+
+#ifdef GLX_DIRECT_RENDERING
+    /*
+    ** Initialize the direct rendering per display data and functions.
+    ** Note: This _must_ be done before calling any other DRI routines
+    ** (e.g., those called in AllocAndFetchScreenConfigs).
+    */
+    if (getenv("LIBGL_ALWAYS_INDIRECT")) {
+        /* Assinging zero here assures we'll never go direct */
+        dpyPriv->driDisplay.private = 0;
+        dpyPriv->driDisplay.destroyDisplay = 0;
+    }
+    else {
+        dpyPriv->driDisplay.private =
+            driCreateDisplay(dpy, &dpyPriv->driDisplay);
+    }
+#endif
+
+    if (!AllocAndFetchScreenConfigs(dpy, dpyPriv)) {
+	__glXUnlock();
+	Xfree((char*) dpyPriv);
+	Xfree((char*) private);
+	return 0;
+    }
+
+    /*
+    ** Fill in the private structure.  This is the actual structure that
+    ** hangs off of the Display structure.  Our private structure is
+    ** referred to by this structure.  Got that?
+    */
+    private->number = info->codes->extension;
+    private->next = 0;
+    private->free_private = __glXFreeDisplayPrivate;
+    private->private_data = (char *) dpyPriv;
+    XAddToExtensionList(privList, private);
+
+    if (dpyPriv->majorVersion == 1 && dpyPriv->minorVersion >= 1) {
+        __glXClientInfo(dpy, dpyPriv->majorOpcode);
+    }
+    __glXUnlock();
+
+    return dpyPriv;
+}
+
+/*
+** Setup for sending a GLX command on dpy.  Make sure the extension is
+** initialized.  Try to avoid calling __glXInitialize as its kinda slow.
+*/
+CARD8 __glXSetupForCommand(Display *dpy)
+{
+    GLXContext gc;
+    __GLXdisplayPrivate *priv;
+
+    /* If this thread has a current context, flush its rendering commands */
+    gc = __glXGetCurrentContext();
+    if (gc->currentDpy) {
+	/* Flush rendering buffer of the current context, if any */
+	(void) __glXFlushRenderBuffer(gc, gc->pc);
+
+	if (gc->currentDpy == dpy) {
+	    /* Use opcode from gc because its right */
+	    INIT_MESA_SPARC
+	    return gc->majorOpcode;
+	} else {
+	    /*
+	    ** Have to get info about argument dpy because it might be to
+	    ** a different server
+	    */
+	}
+    }
+
+    /* Forced to lookup extension via the slow initialize route */
+    priv = __glXInitialize(dpy);
+    if (!priv) {
+	return 0;
+    }
+    return priv->majorOpcode;
+}
+
+/**
+ * Flush the drawing command transport buffer.
+ * 
+ * \param ctx  Context whose transport buffer is to be flushed.
+ * \param pc   Pointer to first unused buffer location.
+ * 
+ * \todo
+ * Modify this function to use \c ctx->pc instead of the explicit
+ * \c pc parameter.
+ */
+GLubyte *__glXFlushRenderBuffer(__GLXcontext *ctx, GLubyte *pc)
+{
+    Display * const dpy = ctx->currentDpy;
+#ifdef USE_XCB
+    XCBConnection *c = XCBConnectionOfDisplay(dpy);
+#else
+    xGLXRenderReq *req;
+#endif /* USE_XCB */
+    const GLint size = pc - ctx->buf;
+
+    if ( (dpy != NULL) && (size > 0) ) {
+#ifdef USE_XCB
+	XCBGlxRender(c, ctx->currentContextTag, size, (char *)ctx->buf);
+#else
+	/* Send the entire buffer as an X request */
+	LockDisplay(dpy);
+	GetReq(GLXRender,req); 
+	req->reqType = ctx->majorOpcode;
+	req->glxCode = X_GLXRender; 
+	req->contextTag = ctx->currentContextTag;
+	req->length += (size + 3) >> 2;
+	_XSend(dpy, (char *)ctx->buf, size);
+	UnlockDisplay(dpy);
+	SyncHandle();
+#endif
+    }
+
+    /* Reset pointer and return it */
+    ctx->pc = ctx->buf;
+    return ctx->pc;
+}
+
+
+/**
+ * Send a portion of a GLXRenderLarge command to the server.  The advantage of
+ * this function over \c __glXSendLargeCommand is that callers can use the
+ * data buffer in the GLX context and may be able to avoid allocating an
+ * extra buffer.  The disadvantage is the clients will have to do more
+ * GLX protocol work (i.e., calculating \c totalRequests, etc.).
+ *
+ * \sa __glXSendLargeCommand
+ *
+ * \param gc             GLX context
+ * \param requestNumber  Which part of the whole command is this?  The first
+ *                       request is 1.
+ * \param totalRequests  How many requests will there be?
+ * \param data           Command data.
+ * \param dataLen        Size, in bytes, of the command data.
+ */
+void __glXSendLargeChunk(__GLXcontext *gc, GLint requestNumber, 
+			 GLint totalRequests,
+			 const GLvoid * data, GLint dataLen)
+{
+    Display *dpy = gc->currentDpy;
+#ifdef USE_XCB
+    XCBConnection *c = XCBConnectionOfDisplay(dpy);
+    XCBGlxRenderLarge(c, gc->currentContextTag, requestNumber, totalRequests, dataLen, data);
+#else
+    xGLXRenderLargeReq *req;
+    
+    if ( requestNumber == 1 ) {
+	LockDisplay(dpy);
+    }
+
+    GetReq(GLXRenderLarge,req); 
+    req->reqType = gc->majorOpcode;
+    req->glxCode = X_GLXRenderLarge; 
+    req->contextTag = gc->currentContextTag;
+    req->length += (dataLen + 3) >> 2;
+    req->requestNumber = requestNumber;
+    req->requestTotal = totalRequests;
+    req->dataBytes = dataLen;
+    Data(dpy, data, dataLen);
+
+    if ( requestNumber == totalRequests ) {
+	UnlockDisplay(dpy);
+	SyncHandle();
+    }
+#endif /* USE_XCB */
+}
+
+
+/**
+ * Send a command that is too large for the GLXRender protocol request.
+ * 
+ * Send a large command, one that is too large for some reason to
+ * send using the GLXRender protocol request.  One reason to send
+ * a large command is to avoid copying the data.
+ * 
+ * \param ctx        GLX context
+ * \param header     Header data.
+ * \param headerLen  Size, in bytes, of the header data.  It is assumed that
+ *                   the header data will always be small enough to fit in
+ *                   a single X protocol packet.
+ * \param data       Command data.
+ * \param dataLen    Size, in bytes, of the command data.
+ */
+void __glXSendLargeCommand(__GLXcontext *ctx,
+			   const GLvoid *header, GLint headerLen,
+			   const GLvoid *data, GLint dataLen)
+{
+    GLint maxSize;
+    GLint totalRequests, requestNumber;
+
+    /*
+    ** Calculate the maximum amount of data can be stuffed into a single
+    ** packet.  sz_xGLXRenderReq is added because bufSize is the maximum
+    ** packet size minus sz_xGLXRenderReq.
+    */
+    maxSize = (ctx->bufSize + sz_xGLXRenderReq) - sz_xGLXRenderLargeReq;
+    totalRequests = 1 + (dataLen / maxSize);
+    if (dataLen % maxSize) totalRequests++;
+
+    /*
+    ** Send all of the command, except the large array, as one request.
+    */
+    assert( headerLen <= maxSize );
+    __glXSendLargeChunk(ctx, 1, totalRequests, header, headerLen);
+
+    /*
+    ** Send enough requests until the whole array is sent.
+    */
+    for ( requestNumber = 2 ; requestNumber <= (totalRequests - 1) ; requestNumber++ ) {
+	__glXSendLargeChunk(ctx, requestNumber, totalRequests, data, maxSize);
+	data = (const GLvoid *) (((const GLubyte *) data) + maxSize);
+	dataLen -= maxSize;
+	assert( dataLen > 0 );
+    }
+
+    assert( dataLen <= maxSize );
+    __glXSendLargeChunk(ctx, requestNumber, totalRequests, data, dataLen);
+}
+
+/************************************************************************/
+
+GLXContext glXGetCurrentContext(void)
+{
+    GLXContext cx = __glXGetCurrentContext();
+    
+    if (cx == &dummyContext) {
+	return NULL;
+    } else {
+	return cx;
+    }
+}
+
+GLXDrawable glXGetCurrentDrawable(void)
+{
+    GLXContext gc = __glXGetCurrentContext();
+    return gc->currentDrawable;
+}
+
+
+/************************************************************************/
+
+#ifdef GLX_DIRECT_RENDERING
+/* Return the DRI per screen structure */
+__DRIscreen *__glXFindDRIScreen(__DRInativeDisplay *dpy, int scrn)
+{
+    __DRIscreen *pDRIScreen = NULL;
+    XExtDisplayInfo *info = __glXFindDisplay(dpy);
+    XExtData **privList, *found;
+    __GLXdisplayPrivate *dpyPriv;
+    XEDataObject dataObj;
+
+    __glXLock();
+    dataObj.display = dpy;
+    privList = XEHeadOfExtensionList(dataObj);
+    found = XFindOnExtensionList(privList, info->codes->extension);
+    __glXUnlock();
+
+    if (found) {
+	dpyPriv = (__GLXdisplayPrivate *)found->private_data;
+	pDRIScreen = &dpyPriv->screenConfigs[scrn].driScreen;
+    }
+
+    return pDRIScreen;
+}
+#endif
+
+/************************************************************************/
+
+static Bool SendMakeCurrentRequest( Display *dpy, CARD8 opcode,
+    GLXContextID gc, GLXContextTag old_gc, GLXDrawable draw, GLXDrawable read,
+    xGLXMakeCurrentReply * reply );
+
+/**
+ * Sends a GLX protocol message to the specified display to make the context
+ * and the drawables current.
+ *
+ * \param dpy     Display to send the message to.
+ * \param opcode  Major opcode value for the display.
+ * \param gc_id   Context tag for the context to be made current.
+ * \param draw    Drawable ID for the "draw" drawable.
+ * \param read    Drawable ID for the "read" drawable.
+ * \param reply   Space to store the X-server's reply.
+ *
+ * \warning
+ * This function assumes that \c dpy is locked with \c LockDisplay on entry.
+ */
+static Bool SendMakeCurrentRequest( Display *dpy, CARD8 opcode,
+				    GLXContextID gc_id, GLXContextTag gc_tag,
+				    GLXDrawable draw, GLXDrawable read,
+				    xGLXMakeCurrentReply * reply )
+{
+    if ( draw == read ) {
+	xGLXMakeCurrentReq *req;
+
+	GetReq(GLXMakeCurrent,req);
+	req->reqType = opcode;
+	req->glxCode = X_GLXMakeCurrent;
+	req->drawable = draw;
+	req->context = gc_id;
+	req->oldContextTag = gc_tag;
+    }
+    else {
+	__GLXdisplayPrivate *priv = __glXInitialize(dpy);
+
+	/* If the server can support the GLX 1.3 version, we should
+	 * perfer that.  Not only that, some servers support GLX 1.3 but
+	 * not the SGI extension.
+	 */
+
+	if ( (priv->majorVersion > 1) || (priv->minorVersion >= 3) ) {
+	    xGLXMakeContextCurrentReq *req;
+
+	    GetReq(GLXMakeContextCurrent,req);
+	    req->reqType = opcode;
+	    req->glxCode = X_GLXMakeContextCurrent;
+	    req->drawable = draw;
+	    req->readdrawable = read;
+	    req->context = gc_id;
+	    req->oldContextTag = gc_tag;
+	}
+	else {
+	    xGLXVendorPrivateWithReplyReq *vpreq;
+	    xGLXMakeCurrentReadSGIReq *req;
+
+	    GetReqExtra(GLXVendorPrivateWithReply,
+			sz_xGLXMakeCurrentReadSGIReq-sz_xGLXVendorPrivateWithReplyReq,vpreq);
+	    req = (xGLXMakeCurrentReadSGIReq *)vpreq;
+	    req->reqType = opcode;
+	    req->glxCode = X_GLXVendorPrivateWithReply;
+	    req->vendorCode = X_GLXvop_MakeCurrentReadSGI;
+	    req->drawable = draw;
+	    req->readable = read;
+	    req->context = gc_id;
+	    req->oldContextTag = gc_tag;
+	}
+    }
+
+    return _XReply(dpy, (xReply*) reply, 0, False);
+}
+
+
+#ifdef GLX_DIRECT_RENDERING
+static Bool BindContextWrapper( Display *dpy, GLXContext gc,
+				GLXDrawable draw, GLXDrawable read )
+{
+    return (*gc->driContext.bindContext)(dpy, gc->screen, draw, read,
+					 & gc->driContext);
+}
+
+
+static Bool UnbindContextWrapper( GLXContext gc )
+{
+    return (*gc->driContext.unbindContext)(gc->currentDpy, gc->screen, 
+					   gc->currentDrawable,
+					   gc->currentReadable,
+					   & gc->driContext );
+}
+#endif /* GLX_DIRECT_RENDERING */
+
+
+/*
+** Make a particular context current.
+** NOTE: this is in this file so that it can access dummyContext.
+*/
+USED static Bool MakeContextCurrent(Display *dpy, GLXDrawable draw,
+                                    GLXDrawable read, GLXContext gc)
+{
+    xGLXMakeCurrentReply reply;
+    GLXContext oldGC;
+    CARD8 opcode, oldOpcode;
+    Bool sentRequestToOldDpy = False;
+    Bool bindReturnValue = True;
+
+    opcode = __glXSetupForCommand(dpy);
+    if (!opcode) {
+	return GL_FALSE;
+    }
+
+    /*
+    ** Make sure that the new context has a nonzero ID.  In the request,
+    ** a zero context ID is used only to mean that we bind to no current
+    ** context.
+    */
+    if ((gc != NULL) && (gc->xid == None)) {
+	return GL_FALSE;
+    }
+
+    oldGC = __glXGetCurrentContext();
+    oldOpcode = (gc == oldGC) ? opcode : __glXSetupForCommand(dpy);
+    if (!oldOpcode) {
+	return GL_FALSE;
+    }
+
+    if ((dpy != oldGC->currentDpy || (gc && gc->isDirect)) &&
+	!oldGC->isDirect && oldGC != &dummyContext) {
+	/*
+	** We are either switching from one dpy to another and have to
+	** send a request to the previous dpy to unbind the previous
+	** context, or we are switching away from a indirect context to
+	** a direct context and have to send a request to the dpy to
+	** unbind the previous context.
+	*/
+	sentRequestToOldDpy = True;
+        LockDisplay(oldGC->currentDpy);
+	if ( ! SendMakeCurrentRequest( oldGC->currentDpy, oldOpcode, None,
+				       oldGC->currentContextTag, None, None,
+				       &reply ) ) {
+	    /* The make current failed.  Just return GL_FALSE. */
+	    UnlockDisplay(oldGC->currentDpy);
+	    SyncHandle();
+	    return GL_FALSE;
+	}
+
+	oldGC->currentContextTag = 0;
+    }
+
+    _glapi_check_multithread();
+
+#ifdef GLX_DIRECT_RENDERING
+    /* Unbind the old direct rendering context */
+    if (oldGC->isDirect) {
+	if (oldGC->driContext.private) {
+	    if (! UnbindContextWrapper( oldGC )) {
+		/* The make current failed.  Just return GL_FALSE. */
+		return GL_FALSE;
+	    }
+	}
+	oldGC->currentContextTag = 0;
+    }
+
+    /* Bind the direct rendering context to the drawable */
+    if (gc && gc->isDirect) {
+	if (gc->driContext.private) {
+	    bindReturnValue = BindContextWrapper( dpy, gc, draw, read );
+	}
+    } else {
+#endif
+	/* Send a glXMakeCurrent request to bind the new context. */
+	LockDisplay(dpy);
+
+	bindReturnValue = SendMakeCurrentRequest( dpy, opcode, 
+						  gc ? gc->xid : None,
+						  oldGC->currentContextTag,
+						  draw, read, &reply );
+	UnlockDisplay(dpy);
+#ifdef GLX_DIRECT_RENDERING
+    }
+#endif
+
+
+    if (!bindReturnValue) {
+	/* The make current failed. */
+	if (gc && !gc->isDirect) {
+	    SyncHandle();
+	}
+
+#ifdef GLX_DIRECT_RENDERING
+	/* If the old context was direct rendering, then re-bind to it. */
+	if (oldGC->isDirect) {
+	    if (oldGC->driContext.private) {
+		if (! BindContextWrapper( oldGC->currentDpy, oldGC,
+					  oldGC->currentDrawable,
+					  oldGC->currentReadable )) {
+		    /*
+		    ** The request failed; this cannot happen with the
+		    ** current API.  If in the future the API is
+		    ** extended to allow context sharing between
+		    ** clients, then this may fail (because another
+		    ** client may have grabbed the context); in that
+		    ** case, we cannot undo the previous request, and
+		    ** cannot adhere to the "no-op" behavior.
+		    */
+		}
+	    }
+	} else
+#endif
+	/*
+	** If we had just sent a request to a previous dpy, we have to
+	** undo that request (because if a command fails, it should act
+	** like a no-op) by making current to the previous context and
+	** drawable.
+	*/
+	if (sentRequestToOldDpy) {
+	    if ( !SendMakeCurrentRequest( oldGC->currentDpy, oldOpcode,
+					  oldGC->xid, 0, 
+					  oldGC->currentDrawable,
+					  oldGC->currentReadable, &reply ) ) {
+		UnlockDisplay(oldGC->currentDpy);
+		SyncHandle();
+		/*
+		** The request failed; this cannot happen with the
+		** current API.  If in the future the API is extended to
+		** allow context sharing between clients, then this may
+		** fail (because another client may have grabbed the
+		** context); in that case, we cannot undo the previous
+		** request, and cannot adhere to the "no-op" behavior.
+		*/
+	    }
+            else {
+		UnlockDisplay(oldGC->currentDpy);
+            }
+	    oldGC->currentContextTag = reply.contextTag;
+	}
+	return GL_FALSE;
+    }
+
+    /* Update our notion of what is current */
+    __glXLock();
+    if (gc == oldGC) {
+	/*
+	** Even though the contexts are the same the drawable might have
+	** changed.  Note that gc cannot be the dummy, and that oldGC
+	** cannot be NULL, therefore if they are the same, gc is not
+	** NULL and not the dummy.
+	*/
+	gc->currentDrawable = draw;
+	gc->currentReadable = read;
+    } else {
+	if (oldGC != &dummyContext) {
+	    /* Old current context is no longer current to anybody */
+	    oldGC->currentDpy = 0;
+	    oldGC->currentDrawable = None;
+	    oldGC->currentReadable = None;
+	    oldGC->currentContextTag = 0;
+
+	    if (oldGC->xid == None) {
+		/* 
+		** We are switching away from a context that was
+		** previously destroyed, so we need to free the memory
+		** for the old handle.
+		*/
+#ifdef GLX_DIRECT_RENDERING
+		/* Destroy the old direct rendering context */
+		if (oldGC->isDirect) {
+		    if (oldGC->driContext.private) {
+			(*oldGC->driContext.destroyContext)
+			    (dpy, oldGC->screen, oldGC->driContext.private);
+			oldGC->driContext.private = NULL;
+		    }
+		}
+#endif
+		__glXFreeContext(oldGC);
+	    }
+	}
+	if (gc) {
+	    __glXSetCurrentContext(gc);
+#ifdef GLX_DIRECT_RENDERING
+            if (!gc->isDirect) {
+               if (!IndirectAPI)
+                  IndirectAPI = __glXNewIndirectAPI();
+               _glapi_set_dispatch(IndirectAPI);
+# ifdef GLX_USE_APPLEGL
+               do {
+                   extern void XAppleDRIUseIndirectDispatch(void);
+                   XAppleDRIUseIndirectDispatch();
+               } while (0);
+# endif
+            }
+#else
+            /* if not direct rendering, always need indirect dispatch */
+            if (!IndirectAPI)
+               IndirectAPI = __glXNewIndirectAPI();
+            _glapi_set_dispatch(IndirectAPI);
+#endif
+	    gc->currentDpy = dpy;
+	    gc->currentDrawable = draw;
+	    gc->currentReadable = read;
+
+	    if ( ! gc->isDirect ) {
+		__GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+
+		gc->currentContextTag = reply.contextTag;
+		if ( state->array_state == NULL ) {
+		    (void) glGetString( GL_EXTENSIONS );
+		    (void) glGetString( GL_VERSION );
+		    __glXInitVertexArrayState(gc);
+		}
+	    }
+	    else {
+		gc->currentContextTag = -1;
+	    }
+	} else {
+	    __glXSetCurrentContext(&dummyContext);
+#ifdef GLX_DIRECT_RENDERING
+            _glapi_set_dispatch(NULL);  /* no-op functions */
+#endif
+	}
+    }
+    __glXUnlock();
+    return GL_TRUE;
+}
+
+
+PUBLIC Bool glXMakeCurrent(Display *dpy, GLXDrawable draw, GLXContext gc)
+{
+    return MakeContextCurrent( dpy, draw, draw, gc );
+}
+
+PUBLIC GLX_ALIAS(Bool, glXMakeCurrentReadSGI,
+	  (Display *dpy, GLXDrawable d, GLXDrawable r, GLXContext ctx),
+	  (dpy, d, r, ctx), MakeContextCurrent)
+
+PUBLIC GLX_ALIAS(Bool, glXMakeContextCurrent,
+	  (Display *dpy, GLXDrawable d, GLXDrawable r, GLXContext ctx),
+	  (dpy, d, r, ctx), MakeContextCurrent)
+
+
+#ifdef DEBUG
+void __glXDumpDrawBuffer(__GLXcontext *ctx)
+{
+    GLubyte *p = ctx->buf;
+    GLubyte *end = ctx->pc;
+    GLushort opcode, length;
+
+    while (p < end) {
+	/* Fetch opcode */
+	opcode = *((GLushort*) p);
+	length = *((GLushort*) (p + 2));
+	printf("%2x: %5d: ", opcode, length);
+	length -= 4;
+	p += 4;
+	while (length > 0) {
+	    printf("%08x ", *((unsigned *) p));
+	    p += 4;
+	    length -= 4;
+	}
+	printf("\n");
+    }	    
+}
+#endif
+
+#ifdef  USE_SPARC_ASM
+/*
+ * Used only when we are sparc, using sparc assembler.
+ *
+ */
+
+static void
+_glx_mesa_init_sparc_glapi_relocs(void)
+{
+	unsigned int *insn_ptr, *end_ptr;
+	unsigned long disp_addr;
+
+	insn_ptr = &_mesa_sparc_glapi_begin;
+	end_ptr = &_mesa_sparc_glapi_end;
+	disp_addr = (unsigned long) &_glapi_Dispatch;
+
+	/*
+         * Verbatim from Mesa sparc.c.  It's needed because there doesn't
+         * seem to be a better way to do this:
+         *
+         * UNCONDITIONAL_JUMP ( (*_glapi_Dispatch) + entry_offset )
+         *
+         * This code is patching in the ADDRESS of the pointer to the
+         * dispatch table.  Hence, it must be called exactly once, because
+         * that address is not going to change.
+         *
+         * What it points to can change, but Mesa (and hence, we) assume
+         * that there is only one pointer.
+         *
+	 */
+	while (insn_ptr < end_ptr) {
+#if ( defined(__sparc_v9__) && ( !defined(__linux__) || defined(__linux_64__) ) )	
+/*
+	This code patches for 64-bit addresses.  This had better
+	not happen for Sparc/Linux, no matter what architecture we
+	are building for.  So, don't do this.
+
+        The 'defined(__linux_64__)' is used here as a placeholder for
+        when we do do 64-bit usermode on sparc linux.
+	*/
+		insn_ptr[0] |= (disp_addr >> (32 + 10));
+		insn_ptr[1] |= ((disp_addr & 0xffffffff) >> 10);
+		__glapi_sparc_icache_flush(&insn_ptr[0]);
+		insn_ptr[2] |= ((disp_addr >> 32) & ((1 << 10) - 1));
+		insn_ptr[3] |= (disp_addr & ((1 << 10) - 1));
+		__glapi_sparc_icache_flush(&insn_ptr[2]);
+		insn_ptr += 11;
+#else
+		insn_ptr[0] |= (disp_addr >> 10);
+		insn_ptr[1] |= (disp_addr & ((1 << 10) - 1));
+		__glapi_sparc_icache_flush(&insn_ptr[0]);
+		insn_ptr += 5;
+#endif
+	}
+}
+#endif  /* sparc ASM in use */
+
diff --git a/src/glx/x11/glxextensions.c b/src/glx/x11/glxextensions.c
new file mode 100644
index 00000000000..d2597981cf3
--- /dev/null
+++ b/src/glx/x11/glxextensions.c
@@ -0,0 +1,717 @@
+/*
+ * (C) Copyright IBM Corporation 2002, 2004
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on 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
+ * THE COPYRIGHT HOLDERS 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.
+ */
+
+/**
+ * \file glxextensions.c
+ *
+ * \author Ian Romanick <[email protected]>
+ */
+
+#include "glxclient.h"
+#include <X11/extensions/extutil.h>
+#include <X11/extensions/Xext.h>
+#include <string.h>
+#include "glapi.h"
+#include "glxextensions.h"
+#include "simple_list.h"
+
+#define SET_BIT(m,b)   (m[ (b) / 8 ] |=  (1U << ((b) % 8)))
+#define CLR_BIT(m,b)   (m[ (b) / 8 ] &= ~(1U << ((b) % 8)))
+#define IS_SET(m,b)    ((m[ (b) / 8 ] & (1U << ((b) % 8))) != 0)
+#define CONCAT(a,b) a ## b
+#define GLX(n) "GLX_" # n, 4 + sizeof( # n ) - 1, CONCAT(n,_bit)
+#define GL(n)  "GL_" # n,  3 + sizeof( # n ) - 1, GL_ ## n ## _bit
+#define VER(a,b)  a, b
+#define Y  1
+#define N  0
+#define EXT_ENABLED(bit,supported) (IS_SET( supported, bit ))
+
+
+struct extension_info {
+   const char * const name;
+   unsigned   name_len;
+
+   unsigned char  bit;
+
+   /* This is the lowest version of GLX that "requires" this extension.
+    * For example, GLX 1.3 requires SGIX_fbconfig, SGIX_pbuffer, and
+    * SGI_make_current_read.  If the extension is not required by any known
+    * version of GLX, use 0, 0.
+    */
+   unsigned char  version_major;
+   unsigned char  version_minor;
+   unsigned char  client_support;
+   unsigned char  direct_support;
+   unsigned char  client_only;       /** Is the extension client-side only? */
+   unsigned char  direct_only;       /** Is the extension for direct
+				      * contexts only?
+				      */
+};
+
+static const struct extension_info known_glx_extensions[] = {
+   { GLX(ARB_get_proc_address),        VER(1,4), Y, N, Y, N },
+   { GLX(ARB_multisample),             VER(1,4), Y, Y, N, N },
+   { GLX(ARB_render_texture),          VER(0,0), N, N, N, N },
+   { GLX(ATI_pixel_format_float),      VER(0,0), N, N, N, N },
+   { GLX(EXT_import_context),          VER(0,0), Y, Y, N, N },
+   { GLX(EXT_visual_info),             VER(0,0), Y, Y, N, N },
+   { GLX(EXT_visual_rating),           VER(0,0), Y, Y, N, N },
+   { GLX(MESA_agp_offset),             VER(0,0), N, N, N, Y }, /* Deprecated */
+   { GLX(MESA_allocate_memory),        VER(0,0), Y, N, N, Y },
+   { GLX(MESA_copy_sub_buffer),        VER(0,0), N, N, N, N }, /* Deprecated? */
+   { GLX(MESA_pixmap_colormap),        VER(0,0), N, N, N, N }, /* Deprecated */
+   { GLX(MESA_release_buffers),        VER(0,0), N, N, N, N }, /* Deprecated */
+   { GLX(MESA_set_3dfx_mode),          VER(0,0), N, N, N, N }, /* Deprecated */
+   { GLX(MESA_swap_control),           VER(0,0), Y, N, N, Y },
+   { GLX(MESA_swap_frame_usage),       VER(0,0), Y, N, N, Y },
+   { GLX(NV_float_buffer),             VER(0,0), N, N, N, N },
+   { GLX(NV_render_depth_texture),     VER(0,0), N, N, N, N },
+   { GLX(NV_render_texture_rectangle), VER(0,0), N, N, N, N },
+   { GLX(NV_vertex_array_range),       VER(0,0), N, N, N, Y }, /* Deprecated */
+   { GLX(OML_swap_method),             VER(0,0), Y, Y, N, N },
+   { GLX(OML_sync_control),            VER(0,0), Y, N, N, Y },
+   { GLX(SGI_cushion),                 VER(0,0), N, N, N, N },
+   { GLX(SGI_make_current_read),       VER(1,3), Y, N, N, N },
+   { GLX(SGI_swap_control),            VER(0,0), Y, N, N, N },
+   { GLX(SGI_video_sync),              VER(0,0), Y, N, N, Y },
+   { GLX(SGIS_blended_overlay),        VER(0,0), N, N, N, N },
+   { GLX(SGIS_color_range),            VER(0,0), N, N, N, N },
+   { GLX(SGIS_multisample),            VER(0,0), Y, Y, N, N },
+   { GLX(SGIX_dm_buffer),              VER(0,0), N, N, N, N },
+   { GLX(SGIX_fbconfig),               VER(1,3), Y, Y, N, N },
+   { GLX(SGIX_pbuffer),                VER(1,3), Y, N, N, N },
+   { GLX(SGIX_swap_barrier),           VER(0,0), N, N, N, N },
+   { GLX(SGIX_swap_group),             VER(0,0), N, N, N, N },
+   { GLX(SGIX_video_resize),           VER(0,0), N, N, N, N },
+   { GLX(SGIX_video_source),           VER(0,0), N, N, N, N },
+   { GLX(SGIX_visual_select_group),    VER(0,0), Y, Y, N, N },
+   { GLX(SUN_get_transparent_index),   VER(0,0), N, N, N, N },
+   { NULL }
+};
+
+static const struct extension_info known_gl_extensions[] = {
+   { GL(ARB_depth_texture),              VER(1,4), Y, N, N, N },
+   { GL(ARB_draw_buffers),               VER(0,0), Y, N, N, N },
+   { GL(ARB_fragment_program),           VER(0,0), Y, N, N, N },
+   { GL(ARB_fragment_program_shadow),    VER(0,0), Y, N, N, N },
+   { GL(ARB_imaging),                    VER(0,0), Y, N, N, N },
+   { GL(ARB_multisample),                VER(1,3), Y, N, N, N },
+   { GL(ARB_multitexture),               VER(1,3), Y, N, N, N },
+   { GL(ARB_occlusion_query),            VER(1,5), Y, N, N, N },
+   { GL(ARB_point_parameters),           VER(1,4), Y, N, N, N },
+   { GL(ARB_point_sprite),               VER(0,0), Y, N, N, N },
+   { GL(ARB_shadow),                     VER(1,4), Y, N, N, N },
+   { GL(ARB_shadow_ambient),             VER(0,0), Y, N, N, N },
+   { GL(ARB_texture_border_clamp),       VER(1,3), Y, N, N, N },
+   { GL(ARB_texture_compression),        VER(1,3), Y, N, N, N },
+   { GL(ARB_texture_cube_map),           VER(1,3), Y, N, N, N },
+   { GL(ARB_texture_env_add),            VER(1,3), Y, N, N, N },
+   { GL(ARB_texture_env_combine),        VER(1,3), Y, N, N, N },
+   { GL(ARB_texture_env_crossbar),       VER(1,4), Y, N, N, N },
+   { GL(ARB_texture_env_dot3),           VER(1,3), Y, N, N, N },
+   { GL(ARB_texture_mirrored_repeat),    VER(1,4), Y, N, N, N },
+   { GL(ARB_texture_non_power_of_two),   VER(1,5), Y, N, N, N },
+   { GL(ARB_texture_rectangle),          VER(0,0), Y, N, N, N },
+   { GL(ARB_transpose_matrix),           VER(1,3), Y, N, Y, N },
+   { GL(ARB_vertex_buffer_object),       VER(1,5), N, N, N, N },
+   { GL(ARB_vertex_program),             VER(0,0), Y, N, N, N },
+   { GL(ARB_window_pos),                 VER(1,4), Y, N, N, N },
+   { GL(EXT_abgr),                       VER(0,0), Y, N, N, N },
+   { GL(EXT_bgra),                       VER(1,2), Y, N, N, N },
+   { GL(EXT_blend_color),                VER(1,4), Y, N, N, N },
+   { GL(EXT_blend_equation_separate),    VER(0,0), N, N, N, N },
+   { GL(EXT_blend_func_separate),        VER(1,4), Y, N, N, N },
+   { GL(EXT_blend_logic_op),             VER(1,4), Y, N, N, N },
+   { GL(EXT_blend_minmax),               VER(1,4), Y, N, N, N },
+   { GL(EXT_blend_subtract),             VER(1,4), Y, N, N, N },
+   { GL(EXT_clip_volume_hint),           VER(0,0), Y, N, N, N },
+   { GL(EXT_compiled_vertex_array),      VER(0,0), N, N, N, N },
+   { GL(EXT_convolution),                VER(0,0), N, N, N, N },
+   { GL(EXT_copy_texture),               VER(1,1), Y, N, N, N },
+   { GL(EXT_cull_vertex),                VER(0,0), N, N, N, N },
+   { GL(EXT_depth_bounds_test),          VER(0,0), N, N, N, N },
+   { GL(EXT_draw_range_elements),        VER(1,2), Y, N, Y, N },
+   { GL(EXT_fog_coord),                  VER(1,4), Y, N, N, N },
+   { GL(EXT_multi_draw_arrays),          VER(1,4), Y, N, Y, N },
+   { GL(EXT_packed_pixels),              VER(1,2), Y, N, N, N },
+   { GL(EXT_paletted_texture),           VER(0,0), Y, N, N, N },
+   { GL(EXT_pixel_buffer_object),        VER(0,0), N, N, N, N },
+   { GL(EXT_point_parameters),           VER(1,4), Y, N, N, N },
+   { GL(EXT_polygon_offset),             VER(1,1), Y, N, N, N },
+   { GL(EXT_rescale_normal),             VER(1,2), Y, N, N, N },
+   { GL(EXT_secondary_color),            VER(1,4), Y, N, N, N },
+   { GL(EXT_separate_specular_color),    VER(1,2), Y, N, N, N },
+   { GL(EXT_shadow_funcs),               VER(1,5), Y, N, N, N },
+   { GL(EXT_shared_texture_palette),     VER(0,0), Y, N, N, N },
+   { GL(EXT_stencil_two_side),           VER(0,0), Y, N, N, N },
+   { GL(EXT_stencil_wrap),               VER(1,4), Y, N, N, N },
+   { GL(EXT_subtexture),                 VER(1,1), Y, N, N, N },
+   { GL(EXT_texture),                    VER(1,1), Y, N, N, N },
+   { GL(EXT_texture3D),                  VER(1,2), Y, N, N, N },
+   { GL(EXT_texture_compression_dxt1),   VER(0,0), Y, N, N, N },
+   { GL(EXT_texture_compression_s3tc),   VER(0,0), Y, N, N, N },
+   { GL(EXT_texture_edge_clamp),         VER(1,2), Y, N, N, N },
+   { GL(EXT_texture_env_add),            VER(1,3), Y, N, N, N },
+   { GL(EXT_texture_env_combine),        VER(1,3), Y, N, N, N },
+   { GL(EXT_texture_env_dot3),           VER(0,0), Y, N, N, N },
+   { GL(EXT_texture_filter_anisotropic), VER(0,0), Y, N, N, N },
+   { GL(EXT_texture_lod),                VER(1,2), Y, N, N, N },
+   { GL(EXT_texture_lod_bias),           VER(1,4), Y, N, N, N },
+   { GL(EXT_texture_mirror_clamp),       VER(0,0), Y, N, N, N },
+   { GL(EXT_texture_object),             VER(1,1), Y, N, N, N },
+   { GL(EXT_texture_rectangle),          VER(0,0), Y, N, N, N },
+   { GL(EXT_vertex_array),               VER(0,0), Y, N, N, N },
+   { GL(3DFX_texture_compression_FXT1),  VER(0,0), Y, N, N, N },
+   { GL(APPLE_packed_pixels),            VER(1,2), Y, N, N, N },
+   { GL(APPLE_ycbcr_422),                VER(0,0), Y, N, N, N },
+   { GL(ATI_draw_buffers),               VER(0,0), Y, N, N, N },
+   { GL(ATI_text_fragment_shader),       VER(0,0), Y, N, N, N },
+   { GL(ATI_texture_env_combine3),       VER(0,0), Y, N, N, N },
+   { GL(ATI_texture_float),              VER(0,0), Y, N, N, N },
+   { GL(ATI_texture_mirror_once),        VER(0,0), Y, N, N, N },
+   { GL(ATIX_texture_env_combine3),      VER(0,0), Y, N, N, N },
+   { GL(HP_convolution_border_modes),    VER(0,0), Y, N, N, N },
+   { GL(HP_occlusion_test),              VER(0,0), Y, N, N, N },
+   { GL(IBM_cull_vertex),                VER(0,0), Y, N, N, N },
+   { GL(IBM_pixel_filter_hint),          VER(0,0), Y, N, N, N },
+   { GL(IBM_rasterpos_clip),             VER(0,0), Y, N, N, N },
+   { GL(IBM_texture_clamp_nodraw),       VER(0,0), Y, N, N, N },
+   { GL(IBM_texture_mirrored_repeat),    VER(0,0), Y, N, N, N },
+   { GL(INGR_blend_func_separate),       VER(0,0), Y, N, N, N },
+   { GL(INGR_interlace_read),            VER(0,0), Y, N, N, N },
+   { GL(MESA_pack_invert),               VER(0,0), Y, N, N, N },
+   { GL(MESA_ycbcr_texture),             VER(0,0), Y, N, N, N },
+   { GL(NV_blend_square),                VER(1,4), Y, N, N, N },
+   { GL(NV_copy_depth_to_color),         VER(0,0), Y, N, N, N },
+   { GL(NV_depth_clamp),                 VER(0,0), Y, N, N, N },
+   { GL(NV_fog_distance),                VER(0,0), Y, N, N, N },
+   { GL(NV_fragment_program),            VER(0,0), Y, N, N, N },
+   { GL(NV_fragment_program_option),     VER(0,0), Y, N, N, N },
+   { GL(NV_fragment_program2),           VER(0,0), Y, N, N, N },
+   { GL(NV_light_max_exponent),          VER(0,0), Y, N, N, N },
+   { GL(NV_multisample_filter_hint),     VER(0,0), Y, N, N, N },
+   { GL(NV_point_sprite),                VER(0,0), Y, N, N, N },
+   { GL(NV_texgen_reflection),           VER(0,0), Y, N, N, N },
+   { GL(NV_texture_compression_vtc),     VER(0,0), Y, N, N, N },
+   { GL(NV_texture_env_combine4),        VER(0,0), Y, N, N, N },
+   { GL(NV_texture_rectangle),           VER(0,0), Y, N, N, N },
+   { GL(NV_vertex_program),              VER(0,0), Y, N, N, N },
+   { GL(NV_vertex_program1_1),           VER(0,0), Y, N, N, N },
+   { GL(NV_vertex_program2),             VER(0,0), Y, N, N, N },
+   { GL(NV_vertex_program2_option),      VER(0,0), Y, N, N, N },
+   { GL(NV_vertex_program3),             VER(0,0), Y, N, N, N },
+   { GL(OES_read_format),                VER(0,0), Y, N, N, N },
+   { GL(OES_compressed_paletted_texture),VER(0,0), Y, N, N, N },
+   { GL(SGI_color_matrix),               VER(0,0), Y, N, N, N },
+   { GL(SGI_texture_color_table),        VER(0,0), Y, N, N, N },
+   { GL(SGIS_generate_mipmap),           VER(1,4), Y, N, N, N },
+   { GL(SGIS_multisample),               VER(0,0), Y, N, N, N },
+   { GL(SGIS_texture_border_clamp),      VER(1,3), Y, N, N, N },
+   { GL(SGIS_texture_edge_clamp),        VER(1,2), Y, N, N, N },
+   { GL(SGIS_texture_lod),               VER(1,2), Y, N, N, N },
+   { GL(SGIX_blend_alpha_minmax),        VER(0,0), Y, N, N, N },
+   { GL(SGIX_clipmap),                   VER(0,0), Y, N, N, N },
+   { GL(SGIX_depth_texture),             VER(0,0), Y, N, N, N },
+   { GL(SGIX_fog_offset),                VER(0,0), Y, N, N, N },
+   { GL(SGIX_shadow),                    VER(0,0), Y, N, N, N },
+   { GL(SGIX_shadow_ambient),            VER(0,0), Y, N, N, N },
+   { GL(SGIX_texture_coordinate_clamp),  VER(0,0), Y, N, N, N },
+   { GL(SGIX_texture_lod_bias),          VER(0,0), Y, N, N, N },
+   { GL(SGIX_texture_range),             VER(0,0), Y, N, N, N },
+   { GL(SGIX_texture_scale_bias),        VER(0,0), Y, N, N, N },
+   { GL(SGIX_vertex_preclip),            VER(0,0), Y, N, N, N },
+   { GL(SGIX_vertex_preclip_hint),       VER(0,0), Y, N, N, N },
+   { GL(SGIX_ycrcb),                     VER(0,0), Y, N, N, N },
+   { GL(SUN_convolution_border_modes),   VER(0,0), Y, N, N, N },
+   { GL(SUN_multi_draw_arrays),          VER(0,0), Y, N, Y, N },
+   { GL(SUN_slice_accum),                VER(0,0), Y, N, N, N },
+   { NULL }
+};
+
+
+/* global bit-fields of available extensions and their characteristics */
+static unsigned char client_glx_support[8];
+static unsigned char client_glx_only[8];
+static unsigned char direct_glx_only[8];
+static unsigned char client_gl_support[ __GL_EXT_BYTES ];
+static unsigned char client_gl_only[ __GL_EXT_BYTES ];
+
+/**
+ * Bits representing the set of extensions that are enabled by default in all
+ * direct rendering drivers.
+ */
+static unsigned char direct_glx_support[8];
+
+/**
+ * Highest core GL version that can be supported for indirect rendering.
+ */
+static const unsigned gl_major = 1;
+static const unsigned gl_minor = 4;
+
+/* client extensions string */
+static const char * __glXGLXClientExtensions = NULL;
+
+static void __glXExtensionsCtr( void );
+static void __glXExtensionsCtrScreen( __GLXscreenConfigs *psc );
+static void __glXProcessServerString( const struct extension_info * ext,
+    const char * server_string, unsigned char * server_support );
+
+/**
+ * Set the state of a GLX extension.
+ *
+ * \param name      Name of the extension.
+ * \param name_len  Length, in characters, of the extension name.
+ * \param state     New state (either enabled or disabled) of the extension.
+ * \param supported Table in which the state of the extension is to be set.
+ */
+static void
+set_glx_extension( const struct extension_info * ext,
+		   const char * name, unsigned name_len, GLboolean state,
+		   unsigned char * supported )
+{
+   unsigned   i;
+
+
+   for ( i = 0 ; ext[i].name != NULL ; i++ ) {
+      if ( (name_len == ext[i].name_len)
+	   && (strncmp( ext[i].name, name, name_len ) == 0) ) {
+	 if ( state ) {
+	    SET_BIT( supported, ext[i].bit );
+	 }
+	 else {
+	    CLR_BIT( supported, ext[i].bit );
+	 }
+
+	 return;
+      }
+   }
+}
+
+
+#define NUL '\0'
+#define SEPARATOR ' '
+
+/**
+ * Convert the server's extension string to a bit-field.
+ * 
+ * \param server_string   GLX extension string from the server.
+ * \param server_support  Bit-field of supported extensions.
+ */
+static void
+__glXProcessServerString( const struct extension_info * ext,
+			  const char * server_string,
+			  unsigned char * server_support )
+{
+   unsigned  base;
+   unsigned  len;
+
+   (void) memset( server_support, 0, sizeof( server_support ) );
+   
+   for ( base = 0 ; server_string[ base ] != NUL ; /* empty */ ) {
+      /* Determine the length of the next extension name.
+       */
+      for ( len = 0
+	    ; (server_string[ base + len ] != SEPARATOR)
+	    && (server_string[ base + len ] != NUL)
+	    ; len++ ) {
+	 /* empty */
+      }
+
+      /* Set the bit for the extension in the server_support table.
+       */
+      set_glx_extension( ext, & server_string[ base ], len, GL_TRUE,
+			 server_support );
+
+ 
+      /* Advance to the next extension string.  This means that we skip
+       * over the previous string and any trialing white-space.
+       */
+      for ( base += len ;
+	    (server_string[ base ] == SEPARATOR)
+	    && (server_string[ base ] != NUL)
+	    ; base++ ) {
+	 /* empty */
+      }
+   }
+}
+
+
+/**
+ * Enable a named GLX extension on a given screen.
+ * Drivers should not call this function directly.  They should instead use
+ * \c glXGetProcAddress to obtain a pointer to the function.
+ *
+ * \param psc   Pointer to GLX per-screen record.
+ * \param name  Name of the extension to enable.
+ *
+ * \sa glXGetProcAddress
+ *
+ * \since Internal API version 20030813.
+ */
+void
+__glXScrEnableExtension( __GLXscreenConfigs *psc, const char * name )
+{
+   __glXExtensionsCtr();
+   __glXExtensionsCtrScreen(psc);
+   set_glx_extension( known_glx_extensions, name, strlen( name ), GL_TRUE,
+		      psc->direct_support );
+}
+
+
+/**
+ * Initialize global extension support tables.
+ */
+
+static void
+__glXExtensionsCtr( void )
+{
+   unsigned   i;
+   static GLboolean ext_list_first_time = GL_TRUE;
+
+
+   if ( ext_list_first_time ) {
+      ext_list_first_time = GL_FALSE;
+
+      (void) memset( client_glx_support, 0, sizeof( client_glx_support ) );
+      (void) memset( direct_glx_support, 0, sizeof( direct_glx_support ) );
+      (void) memset( client_glx_only,    0, sizeof( client_glx_only ) );
+      (void) memset( direct_glx_only,    0, sizeof( direct_glx_only ) );
+
+      (void) memset( client_gl_support,  0, sizeof( client_gl_support ) );
+      (void) memset( client_gl_only,     0, sizeof( client_gl_only ) );
+
+      for ( i = 0 ; known_glx_extensions[i].name != NULL ; i++ ) {
+	 const unsigned  bit = known_glx_extensions[i].bit;
+
+	 if ( known_glx_extensions[i].client_support ) {
+	    SET_BIT( client_glx_support, bit );
+	 }
+
+	 if ( known_glx_extensions[i].direct_support ) {
+	    SET_BIT( direct_glx_support, bit );
+	 }
+
+	 if ( known_glx_extensions[i].client_only ) {
+	    SET_BIT( client_glx_only, bit );
+	 }
+
+	 if ( known_glx_extensions[i].direct_only ) {
+	    SET_BIT( direct_glx_only, bit );
+	 }
+      }
+
+      for ( i = 0 ; known_gl_extensions[i].name != NULL ; i++ ) {
+	 const unsigned  bit = known_gl_extensions[i].bit;
+
+	 if ( known_gl_extensions[i].client_support ) {
+	    SET_BIT( client_gl_support, bit );
+	 }
+
+	 if ( known_gl_extensions[i].client_only ) {
+	    SET_BIT( client_gl_only, bit );
+	 }
+      }
+      
+#if 0
+      fprintf( stderr, "[%s:%u] Maximum client library version: %u.%u\n",
+	       __func__, __LINE__, gl_major, gl_minor );
+#endif
+   }
+}
+
+
+/**
+ * Make sure that per-screen direct-support table is initialized.
+ *
+ * \param psc  Pointer to GLX per-screen record.
+ */
+
+static void
+__glXExtensionsCtrScreen( __GLXscreenConfigs *psc )
+{
+    if (psc->ext_list_first_time) {
+	psc->ext_list_first_time = GL_FALSE;
+	(void) memcpy( psc->direct_support, direct_glx_support,
+		       sizeof( direct_glx_support ) );
+    }
+}
+
+
+/**
+ * Check if a certain extension is enabled on a given screen.
+ *
+ * \param psc  Pointer to GLX per-screen record.
+ * \param bit  Bit index in the direct-support table.
+ * \returns If the extension bit is enabled for the screen, \c GL_TRUE is
+ *          returned.  If the extension bit is not enabled or if \c psc is
+ *          \c NULL, then \c GL_FALSE is returned.
+ */
+GLboolean
+__glXExtensionBitIsEnabled( __GLXscreenConfigs *psc, unsigned bit )
+{
+   GLboolean enabled = GL_FALSE;
+
+   if ( psc != NULL ) {
+      __glXExtensionsCtr();
+      __glXExtensionsCtrScreen( psc );
+      enabled = EXT_ENABLED( bit, psc->direct_support );
+   }
+
+   return enabled;
+}
+
+
+/**
+ * Check if a certain extension is enabled in a given context.
+ *
+ */
+GLboolean
+__glExtensionBitIsEnabled( const __GLXcontext * gc, unsigned bit )
+{
+   GLboolean enabled = GL_FALSE;
+
+   if ( gc != NULL ) {
+      enabled = EXT_ENABLED( bit, gc->gl_extension_bits );
+   }
+
+   return enabled;
+}
+
+
+
+/**
+ * Convert a bit-field to a string of supported extensions.
+ */
+static char *
+__glXGetStringFromTable( const struct extension_info * ext,
+			 const unsigned char * supported )
+{
+   unsigned   i;
+   unsigned   ext_str_len;
+   char * ext_str;
+   char * point;
+
+
+   ext_str_len = 0;
+   for ( i = 0 ; ext[i].name != NULL ; i++ ) {
+      if ( EXT_ENABLED( ext[i].bit, supported ) ) {
+	 ext_str_len += ext[i].name_len + 1;
+      }
+   }
+
+   ext_str = Xmalloc( ext_str_len + 1 );
+   if ( ext_str != NULL ) {
+      point = ext_str;
+
+      for ( i = 0 ; ext[i].name != NULL ; i++ ) {
+	 if ( EXT_ENABLED( ext[i].bit, supported ) ) {
+	    (void) memcpy( point, ext[i].name, ext[i].name_len );
+	    point += ext[i].name_len;
+
+	    *point = ' ';
+	    point++;
+	 }
+      }
+
+      *point = '\0';
+   }
+
+   return ext_str;
+}
+
+
+/**
+ * Get the string of client library supported extensions.
+ */
+const char *
+__glXGetClientExtensions( void )
+{
+   if ( __glXGLXClientExtensions == NULL ) {
+      __glXExtensionsCtr();
+      __glXGLXClientExtensions = __glXGetStringFromTable( known_glx_extensions,
+							  client_glx_support );
+   }
+
+   return __glXGLXClientExtensions;
+}
+
+
+/**
+ * Calculate the list of application usable extensions.  The resulting
+ * string is stored in \c psc->effectiveGLXexts.
+ * 
+ * \param psc                        Pointer to GLX per-screen record.
+ * \param display_is_direct_capable  True if the display is capable of
+ *                                   direct rendering.
+ * \param minor_version              GLX minor version from the server.
+ */
+
+void
+__glXCalculateUsableExtensions( __GLXscreenConfigs *psc,
+				GLboolean display_is_direct_capable,
+				int minor_version )
+{
+   unsigned char server_support[8];
+   unsigned char usable[8];
+   unsigned      i;
+
+   __glXExtensionsCtr();
+   __glXExtensionsCtrScreen( psc );
+   __glXProcessServerString( known_glx_extensions,
+			     psc->serverGLXexts, server_support );
+
+
+   /* This is a hack.  Some servers support GLX 1.3 but don't export
+    * all of the extensions implied by GLX 1.3.  If the server claims
+    * support for GLX 1.3, enable support for the extensions that can be
+    * "emulated" as well.
+    */
+
+   if ( minor_version >= 3 ) {
+      SET_BIT( server_support, EXT_visual_info_bit );
+      SET_BIT( server_support, EXT_visual_rating_bit );
+      SET_BIT( server_support, SGI_make_current_read_bit );
+      SET_BIT( server_support, SGIX_fbconfig_bit );
+      SET_BIT( server_support, SGIX_pbuffer_bit );
+       
+      /* This one is a little iffy.  GLX 1.3 doesn't incorporate all of this
+       * extension.  However, the only part that is not strictly client-side
+       * is shared.  That's the glXQueryContext / glXQueryContextInfoEXT
+       * function.
+       */
+
+      SET_BIT( server_support, EXT_import_context_bit );
+   }
+
+
+   /* An extension is supported if the client-side (i.e., libGL) supports
+    * it and the "server" supports it.  In this case that means that either
+    * the true server supports it or it is only for direct-rendering and
+    * the direct rendering driver supports it.
+    * 
+    * If the display is not capable of direct rendering, then the extension
+    * is enabled if and only if the client-side library and the server
+    * support it.
+    */
+
+   if ( display_is_direct_capable ) {
+      for ( i = 0 ; i < 8 ; i++ ) {
+	 usable[i] = (client_glx_support[i] & client_glx_only[i])
+	     | (client_glx_support[i] & psc->direct_support[i] & server_support[i])
+	     | (client_glx_support[i] & psc->direct_support[i] & direct_glx_only[i]);
+      }
+   }
+   else {
+      for ( i = 0 ; i < 8 ; i++ ) {
+	 usable[i] = (client_glx_support[i] & client_glx_only[i])
+	     | (client_glx_support[i] & server_support[i]);
+      }
+   }
+
+   psc->effectiveGLXexts = __glXGetStringFromTable( known_glx_extensions,
+						    usable );
+}
+
+
+/**
+ * Calculate the list of application usable extensions.  The resulting
+ * string is stored in \c gc->extensions.
+ * 
+ * \param gc             Pointer to GLX context.
+ * \param server_string  Extension string from the server.
+ * \param major_version  GL major version from the server.
+ * \param minor_version  GL minor version from the server.
+ */
+
+void
+__glXCalculateUsableGLExtensions( __GLXcontext * gc,
+				  const char * server_string,
+				  int major_version, int minor_version )
+{
+   unsigned char server_support[ __GL_EXT_BYTES ];
+   unsigned char usable[ __GL_EXT_BYTES ];
+   unsigned      i;
+
+
+   __glXExtensionsCtr();
+
+   (void) memset( server_support, 0, sizeof( server_support ) );
+   __glXProcessServerString( known_gl_extensions, server_string,
+			     server_support );
+
+
+   /* Handle lazy servers that don't export all the extensions strings that
+    * are part of the GL core version that they support.
+    */
+
+   for ( i = 0 ; i < __GL_EXT_BYTES ; i++ ) {
+      if ( (known_gl_extensions[i].version_major != 0)
+	   && ((major_version > known_gl_extensions[i].version_major)
+	       || ((major_version == known_gl_extensions[i].version_major)
+		   && (minor_version >= known_gl_extensions[i].version_minor))) ) {
+	 SET_BIT( server_support, known_gl_extensions[i].bit );
+      }
+   }
+
+
+   /* An extension is supported if the client-side (i.e., libGL) supports
+    * it and the server supports it or the client-side library supports it
+    * and it only needs client-side support.
+    */
+
+   for ( i = 0 ; i < __GL_EXT_BYTES ; i++ ) {
+      usable[i] = (client_gl_support[i] & client_gl_only[i])
+	| (client_gl_support[i] & server_support[i]);
+   }
+
+   gc->extensions = (unsigned char *) 
+     __glXGetStringFromTable( known_gl_extensions, usable );
+   (void) memcpy( gc->gl_extension_bits, usable, sizeof( usable ) );
+}
+
+
+/**
+ * Calculates the maximum core GL version that can be supported for indirect
+ * rendering.
+ */
+void
+__glXGetGLVersion( int * major_version, int * minor_version )
+{		   
+    __glXExtensionsCtr();
+    *major_version = gl_major;
+    *minor_version = gl_minor;
+}
+
+
+/**
+ * Get a string representing the set of extensions supported by the client
+ * library.  This is currently only used to send the list of extensions
+ * supported by the client to the server.
+ */
+char *
+__glXGetClientGLExtensionString( void )
+{
+    __glXExtensionsCtr();
+    return __glXGetStringFromTable( known_gl_extensions, client_gl_support );
+}
diff --git a/src/glx/x11/glxextensions.h b/src/glx/x11/glxextensions.h
new file mode 100644
index 00000000000..b4b03729ce3
--- /dev/null
+++ b/src/glx/x11/glxextensions.h
@@ -0,0 +1,279 @@
+/*
+ * (C) Copyright IBM Corporation 2002, 2004
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on 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
+ * THE COPYRIGHT HOLDERS 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.
+ */
+
+/**
+ * \file glxextensions.h
+ *
+ * \author Ian Romanick <[email protected]>
+ */
+
+#ifndef GLX_GLXEXTENSIONS_H
+#define GLX_GLXEXTENSIONS_H
+
+enum {
+   ARB_get_proc_address_bit = 0,
+   ARB_multisample_bit,
+   ARB_render_texture_bit,
+   ATI_pixel_format_float_bit,
+   EXT_visual_info_bit,
+   EXT_visual_rating_bit,
+   EXT_import_context_bit,
+   MESA_agp_offset_bit,
+   MESA_allocate_memory_bit, /* Replaces MESA_agp_offset & NV_vertex_array_range */
+   MESA_copy_sub_buffer_bit,
+   MESA_depth_float_bit,
+   MESA_pixmap_colormap_bit,
+   MESA_release_buffers_bit,
+   MESA_set_3dfx_mode_bit,
+   MESA_swap_control_bit,
+   MESA_swap_frame_usage_bit,
+   NV_float_buffer_bit,
+   NV_render_depth_texture_bit,
+   NV_render_texture_rectangle_bit,
+   NV_vertex_array_range_bit,
+   OML_swap_method_bit,
+   OML_sync_control_bit,
+   SGI_cushion_bit,
+   SGI_make_current_read_bit,
+   SGI_swap_control_bit,
+   SGI_video_sync_bit,
+   SGIS_blended_overlay_bit,
+   SGIS_color_range_bit,
+   SGIS_multisample_bit,
+   SGIX_dm_buffer_bit,
+   SGIX_fbconfig_bit,
+   SGIX_pbuffer_bit,
+   SGIX_swap_barrier_bit,
+   SGIX_swap_group_bit,
+   SGIX_video_resize_bit,
+   SGIX_video_source_bit,
+   SGIX_visual_select_group_bit,
+   SUN_get_transparent_index_bit
+};
+
+enum {
+   GL_ARB_depth_texture_bit = 0,
+   GL_ARB_draw_buffers_bit,
+   GL_ARB_fragment_program_bit,
+   GL_ARB_fragment_program_shadow_bit,
+   GL_ARB_imaging_bit,
+   GL_ARB_multisample_bit,
+   GL_ARB_multitexture_bit,
+   GL_ARB_occlusion_query_bit,
+   GL_ARB_point_parameters_bit,
+   GL_ARB_point_sprite_bit,
+   GL_ARB_shadow_bit,
+   GL_ARB_shadow_ambient_bit,
+   GL_ARB_texture_border_clamp_bit,
+   GL_ARB_texture_cube_map_bit,
+   GL_ARB_texture_compression_bit,
+   GL_ARB_texture_env_add_bit,
+   GL_ARB_texture_env_combine_bit,
+   GL_ARB_texture_env_crossbar_bit,
+   GL_ARB_texture_env_dot3_bit,
+   GL_ARB_texture_mirrored_repeat_bit,
+   GL_ARB_texture_non_power_of_two_bit,
+   GL_ARB_texture_rectangle_bit,
+   GL_ARB_transpose_matrix_bit,
+   GL_ARB_vertex_buffer_object_bit,
+   GL_ARB_vertex_program_bit,
+   GL_ARB_window_pos_bit,
+   GL_EXT_abgr_bit,
+   GL_EXT_bgra_bit,
+   GL_EXT_blend_color_bit,
+   GL_EXT_blend_equation_separate_bit,
+   GL_EXT_blend_func_separate_bit,
+   GL_EXT_blend_logic_op_bit,
+   GL_EXT_blend_minmax_bit,
+   GL_EXT_blend_subtract_bit,
+   GL_EXT_clip_volume_hint_bit,
+   GL_EXT_compiled_vertex_array_bit,
+   GL_EXT_convolution_bit,
+   GL_EXT_copy_texture_bit,
+   GL_EXT_cull_vertex_bit,
+   GL_EXT_depth_bounds_test_bit,
+   GL_EXT_draw_range_elements_bit,
+   GL_EXT_fog_coord_bit,
+   GL_EXT_multi_draw_arrays_bit,
+   GL_EXT_packed_pixels_bit,
+   GL_EXT_paletted_texture_bit,
+   GL_EXT_pixel_buffer_object_bit,
+   GL_EXT_polygon_offset_bit,
+   GL_EXT_rescale_normal_bit,
+   GL_EXT_secondary_color_bit,
+   GL_EXT_separate_specular_color_bit,
+   GL_EXT_shadow_funcs_bit,
+   GL_EXT_shared_texture_palette_bit,
+   GL_EXT_stencil_two_side_bit,
+   GL_EXT_stencil_wrap_bit,
+   GL_EXT_subtexture_bit,
+   GL_EXT_texture_bit,
+   GL_EXT_texture3D_bit,
+   GL_EXT_texture_compression_dxt1_bit,
+   GL_EXT_texture_compression_s3tc_bit,
+   GL_EXT_texture_edge_clamp_bit,
+   GL_EXT_texture_env_combine_bit,
+   GL_EXT_texture_env_dot3_bit,
+   GL_EXT_texture_filter_anisotropic_bit,
+   GL_EXT_texture_lod_bit,
+   GL_EXT_texture_lod_bias_bit,
+   GL_EXT_texture_mirror_clamp_bit,
+   GL_EXT_texture_object_bit,
+   GL_EXT_vertex_array_bit,
+   GL_3DFX_texture_compression_FXT1_bit,
+   GL_APPLE_packed_pixels_bit,
+   GL_APPLE_ycbcr_422_bit,
+   GL_ATI_text_fragment_shader_bit,
+   GL_ATI_texture_env_combine3_bit,
+   GL_ATI_texture_float_bit,
+   GL_ATI_texture_mirror_once_bit,
+   GL_HP_convolution_border_modes_bit,
+   GL_HP_occlusion_test_bit,
+   GL_IBM_cull_vertex_bit,
+   GL_IBM_pixel_filter_hint_bit,
+   GL_IBM_rasterpos_clip_bit,
+   GL_IBM_texture_clamp_nodraw_bit,
+   GL_INGR_interlace_read_bit,
+   GL_MESA_pack_invert_bit,
+   GL_MESA_ycbcr_texture_bit,
+   GL_NV_blend_square_bit,
+   GL_NV_copy_depth_to_color_bit,
+   GL_NV_depth_clamp_bit,
+   GL_NV_fog_distance_bit,
+   GL_NV_fragment_program_bit,
+   GL_NV_fragment_program_option_bit,
+   GL_NV_fragment_program2_bit,
+   GL_NV_light_max_exponent_bit,
+   GL_NV_multisample_filter_hint_bit,
+   GL_NV_point_sprite_bit,
+   GL_NV_texgen_reflection_bit,
+   GL_NV_texture_compression_vtc_bit,
+   GL_NV_texture_env_combine4_bit,
+   GL_NV_vertex_program_bit,
+   GL_NV_vertex_program1_1_bit,
+   GL_NV_vertex_program2_bit,
+   GL_NV_vertex_program2_option_bit,
+   GL_NV_vertex_program3_bit,
+   GL_OES_compressed_paletted_texture_bit,
+   GL_OES_read_format_bit,
+   GL_SGI_color_matrix_bit,
+   GL_SGI_texture_color_table_bit,
+   GL_SGIS_generate_mipmap_bit,
+   GL_SGIS_multisample_bit,
+   GL_SGIS_texture_lod_bit,
+   GL_SGIX_blend_alpha_minmax_bit,
+   GL_SGIX_clipmap_bit,
+   GL_SGIX_depth_texture_bit,
+   GL_SGIX_fog_offset_bit,
+   GL_SGIX_shadow_bit,
+   GL_SGIX_texture_coordinate_clamp_bit,
+   GL_SGIX_texture_lod_bias_bit,
+   GL_SGIX_texture_range_bit,
+   GL_SGIX_texture_scale_bias_bit,
+   GL_SGIX_vertex_preclip_bit,
+   GL_SGIX_vertex_preclip_hint_bit,
+   GL_SGIX_ycrcb_bit,
+   GL_SUN_convolution_border_modes_bit,
+   GL_SUN_slice_accum_bit,
+
+   /* This *MUST* go here.  If it gets put after the duplicate values it will
+    * get the value after the last duplicate.
+    */
+   __NUM_GL_EXTS,
+
+
+   /* Alias extension bits.  These extensions exist in either vendor-specific
+    * or EXT form and were later promoted to either EXT or ARB form.  In all
+    * cases, the meaning is *exactly* the same.  That's why
+    * EXT_texture_env_combine is *NOT* an alias of ARB_texture_env_combine and
+    * EXT_texture_env_dot3 is *NOT* an alias of ARB_texture_env_dot3.  Be
+    * careful!  When in doubt, src/mesa/main/extensions.c in the Mesa tree
+    * is a great reference.
+    */
+
+   GL_ATI_blend_equation_separate_bit = GL_EXT_blend_equation_separate_bit,
+   GL_ATI_draw_buffers_bit = GL_ARB_draw_buffers_bit,
+   GL_ATIX_texture_env_combine3_bit = GL_ATI_texture_env_combine3_bit,
+   GL_EXT_point_parameters_bit = GL_ARB_point_parameters_bit,
+   GL_EXT_texture_env_add_bit = GL_ARB_texture_env_add_bit,
+   GL_EXT_texture_rectangle_bit = GL_ARB_texture_rectangle_bit,
+   GL_IBM_texture_mirrored_repeat_bit = GL_ARB_texture_mirrored_repeat_bit,
+   GL_INGR_blend_func_separate_bit = GL_EXT_blend_func_separate_bit,
+   GL_MESA_window_pos_bit = GL_ARB_window_pos_bit,
+   GL_NV_texture_rectangle_bit = GL_ARB_texture_rectangle_bit,
+   GL_SGIS_texture_border_clamp_bit = GL_ARB_texture_border_clamp_bit,
+   GL_SGIS_texture_edge_clamp_bit = GL_EXT_texture_edge_clamp_bit,
+   GL_SGIX_shadow_ambient_bit = GL_ARB_shadow_ambient_bit,
+   GL_SUN_multi_draw_arrays_bit = GL_EXT_multi_draw_arrays_bit
+};
+
+#define __GL_EXT_BYTES   ((__NUM_GL_EXTS + 7) / 8)
+
+struct __GLXscreenConfigsRec;
+struct __GLXcontextRec;
+
+extern GLboolean __glXExtensionBitIsEnabled( struct __GLXscreenConfigsRec *psc, unsigned bit );
+extern const char * __glXGetClientExtensions( void );
+extern void __glXCalculateUsableExtensions( struct __GLXscreenConfigsRec *psc,
+    GLboolean display_is_direct_capable, int server_minor_version );
+extern void __glXScrEnableExtension( struct __GLXscreenConfigsRec *psc, const char * name );
+extern void __glXCalculateUsableGLExtensions( struct __GLXcontextRec * gc,
+    const char * server_string, int major_version, int minor_version );
+extern void __glXGetGLVersion( int * major_version, int * minor_version );
+extern char * __glXGetClientGLExtensionString( void );
+
+extern GLboolean __glExtensionBitIsEnabled( const struct __GLXcontextRec * gc, 
+    unsigned bit );
+
+
+/* Source-level backwards compatibility with old drivers. They won't
+ * find the respective functions, though. 
+ */
+typedef void (* PFNGLXENABLEEXTENSIONPROC) ( const char * name,
+    GLboolean force_client );
+typedef void (* PFNGLXDISABLEEXTENSIONPROC) ( const char * name );
+
+/* GLX_ALIAS should be used for functions with a non-void return type.
+   GLX_ALIAS_VOID is for functions with a void return type. */
+#ifdef GLX_NO_STATIC_EXTENSION_FUNCTIONS
+# define GLX_ALIAS(return_type, real_func, proto_args, args, aliased_func)
+# define GLX_ALIAS_VOID(real_func, proto_args, args, aliased_func)
+#else
+# if defined(__GNUC__) && !defined(GLX_ALIAS_UNSUPPORTED)
+#  define GLX_ALIAS(return_type, real_func, proto_args, args, aliased_func) \
+	return_type  real_func  proto_args \
+	__attribute__ ((alias( # aliased_func ) ));
+#  define GLX_ALIAS_VOID(real_func, proto_args, args, aliased_func) \
+	GLX_ALIAS(void, real_func, proto_args, args, aliased_func)
+# else
+#  define GLX_ALIAS(return_type, real_func, proto_args, args, aliased_func) \
+	return_type  real_func  proto_args \
+	{ return aliased_func args ; }
+#  define GLX_ALIAS_VOID(real_func, proto_args, args, aliased_func) \
+	void  real_func  proto_args \
+	{ aliased_func args ; }
+# endif /* __GNUC__ */
+#endif /* GLX_NO_STATIC_EXTENSION_FUNCTIONS */
+
+#endif /* GLX_GLXEXTENSIONS_H */
diff --git a/src/glx/x11/indirect.c b/src/glx/x11/indirect.c
new file mode 100644
index 00000000000..2a4db6578a7
--- /dev/null
+++ b/src/glx/x11/indirect.c
@@ -0,0 +1,8472 @@
+/* DO NOT EDIT - This file generated automatically by glX_proto_send.py (from Mesa) script */
+
+/*
+ * (C) Copyright IBM Corporation 2004, 2005
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * IBM,
+ * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+
+#include <GL/gl.h>
+#include "indirect.h"
+#include "glxclient.h"
+#include "indirect_size.h"
+#include <GL/glxproto.h>
+#ifdef USE_XCB
+#include <X11/xcl.h>
+#include <X11/XCB/xcb.h>
+#include <X11/XCB/glx.h>
+#endif /* USE_XCB */
+
+#define __GLX_PAD(n) (((n) + 3) & ~3)
+
+#  if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined(__MINGW32__)
+#    define FASTCALL __attribute__((fastcall))
+#  else
+#    define FASTCALL
+#  endif
+#  if defined(__GNUC__)
+#    define NOINLINE __attribute__((noinline))
+#  else
+#    define NOINLINE
+#  endif
+
+#if !defined __GNUC__ || __GNUC__ < 3
+#  define __builtin_expect(x, y) x
+#endif
+
+/* If the size and opcode values are known at compile-time, this will, on
+ * x86 at least, emit them with a single instruction.
+ */
+#define emit_header(dest, op, size)            \
+    do { union { short s[2]; int i; } temp;    \
+         temp.s[0] = (size); temp.s[1] = (op); \
+         *((int *)(dest)) = temp.i; } while(0)
+
+NOINLINE CARD32
+__glXReadReply( Display *dpy, size_t size, void * dest, GLboolean reply_is_always_array )
+{
+    xGLXSingleReply reply;
+    
+    (void) _XReply(dpy, (xReply *) & reply, 0, False);
+    if (size != 0) {
+        if ((reply.length > 0) || reply_is_always_array) {
+            const GLint bytes = (reply_is_always_array) 
+              ? (4 * reply.length) : (reply.size * size);
+            const GLint extra = 4 - (bytes & 3);
+
+            _XRead(dpy, dest, bytes);
+            if ( extra < 4 ) {
+                _XEatData(dpy, extra);
+            }
+        }
+        else {
+            (void) memcpy( dest, &(reply.pad3), size);
+        }
+    }
+
+    return reply.retval;
+}
+
+NOINLINE void
+__glXReadPixelReply( Display *dpy, __GLXcontext * gc, unsigned max_dim,
+    GLint width, GLint height, GLint depth, GLenum format, GLenum type,
+    void * dest, GLboolean dimensions_in_reply )
+{
+    xGLXSingleReply reply;
+    GLint size;
+    
+    (void) _XReply(dpy, (xReply *) & reply, 0, False);
+
+    if ( dimensions_in_reply ) {
+        width  = reply.pad3;
+        height = reply.pad4;
+        depth  = reply.pad5;
+	
+	if ((height == 0) || (max_dim < 2)) { height = 1; }
+	if ((depth  == 0) || (max_dim < 3)) { depth  = 1; }
+    }
+
+    size = reply.length * 4;
+    if (size != 0) {
+        void * buf = Xmalloc( size );
+
+        if ( buf == NULL ) {
+            _XEatData(dpy, size);
+            __glXSetError(gc, GL_OUT_OF_MEMORY);
+        }
+        else {
+            const GLint extra = 4 - (size & 3);
+
+            _XRead(dpy, buf, size);
+            if ( extra < 4 ) {
+                _XEatData(dpy, extra);
+            }
+
+            __glEmptyImage(gc, 3, width, height, depth, format, type,
+                           buf, dest);
+            Xfree(buf);
+        }
+    }
+}
+
+#define X_GLXSingle 0
+
+NOINLINE FASTCALL GLubyte *
+__glXSetupSingleRequest( __GLXcontext * gc, GLint sop, GLint cmdlen )
+{
+    xGLXSingleReq * req;
+    Display * const dpy = gc->currentDpy;
+
+    (void) __glXFlushRenderBuffer(gc, gc->pc);
+    LockDisplay(dpy);
+    GetReqExtra(GLXSingle, cmdlen, req);
+    req->reqType = gc->majorOpcode;
+    req->contextTag = gc->currentContextTag;
+    req->glxCode = sop;
+    return (GLubyte *)(req) + sz_xGLXSingleReq;
+}
+
+NOINLINE FASTCALL GLubyte *
+__glXSetupVendorRequest( __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen )
+{
+    xGLXVendorPrivateReq * req;
+    Display * const dpy = gc->currentDpy;
+
+    (void) __glXFlushRenderBuffer(gc, gc->pc);
+    LockDisplay(dpy);
+    GetReqExtra(GLXVendorPrivate, cmdlen, req);
+    req->reqType = gc->majorOpcode;
+    req->glxCode = code;
+    req->vendorCode = vop;
+    req->contextTag = gc->currentContextTag;
+    return (GLubyte *)(req) + sz_xGLXVendorPrivateReq;
+}
+
+const GLuint __glXDefaultPixelStore[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 };
+
+#define zero                        (__glXDefaultPixelStore+0)
+#define one                         (__glXDefaultPixelStore+8)
+#define default_pixel_store_1D      (__glXDefaultPixelStore+4)
+#define default_pixel_store_1D_size 20
+#define default_pixel_store_2D      (__glXDefaultPixelStore+4)
+#define default_pixel_store_2D_size 20
+#define default_pixel_store_3D      (__glXDefaultPixelStore+0)
+#define default_pixel_store_3D_size 36
+#define default_pixel_store_4D      (__glXDefaultPixelStore+0)
+#define default_pixel_store_4D_size 36
+
+static FASTCALL NOINLINE void
+generic_3_byte( GLint rop, const void * ptr )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+
+    emit_header(gc->pc, rop, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), ptr, 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+static FASTCALL NOINLINE void
+generic_4_byte( GLint rop, const void * ptr )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+
+    emit_header(gc->pc, rop, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), ptr, 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+static FASTCALL NOINLINE void
+generic_6_byte( GLint rop, const void * ptr )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+
+    emit_header(gc->pc, rop, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), ptr, 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+static FASTCALL NOINLINE void
+generic_8_byte( GLint rop, const void * ptr )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+
+    emit_header(gc->pc, rop, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), ptr, 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+static FASTCALL NOINLINE void
+generic_12_byte( GLint rop, const void * ptr )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+
+    emit_header(gc->pc, rop, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), ptr, 12);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+static FASTCALL NOINLINE void
+generic_16_byte( GLint rop, const void * ptr )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+
+    emit_header(gc->pc, rop, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), ptr, 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+static FASTCALL NOINLINE void
+generic_24_byte( GLint rop, const void * ptr )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+
+    emit_header(gc->pc, rop, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), ptr, 24);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+static FASTCALL NOINLINE void
+generic_32_byte( GLint rop, const void * ptr )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 36;
+
+    emit_header(gc->pc, rop, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), ptr, 32);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLsop_NewList 101
+void
+__indirect_glNewList(GLuint list, GLenum mode)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxNewList(c, gc->currentContextTag, list, mode);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_NewList, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&mode), 4);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_EndList 102
+void
+__indirect_glEndList(void)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 0;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxEndList(c, gc->currentContextTag);
+#else
+        (void) __glXSetupSingleRequest(gc, X_GLsop_EndList, cmdlen);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLrop_CallList 1
+void
+__indirect_glCallList(GLuint list)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_CallList, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&list), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_CallLists 2
+void
+__indirect_glCallLists(GLsizei n, GLenum type, const GLvoid * lists)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glCallLists_size(type);
+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * n));
+    if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) {
+        if (cmdlen <= gc->maxSmallRenderCommandSize) {
+            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+            emit_header(gc->pc, X_GLrop_CallLists, cmdlen);
+            (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
+            (void) memcpy((void *)(gc->pc + 8), (void *)(&type), 4);
+            (void) memcpy((void *)(gc->pc + 12), (void *)(lists), (compsize * n));
+            gc->pc += cmdlen;
+            if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        }
+        else {
+            const GLint op = X_GLrop_CallLists;
+            const GLuint cmdlenLarge = cmdlen + 4;
+            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+            (void) memcpy((void *)(pc + 8), (void *)(&n), 4);
+            (void) memcpy((void *)(pc + 12), (void *)(&type), 4);
+            __glXSendLargeCommand(gc, pc, 16, lists, (compsize * n));
+        }
+    }
+}
+
+#define X_GLsop_DeleteLists 103
+void
+__indirect_glDeleteLists(GLuint list, GLsizei range)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxDeleteLists(c, gc->currentContextTag, list, range);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_DeleteLists, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&range), 4);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GenLists 104
+GLuint
+__indirect_glGenLists(GLsizei range)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    GLuint retval = (GLuint) 0;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGenListsRep *reply = XCBGlxGenListsReply(c, XCBGlxGenLists(c, gc->currentContextTag, range), NULL);
+        retval = reply->ret_val;
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenLists, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&range), 4);
+        retval = (GLuint) __glXReadReply(dpy, 0, NULL, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return retval;
+}
+
+#define X_GLrop_ListBase 3
+void
+__indirect_glListBase(GLuint base)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_ListBase, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&base), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Begin 4
+void
+__indirect_glBegin(GLenum mode)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_Begin, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Bitmap 5
+void
+__indirect_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = (bitmap != NULL) ? __glImageSize(width, height, 1, GL_COLOR_INDEX, GL_BITMAP, 0) : 0;
+    const GLuint cmdlen = 48 + __GLX_PAD(compsize);
+    if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+        if (cmdlen <= gc->maxSmallRenderCommandSize) {
+            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+            emit_header(gc->pc, X_GLrop_Bitmap, cmdlen);
+            (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
+            (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
+            (void) memcpy((void *)(gc->pc + 32), (void *)(&xorig), 4);
+            (void) memcpy((void *)(gc->pc + 36), (void *)(&yorig), 4);
+            (void) memcpy((void *)(gc->pc + 40), (void *)(&xmove), 4);
+            (void) memcpy((void *)(gc->pc + 44), (void *)(&ymove), 4);
+            if (compsize > 0) {
+                (*gc->fillImage)(gc, 2, width, height, 1, GL_COLOR_INDEX, GL_BITMAP, bitmap, gc->pc + 48, gc->pc + 4);
+            }
+            else {
+                (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+            }
+            gc->pc += cmdlen;
+            if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        }
+        else {
+            const GLint op = X_GLrop_Bitmap;
+            const GLuint cmdlenLarge = cmdlen + 4;
+            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+            (void) memcpy((void *)(pc + 28), (void *)(&width), 4);
+            (void) memcpy((void *)(pc + 32), (void *)(&height), 4);
+            (void) memcpy((void *)(pc + 36), (void *)(&xorig), 4);
+            (void) memcpy((void *)(pc + 40), (void *)(&yorig), 4);
+            (void) memcpy((void *)(pc + 44), (void *)(&xmove), 4);
+            (void) memcpy((void *)(pc + 48), (void *)(&ymove), 4);
+            __glXSendLargeImage(gc, compsize, 2, width, height, 1, GL_COLOR_INDEX, GL_BITMAP, bitmap, pc + 52, pc + 8);
+        }
+    }
+}
+
+#define X_GLrop_Color3bv 6
+void
+__indirect_glColor3b(GLbyte red, GLbyte green, GLbyte blue)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_Color3bv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
+    (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Color3bv 6
+void
+__indirect_glColor3bv(const GLbyte * v)
+{
+    generic_3_byte( X_GLrop_Color3bv, v );
+}
+
+#define X_GLrop_Color3dv 7
+void
+__indirect_glColor3d(GLdouble red, GLdouble green, GLdouble blue)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_Color3dv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Color3dv 7
+void
+__indirect_glColor3dv(const GLdouble * v)
+{
+    generic_24_byte( X_GLrop_Color3dv, v );
+}
+
+#define X_GLrop_Color3fv 8
+void
+__indirect_glColor3f(GLfloat red, GLfloat green, GLfloat blue)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_Color3fv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Color3fv 8
+void
+__indirect_glColor3fv(const GLfloat * v)
+{
+    generic_12_byte( X_GLrop_Color3fv, v );
+}
+
+#define X_GLrop_Color3iv 9
+void
+__indirect_glColor3i(GLint red, GLint green, GLint blue)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_Color3iv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Color3iv 9
+void
+__indirect_glColor3iv(const GLint * v)
+{
+    generic_12_byte( X_GLrop_Color3iv, v );
+}
+
+#define X_GLrop_Color3sv 10
+void
+__indirect_glColor3s(GLshort red, GLshort green, GLshort blue)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_Color3sv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Color3sv 10
+void
+__indirect_glColor3sv(const GLshort * v)
+{
+    generic_6_byte( X_GLrop_Color3sv, v );
+}
+
+#define X_GLrop_Color3ubv 11
+void
+__indirect_glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_Color3ubv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
+    (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Color3ubv 11
+void
+__indirect_glColor3ubv(const GLubyte * v)
+{
+    generic_3_byte( X_GLrop_Color3ubv, v );
+}
+
+#define X_GLrop_Color3uiv 12
+void
+__indirect_glColor3ui(GLuint red, GLuint green, GLuint blue)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_Color3uiv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Color3uiv 12
+void
+__indirect_glColor3uiv(const GLuint * v)
+{
+    generic_12_byte( X_GLrop_Color3uiv, v );
+}
+
+#define X_GLrop_Color3usv 13
+void
+__indirect_glColor3us(GLushort red, GLushort green, GLushort blue)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_Color3usv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Color3usv 13
+void
+__indirect_glColor3usv(const GLushort * v)
+{
+    generic_6_byte( X_GLrop_Color3usv, v );
+}
+
+#define X_GLrop_Color4bv 14
+void
+__indirect_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_Color4bv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
+    (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
+    (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Color4bv 14
+void
+__indirect_glColor4bv(const GLbyte * v)
+{
+    generic_4_byte( X_GLrop_Color4bv, v );
+}
+
+#define X_GLrop_Color4dv 15
+void
+__indirect_glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 36;
+    emit_header(gc->pc, X_GLrop_Color4dv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&alpha), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Color4dv 15
+void
+__indirect_glColor4dv(const GLdouble * v)
+{
+    generic_32_byte( X_GLrop_Color4dv, v );
+}
+
+#define X_GLrop_Color4fv 16
+void
+__indirect_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_Color4fv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Color4fv 16
+void
+__indirect_glColor4fv(const GLfloat * v)
+{
+    generic_16_byte( X_GLrop_Color4fv, v );
+}
+
+#define X_GLrop_Color4iv 17
+void
+__indirect_glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_Color4iv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Color4iv 17
+void
+__indirect_glColor4iv(const GLint * v)
+{
+    generic_16_byte( X_GLrop_Color4iv, v );
+}
+
+#define X_GLrop_Color4sv 18
+void
+__indirect_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_Color4sv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Color4sv 18
+void
+__indirect_glColor4sv(const GLshort * v)
+{
+    generic_8_byte( X_GLrop_Color4sv, v );
+}
+
+#define X_GLrop_Color4ubv 19
+void
+__indirect_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_Color4ubv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
+    (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
+    (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Color4ubv 19
+void
+__indirect_glColor4ubv(const GLubyte * v)
+{
+    generic_4_byte( X_GLrop_Color4ubv, v );
+}
+
+#define X_GLrop_Color4uiv 20
+void
+__indirect_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_Color4uiv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Color4uiv 20
+void
+__indirect_glColor4uiv(const GLuint * v)
+{
+    generic_16_byte( X_GLrop_Color4uiv, v );
+}
+
+#define X_GLrop_Color4usv 21
+void
+__indirect_glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_Color4usv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Color4usv 21
+void
+__indirect_glColor4usv(const GLushort * v)
+{
+    generic_8_byte( X_GLrop_Color4usv, v );
+}
+
+#define X_GLrop_EdgeFlagv 22
+void
+__indirect_glEdgeFlag(GLboolean flag)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_EdgeFlagv 22
+void
+__indirect_glEdgeFlagv(const GLboolean * flag)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(flag), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_End 23
+void
+__indirect_glEnd(void)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 4;
+    emit_header(gc->pc, X_GLrop_End, cmdlen);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Indexdv 24
+void
+__indirect_glIndexd(GLdouble c)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_Indexdv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Indexdv 24
+void
+__indirect_glIndexdv(const GLdouble * c)
+{
+    generic_8_byte( X_GLrop_Indexdv, c );
+}
+
+#define X_GLrop_Indexfv 25
+void
+__indirect_glIndexf(GLfloat c)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_Indexfv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Indexfv 25
+void
+__indirect_glIndexfv(const GLfloat * c)
+{
+    generic_4_byte( X_GLrop_Indexfv, c );
+}
+
+#define X_GLrop_Indexiv 26
+void
+__indirect_glIndexi(GLint c)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_Indexiv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Indexiv 26
+void
+__indirect_glIndexiv(const GLint * c)
+{
+    generic_4_byte( X_GLrop_Indexiv, c );
+}
+
+#define X_GLrop_Indexsv 27
+void
+__indirect_glIndexs(GLshort c)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Indexsv 27
+void
+__indirect_glIndexsv(const GLshort * c)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(c), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Normal3bv 28
+void
+__indirect_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_Normal3bv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 1);
+    (void) memcpy((void *)(gc->pc + 5), (void *)(&ny), 1);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&nz), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Normal3bv 28
+void
+__indirect_glNormal3bv(const GLbyte * v)
+{
+    generic_3_byte( X_GLrop_Normal3bv, v );
+}
+
+#define X_GLrop_Normal3dv 29
+void
+__indirect_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_Normal3dv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&ny), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&nz), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Normal3dv 29
+void
+__indirect_glNormal3dv(const GLdouble * v)
+{
+    generic_24_byte( X_GLrop_Normal3dv, v );
+}
+
+#define X_GLrop_Normal3fv 30
+void
+__indirect_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_Normal3fv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Normal3fv 30
+void
+__indirect_glNormal3fv(const GLfloat * v)
+{
+    generic_12_byte( X_GLrop_Normal3fv, v );
+}
+
+#define X_GLrop_Normal3iv 31
+void
+__indirect_glNormal3i(GLint nx, GLint ny, GLint nz)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_Normal3iv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Normal3iv 31
+void
+__indirect_glNormal3iv(const GLint * v)
+{
+    generic_12_byte( X_GLrop_Normal3iv, v );
+}
+
+#define X_GLrop_Normal3sv 32
+void
+__indirect_glNormal3s(GLshort nx, GLshort ny, GLshort nz)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_Normal3sv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 2);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&ny), 2);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&nz), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Normal3sv 32
+void
+__indirect_glNormal3sv(const GLshort * v)
+{
+    generic_6_byte( X_GLrop_Normal3sv, v );
+}
+
+#define X_GLrop_RasterPos2dv 33
+void
+__indirect_glRasterPos2d(GLdouble x, GLdouble y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_RasterPos2dv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_RasterPos2dv 33
+void
+__indirect_glRasterPos2dv(const GLdouble * v)
+{
+    generic_16_byte( X_GLrop_RasterPos2dv, v );
+}
+
+#define X_GLrop_RasterPos2fv 34
+void
+__indirect_glRasterPos2f(GLfloat x, GLfloat y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_RasterPos2fv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_RasterPos2fv 34
+void
+__indirect_glRasterPos2fv(const GLfloat * v)
+{
+    generic_8_byte( X_GLrop_RasterPos2fv, v );
+}
+
+#define X_GLrop_RasterPos2iv 35
+void
+__indirect_glRasterPos2i(GLint x, GLint y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_RasterPos2iv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_RasterPos2iv 35
+void
+__indirect_glRasterPos2iv(const GLint * v)
+{
+    generic_8_byte( X_GLrop_RasterPos2iv, v );
+}
+
+#define X_GLrop_RasterPos2sv 36
+void
+__indirect_glRasterPos2s(GLshort x, GLshort y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_RasterPos2sv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_RasterPos2sv 36
+void
+__indirect_glRasterPos2sv(const GLshort * v)
+{
+    generic_4_byte( X_GLrop_RasterPos2sv, v );
+}
+
+#define X_GLrop_RasterPos3dv 37
+void
+__indirect_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_RasterPos3dv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_RasterPos3dv 37
+void
+__indirect_glRasterPos3dv(const GLdouble * v)
+{
+    generic_24_byte( X_GLrop_RasterPos3dv, v );
+}
+
+#define X_GLrop_RasterPos3fv 38
+void
+__indirect_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_RasterPos3fv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_RasterPos3fv 38
+void
+__indirect_glRasterPos3fv(const GLfloat * v)
+{
+    generic_12_byte( X_GLrop_RasterPos3fv, v );
+}
+
+#define X_GLrop_RasterPos3iv 39
+void
+__indirect_glRasterPos3i(GLint x, GLint y, GLint z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_RasterPos3iv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_RasterPos3iv 39
+void
+__indirect_glRasterPos3iv(const GLint * v)
+{
+    generic_12_byte( X_GLrop_RasterPos3iv, v );
+}
+
+#define X_GLrop_RasterPos3sv 40
+void
+__indirect_glRasterPos3s(GLshort x, GLshort y, GLshort z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_RasterPos3sv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_RasterPos3sv 40
+void
+__indirect_glRasterPos3sv(const GLshort * v)
+{
+    generic_6_byte( X_GLrop_RasterPos3sv, v );
+}
+
+#define X_GLrop_RasterPos4dv 41
+void
+__indirect_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 36;
+    emit_header(gc->pc, X_GLrop_RasterPos4dv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_RasterPos4dv 41
+void
+__indirect_glRasterPos4dv(const GLdouble * v)
+{
+    generic_32_byte( X_GLrop_RasterPos4dv, v );
+}
+
+#define X_GLrop_RasterPos4fv 42
+void
+__indirect_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_RasterPos4fv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_RasterPos4fv 42
+void
+__indirect_glRasterPos4fv(const GLfloat * v)
+{
+    generic_16_byte( X_GLrop_RasterPos4fv, v );
+}
+
+#define X_GLrop_RasterPos4iv 43
+void
+__indirect_glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_RasterPos4iv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_RasterPos4iv 43
+void
+__indirect_glRasterPos4iv(const GLint * v)
+{
+    generic_16_byte( X_GLrop_RasterPos4iv, v );
+}
+
+#define X_GLrop_RasterPos4sv 44
+void
+__indirect_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_RasterPos4sv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_RasterPos4sv 44
+void
+__indirect_glRasterPos4sv(const GLshort * v)
+{
+    generic_8_byte( X_GLrop_RasterPos4sv, v );
+}
+
+#define X_GLrop_Rectdv 45
+void
+__indirect_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 36;
+    emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y1), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&x2), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&y2), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Rectdv 45
+void
+__indirect_glRectdv(const GLdouble * v1, const GLdouble * v2)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 36;
+    emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 16);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(v2), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Rectfv 46
+void
+__indirect_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Rectfv 46
+void
+__indirect_glRectfv(const GLfloat * v1, const GLfloat * v2)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(v2), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Rectiv 47
+void
+__indirect_glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Rectiv 47
+void
+__indirect_glRectiv(const GLint * v1, const GLint * v2)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(v2), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Rectsv 48
+void
+__indirect_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 2);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&y1), 2);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x2), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&y2), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Rectsv 48
+void
+__indirect_glRectsv(const GLshort * v1, const GLshort * v2)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v2), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexCoord1dv 49
+void
+__indirect_glTexCoord1d(GLdouble s)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_TexCoord1dv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexCoord1dv 49
+void
+__indirect_glTexCoord1dv(const GLdouble * v)
+{
+    generic_8_byte( X_GLrop_TexCoord1dv, v );
+}
+
+#define X_GLrop_TexCoord1fv 50
+void
+__indirect_glTexCoord1f(GLfloat s)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_TexCoord1fv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexCoord1fv 50
+void
+__indirect_glTexCoord1fv(const GLfloat * v)
+{
+    generic_4_byte( X_GLrop_TexCoord1fv, v );
+}
+
+#define X_GLrop_TexCoord1iv 51
+void
+__indirect_glTexCoord1i(GLint s)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_TexCoord1iv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexCoord1iv 51
+void
+__indirect_glTexCoord1iv(const GLint * v)
+{
+    generic_4_byte( X_GLrop_TexCoord1iv, v );
+}
+
+#define X_GLrop_TexCoord1sv 52
+void
+__indirect_glTexCoord1s(GLshort s)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexCoord1sv 52
+void
+__indirect_glTexCoord1sv(const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexCoord2dv 53
+void
+__indirect_glTexCoord2d(GLdouble s, GLdouble t)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_TexCoord2dv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexCoord2dv 53
+void
+__indirect_glTexCoord2dv(const GLdouble * v)
+{
+    generic_16_byte( X_GLrop_TexCoord2dv, v );
+}
+
+#define X_GLrop_TexCoord2fv 54
+void
+__indirect_glTexCoord2f(GLfloat s, GLfloat t)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_TexCoord2fv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexCoord2fv 54
+void
+__indirect_glTexCoord2fv(const GLfloat * v)
+{
+    generic_8_byte( X_GLrop_TexCoord2fv, v );
+}
+
+#define X_GLrop_TexCoord2iv 55
+void
+__indirect_glTexCoord2i(GLint s, GLint t)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_TexCoord2iv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexCoord2iv 55
+void
+__indirect_glTexCoord2iv(const GLint * v)
+{
+    generic_8_byte( X_GLrop_TexCoord2iv, v );
+}
+
+#define X_GLrop_TexCoord2sv 56
+void
+__indirect_glTexCoord2s(GLshort s, GLshort t)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_TexCoord2sv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexCoord2sv 56
+void
+__indirect_glTexCoord2sv(const GLshort * v)
+{
+    generic_4_byte( X_GLrop_TexCoord2sv, v );
+}
+
+#define X_GLrop_TexCoord3dv 57
+void
+__indirect_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_TexCoord3dv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexCoord3dv 57
+void
+__indirect_glTexCoord3dv(const GLdouble * v)
+{
+    generic_24_byte( X_GLrop_TexCoord3dv, v );
+}
+
+#define X_GLrop_TexCoord3fv 58
+void
+__indirect_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_TexCoord3fv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexCoord3fv 58
+void
+__indirect_glTexCoord3fv(const GLfloat * v)
+{
+    generic_12_byte( X_GLrop_TexCoord3fv, v );
+}
+
+#define X_GLrop_TexCoord3iv 59
+void
+__indirect_glTexCoord3i(GLint s, GLint t, GLint r)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_TexCoord3iv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexCoord3iv 59
+void
+__indirect_glTexCoord3iv(const GLint * v)
+{
+    generic_12_byte( X_GLrop_TexCoord3iv, v );
+}
+
+#define X_GLrop_TexCoord3sv 60
+void
+__indirect_glTexCoord3s(GLshort s, GLshort t, GLshort r)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_TexCoord3sv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexCoord3sv 60
+void
+__indirect_glTexCoord3sv(const GLshort * v)
+{
+    generic_6_byte( X_GLrop_TexCoord3sv, v );
+}
+
+#define X_GLrop_TexCoord4dv 61
+void
+__indirect_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 36;
+    emit_header(gc->pc, X_GLrop_TexCoord4dv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexCoord4dv 61
+void
+__indirect_glTexCoord4dv(const GLdouble * v)
+{
+    generic_32_byte( X_GLrop_TexCoord4dv, v );
+}
+
+#define X_GLrop_TexCoord4fv 62
+void
+__indirect_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_TexCoord4fv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexCoord4fv 62
+void
+__indirect_glTexCoord4fv(const GLfloat * v)
+{
+    generic_16_byte( X_GLrop_TexCoord4fv, v );
+}
+
+#define X_GLrop_TexCoord4iv 63
+void
+__indirect_glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_TexCoord4iv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexCoord4iv 63
+void
+__indirect_glTexCoord4iv(const GLint * v)
+{
+    generic_16_byte( X_GLrop_TexCoord4iv, v );
+}
+
+#define X_GLrop_TexCoord4sv 64
+void
+__indirect_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_TexCoord4sv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&q), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexCoord4sv 64
+void
+__indirect_glTexCoord4sv(const GLshort * v)
+{
+    generic_8_byte( X_GLrop_TexCoord4sv, v );
+}
+
+#define X_GLrop_Vertex2dv 65
+void
+__indirect_glVertex2d(GLdouble x, GLdouble y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_Vertex2dv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Vertex2dv 65
+void
+__indirect_glVertex2dv(const GLdouble * v)
+{
+    generic_16_byte( X_GLrop_Vertex2dv, v );
+}
+
+#define X_GLrop_Vertex2fv 66
+void
+__indirect_glVertex2f(GLfloat x, GLfloat y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_Vertex2fv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Vertex2fv 66
+void
+__indirect_glVertex2fv(const GLfloat * v)
+{
+    generic_8_byte( X_GLrop_Vertex2fv, v );
+}
+
+#define X_GLrop_Vertex2iv 67
+void
+__indirect_glVertex2i(GLint x, GLint y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_Vertex2iv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Vertex2iv 67
+void
+__indirect_glVertex2iv(const GLint * v)
+{
+    generic_8_byte( X_GLrop_Vertex2iv, v );
+}
+
+#define X_GLrop_Vertex2sv 68
+void
+__indirect_glVertex2s(GLshort x, GLshort y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_Vertex2sv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Vertex2sv 68
+void
+__indirect_glVertex2sv(const GLshort * v)
+{
+    generic_4_byte( X_GLrop_Vertex2sv, v );
+}
+
+#define X_GLrop_Vertex3dv 69
+void
+__indirect_glVertex3d(GLdouble x, GLdouble y, GLdouble z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_Vertex3dv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Vertex3dv 69
+void
+__indirect_glVertex3dv(const GLdouble * v)
+{
+    generic_24_byte( X_GLrop_Vertex3dv, v );
+}
+
+#define X_GLrop_Vertex3fv 70
+void
+__indirect_glVertex3f(GLfloat x, GLfloat y, GLfloat z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_Vertex3fv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Vertex3fv 70
+void
+__indirect_glVertex3fv(const GLfloat * v)
+{
+    generic_12_byte( X_GLrop_Vertex3fv, v );
+}
+
+#define X_GLrop_Vertex3iv 71
+void
+__indirect_glVertex3i(GLint x, GLint y, GLint z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_Vertex3iv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Vertex3iv 71
+void
+__indirect_glVertex3iv(const GLint * v)
+{
+    generic_12_byte( X_GLrop_Vertex3iv, v );
+}
+
+#define X_GLrop_Vertex3sv 72
+void
+__indirect_glVertex3s(GLshort x, GLshort y, GLshort z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_Vertex3sv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Vertex3sv 72
+void
+__indirect_glVertex3sv(const GLshort * v)
+{
+    generic_6_byte( X_GLrop_Vertex3sv, v );
+}
+
+#define X_GLrop_Vertex4dv 73
+void
+__indirect_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 36;
+    emit_header(gc->pc, X_GLrop_Vertex4dv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Vertex4dv 73
+void
+__indirect_glVertex4dv(const GLdouble * v)
+{
+    generic_32_byte( X_GLrop_Vertex4dv, v );
+}
+
+#define X_GLrop_Vertex4fv 74
+void
+__indirect_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_Vertex4fv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Vertex4fv 74
+void
+__indirect_glVertex4fv(const GLfloat * v)
+{
+    generic_16_byte( X_GLrop_Vertex4fv, v );
+}
+
+#define X_GLrop_Vertex4iv 75
+void
+__indirect_glVertex4i(GLint x, GLint y, GLint z, GLint w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_Vertex4iv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Vertex4iv 75
+void
+__indirect_glVertex4iv(const GLint * v)
+{
+    generic_16_byte( X_GLrop_Vertex4iv, v );
+}
+
+#define X_GLrop_Vertex4sv 76
+void
+__indirect_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_Vertex4sv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Vertex4sv 76
+void
+__indirect_glVertex4sv(const GLshort * v)
+{
+    generic_8_byte( X_GLrop_Vertex4sv, v );
+}
+
+#define X_GLrop_ClipPlane 77
+void
+__indirect_glClipPlane(GLenum plane, const GLdouble * equation)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 40;
+    emit_header(gc->pc, X_GLrop_ClipPlane, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(equation), 32);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&plane), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ColorMaterial 78
+void
+__indirect_glColorMaterial(GLenum face, GLenum mode)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_ColorMaterial, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_CullFace 79
+void
+__indirect_glCullFace(GLenum mode)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_CullFace, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Fogf 80
+void
+__indirect_glFogf(GLenum pname, GLfloat param)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_Fogf, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Fogfv 81
+void
+__indirect_glFogfv(GLenum pname, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glFogfv_size(pname);
+    const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_Fogfv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Fogi 82
+void
+__indirect_glFogi(GLenum pname, GLint param)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_Fogi, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Fogiv 83
+void
+__indirect_glFogiv(GLenum pname, const GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glFogiv_size(pname);
+    const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_Fogiv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_FrontFace 84
+void
+__indirect_glFrontFace(GLenum mode)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_FrontFace, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Hint 85
+void
+__indirect_glHint(GLenum target, GLenum mode)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_Hint, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Lightf 86
+void
+__indirect_glLightf(GLenum light, GLenum pname, GLfloat param)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_Lightf, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Lightfv 87
+void
+__indirect_glLightfv(GLenum light, GLenum pname, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glLightfv_size(pname);
+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_Lightfv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Lighti 88
+void
+__indirect_glLighti(GLenum light, GLenum pname, GLint param)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_Lighti, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Lightiv 89
+void
+__indirect_glLightiv(GLenum light, GLenum pname, const GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glLightiv_size(pname);
+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_Lightiv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_LightModelf 90
+void
+__indirect_glLightModelf(GLenum pname, GLfloat param)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_LightModelf, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_LightModelfv 91
+void
+__indirect_glLightModelfv(GLenum pname, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glLightModelfv_size(pname);
+    const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_LightModelfv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_LightModeli 92
+void
+__indirect_glLightModeli(GLenum pname, GLint param)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_LightModeli, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_LightModeliv 93
+void
+__indirect_glLightModeliv(GLenum pname, const GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glLightModeliv_size(pname);
+    const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_LightModeliv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_LineStipple 94
+void
+__indirect_glLineStipple(GLint factor, GLushort pattern)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_LineStipple, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pattern), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_LineWidth 95
+void
+__indirect_glLineWidth(GLfloat width)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_LineWidth, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&width), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Materialf 96
+void
+__indirect_glMaterialf(GLenum face, GLenum pname, GLfloat param)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_Materialf, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Materialfv 97
+void
+__indirect_glMaterialfv(GLenum face, GLenum pname, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glMaterialfv_size(pname);
+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_Materialfv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Materiali 98
+void
+__indirect_glMateriali(GLenum face, GLenum pname, GLint param)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_Materiali, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Materialiv 99
+void
+__indirect_glMaterialiv(GLenum face, GLenum pname, const GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glMaterialiv_size(pname);
+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_Materialiv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PointSize 100
+void
+__indirect_glPointSize(GLfloat size)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_PointSize, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&size), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PolygonMode 101
+void
+__indirect_glPolygonMode(GLenum face, GLenum mode)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_PolygonMode, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PolygonStipple 102
+void
+__indirect_glPolygonStipple(const GLubyte * mask)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = (mask != NULL) ? __glImageSize(32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, 0) : 0;
+    const GLuint cmdlen = 24 + __GLX_PAD(compsize);
+    emit_header(gc->pc, X_GLrop_PolygonStipple, cmdlen);
+    if (compsize > 0) {
+        (*gc->fillImage)(gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask, gc->pc + 24, gc->pc + 4);
+    }
+    else {
+        (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+    }
+    gc->pc += cmdlen;
+    if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Scissor 103
+void
+__indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_Scissor, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ShadeModel 104
+void
+__indirect_glShadeModel(GLenum mode)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_ShadeModel, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexParameterf 105
+void
+__indirect_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_TexParameterf, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexParameterfv 106
+void
+__indirect_glTexParameterfv(GLenum target, GLenum pname, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glTexParameterfv_size(pname);
+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_TexParameterfv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexParameteri 107
+void
+__indirect_glTexParameteri(GLenum target, GLenum pname, GLint param)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_TexParameteri, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexParameteriv 108
+void
+__indirect_glTexParameteriv(GLenum target, GLenum pname, const GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glTexParameteriv_size(pname);
+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_TexParameteriv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+static void
+__glx_TexImage_1D2D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glImageSize(width, height, 1, format, type, target);
+    const GLuint cmdlen = 56 + __GLX_PAD(compsize);
+    if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+        if (cmdlen <= gc->maxSmallRenderCommandSize) {
+            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+            emit_header(gc->pc, opcode, cmdlen);
+            (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
+            (void) memcpy((void *)(gc->pc + 28), (void *)(&level), 4);
+            (void) memcpy((void *)(gc->pc + 32), (void *)(&internalformat), 4);
+            (void) memcpy((void *)(gc->pc + 36), (void *)(&width), 4);
+            (void) memcpy((void *)(gc->pc + 40), (void *)(&height), 4);
+            (void) memcpy((void *)(gc->pc + 44), (void *)(&border), 4);
+            (void) memcpy((void *)(gc->pc + 48), (void *)(&format), 4);
+            (void) memcpy((void *)(gc->pc + 52), (void *)(&type), 4);
+            if ((compsize > 0) && (pixels != NULL)) {
+                (*gc->fillImage)(gc, dim, width, height, 1, format, type, pixels, gc->pc + 56, gc->pc + 4);
+            }
+            else {
+                (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+            }
+            gc->pc += cmdlen;
+            if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        }
+        else {
+            const GLint op = opcode;
+            const GLuint cmdlenLarge = cmdlen + 4;
+            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+            (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
+            (void) memcpy((void *)(pc + 32), (void *)(&level), 4);
+            (void) memcpy((void *)(pc + 36), (void *)(&internalformat), 4);
+            (void) memcpy((void *)(pc + 40), (void *)(&width), 4);
+            (void) memcpy((void *)(pc + 44), (void *)(&height), 4);
+            (void) memcpy((void *)(pc + 48), (void *)(&border), 4);
+            (void) memcpy((void *)(pc + 52), (void *)(&format), 4);
+            (void) memcpy((void *)(pc + 56), (void *)(&type), 4);
+            __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, pixels, pc + 60, pc + 8);
+        }
+    }
+}
+
+#define X_GLrop_TexImage1D 109
+void
+__indirect_glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
+{
+    __glx_TexImage_1D2D(X_GLrop_TexImage1D, 1, target, level, internalformat, width, 1, border, format, type, pixels );
+}
+
+#define X_GLrop_TexImage2D 110
+void
+__indirect_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
+{
+    __glx_TexImage_1D2D(X_GLrop_TexImage2D, 2, target, level, internalformat, width, height, border, format, type, pixels );
+}
+
+#define X_GLrop_TexEnvf 111
+void
+__indirect_glTexEnvf(GLenum target, GLenum pname, GLfloat param)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_TexEnvf, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexEnvfv 112
+void
+__indirect_glTexEnvfv(GLenum target, GLenum pname, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glTexEnvfv_size(pname);
+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_TexEnvfv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexEnvi 113
+void
+__indirect_glTexEnvi(GLenum target, GLenum pname, GLint param)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_TexEnvi, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexEnviv 114
+void
+__indirect_glTexEnviv(GLenum target, GLenum pname, const GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glTexEnviv_size(pname);
+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_TexEnviv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexGend 115
+void
+__indirect_glTexGend(GLenum coord, GLenum pname, GLdouble param)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_TexGend, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&param), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&coord), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&pname), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexGendv 116
+void
+__indirect_glTexGendv(GLenum coord, GLenum pname, const GLdouble * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glTexGendv_size(pname);
+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8));
+    emit_header(gc->pc, X_GLrop_TexGendv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 8));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexGenf 117
+void
+__indirect_glTexGenf(GLenum coord, GLenum pname, GLfloat param)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_TexGenf, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexGenfv 118
+void
+__indirect_glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glTexGenfv_size(pname);
+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_TexGenfv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexGeni 119
+void
+__indirect_glTexGeni(GLenum coord, GLenum pname, GLint param)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_TexGeni, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_TexGeniv 120
+void
+__indirect_glTexGeniv(GLenum coord, GLenum pname, const GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glTexGeniv_size(pname);
+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_TexGeniv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_InitNames 121
+void
+__indirect_glInitNames(void)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 4;
+    emit_header(gc->pc, X_GLrop_InitNames, cmdlen);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_LoadName 122
+void
+__indirect_glLoadName(GLuint name)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_LoadName, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PassThrough 123
+void
+__indirect_glPassThrough(GLfloat token)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_PassThrough, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&token), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PopName 124
+void
+__indirect_glPopName(void)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 4;
+    emit_header(gc->pc, X_GLrop_PopName, cmdlen);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PushName 125
+void
+__indirect_glPushName(GLuint name)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_PushName, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_DrawBuffer 126
+void
+__indirect_glDrawBuffer(GLenum mode)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_DrawBuffer, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Clear 127
+void
+__indirect_glClear(GLbitfield mask)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_Clear, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ClearAccum 128
+void
+__indirect_glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_ClearAccum, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ClearIndex 129
+void
+__indirect_glClearIndex(GLfloat c)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_ClearIndex, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ClearColor 130
+void
+__indirect_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_ClearColor, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ClearStencil 131
+void
+__indirect_glClearStencil(GLint s)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_ClearStencil, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ClearDepth 132
+void
+__indirect_glClearDepth(GLclampd depth)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_ClearDepth, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&depth), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_StencilMask 133
+void
+__indirect_glStencilMask(GLuint mask)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_StencilMask, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ColorMask 134
+void
+__indirect_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_ColorMask, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
+    (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
+    (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_DepthMask 135
+void
+__indirect_glDepthMask(GLboolean flag)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_DepthMask, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_IndexMask 136
+void
+__indirect_glIndexMask(GLuint mask)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_IndexMask, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Accum 137
+void
+__indirect_glAccum(GLenum op, GLfloat value)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_Accum, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&op), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&value), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PopAttrib 141
+void
+__indirect_glPopAttrib(void)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 4;
+    emit_header(gc->pc, X_GLrop_PopAttrib, cmdlen);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PushAttrib 142
+void
+__indirect_glPushAttrib(GLbitfield mask)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_PushAttrib, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MapGrid1d 147
+void
+__indirect_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_MapGrid1d, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&un), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MapGrid1f 148
+void
+__indirect_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_MapGrid1f, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MapGrid2d 149
+void
+__indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 44;
+    emit_header(gc->pc, X_GLrop_MapGrid2d, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&v1), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&v2), 8);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&un), 4);
+    (void) memcpy((void *)(gc->pc + 40), (void *)(&vn), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MapGrid2f 150
+void
+__indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_MapGrid2f, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&vn), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&v1), 4);
+    (void) memcpy((void *)(gc->pc + 24), (void *)(&v2), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_EvalCoord1dv 151
+void
+__indirect_glEvalCoord1d(GLdouble u)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_EvalCoord1dv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_EvalCoord1dv 151
+void
+__indirect_glEvalCoord1dv(const GLdouble * u)
+{
+    generic_8_byte( X_GLrop_EvalCoord1dv, u );
+}
+
+#define X_GLrop_EvalCoord1fv 152
+void
+__indirect_glEvalCoord1f(GLfloat u)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_EvalCoord1fv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_EvalCoord1fv 152
+void
+__indirect_glEvalCoord1fv(const GLfloat * u)
+{
+    generic_4_byte( X_GLrop_EvalCoord1fv, u );
+}
+
+#define X_GLrop_EvalCoord2dv 153
+void
+__indirect_glEvalCoord2d(GLdouble u, GLdouble v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_EvalCoord2dv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&v), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_EvalCoord2dv 153
+void
+__indirect_glEvalCoord2dv(const GLdouble * u)
+{
+    generic_16_byte( X_GLrop_EvalCoord2dv, u );
+}
+
+#define X_GLrop_EvalCoord2fv 154
+void
+__indirect_glEvalCoord2f(GLfloat u, GLfloat v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_EvalCoord2fv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_EvalCoord2fv 154
+void
+__indirect_glEvalCoord2fv(const GLfloat * u)
+{
+    generic_8_byte( X_GLrop_EvalCoord2fv, u );
+}
+
+#define X_GLrop_EvalMesh1 155
+void
+__indirect_glEvalMesh1(GLenum mode, GLint i1, GLint i2)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_EvalMesh1, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&i2), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_EvalPoint1 156
+void
+__indirect_glEvalPoint1(GLint i)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_EvalPoint1, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_EvalMesh2 157
+void
+__indirect_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_EvalMesh2, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&i2), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&j1), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&j2), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_EvalPoint2 158
+void
+__indirect_glEvalPoint2(GLint i, GLint j)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_EvalPoint2, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&j), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_AlphaFunc 159
+void
+__indirect_glAlphaFunc(GLenum func, GLclampf ref)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_AlphaFunc, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_BlendFunc 160
+void
+__indirect_glBlendFunc(GLenum sfactor, GLenum dfactor)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_BlendFunc, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&sfactor), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&dfactor), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_LogicOp 161
+void
+__indirect_glLogicOp(GLenum opcode)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_LogicOp, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&opcode), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_StencilFunc 162
+void
+__indirect_glStencilFunc(GLenum func, GLint ref, GLuint mask)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_StencilFunc, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&mask), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_StencilOp 163
+void
+__indirect_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_StencilOp, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&fail), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&zfail), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&zpass), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_DepthFunc 164
+void
+__indirect_glDepthFunc(GLenum func)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_DepthFunc, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PixelZoom 165
+void
+__indirect_glPixelZoom(GLfloat xfactor, GLfloat yfactor)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_PixelZoom, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&xfactor), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&yfactor), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PixelTransferf 166
+void
+__indirect_glPixelTransferf(GLenum pname, GLfloat param)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_PixelTransferf, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PixelTransferi 167
+void
+__indirect_glPixelTransferi(GLenum pname, GLint param)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_PixelTransferi, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PixelMapfv 168
+void
+__indirect_glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat * values)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
+    if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
+        if (cmdlen <= gc->maxSmallRenderCommandSize) {
+            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+            emit_header(gc->pc, X_GLrop_PixelMapfv, cmdlen);
+            (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
+            (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
+            (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4));
+            gc->pc += cmdlen;
+            if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        }
+        else {
+            const GLint op = X_GLrop_PixelMapfv;
+            const GLuint cmdlenLarge = cmdlen + 4;
+            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+            (void) memcpy((void *)(pc + 8), (void *)(&map), 4);
+            (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
+            __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
+        }
+    }
+}
+
+#define X_GLrop_PixelMapuiv 169
+void
+__indirect_glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint * values)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
+    if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
+        if (cmdlen <= gc->maxSmallRenderCommandSize) {
+            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+            emit_header(gc->pc, X_GLrop_PixelMapuiv, cmdlen);
+            (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
+            (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
+            (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4));
+            gc->pc += cmdlen;
+            if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        }
+        else {
+            const GLint op = X_GLrop_PixelMapuiv;
+            const GLuint cmdlenLarge = cmdlen + 4;
+            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+            (void) memcpy((void *)(pc + 8), (void *)(&map), 4);
+            (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
+            __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
+        }
+    }
+}
+
+#define X_GLrop_PixelMapusv 170
+void
+__indirect_glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort * values)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 2));
+    if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
+        if (cmdlen <= gc->maxSmallRenderCommandSize) {
+            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+            emit_header(gc->pc, X_GLrop_PixelMapusv, cmdlen);
+            (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
+            (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
+            (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 2));
+            gc->pc += cmdlen;
+            if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        }
+        else {
+            const GLint op = X_GLrop_PixelMapusv;
+            const GLuint cmdlenLarge = cmdlen + 4;
+            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+            (void) memcpy((void *)(pc + 8), (void *)(&map), 4);
+            (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
+            __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 2));
+        }
+    }
+}
+
+#define X_GLrop_ReadBuffer 171
+void
+__indirect_glReadBuffer(GLenum mode)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_ReadBuffer, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_CopyPixels 172
+void
+__indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_CopyPixels, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&type), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLsop_ReadPixels 111
+void
+__indirect_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const __GLXattribute * const state = gc->client_state_private;
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 28;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxReadPixelsRep *reply = XCBGlxReadPixelsReply(c, XCBGlxReadPixels(c, gc->currentContextTag, x, y, width, height, format, type, state->storePack.swapEndian, 0), NULL);
+        (void)memcpy(pixels, XCBGlxReadPixelsData(reply), XCBGlxReadPixelsDataLength(reply) * sizeof(GLvoid));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_ReadPixels, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&x), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&y), 4);
+        (void) memcpy((void *)(pc + 8), (void *)(&width), 4);
+        (void) memcpy((void *)(pc + 12), (void *)(&height), 4);
+        (void) memcpy((void *)(pc + 16), (void *)(&format), 4);
+        (void) memcpy((void *)(pc + 20), (void *)(&type), 4);
+        *(int32_t *)(pc + 24) = 0;
+        * (int8_t *)(pc + 24) = state->storePack.swapEndian;
+        __glXReadPixelReply(dpy, gc, 2, width, height, 1, format, type, pixels, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLrop_DrawPixels 173
+void
+__indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, 1, format, type, 0) : 0;
+    const GLuint cmdlen = 40 + __GLX_PAD(compsize);
+    if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+        if (cmdlen <= gc->maxSmallRenderCommandSize) {
+            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+            emit_header(gc->pc, X_GLrop_DrawPixels, cmdlen);
+            (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
+            (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
+            (void) memcpy((void *)(gc->pc + 32), (void *)(&format), 4);
+            (void) memcpy((void *)(gc->pc + 36), (void *)(&type), 4);
+            if (compsize > 0) {
+                (*gc->fillImage)(gc, 2, width, height, 1, format, type, pixels, gc->pc + 40, gc->pc + 4);
+            }
+            else {
+                (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+            }
+            gc->pc += cmdlen;
+            if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        }
+        else {
+            const GLint op = X_GLrop_DrawPixels;
+            const GLuint cmdlenLarge = cmdlen + 4;
+            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+            (void) memcpy((void *)(pc + 28), (void *)(&width), 4);
+            (void) memcpy((void *)(pc + 32), (void *)(&height), 4);
+            (void) memcpy((void *)(pc + 36), (void *)(&format), 4);
+            (void) memcpy((void *)(pc + 40), (void *)(&type), 4);
+            __glXSendLargeImage(gc, compsize, 2, width, height, 1, format, type, pixels, pc + 44, pc + 8);
+        }
+    }
+}
+
+#define X_GLsop_GetClipPlane 113
+void
+__indirect_glGetClipPlane(GLenum plane, GLdouble * equation)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetClipPlaneRep *reply = XCBGlxGetClipPlaneReply(c, XCBGlxGetClipPlane(c, gc->currentContextTag, plane), NULL);
+        (void)memcpy(equation, XCBGlxGetClipPlaneData(reply), XCBGlxGetClipPlaneDataLength(reply) * sizeof(GLdouble));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetClipPlane, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&plane), 4);
+        (void) __glXReadReply(dpy, 8, equation, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetLightfv 118
+void
+__indirect_glGetLightfv(GLenum light, GLenum pname, GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetLightfvRep *reply = XCBGlxGetLightfvReply(c, XCBGlxGetLightfv(c, gc->currentContextTag, light, pname), NULL);
+        if (XCBGlxGetLightfvDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetLightfvData(reply), XCBGlxGetLightfvDataLength(reply) * sizeof(GLfloat));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetLightfv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&light), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetLightiv 119
+void
+__indirect_glGetLightiv(GLenum light, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetLightivRep *reply = XCBGlxGetLightivReply(c, XCBGlxGetLightiv(c, gc->currentContextTag, light, pname), NULL);
+        if (XCBGlxGetLightivDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetLightivData(reply), XCBGlxGetLightivDataLength(reply) * sizeof(GLint));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetLightiv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&light), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetMapdv 120
+void
+__indirect_glGetMapdv(GLenum target, GLenum query, GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetMapdvRep *reply = XCBGlxGetMapdvReply(c, XCBGlxGetMapdv(c, gc->currentContextTag, target, query), NULL);
+        if (XCBGlxGetMapdvDataLength(reply) == 0)
+            (void)memcpy(v, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(v, XCBGlxGetMapdvData(reply), XCBGlxGetMapdvDataLength(reply) * sizeof(GLdouble));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapdv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
+        (void) __glXReadReply(dpy, 8, v, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetMapfv 121
+void
+__indirect_glGetMapfv(GLenum target, GLenum query, GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetMapfvRep *reply = XCBGlxGetMapfvReply(c, XCBGlxGetMapfv(c, gc->currentContextTag, target, query), NULL);
+        if (XCBGlxGetMapfvDataLength(reply) == 0)
+            (void)memcpy(v, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(v, XCBGlxGetMapfvData(reply), XCBGlxGetMapfvDataLength(reply) * sizeof(GLfloat));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapfv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
+        (void) __glXReadReply(dpy, 4, v, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetMapiv 122
+void
+__indirect_glGetMapiv(GLenum target, GLenum query, GLint * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetMapivRep *reply = XCBGlxGetMapivReply(c, XCBGlxGetMapiv(c, gc->currentContextTag, target, query), NULL);
+        if (XCBGlxGetMapivDataLength(reply) == 0)
+            (void)memcpy(v, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(v, XCBGlxGetMapivData(reply), XCBGlxGetMapivDataLength(reply) * sizeof(GLint));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapiv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
+        (void) __glXReadReply(dpy, 4, v, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetMaterialfv 123
+void
+__indirect_glGetMaterialfv(GLenum face, GLenum pname, GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetMaterialfvRep *reply = XCBGlxGetMaterialfvReply(c, XCBGlxGetMaterialfv(c, gc->currentContextTag, face, pname), NULL);
+        if (XCBGlxGetMaterialfvDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetMaterialfvData(reply), XCBGlxGetMaterialfvDataLength(reply) * sizeof(GLfloat));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMaterialfv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&face), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetMaterialiv 124
+void
+__indirect_glGetMaterialiv(GLenum face, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetMaterialivRep *reply = XCBGlxGetMaterialivReply(c, XCBGlxGetMaterialiv(c, gc->currentContextTag, face, pname), NULL);
+        if (XCBGlxGetMaterialivDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetMaterialivData(reply), XCBGlxGetMaterialivDataLength(reply) * sizeof(GLint));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMaterialiv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&face), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetPixelMapfv 125
+void
+__indirect_glGetPixelMapfv(GLenum map, GLfloat * values)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetPixelMapfvRep *reply = XCBGlxGetPixelMapfvReply(c, XCBGlxGetPixelMapfv(c, gc->currentContextTag, map), NULL);
+        if (XCBGlxGetPixelMapfvDataLength(reply) == 0)
+            (void)memcpy(values, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(values, XCBGlxGetPixelMapfvData(reply), XCBGlxGetPixelMapfvDataLength(reply) * sizeof(GLfloat));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapfv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
+        (void) __glXReadReply(dpy, 4, values, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetPixelMapuiv 126
+void
+__indirect_glGetPixelMapuiv(GLenum map, GLuint * values)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetPixelMapuivRep *reply = XCBGlxGetPixelMapuivReply(c, XCBGlxGetPixelMapuiv(c, gc->currentContextTag, map), NULL);
+        if (XCBGlxGetPixelMapuivDataLength(reply) == 0)
+            (void)memcpy(values, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(values, XCBGlxGetPixelMapuivData(reply), XCBGlxGetPixelMapuivDataLength(reply) * sizeof(GLuint));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapuiv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
+        (void) __glXReadReply(dpy, 4, values, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetPixelMapusv 127
+void
+__indirect_glGetPixelMapusv(GLenum map, GLushort * values)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetPixelMapusvRep *reply = XCBGlxGetPixelMapusvReply(c, XCBGlxGetPixelMapusv(c, gc->currentContextTag, map), NULL);
+        if (XCBGlxGetPixelMapusvDataLength(reply) == 0)
+            (void)memcpy(values, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(values, XCBGlxGetPixelMapusvData(reply), XCBGlxGetPixelMapusvDataLength(reply) * sizeof(GLushort));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapusv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
+        (void) __glXReadReply(dpy, 2, values, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetPolygonStipple 128
+void
+__indirect_glGetPolygonStipple(GLubyte * mask)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const __GLXattribute * const state = gc->client_state_private;
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetPolygonStippleRep *reply = XCBGlxGetPolygonStippleReply(c, XCBGlxGetPolygonStipple(c, gc->currentContextTag, 0), NULL);
+        (void)memcpy(mask, XCBGlxGetPolygonStippleData(reply), XCBGlxGetPolygonStippleDataLength(reply) * sizeof(GLubyte));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPolygonStipple, cmdlen);
+        *(int32_t *)(pc + 0) = 0;
+        __glXReadPixelReply(dpy, gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetTexEnvfv 130
+void
+__indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetTexEnvfvRep *reply = XCBGlxGetTexEnvfvReply(c, XCBGlxGetTexEnvfv(c, gc->currentContextTag, target, pname), NULL);
+        if (XCBGlxGetTexEnvfvDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetTexEnvfvData(reply), XCBGlxGetTexEnvfvDataLength(reply) * sizeof(GLfloat));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexEnvfv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetTexEnviv 131
+void
+__indirect_glGetTexEnviv(GLenum target, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetTexEnvivRep *reply = XCBGlxGetTexEnvivReply(c, XCBGlxGetTexEnviv(c, gc->currentContextTag, target, pname), NULL);
+        if (XCBGlxGetTexEnvivDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetTexEnvivData(reply), XCBGlxGetTexEnvivDataLength(reply) * sizeof(GLint));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexEnviv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetTexGendv 132
+void
+__indirect_glGetTexGendv(GLenum coord, GLenum pname, GLdouble * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetTexGendvRep *reply = XCBGlxGetTexGendvReply(c, XCBGlxGetTexGendv(c, gc->currentContextTag, coord, pname), NULL);
+        if (XCBGlxGetTexGendvDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetTexGendvData(reply), XCBGlxGetTexGendvDataLength(reply) * sizeof(GLdouble));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGendv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 8, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetTexGenfv 133
+void
+__indirect_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetTexGenfvRep *reply = XCBGlxGetTexGenfvReply(c, XCBGlxGetTexGenfv(c, gc->currentContextTag, coord, pname), NULL);
+        if (XCBGlxGetTexGenfvDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetTexGenfvData(reply), XCBGlxGetTexGenfvDataLength(reply) * sizeof(GLfloat));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGenfv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetTexGeniv 134
+void
+__indirect_glGetTexGeniv(GLenum coord, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetTexGenivRep *reply = XCBGlxGetTexGenivReply(c, XCBGlxGetTexGeniv(c, gc->currentContextTag, coord, pname), NULL);
+        if (XCBGlxGetTexGenivDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetTexGenivData(reply), XCBGlxGetTexGenivDataLength(reply) * sizeof(GLint));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGeniv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetTexImage 135
+void
+__indirect_glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const __GLXattribute * const state = gc->client_state_private;
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 20;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetTexImageRep *reply = XCBGlxGetTexImageReply(c, XCBGlxGetTexImage(c, gc->currentContextTag, target, level, format, type, state->storePack.swapEndian), NULL);
+        (void)memcpy(pixels, XCBGlxGetTexImageData(reply), XCBGlxGetTexImageDataLength(reply) * sizeof(GLvoid));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexImage, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&level), 4);
+        (void) memcpy((void *)(pc + 8), (void *)(&format), 4);
+        (void) memcpy((void *)(pc + 12), (void *)(&type), 4);
+        *(int32_t *)(pc + 16) = 0;
+        * (int8_t *)(pc + 16) = state->storePack.swapEndian;
+        __glXReadPixelReply(dpy, gc, 3, 0, 0, 0, format, type, pixels, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetTexParameterfv 136
+void
+__indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetTexParameterfvRep *reply = XCBGlxGetTexParameterfvReply(c, XCBGlxGetTexParameterfv(c, gc->currentContextTag, target, pname), NULL);
+        if (XCBGlxGetTexParameterfvDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetTexParameterfvData(reply), XCBGlxGetTexParameterfvDataLength(reply) * sizeof(GLfloat));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexParameterfv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetTexParameteriv 137
+void
+__indirect_glGetTexParameteriv(GLenum target, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetTexParameterivRep *reply = XCBGlxGetTexParameterivReply(c, XCBGlxGetTexParameteriv(c, gc->currentContextTag, target, pname), NULL);
+        if (XCBGlxGetTexParameterivDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetTexParameterivData(reply), XCBGlxGetTexParameterivDataLength(reply) * sizeof(GLint));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexParameteriv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetTexLevelParameterfv 138
+void
+__indirect_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 12;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetTexLevelParameterfvRep *reply = XCBGlxGetTexLevelParameterfvReply(c, XCBGlxGetTexLevelParameterfv(c, gc->currentContextTag, target, level, pname), NULL);
+        if (XCBGlxGetTexLevelParameterfvDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetTexLevelParameterfvData(reply), XCBGlxGetTexLevelParameterfvDataLength(reply) * sizeof(GLfloat));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameterfv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&level), 4);
+        (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetTexLevelParameteriv 139
+void
+__indirect_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 12;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetTexLevelParameterivRep *reply = XCBGlxGetTexLevelParameterivReply(c, XCBGlxGetTexLevelParameteriv(c, gc->currentContextTag, target, level, pname), NULL);
+        if (XCBGlxGetTexLevelParameterivDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetTexLevelParameterivData(reply), XCBGlxGetTexLevelParameterivDataLength(reply) * sizeof(GLint));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameteriv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&level), 4);
+        (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_IsList 141
+GLboolean
+__indirect_glIsList(GLuint list)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    GLboolean retval = (GLboolean) 0;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxIsListRep *reply = XCBGlxIsListReply(c, XCBGlxIsList(c, gc->currentContextTag, list), NULL);
+        retval = reply->ret_val;
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsList, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
+        retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return retval;
+}
+
+#define X_GLrop_DepthRange 174
+void
+__indirect_glDepthRange(GLclampd zNear, GLclampd zFar)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_DepthRange, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&zNear), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&zFar), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Frustum 175
+void
+__indirect_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 52;
+    emit_header(gc->pc, X_GLrop_Frustum, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&bottom), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&top), 8);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8);
+    (void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_LoadIdentity 176
+void
+__indirect_glLoadIdentity(void)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 4;
+    emit_header(gc->pc, X_GLrop_LoadIdentity, cmdlen);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_LoadMatrixf 177
+void
+__indirect_glLoadMatrixf(const GLfloat * m)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 68;
+    emit_header(gc->pc, X_GLrop_LoadMatrixf, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(m), 64);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_LoadMatrixd 178
+void
+__indirect_glLoadMatrixd(const GLdouble * m)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 132;
+    emit_header(gc->pc, X_GLrop_LoadMatrixd, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(m), 128);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MatrixMode 179
+void
+__indirect_glMatrixMode(GLenum mode)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_MatrixMode, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultMatrixf 180
+void
+__indirect_glMultMatrixf(const GLfloat * m)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 68;
+    emit_header(gc->pc, X_GLrop_MultMatrixf, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(m), 64);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultMatrixd 181
+void
+__indirect_glMultMatrixd(const GLdouble * m)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 132;
+    emit_header(gc->pc, X_GLrop_MultMatrixd, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(m), 128);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Ortho 182
+void
+__indirect_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 52;
+    emit_header(gc->pc, X_GLrop_Ortho, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&bottom), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&top), 8);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8);
+    (void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PopMatrix 183
+void
+__indirect_glPopMatrix(void)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 4;
+    emit_header(gc->pc, X_GLrop_PopMatrix, cmdlen);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PushMatrix 184
+void
+__indirect_glPushMatrix(void)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 4;
+    emit_header(gc->pc, X_GLrop_PushMatrix, cmdlen);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Rotated 185
+void
+__indirect_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 36;
+    emit_header(gc->pc, X_GLrop_Rotated, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Rotatef 186
+void
+__indirect_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_Rotatef, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Scaled 187
+void
+__indirect_glScaled(GLdouble x, GLdouble y, GLdouble z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_Scaled, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Scalef 188
+void
+__indirect_glScalef(GLfloat x, GLfloat y, GLfloat z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_Scalef, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Translated 189
+void
+__indirect_glTranslated(GLdouble x, GLdouble y, GLdouble z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_Translated, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Translatef 190
+void
+__indirect_glTranslatef(GLfloat x, GLfloat y, GLfloat z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_Translatef, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Viewport 191
+void
+__indirect_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_Viewport, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_BindTexture 4117
+void
+__indirect_glBindTexture(GLenum target, GLuint texture)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_BindTexture, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&texture), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Indexubv 194
+void
+__indirect_glIndexub(GLubyte c)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Indexubv 194
+void
+__indirect_glIndexubv(const GLubyte * c)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(c), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PolygonOffset 192
+void
+__indirect_glPolygonOffset(GLfloat factor, GLfloat units)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_PolygonOffset, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&units), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLsop_AreTexturesResident 143
+GLboolean
+__indirect_glAreTexturesResident(GLsizei n, const GLuint * textures, GLboolean * residences)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    GLboolean retval = (GLboolean) 0;
+    const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
+    if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxAreTexturesResidentRep *reply = XCBGlxAreTexturesResidentReply(c, XCBGlxAreTexturesResident(c, gc->currentContextTag, n, textures), NULL);
+        (void)memcpy(residences, XCBGlxAreTexturesResidentData(reply), XCBGlxAreTexturesResidentDataLength(reply) * sizeof(GLboolean));
+        retval = reply->ret_val;
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_AreTexturesResident, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
+        retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return retval;
+}
+
+#define X_GLrop_CopyTexImage1D 4119
+void
+__indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 32;
+    emit_header(gc->pc, X_GLrop_CopyTexImage1D, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&border), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_CopyTexImage2D 4120
+void
+__indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 36;
+    emit_header(gc->pc, X_GLrop_CopyTexImage2D, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
+    (void) memcpy((void *)(gc->pc + 32), (void *)(&border), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_CopyTexSubImage1D 4121
+void
+__indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_CopyTexSubImage1D, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_CopyTexSubImage2D 4122
+void
+__indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 36;
+    emit_header(gc->pc, X_GLrop_CopyTexSubImage2D, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&yoffset), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 24), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&width), 4);
+    (void) memcpy((void *)(gc->pc + 32), (void *)(&height), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLvop_DeleteTextures 12
+void
+__indirect_glDeleteTextures(GLsizei n, const GLuint * textures)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
+    if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivate, X_GLvop_DeleteTextures, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLsop_GenTextures 145
+void
+__indirect_glGenTextures(GLsizei n, GLuint * textures)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGenTexturesRep *reply = XCBGlxGenTexturesReply(c, XCBGlxGenTextures(c, gc->currentContextTag, n), NULL);
+        (void)memcpy(textures, XCBGlxGenTexturesData(reply), XCBGlxGenTexturesDataLength(reply) * sizeof(GLuint));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenTextures, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        (void) __glXReadReply(dpy, 4, textures, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_IsTexture 146
+GLboolean
+__indirect_glIsTexture(GLuint texture)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    GLboolean retval = (GLboolean) 0;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxIsTextureRep *reply = XCBGlxIsTextureReply(c, XCBGlxIsTexture(c, gc->currentContextTag, texture), NULL);
+        retval = reply->ret_val;
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsTexture, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&texture), 4);
+        retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return retval;
+}
+
+#define X_GLrop_PrioritizeTextures 4118
+void
+__indirect_glPrioritizeTextures(GLsizei n, const GLuint * textures, const GLclampf * priorities)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8 + __GLX_PAD((n * 4)) + __GLX_PAD((n * 4));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_PrioritizeTextures, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(textures), (n * 4));
+        (void) memcpy((void *)(gc->pc + 8 + (n * 4)), (void *)(priorities), (n * 4));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+static void
+__glx_TexSubImage_1D2D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, 1, format, type, target) : 0;
+    const GLuint cmdlen = 60 + __GLX_PAD(compsize);
+    if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+        if (cmdlen <= gc->maxSmallRenderCommandSize) {
+            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+            emit_header(gc->pc, opcode, cmdlen);
+            (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
+            (void) memcpy((void *)(gc->pc + 28), (void *)(&level), 4);
+            (void) memcpy((void *)(gc->pc + 32), (void *)(&xoffset), 4);
+            (void) memcpy((void *)(gc->pc + 36), (void *)(&yoffset), 4);
+            (void) memcpy((void *)(gc->pc + 40), (void *)(&width), 4);
+            (void) memcpy((void *)(gc->pc + 44), (void *)(&height), 4);
+            (void) memcpy((void *)(gc->pc + 48), (void *)(&format), 4);
+            (void) memcpy((void *)(gc->pc + 52), (void *)(&type), 4);
+            (void) memcpy((void *)(gc->pc + 56), (void *)((pixels == NULL) ? one : zero), 4);
+            if (compsize > 0) {
+                (*gc->fillImage)(gc, dim, width, height, 1, format, type, pixels, gc->pc + 60, gc->pc + 4);
+            }
+            else {
+                (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+            }
+            gc->pc += cmdlen;
+            if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        }
+        else {
+            const GLint op = opcode;
+            const GLuint cmdlenLarge = cmdlen + 4;
+            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+            (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
+            (void) memcpy((void *)(pc + 32), (void *)(&level), 4);
+            (void) memcpy((void *)(pc + 36), (void *)(&xoffset), 4);
+            (void) memcpy((void *)(pc + 40), (void *)(&yoffset), 4);
+            (void) memcpy((void *)(pc + 44), (void *)(&width), 4);
+            (void) memcpy((void *)(pc + 48), (void *)(&height), 4);
+            (void) memcpy((void *)(pc + 52), (void *)(&format), 4);
+            (void) memcpy((void *)(pc + 56), (void *)(&type), 4);
+            (void) memcpy((void *)(pc + 60), zero, 4);
+            __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, pixels, pc + 64, pc + 8);
+        }
+    }
+}
+
+#define X_GLrop_TexSubImage1D 4099
+void
+__indirect_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels)
+{
+    __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D, 1, target, level, xoffset, 1, width, 1, format, type, pixels );
+}
+
+#define X_GLrop_TexSubImage2D 4100
+void
+__indirect_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
+{
+    __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D, 2, target, level, xoffset, yoffset, width, height, format, type, pixels );
+}
+
+#define X_GLrop_BlendColor 4096
+void
+__indirect_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_BlendColor, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_BlendEquation 4097
+void
+__indirect_glBlendEquation(GLenum mode)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_BlendEquation, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ColorTable 2053
+void
+__indirect_glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = (table != NULL) ? __glImageSize(width, 1, 1, format, type, target) : 0;
+    const GLuint cmdlen = 44 + __GLX_PAD(compsize);
+    if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+        if (cmdlen <= gc->maxSmallRenderCommandSize) {
+            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+            emit_header(gc->pc, X_GLrop_ColorTable, cmdlen);
+            (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
+            (void) memcpy((void *)(gc->pc + 28), (void *)(&internalformat), 4);
+            (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
+            (void) memcpy((void *)(gc->pc + 36), (void *)(&format), 4);
+            (void) memcpy((void *)(gc->pc + 40), (void *)(&type), 4);
+            if (compsize > 0) {
+                (*gc->fillImage)(gc, 1, width, 1, 1, format, type, table, gc->pc + 44, gc->pc + 4);
+            }
+            else {
+                (void) memcpy( gc->pc + 4, default_pixel_store_1D, default_pixel_store_1D_size );
+            }
+            gc->pc += cmdlen;
+            if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        }
+        else {
+            const GLint op = X_GLrop_ColorTable;
+            const GLuint cmdlenLarge = cmdlen + 4;
+            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+            (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
+            (void) memcpy((void *)(pc + 32), (void *)(&internalformat), 4);
+            (void) memcpy((void *)(pc + 36), (void *)(&width), 4);
+            (void) memcpy((void *)(pc + 40), (void *)(&format), 4);
+            (void) memcpy((void *)(pc + 44), (void *)(&type), 4);
+            __glXSendLargeImage(gc, compsize, 1, width, 1, 1, format, type, table, pc + 48, pc + 8);
+        }
+    }
+}
+
+#define X_GLrop_ColorTableParameterfv 2054
+void
+__indirect_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glColorTableParameterfv_size(pname);
+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_ColorTableParameterfv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ColorTableParameteriv 2055
+void
+__indirect_glColorTableParameteriv(GLenum target, GLenum pname, const GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glColorTableParameteriv_size(pname);
+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_ColorTableParameteriv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_CopyColorTable 2056
+void
+__indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_CopyColorTable, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLsop_GetColorTable 147
+void
+__indirect_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid * table)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const __GLXattribute * const state = gc->client_state_private;
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 16;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetColorTableRep *reply = XCBGlxGetColorTableReply(c, XCBGlxGetColorTable(c, gc->currentContextTag, target, format, type, state->storePack.swapEndian), NULL);
+        (void)memcpy(table, XCBGlxGetColorTableData(reply), XCBGlxGetColorTableDataLength(reply) * sizeof(GLvoid));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTable, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
+        (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
+        *(int32_t *)(pc + 12) = 0;
+        * (int8_t *)(pc + 12) = state->storePack.swapEndian;
+        __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetColorTableParameterfv 148
+void
+__indirect_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetColorTableParameterfvRep *reply = XCBGlxGetColorTableParameterfvReply(c, XCBGlxGetColorTableParameterfv(c, gc->currentContextTag, target, pname), NULL);
+        if (XCBGlxGetColorTableParameterfvDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetColorTableParameterfvData(reply), XCBGlxGetColorTableParameterfvDataLength(reply) * sizeof(GLfloat));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameterfv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetColorTableParameteriv 149
+void
+__indirect_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetColorTableParameterivRep *reply = XCBGlxGetColorTableParameterivReply(c, XCBGlxGetColorTableParameteriv(c, gc->currentContextTag, target, pname), NULL);
+        if (XCBGlxGetColorTableParameterivDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetColorTableParameterivData(reply), XCBGlxGetColorTableParameterivDataLength(reply) * sizeof(GLint));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameteriv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLrop_ColorSubTable 195
+void
+__indirect_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = (data != NULL) ? __glImageSize(count, 1, 1, format, type, target) : 0;
+    const GLuint cmdlen = 44 + __GLX_PAD(compsize);
+    if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+        if (cmdlen <= gc->maxSmallRenderCommandSize) {
+            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+            emit_header(gc->pc, X_GLrop_ColorSubTable, cmdlen);
+            (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
+            (void) memcpy((void *)(gc->pc + 28), (void *)(&start), 4);
+            (void) memcpy((void *)(gc->pc + 32), (void *)(&count), 4);
+            (void) memcpy((void *)(gc->pc + 36), (void *)(&format), 4);
+            (void) memcpy((void *)(gc->pc + 40), (void *)(&type), 4);
+            if (compsize > 0) {
+                (*gc->fillImage)(gc, 1, count, 1, 1, format, type, data, gc->pc + 44, gc->pc + 4);
+            }
+            else {
+                (void) memcpy( gc->pc + 4, default_pixel_store_1D, default_pixel_store_1D_size );
+            }
+            gc->pc += cmdlen;
+            if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        }
+        else {
+            const GLint op = X_GLrop_ColorSubTable;
+            const GLuint cmdlenLarge = cmdlen + 4;
+            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+            (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
+            (void) memcpy((void *)(pc + 32), (void *)(&start), 4);
+            (void) memcpy((void *)(pc + 36), (void *)(&count), 4);
+            (void) memcpy((void *)(pc + 40), (void *)(&format), 4);
+            (void) memcpy((void *)(pc + 44), (void *)(&type), 4);
+            __glXSendLargeImage(gc, compsize, 1, count, 1, 1, format, type, data, pc + 48, pc + 8);
+        }
+    }
+}
+
+#define X_GLrop_CopyColorSubTable 196
+void
+__indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_CopyColorSubTable, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&start), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+static void
+__glx_ConvolutionFilter_1D2D( unsigned opcode, unsigned dim, GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = (image != NULL) ? __glImageSize(width, height, 1, format, type, target) : 0;
+    const GLuint cmdlen = 48 + __GLX_PAD(compsize);
+    if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+        if (cmdlen <= gc->maxSmallRenderCommandSize) {
+            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+            emit_header(gc->pc, opcode, cmdlen);
+            (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
+            (void) memcpy((void *)(gc->pc + 28), (void *)(&internalformat), 4);
+            (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
+            (void) memcpy((void *)(gc->pc + 36), (void *)(&height), 4);
+            (void) memcpy((void *)(gc->pc + 40), (void *)(&format), 4);
+            (void) memcpy((void *)(gc->pc + 44), (void *)(&type), 4);
+            if (compsize > 0) {
+                (*gc->fillImage)(gc, dim, width, height, 1, format, type, image, gc->pc + 48, gc->pc + 4);
+            }
+            else {
+                (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+            }
+            gc->pc += cmdlen;
+            if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        }
+        else {
+            const GLint op = opcode;
+            const GLuint cmdlenLarge = cmdlen + 4;
+            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+            (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
+            (void) memcpy((void *)(pc + 32), (void *)(&internalformat), 4);
+            (void) memcpy((void *)(pc + 36), (void *)(&width), 4);
+            (void) memcpy((void *)(pc + 40), (void *)(&height), 4);
+            (void) memcpy((void *)(pc + 44), (void *)(&format), 4);
+            (void) memcpy((void *)(pc + 48), (void *)(&type), 4);
+            __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, image, pc + 52, pc + 8);
+        }
+    }
+}
+
+#define X_GLrop_ConvolutionFilter1D 4101
+void
+__indirect_glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image)
+{
+    __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D, 1, target, internalformat, width, 1, format, type, image );
+}
+
+#define X_GLrop_ConvolutionFilter2D 4102
+void
+__indirect_glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image)
+{
+    __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D, 2, target, internalformat, width, height, format, type, image );
+}
+
+#define X_GLrop_ConvolutionParameterf 4103
+void
+__indirect_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_ConvolutionParameterf, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&params), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ConvolutionParameterfv 4104
+void
+__indirect_glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glConvolutionParameterfv_size(pname);
+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_ConvolutionParameterfv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ConvolutionParameteri 4105
+void
+__indirect_glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_ConvolutionParameteri, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&params), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ConvolutionParameteriv 4106
+void
+__indirect_glConvolutionParameteriv(GLenum target, GLenum pname, const GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glConvolutionParameteriv_size(pname);
+    const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_ConvolutionParameteriv, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_CopyConvolutionFilter1D 4107
+void
+__indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_CopyConvolutionFilter1D, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_CopyConvolutionFilter2D 4108
+void
+__indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_CopyConvolutionFilter2D, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
+    (void) memcpy((void *)(gc->pc + 24), (void *)(&height), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLsop_GetConvolutionFilter 150
+void
+__indirect_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid * image)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const __GLXattribute * const state = gc->client_state_private;
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 16;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetConvolutionFilterRep *reply = XCBGlxGetConvolutionFilterReply(c, XCBGlxGetConvolutionFilter(c, gc->currentContextTag, target, format, type, state->storePack.swapEndian), NULL);
+        (void)memcpy(image, XCBGlxGetConvolutionFilterData(reply), XCBGlxGetConvolutionFilterDataLength(reply) * sizeof(GLvoid));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionFilter, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
+        (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
+        *(int32_t *)(pc + 12) = 0;
+        * (int8_t *)(pc + 12) = state->storePack.swapEndian;
+        __glXReadPixelReply(dpy, gc, 2, 0, 0, 0, format, type, image, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetConvolutionParameterfv 151
+void
+__indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetConvolutionParameterfvRep *reply = XCBGlxGetConvolutionParameterfvReply(c, XCBGlxGetConvolutionParameterfv(c, gc->currentContextTag, target, pname), NULL);
+        if (XCBGlxGetConvolutionParameterfvDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetConvolutionParameterfvData(reply), XCBGlxGetConvolutionParameterfvDataLength(reply) * sizeof(GLfloat));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameterfv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetConvolutionParameteriv 152
+void
+__indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetConvolutionParameterivRep *reply = XCBGlxGetConvolutionParameterivReply(c, XCBGlxGetConvolutionParameteriv(c, gc->currentContextTag, target, pname), NULL);
+        if (XCBGlxGetConvolutionParameterivDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetConvolutionParameterivData(reply), XCBGlxGetConvolutionParameterivDataLength(reply) * sizeof(GLint));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameteriv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetHistogram 154
+void
+__indirect_glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const __GLXattribute * const state = gc->client_state_private;
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 16;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetHistogramRep *reply = XCBGlxGetHistogramReply(c, XCBGlxGetHistogram(c, gc->currentContextTag, target, reset, format, type, state->storePack.swapEndian), NULL);
+        (void)memcpy(values, XCBGlxGetHistogramData(reply), XCBGlxGetHistogramDataLength(reply) * sizeof(GLvoid));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogram, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
+        (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
+        *(int32_t *)(pc + 12) = 0;
+        * (int8_t *)(pc + 12) = state->storePack.swapEndian;
+        * (int8_t *)(pc + 13) = reset;
+        __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, values, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetHistogramParameterfv 155
+void
+__indirect_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetHistogramParameterfvRep *reply = XCBGlxGetHistogramParameterfvReply(c, XCBGlxGetHistogramParameterfv(c, gc->currentContextTag, target, pname), NULL);
+        if (XCBGlxGetHistogramParameterfvDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetHistogramParameterfvData(reply), XCBGlxGetHistogramParameterfvDataLength(reply) * sizeof(GLfloat));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameterfv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetHistogramParameteriv 156
+void
+__indirect_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetHistogramParameterivRep *reply = XCBGlxGetHistogramParameterivReply(c, XCBGlxGetHistogramParameteriv(c, gc->currentContextTag, target, pname), NULL);
+        if (XCBGlxGetHistogramParameterivDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetHistogramParameterivData(reply), XCBGlxGetHistogramParameterivDataLength(reply) * sizeof(GLint));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameteriv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetMinmax 157
+void
+__indirect_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const __GLXattribute * const state = gc->client_state_private;
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 16;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetMinmaxRep *reply = XCBGlxGetMinmaxReply(c, XCBGlxGetMinmax(c, gc->currentContextTag, target, reset, format, type, state->storePack.swapEndian), NULL);
+        (void)memcpy(values, XCBGlxGetMinmaxData(reply), XCBGlxGetMinmaxDataLength(reply) * sizeof(GLvoid));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmax, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
+        (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
+        *(int32_t *)(pc + 12) = 0;
+        * (int8_t *)(pc + 12) = state->storePack.swapEndian;
+        * (int8_t *)(pc + 13) = reset;
+        __glXReadPixelReply(dpy, gc, 1, 2, 1, 1, format, type, values, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetMinmaxParameterfv 158
+void
+__indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetMinmaxParameterfvRep *reply = XCBGlxGetMinmaxParameterfvReply(c, XCBGlxGetMinmaxParameterfv(c, gc->currentContextTag, target, pname), NULL);
+        if (XCBGlxGetMinmaxParameterfvDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetMinmaxParameterfvData(reply), XCBGlxGetMinmaxParameterfvDataLength(reply) * sizeof(GLfloat));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameterfv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetMinmaxParameteriv 159
+void
+__indirect_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetMinmaxParameterivRep *reply = XCBGlxGetMinmaxParameterivReply(c, XCBGlxGetMinmaxParameteriv(c, gc->currentContextTag, target, pname), NULL);
+        if (XCBGlxGetMinmaxParameterivDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetMinmaxParameterivData(reply), XCBGlxGetMinmaxParameterivDataLength(reply) * sizeof(GLint));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameteriv, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLrop_Histogram 4110
+void
+__indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_Histogram, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&width), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&sink), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_Minmax 4111
+void
+__indirect_glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_Minmax, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&sink), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ResetHistogram 4112
+void
+__indirect_glResetHistogram(GLenum target)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_ResetHistogram, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ResetMinmax 4113
+void
+__indirect_glResetMinmax(GLenum target)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_ResetMinmax, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+static void
+__glx_TexImage_3D4D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLint border, GLenum format, GLenum type, const GLvoid * pixels )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, depth, format, type, target) : 0;
+    const GLuint cmdlen = 84 + __GLX_PAD(compsize);
+    if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+        if (cmdlen <= gc->maxSmallRenderCommandSize) {
+            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+            emit_header(gc->pc, opcode, cmdlen);
+            (void) memcpy((void *)(gc->pc + 40), (void *)(&target), 4);
+            (void) memcpy((void *)(gc->pc + 44), (void *)(&level), 4);
+            (void) memcpy((void *)(gc->pc + 48), (void *)(&internalformat), 4);
+            (void) memcpy((void *)(gc->pc + 52), (void *)(&width), 4);
+            (void) memcpy((void *)(gc->pc + 56), (void *)(&height), 4);
+            (void) memcpy((void *)(gc->pc + 60), (void *)(&depth), 4);
+            (void) memcpy((void *)(gc->pc + 64), (void *)(&extent), 4);
+            (void) memcpy((void *)(gc->pc + 68), (void *)(&border), 4);
+            (void) memcpy((void *)(gc->pc + 72), (void *)(&format), 4);
+            (void) memcpy((void *)(gc->pc + 76), (void *)(&type), 4);
+            (void) memcpy((void *)(gc->pc + 80), (void *)((pixels == NULL) ? one : zero), 4);
+            if (compsize > 0) {
+                (*gc->fillImage)(gc, dim, width, height, depth, format, type, pixels, gc->pc + 84, gc->pc + 4);
+            }
+            else {
+                (void) memcpy( gc->pc + 4, default_pixel_store_4D, default_pixel_store_4D_size );
+            }
+            gc->pc += cmdlen;
+            if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        }
+        else {
+            const GLint op = opcode;
+            const GLuint cmdlenLarge = cmdlen + 4;
+            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+            (void) memcpy((void *)(pc + 44), (void *)(&target), 4);
+            (void) memcpy((void *)(pc + 48), (void *)(&level), 4);
+            (void) memcpy((void *)(pc + 52), (void *)(&internalformat), 4);
+            (void) memcpy((void *)(pc + 56), (void *)(&width), 4);
+            (void) memcpy((void *)(pc + 60), (void *)(&height), 4);
+            (void) memcpy((void *)(pc + 64), (void *)(&depth), 4);
+            (void) memcpy((void *)(pc + 68), (void *)(&extent), 4);
+            (void) memcpy((void *)(pc + 72), (void *)(&border), 4);
+            (void) memcpy((void *)(pc + 76), (void *)(&format), 4);
+            (void) memcpy((void *)(pc + 80), (void *)(&type), 4);
+            (void) memcpy((void *)(pc + 84), zero, 4);
+            __glXSendLargeImage(gc, compsize, dim, width, height, depth, format, type, pixels, pc + 88, pc + 8);
+        }
+    }
+}
+
+#define X_GLrop_TexImage3D 4114
+void
+__indirect_glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
+{
+    __glx_TexImage_3D4D(X_GLrop_TexImage3D, 3, target, level, internalformat, width, height, depth, 1, border, format, type, pixels );
+}
+
+static void
+__glx_TexSubImage_3D4D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLenum format, GLenum type, const GLvoid * pixels )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, depth, format, type, target) : 0;
+    const GLuint cmdlen = 92 + __GLX_PAD(compsize);
+    if (__builtin_expect(gc->currentDpy != NULL, 1)) {
+        if (cmdlen <= gc->maxSmallRenderCommandSize) {
+            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+            emit_header(gc->pc, opcode, cmdlen);
+            (void) memcpy((void *)(gc->pc + 40), (void *)(&target), 4);
+            (void) memcpy((void *)(gc->pc + 44), (void *)(&level), 4);
+            (void) memcpy((void *)(gc->pc + 48), (void *)(&xoffset), 4);
+            (void) memcpy((void *)(gc->pc + 52), (void *)(&yoffset), 4);
+            (void) memcpy((void *)(gc->pc + 56), (void *)(&zoffset), 4);
+            (void) memcpy((void *)(gc->pc + 60), (void *)(&woffset), 4);
+            (void) memcpy((void *)(gc->pc + 64), (void *)(&width), 4);
+            (void) memcpy((void *)(gc->pc + 68), (void *)(&height), 4);
+            (void) memcpy((void *)(gc->pc + 72), (void *)(&depth), 4);
+            (void) memcpy((void *)(gc->pc + 76), (void *)(&extent), 4);
+            (void) memcpy((void *)(gc->pc + 80), (void *)(&format), 4);
+            (void) memcpy((void *)(gc->pc + 84), (void *)(&type), 4);
+            (void) memcpy((void *)(gc->pc + 88), (void *)((pixels == NULL) ? one : zero), 4);
+            if (compsize > 0) {
+                (*gc->fillImage)(gc, dim, width, height, depth, format, type, pixels, gc->pc + 92, gc->pc + 4);
+            }
+            else {
+                (void) memcpy( gc->pc + 4, default_pixel_store_4D, default_pixel_store_4D_size );
+            }
+            gc->pc += cmdlen;
+            if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        }
+        else {
+            const GLint op = opcode;
+            const GLuint cmdlenLarge = cmdlen + 4;
+            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+            (void) memcpy((void *)(pc + 44), (void *)(&target), 4);
+            (void) memcpy((void *)(pc + 48), (void *)(&level), 4);
+            (void) memcpy((void *)(pc + 52), (void *)(&xoffset), 4);
+            (void) memcpy((void *)(pc + 56), (void *)(&yoffset), 4);
+            (void) memcpy((void *)(pc + 60), (void *)(&zoffset), 4);
+            (void) memcpy((void *)(pc + 64), (void *)(&woffset), 4);
+            (void) memcpy((void *)(pc + 68), (void *)(&width), 4);
+            (void) memcpy((void *)(pc + 72), (void *)(&height), 4);
+            (void) memcpy((void *)(pc + 76), (void *)(&depth), 4);
+            (void) memcpy((void *)(pc + 80), (void *)(&extent), 4);
+            (void) memcpy((void *)(pc + 84), (void *)(&format), 4);
+            (void) memcpy((void *)(pc + 88), (void *)(&type), 4);
+            (void) memcpy((void *)(pc + 92), zero, 4);
+            __glXSendLargeImage(gc, compsize, dim, width, height, depth, format, type, pixels, pc + 96, pc + 8);
+        }
+    }
+}
+
+#define X_GLrop_TexSubImage3D 4115
+void
+__indirect_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels)
+{
+    __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D, 3, target, level, xoffset, yoffset, zoffset, 1, width, height, depth, 1, format, type, pixels );
+}
+
+#define X_GLrop_CopyTexSubImage3D 4123
+void
+__indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 40;
+    emit_header(gc->pc, X_GLrop_CopyTexSubImage3D, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&yoffset), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&zoffset), 4);
+    (void) memcpy((void *)(gc->pc + 24), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&height), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ActiveTextureARB 197
+void
+__indirect_glActiveTextureARB(GLenum texture)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_ActiveTextureARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&texture), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord1dvARB 198
+void
+__indirect_glMultiTexCoord1dARB(GLenum target, GLdouble s)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord1dvARB 198
+void
+__indirect_glMultiTexCoord1dvARB(GLenum target, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord1fvARB 199
+void
+__indirect_glMultiTexCoord1fARB(GLenum target, GLfloat s)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord1fvARB 199
+void
+__indirect_glMultiTexCoord1fvARB(GLenum target, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord1ivARB 200
+void
+__indirect_glMultiTexCoord1iARB(GLenum target, GLint s)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord1ivARB 200
+void
+__indirect_glMultiTexCoord1ivARB(GLenum target, const GLint * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord1svARB 201
+void
+__indirect_glMultiTexCoord1sARB(GLenum target, GLshort s)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord1svARB 201
+void
+__indirect_glMultiTexCoord1svARB(GLenum target, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord2dvARB 202
+void
+__indirect_glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord2dvARB 202
+void
+__indirect_glMultiTexCoord2dvARB(GLenum target, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 16);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord2fvARB 203
+void
+__indirect_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord2fvARB 203
+void
+__indirect_glMultiTexCoord2fvARB(GLenum target, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord2ivARB 204
+void
+__indirect_glMultiTexCoord2iARB(GLenum target, GLint s, GLint t)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord2ivARB 204
+void
+__indirect_glMultiTexCoord2ivARB(GLenum target, const GLint * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord2svARB 205
+void
+__indirect_glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord2svARB 205
+void
+__indirect_glMultiTexCoord2svARB(GLenum target, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord3dvARB 206
+void
+__indirect_glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 32;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord3dvARB 206
+void
+__indirect_glMultiTexCoord3dvARB(GLenum target, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 32;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 24);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord3fvARB 207
+void
+__indirect_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord3fvARB 207
+void
+__indirect_glMultiTexCoord3fvARB(GLenum target, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord3ivARB 208
+void
+__indirect_glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord3ivARB 208
+void
+__indirect_glMultiTexCoord3ivARB(GLenum target, const GLint * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord3svARB 209
+void
+__indirect_glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord3svARB 209
+void
+__indirect_glMultiTexCoord3svARB(GLenum target, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord4dvARB 210
+void
+__indirect_glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 40;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord4dvARB 210
+void
+__indirect_glMultiTexCoord4dvARB(GLenum target, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 40;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord4fvARB 211
+void
+__indirect_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord4fvARB 211
+void
+__indirect_glMultiTexCoord4fvARB(GLenum target, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord4ivARB 212
+void
+__indirect_glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord4ivARB 212
+void
+__indirect_glMultiTexCoord4ivARB(GLenum target, const GLint * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord4svARB 213
+void
+__indirect_glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2);
+    (void) memcpy((void *)(gc->pc + 14), (void *)(&q), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_MultiTexCoord4svARB 213
+void
+__indirect_glMultiTexCoord4svARB(GLenum target, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_SampleCoverageARB 229
+void
+__indirect_glSampleCoverageARB(GLclampf value, GLboolean invert)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_SampleCoverageARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_DrawBuffersARB 233
+void
+__indirect_glDrawBuffersARB(GLsizei n, const GLenum * bufs)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
+    if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) {
+        if (cmdlen <= gc->maxSmallRenderCommandSize) {
+            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+            emit_header(gc->pc, X_GLrop_DrawBuffersARB, cmdlen);
+            (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
+            (void) memcpy((void *)(gc->pc + 8), (void *)(bufs), (n * 4));
+            gc->pc += cmdlen;
+            if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        }
+        else {
+            const GLint op = X_GLrop_DrawBuffersARB;
+            const GLuint cmdlenLarge = cmdlen + 4;
+            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+            (void) memcpy((void *)(pc + 8), (void *)(&n), 4);
+            __glXSendLargeCommand(gc, pc, 12, bufs, (n * 4));
+        }
+    }
+}
+
+#define X_GLvop_AreTexturesResidentEXT 11
+GLboolean
+__indirect_glAreTexturesResidentEXT(GLsizei n, const GLuint * textures, GLboolean * residences)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    GLboolean retval = (GLboolean) 0;
+    const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
+    if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_AreTexturesResidentEXT, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
+        retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return retval;
+}
+
+#define X_GLvop_GenTexturesEXT 13
+void
+__indirect_glGenTexturesEXT(GLsizei n, GLuint * textures)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenTexturesEXT, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        (void) __glXReadReply(dpy, 4, textures, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_IsTextureEXT 14
+GLboolean
+__indirect_glIsTextureEXT(GLuint texture)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    GLboolean retval = (GLboolean) 0;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsTextureEXT, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&texture), 4);
+        retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return retval;
+}
+
+#define X_GLrop_SampleMaskSGIS 2048
+void
+__indirect_glSampleMaskSGIS(GLclampf value, GLboolean invert)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_SampleMaskSGIS, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_SamplePatternSGIS 2049
+void
+__indirect_glSamplePatternSGIS(GLenum pattern)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_SamplePatternSGIS, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&pattern), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PointParameterfEXT 2065
+void
+__indirect_glPointParameterfEXT(GLenum pname, GLfloat param)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_PointParameterfEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PointParameterfvEXT 2066
+void
+__indirect_glPointParameterfvEXT(GLenum pname, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glPointParameterfvEXT_size(pname);
+    const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_PointParameterfvEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_WindowPos3fvMESA 230
+void
+__indirect_glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_WindowPos3fvMESA, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_WindowPos3fvMESA 230
+void
+__indirect_glWindowPos3fvMESA(const GLfloat * v)
+{
+    generic_12_byte( X_GLrop_WindowPos3fvMESA, v );
+}
+
+#define X_GLrop_BlendFuncSeparateEXT 4134
+void
+__indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_BlendFuncSeparateEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&sfactorRGB), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&dfactorRGB), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&sfactorAlpha), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&dfactorAlpha), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_FogCoordfvEXT 4124
+void
+__indirect_glFogCoordfEXT(GLfloat coord)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_FogCoordfvEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_FogCoordfvEXT 4124
+void
+__indirect_glFogCoordfvEXT(const GLfloat * coord)
+{
+    generic_4_byte( X_GLrop_FogCoordfvEXT, coord );
+}
+
+#define X_GLrop_FogCoorddvEXT 4125
+void
+__indirect_glFogCoorddEXT(GLdouble coord)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_FogCoorddvEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_FogCoorddvEXT 4125
+void
+__indirect_glFogCoorddvEXT(const GLdouble * coord)
+{
+    generic_8_byte( X_GLrop_FogCoorddvEXT, coord );
+}
+
+#define X_GLrop_SecondaryColor3bvEXT 4126
+void
+__indirect_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_SecondaryColor3bvEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
+    (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_SecondaryColor3bvEXT 4126
+void
+__indirect_glSecondaryColor3bvEXT(const GLbyte * v)
+{
+    generic_3_byte( X_GLrop_SecondaryColor3bvEXT, v );
+}
+
+#define X_GLrop_SecondaryColor3dvEXT 4130
+void
+__indirect_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_SecondaryColor3dvEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_SecondaryColor3dvEXT 4130
+void
+__indirect_glSecondaryColor3dvEXT(const GLdouble * v)
+{
+    generic_24_byte( X_GLrop_SecondaryColor3dvEXT, v );
+}
+
+#define X_GLrop_SecondaryColor3fvEXT 4129
+void
+__indirect_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_SecondaryColor3fvEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_SecondaryColor3fvEXT 4129
+void
+__indirect_glSecondaryColor3fvEXT(const GLfloat * v)
+{
+    generic_12_byte( X_GLrop_SecondaryColor3fvEXT, v );
+}
+
+#define X_GLrop_SecondaryColor3ivEXT 4128
+void
+__indirect_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_SecondaryColor3ivEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_SecondaryColor3ivEXT 4128
+void
+__indirect_glSecondaryColor3ivEXT(const GLint * v)
+{
+    generic_12_byte( X_GLrop_SecondaryColor3ivEXT, v );
+}
+
+#define X_GLrop_SecondaryColor3svEXT 4127
+void
+__indirect_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_SecondaryColor3svEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_SecondaryColor3svEXT 4127
+void
+__indirect_glSecondaryColor3svEXT(const GLshort * v)
+{
+    generic_6_byte( X_GLrop_SecondaryColor3svEXT, v );
+}
+
+#define X_GLrop_SecondaryColor3ubvEXT 4131
+void
+__indirect_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_SecondaryColor3ubvEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
+    (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_SecondaryColor3ubvEXT 4131
+void
+__indirect_glSecondaryColor3ubvEXT(const GLubyte * v)
+{
+    generic_3_byte( X_GLrop_SecondaryColor3ubvEXT, v );
+}
+
+#define X_GLrop_SecondaryColor3uivEXT 4133
+void
+__indirect_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_SecondaryColor3uivEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_SecondaryColor3uivEXT 4133
+void
+__indirect_glSecondaryColor3uivEXT(const GLuint * v)
+{
+    generic_12_byte( X_GLrop_SecondaryColor3uivEXT, v );
+}
+
+#define X_GLrop_SecondaryColor3usvEXT 4132
+void
+__indirect_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_SecondaryColor3usvEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
+    (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_SecondaryColor3usvEXT 4132
+void
+__indirect_glSecondaryColor3usvEXT(const GLushort * v)
+{
+    generic_6_byte( X_GLrop_SecondaryColor3usvEXT, v );
+}
+
+#define X_GLvop_AreProgramsResidentNV 1293
+GLboolean
+__indirect_glAreProgramsResidentNV(GLsizei n, const GLuint * ids, GLboolean * residences)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    GLboolean retval = (GLboolean) 0;
+    const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
+    if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_AreProgramsResidentNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(ids), (n * 4));
+        retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return retval;
+}
+
+#define X_GLrop_BindProgramNV 4180
+void
+__indirect_glBindProgramNV(GLenum target, GLuint program)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_BindProgramNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&program), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLvop_DeleteProgramsNV 1294
+void
+__indirect_glDeleteProgramsNV(GLsizei n, const GLuint * programs)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
+    if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivate, X_GLvop_DeleteProgramsNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(programs), (n * 4));
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLrop_ExecuteProgramNV 4181
+void
+__indirect_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_ExecuteProgramNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLvop_GenProgramsNV 1295
+void
+__indirect_glGenProgramsNV(GLsizei n, GLuint * programs)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenProgramsNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        (void) __glXReadReply(dpy, 4, programs, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_GetProgramParameterdvNV 1297
+void
+__indirect_glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 12;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramParameterdvNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 8, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_GetProgramParameterfvNV 1296
+void
+__indirect_glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 12;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramParameterfvNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_GetProgramivNV 1298
+void
+__indirect_glGetProgramivNV(GLuint id, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramivNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_GetProgramStringNV 1299
+void
+__indirect_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte * program)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramStringNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 1, program, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_GetTrackMatrixivNV 1300
+void
+__indirect_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 12;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetTrackMatrixivNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&address), 4);
+        (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_IsProgramNV 1304
+GLboolean
+__indirect_glIsProgramNV(GLuint program)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    GLboolean retval = (GLboolean) 0;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsProgramNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&program), 4);
+        retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return retval;
+}
+
+#define X_GLrop_LoadProgramNV 4183
+void
+__indirect_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte * program)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16 + __GLX_PAD(len);
+    if (__builtin_expect(len >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_LoadProgramNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4);
+        (void) memcpy((void *)(gc->pc + 16), (void *)(program), len);
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_ProgramParameter4dvNV 4185
+void
+__indirect_glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 44;
+    emit_header(gc->pc, X_GLrop_ProgramParameter4dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&w), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramParameter4dvNV 4185
+void
+__indirect_glProgramParameter4dvNV(GLenum target, GLuint index, const GLdouble * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 44;
+    emit_header(gc->pc, X_GLrop_ProgramParameter4dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), 32);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramParameter4fvNV 4184
+void
+__indirect_glProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_ProgramParameter4fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
+    (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramParameter4fvNV 4184
+void
+__indirect_glProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_ProgramParameter4fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramParameters4dvNV 4187
+void
+__indirect_glProgramParameters4dvNV(GLenum target, GLuint index, GLuint num, const GLdouble * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16 + __GLX_PAD((num * 32));
+    if (__builtin_expect(num >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_ProgramParameters4dvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(&num), 4);
+        (void) memcpy((void *)(gc->pc + 16), (void *)(params), (num * 32));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_ProgramParameters4fvNV 4186
+void
+__indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLuint num, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16 + __GLX_PAD((num * 16));
+    if (__builtin_expect(num >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_ProgramParameters4fvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(&num), 4);
+        (void) memcpy((void *)(gc->pc + 16), (void *)(params), (num * 16));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_RequestResidentProgramsNV 4182
+void
+__indirect_glRequestResidentProgramsNV(GLsizei n, const GLuint * ids)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_RequestResidentProgramsNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(ids), (n * 4));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_TrackMatrixNV 4188
+void
+__indirect_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_TrackMatrixNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&address), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&matrix), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&transform), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1dvARB 4197
+void
+__indirect_glVertexAttrib1dARB(GLuint index, GLdouble x)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1dvARB 4197
+void
+__indirect_glVertexAttrib1dvARB(GLuint index, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1fvARB 4193
+void
+__indirect_glVertexAttrib1fARB(GLuint index, GLfloat x)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1fvARB 4193
+void
+__indirect_glVertexAttrib1fvARB(GLuint index, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1svARB 4189
+void
+__indirect_glVertexAttrib1sARB(GLuint index, GLshort x)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1svARB 4189
+void
+__indirect_glVertexAttrib1svARB(GLuint index, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2dvARB 4198
+void
+__indirect_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2dvARB 4198
+void
+__indirect_glVertexAttrib2dvARB(GLuint index, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 16);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2fvARB 4194
+void
+__indirect_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2fvARB 4194
+void
+__indirect_glVertexAttrib2fvARB(GLuint index, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2svARB 4190
+void
+__indirect_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2svARB 4190
+void
+__indirect_glVertexAttrib2svARB(GLuint index, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3dvARB 4199
+void
+__indirect_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 32;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3dvARB 4199
+void
+__indirect_glVertexAttrib3dvARB(GLuint index, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 32;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 24);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3fvARB 4195
+void
+__indirect_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3fvARB 4195
+void
+__indirect_glVertexAttrib3fvARB(GLuint index, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3svARB 4191
+void
+__indirect_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3svARB 4191
+void
+__indirect_glVertexAttrib3svARB(GLuint index, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4dvARB 4200
+void
+__indirect_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 40;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4dvARB 4200
+void
+__indirect_glVertexAttrib4dvARB(GLuint index, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 40;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&index), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4fvARB 4196
+void
+__indirect_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4fvARB 4196
+void
+__indirect_glVertexAttrib4fvARB(GLuint index, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4svARB 4192
+void
+__indirect_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
+    (void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4svARB 4192
+void
+__indirect_glVertexAttrib4svARB(GLuint index, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NubvARB 4201
+void
+__indirect_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1);
+    (void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1);
+    (void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NubvARB 4201
+void
+__indirect_glVertexAttrib4NubvARB(GLuint index, const GLubyte * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttribs1dvNV 4210
+void
+__indirect_glVertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_VertexAttribs1dvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_VertexAttribs1fvNV 4206
+void
+__indirect_glVertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_VertexAttribs1fvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_VertexAttribs1svNV 4202
+void
+__indirect_glVertexAttribs1svNV(GLuint index, GLsizei n, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12 + __GLX_PAD((n * 2));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_VertexAttribs1svNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 2));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_VertexAttribs2dvNV 4211
+void
+__indirect_glVertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12 + __GLX_PAD((n * 16));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_VertexAttribs2dvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 16));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_VertexAttribs2fvNV 4207
+void
+__indirect_glVertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_VertexAttribs2fvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_VertexAttribs2svNV 4203
+void
+__indirect_glVertexAttribs2svNV(GLuint index, GLsizei n, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_VertexAttribs2svNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_VertexAttribs3dvNV 4212
+void
+__indirect_glVertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12 + __GLX_PAD((n * 24));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_VertexAttribs3dvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 24));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_VertexAttribs3fvNV 4208
+void
+__indirect_glVertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12 + __GLX_PAD((n * 12));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_VertexAttribs3fvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 12));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_VertexAttribs3svNV 4204
+void
+__indirect_glVertexAttribs3svNV(GLuint index, GLsizei n, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12 + __GLX_PAD((n * 6));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_VertexAttribs3svNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 6));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_VertexAttribs4dvNV 4213
+void
+__indirect_glVertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12 + __GLX_PAD((n * 32));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_VertexAttribs4dvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 32));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_VertexAttribs4fvNV 4209
+void
+__indirect_glVertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12 + __GLX_PAD((n * 16));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_VertexAttribs4fvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 16));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_VertexAttribs4svNV 4205
+void
+__indirect_glVertexAttribs4svNV(GLuint index, GLsizei n, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_VertexAttribs4svNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_VertexAttribs4ubvNV 4214
+void
+__indirect_glVertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_VertexAttribs4ubvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_PointParameteriNV 4221
+void
+__indirect_glPointParameteriNV(GLenum pname, GLint param)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_PointParameteriNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_PointParameterivNV 4222
+void
+__indirect_glPointParameterivNV(GLenum pname, const GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint compsize = __glPointParameterivNV_size(pname);
+    const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
+    emit_header(gc->pc, X_GLrop_PointParameterivNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ActiveStencilFaceEXT 4220
+void
+__indirect_glActiveStencilFaceEXT(GLenum face)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4bvARB 4230
+void
+__indirect_glVertexAttrib4bvARB(GLuint index, const GLbyte * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4bvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4ivARB 4231
+void
+__indirect_glVertexAttrib4ivARB(GLuint index, const GLint * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4ivARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4ubvARB 4232
+void
+__indirect_glVertexAttrib4ubvARB(GLuint index, const GLubyte * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4ubvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4usvARB 4233
+void
+__indirect_glVertexAttrib4usvARB(GLuint index, const GLushort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4usvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4uivARB 4234
+void
+__indirect_glVertexAttrib4uivARB(GLuint index, const GLuint * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4uivARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NbvARB 4235
+void
+__indirect_glVertexAttrib4NbvARB(GLuint index, const GLbyte * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4NbvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NsvARB 4236
+void
+__indirect_glVertexAttrib4NsvARB(GLuint index, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4NsvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NivARB 4237
+void
+__indirect_glVertexAttrib4NivARB(GLuint index, const GLint * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4NivARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NusvARB 4238
+void
+__indirect_glVertexAttrib4NusvARB(GLuint index, const GLushort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4NusvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4NuivARB 4239
+void
+__indirect_glVertexAttrib4NuivARB(GLuint index, const GLuint * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4NuivARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramStringARB 4217
+void
+__indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len, const GLvoid * string)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16 + __GLX_PAD(len);
+    if (__builtin_expect((len >= 0) && (gc->currentDpy != NULL), 1)) {
+        if (cmdlen <= gc->maxSmallRenderCommandSize) {
+            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+            emit_header(gc->pc, X_GLrop_ProgramStringARB, cmdlen);
+            (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+            (void) memcpy((void *)(gc->pc + 8), (void *)(&format), 4);
+            (void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4);
+            (void) memcpy((void *)(gc->pc + 16), (void *)(string), len);
+            gc->pc += cmdlen;
+            if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        }
+        else {
+            const GLint op = X_GLrop_ProgramStringARB;
+            const GLuint cmdlenLarge = cmdlen + 4;
+            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
+            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
+            (void) memcpy((void *)(pc + 8), (void *)(&target), 4);
+            (void) memcpy((void *)(pc + 12), (void *)(&format), 4);
+            (void) memcpy((void *)(pc + 16), (void *)(&len), 4);
+            __glXSendLargeCommand(gc, pc, 20, string, len);
+        }
+    }
+}
+
+#define X_GLrop_ProgramEnvParameter4dvARB 4185
+void
+__indirect_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 44;
+    emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&w), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramEnvParameter4dvARB 4185
+void
+__indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 44;
+    emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), 32);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramEnvParameter4fvARB 4184
+void
+__indirect_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
+    (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramEnvParameter4fvARB 4184
+void
+__indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramLocalParameter4dvARB 4216
+void
+__indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 44;
+    emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8);
+    (void) memcpy((void *)(gc->pc + 36), (void *)(&w), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramLocalParameter4dvARB 4216
+void
+__indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 44;
+    emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), 32);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramLocalParameter4fvARB 4215
+void
+__indirect_glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
+    (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_ProgramLocalParameter4fvARB 4215
+void
+__indirect_glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLvop_GetProgramivARB 1307
+void
+__indirect_glGetProgramivARB(GLenum target, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramivARB, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_GetProgramStringARB 1308
+void
+__indirect_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * string)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramStringARB, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 1, string, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLrop_ProgramNamedParameter4fvNV 4218
+void
+__indirect_glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28 + __GLX_PAD(len);
+    if (__builtin_expect(len >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
+        (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
+        (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
+        (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
+        (void) memcpy((void *)(gc->pc + 28), (void *)(name), len);
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_ProgramNamedParameter4dvNV 4219
+void
+__indirect_glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 44 + __GLX_PAD(len);
+    if (__builtin_expect(len >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+        (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+        (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+        (void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4);
+        (void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4);
+        (void) memcpy((void *)(gc->pc + 44), (void *)(name), len);
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_ProgramNamedParameter4fvNV 4218
+void
+__indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28 + __GLX_PAD(len);
+    if (__builtin_expect(len >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4);
+        (void) memcpy((void *)(gc->pc + 12), (void *)(v), 16);
+        (void) memcpy((void *)(gc->pc + 28), (void *)(name), len);
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLrop_ProgramNamedParameter4dvNV 4219
+void
+__indirect_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 44 + __GLX_PAD(len);
+    if (__builtin_expect(len >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
+        (void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4);
+        (void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4);
+        (void) memcpy((void *)(gc->pc + 44), (void *)(name), len);
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLvop_GetProgramNamedParameterfvNV 1310
+void
+__indirect_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8 + __GLX_PAD(len);
+    if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramNamedParameterfvNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&len), 4);
+        (void) memcpy((void *)(pc + 8), (void *)(name), len);
+        (void) __glXReadReply(dpy, 4, params, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_GetProgramNamedParameterdvNV 1311
+void
+__indirect_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8 + __GLX_PAD(len);
+    if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramNamedParameterdvNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&len), 4);
+        (void) memcpy((void *)(pc + 8), (void *)(name), len);
+        (void) __glXReadReply(dpy, 8, params, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLsop_GenQueriesARB 162
+void
+__indirect_glGenQueriesARB(GLsizei n, GLuint * ids)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGenQueriesARBRep *reply = XCBGlxGenQueriesARBReply(c, XCBGlxGenQueriesARB(c, gc->currentContextTag, n), NULL);
+        (void)memcpy(ids, XCBGlxGenQueriesARBData(reply), XCBGlxGenQueriesARBDataLength(reply) * sizeof(GLuint));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenQueriesARB, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        (void) __glXReadReply(dpy, 4, ids, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_DeleteQueriesARB 161
+void
+__indirect_glDeleteQueriesARB(GLsizei n, const GLuint * ids)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
+    if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxDeleteQueriesARB(c, gc->currentContextTag, n, ids);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_DeleteQueriesARB, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(ids), (n * 4));
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_IsQueryARB 163
+GLboolean
+__indirect_glIsQueryARB(GLuint id)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    GLboolean retval = (GLboolean) 0;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxIsQueryARBRep *reply = XCBGlxIsQueryARBReply(c, XCBGlxIsQueryARB(c, gc->currentContextTag, id), NULL);
+        retval = reply->ret_val;
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsQueryARB, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+        retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return retval;
+}
+
+#define X_GLrop_BeginQueryARB 231
+void
+__indirect_glBeginQueryARB(GLenum target, GLuint id)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_BeginQueryARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_EndQueryARB 232
+void
+__indirect_glEndQueryARB(GLenum target)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_EndQueryARB, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLsop_GetQueryivARB 164
+void
+__indirect_glGetQueryivARB(GLenum target, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetQueryivARBRep *reply = XCBGlxGetQueryivARBReply(c, XCBGlxGetQueryivARB(c, gc->currentContextTag, target, pname), NULL);
+        if (XCBGlxGetQueryivARBDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetQueryivARBData(reply), XCBGlxGetQueryivARBDataLength(reply) * sizeof(GLint));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryivARB, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetQueryObjectivARB 165
+void
+__indirect_glGetQueryObjectivARB(GLuint id, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetQueryObjectivARBRep *reply = XCBGlxGetQueryObjectivARBReply(c, XCBGlxGetQueryObjectivARB(c, gc->currentContextTag, id, pname), NULL);
+        if (XCBGlxGetQueryObjectivARBDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetQueryObjectivARBData(reply), XCBGlxGetQueryObjectivARBDataLength(reply) * sizeof(GLint));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectivARB, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLsop_GetQueryObjectuivARB 166
+void
+__indirect_glGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+#ifdef USE_XCB
+        XCBConnection *c = XCBConnectionOfDisplay(dpy);
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+        XCBGlxGetQueryObjectuivARBRep *reply = XCBGlxGetQueryObjectuivARBReply(c, XCBGlxGetQueryObjectuivARB(c, gc->currentContextTag, id, pname), NULL);
+        if (XCBGlxGetQueryObjectuivARBDataLength(reply) == 0)
+            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+        else
+        (void)memcpy(params, XCBGlxGetQueryObjectuivARBData(reply), XCBGlxGetQueryObjectuivARBDataLength(reply) * sizeof(GLuint));
+        free(reply);
+#else
+        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectuivARB, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+#endif /* USE_XCB */
+    }
+    return;
+}
+
+#define X_GLvop_GetVertexAttribdvNV 1301
+void
+__indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribdvNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 8, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_GetVertexAttribfvNV 1302
+void
+__indirect_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribfvNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_GetVertexAttribivNV 1303
+void
+__indirect_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribivNV, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLrop_VertexAttrib1dvNV 4197
+void
+__indirect_glVertexAttrib1dNV(GLuint index, GLdouble x)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1dvNV 4197
+void
+__indirect_glVertexAttrib1dvNV(GLuint index, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1fvNV 4193
+void
+__indirect_glVertexAttrib1fNV(GLuint index, GLfloat x)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1fvNV 4193
+void
+__indirect_glVertexAttrib1fvNV(GLuint index, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1svNV 4189
+void
+__indirect_glVertexAttrib1sNV(GLuint index, GLshort x)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib1svNV 4189
+void
+__indirect_glVertexAttrib1svNV(GLuint index, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2dvNV 4198
+void
+__indirect_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2dvNV 4198
+void
+__indirect_glVertexAttrib2dvNV(GLuint index, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2fvNV 4194
+void
+__indirect_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2fvNV 4194
+void
+__indirect_glVertexAttrib2fvNV(GLuint index, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2svNV 4190
+void
+__indirect_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib2svNV 4190
+void
+__indirect_glVertexAttrib2svNV(GLuint index, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3dvNV 4199
+void
+__indirect_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 32;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3dvNV 4199
+void
+__indirect_glVertexAttrib3dvNV(GLuint index, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 32;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 24);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3fvNV 4195
+void
+__indirect_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3fvNV 4195
+void
+__indirect_glVertexAttrib3fvNV(GLuint index, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3svNV 4191
+void
+__indirect_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib3svNV 4191
+void
+__indirect_glVertexAttrib3svNV(GLuint index, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4dvNV 4200
+void
+__indirect_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 40;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8);
+    (void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8);
+    (void) memcpy((void *)(gc->pc + 32), (void *)(&w), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4dvNV 4200
+void
+__indirect_glVertexAttrib4dvNV(GLuint index, const GLdouble * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 40;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 32);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4fvNV 4196
+void
+__indirect_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4fvNV 4196
+void
+__indirect_glVertexAttrib4fvNV(GLuint index, const GLfloat * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4svNV 4192
+void
+__indirect_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
+    (void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4svNV 4192
+void
+__indirect_glVertexAttrib4svNV(GLuint index, const GLshort * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 16;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4ubvNV 4201
+void
+__indirect_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1);
+    (void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1);
+    (void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1);
+    (void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_VertexAttrib4ubvNV 4201
+void
+__indirect_glVertexAttrib4ubvNV(GLuint index, const GLubyte * v)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLvop_IsRenderbufferEXT 1422
+GLboolean
+__indirect_glIsRenderbufferEXT(GLuint renderbuffer)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    GLboolean retval = (GLboolean) 0;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsRenderbufferEXT, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&renderbuffer), 4);
+        retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return retval;
+}
+
+#define X_GLrop_BindRenderbufferEXT 4316
+void
+__indirect_glBindRenderbufferEXT(GLenum target, GLuint renderbuffer)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_BindRenderbufferEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&renderbuffer), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_DeleteRenderbuffersEXT 4317
+void
+__indirect_glDeleteRenderbuffersEXT(GLsizei n, const GLuint * renderbuffers)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_DeleteRenderbuffersEXT, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(renderbuffers), (n * 4));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLvop_GenRenderbuffersEXT 1423
+void
+__indirect_glGenRenderbuffersEXT(GLsizei n, GLuint * renderbuffers)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenRenderbuffersEXT, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        (void) __glXReadReply(dpy, 4, renderbuffers, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLrop_RenderbufferStorageEXT 4318
+void
+__indirect_glRenderbufferStorageEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_RenderbufferStorageEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLvop_GetRenderbufferParameterivEXT 1424
+void
+__indirect_glGetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetRenderbufferParameterivEXT, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_IsFramebufferEXT 1425
+GLboolean
+__indirect_glIsFramebufferEXT(GLuint framebuffer)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    GLboolean retval = (GLboolean) 0;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsFramebufferEXT, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&framebuffer), 4);
+        retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return retval;
+}
+
+#define X_GLrop_BindFramebufferEXT 4319
+void
+__indirect_glBindFramebufferEXT(GLenum target, GLuint framebuffer)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 12;
+    emit_header(gc->pc, X_GLrop_BindFramebufferEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&framebuffer), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_DeleteFramebuffersEXT 4320
+void
+__indirect_glDeleteFramebuffersEXT(GLsizei n, const GLuint * framebuffers)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
+    if (__builtin_expect(n >= 0, 1)) {
+        emit_header(gc->pc, X_GLrop_DeleteFramebuffersEXT, cmdlen);
+        (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
+        (void) memcpy((void *)(gc->pc + 8), (void *)(framebuffers), (n * 4));
+        gc->pc += cmdlen;
+        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    }
+}
+
+#define X_GLvop_GenFramebuffersEXT 1426
+void
+__indirect_glGenFramebuffersEXT(GLsizei n, GLuint * framebuffers)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenFramebuffersEXT, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        (void) __glXReadReply(dpy, 4, framebuffers, GL_TRUE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLvop_CheckFramebufferStatusEXT 1427
+GLenum
+__indirect_glCheckFramebufferStatusEXT(GLenum target)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    GLenum retval = (GLenum) 0;
+    const GLuint cmdlen = 4;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_CheckFramebufferStatusEXT, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        retval = (GLenum) __glXReadReply(dpy, 0, NULL, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return retval;
+}
+
+#define X_GLrop_FramebufferTexture1DEXT 4321
+void
+__indirect_glFramebufferTexture1DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_FramebufferTexture1DEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&textarget), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&texture), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&level), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_FramebufferTexture2DEXT 4322
+void
+__indirect_glFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 24;
+    emit_header(gc->pc, X_GLrop_FramebufferTexture2DEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&textarget), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&texture), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&level), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_FramebufferTexture3DEXT 4323
+void
+__indirect_glFramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 28;
+    emit_header(gc->pc, X_GLrop_FramebufferTexture3DEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&textarget), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&texture), 4);
+    (void) memcpy((void *)(gc->pc + 20), (void *)(&level), 4);
+    (void) memcpy((void *)(gc->pc + 24), (void *)(&zoffset), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLrop_FramebufferRenderbufferEXT 4324
+void
+__indirect_glFramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 20;
+    emit_header(gc->pc, X_GLrop_FramebufferRenderbufferEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4);
+    (void) memcpy((void *)(gc->pc + 12), (void *)(&renderbuffertarget), 4);
+    (void) memcpy((void *)(gc->pc + 16), (void *)(&renderbuffer), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+#define X_GLvop_GetFramebufferAttachmentParameterivEXT 1428
+void
+__indirect_glGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, GLint * params)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 12;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetFramebufferAttachmentParameterivEXT, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        (void) memcpy((void *)(pc + 4), (void *)(&attachment), 4);
+        (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+        (void) __glXReadReply(dpy, 4, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+#define X_GLrop_GenerateMipmapEXT 4325
+void
+__indirect_glGenerateMipmapEXT(GLenum target)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    const GLuint cmdlen = 8;
+    emit_header(gc->pc, X_GLrop_GenerateMipmapEXT, cmdlen);
+    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+}
+
+
+#  undef FASTCALL
+#  undef NOINLINE
diff --git a/src/glx/x11/indirect.h b/src/glx/x11/indirect.h
new file mode 100644
index 00000000000..1c45fa28a4c
--- /dev/null
+++ b/src/glx/x11/indirect.h
@@ -0,0 +1,707 @@
+/* DO NOT EDIT - This file generated automatically by glX_proto_send.py (from Mesa) script */
+
+/*
+ * Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+ * (C) Copyright IBM Corporation 2004
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * PRECISION INSIGHT, IBM,
+ * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#if !defined( _INDIRECT_H_ )
+#  define _INDIRECT_H_
+
+/**
+ * \file
+ * Prototypes for indirect rendering functions.
+ *
+ * \author Kevin E. Martin <[email protected]>
+ * \author Ian Romanick <[email protected]>
+ */
+
+#  if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__)
+#    define HIDDEN  __attribute__((visibility("hidden")))
+#  else
+#    define HIDDEN
+#  endif
+#  if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined(__MINGW32__)
+#    define FASTCALL __attribute__((fastcall))
+#  else
+#    define FASTCALL
+#  endif
+#  if defined(__GNUC__)
+#    define NOINLINE __attribute__((noinline))
+#  else
+#    define NOINLINE
+#  endif
+
+#include "glxclient.h"
+
+extern HIDDEN NOINLINE CARD32 __glXReadReply( Display *dpy, size_t size,
+    void * dest, GLboolean reply_is_always_array );
+
+extern HIDDEN NOINLINE void __glXReadPixelReply( Display *dpy,
+    __GLXcontext * gc, unsigned max_dim, GLint width, GLint height,
+    GLint depth, GLenum format, GLenum type, void * dest,
+    GLboolean dimensions_in_reply );
+
+extern HIDDEN NOINLINE FASTCALL GLubyte * __glXSetupSingleRequest(
+    __GLXcontext * gc, GLint sop, GLint cmdlen );
+
+extern HIDDEN NOINLINE FASTCALL GLubyte * __glXSetupVendorRequest(
+    __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen );
+
+extern HIDDEN void __indirect_glNewList(GLuint list, GLenum mode);
+extern HIDDEN void __indirect_glEndList(void);
+extern HIDDEN void __indirect_glCallList(GLuint list);
+extern HIDDEN void __indirect_glCallLists(GLsizei n, GLenum type, const GLvoid * lists);
+extern HIDDEN void __indirect_glDeleteLists(GLuint list, GLsizei range);
+extern HIDDEN GLuint __indirect_glGenLists(GLsizei range);
+extern HIDDEN void __indirect_glListBase(GLuint base);
+extern HIDDEN void __indirect_glBegin(GLenum mode);
+extern HIDDEN void __indirect_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap);
+extern HIDDEN void __indirect_glColor3b(GLbyte red, GLbyte green, GLbyte blue);
+extern HIDDEN void __indirect_glColor3bv(const GLbyte * v);
+extern HIDDEN void __indirect_glColor3d(GLdouble red, GLdouble green, GLdouble blue);
+extern HIDDEN void __indirect_glColor3dv(const GLdouble * v);
+extern HIDDEN void __indirect_glColor3f(GLfloat red, GLfloat green, GLfloat blue);
+extern HIDDEN void __indirect_glColor3fv(const GLfloat * v);
+extern HIDDEN void __indirect_glColor3i(GLint red, GLint green, GLint blue);
+extern HIDDEN void __indirect_glColor3iv(const GLint * v);
+extern HIDDEN void __indirect_glColor3s(GLshort red, GLshort green, GLshort blue);
+extern HIDDEN void __indirect_glColor3sv(const GLshort * v);
+extern HIDDEN void __indirect_glColor3ub(GLubyte red, GLubyte green, GLubyte blue);
+extern HIDDEN void __indirect_glColor3ubv(const GLubyte * v);
+extern HIDDEN void __indirect_glColor3ui(GLuint red, GLuint green, GLuint blue);
+extern HIDDEN void __indirect_glColor3uiv(const GLuint * v);
+extern HIDDEN void __indirect_glColor3us(GLushort red, GLushort green, GLushort blue);
+extern HIDDEN void __indirect_glColor3usv(const GLushort * v);
+extern HIDDEN void __indirect_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+extern HIDDEN void __indirect_glColor4bv(const GLbyte * v);
+extern HIDDEN void __indirect_glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+extern HIDDEN void __indirect_glColor4dv(const GLdouble * v);
+extern HIDDEN void __indirect_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+extern HIDDEN void __indirect_glColor4fv(const GLfloat * v);
+extern HIDDEN void __indirect_glColor4i(GLint red, GLint green, GLint blue, GLint alpha);
+extern HIDDEN void __indirect_glColor4iv(const GLint * v);
+extern HIDDEN void __indirect_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
+extern HIDDEN void __indirect_glColor4sv(const GLshort * v);
+extern HIDDEN void __indirect_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+extern HIDDEN void __indirect_glColor4ubv(const GLubyte * v);
+extern HIDDEN void __indirect_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+extern HIDDEN void __indirect_glColor4uiv(const GLuint * v);
+extern HIDDEN void __indirect_glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
+extern HIDDEN void __indirect_glColor4usv(const GLushort * v);
+extern HIDDEN void __indirect_glEdgeFlag(GLboolean flag);
+extern HIDDEN void __indirect_glEdgeFlagv(const GLboolean * flag);
+extern HIDDEN void __indirect_glEnd(void);
+extern HIDDEN void __indirect_glIndexd(GLdouble c);
+extern HIDDEN void __indirect_glIndexdv(const GLdouble * c);
+extern HIDDEN void __indirect_glIndexf(GLfloat c);
+extern HIDDEN void __indirect_glIndexfv(const GLfloat * c);
+extern HIDDEN void __indirect_glIndexi(GLint c);
+extern HIDDEN void __indirect_glIndexiv(const GLint * c);
+extern HIDDEN void __indirect_glIndexs(GLshort c);
+extern HIDDEN void __indirect_glIndexsv(const GLshort * c);
+extern HIDDEN void __indirect_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);
+extern HIDDEN void __indirect_glNormal3bv(const GLbyte * v);
+extern HIDDEN void __indirect_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);
+extern HIDDEN void __indirect_glNormal3dv(const GLdouble * v);
+extern HIDDEN void __indirect_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
+extern HIDDEN void __indirect_glNormal3fv(const GLfloat * v);
+extern HIDDEN void __indirect_glNormal3i(GLint nx, GLint ny, GLint nz);
+extern HIDDEN void __indirect_glNormal3iv(const GLint * v);
+extern HIDDEN void __indirect_glNormal3s(GLshort nx, GLshort ny, GLshort nz);
+extern HIDDEN void __indirect_glNormal3sv(const GLshort * v);
+extern HIDDEN void __indirect_glRasterPos2d(GLdouble x, GLdouble y);
+extern HIDDEN void __indirect_glRasterPos2dv(const GLdouble * v);
+extern HIDDEN void __indirect_glRasterPos2f(GLfloat x, GLfloat y);
+extern HIDDEN void __indirect_glRasterPos2fv(const GLfloat * v);
+extern HIDDEN void __indirect_glRasterPos2i(GLint x, GLint y);
+extern HIDDEN void __indirect_glRasterPos2iv(const GLint * v);
+extern HIDDEN void __indirect_glRasterPos2s(GLshort x, GLshort y);
+extern HIDDEN void __indirect_glRasterPos2sv(const GLshort * v);
+extern HIDDEN void __indirect_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);
+extern HIDDEN void __indirect_glRasterPos3dv(const GLdouble * v);
+extern HIDDEN void __indirect_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);
+extern HIDDEN void __indirect_glRasterPos3fv(const GLfloat * v);
+extern HIDDEN void __indirect_glRasterPos3i(GLint x, GLint y, GLint z);
+extern HIDDEN void __indirect_glRasterPos3iv(const GLint * v);
+extern HIDDEN void __indirect_glRasterPos3s(GLshort x, GLshort y, GLshort z);
+extern HIDDEN void __indirect_glRasterPos3sv(const GLshort * v);
+extern HIDDEN void __indirect_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glRasterPos4dv(const GLdouble * v);
+extern HIDDEN void __indirect_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glRasterPos4fv(const GLfloat * v);
+extern HIDDEN void __indirect_glRasterPos4i(GLint x, GLint y, GLint z, GLint w);
+extern HIDDEN void __indirect_glRasterPos4iv(const GLint * v);
+extern HIDDEN void __indirect_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
+extern HIDDEN void __indirect_glRasterPos4sv(const GLshort * v);
+extern HIDDEN void __indirect_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+extern HIDDEN void __indirect_glRectdv(const GLdouble * v1, const GLdouble * v2);
+extern HIDDEN void __indirect_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+extern HIDDEN void __indirect_glRectfv(const GLfloat * v1, const GLfloat * v2);
+extern HIDDEN void __indirect_glRecti(GLint x1, GLint y1, GLint x2, GLint y2);
+extern HIDDEN void __indirect_glRectiv(const GLint * v1, const GLint * v2);
+extern HIDDEN void __indirect_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+extern HIDDEN void __indirect_glRectsv(const GLshort * v1, const GLshort * v2);
+extern HIDDEN void __indirect_glTexCoord1d(GLdouble s);
+extern HIDDEN void __indirect_glTexCoord1dv(const GLdouble * v);
+extern HIDDEN void __indirect_glTexCoord1f(GLfloat s);
+extern HIDDEN void __indirect_glTexCoord1fv(const GLfloat * v);
+extern HIDDEN void __indirect_glTexCoord1i(GLint s);
+extern HIDDEN void __indirect_glTexCoord1iv(const GLint * v);
+extern HIDDEN void __indirect_glTexCoord1s(GLshort s);
+extern HIDDEN void __indirect_glTexCoord1sv(const GLshort * v);
+extern HIDDEN void __indirect_glTexCoord2d(GLdouble s, GLdouble t);
+extern HIDDEN void __indirect_glTexCoord2dv(const GLdouble * v);
+extern HIDDEN void __indirect_glTexCoord2f(GLfloat s, GLfloat t);
+extern HIDDEN void __indirect_glTexCoord2fv(const GLfloat * v);
+extern HIDDEN void __indirect_glTexCoord2i(GLint s, GLint t);
+extern HIDDEN void __indirect_glTexCoord2iv(const GLint * v);
+extern HIDDEN void __indirect_glTexCoord2s(GLshort s, GLshort t);
+extern HIDDEN void __indirect_glTexCoord2sv(const GLshort * v);
+extern HIDDEN void __indirect_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);
+extern HIDDEN void __indirect_glTexCoord3dv(const GLdouble * v);
+extern HIDDEN void __indirect_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);
+extern HIDDEN void __indirect_glTexCoord3fv(const GLfloat * v);
+extern HIDDEN void __indirect_glTexCoord3i(GLint s, GLint t, GLint r);
+extern HIDDEN void __indirect_glTexCoord3iv(const GLint * v);
+extern HIDDEN void __indirect_glTexCoord3s(GLshort s, GLshort t, GLshort r);
+extern HIDDEN void __indirect_glTexCoord3sv(const GLshort * v);
+extern HIDDEN void __indirect_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+extern HIDDEN void __indirect_glTexCoord4dv(const GLdouble * v);
+extern HIDDEN void __indirect_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+extern HIDDEN void __indirect_glTexCoord4fv(const GLfloat * v);
+extern HIDDEN void __indirect_glTexCoord4i(GLint s, GLint t, GLint r, GLint q);
+extern HIDDEN void __indirect_glTexCoord4iv(const GLint * v);
+extern HIDDEN void __indirect_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
+extern HIDDEN void __indirect_glTexCoord4sv(const GLshort * v);
+extern HIDDEN void __indirect_glVertex2d(GLdouble x, GLdouble y);
+extern HIDDEN void __indirect_glVertex2dv(const GLdouble * v);
+extern HIDDEN void __indirect_glVertex2f(GLfloat x, GLfloat y);
+extern HIDDEN void __indirect_glVertex2fv(const GLfloat * v);
+extern HIDDEN void __indirect_glVertex2i(GLint x, GLint y);
+extern HIDDEN void __indirect_glVertex2iv(const GLint * v);
+extern HIDDEN void __indirect_glVertex2s(GLshort x, GLshort y);
+extern HIDDEN void __indirect_glVertex2sv(const GLshort * v);
+extern HIDDEN void __indirect_glVertex3d(GLdouble x, GLdouble y, GLdouble z);
+extern HIDDEN void __indirect_glVertex3dv(const GLdouble * v);
+extern HIDDEN void __indirect_glVertex3f(GLfloat x, GLfloat y, GLfloat z);
+extern HIDDEN void __indirect_glVertex3fv(const GLfloat * v);
+extern HIDDEN void __indirect_glVertex3i(GLint x, GLint y, GLint z);
+extern HIDDEN void __indirect_glVertex3iv(const GLint * v);
+extern HIDDEN void __indirect_glVertex3s(GLshort x, GLshort y, GLshort z);
+extern HIDDEN void __indirect_glVertex3sv(const GLshort * v);
+extern HIDDEN void __indirect_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glVertex4dv(const GLdouble * v);
+extern HIDDEN void __indirect_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glVertex4fv(const GLfloat * v);
+extern HIDDEN void __indirect_glVertex4i(GLint x, GLint y, GLint z, GLint w);
+extern HIDDEN void __indirect_glVertex4iv(const GLint * v);
+extern HIDDEN void __indirect_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
+extern HIDDEN void __indirect_glVertex4sv(const GLshort * v);
+extern HIDDEN void __indirect_glClipPlane(GLenum plane, const GLdouble * equation);
+extern HIDDEN void __indirect_glColorMaterial(GLenum face, GLenum mode);
+extern HIDDEN void __indirect_glCullFace(GLenum mode);
+extern HIDDEN void __indirect_glFogf(GLenum pname, GLfloat param);
+extern HIDDEN void __indirect_glFogfv(GLenum pname, const GLfloat * params);
+extern HIDDEN void __indirect_glFogi(GLenum pname, GLint param);
+extern HIDDEN void __indirect_glFogiv(GLenum pname, const GLint * params);
+extern HIDDEN void __indirect_glFrontFace(GLenum mode);
+extern HIDDEN void __indirect_glHint(GLenum target, GLenum mode);
+extern HIDDEN void __indirect_glLightf(GLenum light, GLenum pname, GLfloat param);
+extern HIDDEN void __indirect_glLightfv(GLenum light, GLenum pname, const GLfloat * params);
+extern HIDDEN void __indirect_glLighti(GLenum light, GLenum pname, GLint param);
+extern HIDDEN void __indirect_glLightiv(GLenum light, GLenum pname, const GLint * params);
+extern HIDDEN void __indirect_glLightModelf(GLenum pname, GLfloat param);
+extern HIDDEN void __indirect_glLightModelfv(GLenum pname, const GLfloat * params);
+extern HIDDEN void __indirect_glLightModeli(GLenum pname, GLint param);
+extern HIDDEN void __indirect_glLightModeliv(GLenum pname, const GLint * params);
+extern HIDDEN void __indirect_glLineStipple(GLint factor, GLushort pattern);
+extern HIDDEN void __indirect_glLineWidth(GLfloat width);
+extern HIDDEN void __indirect_glMaterialf(GLenum face, GLenum pname, GLfloat param);
+extern HIDDEN void __indirect_glMaterialfv(GLenum face, GLenum pname, const GLfloat * params);
+extern HIDDEN void __indirect_glMateriali(GLenum face, GLenum pname, GLint param);
+extern HIDDEN void __indirect_glMaterialiv(GLenum face, GLenum pname, const GLint * params);
+extern HIDDEN void __indirect_glPointSize(GLfloat size);
+extern HIDDEN void __indirect_glPolygonMode(GLenum face, GLenum mode);
+extern HIDDEN void __indirect_glPolygonStipple(const GLubyte * mask);
+extern HIDDEN void __indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
+extern HIDDEN void __indirect_glShadeModel(GLenum mode);
+extern HIDDEN void __indirect_glTexParameterf(GLenum target, GLenum pname, GLfloat param);
+extern HIDDEN void __indirect_glTexParameterfv(GLenum target, GLenum pname, const GLfloat * params);
+extern HIDDEN void __indirect_glTexParameteri(GLenum target, GLenum pname, GLint param);
+extern HIDDEN void __indirect_glTexParameteriv(GLenum target, GLenum pname, const GLint * params);
+extern HIDDEN void __indirect_glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels);
+extern HIDDEN void __indirect_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels);
+extern HIDDEN void __indirect_glTexEnvf(GLenum target, GLenum pname, GLfloat param);
+extern HIDDEN void __indirect_glTexEnvfv(GLenum target, GLenum pname, const GLfloat * params);
+extern HIDDEN void __indirect_glTexEnvi(GLenum target, GLenum pname, GLint param);
+extern HIDDEN void __indirect_glTexEnviv(GLenum target, GLenum pname, const GLint * params);
+extern HIDDEN void __indirect_glTexGend(GLenum coord, GLenum pname, GLdouble param);
+extern HIDDEN void __indirect_glTexGendv(GLenum coord, GLenum pname, const GLdouble * params);
+extern HIDDEN void __indirect_glTexGenf(GLenum coord, GLenum pname, GLfloat param);
+extern HIDDEN void __indirect_glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params);
+extern HIDDEN void __indirect_glTexGeni(GLenum coord, GLenum pname, GLint param);
+extern HIDDEN void __indirect_glTexGeniv(GLenum coord, GLenum pname, const GLint * params);
+extern HIDDEN void __indirect_glFeedbackBuffer(GLsizei size, GLenum type, GLfloat * buffer);
+extern HIDDEN void __indirect_glSelectBuffer(GLsizei size, GLuint * buffer);
+extern HIDDEN GLint __indirect_glRenderMode(GLenum mode);
+extern HIDDEN void __indirect_glInitNames(void);
+extern HIDDEN void __indirect_glLoadName(GLuint name);
+extern HIDDEN void __indirect_glPassThrough(GLfloat token);
+extern HIDDEN void __indirect_glPopName(void);
+extern HIDDEN void __indirect_glPushName(GLuint name);
+extern HIDDEN void __indirect_glDrawBuffer(GLenum mode);
+extern HIDDEN void __indirect_glClear(GLbitfield mask);
+extern HIDDEN void __indirect_glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+extern HIDDEN void __indirect_glClearIndex(GLfloat c);
+extern HIDDEN void __indirect_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+extern HIDDEN void __indirect_glClearStencil(GLint s);
+extern HIDDEN void __indirect_glClearDepth(GLclampd depth);
+extern HIDDEN void __indirect_glStencilMask(GLuint mask);
+extern HIDDEN void __indirect_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+extern HIDDEN void __indirect_glDepthMask(GLboolean flag);
+extern HIDDEN void __indirect_glIndexMask(GLuint mask);
+extern HIDDEN void __indirect_glAccum(GLenum op, GLfloat value);
+extern HIDDEN void __indirect_glDisable(GLenum cap);
+extern HIDDEN void __indirect_glEnable(GLenum cap);
+extern HIDDEN void __indirect_glFinish(void);
+extern HIDDEN void __indirect_glFlush(void);
+extern HIDDEN void __indirect_glPopAttrib(void);
+extern HIDDEN void __indirect_glPushAttrib(GLbitfield mask);
+extern HIDDEN void __indirect_glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble * points);
+extern HIDDEN void __indirect_glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat * points);
+extern HIDDEN void __indirect_glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble * points);
+extern HIDDEN void __indirect_glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat * points);
+extern HIDDEN void __indirect_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);
+extern HIDDEN void __indirect_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);
+extern HIDDEN void __indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+extern HIDDEN void __indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+extern HIDDEN void __indirect_glEvalCoord1d(GLdouble u);
+extern HIDDEN void __indirect_glEvalCoord1dv(const GLdouble * u);
+extern HIDDEN void __indirect_glEvalCoord1f(GLfloat u);
+extern HIDDEN void __indirect_glEvalCoord1fv(const GLfloat * u);
+extern HIDDEN void __indirect_glEvalCoord2d(GLdouble u, GLdouble v);
+extern HIDDEN void __indirect_glEvalCoord2dv(const GLdouble * u);
+extern HIDDEN void __indirect_glEvalCoord2f(GLfloat u, GLfloat v);
+extern HIDDEN void __indirect_glEvalCoord2fv(const GLfloat * u);
+extern HIDDEN void __indirect_glEvalMesh1(GLenum mode, GLint i1, GLint i2);
+extern HIDDEN void __indirect_glEvalPoint1(GLint i);
+extern HIDDEN void __indirect_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+extern HIDDEN void __indirect_glEvalPoint2(GLint i, GLint j);
+extern HIDDEN void __indirect_glAlphaFunc(GLenum func, GLclampf ref);
+extern HIDDEN void __indirect_glBlendFunc(GLenum sfactor, GLenum dfactor);
+extern HIDDEN void __indirect_glLogicOp(GLenum opcode);
+extern HIDDEN void __indirect_glStencilFunc(GLenum func, GLint ref, GLuint mask);
+extern HIDDEN void __indirect_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
+extern HIDDEN void __indirect_glDepthFunc(GLenum func);
+extern HIDDEN void __indirect_glPixelZoom(GLfloat xfactor, GLfloat yfactor);
+extern HIDDEN void __indirect_glPixelTransferf(GLenum pname, GLfloat param);
+extern HIDDEN void __indirect_glPixelTransferi(GLenum pname, GLint param);
+extern HIDDEN void __indirect_glPixelStoref(GLenum pname, GLfloat param);
+extern HIDDEN void __indirect_glPixelStorei(GLenum pname, GLint param);
+extern HIDDEN void __indirect_glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat * values);
+extern HIDDEN void __indirect_glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint * values);
+extern HIDDEN void __indirect_glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort * values);
+extern HIDDEN void __indirect_glReadBuffer(GLenum mode);
+extern HIDDEN void __indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+extern HIDDEN void __indirect_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels);
+extern HIDDEN void __indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels);
+extern HIDDEN void __indirect_glGetBooleanv(GLenum pname, GLboolean * params);
+extern HIDDEN void __indirect_glGetClipPlane(GLenum plane, GLdouble * equation);
+extern HIDDEN void __indirect_glGetDoublev(GLenum pname, GLdouble * params);
+extern HIDDEN GLenum __indirect_glGetError(void);
+extern HIDDEN void __indirect_glGetFloatv(GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetIntegerv(GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetLightfv(GLenum light, GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetLightiv(GLenum light, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetMapdv(GLenum target, GLenum query, GLdouble * v);
+extern HIDDEN void __indirect_glGetMapfv(GLenum target, GLenum query, GLfloat * v);
+extern HIDDEN void __indirect_glGetMapiv(GLenum target, GLenum query, GLint * v);
+extern HIDDEN void __indirect_glGetMaterialfv(GLenum face, GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetMaterialiv(GLenum face, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetPixelMapfv(GLenum map, GLfloat * values);
+extern HIDDEN void __indirect_glGetPixelMapuiv(GLenum map, GLuint * values);
+extern HIDDEN void __indirect_glGetPixelMapusv(GLenum map, GLushort * values);
+extern HIDDEN void __indirect_glGetPolygonStipple(GLubyte * mask);
+extern HIDDEN const GLubyte * __indirect_glGetString(GLenum name);
+extern HIDDEN void __indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetTexEnviv(GLenum target, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetTexGendv(GLenum coord, GLenum pname, GLdouble * params);
+extern HIDDEN void __indirect_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetTexGeniv(GLenum coord, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels);
+extern HIDDEN void __indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetTexParameteriv(GLenum target, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint * params);
+extern HIDDEN GLboolean __indirect_glIsEnabled(GLenum cap);
+extern HIDDEN GLboolean __indirect_glIsList(GLuint list);
+extern HIDDEN void __indirect_glDepthRange(GLclampd zNear, GLclampd zFar);
+extern HIDDEN void __indirect_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+extern HIDDEN void __indirect_glLoadIdentity(void);
+extern HIDDEN void __indirect_glLoadMatrixf(const GLfloat * m);
+extern HIDDEN void __indirect_glLoadMatrixd(const GLdouble * m);
+extern HIDDEN void __indirect_glMatrixMode(GLenum mode);
+extern HIDDEN void __indirect_glMultMatrixf(const GLfloat * m);
+extern HIDDEN void __indirect_glMultMatrixd(const GLdouble * m);
+extern HIDDEN void __indirect_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+extern HIDDEN void __indirect_glPopMatrix(void);
+extern HIDDEN void __indirect_glPushMatrix(void);
+extern HIDDEN void __indirect_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+extern HIDDEN void __indirect_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+extern HIDDEN void __indirect_glScaled(GLdouble x, GLdouble y, GLdouble z);
+extern HIDDEN void __indirect_glScalef(GLfloat x, GLfloat y, GLfloat z);
+extern HIDDEN void __indirect_glTranslated(GLdouble x, GLdouble y, GLdouble z);
+extern HIDDEN void __indirect_glTranslatef(GLfloat x, GLfloat y, GLfloat z);
+extern HIDDEN void __indirect_glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
+extern HIDDEN void __indirect_glArrayElement(GLint i);
+extern HIDDEN void __indirect_glBindTexture(GLenum target, GLuint texture);
+extern HIDDEN void __indirect_glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer);
+extern HIDDEN void __indirect_glDisableClientState(GLenum array);
+extern HIDDEN void __indirect_glDrawArrays(GLenum mode, GLint first, GLsizei count);
+extern HIDDEN void __indirect_glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices);
+extern HIDDEN void __indirect_glEdgeFlagPointer(GLsizei stride, const GLvoid * pointer);
+extern HIDDEN void __indirect_glEnableClientState(GLenum array);
+extern HIDDEN void __indirect_glIndexPointer(GLenum type, GLsizei stride, const GLvoid * pointer);
+extern HIDDEN void __indirect_glIndexub(GLubyte c);
+extern HIDDEN void __indirect_glIndexubv(const GLubyte * c);
+extern HIDDEN void __indirect_glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid * pointer);
+extern HIDDEN void __indirect_glNormalPointer(GLenum type, GLsizei stride, const GLvoid * pointer);
+extern HIDDEN void __indirect_glPolygonOffset(GLfloat factor, GLfloat units);
+extern HIDDEN void __indirect_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer);
+extern HIDDEN void __indirect_glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer);
+extern HIDDEN GLboolean __indirect_glAreTexturesResident(GLsizei n, const GLuint * textures, GLboolean * residences);
+extern HIDDEN void __indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+extern HIDDEN void __indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+extern HIDDEN void __indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+extern HIDDEN void __indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+extern HIDDEN void __indirect_glDeleteTextures(GLsizei n, const GLuint * textures);
+extern HIDDEN void __indirect_glGenTextures(GLsizei n, GLuint * textures);
+extern HIDDEN void __indirect_glGetPointerv(GLenum pname, GLvoid ** params);
+extern HIDDEN GLboolean __indirect_glIsTexture(GLuint texture);
+extern HIDDEN void __indirect_glPrioritizeTextures(GLsizei n, const GLuint * textures, const GLclampf * priorities);
+extern HIDDEN void __indirect_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels);
+extern HIDDEN void __indirect_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels);
+extern HIDDEN void __indirect_glPopClientAttrib(void);
+extern HIDDEN void __indirect_glPushClientAttrib(GLbitfield mask);
+extern HIDDEN void __indirect_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+extern HIDDEN void __indirect_glBlendEquation(GLenum mode);
+extern HIDDEN void __indirect_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices);
+extern HIDDEN void __indirect_glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table);
+extern HIDDEN void __indirect_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat * params);
+extern HIDDEN void __indirect_glColorTableParameteriv(GLenum target, GLenum pname, const GLint * params);
+extern HIDDEN void __indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+extern HIDDEN void __indirect_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid * table);
+extern HIDDEN void __indirect_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data);
+extern HIDDEN void __indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
+extern HIDDEN void __indirect_glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image);
+extern HIDDEN void __indirect_glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image);
+extern HIDDEN void __indirect_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params);
+extern HIDDEN void __indirect_glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat * params);
+extern HIDDEN void __indirect_glConvolutionParameteri(GLenum target, GLenum pname, GLint params);
+extern HIDDEN void __indirect_glConvolutionParameteriv(GLenum target, GLenum pname, const GLint * params);
+extern HIDDEN void __indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+extern HIDDEN void __indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
+extern HIDDEN void __indirect_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid * image);
+extern HIDDEN void __indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span);
+extern HIDDEN void __indirect_glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column);
+extern HIDDEN void __indirect_glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values);
+extern HIDDEN void __indirect_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values);
+extern HIDDEN void __indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
+extern HIDDEN void __indirect_glMinmax(GLenum target, GLenum internalformat, GLboolean sink);
+extern HIDDEN void __indirect_glResetHistogram(GLenum target);
+extern HIDDEN void __indirect_glResetMinmax(GLenum target);
+extern HIDDEN void __indirect_glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels);
+extern HIDDEN void __indirect_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels);
+extern HIDDEN void __indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+extern HIDDEN void __indirect_glActiveTextureARB(GLenum texture);
+extern HIDDEN void __indirect_glClientActiveTextureARB(GLenum texture);
+extern HIDDEN void __indirect_glMultiTexCoord1dARB(GLenum target, GLdouble s);
+extern HIDDEN void __indirect_glMultiTexCoord1dvARB(GLenum target, const GLdouble * v);
+extern HIDDEN void __indirect_glMultiTexCoord1fARB(GLenum target, GLfloat s);
+extern HIDDEN void __indirect_glMultiTexCoord1fvARB(GLenum target, const GLfloat * v);
+extern HIDDEN void __indirect_glMultiTexCoord1iARB(GLenum target, GLint s);
+extern HIDDEN void __indirect_glMultiTexCoord1ivARB(GLenum target, const GLint * v);
+extern HIDDEN void __indirect_glMultiTexCoord1sARB(GLenum target, GLshort s);
+extern HIDDEN void __indirect_glMultiTexCoord1svARB(GLenum target, const GLshort * v);
+extern HIDDEN void __indirect_glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t);
+extern HIDDEN void __indirect_glMultiTexCoord2dvARB(GLenum target, const GLdouble * v);
+extern HIDDEN void __indirect_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t);
+extern HIDDEN void __indirect_glMultiTexCoord2fvARB(GLenum target, const GLfloat * v);
+extern HIDDEN void __indirect_glMultiTexCoord2iARB(GLenum target, GLint s, GLint t);
+extern HIDDEN void __indirect_glMultiTexCoord2ivARB(GLenum target, const GLint * v);
+extern HIDDEN void __indirect_glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t);
+extern HIDDEN void __indirect_glMultiTexCoord2svARB(GLenum target, const GLshort * v);
+extern HIDDEN void __indirect_glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r);
+extern HIDDEN void __indirect_glMultiTexCoord3dvARB(GLenum target, const GLdouble * v);
+extern HIDDEN void __indirect_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r);
+extern HIDDEN void __indirect_glMultiTexCoord3fvARB(GLenum target, const GLfloat * v);
+extern HIDDEN void __indirect_glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r);
+extern HIDDEN void __indirect_glMultiTexCoord3ivARB(GLenum target, const GLint * v);
+extern HIDDEN void __indirect_glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r);
+extern HIDDEN void __indirect_glMultiTexCoord3svARB(GLenum target, const GLshort * v);
+extern HIDDEN void __indirect_glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+extern HIDDEN void __indirect_glMultiTexCoord4dvARB(GLenum target, const GLdouble * v);
+extern HIDDEN void __indirect_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+extern HIDDEN void __indirect_glMultiTexCoord4fvARB(GLenum target, const GLfloat * v);
+extern HIDDEN void __indirect_glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q);
+extern HIDDEN void __indirect_glMultiTexCoord4ivARB(GLenum target, const GLint * v);
+extern HIDDEN void __indirect_glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+extern HIDDEN void __indirect_glMultiTexCoord4svARB(GLenum target, const GLshort * v);
+extern HIDDEN void __indirect_glLoadTransposeMatrixfARB(const GLfloat * m);
+extern HIDDEN void __indirect_glLoadTransposeMatrixdARB(const GLdouble * m);
+extern HIDDEN void __indirect_glMultTransposeMatrixfARB(const GLfloat * m);
+extern HIDDEN void __indirect_glMultTransposeMatrixdARB(const GLdouble * m);
+extern HIDDEN void __indirect_glSampleCoverageARB(GLclampf value, GLboolean invert);
+extern HIDDEN void __indirect_glDrawBuffersARB(GLsizei n, const GLenum * bufs);
+extern HIDDEN GLboolean __indirect_glAreTexturesResidentEXT(GLsizei n, const GLuint * textures, GLboolean * residences);
+extern HIDDEN void __indirect_glGenTexturesEXT(GLsizei n, GLuint * textures);
+extern HIDDEN GLboolean __indirect_glIsTextureEXT(GLuint texture);
+extern HIDDEN void __indirect_glSampleMaskSGIS(GLclampf value, GLboolean invert);
+extern HIDDEN void __indirect_glSamplePatternSGIS(GLenum pattern);
+extern HIDDEN void __indirect_glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer);
+extern HIDDEN void __indirect_glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean * pointer);
+extern HIDDEN void __indirect_glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer);
+extern HIDDEN void __indirect_glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer);
+extern HIDDEN void __indirect_glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer);
+extern HIDDEN void __indirect_glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer);
+extern HIDDEN void __indirect_glPointParameterfEXT(GLenum pname, GLfloat param);
+extern HIDDEN void __indirect_glPointParameterfvEXT(GLenum pname, const GLfloat * params);
+extern HIDDEN void __indirect_glWindowPos2dMESA(GLdouble x, GLdouble y);
+extern HIDDEN void __indirect_glWindowPos2dvMESA(const GLdouble * v);
+extern HIDDEN void __indirect_glWindowPos2fMESA(GLfloat x, GLfloat y);
+extern HIDDEN void __indirect_glWindowPos2fvMESA(const GLfloat * v);
+extern HIDDEN void __indirect_glWindowPos2iMESA(GLint x, GLint y);
+extern HIDDEN void __indirect_glWindowPos2ivMESA(const GLint * v);
+extern HIDDEN void __indirect_glWindowPos2sMESA(GLshort x, GLshort y);
+extern HIDDEN void __indirect_glWindowPos2svMESA(const GLshort * v);
+extern HIDDEN void __indirect_glWindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z);
+extern HIDDEN void __indirect_glWindowPos3dvMESA(const GLdouble * v);
+extern HIDDEN void __indirect_glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z);
+extern HIDDEN void __indirect_glWindowPos3fvMESA(const GLfloat * v);
+extern HIDDEN void __indirect_glWindowPos3iMESA(GLint x, GLint y, GLint z);
+extern HIDDEN void __indirect_glWindowPos3ivMESA(const GLint * v);
+extern HIDDEN void __indirect_glWindowPos3sMESA(GLshort x, GLshort y, GLshort z);
+extern HIDDEN void __indirect_glWindowPos3svMESA(const GLshort * v);
+extern HIDDEN void __indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+extern HIDDEN void __indirect_glFogCoordfEXT(GLfloat coord);
+extern HIDDEN void __indirect_glFogCoordfvEXT(const GLfloat * coord);
+extern HIDDEN void __indirect_glFogCoorddEXT(GLdouble coord);
+extern HIDDEN void __indirect_glFogCoorddvEXT(const GLdouble * coord);
+extern HIDDEN void __indirect_glFogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid * pointer);
+extern HIDDEN void __indirect_glCompressedTexImage3DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data);
+extern HIDDEN void __indirect_glCompressedTexImage2DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data);
+extern HIDDEN void __indirect_glCompressedTexImage1DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data);
+extern HIDDEN void __indirect_glCompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data);
+extern HIDDEN void __indirect_glCompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data);
+extern HIDDEN void __indirect_glCompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data);
+extern HIDDEN void __indirect_glGetCompressedTexImageARB(GLenum target, GLint level, GLvoid * img);
+extern HIDDEN void __indirect_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue);
+extern HIDDEN void __indirect_glSecondaryColor3bvEXT(const GLbyte * v);
+extern HIDDEN void __indirect_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue);
+extern HIDDEN void __indirect_glSecondaryColor3dvEXT(const GLdouble * v);
+extern HIDDEN void __indirect_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue);
+extern HIDDEN void __indirect_glSecondaryColor3fvEXT(const GLfloat * v);
+extern HIDDEN void __indirect_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue);
+extern HIDDEN void __indirect_glSecondaryColor3ivEXT(const GLint * v);
+extern HIDDEN void __indirect_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue);
+extern HIDDEN void __indirect_glSecondaryColor3svEXT(const GLshort * v);
+extern HIDDEN void __indirect_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue);
+extern HIDDEN void __indirect_glSecondaryColor3ubvEXT(const GLubyte * v);
+extern HIDDEN void __indirect_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue);
+extern HIDDEN void __indirect_glSecondaryColor3uivEXT(const GLuint * v);
+extern HIDDEN void __indirect_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue);
+extern HIDDEN void __indirect_glSecondaryColor3usvEXT(const GLushort * v);
+extern HIDDEN void __indirect_glSecondaryColorPointerEXT(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer);
+extern HIDDEN GLboolean __indirect_glAreProgramsResidentNV(GLsizei n, const GLuint * ids, GLboolean * residences);
+extern HIDDEN void __indirect_glBindProgramNV(GLenum target, GLuint program);
+extern HIDDEN void __indirect_glDeleteProgramsNV(GLsizei n, const GLuint * programs);
+extern HIDDEN void __indirect_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat * params);
+extern HIDDEN void __indirect_glGenProgramsNV(GLsizei n, GLuint * programs);
+extern HIDDEN void __indirect_glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble * params);
+extern HIDDEN void __indirect_glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetProgramivNV(GLuint id, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte * program);
+extern HIDDEN void __indirect_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble * params);
+extern HIDDEN void __indirect_glGetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetVertexAttribivARB(GLuint index, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetVertexAttribPointervNV(GLuint index, GLenum pname, GLvoid ** params);
+extern HIDDEN GLboolean __indirect_glIsProgramNV(GLuint program);
+extern HIDDEN void __indirect_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte * program);
+extern HIDDEN void __indirect_glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glProgramParameter4dvNV(GLenum target, GLuint index, const GLdouble * params);
+extern HIDDEN void __indirect_glProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat * params);
+extern HIDDEN void __indirect_glProgramParameters4dvNV(GLenum target, GLuint index, GLuint num, const GLdouble * params);
+extern HIDDEN void __indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLuint num, const GLfloat * params);
+extern HIDDEN void __indirect_glRequestResidentProgramsNV(GLsizei n, const GLuint * ids);
+extern HIDDEN void __indirect_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform);
+extern HIDDEN void __indirect_glVertexAttribPointerNV(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer);
+extern HIDDEN void __indirect_glVertexAttrib1dARB(GLuint index, GLdouble x);
+extern HIDDEN void __indirect_glVertexAttrib1dvARB(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib1fARB(GLuint index, GLfloat x);
+extern HIDDEN void __indirect_glVertexAttrib1fvARB(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib1sARB(GLuint index, GLshort x);
+extern HIDDEN void __indirect_glVertexAttrib1svARB(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y);
+extern HIDDEN void __indirect_glVertexAttrib2dvARB(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y);
+extern HIDDEN void __indirect_glVertexAttrib2fvARB(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y);
+extern HIDDEN void __indirect_glVertexAttrib2svARB(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z);
+extern HIDDEN void __indirect_glVertexAttrib3dvARB(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+extern HIDDEN void __indirect_glVertexAttrib3fvARB(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z);
+extern HIDDEN void __indirect_glVertexAttrib3svARB(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glVertexAttrib4dvARB(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glVertexAttrib4fvARB(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+extern HIDDEN void __indirect_glVertexAttrib4svARB(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+extern HIDDEN void __indirect_glVertexAttrib4NubvARB(GLuint index, const GLubyte * v);
+extern HIDDEN void __indirect_glVertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttribs1svNV(GLuint index, GLsizei n, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttribs2svNV(GLuint index, GLsizei n, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttribs3svNV(GLuint index, GLsizei n, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttribs4svNV(GLuint index, GLsizei n, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte * v);
+extern HIDDEN void __indirect_glPointParameteriNV(GLenum pname, GLint param);
+extern HIDDEN void __indirect_glPointParameterivNV(GLenum pname, const GLint * params);
+extern HIDDEN void __indirect_glMultiDrawArraysEXT(GLenum mode, GLint * first, GLsizei * count, GLsizei primcount);
+extern HIDDEN void __indirect_glMultiDrawElementsEXT(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount);
+extern HIDDEN void __indirect_glActiveStencilFaceEXT(GLenum face);
+extern HIDDEN void __indirect_glVertexAttrib4bvARB(GLuint index, const GLbyte * v);
+extern HIDDEN void __indirect_glVertexAttrib4ivARB(GLuint index, const GLint * v);
+extern HIDDEN void __indirect_glVertexAttrib4ubvARB(GLuint index, const GLubyte * v);
+extern HIDDEN void __indirect_glVertexAttrib4usvARB(GLuint index, const GLushort * v);
+extern HIDDEN void __indirect_glVertexAttrib4uivARB(GLuint index, const GLuint * v);
+extern HIDDEN void __indirect_glVertexAttrib4NbvARB(GLuint index, const GLbyte * v);
+extern HIDDEN void __indirect_glVertexAttrib4NsvARB(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib4NivARB(GLuint index, const GLint * v);
+extern HIDDEN void __indirect_glVertexAttrib4NusvARB(GLuint index, const GLushort * v);
+extern HIDDEN void __indirect_glVertexAttrib4NuivARB(GLuint index, const GLuint * v);
+extern HIDDEN void __indirect_glVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer);
+extern HIDDEN void __indirect_glEnableVertexAttribArrayARB(GLuint index);
+extern HIDDEN void __indirect_glDisableVertexAttribArrayARB(GLuint index);
+extern HIDDEN void __indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len, const GLvoid * string);
+extern HIDDEN void __indirect_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble * params);
+extern HIDDEN void __indirect_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat * params);
+extern HIDDEN void __indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble * params);
+extern HIDDEN void __indirect_glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat * params);
+extern HIDDEN void __indirect_glGetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble * params);
+extern HIDDEN void __indirect_glGetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat * params);
+extern HIDDEN void __indirect_glGetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble * params);
+extern HIDDEN void __indirect_glGetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat * params);
+extern HIDDEN void __indirect_glGetProgramivARB(GLenum target, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * string);
+extern HIDDEN void __indirect_glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v);
+extern HIDDEN void __indirect_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v);
+extern HIDDEN void __indirect_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params);
+extern HIDDEN void __indirect_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params);
+extern HIDDEN void __indirect_glGenQueriesARB(GLsizei n, GLuint * ids);
+extern HIDDEN void __indirect_glDeleteQueriesARB(GLsizei n, const GLuint * ids);
+extern HIDDEN GLboolean __indirect_glIsQueryARB(GLuint id);
+extern HIDDEN void __indirect_glBeginQueryARB(GLenum target, GLuint id);
+extern HIDDEN void __indirect_glEndQueryARB(GLenum target);
+extern HIDDEN void __indirect_glGetQueryivARB(GLenum target, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetQueryObjectivARB(GLuint id, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint * params);
+extern HIDDEN void __indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble * params);
+extern HIDDEN void __indirect_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params);
+extern HIDDEN void __indirect_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glVertexAttrib1dNV(GLuint index, GLdouble x);
+extern HIDDEN void __indirect_glVertexAttrib1dvNV(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib1fNV(GLuint index, GLfloat x);
+extern HIDDEN void __indirect_glVertexAttrib1fvNV(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib1sNV(GLuint index, GLshort x);
+extern HIDDEN void __indirect_glVertexAttrib1svNV(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y);
+extern HIDDEN void __indirect_glVertexAttrib2dvNV(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y);
+extern HIDDEN void __indirect_glVertexAttrib2fvNV(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y);
+extern HIDDEN void __indirect_glVertexAttrib2svNV(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z);
+extern HIDDEN void __indirect_glVertexAttrib3dvNV(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+extern HIDDEN void __indirect_glVertexAttrib3fvNV(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z);
+extern HIDDEN void __indirect_glVertexAttrib3svNV(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern HIDDEN void __indirect_glVertexAttrib4dvNV(GLuint index, const GLdouble * v);
+extern HIDDEN void __indirect_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern HIDDEN void __indirect_glVertexAttrib4fvNV(GLuint index, const GLfloat * v);
+extern HIDDEN void __indirect_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+extern HIDDEN void __indirect_glVertexAttrib4svNV(GLuint index, const GLshort * v);
+extern HIDDEN void __indirect_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+extern HIDDEN void __indirect_glVertexAttrib4ubvNV(GLuint index, const GLubyte * v);
+extern HIDDEN GLboolean __indirect_glIsRenderbufferEXT(GLuint renderbuffer);
+extern HIDDEN void __indirect_glBindRenderbufferEXT(GLenum target, GLuint renderbuffer);
+extern HIDDEN void __indirect_glDeleteRenderbuffersEXT(GLsizei n, const GLuint * renderbuffers);
+extern HIDDEN void __indirect_glGenRenderbuffersEXT(GLsizei n, GLuint * renderbuffers);
+extern HIDDEN void __indirect_glRenderbufferStorageEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+extern HIDDEN void __indirect_glGetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint * params);
+extern HIDDEN GLboolean __indirect_glIsFramebufferEXT(GLuint framebuffer);
+extern HIDDEN void __indirect_glBindFramebufferEXT(GLenum target, GLuint framebuffer);
+extern HIDDEN void __indirect_glDeleteFramebuffersEXT(GLsizei n, const GLuint * framebuffers);
+extern HIDDEN void __indirect_glGenFramebuffersEXT(GLsizei n, GLuint * framebuffers);
+extern HIDDEN GLenum __indirect_glCheckFramebufferStatusEXT(GLenum target);
+extern HIDDEN void __indirect_glFramebufferTexture1DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+extern HIDDEN void __indirect_glFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+extern HIDDEN void __indirect_glFramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
+extern HIDDEN void __indirect_glFramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+extern HIDDEN void __indirect_glGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, GLint * params);
+extern HIDDEN void __indirect_glGenerateMipmapEXT(GLenum target);
+
+#  undef HIDDEN
+#  undef FASTCALL
+#  undef NOINLINE
+
+#endif /* !defined( _INDIRECT_H_ ) */
diff --git a/src/glx/x11/indirect_init.c b/src/glx/x11/indirect_init.c
new file mode 100644
index 00000000000..6627edfebd8
--- /dev/null
+++ b/src/glx/x11/indirect_init.c
@@ -0,0 +1,779 @@
+/* DO NOT EDIT - This file generated automatically by glX_proto_send.py (from Mesa) script */
+
+/*
+ * Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+ * (C) Copyright IBM Corporation 2004
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * PRECISION INSIGHT, 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.
+ */
+
+/**
+ * \file indirect_init.c
+ * Initialize indirect rendering dispatch table.
+ *
+ * \author Kevin E. Martin <[email protected]>
+ * \author Brian Paul <[email protected]>
+ * \author Ian Romanick <[email protected]>
+ */
+
+#include "indirect_init.h"
+#include "indirect.h"
+#include "glapi.h"
+
+
+/**
+ * No-op function used to initialize functions that have no GLX protocol
+ * support.
+ */
+static int NoOp(void)
+{
+    return 0;
+}
+
+/**
+ * Create and initialize a new GL dispatch table.  The table is initialized
+ * with GLX indirect rendering protocol functions.
+ */
+__GLapi * __glXNewIndirectAPI( void )
+{
+    __GLapi *glAPI;
+    GLuint entries;
+
+    entries = _glapi_get_dispatch_table_size();
+    glAPI = (__GLapi *) Xmalloc(entries * sizeof(void *));
+
+    /* first, set all entries to point to no-op functions */
+    {
+       int i;
+       void **dispatch = (void **) glAPI;
+       for (i = 0; i < entries; i++) {
+          dispatch[i] = (void *) NoOp;
+       }
+    }
+
+    /* now, initialize the entries we understand */
+
+    /* 1.0 */
+
+    glAPI->NewList = __indirect_glNewList;
+    glAPI->EndList = __indirect_glEndList;
+    glAPI->CallList = __indirect_glCallList;
+    glAPI->CallLists = __indirect_glCallLists;
+    glAPI->DeleteLists = __indirect_glDeleteLists;
+    glAPI->GenLists = __indirect_glGenLists;
+    glAPI->ListBase = __indirect_glListBase;
+    glAPI->Begin = __indirect_glBegin;
+    glAPI->Bitmap = __indirect_glBitmap;
+    glAPI->Color3b = __indirect_glColor3b;
+    glAPI->Color3bv = __indirect_glColor3bv;
+    glAPI->Color3d = __indirect_glColor3d;
+    glAPI->Color3dv = __indirect_glColor3dv;
+    glAPI->Color3f = __indirect_glColor3f;
+    glAPI->Color3fv = __indirect_glColor3fv;
+    glAPI->Color3i = __indirect_glColor3i;
+    glAPI->Color3iv = __indirect_glColor3iv;
+    glAPI->Color3s = __indirect_glColor3s;
+    glAPI->Color3sv = __indirect_glColor3sv;
+    glAPI->Color3ub = __indirect_glColor3ub;
+    glAPI->Color3ubv = __indirect_glColor3ubv;
+    glAPI->Color3ui = __indirect_glColor3ui;
+    glAPI->Color3uiv = __indirect_glColor3uiv;
+    glAPI->Color3us = __indirect_glColor3us;
+    glAPI->Color3usv = __indirect_glColor3usv;
+    glAPI->Color4b = __indirect_glColor4b;
+    glAPI->Color4bv = __indirect_glColor4bv;
+    glAPI->Color4d = __indirect_glColor4d;
+    glAPI->Color4dv = __indirect_glColor4dv;
+    glAPI->Color4f = __indirect_glColor4f;
+    glAPI->Color4fv = __indirect_glColor4fv;
+    glAPI->Color4i = __indirect_glColor4i;
+    glAPI->Color4iv = __indirect_glColor4iv;
+    glAPI->Color4s = __indirect_glColor4s;
+    glAPI->Color4sv = __indirect_glColor4sv;
+    glAPI->Color4ub = __indirect_glColor4ub;
+    glAPI->Color4ubv = __indirect_glColor4ubv;
+    glAPI->Color4ui = __indirect_glColor4ui;
+    glAPI->Color4uiv = __indirect_glColor4uiv;
+    glAPI->Color4us = __indirect_glColor4us;
+    glAPI->Color4usv = __indirect_glColor4usv;
+    glAPI->EdgeFlag = __indirect_glEdgeFlag;
+    glAPI->EdgeFlagv = __indirect_glEdgeFlagv;
+    glAPI->End = __indirect_glEnd;
+    glAPI->Indexd = __indirect_glIndexd;
+    glAPI->Indexdv = __indirect_glIndexdv;
+    glAPI->Indexf = __indirect_glIndexf;
+    glAPI->Indexfv = __indirect_glIndexfv;
+    glAPI->Indexi = __indirect_glIndexi;
+    glAPI->Indexiv = __indirect_glIndexiv;
+    glAPI->Indexs = __indirect_glIndexs;
+    glAPI->Indexsv = __indirect_glIndexsv;
+    glAPI->Normal3b = __indirect_glNormal3b;
+    glAPI->Normal3bv = __indirect_glNormal3bv;
+    glAPI->Normal3d = __indirect_glNormal3d;
+    glAPI->Normal3dv = __indirect_glNormal3dv;
+    glAPI->Normal3f = __indirect_glNormal3f;
+    glAPI->Normal3fv = __indirect_glNormal3fv;
+    glAPI->Normal3i = __indirect_glNormal3i;
+    glAPI->Normal3iv = __indirect_glNormal3iv;
+    glAPI->Normal3s = __indirect_glNormal3s;
+    glAPI->Normal3sv = __indirect_glNormal3sv;
+    glAPI->RasterPos2d = __indirect_glRasterPos2d;
+    glAPI->RasterPos2dv = __indirect_glRasterPos2dv;
+    glAPI->RasterPos2f = __indirect_glRasterPos2f;
+    glAPI->RasterPos2fv = __indirect_glRasterPos2fv;
+    glAPI->RasterPos2i = __indirect_glRasterPos2i;
+    glAPI->RasterPos2iv = __indirect_glRasterPos2iv;
+    glAPI->RasterPos2s = __indirect_glRasterPos2s;
+    glAPI->RasterPos2sv = __indirect_glRasterPos2sv;
+    glAPI->RasterPos3d = __indirect_glRasterPos3d;
+    glAPI->RasterPos3dv = __indirect_glRasterPos3dv;
+    glAPI->RasterPos3f = __indirect_glRasterPos3f;
+    glAPI->RasterPos3fv = __indirect_glRasterPos3fv;
+    glAPI->RasterPos3i = __indirect_glRasterPos3i;
+    glAPI->RasterPos3iv = __indirect_glRasterPos3iv;
+    glAPI->RasterPos3s = __indirect_glRasterPos3s;
+    glAPI->RasterPos3sv = __indirect_glRasterPos3sv;
+    glAPI->RasterPos4d = __indirect_glRasterPos4d;
+    glAPI->RasterPos4dv = __indirect_glRasterPos4dv;
+    glAPI->RasterPos4f = __indirect_glRasterPos4f;
+    glAPI->RasterPos4fv = __indirect_glRasterPos4fv;
+    glAPI->RasterPos4i = __indirect_glRasterPos4i;
+    glAPI->RasterPos4iv = __indirect_glRasterPos4iv;
+    glAPI->RasterPos4s = __indirect_glRasterPos4s;
+    glAPI->RasterPos4sv = __indirect_glRasterPos4sv;
+    glAPI->Rectd = __indirect_glRectd;
+    glAPI->Rectdv = __indirect_glRectdv;
+    glAPI->Rectf = __indirect_glRectf;
+    glAPI->Rectfv = __indirect_glRectfv;
+    glAPI->Recti = __indirect_glRecti;
+    glAPI->Rectiv = __indirect_glRectiv;
+    glAPI->Rects = __indirect_glRects;
+    glAPI->Rectsv = __indirect_glRectsv;
+    glAPI->TexCoord1d = __indirect_glTexCoord1d;
+    glAPI->TexCoord1dv = __indirect_glTexCoord1dv;
+    glAPI->TexCoord1f = __indirect_glTexCoord1f;
+    glAPI->TexCoord1fv = __indirect_glTexCoord1fv;
+    glAPI->TexCoord1i = __indirect_glTexCoord1i;
+    glAPI->TexCoord1iv = __indirect_glTexCoord1iv;
+    glAPI->TexCoord1s = __indirect_glTexCoord1s;
+    glAPI->TexCoord1sv = __indirect_glTexCoord1sv;
+    glAPI->TexCoord2d = __indirect_glTexCoord2d;
+    glAPI->TexCoord2dv = __indirect_glTexCoord2dv;
+    glAPI->TexCoord2f = __indirect_glTexCoord2f;
+    glAPI->TexCoord2fv = __indirect_glTexCoord2fv;
+    glAPI->TexCoord2i = __indirect_glTexCoord2i;
+    glAPI->TexCoord2iv = __indirect_glTexCoord2iv;
+    glAPI->TexCoord2s = __indirect_glTexCoord2s;
+    glAPI->TexCoord2sv = __indirect_glTexCoord2sv;
+    glAPI->TexCoord3d = __indirect_glTexCoord3d;
+    glAPI->TexCoord3dv = __indirect_glTexCoord3dv;
+    glAPI->TexCoord3f = __indirect_glTexCoord3f;
+    glAPI->TexCoord3fv = __indirect_glTexCoord3fv;
+    glAPI->TexCoord3i = __indirect_glTexCoord3i;
+    glAPI->TexCoord3iv = __indirect_glTexCoord3iv;
+    glAPI->TexCoord3s = __indirect_glTexCoord3s;
+    glAPI->TexCoord3sv = __indirect_glTexCoord3sv;
+    glAPI->TexCoord4d = __indirect_glTexCoord4d;
+    glAPI->TexCoord4dv = __indirect_glTexCoord4dv;
+    glAPI->TexCoord4f = __indirect_glTexCoord4f;
+    glAPI->TexCoord4fv = __indirect_glTexCoord4fv;
+    glAPI->TexCoord4i = __indirect_glTexCoord4i;
+    glAPI->TexCoord4iv = __indirect_glTexCoord4iv;
+    glAPI->TexCoord4s = __indirect_glTexCoord4s;
+    glAPI->TexCoord4sv = __indirect_glTexCoord4sv;
+    glAPI->Vertex2d = __indirect_glVertex2d;
+    glAPI->Vertex2dv = __indirect_glVertex2dv;
+    glAPI->Vertex2f = __indirect_glVertex2f;
+    glAPI->Vertex2fv = __indirect_glVertex2fv;
+    glAPI->Vertex2i = __indirect_glVertex2i;
+    glAPI->Vertex2iv = __indirect_glVertex2iv;
+    glAPI->Vertex2s = __indirect_glVertex2s;
+    glAPI->Vertex2sv = __indirect_glVertex2sv;
+    glAPI->Vertex3d = __indirect_glVertex3d;
+    glAPI->Vertex3dv = __indirect_glVertex3dv;
+    glAPI->Vertex3f = __indirect_glVertex3f;
+    glAPI->Vertex3fv = __indirect_glVertex3fv;
+    glAPI->Vertex3i = __indirect_glVertex3i;
+    glAPI->Vertex3iv = __indirect_glVertex3iv;
+    glAPI->Vertex3s = __indirect_glVertex3s;
+    glAPI->Vertex3sv = __indirect_glVertex3sv;
+    glAPI->Vertex4d = __indirect_glVertex4d;
+    glAPI->Vertex4dv = __indirect_glVertex4dv;
+    glAPI->Vertex4f = __indirect_glVertex4f;
+    glAPI->Vertex4fv = __indirect_glVertex4fv;
+    glAPI->Vertex4i = __indirect_glVertex4i;
+    glAPI->Vertex4iv = __indirect_glVertex4iv;
+    glAPI->Vertex4s = __indirect_glVertex4s;
+    glAPI->Vertex4sv = __indirect_glVertex4sv;
+    glAPI->ClipPlane = __indirect_glClipPlane;
+    glAPI->ColorMaterial = __indirect_glColorMaterial;
+    glAPI->CullFace = __indirect_glCullFace;
+    glAPI->Fogf = __indirect_glFogf;
+    glAPI->Fogfv = __indirect_glFogfv;
+    glAPI->Fogi = __indirect_glFogi;
+    glAPI->Fogiv = __indirect_glFogiv;
+    glAPI->FrontFace = __indirect_glFrontFace;
+    glAPI->Hint = __indirect_glHint;
+    glAPI->Lightf = __indirect_glLightf;
+    glAPI->Lightfv = __indirect_glLightfv;
+    glAPI->Lighti = __indirect_glLighti;
+    glAPI->Lightiv = __indirect_glLightiv;
+    glAPI->LightModelf = __indirect_glLightModelf;
+    glAPI->LightModelfv = __indirect_glLightModelfv;
+    glAPI->LightModeli = __indirect_glLightModeli;
+    glAPI->LightModeliv = __indirect_glLightModeliv;
+    glAPI->LineStipple = __indirect_glLineStipple;
+    glAPI->LineWidth = __indirect_glLineWidth;
+    glAPI->Materialf = __indirect_glMaterialf;
+    glAPI->Materialfv = __indirect_glMaterialfv;
+    glAPI->Materiali = __indirect_glMateriali;
+    glAPI->Materialiv = __indirect_glMaterialiv;
+    glAPI->PointSize = __indirect_glPointSize;
+    glAPI->PolygonMode = __indirect_glPolygonMode;
+    glAPI->PolygonStipple = __indirect_glPolygonStipple;
+    glAPI->Scissor = __indirect_glScissor;
+    glAPI->ShadeModel = __indirect_glShadeModel;
+    glAPI->TexParameterf = __indirect_glTexParameterf;
+    glAPI->TexParameterfv = __indirect_glTexParameterfv;
+    glAPI->TexParameteri = __indirect_glTexParameteri;
+    glAPI->TexParameteriv = __indirect_glTexParameteriv;
+    glAPI->TexImage1D = __indirect_glTexImage1D;
+    glAPI->TexImage2D = __indirect_glTexImage2D;
+    glAPI->TexEnvf = __indirect_glTexEnvf;
+    glAPI->TexEnvfv = __indirect_glTexEnvfv;
+    glAPI->TexEnvi = __indirect_glTexEnvi;
+    glAPI->TexEnviv = __indirect_glTexEnviv;
+    glAPI->TexGend = __indirect_glTexGend;
+    glAPI->TexGendv = __indirect_glTexGendv;
+    glAPI->TexGenf = __indirect_glTexGenf;
+    glAPI->TexGenfv = __indirect_glTexGenfv;
+    glAPI->TexGeni = __indirect_glTexGeni;
+    glAPI->TexGeniv = __indirect_glTexGeniv;
+    glAPI->FeedbackBuffer = __indirect_glFeedbackBuffer;
+    glAPI->SelectBuffer = __indirect_glSelectBuffer;
+    glAPI->RenderMode = __indirect_glRenderMode;
+    glAPI->InitNames = __indirect_glInitNames;
+    glAPI->LoadName = __indirect_glLoadName;
+    glAPI->PassThrough = __indirect_glPassThrough;
+    glAPI->PopName = __indirect_glPopName;
+    glAPI->PushName = __indirect_glPushName;
+    glAPI->DrawBuffer = __indirect_glDrawBuffer;
+    glAPI->Clear = __indirect_glClear;
+    glAPI->ClearAccum = __indirect_glClearAccum;
+    glAPI->ClearIndex = __indirect_glClearIndex;
+    glAPI->ClearColor = __indirect_glClearColor;
+    glAPI->ClearStencil = __indirect_glClearStencil;
+    glAPI->ClearDepth = __indirect_glClearDepth;
+    glAPI->StencilMask = __indirect_glStencilMask;
+    glAPI->ColorMask = __indirect_glColorMask;
+    glAPI->DepthMask = __indirect_glDepthMask;
+    glAPI->IndexMask = __indirect_glIndexMask;
+    glAPI->Accum = __indirect_glAccum;
+    glAPI->Disable = __indirect_glDisable;
+    glAPI->Enable = __indirect_glEnable;
+    glAPI->Finish = __indirect_glFinish;
+    glAPI->Flush = __indirect_glFlush;
+    glAPI->PopAttrib = __indirect_glPopAttrib;
+    glAPI->PushAttrib = __indirect_glPushAttrib;
+    glAPI->Map1d = __indirect_glMap1d;
+    glAPI->Map1f = __indirect_glMap1f;
+    glAPI->Map2d = __indirect_glMap2d;
+    glAPI->Map2f = __indirect_glMap2f;
+    glAPI->MapGrid1d = __indirect_glMapGrid1d;
+    glAPI->MapGrid1f = __indirect_glMapGrid1f;
+    glAPI->MapGrid2d = __indirect_glMapGrid2d;
+    glAPI->MapGrid2f = __indirect_glMapGrid2f;
+    glAPI->EvalCoord1d = __indirect_glEvalCoord1d;
+    glAPI->EvalCoord1dv = __indirect_glEvalCoord1dv;
+    glAPI->EvalCoord1f = __indirect_glEvalCoord1f;
+    glAPI->EvalCoord1fv = __indirect_glEvalCoord1fv;
+    glAPI->EvalCoord2d = __indirect_glEvalCoord2d;
+    glAPI->EvalCoord2dv = __indirect_glEvalCoord2dv;
+    glAPI->EvalCoord2f = __indirect_glEvalCoord2f;
+    glAPI->EvalCoord2fv = __indirect_glEvalCoord2fv;
+    glAPI->EvalMesh1 = __indirect_glEvalMesh1;
+    glAPI->EvalPoint1 = __indirect_glEvalPoint1;
+    glAPI->EvalMesh2 = __indirect_glEvalMesh2;
+    glAPI->EvalPoint2 = __indirect_glEvalPoint2;
+    glAPI->AlphaFunc = __indirect_glAlphaFunc;
+    glAPI->BlendFunc = __indirect_glBlendFunc;
+    glAPI->LogicOp = __indirect_glLogicOp;
+    glAPI->StencilFunc = __indirect_glStencilFunc;
+    glAPI->StencilOp = __indirect_glStencilOp;
+    glAPI->DepthFunc = __indirect_glDepthFunc;
+    glAPI->PixelZoom = __indirect_glPixelZoom;
+    glAPI->PixelTransferf = __indirect_glPixelTransferf;
+    glAPI->PixelTransferi = __indirect_glPixelTransferi;
+    glAPI->PixelStoref = __indirect_glPixelStoref;
+    glAPI->PixelStorei = __indirect_glPixelStorei;
+    glAPI->PixelMapfv = __indirect_glPixelMapfv;
+    glAPI->PixelMapuiv = __indirect_glPixelMapuiv;
+    glAPI->PixelMapusv = __indirect_glPixelMapusv;
+    glAPI->ReadBuffer = __indirect_glReadBuffer;
+    glAPI->CopyPixels = __indirect_glCopyPixels;
+    glAPI->ReadPixels = __indirect_glReadPixels;
+    glAPI->DrawPixels = __indirect_glDrawPixels;
+    glAPI->GetBooleanv = __indirect_glGetBooleanv;
+    glAPI->GetClipPlane = __indirect_glGetClipPlane;
+    glAPI->GetDoublev = __indirect_glGetDoublev;
+    glAPI->GetError = __indirect_glGetError;
+    glAPI->GetFloatv = __indirect_glGetFloatv;
+    glAPI->GetIntegerv = __indirect_glGetIntegerv;
+    glAPI->GetLightfv = __indirect_glGetLightfv;
+    glAPI->GetLightiv = __indirect_glGetLightiv;
+    glAPI->GetMapdv = __indirect_glGetMapdv;
+    glAPI->GetMapfv = __indirect_glGetMapfv;
+    glAPI->GetMapiv = __indirect_glGetMapiv;
+    glAPI->GetMaterialfv = __indirect_glGetMaterialfv;
+    glAPI->GetMaterialiv = __indirect_glGetMaterialiv;
+    glAPI->GetPixelMapfv = __indirect_glGetPixelMapfv;
+    glAPI->GetPixelMapuiv = __indirect_glGetPixelMapuiv;
+    glAPI->GetPixelMapusv = __indirect_glGetPixelMapusv;
+    glAPI->GetPolygonStipple = __indirect_glGetPolygonStipple;
+    glAPI->GetString = __indirect_glGetString;
+    glAPI->GetTexEnvfv = __indirect_glGetTexEnvfv;
+    glAPI->GetTexEnviv = __indirect_glGetTexEnviv;
+    glAPI->GetTexGendv = __indirect_glGetTexGendv;
+    glAPI->GetTexGenfv = __indirect_glGetTexGenfv;
+    glAPI->GetTexGeniv = __indirect_glGetTexGeniv;
+    glAPI->GetTexImage = __indirect_glGetTexImage;
+    glAPI->GetTexParameterfv = __indirect_glGetTexParameterfv;
+    glAPI->GetTexParameteriv = __indirect_glGetTexParameteriv;
+    glAPI->GetTexLevelParameterfv = __indirect_glGetTexLevelParameterfv;
+    glAPI->GetTexLevelParameteriv = __indirect_glGetTexLevelParameteriv;
+    glAPI->IsEnabled = __indirect_glIsEnabled;
+    glAPI->IsList = __indirect_glIsList;
+    glAPI->DepthRange = __indirect_glDepthRange;
+    glAPI->Frustum = __indirect_glFrustum;
+    glAPI->LoadIdentity = __indirect_glLoadIdentity;
+    glAPI->LoadMatrixf = __indirect_glLoadMatrixf;
+    glAPI->LoadMatrixd = __indirect_glLoadMatrixd;
+    glAPI->MatrixMode = __indirect_glMatrixMode;
+    glAPI->MultMatrixf = __indirect_glMultMatrixf;
+    glAPI->MultMatrixd = __indirect_glMultMatrixd;
+    glAPI->Ortho = __indirect_glOrtho;
+    glAPI->PopMatrix = __indirect_glPopMatrix;
+    glAPI->PushMatrix = __indirect_glPushMatrix;
+    glAPI->Rotated = __indirect_glRotated;
+    glAPI->Rotatef = __indirect_glRotatef;
+    glAPI->Scaled = __indirect_glScaled;
+    glAPI->Scalef = __indirect_glScalef;
+    glAPI->Translated = __indirect_glTranslated;
+    glAPI->Translatef = __indirect_glTranslatef;
+    glAPI->Viewport = __indirect_glViewport;
+
+    /* 1.1 */
+
+    glAPI->ArrayElement = __indirect_glArrayElement;
+    glAPI->BindTexture = __indirect_glBindTexture;
+    glAPI->ColorPointer = __indirect_glColorPointer;
+    glAPI->DisableClientState = __indirect_glDisableClientState;
+    glAPI->DrawArrays = __indirect_glDrawArrays;
+    glAPI->DrawElements = __indirect_glDrawElements;
+    glAPI->EdgeFlagPointer = __indirect_glEdgeFlagPointer;
+    glAPI->EnableClientState = __indirect_glEnableClientState;
+    glAPI->IndexPointer = __indirect_glIndexPointer;
+    glAPI->Indexub = __indirect_glIndexub;
+    glAPI->Indexubv = __indirect_glIndexubv;
+    glAPI->InterleavedArrays = __indirect_glInterleavedArrays;
+    glAPI->NormalPointer = __indirect_glNormalPointer;
+    glAPI->PolygonOffset = __indirect_glPolygonOffset;
+    glAPI->TexCoordPointer = __indirect_glTexCoordPointer;
+    glAPI->VertexPointer = __indirect_glVertexPointer;
+    glAPI->AreTexturesResident = __indirect_glAreTexturesResident;
+    glAPI->CopyTexImage1D = __indirect_glCopyTexImage1D;
+    glAPI->CopyTexImage2D = __indirect_glCopyTexImage2D;
+    glAPI->CopyTexSubImage1D = __indirect_glCopyTexSubImage1D;
+    glAPI->CopyTexSubImage2D = __indirect_glCopyTexSubImage2D;
+    glAPI->DeleteTextures = __indirect_glDeleteTextures;
+    glAPI->GenTextures = __indirect_glGenTextures;
+    glAPI->GetPointerv = __indirect_glGetPointerv;
+    glAPI->IsTexture = __indirect_glIsTexture;
+    glAPI->PrioritizeTextures = __indirect_glPrioritizeTextures;
+    glAPI->TexSubImage1D = __indirect_glTexSubImage1D;
+    glAPI->TexSubImage2D = __indirect_glTexSubImage2D;
+    glAPI->PopClientAttrib = __indirect_glPopClientAttrib;
+    glAPI->PushClientAttrib = __indirect_glPushClientAttrib;
+
+    /* 1.2 */
+
+    glAPI->BlendColor = __indirect_glBlendColor;
+    glAPI->BlendEquation = __indirect_glBlendEquation;
+    glAPI->DrawRangeElements = __indirect_glDrawRangeElements;
+    glAPI->ColorTable = __indirect_glColorTable;
+    glAPI->ColorTableParameterfv = __indirect_glColorTableParameterfv;
+    glAPI->ColorTableParameteriv = __indirect_glColorTableParameteriv;
+    glAPI->CopyColorTable = __indirect_glCopyColorTable;
+    glAPI->GetColorTable = __indirect_glGetColorTable;
+    glAPI->GetColorTableParameterfv = __indirect_glGetColorTableParameterfv;
+    glAPI->GetColorTableParameteriv = __indirect_glGetColorTableParameteriv;
+    glAPI->ColorSubTable = __indirect_glColorSubTable;
+    glAPI->CopyColorSubTable = __indirect_glCopyColorSubTable;
+    glAPI->ConvolutionFilter1D = __indirect_glConvolutionFilter1D;
+    glAPI->ConvolutionFilter2D = __indirect_glConvolutionFilter2D;
+    glAPI->ConvolutionParameterf = __indirect_glConvolutionParameterf;
+    glAPI->ConvolutionParameterfv = __indirect_glConvolutionParameterfv;
+    glAPI->ConvolutionParameteri = __indirect_glConvolutionParameteri;
+    glAPI->ConvolutionParameteriv = __indirect_glConvolutionParameteriv;
+    glAPI->CopyConvolutionFilter1D = __indirect_glCopyConvolutionFilter1D;
+    glAPI->CopyConvolutionFilter2D = __indirect_glCopyConvolutionFilter2D;
+    glAPI->GetConvolutionFilter = __indirect_glGetConvolutionFilter;
+    glAPI->GetConvolutionParameterfv = __indirect_glGetConvolutionParameterfv;
+    glAPI->GetConvolutionParameteriv = __indirect_glGetConvolutionParameteriv;
+    glAPI->GetSeparableFilter = __indirect_glGetSeparableFilter;
+    glAPI->SeparableFilter2D = __indirect_glSeparableFilter2D;
+    glAPI->GetHistogram = __indirect_glGetHistogram;
+    glAPI->GetHistogramParameterfv = __indirect_glGetHistogramParameterfv;
+    glAPI->GetHistogramParameteriv = __indirect_glGetHistogramParameteriv;
+    glAPI->GetMinmax = __indirect_glGetMinmax;
+    glAPI->GetMinmaxParameterfv = __indirect_glGetMinmaxParameterfv;
+    glAPI->GetMinmaxParameteriv = __indirect_glGetMinmaxParameteriv;
+    glAPI->Histogram = __indirect_glHistogram;
+    glAPI->Minmax = __indirect_glMinmax;
+    glAPI->ResetHistogram = __indirect_glResetHistogram;
+    glAPI->ResetMinmax = __indirect_glResetMinmax;
+    glAPI->TexImage3D = __indirect_glTexImage3D;
+    glAPI->TexSubImage3D = __indirect_glTexSubImage3D;
+    glAPI->CopyTexSubImage3D = __indirect_glCopyTexSubImage3D;
+
+    /*   1. GL_ARB_multitexture */
+
+    glAPI->MultiTexCoord2dARB = __indirect_glMultiTexCoord2dARB;
+    glAPI->MultiTexCoord2dvARB = __indirect_glMultiTexCoord2dvARB;
+    glAPI->MultiTexCoord2fARB = __indirect_glMultiTexCoord2fARB;
+    glAPI->MultiTexCoord2fvARB = __indirect_glMultiTexCoord2fvARB;
+    glAPI->MultiTexCoord2iARB = __indirect_glMultiTexCoord2iARB;
+    glAPI->MultiTexCoord2ivARB = __indirect_glMultiTexCoord2ivARB;
+    glAPI->MultiTexCoord2sARB = __indirect_glMultiTexCoord2sARB;
+    glAPI->MultiTexCoord2svARB = __indirect_glMultiTexCoord2svARB;
+    glAPI->MultiTexCoord3dARB = __indirect_glMultiTexCoord3dARB;
+    glAPI->MultiTexCoord3dvARB = __indirect_glMultiTexCoord3dvARB;
+    glAPI->MultiTexCoord3fARB = __indirect_glMultiTexCoord3fARB;
+    glAPI->MultiTexCoord3fvARB = __indirect_glMultiTexCoord3fvARB;
+    glAPI->MultiTexCoord3iARB = __indirect_glMultiTexCoord3iARB;
+    glAPI->MultiTexCoord3ivARB = __indirect_glMultiTexCoord3ivARB;
+    glAPI->MultiTexCoord3sARB = __indirect_glMultiTexCoord3sARB;
+    glAPI->MultiTexCoord3svARB = __indirect_glMultiTexCoord3svARB;
+    glAPI->MultiTexCoord4dARB = __indirect_glMultiTexCoord4dARB;
+    glAPI->MultiTexCoord4dvARB = __indirect_glMultiTexCoord4dvARB;
+    glAPI->MultiTexCoord4fARB = __indirect_glMultiTexCoord4fARB;
+    glAPI->MultiTexCoord4fvARB = __indirect_glMultiTexCoord4fvARB;
+    glAPI->MultiTexCoord4iARB = __indirect_glMultiTexCoord4iARB;
+    glAPI->MultiTexCoord4ivARB = __indirect_glMultiTexCoord4ivARB;
+    glAPI->MultiTexCoord4sARB = __indirect_glMultiTexCoord4sARB;
+    glAPI->MultiTexCoord4svARB = __indirect_glMultiTexCoord4svARB;
+    glAPI->ActiveTextureARB = __indirect_glActiveTextureARB;
+    glAPI->ClientActiveTextureARB = __indirect_glClientActiveTextureARB;
+    glAPI->MultiTexCoord1dARB = __indirect_glMultiTexCoord1dARB;
+    glAPI->MultiTexCoord1dvARB = __indirect_glMultiTexCoord1dvARB;
+    glAPI->MultiTexCoord1fARB = __indirect_glMultiTexCoord1fARB;
+    glAPI->MultiTexCoord1fvARB = __indirect_glMultiTexCoord1fvARB;
+    glAPI->MultiTexCoord1iARB = __indirect_glMultiTexCoord1iARB;
+    glAPI->MultiTexCoord1ivARB = __indirect_glMultiTexCoord1ivARB;
+    glAPI->MultiTexCoord1sARB = __indirect_glMultiTexCoord1sARB;
+    glAPI->MultiTexCoord1svARB = __indirect_glMultiTexCoord1svARB;
+
+    /*   3. GL_ARB_transpose_matrix */
+
+    glAPI->LoadTransposeMatrixfARB = __indirect_glLoadTransposeMatrixfARB;
+    glAPI->LoadTransposeMatrixdARB = __indirect_glLoadTransposeMatrixdARB;
+    glAPI->MultTransposeMatrixfARB = __indirect_glMultTransposeMatrixfARB;
+    glAPI->MultTransposeMatrixdARB = __indirect_glMultTransposeMatrixdARB;
+
+    /*   5. GL_ARB_multisample */
+
+    glAPI->SampleCoverageARB = __indirect_glSampleCoverageARB;
+
+    /*  12. GL_ARB_texture_compression */
+
+    glAPI->CompressedTexImage3DARB = __indirect_glCompressedTexImage3DARB;
+    glAPI->CompressedTexImage2DARB = __indirect_glCompressedTexImage2DARB;
+    glAPI->CompressedTexImage1DARB = __indirect_glCompressedTexImage1DARB;
+    glAPI->CompressedTexSubImage3DARB = __indirect_glCompressedTexSubImage3DARB;
+    glAPI->CompressedTexSubImage2DARB = __indirect_glCompressedTexSubImage2DARB;
+    glAPI->CompressedTexSubImage1DARB = __indirect_glCompressedTexSubImage1DARB;
+    glAPI->GetCompressedTexImageARB = __indirect_glGetCompressedTexImageARB;
+
+    /*  26. GL_ARB_vertex_program */
+
+    glAPI->VertexAttrib4bvARB = __indirect_glVertexAttrib4bvARB;
+    glAPI->VertexAttrib4ivARB = __indirect_glVertexAttrib4ivARB;
+    glAPI->VertexAttrib4ubvARB = __indirect_glVertexAttrib4ubvARB;
+    glAPI->VertexAttrib4usvARB = __indirect_glVertexAttrib4usvARB;
+    glAPI->VertexAttrib4uivARB = __indirect_glVertexAttrib4uivARB;
+    glAPI->VertexAttrib4NbvARB = __indirect_glVertexAttrib4NbvARB;
+    glAPI->VertexAttrib4NsvARB = __indirect_glVertexAttrib4NsvARB;
+    glAPI->VertexAttrib4NivARB = __indirect_glVertexAttrib4NivARB;
+    glAPI->VertexAttrib4NusvARB = __indirect_glVertexAttrib4NusvARB;
+    glAPI->VertexAttrib4NuivARB = __indirect_glVertexAttrib4NuivARB;
+    glAPI->VertexAttribPointerARB = __indirect_glVertexAttribPointerARB;
+    glAPI->EnableVertexAttribArrayARB = __indirect_glEnableVertexAttribArrayARB;
+    glAPI->DisableVertexAttribArrayARB = __indirect_glDisableVertexAttribArrayARB;
+    glAPI->ProgramStringARB = __indirect_glProgramStringARB;
+    glAPI->ProgramEnvParameter4dARB = __indirect_glProgramEnvParameter4dARB;
+    glAPI->ProgramEnvParameter4dvARB = __indirect_glProgramEnvParameter4dvARB;
+    glAPI->ProgramEnvParameter4fARB = __indirect_glProgramEnvParameter4fARB;
+    glAPI->ProgramEnvParameter4fvARB = __indirect_glProgramEnvParameter4fvARB;
+    glAPI->ProgramLocalParameter4dARB = __indirect_glProgramLocalParameter4dARB;
+    glAPI->ProgramLocalParameter4dvARB = __indirect_glProgramLocalParameter4dvARB;
+    glAPI->ProgramLocalParameter4fARB = __indirect_glProgramLocalParameter4fARB;
+    glAPI->ProgramLocalParameter4fvARB = __indirect_glProgramLocalParameter4fvARB;
+    glAPI->GetProgramEnvParameterdvARB = __indirect_glGetProgramEnvParameterdvARB;
+    glAPI->GetProgramEnvParameterfvARB = __indirect_glGetProgramEnvParameterfvARB;
+    glAPI->GetProgramLocalParameterdvARB = __indirect_glGetProgramLocalParameterdvARB;
+    glAPI->GetProgramLocalParameterfvARB = __indirect_glGetProgramLocalParameterfvARB;
+    glAPI->GetProgramivARB = __indirect_glGetProgramivARB;
+    glAPI->GetProgramStringARB = __indirect_glGetProgramStringARB;
+    glAPI->GetVertexAttribdvARB = __indirect_glGetVertexAttribdvARB;
+    glAPI->GetVertexAttribfvARB = __indirect_glGetVertexAttribfvARB;
+    glAPI->GetVertexAttribivARB = __indirect_glGetVertexAttribivARB;
+    glAPI->VertexAttrib1dARB = __indirect_glVertexAttrib1dARB;
+    glAPI->VertexAttrib1dvARB = __indirect_glVertexAttrib1dvARB;
+    glAPI->VertexAttrib1fARB = __indirect_glVertexAttrib1fARB;
+    glAPI->VertexAttrib1fvARB = __indirect_glVertexAttrib1fvARB;
+    glAPI->VertexAttrib1sARB = __indirect_glVertexAttrib1sARB;
+    glAPI->VertexAttrib1svARB = __indirect_glVertexAttrib1svARB;
+    glAPI->VertexAttrib2dARB = __indirect_glVertexAttrib2dARB;
+    glAPI->VertexAttrib2dvARB = __indirect_glVertexAttrib2dvARB;
+    glAPI->VertexAttrib2fARB = __indirect_glVertexAttrib2fARB;
+    glAPI->VertexAttrib2fvARB = __indirect_glVertexAttrib2fvARB;
+    glAPI->VertexAttrib2sARB = __indirect_glVertexAttrib2sARB;
+    glAPI->VertexAttrib2svARB = __indirect_glVertexAttrib2svARB;
+    glAPI->VertexAttrib3dARB = __indirect_glVertexAttrib3dARB;
+    glAPI->VertexAttrib3dvARB = __indirect_glVertexAttrib3dvARB;
+    glAPI->VertexAttrib3fARB = __indirect_glVertexAttrib3fARB;
+    glAPI->VertexAttrib3fvARB = __indirect_glVertexAttrib3fvARB;
+    glAPI->VertexAttrib3sARB = __indirect_glVertexAttrib3sARB;
+    glAPI->VertexAttrib3svARB = __indirect_glVertexAttrib3svARB;
+    glAPI->VertexAttrib4dARB = __indirect_glVertexAttrib4dARB;
+    glAPI->VertexAttrib4dvARB = __indirect_glVertexAttrib4dvARB;
+    glAPI->VertexAttrib4fARB = __indirect_glVertexAttrib4fARB;
+    glAPI->VertexAttrib4fvARB = __indirect_glVertexAttrib4fvARB;
+    glAPI->VertexAttrib4sARB = __indirect_glVertexAttrib4sARB;
+    glAPI->VertexAttrib4svARB = __indirect_glVertexAttrib4svARB;
+    glAPI->VertexAttrib4NubARB = __indirect_glVertexAttrib4NubARB;
+    glAPI->VertexAttrib4NubvARB = __indirect_glVertexAttrib4NubvARB;
+
+    /*  29. GL_ARB_occlusion_query */
+
+    glAPI->EndQueryARB = __indirect_glEndQueryARB;
+    glAPI->GetQueryivARB = __indirect_glGetQueryivARB;
+    glAPI->GetQueryObjectivARB = __indirect_glGetQueryObjectivARB;
+    glAPI->GetQueryObjectuivARB = __indirect_glGetQueryObjectuivARB;
+    glAPI->GenQueriesARB = __indirect_glGenQueriesARB;
+    glAPI->DeleteQueriesARB = __indirect_glDeleteQueriesARB;
+    glAPI->IsQueryARB = __indirect_glIsQueryARB;
+    glAPI->BeginQueryARB = __indirect_glBeginQueryARB;
+
+    /*  37. GL_ARB_draw_buffers */
+
+    glAPI->DrawBuffersARB = __indirect_glDrawBuffersARB;
+
+    /*  20. GL_EXT_texture_object */
+
+    glAPI->GenTexturesEXT = __indirect_glGenTexturesEXT;
+    glAPI->IsTextureEXT = __indirect_glIsTextureEXT;
+    glAPI->AreTexturesResidentEXT = __indirect_glAreTexturesResidentEXT;
+
+    /*  25. GL_SGIS_multisample */
+
+    glAPI->SampleMaskSGIS = __indirect_glSampleMaskSGIS;
+    glAPI->SamplePatternSGIS = __indirect_glSamplePatternSGIS;
+
+    /*  30. GL_EXT_vertex_array */
+
+    glAPI->ColorPointerEXT = __indirect_glColorPointerEXT;
+    glAPI->EdgeFlagPointerEXT = __indirect_glEdgeFlagPointerEXT;
+    glAPI->IndexPointerEXT = __indirect_glIndexPointerEXT;
+    glAPI->NormalPointerEXT = __indirect_glNormalPointerEXT;
+    glAPI->TexCoordPointerEXT = __indirect_glTexCoordPointerEXT;
+    glAPI->VertexPointerEXT = __indirect_glVertexPointerEXT;
+
+    /*  54. GL_EXT_point_parameters */
+
+    glAPI->PointParameterfEXT = __indirect_glPointParameterfEXT;
+    glAPI->PointParameterfvEXT = __indirect_glPointParameterfvEXT;
+
+    /* 145. GL_EXT_secondary_color */
+
+    glAPI->SecondaryColor3usvEXT = __indirect_glSecondaryColor3usvEXT;
+    glAPI->SecondaryColorPointerEXT = __indirect_glSecondaryColorPointerEXT;
+    glAPI->SecondaryColor3bEXT = __indirect_glSecondaryColor3bEXT;
+    glAPI->SecondaryColor3bvEXT = __indirect_glSecondaryColor3bvEXT;
+    glAPI->SecondaryColor3dEXT = __indirect_glSecondaryColor3dEXT;
+    glAPI->SecondaryColor3dvEXT = __indirect_glSecondaryColor3dvEXT;
+    glAPI->SecondaryColor3fEXT = __indirect_glSecondaryColor3fEXT;
+    glAPI->SecondaryColor3fvEXT = __indirect_glSecondaryColor3fvEXT;
+    glAPI->SecondaryColor3iEXT = __indirect_glSecondaryColor3iEXT;
+    glAPI->SecondaryColor3ivEXT = __indirect_glSecondaryColor3ivEXT;
+    glAPI->SecondaryColor3sEXT = __indirect_glSecondaryColor3sEXT;
+    glAPI->SecondaryColor3svEXT = __indirect_glSecondaryColor3svEXT;
+    glAPI->SecondaryColor3ubEXT = __indirect_glSecondaryColor3ubEXT;
+    glAPI->SecondaryColor3ubvEXT = __indirect_glSecondaryColor3ubvEXT;
+    glAPI->SecondaryColor3uiEXT = __indirect_glSecondaryColor3uiEXT;
+    glAPI->SecondaryColor3uivEXT = __indirect_glSecondaryColor3uivEXT;
+    glAPI->SecondaryColor3usEXT = __indirect_glSecondaryColor3usEXT;
+
+    /* 148. GL_EXT_multi_draw_arrays */
+
+    glAPI->MultiDrawArraysEXT = __indirect_glMultiDrawArraysEXT;
+    glAPI->MultiDrawElementsEXT = __indirect_glMultiDrawElementsEXT;
+
+    /* 149. GL_EXT_fog_coord */
+
+    glAPI->FogCoordfEXT = __indirect_glFogCoordfEXT;
+    glAPI->FogCoordfvEXT = __indirect_glFogCoordfvEXT;
+    glAPI->FogCoorddEXT = __indirect_glFogCoorddEXT;
+    glAPI->FogCoorddvEXT = __indirect_glFogCoorddvEXT;
+    glAPI->FogCoordPointerEXT = __indirect_glFogCoordPointerEXT;
+
+    /* 173. GL_EXT_blend_func_separate */
+
+    glAPI->BlendFuncSeparateEXT = __indirect_glBlendFuncSeparateEXT;
+
+    /* 197. GL_MESA_window_pos */
+
+    glAPI->WindowPos2dMESA = __indirect_glWindowPos2dMESA;
+    glAPI->WindowPos2dvMESA = __indirect_glWindowPos2dvMESA;
+    glAPI->WindowPos2fMESA = __indirect_glWindowPos2fMESA;
+    glAPI->WindowPos2fvMESA = __indirect_glWindowPos2fvMESA;
+    glAPI->WindowPos2iMESA = __indirect_glWindowPos2iMESA;
+    glAPI->WindowPos2ivMESA = __indirect_glWindowPos2ivMESA;
+    glAPI->WindowPos2sMESA = __indirect_glWindowPos2sMESA;
+    glAPI->WindowPos2svMESA = __indirect_glWindowPos2svMESA;
+    glAPI->WindowPos3dMESA = __indirect_glWindowPos3dMESA;
+    glAPI->WindowPos3dvMESA = __indirect_glWindowPos3dvMESA;
+    glAPI->WindowPos3fMESA = __indirect_glWindowPos3fMESA;
+    glAPI->WindowPos3fvMESA = __indirect_glWindowPos3fvMESA;
+    glAPI->WindowPos3iMESA = __indirect_glWindowPos3iMESA;
+    glAPI->WindowPos3ivMESA = __indirect_glWindowPos3ivMESA;
+    glAPI->WindowPos3sMESA = __indirect_glWindowPos3sMESA;
+    glAPI->WindowPos3svMESA = __indirect_glWindowPos3svMESA;
+
+    /* 233. GL_NV_vertex_program */
+
+    glAPI->VertexAttribs4svNV = __indirect_glVertexAttribs4svNV;
+    glAPI->VertexAttribs4ubvNV = __indirect_glVertexAttribs4ubvNV;
+    glAPI->VertexAttrib3fNV = __indirect_glVertexAttrib3fNV;
+    glAPI->VertexAttrib3fvNV = __indirect_glVertexAttrib3fvNV;
+    glAPI->VertexAttrib3sNV = __indirect_glVertexAttrib3sNV;
+    glAPI->VertexAttrib3svNV = __indirect_glVertexAttrib3svNV;
+    glAPI->VertexAttrib4dNV = __indirect_glVertexAttrib4dNV;
+    glAPI->VertexAttrib3dvNV = __indirect_glVertexAttrib3dvNV;
+    glAPI->VertexAttrib4fNV = __indirect_glVertexAttrib4fNV;
+    glAPI->VertexAttrib4fvNV = __indirect_glVertexAttrib4fvNV;
+    glAPI->VertexAttrib4sNV = __indirect_glVertexAttrib4sNV;
+    glAPI->VertexAttrib4svNV = __indirect_glVertexAttrib4svNV;
+    glAPI->VertexAttrib4ubNV = __indirect_glVertexAttrib4ubNV;
+    glAPI->VertexAttrib4ubvNV = __indirect_glVertexAttrib4ubvNV;
+    glAPI->VertexAttrib1fvNV = __indirect_glVertexAttrib1fvNV;
+    glAPI->VertexAttrib3dNV = __indirect_glVertexAttrib3dNV;
+    glAPI->VertexAttrib4dvNV = __indirect_glVertexAttrib4dvNV;
+    glAPI->VertexAttrib1sNV = __indirect_glVertexAttrib1sNV;
+    glAPI->VertexAttrib1fNV = __indirect_glVertexAttrib1fNV;
+    glAPI->VertexAttrib1svNV = __indirect_glVertexAttrib1svNV;
+    glAPI->VertexAttrib1dvNV = __indirect_glVertexAttrib1dvNV;
+    glAPI->AreProgramsResidentNV = __indirect_glAreProgramsResidentNV;
+    glAPI->BindProgramNV = __indirect_glBindProgramNV;
+    glAPI->DeleteProgramsNV = __indirect_glDeleteProgramsNV;
+    glAPI->ExecuteProgramNV = __indirect_glExecuteProgramNV;
+    glAPI->GenProgramsNV = __indirect_glGenProgramsNV;
+    glAPI->GetProgramParameterdvNV = __indirect_glGetProgramParameterdvNV;
+    glAPI->GetProgramParameterfvNV = __indirect_glGetProgramParameterfvNV;
+    glAPI->GetProgramivNV = __indirect_glGetProgramivNV;
+    glAPI->GetProgramStringNV = __indirect_glGetProgramStringNV;
+    glAPI->GetTrackMatrixivNV = __indirect_glGetTrackMatrixivNV;
+    glAPI->GetVertexAttribPointervNV = __indirect_glGetVertexAttribPointervNV;
+    glAPI->IsProgramNV = __indirect_glIsProgramNV;
+    glAPI->LoadProgramNV = __indirect_glLoadProgramNV;
+    glAPI->ProgramParameter4dNV = __indirect_glProgramParameter4dNV;
+    glAPI->ProgramParameter4dvNV = __indirect_glProgramParameter4dvNV;
+    glAPI->ProgramParameter4fNV = __indirect_glProgramParameter4fNV;
+    glAPI->ProgramParameter4fvNV = __indirect_glProgramParameter4fvNV;
+    glAPI->ProgramParameters4dvNV = __indirect_glProgramParameters4dvNV;
+    glAPI->ProgramParameters4fvNV = __indirect_glProgramParameters4fvNV;
+    glAPI->RequestResidentProgramsNV = __indirect_glRequestResidentProgramsNV;
+    glAPI->TrackMatrixNV = __indirect_glTrackMatrixNV;
+    glAPI->VertexAttribPointerNV = __indirect_glVertexAttribPointerNV;
+    glAPI->VertexAttrib2dNV = __indirect_glVertexAttrib2dNV;
+    glAPI->VertexAttrib2sNV = __indirect_glVertexAttrib2sNV;
+    glAPI->VertexAttrib2dvNV = __indirect_glVertexAttrib2dvNV;
+    glAPI->VertexAttrib2fNV = __indirect_glVertexAttrib2fNV;
+    glAPI->VertexAttrib2svNV = __indirect_glVertexAttrib2svNV;
+    glAPI->VertexAttrib2fvNV = __indirect_glVertexAttrib2fvNV;
+    glAPI->GetVertexAttribdvNV = __indirect_glGetVertexAttribdvNV;
+    glAPI->GetVertexAttribfvNV = __indirect_glGetVertexAttribfvNV;
+    glAPI->GetVertexAttribivNV = __indirect_glGetVertexAttribivNV;
+    glAPI->VertexAttrib1dNV = __indirect_glVertexAttrib1dNV;
+    glAPI->VertexAttribs1dvNV = __indirect_glVertexAttribs1dvNV;
+    glAPI->VertexAttribs1fvNV = __indirect_glVertexAttribs1fvNV;
+    glAPI->VertexAttribs1svNV = __indirect_glVertexAttribs1svNV;
+    glAPI->VertexAttribs2dvNV = __indirect_glVertexAttribs2dvNV;
+    glAPI->VertexAttribs2fvNV = __indirect_glVertexAttribs2fvNV;
+    glAPI->VertexAttribs2svNV = __indirect_glVertexAttribs2svNV;
+    glAPI->VertexAttribs3dvNV = __indirect_glVertexAttribs3dvNV;
+    glAPI->VertexAttribs3fvNV = __indirect_glVertexAttribs3fvNV;
+    glAPI->VertexAttribs3svNV = __indirect_glVertexAttribs3svNV;
+    glAPI->VertexAttribs4dvNV = __indirect_glVertexAttribs4dvNV;
+    glAPI->VertexAttribs4fvNV = __indirect_glVertexAttribs4fvNV;
+
+    /* 262. GL_NV_point_sprite */
+
+    glAPI->PointParameteriNV = __indirect_glPointParameteriNV;
+    glAPI->PointParameterivNV = __indirect_glPointParameterivNV;
+
+    /* 268. GL_EXT_stencil_two_side */
+
+    glAPI->ActiveStencilFaceEXT = __indirect_glActiveStencilFaceEXT;
+
+    /* 282. GL_NV_fragment_program */
+
+    glAPI->ProgramNamedParameter4fNV = __indirect_glProgramNamedParameter4fNV;
+    glAPI->ProgramNamedParameter4dNV = __indirect_glProgramNamedParameter4dNV;
+    glAPI->ProgramNamedParameter4fvNV = __indirect_glProgramNamedParameter4fvNV;
+    glAPI->ProgramNamedParameter4dvNV = __indirect_glProgramNamedParameter4dvNV;
+    glAPI->GetProgramNamedParameterfvNV = __indirect_glGetProgramNamedParameterfvNV;
+    glAPI->GetProgramNamedParameterdvNV = __indirect_glGetProgramNamedParameterdvNV;
+
+    /* 310. GL_EXT_framebuffer_object */
+
+    glAPI->RenderbufferStorageEXT = __indirect_glRenderbufferStorageEXT;
+    glAPI->GetRenderbufferParameterivEXT = __indirect_glGetRenderbufferParameterivEXT;
+    glAPI->IsFramebufferEXT = __indirect_glIsFramebufferEXT;
+    glAPI->BindFramebufferEXT = __indirect_glBindFramebufferEXT;
+    glAPI->DeleteFramebuffersEXT = __indirect_glDeleteFramebuffersEXT;
+    glAPI->GenFramebuffersEXT = __indirect_glGenFramebuffersEXT;
+    glAPI->CheckFramebufferStatusEXT = __indirect_glCheckFramebufferStatusEXT;
+    glAPI->FramebufferTexture1DEXT = __indirect_glFramebufferTexture1DEXT;
+    glAPI->FramebufferTexture2DEXT = __indirect_glFramebufferTexture2DEXT;
+    glAPI->FramebufferTexture3DEXT = __indirect_glFramebufferTexture3DEXT;
+    glAPI->FramebufferRenderbufferEXT = __indirect_glFramebufferRenderbufferEXT;
+    glAPI->GetFramebufferAttachmentParameterivEXT = __indirect_glGetFramebufferAttachmentParameterivEXT;
+    glAPI->GenerateMipmapEXT = __indirect_glGenerateMipmapEXT;
+    glAPI->IsRenderbufferEXT = __indirect_glIsRenderbufferEXT;
+    glAPI->BindRenderbufferEXT = __indirect_glBindRenderbufferEXT;
+    glAPI->DeleteRenderbuffersEXT = __indirect_glDeleteRenderbuffersEXT;
+    glAPI->GenRenderbuffersEXT = __indirect_glGenRenderbuffersEXT;
+
+    return glAPI;
+}
+
diff --git a/src/glx/x11/indirect_init.h b/src/glx/x11/indirect_init.h
new file mode 100644
index 00000000000..62d04ba6dc2
--- /dev/null
+++ b/src/glx/x11/indirect_init.h
@@ -0,0 +1,42 @@
+/* $XFree86: xc/lib/GL/glx/indirect_init.h,v 1.2 2000/02/08 17:18:33 dawes Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+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 PRECISION INSIGHT AND/OR ITS 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.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Kevin E. Martin <[email protected]>
+ *
+ */
+
+#ifndef _INDIRECT_INIT_H_
+#define _INDIRECT_INIT_H_
+
+#include "glxclient.h"
+
+extern __GLapi *__glXNewIndirectAPI(void);
+
+#endif /* _INDIRECT_INIT_H_ */
diff --git a/src/glx/x11/indirect_size.c b/src/glx/x11/indirect_size.c
new file mode 100644
index 00000000000..79d57d55b68
--- /dev/null
+++ b/src/glx/x11/indirect_size.c
@@ -0,0 +1,370 @@
+/* DO NOT EDIT - This file generated automatically by glX_proto_size.py (from Mesa) script */
+
+/*
+ * (C) Copyright IBM Corporation 2004
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * IBM,
+ * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+
+#include <GL/gl.h>
+#include "indirect_size.h"
+
+#  if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
+#    define PURE __attribute__((pure))
+#  else
+#    define PURE
+#  endif
+
+#  if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined(__MINGW32__)
+#    define FASTCALL __attribute__((fastcall))
+#  else
+#    define FASTCALL
+#  endif
+
+#  if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__)
+#    define INTERNAL  __attribute__((visibility("internal")))
+#  else
+#    define INTERNAL
+#  endif
+
+
+#if defined(__CYGWIN__) || defined(__MINGW32__) || defined(__APPLE__)
+#  undef HAVE_ALIAS
+#endif
+#ifdef HAVE_ALIAS
+#  define ALIAS2(from,to) \
+    INTERNAL PURE FASTCALL GLint __gl ## from ## _size( GLenum e ) \
+        __attribute__ ((alias( # to )));
+#  define ALIAS(from,to) ALIAS2( from, __gl ## to ## _size )
+#else
+#  define ALIAS(from,to) \
+    INTERNAL PURE FASTCALL GLint __gl ## from ## _size( GLenum e ) \
+    { return __gl ## to ## _size( e ); }
+#endif
+
+
+INTERNAL PURE FASTCALL GLint
+__glCallLists_size( GLenum e )
+{
+    switch( e ) {
+        case GL_BYTE:
+        case GL_UNSIGNED_BYTE:
+            return 1;
+        case GL_SHORT:
+        case GL_UNSIGNED_SHORT:
+        case GL_2_BYTES:
+            return 2;
+        case GL_3_BYTES:
+            return 3;
+        case GL_INT:
+        case GL_UNSIGNED_INT:
+        case GL_FLOAT:
+        case GL_4_BYTES:
+            return 4;
+        default: return 0;
+    }
+}
+
+INTERNAL PURE FASTCALL GLint
+__glFogfv_size( GLenum e )
+{
+    switch( e ) {
+        case GL_FOG_INDEX:
+        case GL_FOG_DENSITY:
+        case GL_FOG_START:
+        case GL_FOG_END:
+        case GL_FOG_MODE:
+        case GL_FOG_OFFSET_VALUE_SGIX:
+        case GL_FOG_DISTANCE_MODE_NV:
+            return 1;
+        case GL_FOG_COLOR:
+            return 4;
+        default: return 0;
+    }
+}
+
+INTERNAL PURE FASTCALL GLint
+__glLightfv_size( GLenum e )
+{
+    switch( e ) {
+        case GL_SPOT_EXPONENT:
+        case GL_SPOT_CUTOFF:
+        case GL_CONSTANT_ATTENUATION:
+        case GL_LINEAR_ATTENUATION:
+        case GL_QUADRATIC_ATTENUATION:
+            return 1;
+        case GL_SPOT_DIRECTION:
+            return 3;
+        case GL_AMBIENT:
+        case GL_DIFFUSE:
+        case GL_SPECULAR:
+        case GL_POSITION:
+            return 4;
+        default: return 0;
+    }
+}
+
+INTERNAL PURE FASTCALL GLint
+__glLightModelfv_size( GLenum e )
+{
+    switch( e ) {
+        case GL_LIGHT_MODEL_LOCAL_VIEWER:
+        case GL_LIGHT_MODEL_TWO_SIDE:
+        case GL_LIGHT_MODEL_COLOR_CONTROL:
+/*      case GL_LIGHT_MODEL_COLOR_CONTROL_EXT:*/
+            return 1;
+        case GL_LIGHT_MODEL_AMBIENT:
+            return 4;
+        default: return 0;
+    }
+}
+
+INTERNAL PURE FASTCALL GLint
+__glMaterialfv_size( GLenum e )
+{
+    switch( e ) {
+        case GL_SHININESS:
+            return 1;
+        case GL_COLOR_INDEXES:
+            return 3;
+        case GL_AMBIENT:
+        case GL_DIFFUSE:
+        case GL_SPECULAR:
+        case GL_EMISSION:
+        case GL_AMBIENT_AND_DIFFUSE:
+            return 4;
+        default: return 0;
+    }
+}
+
+INTERNAL PURE FASTCALL GLint
+__glTexParameterfv_size( GLenum e )
+{
+    switch( e ) {
+        case GL_TEXTURE_MAG_FILTER:
+        case GL_TEXTURE_MIN_FILTER:
+        case GL_TEXTURE_WRAP_S:
+        case GL_TEXTURE_WRAP_T:
+        case GL_TEXTURE_PRIORITY:
+        case GL_TEXTURE_WRAP_R:
+        case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
+/*      case GL_SHADOW_AMBIENT_SGIX:*/
+        case GL_TEXTURE_MIN_LOD:
+        case GL_TEXTURE_MAX_LOD:
+        case GL_TEXTURE_BASE_LEVEL:
+        case GL_TEXTURE_MAX_LEVEL:
+        case GL_TEXTURE_CLIPMAP_FRAME_SGIX:
+        case GL_TEXTURE_LOD_BIAS_S_SGIX:
+        case GL_TEXTURE_LOD_BIAS_T_SGIX:
+        case GL_TEXTURE_LOD_BIAS_R_SGIX:
+        case GL_GENERATE_MIPMAP:
+/*      case GL_GENERATE_MIPMAP_SGIS:*/
+        case GL_TEXTURE_COMPARE_SGIX:
+        case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
+        case GL_TEXTURE_MAX_CLAMP_S_SGIX:
+        case GL_TEXTURE_MAX_CLAMP_T_SGIX:
+        case GL_TEXTURE_MAX_CLAMP_R_SGIX:
+        case GL_TEXTURE_MAX_ANISOTROPY_EXT:
+        case GL_TEXTURE_LOD_BIAS:
+/*      case GL_TEXTURE_LOD_BIAS_EXT:*/
+        case GL_DEPTH_TEXTURE_MODE:
+/*      case GL_DEPTH_TEXTURE_MODE_ARB:*/
+        case GL_TEXTURE_COMPARE_MODE:
+/*      case GL_TEXTURE_COMPARE_MODE_ARB:*/
+        case GL_TEXTURE_COMPARE_FUNC:
+/*      case GL_TEXTURE_COMPARE_FUNC_ARB:*/
+        case GL_TEXTURE_UNSIGNED_REMAP_MODE_NV:
+            return 1;
+        case GL_TEXTURE_CLIPMAP_CENTER_SGIX:
+        case GL_TEXTURE_CLIPMAP_OFFSET_SGIX:
+            return 2;
+        case GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX:
+            return 3;
+        case GL_TEXTURE_BORDER_COLOR:
+        case GL_POST_TEXTURE_FILTER_BIAS_SGIX:
+        case GL_POST_TEXTURE_FILTER_SCALE_SGIX:
+            return 4;
+        default: return 0;
+    }
+}
+
+INTERNAL PURE FASTCALL GLint
+__glTexEnvfv_size( GLenum e )
+{
+    switch( e ) {
+        case GL_ALPHA_SCALE:
+        case GL_TEXTURE_ENV_MODE:
+        case GL_TEXTURE_LOD_BIAS:
+        case GL_COMBINE_RGB:
+        case GL_COMBINE_ALPHA:
+        case GL_RGB_SCALE:
+        case GL_SOURCE0_RGB:
+        case GL_SOURCE1_RGB:
+        case GL_SOURCE2_RGB:
+        case GL_SOURCE3_RGB_NV:
+        case GL_SOURCE0_ALPHA:
+        case GL_SOURCE1_ALPHA:
+        case GL_SOURCE2_ALPHA:
+        case GL_SOURCE3_ALPHA_NV:
+        case GL_OPERAND0_RGB:
+        case GL_OPERAND1_RGB:
+        case GL_OPERAND2_RGB:
+        case GL_OPERAND3_RGB_NV:
+        case GL_OPERAND0_ALPHA:
+        case GL_OPERAND1_ALPHA:
+        case GL_OPERAND2_ALPHA:
+        case GL_OPERAND3_ALPHA_NV:
+        case GL_COORD_REPLACE_ARB:
+/*      case GL_COORD_REPLACE_NV:*/
+            return 1;
+        case GL_TEXTURE_ENV_COLOR:
+            return 4;
+        default: return 0;
+    }
+}
+
+INTERNAL PURE FASTCALL GLint
+__glTexGendv_size( GLenum e )
+{
+    switch( e ) {
+        case GL_TEXTURE_GEN_MODE:
+            return 1;
+        case GL_OBJECT_PLANE:
+        case GL_EYE_PLANE:
+            return 4;
+        default: return 0;
+    }
+}
+
+INTERNAL PURE FASTCALL GLint
+__glMap1d_size( GLenum e )
+{
+    switch( e ) {
+        case GL_MAP1_INDEX:
+        case GL_MAP1_TEXTURE_COORD_1:
+            return 1;
+        case GL_MAP1_TEXTURE_COORD_2:
+            return 2;
+        case GL_MAP1_NORMAL:
+        case GL_MAP1_TEXTURE_COORD_3:
+        case GL_MAP1_VERTEX_3:
+            return 3;
+        case GL_MAP1_COLOR_4:
+        case GL_MAP1_TEXTURE_COORD_4:
+        case GL_MAP1_VERTEX_4:
+            return 4;
+        default: return 0;
+    }
+}
+
+INTERNAL PURE FASTCALL GLint
+__glMap2d_size( GLenum e )
+{
+    switch( e ) {
+        case GL_MAP2_INDEX:
+        case GL_MAP2_TEXTURE_COORD_1:
+            return 1;
+        case GL_MAP2_TEXTURE_COORD_2:
+            return 2;
+        case GL_MAP2_NORMAL:
+        case GL_MAP2_TEXTURE_COORD_3:
+        case GL_MAP2_VERTEX_3:
+            return 3;
+        case GL_MAP2_COLOR_4:
+        case GL_MAP2_TEXTURE_COORD_4:
+        case GL_MAP2_VERTEX_4:
+            return 4;
+        default: return 0;
+    }
+}
+
+INTERNAL PURE FASTCALL GLint
+__glColorTableParameterfv_size( GLenum e )
+{
+    switch( e ) {
+        case GL_COLOR_TABLE_SCALE:
+        case GL_COLOR_TABLE_BIAS:
+            return 4;
+        default: return 0;
+    }
+}
+
+INTERNAL PURE FASTCALL GLint
+__glConvolutionParameterfv_size( GLenum e )
+{
+    switch( e ) {
+        case GL_CONVOLUTION_BORDER_MODE:
+/*      case GL_CONVOLUTION_BORDER_MODE_EXT:*/
+            return 1;
+        case GL_CONVOLUTION_FILTER_SCALE:
+/*      case GL_CONVOLUTION_FILTER_SCALE_EXT:*/
+        case GL_CONVOLUTION_FILTER_BIAS:
+/*      case GL_CONVOLUTION_FILTER_BIAS_EXT:*/
+        case GL_CONVOLUTION_BORDER_COLOR:
+/*      case GL_CONVOLUTION_BORDER_COLOR_HP:*/
+            return 4;
+        default: return 0;
+    }
+}
+
+INTERNAL PURE FASTCALL GLint
+__glPointParameterfvEXT_size( GLenum e )
+{
+    switch( e ) {
+        case GL_POINT_SIZE_MIN:
+/*      case GL_POINT_SIZE_MIN_ARB:*/
+/*      case GL_POINT_SIZE_MIN_SGIS:*/
+        case GL_POINT_SIZE_MAX:
+/*      case GL_POINT_SIZE_MAX_ARB:*/
+/*      case GL_POINT_SIZE_MAX_SGIS:*/
+        case GL_POINT_FADE_THRESHOLD_SIZE:
+/*      case GL_POINT_FADE_THRESHOLD_SIZE_ARB:*/
+/*      case GL_POINT_FADE_THRESHOLD_SIZE_SGIS:*/
+        case GL_POINT_SPRITE_R_MODE_NV:
+        case GL_POINT_SPRITE_COORD_ORIGIN:
+            return 1;
+        case GL_POINT_DISTANCE_ATTENUATION:
+/*      case GL_POINT_DISTANCE_ATTENUATION_ARB:*/
+/*      case GL_POINT_DISTANCE_ATTENUATION_SGIS:*/
+            return 3;
+        default: return 0;
+    }
+}
+
+ALIAS( Fogiv, Fogfv )
+ALIAS( Lightiv, Lightfv )
+ALIAS( LightModeliv, LightModelfv )
+ALIAS( Materialiv, Materialfv )
+ALIAS( TexParameteriv, TexParameterfv )
+ALIAS( TexEnviv, TexEnvfv )
+ALIAS( TexGenfv, TexGendv )
+ALIAS( TexGeniv, TexGendv )
+ALIAS( Map1f, Map1d )
+ALIAS( Map2f, Map2d )
+ALIAS( ColorTableParameteriv, ColorTableParameterfv )
+ALIAS( ConvolutionParameteriv, ConvolutionParameterfv )
+ALIAS( PointParameterivNV, PointParameterfvEXT )
+
+#  undef PURE
+#  undef FASTCALL
+#  undef INTERNAL
diff --git a/src/glx/x11/indirect_size.h b/src/glx/x11/indirect_size.h
new file mode 100644
index 00000000000..9ba0bd69075
--- /dev/null
+++ b/src/glx/x11/indirect_size.h
@@ -0,0 +1,88 @@
+/* DO NOT EDIT - This file generated automatically by glX_proto_size.py (from Mesa) script */
+
+/*
+ * (C) Copyright IBM Corporation 2004
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * IBM,
+ * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#if !defined( _INDIRECT_SIZE_H_ )
+#  define _INDIRECT_SIZE_H_
+
+/**
+ * \file
+ * Prototypes for functions used to determine the number of data elements in
+ * various GLX protocol messages.
+ *
+ * \author Ian Romanick <[email protected]>
+ */
+
+#  if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
+#    define PURE __attribute__((pure))
+#  else
+#    define PURE
+#  endif
+
+#  if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined(__MINGW32__)
+#    define FASTCALL __attribute__((fastcall))
+#  else
+#    define FASTCALL
+#  endif
+
+#  if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__)
+#    define INTERNAL  __attribute__((visibility("internal")))
+#  else
+#    define INTERNAL
+#  endif
+
+extern INTERNAL PURE FASTCALL GLint __glCallLists_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glFogfv_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glFogiv_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glLightfv_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glLightiv_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glLightModelfv_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glLightModeliv_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glMaterialfv_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glMaterialiv_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glTexParameterfv_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glTexParameteriv_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glTexEnvfv_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glTexEnviv_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glTexGendv_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glTexGenfv_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glTexGeniv_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glMap1d_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glMap1f_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glMap2d_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glMap2f_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glColorTableParameterfv_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glColorTableParameteriv_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glConvolutionParameterfv_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glConvolutionParameteriv_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glPointParameterfvEXT_size(GLenum);
+extern INTERNAL PURE FASTCALL GLint __glPointParameterivNV_size(GLenum);
+
+#  undef PURE
+#  undef FASTCALL
+#  undef INTERNAL
+
+#endif /* !defined( _INDIRECT_SIZE_H_ ) */
diff --git a/src/glx/x11/indirect_transpose_matrix.c b/src/glx/x11/indirect_transpose_matrix.c
new file mode 100644
index 00000000000..2144410e5ac
--- /dev/null
+++ b/src/glx/x11/indirect_transpose_matrix.c
@@ -0,0 +1,83 @@
+/*
+ * (C) Copyright IBM Corporation 2004
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on 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
+ * THE COPYRIGHT HOLDERS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <GL/gl.h>
+#include "indirect.h"
+
+static void TransposeMatrixf(const GLfloat s[16], GLfloat d[16])
+{
+    int i, j;
+    for (i = 0; i < 4; i++) {
+        for (j = 0; j < 4; j++) {
+            d[i*4+j] = s[j*4+i];
+        }
+    }
+}
+
+static void TransposeMatrixd(const GLdouble s[16], GLdouble d[16])
+{
+    int i, j;
+    for (i = 0; i < 4; i++) {
+        for (j = 0; j < 4; j++) {
+            d[i*4+j] = s[j*4+i];
+        }
+    }
+}
+
+
+void
+__indirect_glLoadTransposeMatrixdARB( const GLdouble * m )
+{
+   GLdouble mt[16];
+   
+   TransposeMatrixd( m, mt );
+   __indirect_glLoadMatrixd( mt );
+}
+
+void
+__indirect_glLoadTransposeMatrixfARB( const GLfloat * m )
+{
+   GLfloat mt[16];
+
+   TransposeMatrixf( m, mt );
+   __indirect_glLoadMatrixf( mt );
+}
+
+void
+__indirect_glMultTransposeMatrixdARB( const GLdouble * m )
+{
+   GLdouble mt[16];
+   
+   TransposeMatrixd( m, mt );
+   __indirect_glMultMatrixd( mt );
+}
+
+void
+__indirect_glMultTransposeMatrixfARB( const GLfloat * m )
+{
+   GLfloat mt[16];
+
+   TransposeMatrixf( m, mt );
+   __indirect_glMultMatrixf( mt );
+}
diff --git a/src/glx/x11/indirect_va_private.h b/src/glx/x11/indirect_va_private.h
new file mode 100644
index 00000000000..ab97dc645fb
--- /dev/null
+++ b/src/glx/x11/indirect_va_private.h
@@ -0,0 +1,308 @@
+/*
+ * (C) Copyright IBM Corporation 2004, 2005
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * IBM,
+ * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef _INDIRECT_VA_PRIVATE_
+#define _INDIRECT_VA_PRIVATE_
+
+/**
+ * \file indirect_va_private.h
+ *
+ * \author Ian Romanick <[email protected]>
+ */
+
+#include <inttypes.h>
+
+#include "glxclient.h"
+#include "indirect.h"
+#include <GL/glxproto.h>
+
+
+/**
+ * State descriptor for a single array of vertex data.
+ */
+struct array_state {
+    /**
+     * Pointer to the application supplied data.
+     */
+    const void * data;
+    
+    /**
+     * Enum representing the type of the application supplied data.
+     */
+    GLenum data_type;
+
+    /**
+     * Stride value supplied by the application.  This value is not used
+     * internally.  It is only kept so that it can be queried by the
+     * application using glGet*v.
+     */
+    GLsizei user_stride;
+
+    /**
+     * Calculated size, in bytes, of a single element in the array.  This
+     * is calculated based on \c count and the size of the data type
+     * represented by \c data_type.
+     */
+    GLsizei element_size;
+
+    /**
+     * Actual byte-stride from one element to the next.  This value will
+     * be equal to either \c user_stride or \c element_stride.
+     */
+    GLsizei true_stride;
+
+    /**
+     * Number of data values in each element.
+     */
+    GLint count;
+
+    /**
+     * "Normalized" data is on the range [0,1] (unsigned) or [-1,1] (signed).
+     * This is used for mapping integral types to floating point types.
+     */
+    GLboolean normalized;
+
+    /**
+     * Pre-calculated GLX protocol command header.
+     */
+    uint32_t header[2];
+    
+    /**
+     * Size of the header data.  For simple data, like glColorPointerfv,
+     * this is 4.  For complex data that requires either a count (e.g.,
+     * glWeightfvARB), an index (e.g., glVertexAttrib1fvARB), or a
+     * selector enum (e.g., glMultiTexCoord2fv) this is 8.
+     */
+    unsigned header_size;
+    
+    /**
+     * Set to \c GL_TRUE if this array is enabled.  Otherwise, it is set
+     * to \c GL_FALSE.
+     */
+    GLboolean  enabled;
+
+    /**
+     * For multi-arrayed data (e.g., texture coordinates, generic vertex
+     * program attributes, etc.), this specifies which array this is.
+     */
+    unsigned index;
+    
+    /**
+     * Per-array-type key.  For most arrays, this will be the GL enum for
+     * that array (e.g., GL_VERTEX_ARRAY for vertex data, GL_NORMAL_ARRAY
+     * for normal data, GL_TEXTURE_COORD_ARRAY for texture coordinate data,
+     * etc.).
+     */
+    GLenum key;
+
+    /**
+     * If this array can be used with the "classic" \c glDrawArrays protocol,
+     * this is set to \c GL_TRUE.  Otherwise, it is set to \c GL_FALSE.
+     */
+    GLboolean old_DrawArrays_possible;
+};
+
+
+/**
+ * Array state that is pushed / poped by \c glPushClientAttrib and
+ * \c glPopClientAttrib.
+ */
+struct array_stack_state {
+    /**
+     * Pointer to the application supplied data.
+     */
+    const void * data;
+    
+    /**
+     * Enum representing the type of the application supplied data.
+     */
+    GLenum data_type;
+
+    /**
+     * Stride value supplied by the application.  This value is not used
+     * internally.  It is only kept so that it can be queried by the
+     * application using glGet*v.
+     */
+    GLsizei user_stride;
+
+    /**
+     * Number of data values in each element.
+     */
+    GLint count;
+
+    /**
+     * Per-array-type key.  For most arrays, this will be the GL enum for
+     * that array (e.g., GL_VERTEX_ARRAY for vertex data, GL_NORMAL_ARRAY
+     * for normal data, GL_TEXTURE_COORD_ARRAY for texture coordinate data,
+     * etc.).
+     */
+    GLenum key;
+
+    /**
+     * For multi-arrayed data (e.g., texture coordinates, generic vertex
+     * program attributes, etc.), this specifies which array this is.
+     */
+    unsigned index;
+
+    /**
+     * Set to \c GL_TRUE if this array is enabled.  Otherwise, it is set
+     * to \c GL_FALSE.
+     */
+    GLboolean  enabled;
+};
+
+
+/**
+ * Collection of all the vertex array state.
+ */
+struct array_state_vector {
+    /**
+     * Number of arrays tracked by \c ::arrays.
+     */
+    size_t num_arrays;
+
+    /**
+     * Array of vertex array state.  This array contains all of the valid
+     * vertex arrays.  If a vertex array isn't in this array, then it isn't
+     * valid.  For example, if an implementation does not support
+     * EXT_fog_coord, there won't be a GL_FOG_COORD_ARRAY entry in this
+     * array.
+     */
+    struct array_state * arrays;
+
+    /**
+     * Number of currently enabled client-side arrays.  The value of this 
+     * field is only valid if \c array_info_cache_valid is true.
+     */
+    size_t enabled_client_array_count;
+
+    /**
+     * \name ARRAY_INFO cache.
+     * 
+     * These fields track the state of the ARRAY_INFO cache.  The
+     * \c array_info_cache_size is the size of the actual data stored in
+     * \c array_info_cache.  \c array_info_cache_buffer_size is the size of
+     * the buffer.  This will always be greater than or equal to
+     * \c array_info_cache_size.
+     *
+     * \note
+     * There are some bytes of extra data before \c array_info_cache that is
+     * used to hold the header for RenderLarge commands.  This is
+     * \b not included in \c array_info_cache_size or
+     * \c array_info_cache_buffer_size.  \c array_info_cache_base stores a
+     * pointer to the true start of the buffer (i.e., what malloc returned).
+     */
+    /*@{*/
+    size_t array_info_cache_size;
+    size_t array_info_cache_buffer_size;
+    void * array_info_cache;
+    void * array_info_cache_base;
+    /*@}*/
+
+
+    /**
+     * Is the cache of ARRAY_INFO data valid?  The cache can become invalid
+     * when one of several state changes occur.  Among these chages are
+     * modifying the array settings for an enabled array and enabling /
+     * disabling an array.
+     */
+    GLboolean array_info_cache_valid;
+
+    /**
+     * Is it possible to use the GL 1.1 / EXT_vertex_arrays protocol?  Use
+     * of this protocol is disabled with really old servers (i.e., servers
+     * that don't support GL 1.1 or EXT_vertex_arrays) or when an environment
+     * variable is set.
+     * 
+     * \todo
+     * GL 1.1 and EXT_vertex_arrays use identical protocol, but have different
+     * opcodes for \c glDrawArrays.  For servers that advertise one or the
+     * other, there should be a way to select which opcode to use.
+     */
+    GLboolean old_DrawArrays_possible;
+
+    /**
+     * Is it possible to use the new GL X.X / ARB_vertex_buffer_object
+     * protocol?
+     * 
+     * \todo
+     * This protocol has not yet been defined by the ARB, but is currently a
+     * work in progress.  This field is a place-holder.
+     */
+    GLboolean new_DrawArrays_possible;
+
+    /**
+     * Active texture unit set by \c glClientActiveTexture.
+     * 
+     * \sa __glXGetActiveTextureUnit
+     */
+    unsigned active_texture_unit;
+    
+    /**
+     * Number of supported texture units.  Even if ARB_multitexture /
+     * GL 1.3 are not supported, this will be at least 1.  When multitexture
+     * is supported, this will be the value queried by calling
+     * \c glGetIntegerv with \c GL_MAX_TEXTURE_UNITS.
+     * 
+     * \todo
+     * Investigate if this should be the value of \c GL_MAX_TEXTURE_COORDS
+     * instead (if GL 2.0 / ARB_fragment_shader / ARB_fragment_program /
+     * NV_fragment_program are supported).
+     */
+    unsigned num_texture_units;
+
+    /**
+     * Number of generic vertex program attribs.  If GL_ARB_vertex_program
+     * is not supported, this will be zero.  Otherwise it will be the value
+     * queries by calling \c glGetProgramiv with \c GL_VERTEX_PROGRAM_ARB
+     * and \c GL_MAX_PROGRAM_ATTRIBS_ARB.
+     */
+    unsigned num_vertex_program_attribs;
+
+    /**
+     * \n Methods for implementing various GL functions.
+     * 
+     * These method pointers are only valid \c array_info_cache_valid is set.
+     * When each function starts, it much check \c array_info_cache_valid.
+     * If it is not set, it must call \c fill_array_info_cache and call
+     * the new method.
+     * 
+     * \sa fill_array_info_cache
+     * 
+     * \todo
+     * Write code to plug these functions directly into the dispatch table.
+     */
+    /*@{*/
+    void (*DrawArrays)( GLenum, GLint, GLsizei );
+    void (*DrawElements)( GLenum mode, GLsizei count, GLenum type,
+			  const GLvoid *indices );
+    /*@}*/
+
+    struct array_stack_state * stack;
+    unsigned active_texture_unit_stack[ __GL_CLIENT_ATTRIB_STACK_DEPTH ];
+    unsigned stack_index;
+};
+
+#endif /* _INDIRECT_VA_PRIVATE_ */
diff --git a/src/glx/x11/indirect_vertex_array.c b/src/glx/x11/indirect_vertex_array.c
new file mode 100644
index 00000000000..62a101e6656
--- /dev/null
+++ b/src/glx/x11/indirect_vertex_array.c
@@ -0,0 +1,1847 @@
+/*
+ * (C) Copyright IBM Corporation 2004, 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 <inttypes.h>
+#include <assert.h>
+#include <string.h>
+
+#include "glxclient.h"
+#include "indirect.h"
+#include <GL/glxproto.h>
+#include "glxextensions.h"
+#include "indirect_vertex_array.h"
+#include "indirect_va_private.h"
+
+#define __GLX_PAD(n) (((n)+3) & ~3)
+
+/**
+ * \file indirect_vertex_array.c
+ * Implement GLX protocol for vertex arrays and vertex buffer objects.
+ * 
+ * The most important function in this fill is \c fill_array_info_cache.
+ * The \c array_state_vector contains a cache of the ARRAY_INFO data sent
+ * in the DrawArrays protocol.  Certain operations, such as enabling or
+ * disabling an array, can invalidate this cache.  \c fill_array_info_cache
+ * fills-in this data.  Additionally, it examines the enabled state and
+ * other factors to determine what "version" of DrawArrays protocoal can be
+ * used.
+ * 
+ * Current, only two versions of DrawArrays protocol are implemented.  The
+ * first version is the "none" protocol.  This is the fallback when the
+ * server does not support GL 1.1 / EXT_vertex_arrays.  It is implemented
+ * by sending batches of immediate mode commands that are equivalent to the
+ * DrawArrays protocol.
+ *
+ * The other protocol that is currently implemented is the "old" protocol.
+ * This is the GL 1.1 DrawArrays protocol.  The only difference between GL
+ * 1.1 and EXT_vertex_arrays is the opcode used for the DrawArrays command.
+ * This protocol is called "old" because the ARB is in the process of
+ * defining a new protocol, which will probably be called wither "new" or
+ * "vbo", to support multiple texture coordinate arrays, generic attributes,
+ * and vertex buffer objects.
+ *
+ * \author Ian Romanick <[email protected]>
+ */
+
+static void emit_DrawArrays_none( GLenum mode, GLint first, GLsizei count );
+static void emit_DrawArrays_old ( GLenum mode, GLint first, GLsizei count );
+
+static void emit_DrawElements_none( GLenum mode, GLsizei count, GLenum type,
+    const GLvoid *indices );
+static void emit_DrawElements_old ( GLenum mode, GLsizei count, GLenum type,
+    const GLvoid *indices );
+
+
+static GLubyte * emit_element_none( GLubyte * dst,
+    const struct array_state_vector * arrays, unsigned index );
+static GLubyte * emit_element_old( GLubyte * dst,
+    const struct array_state_vector * arrays, unsigned index );
+static struct array_state * get_array_entry(
+    const struct array_state_vector * arrays, GLenum key, unsigned index );
+static void fill_array_info_cache( struct array_state_vector * arrays );
+static GLboolean validate_mode(__GLXcontext *gc, GLenum mode);
+static GLboolean validate_count(__GLXcontext *gc, GLsizei count);
+static GLboolean validate_type(__GLXcontext *gc, GLenum type);
+
+
+/**
+ * Table of sizes, in bytes, of a GL types.  All of the type enums are be in 
+ * the range 0x1400 - 0x140F.  That includes types added by extensions (i.e.,
+ * \c GL_HALF_FLOAT_NV).  This elements of this table correspond to the
+ * type enums masked with 0x0f.
+ * 
+ * \notes
+ * \c GL_HALF_FLOAT_NV is not included.  Neither are \c GL_2_BYTES,
+ * \c GL_3_BYTES, or \c GL_4_BYTES.
+ */
+const GLuint __glXTypeSize_table[16] = {
+    1, 1, 2, 2, 4, 4, 4, 0, 0, 0, 8, 0, 0, 0, 0, 0
+};
+
+
+
+/**
+ * Initialize vertex array state of a GLX context.
+ * 
+ * \param gc  GLX context whose vertex array state is to be initialized.
+ * 
+ * \warning
+ * This function may only be called after __GLXcontext::gl_extension_bits,
+ * __GLXcontext::server_minor, and __GLXcontext::server_major have been
+ * initialized.  These values are used to determine what vertex arrays are
+ * supported.
+ * 
+ * \bug
+ * Return values from malloc are not properly tested.
+ */
+void
+__glXInitVertexArrayState( __GLXcontext * gc )
+{
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays;
+
+    unsigned array_count;
+    unsigned texture_units = 1;
+    unsigned i;
+    unsigned j;
+    unsigned vertex_program_attribs = 0;
+
+    GLboolean got_fog = GL_FALSE;
+    GLboolean got_secondary_color = GL_FALSE;
+
+
+    arrays = calloc( 1, sizeof( struct array_state_vector ) );
+    state->array_state = arrays;
+
+    arrays->old_DrawArrays_possible = !state->NoDrawArraysProtocol;
+    arrays->new_DrawArrays_possible = GL_FALSE;
+    arrays->DrawArrays = NULL;
+
+    arrays->active_texture_unit = 0;
+
+
+    /* Determine how many arrays are actually needed.  Only arrays that
+     * are supported by the server are create.  For example, if the server
+     * supports only 2 texture units, then only 2 texture coordinate arrays
+     * are created.
+     * 
+     * At the very least, GL_VERTEX_ARRAY, GL_NORMAL_ARRAY,
+     * GL_COLOR_ARRAY, GL_INDEX_ARRAY, GL_TEXTURE_COORD_ARRAY, and
+     * GL_EDGE_FLAG_ARRAY are supported.
+     */
+
+    array_count = 5;
+    
+    if ( __glExtensionBitIsEnabled( gc, GL_EXT_fog_coord_bit )
+	 || (gc->server_major > 1) || (gc->server_minor >= 4) ) {
+	got_fog = GL_TRUE;
+	array_count++;
+    }
+
+    if ( __glExtensionBitIsEnabled( gc, GL_EXT_secondary_color_bit )
+	 || (gc->server_major > 1) || (gc->server_minor >= 4) ) {
+	got_secondary_color = GL_TRUE;
+	array_count++;
+    }
+
+    if ( __glExtensionBitIsEnabled( gc, GL_ARB_multitexture_bit )
+	 || (gc->server_major > 1) || (gc->server_minor >= 3) ) {
+	__indirect_glGetIntegerv( GL_MAX_TEXTURE_UNITS, & texture_units );
+    }
+
+    if ( __glExtensionBitIsEnabled( gc, GL_ARB_vertex_program_bit ) ) {
+	__indirect_glGetProgramivARB( GL_VERTEX_PROGRAM_ARB,
+				      GL_MAX_PROGRAM_ATTRIBS_ARB,
+				      & vertex_program_attribs );
+    }
+
+    arrays->num_texture_units = texture_units;
+    arrays->num_vertex_program_attribs = vertex_program_attribs;
+    array_count += texture_units + vertex_program_attribs;
+    arrays->num_arrays = array_count;
+    arrays->arrays = calloc( array_count, sizeof( struct array_state ) );
+
+    arrays->arrays[0].data_type = GL_FLOAT;
+    arrays->arrays[0].count = 3;
+    arrays->arrays[0].key = GL_NORMAL_ARRAY;
+    arrays->arrays[0].normalized = GL_TRUE;
+    arrays->arrays[0].old_DrawArrays_possible = GL_TRUE;
+
+    arrays->arrays[1].data_type = GL_FLOAT;
+    arrays->arrays[1].count = 4;
+    arrays->arrays[1].key = GL_COLOR_ARRAY;
+    arrays->arrays[1].normalized = GL_TRUE;
+    arrays->arrays[1].old_DrawArrays_possible = GL_TRUE;
+
+    arrays->arrays[2].data_type = GL_FLOAT;
+    arrays->arrays[2].count = 1;
+    arrays->arrays[2].key = GL_INDEX_ARRAY;
+    arrays->arrays[2].old_DrawArrays_possible = GL_TRUE;
+
+    arrays->arrays[3].data_type = GL_UNSIGNED_BYTE;
+    arrays->arrays[3].count = 1;
+    arrays->arrays[3].key = GL_EDGE_FLAG_ARRAY;
+    arrays->arrays[3].old_DrawArrays_possible = GL_TRUE;
+
+    for ( i = 0 ; i < texture_units ; i++ ) {
+	arrays->arrays[4 + i].data_type = GL_FLOAT;
+	arrays->arrays[4 + i].count = 4;
+	arrays->arrays[4 + i].key = GL_TEXTURE_COORD_ARRAY;
+
+	arrays->arrays[4 + i].old_DrawArrays_possible = (i == 0);
+	arrays->arrays[4 + i].index = i;
+
+	arrays->arrays[4 + i].header[1] = i + GL_TEXTURE0;
+    }
+    
+    i = 4 + texture_units;
+
+    if ( got_fog ) {
+	arrays->arrays[i].data_type = GL_FLOAT;
+	arrays->arrays[i].count = 1;
+	arrays->arrays[i].key = GL_FOG_COORDINATE_ARRAY;
+	arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;
+	i++;
+    }
+
+    if ( got_secondary_color ) {
+	arrays->arrays[i].data_type = GL_FLOAT;
+	arrays->arrays[i].count = 3;
+	arrays->arrays[i].key = GL_SECONDARY_COLOR_ARRAY;
+	arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;
+	arrays->arrays[i].normalized = GL_TRUE;
+	i++;
+    }
+
+
+    for ( j = 0 ; j < vertex_program_attribs ; j++ ) {
+	const unsigned idx = (vertex_program_attribs - (j + 1));
+
+
+	arrays->arrays[idx + i].data_type = GL_FLOAT;
+	arrays->arrays[idx + i].count = 4;
+	arrays->arrays[idx + i].key = GL_VERTEX_ATTRIB_ARRAY_POINTER;
+
+	arrays->arrays[idx + i].old_DrawArrays_possible = 0;
+	arrays->arrays[idx + i].index = idx;
+
+	arrays->arrays[idx + i].header[1] = idx;
+    }
+
+    i += vertex_program_attribs;
+
+
+    /* Vertex array *must* be last becuase of the way that
+     * emit_DrawArrays_none works.
+     */
+
+    arrays->arrays[i].data_type = GL_FLOAT;
+    arrays->arrays[i].count = 4;
+    arrays->arrays[i].key = GL_VERTEX_ARRAY;
+    arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;
+
+    assert( (i + 1) == arrays->num_arrays );
+
+    arrays->stack_index = 0;
+    arrays->stack = malloc( sizeof( struct array_stack_state )
+			    * arrays->num_arrays );
+}
+
+
+/**
+ * Calculate the size of a single vertex for the "none" protocol.  This is
+ * essentially the size of all the immediate-mode commands required to
+ * implement the enabled vertex arrays.
+ */
+static size_t
+calculate_single_vertex_size_none( const struct array_state_vector * arrays )
+{
+    size_t single_vertex_size = 0;
+    unsigned   i;
+
+
+    for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
+    	if ( arrays->arrays[i].enabled ) {
+	    single_vertex_size += ((uint16_t *)arrays->arrays[i].header)[0];
+	}
+    }
+    
+    return single_vertex_size;
+}
+
+
+/**
+ * Emit a single element using non-DrawArrays protocol.
+ */
+GLubyte *
+emit_element_none( GLubyte * dst,
+		   const struct array_state_vector * arrays,
+		   unsigned index )
+{
+    unsigned i;
+
+
+    for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
+	if ( arrays->arrays[i].enabled ) {
+	    const size_t offset = index * arrays->arrays[i].true_stride;
+
+	    /* The generic attributes can have more data than is in the
+	     * elements.  This is because a vertex array can be a 2 element,
+	     * normalized, unsigned short, but the "closest" immediate mode
+	     * protocol is for a 4Nus.  Since the sizes are small, the
+	     * performance impact on modern processors should be negligible.
+	     */
+	    (void) memset( dst, 0,
+			   ((uint16_t *)arrays->arrays[i].header)[0] );
+
+	    (void) memcpy( dst, arrays->arrays[i].header, 
+			   arrays->arrays[i].header_size );
+
+	    dst += arrays->arrays[i].header_size;
+
+	    (void) memcpy( dst, ((GLubyte *) arrays->arrays[i].data) + offset,
+			   arrays->arrays[i].element_size );
+
+	    dst += __GLX_PAD( arrays->arrays[i].element_size );
+	}
+    }
+
+    return dst;
+}
+
+
+/**
+ * Emit a single element using "old" DrawArrays protocol from
+ * EXT_vertex_arrays / OpenGL 1.1.
+ */
+GLubyte *
+emit_element_old( GLubyte * dst,
+		  const struct array_state_vector * arrays,
+		  unsigned index )
+{
+    unsigned i;
+
+
+    for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
+	if ( arrays->arrays[i].enabled ) {
+	    const size_t offset = index * arrays->arrays[i].true_stride;
+
+	    (void) memcpy( dst, ((GLubyte *) arrays->arrays[i].data) + offset,
+			   arrays->arrays[i].element_size );
+
+	    dst += __GLX_PAD( arrays->arrays[i].element_size );
+	}
+    }
+
+    return dst;
+}
+
+
+struct array_state *
+get_array_entry( const struct array_state_vector * arrays,
+		 GLenum key, unsigned index )
+{
+    unsigned  i;
+
+    for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
+	if ( (arrays->arrays[i].key == key)
+	     && (arrays->arrays[i].index == index) ) {
+	    return & arrays->arrays[i];
+	}
+    }
+    
+    return NULL;
+}
+
+
+static GLboolean
+allocate_array_info_cache( struct array_state_vector * arrays,
+			   size_t required_size )
+{
+#define MAX_HEADER_SIZE 20
+    if ( arrays->array_info_cache_buffer_size < required_size ) {
+	GLubyte * temp = realloc( arrays->array_info_cache_base,
+				  required_size + MAX_HEADER_SIZE );
+
+	if ( temp == NULL ) {
+	    return GL_FALSE;
+	}
+
+	arrays->array_info_cache_base = temp;
+	arrays->array_info_cache = temp + MAX_HEADER_SIZE;
+	arrays->array_info_cache_buffer_size = required_size;
+    }
+
+    arrays->array_info_cache_size = required_size;
+    return GL_TRUE;
+}
+
+
+/**
+ */
+void
+fill_array_info_cache( struct array_state_vector * arrays )
+{
+    GLboolean old_DrawArrays_possible;
+    unsigned  i;
+
+
+    /* Determine how many arrays are enabled.
+     */
+
+    arrays->enabled_client_array_count = 0;
+    old_DrawArrays_possible = arrays->old_DrawArrays_possible;
+    for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
+	if ( arrays->arrays[i].enabled ) {
+	    arrays->enabled_client_array_count++;
+	    old_DrawArrays_possible &= arrays->arrays[i].old_DrawArrays_possible;
+	}
+    }
+    
+    
+    if ( arrays->new_DrawArrays_possible ) {
+	assert( ! arrays->new_DrawArrays_possible );
+    }
+    else if ( old_DrawArrays_possible ) {
+	const size_t required_size = arrays->enabled_client_array_count * 12;
+	uint32_t * info;
+
+
+	if ( ! allocate_array_info_cache( arrays, required_size ) ) {
+	    return;
+	}
+
+
+	info = (uint32_t *) arrays->array_info_cache;
+	for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
+	    if ( arrays->arrays[i].enabled ) {
+		*(info++) = arrays->arrays[i].data_type;
+		*(info++) = arrays->arrays[i].count;
+		*(info++) = arrays->arrays[i].key;
+	    }
+	}
+
+	arrays->DrawArrays = emit_DrawArrays_old;
+	arrays->DrawElements = emit_DrawElements_old;
+    }
+    else {
+	arrays->DrawArrays = emit_DrawArrays_none;
+	arrays->DrawElements = emit_DrawElements_none;
+    }
+
+    arrays->array_info_cache_valid = GL_TRUE;
+}
+
+
+/**
+ * Emit a \c glDrawArrays command using the "none" protocol.  That is,
+ * emit immediate-mode commands that are equivalent to the requiested
+ * \c glDrawArrays command.  This is used with servers that don't support
+ * the OpenGL 1.1 / EXT_vertex_arrays DrawArrays protocol or in cases where
+ * vertex state is enabled that is not compatible with that protocol.
+ */
+void
+emit_DrawArrays_none( GLenum mode, GLint first, GLsizei count )
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    const __GLXattribute * state = 
+       (const __GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+
+    size_t single_vertex_size;
+    GLubyte * pc;
+    unsigned  i;
+    static const uint16_t begin_cmd[2] = { 8, X_GLrop_Begin };
+    static const uint16_t end_cmd[2]   = { 4, X_GLrop_End };
+
+
+    single_vertex_size = calculate_single_vertex_size_none( arrays );
+
+    pc = gc->pc;
+
+    (void) memcpy( pc, begin_cmd, 4 );
+    *(int *)(pc +  4) = mode;
+
+    pc += 8;
+
+    for ( i = 0 ; i < count ; i++ ) {
+	if ( (pc + single_vertex_size) >= gc->bufEnd ) {
+	    pc = __glXFlushRenderBuffer(gc, gc->pc);
+	}
+
+	pc = emit_element_none( pc, arrays, first + i );
+    }
+
+    if ( (pc + 4) >= gc->bufEnd ) {
+	pc = __glXFlushRenderBuffer(gc, gc->pc);
+    }
+
+    (void) memcpy( pc, end_cmd, 4 );
+    pc += 4;
+
+    gc->pc = pc;
+    if ( gc->pc > gc->limit ) {
+	(void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
+}
+
+
+/**
+ * Emit the header data for the GL 1.1 / EXT_vertex_arrays DrawArrays
+ * protocol.
+ * 
+ * \param gc                    GLX context.
+ * \param arrays                Array state.
+ * \param elements_per_request  Location to store the number of elements that
+ *                              can fit in a single Render / RenderLarge
+ *                              command.
+ * \param total_request         Total number of requests for a RenderLarge
+ *                              command.  If a Render command is used, this
+ *                              will be zero.
+ * \param mode                  Drawing mode.
+ * \param count                 Number of vertices.
+ * 
+ * \returns
+ * A pointer to the buffer for array data.
+ */
+static GLubyte *
+emit_DrawArrays_header_old( __GLXcontext * gc,
+			    struct array_state_vector * arrays,
+			    size_t * elements_per_request,
+			    size_t * total_requests,
+			    GLenum mode, GLsizei count )
+{
+    size_t command_size;
+    size_t single_vertex_size;
+    const unsigned header_size = 16;
+    unsigned  i;
+    GLubyte * pc;
+
+
+    /* Determine the size of the whole command.  This includes the header,
+     * the ARRAY_INFO data and the array data.  Once this size is calculated,
+     * it will be known whether a Render or RenderLarge command is needed.
+     */
+
+    single_vertex_size = 0;
+    for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
+	if ( arrays->arrays[i].enabled ) {
+	    single_vertex_size += __GLX_PAD( arrays->arrays[i].element_size );
+	}
+    }
+
+    command_size = arrays->array_info_cache_size + header_size 
+      + (single_vertex_size * count);
+
+
+    /* Write the header for either a Render command or a RenderLarge
+     * command.  After the header is written, write the ARRAY_INFO data.
+     */
+
+    if ( command_size > gc->maxSmallRenderCommandSize ) {
+	/* maxSize is the maximum amount of data can be stuffed into a single
+	 * packet.  sz_xGLXRenderReq is added because bufSize is the maximum
+	 * packet size minus sz_xGLXRenderReq.
+	 */
+	const size_t maxSize = (gc->bufSize + sz_xGLXRenderReq)
+	  - sz_xGLXRenderLargeReq;
+	unsigned vertex_requests;
+
+
+	/* Calculate the number of data packets that will be required to send
+	 * the whole command.  To do this, the number of verticies that
+	 * will fit in a single buffer must be calculated.
+	 * 
+	 * The important value here is elements_per_request.  This is the
+	 * number of complete array elements that will fit in a single
+	 * buffer.  There may be some wasted space at the end of the buffer,
+	 * but splitting elements across buffer boundries would be painful.
+	 */
+
+	elements_per_request[0] = maxSize / single_vertex_size;
+
+	vertex_requests = (count + elements_per_request[0] - 1)
+	  / elements_per_request[0];
+	  
+	*total_requests = vertex_requests + 1;
+
+
+	__glXFlushRenderBuffer(gc, gc->pc);
+
+	command_size += 4;
+
+	pc = ((GLubyte *) arrays->array_info_cache) - (header_size + 4);
+	*(uint32_t *)(pc +  0) = command_size;
+	*(uint32_t *)(pc +  4) = X_GLrop_DrawArrays;
+	*(uint32_t *)(pc +  8) = count;
+	*(uint32_t *)(pc + 12) = arrays->enabled_client_array_count;
+	*(uint32_t *)(pc + 16) = mode;
+
+	__glXSendLargeChunk( gc, 1, *total_requests, pc,
+			     header_size + 4 + arrays->array_info_cache_size );
+
+	pc = gc->pc;
+    }
+    else {
+	if ( (gc->pc + command_size) >= gc->bufEnd ) {
+	    (void) __glXFlushRenderBuffer(gc, gc->pc);
+	}
+
+	pc = gc->pc;
+	*(uint16_t *)(pc +  0) = command_size;
+	*(uint16_t *)(pc +  2) = X_GLrop_DrawArrays;
+	*(uint32_t *)(pc +  4) = count;
+	*(uint32_t *)(pc +  8) = arrays->enabled_client_array_count;
+	*(uint32_t *)(pc + 12) = mode;
+
+	pc += header_size;
+
+	(void) memcpy( pc, arrays->array_info_cache,
+		       arrays->array_info_cache_size );
+	pc += arrays->array_info_cache_size;
+
+	*elements_per_request = count;
+	*total_requests = 0;
+    }
+
+
+    return pc;
+}
+
+
+/**
+ */
+void
+emit_DrawArrays_old( GLenum mode, GLint first, GLsizei count )
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    const __GLXattribute * state = 
+       (const __GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+
+    GLubyte * pc;
+    size_t elements_per_request;
+    unsigned total_requests = 0;
+    unsigned i;
+    size_t total_sent = 0;
+
+
+    pc = emit_DrawArrays_header_old( gc, arrays, & elements_per_request,
+				     & total_requests, mode, count);
+
+    
+    /* Write the arrays.
+     */
+
+    if ( total_requests == 0 ) {
+	assert( elements_per_request >= count );
+
+	for ( i = 0 ; i < count ; i++ ) {
+	    pc = emit_element_old( pc, arrays, i + first );
+	}
+
+	assert( pc <= gc->bufEnd );
+
+	gc->pc = pc;
+	if ( gc->pc > gc->limit ) {
+	    (void) __glXFlushRenderBuffer(gc, gc->pc);
+	}
+    }
+    else {
+	unsigned req;
+
+
+	for ( req = 2 ; req <= total_requests ; req++ ) {
+	    if ( count < elements_per_request ) {
+		elements_per_request = count;
+	    }
+
+	    pc = gc->pc;
+	    for ( i = 0 ; i < elements_per_request ; i++ ) {
+		pc = emit_element_old( pc, arrays, i + first );
+	    }
+
+	    first += elements_per_request;
+
+	    total_sent += (size_t) (pc - gc->pc);
+	    __glXSendLargeChunk( gc, req, total_requests, gc->pc,
+				 pc - gc->pc );
+
+	    count -= elements_per_request;
+	}
+    }
+}
+
+
+void
+emit_DrawElements_none( GLenum mode, GLsizei count, GLenum type,
+			const GLvoid *indices )
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    const __GLXattribute * state = 
+       (const __GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+    static const uint16_t begin_cmd[2] = { 8, X_GLrop_Begin };
+    static const uint16_t end_cmd[2]   = { 4, X_GLrop_End };
+
+    GLubyte * pc;
+    size_t single_vertex_size;
+    unsigned  i;
+
+
+    single_vertex_size = calculate_single_vertex_size_none( arrays );
+
+
+    if ( (gc->pc + single_vertex_size) >= gc->bufEnd ) {
+	gc->pc = __glXFlushRenderBuffer(gc, gc->pc);
+    }
+
+    pc = gc->pc;
+
+    (void) memcpy( pc, begin_cmd, 4 );
+    *(int *)(pc +  4) = mode;
+
+    pc += 8;
+
+    for ( i = 0 ; i < count ; i++ ) {
+	unsigned  index = 0;
+
+	if ( (pc + single_vertex_size) >= gc->bufEnd ) {
+	    pc = __glXFlushRenderBuffer(gc, gc->pc);
+	}
+
+	switch( type ) {
+	case GL_UNSIGNED_INT:
+	    index = (unsigned) (((GLuint *) indices)[i]);
+	    break;
+	case GL_UNSIGNED_SHORT:
+	    index = (unsigned) (((GLushort *) indices)[i]);
+	    break;
+	case GL_UNSIGNED_BYTE:
+	    index = (unsigned) (((GLubyte *) indices)[i]);
+	    break;
+	}
+	pc = emit_element_none( pc, arrays, index );
+    }
+
+    if ( (pc + 4) >= gc->bufEnd ) {
+	pc = __glXFlushRenderBuffer(gc, gc->pc);
+    }
+
+    (void) memcpy( pc, end_cmd, 4 );
+    pc += 4;
+
+    gc->pc = pc;
+    if ( gc->pc > gc->limit ) {
+	(void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
+}
+
+
+/**
+ */
+void
+emit_DrawElements_old( GLenum mode, GLsizei count, GLenum type,
+		       const GLvoid *indices )
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    const __GLXattribute * state = 
+       (const __GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+
+    GLubyte * pc;
+    size_t elements_per_request;
+    unsigned total_requests = 0;
+    unsigned i;
+    unsigned req;
+
+
+    pc = emit_DrawArrays_header_old( gc, arrays, & elements_per_request,
+				     & total_requests, mode, count);
+
+    
+    /* Write the arrays.
+     */
+
+    req = 2;
+    while ( count > 0 ) {
+	if ( count < elements_per_request ) {
+	    elements_per_request = count;
+	}
+
+	switch( type ) {
+	case GL_UNSIGNED_INT: {
+	    const GLuint   * ui_ptr = (const GLuint   *) indices;
+
+	    for ( i = 0 ; i < elements_per_request ; i++ ) {
+		const GLint index = (GLint) *(ui_ptr++);
+		pc = emit_element_old( pc, arrays, index );
+	    }
+	    break;
+	}
+	case GL_UNSIGNED_SHORT: {
+	    const GLushort * us_ptr = (const GLushort *) indices;
+
+	    for ( i = 0 ; i < elements_per_request ; i++ ) {
+		const GLint index = (GLint) *(us_ptr++);
+		pc = emit_element_old( pc, arrays, index );
+	    }
+	    break;
+	}
+	case GL_UNSIGNED_BYTE: {
+	    const GLubyte  * ub_ptr = (const GLubyte  *) indices;
+
+	    for ( i = 0 ; i < elements_per_request ; i++ ) {
+		const GLint index = (GLint) *(ub_ptr++);
+		pc = emit_element_old( pc, arrays, index );
+	    }
+	    break;
+	}
+	}
+
+	if ( total_requests != 0 ) {
+	    __glXSendLargeChunk( gc, req, total_requests, gc->pc,
+				 pc - gc->pc );
+	    pc = gc->pc;
+	    req++;
+	}
+
+	count -= elements_per_request;
+    }
+
+
+    assert( (total_requests == 0) || ((req - 1) == total_requests) );
+
+    if ( total_requests == 0 ) {
+	assert( pc <= gc->bufEnd );
+
+	gc->pc = pc;
+	if ( gc->pc > gc->limit ) {
+	    (void) __glXFlushRenderBuffer(gc, gc->pc);
+	}
+    }
+}
+
+
+/**
+ * Validate that the \c mode parameter to \c glDrawArrays, et. al. is valid.
+ * If it is not valid, then an error code is set in the GLX context.
+ * 
+ * \returns
+ * \c GL_TRUE if the argument is valid, \c GL_FALSE if is not.
+ */
+static GLboolean
+validate_mode(__GLXcontext *gc, GLenum mode)
+{
+    switch(mode) {
+      case GL_POINTS:
+      case GL_LINE_STRIP:
+      case GL_LINE_LOOP:
+      case GL_LINES:
+      case GL_TRIANGLE_STRIP:
+      case GL_TRIANGLE_FAN:
+      case GL_TRIANGLES:
+      case GL_QUAD_STRIP:
+      case GL_QUADS:
+      case GL_POLYGON:
+	break;
+      default:
+        __glXSetError(gc, GL_INVALID_ENUM);
+        return GL_FALSE;
+    }
+    
+    return GL_TRUE;
+}
+
+
+/**
+ * Validate that the \c count parameter to \c glDrawArrays, et. al. is valid.
+ * A value less than zero is invalid and will result in \c GL_INVALID_VALUE
+ * being set.  A value of zero will not result in an error being set, but
+ * will result in \c GL_FALSE being returned.
+ * 
+ * \returns
+ * \c GL_TRUE if the argument is valid, \c GL_FALSE if it is not.
+ */
+static GLboolean
+validate_count(__GLXcontext *gc, GLsizei count)
+{
+    if (count < 0) {
+	__glXSetError(gc, GL_INVALID_VALUE);
+    }
+
+    return (count > 0);
+}
+
+
+/**
+ * Validate that the \c type parameter to \c glDrawElements, et. al. is
+ * valid.  Only \c GL_UNSIGNED_BYTE, \c GL_UNSIGNED_SHORT, and
+ * \c GL_UNSIGNED_INT are valid.
+ *
+ * \returns
+ * \c GL_TRUE if the argument is valid, \c GL_FALSE if it is not.
+ */
+static GLboolean validate_type(__GLXcontext *gc, GLenum type)
+{
+    switch( type ) {
+    case GL_UNSIGNED_INT:
+    case GL_UNSIGNED_SHORT:
+    case GL_UNSIGNED_BYTE:
+	return GL_TRUE;
+     default:
+	__glXSetError(gc, GL_INVALID_ENUM);
+	return GL_FALSE;
+    }
+}
+
+
+void __indirect_glDrawArrays(GLenum mode, GLint first, GLsizei count)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    const __GLXattribute * state = 
+       (const __GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+    
+
+    if ( validate_mode(gc, mode) && validate_count(gc, count) ) {
+	if ( ! arrays->array_info_cache_valid ) {
+	    fill_array_info_cache( arrays );
+	}
+
+	arrays->DrawArrays(mode, first, count);
+    }
+}
+
+
+void __indirect_glArrayElement(GLint index)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    const __GLXattribute * state = 
+       (const __GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+
+    size_t single_vertex_size;
+
+
+    single_vertex_size = calculate_single_vertex_size_none( arrays );
+
+    if ( (gc->pc + single_vertex_size) >= gc->bufEnd ) {
+	gc->pc = __glXFlushRenderBuffer(gc, gc->pc);
+    }
+
+    gc->pc = emit_element_none( gc->pc, arrays, index );
+
+    if ( gc->pc > gc->limit ) {
+	(void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
+}
+
+
+void __indirect_glDrawElements(GLenum mode, GLsizei count, GLenum type,
+		    const GLvoid *indices)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    const __GLXattribute * state = 
+       (const __GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+
+
+    if ( validate_mode(gc, mode) && validate_count(gc, count)
+	 && validate_type(gc, type) ) {
+	if ( ! arrays->array_info_cache_valid ) {
+	    fill_array_info_cache( arrays );
+	}
+
+	arrays->DrawElements(mode, count, type, indices);
+    }
+}
+
+
+void __indirect_glDrawRangeElements(GLenum mode, GLuint start, GLuint end,
+				    GLsizei count, GLenum type,
+				    const GLvoid *indices)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    const __GLXattribute * state = 
+       (const __GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+
+
+    if ( validate_mode(gc, mode) && validate_count(gc, count)
+	 && validate_type(gc, type) ) {
+	if (end < start) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+
+	if ( ! arrays->array_info_cache_valid ) {
+	    fill_array_info_cache( arrays );
+	}
+
+	arrays->DrawElements(mode, count, type, indices);
+    }
+}
+
+
+void __indirect_glMultiDrawArraysEXT(GLenum mode, GLint *first, GLsizei *count,
+		       GLsizei primcount)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    const __GLXattribute * state = 
+       (const __GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+    GLsizei  i;
+
+
+    if ( validate_mode(gc, mode) ) {
+	if ( ! arrays->array_info_cache_valid ) {
+	    fill_array_info_cache( arrays );
+	}
+
+	for ( i = 0 ; i < primcount ; i++ ) {
+	    if ( validate_count( gc, count[i] ) ) {
+		arrays->DrawArrays(mode, first[i], count[i]);
+	    }
+	}
+    }
+}
+
+
+void __indirect_glMultiDrawElementsEXT(GLenum mode, const GLsizei *count,
+			 GLenum type, const GLvoid ** indices,
+			 GLsizei primcount)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    const __GLXattribute * state = 
+       (const __GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+    GLsizei  i;
+
+
+    if ( validate_mode(gc, mode) && validate_type(gc, type) ) {
+	if ( ! arrays->array_info_cache_valid ) {
+	    fill_array_info_cache( arrays );
+	}
+
+	for ( i = 0 ; i < primcount ; i++ ) {
+	    if ( validate_count( gc, count[i] ) ) {
+		arrays->DrawElements(mode, count[i], type, indices[i]);
+	    }
+	}
+    }
+}
+
+
+#define COMMON_ARRAY_DATA_INIT(a, PTR, TYPE, STRIDE, COUNT, NORMALIZED, HDR_SIZE, OPCODE) \
+    do { \
+	(a)->data = PTR; \
+	(a)->data_type = TYPE; \
+	(a)->user_stride = STRIDE; \
+	(a)->count = COUNT; \
+	(a)->normalized = NORMALIZED; \
+	\
+	(a)->element_size = __glXTypeSize( TYPE ) * COUNT; \
+	(a)->true_stride = (STRIDE == 0) \
+	  ? (a)->element_size : STRIDE; \
+	\
+	(a)->header_size = HDR_SIZE; \
+	((uint16_t *) (a)->header)[0] = __GLX_PAD((a)->header_size + (a)->element_size); \
+	((uint16_t *) (a)->header)[1] = OPCODE; \
+    } while(0)
+
+
+void __indirect_glVertexPointer( GLint size, GLenum type, GLsizei stride,
+				 const GLvoid * pointer )
+{
+    static const uint16_t short_ops[5] = {
+	0, 0, X_GLrop_Vertex2sv, X_GLrop_Vertex3sv, X_GLrop_Vertex4sv
+    };
+    static const uint16_t int_ops[5] = {
+	0, 0, X_GLrop_Vertex2iv, X_GLrop_Vertex3iv, X_GLrop_Vertex4iv
+    };
+    static const uint16_t float_ops[5] = {
+	0, 0, X_GLrop_Vertex2fv, X_GLrop_Vertex3fv, X_GLrop_Vertex4fv
+    };
+    static const uint16_t double_ops[5] = {
+	0, 0, X_GLrop_Vertex2dv, X_GLrop_Vertex3dv, X_GLrop_Vertex4dv
+    };
+    uint16_t opcode;
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+    struct array_state * a;
+
+
+    if (size < 2 || size > 4 || stride < 0) {
+        __glXSetError(gc, GL_INVALID_VALUE);
+        return;
+    }
+    
+    switch ( type ) {
+    case GL_SHORT:	opcode = short_ops[size]; break;
+    case GL_INT:	opcode = int_ops[size]; break;
+    case GL_FLOAT:	opcode = float_ops[size]; break;
+    case GL_DOUBLE:	opcode = double_ops[size]; break;
+    default:
+        __glXSetError(gc, GL_INVALID_ENUM);
+        return;
+    }
+
+    a = get_array_entry( arrays, GL_VERTEX_ARRAY, 0 );
+    assert( a != NULL );
+    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, GL_FALSE, 4,
+			    opcode );
+
+    if ( a->enabled ) {
+	arrays->array_info_cache_valid = GL_FALSE;
+    }
+}
+
+
+void __indirect_glNormalPointer( GLenum type, GLsizei stride,
+				 const GLvoid * pointer )
+{
+    uint16_t opcode;
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+    struct array_state * a;
+
+
+    if (stride < 0) {
+        __glXSetError(gc, GL_INVALID_VALUE);
+        return;
+    }
+
+    switch ( type ) {
+    case GL_BYTE:	opcode = X_GLrop_Normal3bv; break;
+    case GL_SHORT:	opcode = X_GLrop_Normal3sv; break;
+    case GL_INT:	opcode = X_GLrop_Normal3iv; break;
+    case GL_FLOAT:	opcode = X_GLrop_Normal3fv; break;
+    case GL_DOUBLE:	opcode = X_GLrop_Normal3dv; break;
+    default:
+        __glXSetError(gc, GL_INVALID_ENUM);
+        return;
+    }
+
+    a = get_array_entry( arrays, GL_NORMAL_ARRAY, 0 );
+    assert( a != NULL );
+    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, 3, GL_TRUE, 4,
+			    opcode );
+
+    if ( a->enabled ) {
+	arrays->array_info_cache_valid = GL_FALSE;
+    }
+}
+
+
+void __indirect_glColorPointer( GLint size, GLenum type, GLsizei stride,
+				const GLvoid * pointer )
+{
+    static const uint16_t byte_ops[5] = {
+	0, 0, 0, X_GLrop_Color3bv, X_GLrop_Color4bv
+    };
+    static const uint16_t ubyte_ops[5] = {
+	0, 0, 0, X_GLrop_Color3ubv, X_GLrop_Color4ubv
+    };
+    static const uint16_t short_ops[5] = {
+	0, 0, 0, X_GLrop_Color3sv, X_GLrop_Color4sv
+    };
+    static const uint16_t ushort_ops[5] = {
+	0, 0, 0, X_GLrop_Color3usv, X_GLrop_Color4usv
+    };
+    static const uint16_t int_ops[5] = {
+	0, 0, 0, X_GLrop_Color3iv, X_GLrop_Color4iv
+    };
+    static const uint16_t uint_ops[5] = {
+	0, 0, 0, X_GLrop_Color3uiv, X_GLrop_Color4uiv
+    };
+    static const uint16_t float_ops[5] = {
+	0, 0, 0, X_GLrop_Color3fv, X_GLrop_Color4fv
+    };
+    static const uint16_t double_ops[5] = {
+	0, 0, 0, X_GLrop_Color3dv, X_GLrop_Color4dv
+    };
+    uint16_t opcode;
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+    struct array_state * a;
+
+
+    if (size < 3 || size > 4 || stride < 0) {
+        __glXSetError(gc, GL_INVALID_VALUE);
+        return;
+    }
+    
+    switch ( type ) {
+    case GL_BYTE:		opcode = byte_ops[size]; break;
+    case GL_UNSIGNED_BYTE:	opcode = ubyte_ops[size]; break;
+    case GL_SHORT:		opcode = short_ops[size]; break;
+    case GL_UNSIGNED_SHORT:	opcode = ushort_ops[size]; break;
+    case GL_INT:		opcode = int_ops[size]; break;
+    case GL_UNSIGNED_INT:	opcode = uint_ops[size]; break;
+    case GL_FLOAT:		opcode = float_ops[size]; break;
+    case GL_DOUBLE:		opcode = double_ops[size]; break;
+    default:
+        __glXSetError(gc, GL_INVALID_ENUM);
+        return;
+    }
+
+    a = get_array_entry( arrays, GL_COLOR_ARRAY, 0 );
+    assert( a != NULL );
+    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, GL_TRUE, 4,
+			    opcode );
+
+    if ( a->enabled ) {
+	arrays->array_info_cache_valid = GL_FALSE;
+    }
+}
+
+
+void __indirect_glIndexPointer( GLenum type, GLsizei stride,
+				const GLvoid * pointer )
+{
+    uint16_t opcode;
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+    struct array_state * a;
+
+
+    if (stride < 0) {
+        __glXSetError(gc, GL_INVALID_VALUE);
+        return;
+    }
+    
+    switch ( type ) {
+    case GL_UNSIGNED_BYTE:	opcode = X_GLrop_Indexubv; break;
+    case GL_SHORT:		opcode = X_GLrop_Indexsv; break;
+    case GL_INT:		opcode = X_GLrop_Indexiv; break;
+    case GL_FLOAT:		opcode = X_GLrop_Indexfv; break;
+    case GL_DOUBLE:		opcode = X_GLrop_Indexdv; break;
+    default:
+        __glXSetError(gc, GL_INVALID_ENUM);
+        return;
+    }
+
+    a = get_array_entry( arrays, GL_INDEX_ARRAY, 0 );
+    assert( a != NULL );
+    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, 1, GL_FALSE, 4,
+			    opcode );
+
+    if ( a->enabled ) {
+	arrays->array_info_cache_valid = GL_FALSE;
+    }
+}
+
+
+void __indirect_glEdgeFlagPointer( GLsizei stride, const GLvoid * pointer )
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+    struct array_state * a;
+
+
+    if (stride < 0) {
+        __glXSetError(gc, GL_INVALID_VALUE);
+        return;
+    }
+    
+
+    a = get_array_entry( arrays, GL_EDGE_FLAG_ARRAY, 0 );
+    assert( a != NULL );
+    COMMON_ARRAY_DATA_INIT( a, pointer, GL_UNSIGNED_BYTE, stride, 1, GL_FALSE,
+			    4, X_GLrop_EdgeFlagv );
+
+    if ( a->enabled ) {
+	arrays->array_info_cache_valid = GL_FALSE;
+    }
+}
+
+
+void __indirect_glTexCoordPointer( GLint size, GLenum type, GLsizei stride,
+				   const GLvoid * pointer )
+{
+    static const uint16_t short_ops[5] = {
+	0, X_GLrop_TexCoord1sv, X_GLrop_TexCoord2sv, X_GLrop_TexCoord3sv, X_GLrop_TexCoord4sv
+    };
+    static const uint16_t int_ops[5] = {
+	0, X_GLrop_TexCoord1iv, X_GLrop_TexCoord2iv, X_GLrop_TexCoord3iv, X_GLrop_TexCoord4iv
+    };
+    static const uint16_t float_ops[5] = {
+	0, X_GLrop_TexCoord1dv, X_GLrop_TexCoord2fv, X_GLrop_TexCoord3fv, X_GLrop_TexCoord4fv
+    };
+    static const uint16_t double_ops[5] = {
+	0, X_GLrop_TexCoord1dv, X_GLrop_TexCoord2dv, X_GLrop_TexCoord3dv, X_GLrop_TexCoord4dv
+    };
+
+    static const uint16_t mshort_ops[5] = {
+	0, X_GLrop_MultiTexCoord1svARB, X_GLrop_MultiTexCoord2svARB, X_GLrop_MultiTexCoord3svARB, X_GLrop_MultiTexCoord4svARB
+    };
+    static const uint16_t mint_ops[5] = {
+	0, X_GLrop_MultiTexCoord1ivARB, X_GLrop_MultiTexCoord2ivARB, X_GLrop_MultiTexCoord3ivARB, X_GLrop_MultiTexCoord4ivARB
+    };
+    static const uint16_t mfloat_ops[5] = {
+	0, X_GLrop_MultiTexCoord1dvARB, X_GLrop_MultiTexCoord2fvARB, X_GLrop_MultiTexCoord3fvARB, X_GLrop_MultiTexCoord4fvARB
+    };
+    static const uint16_t mdouble_ops[5] = {
+	0, X_GLrop_MultiTexCoord1dvARB, X_GLrop_MultiTexCoord2dvARB, X_GLrop_MultiTexCoord3dvARB, X_GLrop_MultiTexCoord4dvARB
+    };
+
+    uint16_t opcode;
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+    struct array_state * a;
+    unsigned header_size;
+    unsigned index;
+
+
+    if (size < 1 || size > 4 || stride < 0) {
+        __glXSetError(gc, GL_INVALID_VALUE);
+        return;
+    }
+    
+    index = arrays->active_texture_unit;
+    if ( index == 0 ) {
+	switch ( type ) {
+	case GL_SHORT:		opcode = short_ops[size]; break;
+	case GL_INT:		opcode = int_ops[size]; break;
+	case GL_FLOAT:		opcode = float_ops[size]; break;
+	case GL_DOUBLE:		opcode = double_ops[size]; break;
+	default:
+	    __glXSetError(gc, GL_INVALID_ENUM);
+	    return;
+	}
+
+	header_size = 4;
+    }
+    else {
+	switch ( type ) {
+	case GL_SHORT:		opcode = mshort_ops[size]; break;
+	case GL_INT:		opcode = mint_ops[size]; break;
+	case GL_FLOAT:		opcode = mfloat_ops[size]; break;
+	case GL_DOUBLE:		opcode = mdouble_ops[size]; break;
+	default:
+	    __glXSetError(gc, GL_INVALID_ENUM);
+	    return;
+	}
+
+	header_size = 8;
+    }
+
+    a = get_array_entry( arrays, GL_TEXTURE_COORD_ARRAY, index );
+    assert( a != NULL );
+    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, GL_FALSE,
+			    header_size, opcode );
+
+    if ( a->enabled ) {
+	arrays->array_info_cache_valid = GL_FALSE;
+    }
+}
+
+
+void __indirect_glSecondaryColorPointerEXT( GLint size, GLenum type, GLsizei stride,
+				const GLvoid * pointer )
+{
+    uint16_t opcode;
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+    struct array_state * a;
+
+
+    if (size != 3 || stride < 0) {
+        __glXSetError(gc, GL_INVALID_VALUE);
+        return;
+    }
+    
+    switch ( type ) {
+    case GL_BYTE:		opcode = 4126; break;
+    case GL_UNSIGNED_BYTE:	opcode = 4131; break;
+    case GL_SHORT:		opcode = 4127; break;
+    case GL_UNSIGNED_SHORT:	opcode = 4132; break;
+    case GL_INT:		opcode = 4128; break;
+    case GL_UNSIGNED_INT:	opcode = 4133; break;
+    case GL_FLOAT:		opcode = 4129; break;
+    case GL_DOUBLE:		opcode = 4130; break;
+    default:
+        __glXSetError(gc, GL_INVALID_ENUM);
+        return;
+    }
+
+    a = get_array_entry( arrays, GL_SECONDARY_COLOR_ARRAY, 0 );
+    if ( a == NULL ) {
+        __glXSetError(gc, GL_INVALID_OPERATION);
+        return;
+    }
+
+    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, GL_TRUE, 4,
+			    opcode );
+
+    if ( a->enabled ) {
+	arrays->array_info_cache_valid = GL_FALSE;
+    }
+}
+
+
+void __indirect_glFogCoordPointerEXT( GLenum type, GLsizei stride,
+				const GLvoid * pointer )
+{
+    uint16_t opcode;
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+    struct array_state * a;
+
+
+    if (stride < 0) {
+        __glXSetError(gc, GL_INVALID_VALUE);
+        return;
+    }
+
+    switch ( type ) {
+    case GL_FLOAT:		opcode = 4124; break;
+    case GL_DOUBLE:		opcode = 4125; break;
+    default:
+        __glXSetError(gc, GL_INVALID_ENUM);
+        return;
+    }
+
+    a = get_array_entry( arrays, GL_FOG_COORD_ARRAY, 0 );
+    if ( a == NULL ) {
+        __glXSetError(gc, GL_INVALID_OPERATION);
+        return;
+    }
+
+    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, 1, GL_FALSE, 4,
+			    opcode );
+
+    if ( a->enabled ) {
+	arrays->array_info_cache_valid = GL_FALSE;
+    }
+}
+
+
+void __indirect_glVertexAttribPointerARB(GLuint index, GLint size,
+					 GLenum type, GLboolean normalized,
+					 GLsizei stride,
+					 const GLvoid * pointer)
+{
+    static const uint16_t short_ops[5]  = { 0, 4189, 4190, 4191, 4192 };
+    static const uint16_t float_ops[5]  = { 0, 4193, 4194, 4195, 4196 };
+    static const uint16_t double_ops[5] = { 0, 4197, 4198, 4199, 4200 };
+
+    uint16_t opcode;
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * arrays = state->array_state;
+    struct array_state * a;
+    unsigned true_immediate_count;
+    unsigned true_immediate_size;
+
+
+    if ( (size < 1) || (size > 4) || (stride < 0) 
+	 || (index > arrays->num_vertex_program_attribs) ){
+        __glXSetError(gc, GL_INVALID_VALUE);
+        return;
+    }
+
+    if ( normalized && (type != GL_FLOAT) && (type != GL_DOUBLE)) {
+	switch( type ) {
+	case GL_BYTE:           opcode = X_GLrop_VertexAttrib4NbvARB;  break;
+	case GL_UNSIGNED_BYTE:  opcode = X_GLrop_VertexAttrib4NubvARB; break;
+	case GL_SHORT:          opcode = X_GLrop_VertexAttrib4NsvARB;  break;
+	case GL_UNSIGNED_SHORT: opcode = X_GLrop_VertexAttrib4NusvARB; break;
+	case GL_INT:            opcode = X_GLrop_VertexAttrib4NivARB;  break;
+	case GL_UNSIGNED_INT:   opcode = X_GLrop_VertexAttrib4NuivARB; break;
+	default:
+	    __glXSetError(gc, GL_INVALID_ENUM);
+	    return;
+	}
+	
+	true_immediate_count = 4;
+    }
+    else {
+	true_immediate_count = size;
+
+	switch( type ) {
+	case GL_BYTE:
+	    opcode = X_GLrop_VertexAttrib4bvARB;
+	    true_immediate_count = 4;
+	    break;
+	case GL_UNSIGNED_BYTE:
+	    opcode = X_GLrop_VertexAttrib4ubvARB;
+	    true_immediate_count = 4;
+	    break;
+	case GL_SHORT:
+	    opcode = short_ops[size];
+	    break;
+	case GL_UNSIGNED_SHORT:
+	    opcode = X_GLrop_VertexAttrib4usvARB;
+	    true_immediate_count = 4;
+	    break;
+	case GL_INT:
+            opcode = X_GLrop_VertexAttrib4ivARB;
+	    true_immediate_count = 4;
+	    break;
+	case GL_UNSIGNED_INT:
+	    opcode = X_GLrop_VertexAttrib4uivARB;
+	    true_immediate_count = 4;
+	    break;
+	case GL_FLOAT:
+	    opcode = float_ops[size];
+	    break;
+	case GL_DOUBLE:
+	    opcode = double_ops[size];
+	    break;
+	default:
+	    __glXSetError(gc, GL_INVALID_ENUM);
+	    return;
+	}
+    }
+
+    a = get_array_entry( arrays, GL_VERTEX_ATTRIB_ARRAY_POINTER, index );
+    if ( a == NULL ) {
+        __glXSetError(gc, GL_INVALID_OPERATION);
+        return;
+    }
+
+    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, normalized, 8,
+			    opcode );
+
+    true_immediate_size = __glXTypeSize(type) * true_immediate_count;
+    ((uint16_t *) (a)->header)[0] = __GLX_PAD(a->header_size 
+					      + true_immediate_size);
+
+    if ( a->enabled ) {
+	arrays->array_info_cache_valid = GL_FALSE;
+    }
+}
+
+
+/**
+ * I don't have 100% confidence that this is correct.  The different rules
+ * about whether or not generic vertex attributes alias "classic" vertex
+ * attributes (i.e., attrib1 ?= primary color) between ARB_vertex_program,
+ * ARB_vertex_shader, and NV_vertex_program are a bit confusing.  My
+ * feeling is that the client-side doesn't have to worry about it.  The
+ * client just sends all the data to the server and lets the server deal
+ * with it.
+ */
+void __indirect_glVertexAttribPointerNV( GLuint index, GLint size,
+					 GLenum type, GLsizei stride,
+					 const GLvoid * pointer)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    GLboolean normalized = GL_FALSE;
+
+
+    switch( type ) {
+    case GL_UNSIGNED_BYTE:
+	if ( size != 4 ) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	normalized = GL_TRUE;
+
+    case GL_SHORT:
+    case GL_FLOAT:
+    case GL_DOUBLE:
+	__indirect_glVertexAttribPointerARB(index, size, type,
+					    normalized,
+					    stride, pointer);
+	return;
+    default:
+	__glXSetError(gc, GL_INVALID_ENUM);
+	return;
+    }
+}
+
+
+void __indirect_glClientActiveTextureARB(GLenum texture)
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXattribute * const state = (__GLXattribute *)(gc->client_state_private);
+    struct array_state_vector * const arrays = state->array_state;
+    const GLint unit = (GLint) texture - GL_TEXTURE0;
+
+
+    if ( (unit < 0) || (unit > arrays->num_texture_units) ) {
+	__glXSetError(gc, GL_INVALID_ENUM);
+	return;
+    }
+
+    arrays->active_texture_unit = unit;
+}
+
+
+/**
+ */
+GLboolean
+__glXSetArrayEnable( __GLXattribute * state,
+		     GLenum key, unsigned index, GLboolean enable )
+{
+    struct array_state_vector * arrays = state->array_state;
+    struct array_state * a;
+    
+
+    if ( key == GL_TEXTURE_COORD_ARRAY ) {
+	index = arrays->active_texture_unit;
+    }
+
+    a = get_array_entry( arrays, key, index );
+
+    if ( (a != NULL) && (a->enabled != enable) ) {
+	a->enabled = enable;
+	arrays->array_info_cache_valid = GL_FALSE;
+    }
+
+    return (a != NULL);
+}
+
+
+void
+__glXArrayDisableAll( __GLXattribute * state )
+{
+    struct array_state_vector * arrays = state->array_state;
+    unsigned  i;
+
+
+    for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
+	arrays->arrays[i].enabled = GL_FALSE;
+    }
+
+    arrays->array_info_cache_valid = GL_FALSE;
+}
+
+
+/**
+ */
+GLboolean
+__glXGetArrayEnable( const __GLXattribute * const state,
+		     GLenum key, unsigned index, GLintptr * dest )
+{
+    const struct array_state_vector * arrays = state->array_state;
+    const struct array_state * a = get_array_entry( (struct array_state_vector *) arrays,
+						    key, index );
+
+    if ( a != NULL ) {
+	*dest = (GLintptr) a->enabled;
+    }
+
+    return (a != NULL);
+}
+
+
+/**
+ */
+GLboolean
+__glXGetArrayType( const __GLXattribute * const state,
+		     GLenum key, unsigned index, GLintptr * dest )
+{
+    const struct array_state_vector * arrays = state->array_state;
+    const struct array_state * a = get_array_entry( (struct array_state_vector *) arrays,
+						    key, index );
+
+    if ( a != NULL ) {
+	*dest = (GLintptr) a->enabled;
+    }
+
+    return (a != NULL);
+}
+
+
+/**
+ */
+GLboolean
+__glXGetArraySize( const __GLXattribute * const state,
+		     GLenum key, unsigned index, GLintptr * dest )
+{
+    const struct array_state_vector * arrays = state->array_state;
+    const struct array_state * a = get_array_entry( (struct array_state_vector *) arrays,
+						    key, index );
+
+    if ( a != NULL ) {
+	*dest = (GLintptr) a->count;
+    }
+
+    return (a != NULL);
+}
+
+
+/**
+ */
+GLboolean
+__glXGetArrayStride( const __GLXattribute * const state,
+		     GLenum key, unsigned index, GLintptr * dest )
+{
+    const struct array_state_vector * arrays = state->array_state;
+    const struct array_state * a = get_array_entry( (struct array_state_vector *) arrays,
+						    key, index );
+
+    if ( a != NULL ) {
+	*dest = (GLintptr) a->user_stride;
+    }
+
+    return (a != NULL);
+}
+
+
+/**
+ */
+GLboolean
+__glXGetArrayPointer( const __GLXattribute * const state,
+		      GLenum key, unsigned index, void ** dest )
+{
+    const struct array_state_vector * arrays = state->array_state;
+    const struct array_state * a = get_array_entry( (struct array_state_vector *) arrays,
+						    key, index );
+
+
+    if ( a != NULL ) {
+	*dest = (void *) (a->data);
+    }
+
+    return (a != NULL);
+}
+
+
+/**
+ */
+GLboolean
+__glXGetArrayNormalized( const __GLXattribute * const state,
+			 GLenum key, unsigned index, GLintptr * dest )
+{
+    const struct array_state_vector * arrays = state->array_state;
+    const struct array_state * a = get_array_entry( (struct array_state_vector *) arrays,
+						    key, index );
+
+
+    if ( a != NULL ) {
+	*dest = (GLintptr) a->normalized;
+    }
+
+    return (a != NULL);
+}
+
+
+/**
+ */
+GLuint
+__glXGetActiveTextureUnit( const __GLXattribute * const state )
+{
+    return state->array_state->active_texture_unit;
+}
+
+
+void
+__glXPushArrayState( __GLXattribute * state )
+{
+    struct array_state_vector * arrays = state->array_state;
+    struct array_stack_state * stack = & arrays->stack[ (arrays->stack_index * arrays->num_arrays)];
+    unsigned  i;
+
+
+    for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
+	stack[i].data = arrays->arrays[i].data;
+	stack[i].data_type = arrays->arrays[i].data_type;
+	stack[i].user_stride = arrays->arrays[i].user_stride;
+	stack[i].count = arrays->arrays[i].count;
+	stack[i].key = arrays->arrays[i].key;
+	stack[i].enabled = arrays->arrays[i].enabled;
+    }
+
+    arrays->active_texture_unit_stack[ arrays->stack_index ] =
+      arrays->active_texture_unit;
+
+    arrays->stack_index++;
+}
+
+
+void
+__glXPopArrayState( __GLXattribute * state )
+{
+    struct array_state_vector * arrays = state->array_state;
+    struct array_stack_state * stack;
+    unsigned  i;
+
+
+    arrays->stack_index--;
+    stack = & arrays->stack[ (arrays->stack_index * arrays->num_arrays) ];
+
+    for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
+	switch ( stack[i].key ) {
+	case GL_NORMAL_ARRAY:
+	    __indirect_glNormalPointer( stack[i].data_type,
+					stack[i].user_stride,
+					stack[i].data );
+	    break;
+	case GL_COLOR_ARRAY:
+	    __indirect_glColorPointer( stack[i].count,
+				       stack[i].data_type,
+				       stack[i].user_stride,
+				       stack[i].data );
+	    break;
+	case GL_INDEX_ARRAY:
+	    __indirect_glIndexPointer( stack[i].data_type,
+				       stack[i].user_stride,
+				       stack[i].data );
+	    break;
+	case GL_EDGE_FLAG_ARRAY:
+	    __indirect_glEdgeFlagPointer( stack[i].user_stride,
+					  stack[i].data );
+	    break;
+	case GL_TEXTURE_COORD_ARRAY:
+	    arrays->active_texture_unit = stack[i].index;
+	    __indirect_glTexCoordPointer( stack[i].count,
+					  stack[i].data_type,
+					  stack[i].user_stride,
+					  stack[i].data );
+	    break;
+	case GL_SECONDARY_COLOR_ARRAY:
+	    __indirect_glSecondaryColorPointerEXT( stack[i].count,
+						   stack[i].data_type,
+						   stack[i].user_stride,
+						   stack[i].data );
+	    break;
+	case GL_FOG_COORDINATE_ARRAY:
+	    __indirect_glFogCoordPointerEXT( stack[i].data_type,
+					     stack[i].user_stride,
+					     stack[i].data );
+	    break;
+
+	}
+	
+	__glXSetArrayEnable( state, stack[i].key, stack[i].index,
+			     stack[i].enabled );
+    }
+
+    arrays->active_texture_unit = 
+      arrays->active_texture_unit_stack[ arrays->stack_index ];
+}
diff --git a/src/glx/x11/indirect_vertex_array.h b/src/glx/x11/indirect_vertex_array.h
new file mode 100644
index 00000000000..caab62b672e
--- /dev/null
+++ b/src/glx/x11/indirect_vertex_array.h
@@ -0,0 +1,57 @@
+/*
+ * (C) Copyright IBM Corporation 2004, 2005
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * IBM,
+ * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef INDIRECT_VERTEX_ARRAY_H
+#define INDIRECT_VERTEX_ARRAY_H
+
+extern const GLuint __glXTypeSize_table[16];
+
+#define __glXTypeSize(e) ((((e) & ~0x0f) != 0x1400) \
+    ? 0 : __glXTypeSize_table[ (e) & 0x0f ])
+
+extern void __glXArrayDisableAll( __GLXattribute * state );
+
+extern GLboolean __glXSetArrayEnable( __GLXattribute * state,
+    GLenum key, unsigned index, GLboolean enable );
+
+extern GLboolean __glXGetArrayEnable( const __GLXattribute * const state,
+    GLenum key, unsigned index, GLintptr * dest );
+extern GLboolean __glXGetArraySize( const __GLXattribute * const state,
+    GLenum key, unsigned index, GLintptr * dest );
+extern GLboolean __glXGetArrayType( const __GLXattribute * const state,
+    GLenum key, unsigned index, GLintptr * dest );
+extern GLboolean __glXGetArrayStride( const __GLXattribute * const state,
+    GLenum key, unsigned index, GLintptr * dest );
+extern GLboolean __glXGetArrayPointer( const __GLXattribute * const state,
+    GLenum key, unsigned index, void ** dest );
+extern GLboolean __glXGetArrayNormalized( const __GLXattribute * const state,
+    GLenum key, unsigned index, GLintptr * dest );
+
+extern void __glXPushArrayState( __GLXattribute * state );
+extern void __glXPopArrayState( __GLXattribute * state );
+
+extern GLuint __glXGetActiveTextureUnit( const __GLXattribute * const state );
+
+#endif /* INDIRECT_VERTEX_ARRAY_H */
diff --git a/src/glx/x11/indirect_vertex_program.c b/src/glx/x11/indirect_vertex_program.c
new file mode 100644
index 00000000000..d0f0d270482
--- /dev/null
+++ b/src/glx/x11/indirect_vertex_program.c
@@ -0,0 +1,272 @@
+/*
+ * (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 <inttypes.h>
+#include <GL/gl.h>
+#include "indirect.h"
+#include "glxclient.h"
+#include "indirect_vertex_array.h"
+#include <GL/glxproto.h>
+
+void do_vertex_attrib_enable( GLuint index, GLboolean val )
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+
+    if ( ! __glXSetArrayEnable( state, GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB,
+				index, val ) ) {
+	__glXSetError(gc, GL_INVALID_ENUM);
+    }
+}
+
+
+void __indirect_glEnableVertexAttribArrayARB( GLuint index )
+{
+    do_vertex_attrib_enable( index, GL_TRUE );
+}
+
+
+void __indirect_glDisableVertexAttribArrayARB( GLuint index )
+{
+    do_vertex_attrib_enable( index, GL_FALSE );
+}
+
+
+static void
+get_parameter( unsigned opcode, unsigned size, GLenum target, GLuint index,
+	       void * params )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 12;
+
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupVendorRequest(gc,
+						     X_GLXVendorPrivateWithReply,
+						     opcode, cmdlen);
+
+	*((GLenum *)(pc +  0)) = target;
+	*((GLuint *)(pc +  4)) = index;
+	*((GLuint *)(pc +  8)) = 0;
+
+        (void) __glXReadReply(dpy, size, params, GL_FALSE);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+
+void __indirect_glGetProgramEnvParameterfvARB( GLenum target, GLuint index,
+					       GLfloat * params )
+{
+    get_parameter( 1296, 4, target, index, params );
+}
+
+
+void __indirect_glGetProgramEnvParameterdvARB( GLenum target, GLuint index,
+					       GLdouble * params )
+{
+    get_parameter( 1297, 8, target, index, params );
+}
+
+
+void __indirect_glGetProgramLocalParameterfvARB( GLenum target, GLuint index,
+						 GLfloat * params )
+{
+    get_parameter( 1305, 4, target, index, params );
+}
+
+
+void __indirect_glGetProgramLocalParameterdvARB( GLenum target, GLuint index,
+						 GLdouble * params )
+{
+    get_parameter( 1306, 8, target, index, params );
+}
+
+
+void __indirect_glGetVertexAttribPointervNV( GLuint index, GLenum pname,
+					     GLvoid ** pointer )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+ 
+    if ( pname != GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB ) {
+	__glXSetError( gc, GL_INVALID_ENUM );
+    }
+    
+    if ( ! __glXGetArrayPointer( state, GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB,
+				 index, pointer ) ) {
+	__glXSetError( gc, GL_INVALID_VALUE );
+    }
+}
+
+
+/**
+ * Get the selected attribute from the vertex array state vector.
+ * 
+ * \returns
+ * On success \c GL_TRUE is returned.  Otherwise, \c GL_FALSE is returned.
+ */
+static GLboolean
+get_attrib_array_data( __GLXattribute * state, GLuint index, GLenum cap,
+		       GLintptr * data )
+{
+    GLboolean retval = GL_FALSE;
+    const GLenum attrib = GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB;
+
+    switch( cap ) {
+    case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB:
+	retval = __glXGetArrayEnable( state, attrib, index, data );
+	break;
+
+    case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB:
+	retval = __glXGetArraySize( state, attrib, index, data );
+	break;
+
+    case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB:
+	retval = __glXGetArrayStride( state, attrib, index, data );
+	break;
+
+    case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB:
+	retval = __glXGetArrayType( state, attrib, index, data );
+	break;
+
+    case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB:
+	retval = __glXGetArrayNormalized( state, attrib, index, data );
+	break;
+    }
+
+    
+    return retval;
+}
+
+
+static void get_vertex_attrib( __GLXcontext * gc, unsigned vop,
+			       GLuint index, GLenum pname,
+			       xReply * reply )
+{
+    Display * const dpy = gc->currentDpy;
+    GLubyte * const pc = __glXSetupVendorRequest(gc,
+						 X_GLXVendorPrivateWithReply,
+						 vop, 8);
+						     
+    *((uint32_t *)(pc +  0)) = index;
+    *((uint32_t *)(pc +  4)) = pname;
+
+    (void) _XReply( dpy, reply, 0, False );
+}
+
+
+void __indirect_glGetVertexAttribivARB( GLuint index, GLenum pname,
+					GLint * params )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    xGLXSingleReply reply;
+
+
+    get_vertex_attrib( gc, 1303, index, pname, (xReply *) & reply );
+
+    if ( reply.size != 0 ) {
+	if ( ! get_attrib_array_data( state, index, pname, params ) ) {
+	    if (reply.size == 1) {
+		*params = (GLint) reply.pad3;
+	    } 
+	    else {
+		_XRead(dpy, (void *) params, 4 * reply.size);
+	    }
+	}
+    }
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+
+void __indirect_glGetVertexAttribfvARB( GLuint index, GLenum pname,
+					GLfloat * params )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    xGLXSingleReply reply;
+
+
+    get_vertex_attrib( gc, 1302, index, pname, (xReply *) & reply );
+
+    if ( reply.size != 0 ) {
+	GLintptr data;
+
+
+	if ( get_attrib_array_data( state, index, pname, & data ) ) {
+	    *params = (GLfloat) data;
+	}
+	else {
+	    if (reply.size == 1) {
+		(void) memcpy( params, & reply.pad3, sizeof( GLfloat ) );
+	    } 
+	    else {
+		_XRead(dpy, (void *) params, 4 * reply.size);
+	    }
+	}
+    }
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
+
+
+void __indirect_glGetVertexAttribdvARB( GLuint index, GLenum pname,
+					GLdouble * params )
+{
+    __GLXcontext * const gc = __glXGetCurrentContext();
+    Display * const dpy = gc->currentDpy;
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    xGLXSingleReply reply;
+
+
+    get_vertex_attrib( gc, 1301, index, pname, (xReply *) & reply );
+
+    if ( reply.size != 0 ) {
+	GLintptr data;
+
+
+	if ( get_attrib_array_data( state, index, pname, & data ) ) {
+	    *params = (GLdouble) data;
+	}
+	else {
+	    if (reply.size == 1) {
+		(void) memcpy( params, & reply.pad3, sizeof( GLdouble ) );
+	    } 
+	    else {
+		_XRead(dpy, (void *) params, 8 * reply.size);
+	    }
+	}
+    }
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+}
diff --git a/src/glx/x11/indirect_window_pos.c b/src/glx/x11/indirect_window_pos.c
new file mode 100644
index 00000000000..533f8ef1a40
--- /dev/null
+++ b/src/glx/x11/indirect_window_pos.c
@@ -0,0 +1,98 @@
+/*
+ * Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+ * (C) Copyright IBM Corporation 2004
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * PRECISION INSIGHT, IBM,
+ * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <GL/gl.h>
+#include "indirect.h"
+
+void __indirect_glWindowPos2dMESA(GLdouble x, GLdouble y)
+{
+	__indirect_glWindowPos3fMESA(x, y, 0.0);
+}
+
+void __indirect_glWindowPos2iMESA(GLint x, GLint y)
+{
+	__indirect_glWindowPos3fMESA(x, y, 0.0);
+}
+
+void __indirect_glWindowPos2fMESA(GLfloat x, GLfloat y)
+{
+	__indirect_glWindowPos3fMESA(x, y, 0.0);
+}
+
+void __indirect_glWindowPos2sMESA(GLshort x, GLshort y)
+{
+	__indirect_glWindowPos3fMESA(x, y, 0.0);
+}
+
+void __indirect_glWindowPos2dvMESA(const GLdouble * p)
+{
+	__indirect_glWindowPos3fMESA(p[0], p[1], 0.0);
+}
+
+void __indirect_glWindowPos2fvMESA(const GLfloat * p)
+{
+	__indirect_glWindowPos3fMESA(p[0], p[1], 0.0);
+}
+
+void __indirect_glWindowPos2ivMESA(const GLint * p)
+{
+	__indirect_glWindowPos3fMESA(p[0], p[1], 0.0);
+}
+
+void __indirect_glWindowPos2svMESA(const GLshort * p)
+{
+	__indirect_glWindowPos3fMESA(p[0], p[1], 0.0);
+}
+
+void __indirect_glWindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z)
+{
+	__indirect_glWindowPos3fMESA(x, y, z);
+}
+
+void __indirect_glWindowPos3iMESA(GLint x, GLint y, GLint z)
+{
+	__indirect_glWindowPos3fMESA(x, y, z);
+}
+
+void __indirect_glWindowPos3sMESA(GLshort x, GLshort y, GLshort z)
+{
+	__indirect_glWindowPos3fMESA(x, y, z);
+}
+
+void __indirect_glWindowPos3dvMESA(const GLdouble * p)
+{
+	__indirect_glWindowPos3fMESA(p[0], p[1], p[2]);
+}
+
+void __indirect_glWindowPos3ivMESA(const GLint * p)
+{
+	__indirect_glWindowPos3fMESA(p[0], p[1], p[2]);
+}
+
+void __indirect_glWindowPos3svMESA(const GLshort * p)
+{
+	__indirect_glWindowPos3fMESA(p[0], p[1], p[2]);
+}
diff --git a/src/glx/x11/packrender.h b/src/glx/x11/packrender.h
new file mode 100644
index 00000000000..ce2a1616dec
--- /dev/null
+++ b/src/glx/x11/packrender.h
@@ -0,0 +1,249 @@
+/* $XFree86: xc/lib/GL/glx/packrender.h,v 1.7tsi Exp $ */
+#ifndef __GLX_packrender_h__
+#define __GLX_packrender_h__
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include "glxclient.h"
+
+/*
+** The macros in this header convert the client machine's native data types to
+** wire protocol data types.  The header is part of the porting layer of the
+** client library, and it is intended that hardware vendors will rewrite this
+** header to suit their own machines.
+*/
+
+/*
+** Pad a count of bytes to the nearest multiple of 4.  The X protocol
+** transfers data in 4 byte quantities, so this macro is used to
+** insure the right amount of data being sent.
+*/
+#define __GLX_PAD(a) (((a)+3) & ~3)
+
+/*
+ ** Network size parameters
+ */
+#define sz_double 8
+
+/* Setup for all commands */
+#define __GLX_DECLARE_VARIABLES() \
+    __GLXcontext *gc;		  \
+    GLubyte *pc, *pixelHeaderPC;  \
+    GLuint compsize, cmdlen
+
+#define __GLX_LOAD_VARIABLES()	   \
+    gc = __glXGetCurrentContext(); \
+    pc = gc->pc;                   \
+    /* Muffle compilers */		    \
+    cmdlen = 0;         (void)cmdlen;	    \
+    compsize = 0;       (void)compsize;	    \
+    pixelHeaderPC = 0;  (void)pixelHeaderPC
+
+/*
+** Variable sized command support macro.  This macro is used by calls
+** that are potentially larger than __GLX_SMALL_RENDER_CMD_SIZE.
+** Because of their size, they may not automatically fit in the buffer.
+** If the buffer can't hold the command then it is flushed so that
+** the command will fit in the next buffer.
+*/
+#define __GLX_BEGIN_VARIABLE(opcode,size)	\
+    if (pc + (size) > gc->bufEnd) {		\
+	pc = __glXFlushRenderBuffer(gc, pc);	\
+    }						\
+    __GLX_PUT_SHORT(0,size);			\
+    __GLX_PUT_SHORT(2,opcode)
+
+#define __GLX_BEGIN_VARIABLE_LARGE(opcode,size)	\
+    pc = __glXFlushRenderBuffer(gc, pc);	\
+    __GLX_PUT_LONG(0,size);			\
+    __GLX_PUT_LONG(4,opcode)
+
+#define __GLX_BEGIN_VARIABLE_WITH_PIXEL(opcode,size) \
+    if (pc + (size) > gc->bufEnd) {		     \
+	pc = __glXFlushRenderBuffer(gc, pc);	     \
+    }						     \
+    __GLX_PUT_SHORT(0,size);			     \
+    __GLX_PUT_SHORT(2,opcode);			     \
+    pc += __GLX_RENDER_HDR_SIZE;		     \
+    pixelHeaderPC = pc;				     \
+    pc += __GLX_PIXEL_HDR_SIZE
+
+#define __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(opcode,size) \
+    pc = __glXFlushRenderBuffer(gc, pc);		   \
+    __GLX_PUT_LONG(0,size);				   \
+    __GLX_PUT_LONG(4,opcode);				   \
+    pc += __GLX_RENDER_LARGE_HDR_SIZE;			   \
+    pixelHeaderPC = pc;					   \
+    pc += __GLX_PIXEL_HDR_SIZE
+
+#define __GLX_BEGIN_VARIABLE_WITH_PIXEL_3D(opcode,size) \
+    if (pc + (size) > gc->bufEnd) {		        \
+	pc = __glXFlushRenderBuffer(gc, pc); 	        \
+    }						        \
+    __GLX_PUT_SHORT(0,size);			        \
+    __GLX_PUT_SHORT(2,opcode);			        \
+    pc += __GLX_RENDER_HDR_SIZE;		        \
+    pixelHeaderPC = pc;				        \
+    pc += __GLX_PIXEL_3D_HDR_SIZE
+
+#define __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL_3D(opcode,size) \
+    pc = __glXFlushRenderBuffer(gc, pc);	   	      \
+    __GLX_PUT_LONG(0,size);				      \
+    __GLX_PUT_LONG(4,opcode);				      \
+    pc += __GLX_RENDER_LARGE_HDR_SIZE;			      \
+    pixelHeaderPC = pc;					      \
+    pc += __GLX_PIXEL_3D_HDR_SIZE
+
+/*
+** Fixed size command support macro.  This macro is used by calls that
+** are never larger than __GLX_SMALL_RENDER_CMD_SIZE.  Because they
+** always fit in the buffer, and because the buffer promises to
+** maintain enough room for them, we don't need to check for space
+** before doing the storage work.
+*/
+#define __GLX_BEGIN(opcode,size) \
+    __GLX_PUT_SHORT(0,size);     \
+    __GLX_PUT_SHORT(2,opcode)
+
+/*
+** Finish a rendering command by advancing the pc.  If the pc is now past
+** the limit pointer then there is no longer room for a
+** __GLX_SMALL_RENDER_CMD_SIZE sized command, which will break the
+** assumptions present in the __GLX_BEGIN macro.  In this case the
+** rendering buffer is flushed out into the X protocol stream (which may
+** or may not do I/O).
+*/
+#define __GLX_END(size)			       \
+    pc += size;				       \
+    if (pc > gc->limit) {		       \
+	(void) __glXFlushRenderBuffer(gc, pc); \
+    } else {				       \
+	gc->pc = pc;			       \
+    }
+
+/* Array copy macros */
+#define __GLX_MEM_COPY(dest,src,bytes) \
+    if (src && dest) \
+    	memcpy(dest, src, bytes)
+
+/* Single item copy macros */
+#define __GLX_PUT_CHAR(offset,a) \
+    *((INT8 *) (pc + offset)) = a
+
+#ifndef _CRAY
+#define __GLX_PUT_SHORT(offset,a) \
+    *((INT16 *) (pc + offset)) = a
+
+#define __GLX_PUT_LONG(offset,a) \
+    *((INT32 *) (pc + offset)) = a
+
+#define __GLX_PUT_FLOAT(offset,a) \
+    *((FLOAT32 *) (pc + offset)) = a
+
+#else
+#define __GLX_PUT_SHORT(offset,a) \
+ { GLubyte *cp = (pc+offset); \
+   int shift = (64-16) - ((int)(cp) >> (64-6)); \
+   *(int *)cp = (*(int *)cp & ~(0xffff << shift)) | ((a & 0xffff) << shift); }
+
+#define __GLX_PUT_LONG(offset,a) \
+ { GLubyte *cp = (pc+offset); \
+   int shift = (64-32) - ((int)(cp) >> (64-6)); \
+   *(int *)cp = (*(int *)cp & ~(0xffffffff << shift)) | ((a & 0xffffffff) << shift); }
+
+#define __GLX_PUT_FLOAT(offset,a) \
+    gl_put_float((pc + offset),a)
+
+#define __GLX_PUT_DOUBLE(offset,a) \
+    gl_put_double(pc + offset, a)
+
+extern void gl_put_float(/*GLubyte *, struct cray_single*/);
+extern void gl_put_double(/*GLubyte *, struct cray_double*/);
+#endif
+
+#ifndef _CRAY
+
+#ifdef __GLX_ALIGN64
+/*
+** This can certainly be done better for a particular machine
+** architecture!
+*/
+#define __GLX_PUT_DOUBLE(offset,a) \
+    __GLX_MEM_COPY(pc + offset, &a, 8)
+#else
+#define __GLX_PUT_DOUBLE(offset,a) \
+    *((FLOAT64 *) (pc + offset)) = a
+#endif
+
+#endif
+
+#define __GLX_PUT_CHAR_ARRAY(offset,a,alen) \
+    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT8)
+
+#ifndef _CRAY
+#define __GLX_PUT_SHORT_ARRAY(offset,a,alen) \
+    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT16)
+
+#define __GLX_PUT_LONG_ARRAY(offset,a,alen) \
+    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT32)
+
+#define __GLX_PUT_FLOAT_ARRAY(offset,a,alen) \
+    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_FLOAT32)
+
+#define __GLX_PUT_DOUBLE_ARRAY(offset,a,alen) \
+    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_FLOAT64)
+
+#else
+#define __GLX_PUT_SHORT_ARRAY(offset,a,alen) \
+    gl_put_short_array((GLubyte *)(pc + offset), a, alen * __GLX_SIZE_INT16)
+
+#define __GLX_PUT_LONG_ARRAY(offset,a,alen) \
+    gl_put_long_array((GLubyte *)(pc + offset), (long *)a, alen * __GLX_SIZE_INT32)
+
+#define __GLX_PUT_FLOAT_ARRAY(offset,a,alen) \
+    gl_put_float_array((GLubyte *)(pc + offset), (float *)a, alen * __GLX_SIZE_FLOAT32)
+
+#define __GLX_PUT_DOUBLE_ARRAY(offset,a,alen) \
+    gl_put_double_array((GLubyte *)(pc + offset), (double *)a, alen * __GLX_SIZE_FLOAT64)
+
+extern gl_put_short_array (GLubyte *, short *, int);
+extern gl_put_long_array (GLubyte *, long *, int);
+extern gl_put_float_array (GLubyte *, float *, int);
+extern gl_put_double_array (GLubyte *, double *, int);
+
+#endif /* _CRAY */
+
+#endif /* !__GLX_packrender_h__ */
diff --git a/src/glx/x11/packsingle.h b/src/glx/x11/packsingle.h
new file mode 100644
index 00000000000..16b054f1e04
--- /dev/null
+++ b/src/glx/x11/packsingle.h
@@ -0,0 +1,219 @@
+/* $XFree86: xc/lib/GL/glx/packsingle.h,v 1.5tsi Exp $ */
+#ifndef __GLX_packsingle_h__
+#define __GLX_packsingle_h__
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include "packrender.h"
+
+/*
+** The macros in this header convert wire protocol data types to the client
+** machine's native data types.  The header is part of the porting layer of
+** the client library, and it is intended that hardware vendors will rewrite
+** this header to suit their own machines.
+*/
+
+/*
+** Dummy define to make the GetReqExtra macro happy.  The value is not
+** used, but instead the code in __GLX_SINGLE_BEGIN issues its own store
+** to req->reqType with the proper code (our extension code).
+*/
+#define X_GLXSingle 0
+
+/* Declare common variables used during a single command */
+#define __GLX_SINGLE_DECLARE_VARIABLES()	 \
+    __GLXcontext *gc = __glXGetCurrentContext(); \
+    GLubyte *pc, *pixelHeaderPC;		 \
+    GLuint compsize, cmdlen;			 \
+    Display *dpy = gc->currentDpy;		 \
+    xGLXSingleReq *req
+
+#define __GLX_SINGLE_LOAD_VARIABLES() \
+    pc = gc->pc;           \
+    /* Muffle compilers */		     \
+    pixelHeaderPC = 0;  (void)pixelHeaderPC; \
+    compsize = 0;       (void)compsize;	     \
+    cmdlen = 0;         (void)cmdlen
+
+/* Start a single command */
+#define __GLX_SINGLE_BEGIN(opcode,bytes)	   \
+    if (dpy) {					   \
+	(void) __glXFlushRenderBuffer(gc, pc);	   \
+	LockDisplay(dpy);			   \
+	GetReqExtra(GLXSingle,bytes,req);	   \
+	req->reqType = gc->majorOpcode;		   \
+	req->glxCode = opcode;			   \
+	req->contextTag = gc->currentContextTag;   \
+	pc = ((GLubyte *)(req) + sz_xGLXSingleReq)
+
+/* End a single command */
+#define __GLX_SINGLE_END()			   \
+	UnlockDisplay(dpy);			   \
+	SyncHandle();				   \
+    }
+
+/* Store data to sending for a single command */
+#define __GLX_SINGLE_PUT_CHAR(offset,a)	\
+    *((INT8 *) (pc + offset)) = a
+
+#ifndef CRAY
+#define __GLX_SINGLE_PUT_SHORT(offset,a) \
+    *((INT16 *) (pc + offset)) = a
+
+#define __GLX_SINGLE_PUT_LONG(offset,a)	\
+    *((INT32 *) (pc + offset)) = a
+
+#define __GLX_SINGLE_PUT_FLOAT(offset,a) \
+    *((FLOAT32 *) (pc + offset)) = a
+
+#else
+#define __GLX_SINGLE_PUT_SHORT(offset,a) \
+    { GLubyte *cp = (pc+offset); \
+      int shift = (64-16) - ((int)(cp) >> (64-6)); \
+      *(int *)cp = (*(int *)cp & ~(0xffff << shift)) | ((a & 0xffff) << shift); }
+
+#define __GLX_SINGLE_PUT_LONG(offset,a) \
+    { GLubyte *cp = (pc+offset); \
+      int shift = (64-32) - ((int)(cp) >> (64-6)); \
+      *(int *)cp = (*(int *)cp & ~(0xffffffff << shift)) | ((a & 0xffffffff) << shift); }
+
+#define __GLX_SINGLE_PUT_FLOAT(offset,a) \
+    gl_put_float(pc + offset, a)
+#endif
+
+/* Read support macros */
+#define __GLX_SINGLE_READ_XREPLY()		    \
+    (void) _XReply(dpy, (xReply*) &reply, 0, False)
+
+#define __GLX_SINGLE_GET_RETVAL(a,cast)	\
+    a = (cast) reply.retval
+
+#define __GLX_SINGLE_GET_SIZE(a) \
+    a = (GLint) reply.size
+
+#ifndef _CRAY
+#define __GLX_SINGLE_GET_CHAR(p) \
+    *p = *(GLbyte *)&reply.pad3;
+
+#define __GLX_SINGLE_GET_SHORT(p) \
+    *p = *(GLshort *)&reply.pad3;
+
+#define __GLX_SINGLE_GET_LONG(p) \
+    *p = *(GLint *)&reply.pad3;
+
+#define __GLX_SINGLE_GET_FLOAT(p) \
+    *p = *(GLfloat *)&reply.pad3;
+
+#else
+#define __GLX_SINGLE_GET_CHAR(p) \
+    *p = reply.pad3 >> 24;
+
+#define __GLX_SINGLE_GET_SHORT(p) \
+    {int t = reply.pad3 >> 16; \
+     *p = (t & 0x8000) ? (t | ~0xffff) : (t & 0xffff);}
+
+#define __GLX_SINGLE_GET_LONG(p) \
+    {int t = reply.pad3; \
+     *p = (t & 0x80000000) ? (t | ~0xffffffff) : (t & 0xffffffff);}
+
+#define PAD3OFFSET 16
+#define __GLX_SINGLE_GET_FLOAT(p) \
+    *p = gl_ntoh_float((GLubyte *)&reply + PAD3OFFSET);
+
+#define __GLX_SINGLE_GET_DOUBLE(p) \
+    *p = gl_ntoh_double((GLubyte *)&reply + PAD3OFFSET);
+
+extern float gl_ntoh_float(GLubyte *);
+extern float gl_ntoh_double(GLubyte *);
+#endif
+
+#ifndef _CRAY
+
+#ifdef __GLX_ALIGN64
+#define __GLX_SINGLE_GET_DOUBLE(p) \
+    __GLX_MEM_COPY(p, &reply.pad3, 8)
+#else
+#define __GLX_SINGLE_GET_DOUBLE(p) \
+    *p = *(GLdouble *)&reply.pad3
+#endif
+
+#endif
+	  
+/* Get an array of typed data */
+#define __GLX_SINGLE_GET_VOID_ARRAY(a,alen)	\
+{						\
+    GLint slop = alen*__GLX_SIZE_INT8 & 3;	\
+    _XRead(dpy,(char *)a,alen*__GLX_SIZE_INT8);	\
+    if (slop) _XEatData(dpy,4-slop);		\
+}
+
+#define __GLX_SINGLE_GET_CHAR_ARRAY(a,alen)	\
+{						\
+    GLint slop = alen*__GLX_SIZE_INT8 & 3;	\
+    _XRead(dpy,(char *)a,alen*__GLX_SIZE_INT8);	\
+    if (slop) _XEatData(dpy,4-slop);		\
+}
+					
+
+#define __GLX_SINGLE_GET_SHORT_ARRAY(a,alen)	\
+{						\
+    GLint slop = (alen*__GLX_SIZE_INT16) & 3;	\
+    _XRead(dpy,(char *)a,alen*__GLX_SIZE_INT16);\
+    if (slop) _XEatData(dpy,4-slop);		\
+}
+
+#define __GLX_SINGLE_GET_LONG_ARRAY(a,alen) \
+    _XRead(dpy,(char *)a,alen*__GLX_SIZE_INT32);  	
+
+#ifndef _CRAY
+#define __GLX_SINGLE_GET_FLOAT_ARRAY(a,alen) \
+    _XRead(dpy,(char *)a,alen*__GLX_SIZE_FLOAT32);  	
+
+#define __GLX_SINGLE_GET_DOUBLE_ARRAY(a,alen) \
+    _XRead(dpy,(char *)a,alen*__GLX_SIZE_FLOAT64);  	
+
+#else
+#define __GLX_SINGLE_GET_FLOAT_ARRAY(a,alen) \
+    gl_get_float_array(dpy,a,alen);
+
+#define __GLX_SINGLE_GET_DOUBLE_ARRAY(a,alen) \
+    gl_get_double_array(dpy, a, alen);
+
+extern void gl_get_float_array(Display *dpy, float *a, int alen);
+extern void gl_get_double_array(Display *dpy, double *a, int alen);
+#endif
+
+#endif /* !__GLX_packsingle_h__ */
diff --git a/src/glx/x11/pixel.c b/src/glx/x11/pixel.c
new file mode 100644
index 00000000000..3b3a1811abb
--- /dev/null
+++ b/src/glx/x11/pixel.c
@@ -0,0 +1,443 @@
+/* $XFree86: xc/lib/GL/glx/pixel.c,v 1.8 2003/09/28 20:15:04 alanh Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include "packrender.h"
+
+static const GLubyte MsbToLsbTable[256] = {
+    0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
+    0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
+    0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
+    0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
+    0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
+    0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
+    0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
+    0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
+    0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
+    0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
+    0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
+    0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
+    0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
+    0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
+    0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
+    0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
+    0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
+    0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
+    0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
+    0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
+    0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
+    0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
+    0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
+    0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
+    0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
+    0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
+    0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
+    0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
+    0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
+    0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
+    0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
+    0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
+};
+
+static const GLubyte LowBitsMask[9] = {
+    0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff,
+};
+
+static const GLubyte HighBitsMask[9] = {
+    0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff,
+};
+
+
+/*
+** Copy bitmap data from clients packed memory applying unpacking modes as the
+** data is transfered into the destImage buffer.  Return in modes the
+** set of pixel modes that are to be done by the server.
+*/
+static void FillBitmap(__GLXcontext *gc, GLint width, GLint height,
+		       GLenum format, const GLvoid *userdata,
+		       GLubyte *destImage)
+{
+    const __GLXattribute * state = gc->client_state_private;
+    GLint rowLength = state->storeUnpack.rowLength;
+    GLint alignment = state->storeUnpack.alignment;
+    GLint skipPixels = state->storeUnpack.skipPixels;
+    GLint skipRows = state->storeUnpack.skipRows;
+    GLint lsbFirst = state->storeUnpack.lsbFirst;
+    GLint elementsLeft, bitOffset, currentByte, nextByte, highBitMask;
+    GLint lowBitMask, i;
+    GLint components, groupsPerRow, rowSize, padding, elementsPerRow;
+    const GLubyte *start, *iter;
+
+    if (rowLength > 0) {
+	groupsPerRow = rowLength;
+    } else {
+	groupsPerRow = width;
+    }
+    components = __glElementsPerGroup(format,GL_BITMAP);
+    rowSize = (groupsPerRow * components + 7) >> 3;
+    padding = (rowSize % alignment);
+    if (padding) {
+	rowSize += alignment - padding;
+    }
+    start = ((const GLubyte*) userdata) + skipRows * rowSize + 
+	((skipPixels * components) >> 3);
+    bitOffset = (skipPixels * components) & 7;
+    highBitMask = LowBitsMask[8-bitOffset];
+    lowBitMask = HighBitsMask[bitOffset];
+    elementsPerRow = width * components;
+    for (i = 0; i < height; i++) {
+	elementsLeft = elementsPerRow;
+	iter = start;
+	while (elementsLeft) {
+	    /* First retrieve low bits from current byte */
+	    if (lsbFirst) {
+		currentByte = MsbToLsbTable[iter[0]];
+	    } else {
+		currentByte = iter[0];
+	    }
+	    if (bitOffset) {
+		/* Need to read next byte to finish current byte */
+		if (elementsLeft > (8 - bitOffset)) {
+		    if (lsbFirst) {
+			nextByte = MsbToLsbTable[iter[1]];
+		    } else {
+			nextByte = iter[1];
+		    }
+		    currentByte = 
+			((currentByte & highBitMask) << bitOffset) |
+			    ((nextByte & lowBitMask) >> (8 - bitOffset));
+		} else {
+		    currentByte = 
+			((currentByte & highBitMask) << bitOffset);
+		}
+	    } 
+	    if (elementsLeft >= 8) {
+		*destImage = currentByte;
+		elementsLeft -= 8;
+	    } else {
+		*destImage = currentByte & HighBitsMask[elementsLeft];
+		elementsLeft = 0;
+	    }
+	    destImage++;
+	    iter++;
+	}
+	start += rowSize;
+    }
+}
+
+/*
+** Extract array from user's data applying all pixel store modes.
+** The internal packed array format used has LSB_FIRST = FALSE and 
+** ALIGNMENT = 1.
+*/
+void __glFillImage(__GLXcontext *gc, GLint dim, GLint width, GLint height,
+		   GLint depth, GLenum format, GLenum type,
+		   const GLvoid *userdata, GLubyte *newimage, GLubyte *modes)
+{
+    const __GLXattribute * state = gc->client_state_private;
+    GLint rowLength = state->storeUnpack.rowLength;
+    GLint imageHeight = state->storeUnpack.imageHeight;
+    GLint alignment = state->storeUnpack.alignment;
+    GLint skipPixels = state->storeUnpack.skipPixels;
+    GLint skipRows = state->storeUnpack.skipRows;
+    GLint skipImages = state->storeUnpack.skipImages;
+    GLint swapBytes = state->storeUnpack.swapEndian;
+    GLint components, elementSize, rowSize, padding, groupsPerRow, groupSize;
+    GLint elementsPerRow, imageSize, rowsPerImage, h, i, j, k;
+    const GLubyte *start, *iter, *itera, *iterb, *iterc;
+    GLubyte *iter2;
+
+    if (type == GL_BITMAP) {
+	FillBitmap(gc, width, height, format, userdata, newimage);
+    } else {
+	components = __glElementsPerGroup(format,type);
+	if (rowLength > 0) {
+	    groupsPerRow = rowLength;
+	} else {
+	    groupsPerRow = width;
+	}
+	if (imageHeight > 0) {
+	    rowsPerImage = imageHeight;
+	} else {
+	    rowsPerImage = height;
+	}
+
+	elementSize = __glBytesPerElement(type);
+	groupSize = elementSize * components;
+	if (elementSize == 1) swapBytes = 0;
+
+	rowSize = groupsPerRow * groupSize;
+	padding = (rowSize % alignment);
+	if (padding) {
+	    rowSize += alignment - padding;
+	}
+	imageSize = rowSize * rowsPerImage;
+	start = ((const GLubyte*) userdata) + skipImages * imageSize +
+		skipRows * rowSize + skipPixels * groupSize;
+	iter2 = newimage;
+	elementsPerRow = width * components;
+
+	if (swapBytes) {
+	    itera = start;
+	    for (h = 0; h < depth; h++) {
+		iterb = itera;
+		for (i = 0; i < height; i++) {
+		    iterc = iterb;
+		    for (j = 0; j < elementsPerRow; j++) {
+			for (k = 1; k <= elementSize; k++) {
+			    iter2[k-1] = iterc[elementSize - k];
+			}
+			iter2 += elementSize;
+			iterc += elementSize;
+		    }
+		    iterb += rowSize;
+		}
+		itera += imageSize;
+	    }
+	} else {
+	    itera = start;
+	    for (h = 0; h < depth; h++) {
+		if (rowSize == elementsPerRow * elementSize) {
+		    /* Ha!  This is mondo easy! */
+		    __GLX_MEM_COPY(iter2, itera,
+				   elementsPerRow * elementSize * height);
+		    iter2 += elementsPerRow * elementSize * height;
+		} else {
+		    iter = itera;
+		    for (i = 0; i < height; i++) {
+			__GLX_MEM_COPY(iter2, iter, elementsPerRow*elementSize);
+			iter2 += elementsPerRow * elementSize;
+			iter += rowSize;
+		    }
+		}
+		itera += imageSize;
+	    }    
+	}
+    }
+
+    /* Setup store modes that describe what we just did */
+    if (modes) {
+       if ( dim < 3 ) {
+	  (void) memcpy( modes, __glXDefaultPixelStore + 4, 20 );
+       }
+       else {
+	  (void) memcpy( modes, __glXDefaultPixelStore + 0, 36 );
+       }
+    }
+}
+
+/*
+** Empty a bitmap in LSB_FIRST=GL_FALSE and ALIGNMENT=4 format packing it
+** into the clients memory using the pixel store PACK modes.
+*/
+static void EmptyBitmap(__GLXcontext *gc, GLint width, GLint height,
+			GLenum format, const GLubyte *sourceImage,
+			GLvoid *userdata)
+{
+    const __GLXattribute * state = gc->client_state_private;
+    GLint rowLength = state->storePack.rowLength;
+    GLint alignment = state->storePack.alignment;
+    GLint skipPixels = state->storePack.skipPixels;
+    GLint skipRows = state->storePack.skipRows;
+    GLint lsbFirst = state->storePack.lsbFirst;
+    GLint components, groupsPerRow, rowSize, padding, elementsPerRow;
+    GLint sourceRowSize, sourcePadding, sourceSkip;
+    GLubyte *start, *iter;
+    GLint elementsLeft, bitOffset, currentByte, highBitMask, lowBitMask;
+    GLint writeMask, i;
+    GLubyte writeByte;
+
+    components = __glElementsPerGroup(format,GL_BITMAP);
+    if (rowLength > 0) {
+	groupsPerRow = rowLength;
+    } else {
+	groupsPerRow = width;
+    }
+
+    rowSize = (groupsPerRow * components + 7) >> 3;
+    padding = (rowSize % alignment);
+    if (padding) {
+	rowSize += alignment - padding;
+    }
+    sourceRowSize = (width * components + 7) >> 3;
+    sourcePadding = (sourceRowSize % 4);
+    if (sourcePadding) {
+	sourceSkip = 4 - sourcePadding;
+    } else {
+	sourceSkip = 0;
+    }
+    start = ((GLubyte*) userdata) + skipRows * rowSize + 
+	((skipPixels * components) >> 3);
+    bitOffset = (skipPixels * components) & 7;
+    highBitMask = LowBitsMask[8-bitOffset];
+    lowBitMask = HighBitsMask[bitOffset];
+    elementsPerRow = width * components;
+    for (i = 0; i < height; i++) {
+	elementsLeft = elementsPerRow;
+	iter = start;
+	writeMask = highBitMask;
+	writeByte = 0;
+	while (elementsLeft) {
+	    /* Set up writeMask (to write to current byte) */
+	    if (elementsLeft + bitOffset < 8) {
+		/* Need to trim writeMask */
+		writeMask &= HighBitsMask[bitOffset+elementsLeft];
+	    }
+
+	    if (lsbFirst) {
+		currentByte = MsbToLsbTable[iter[0]];
+	    } else {
+		currentByte = iter[0];
+	    }
+
+	    if (bitOffset) {
+		writeByte |= (sourceImage[0] >> bitOffset);
+		currentByte = (currentByte & ~writeMask) | 
+		    (writeByte & writeMask);
+		writeByte = (sourceImage[0] << (8 - bitOffset));
+	    } else {
+		currentByte = (currentByte & ~writeMask) |
+		    (sourceImage[0] & writeMask);
+	    }
+
+	    if (lsbFirst) {
+		iter[0] = MsbToLsbTable[currentByte];
+	    } else {
+		iter[0] = currentByte;
+	    }
+
+	    if (elementsLeft >= 8) {
+		elementsLeft -= 8;
+	    } else {
+		elementsLeft = 0;
+	    }
+	    sourceImage++;
+	    iter++;
+	    writeMask = 0xff;
+	}
+	if (writeByte) {
+	    /* Some data left over that still needs writing */
+	    writeMask &= lowBitMask;
+	    if (lsbFirst) {
+		currentByte = MsbToLsbTable[iter[0]];
+	    } else {
+		currentByte = iter[0];
+	    }
+	    currentByte = (currentByte & ~writeMask) | (writeByte & writeMask);
+	    if (lsbFirst) {
+		iter[0] = MsbToLsbTable[currentByte];
+	    } else {
+		iter[0] = currentByte;
+	    }
+	}
+	start += rowSize;
+	sourceImage += sourceSkip;
+    }
+}
+
+/*
+** Insert array into user's data applying all pixel store modes.
+** The packed array format from the server is LSB_FIRST = FALSE,
+** SWAP_BYTES = the current pixel storage pack mode, and ALIGNMENT = 4.
+** Named __glEmptyImage() because it is the opposite of __glFillImage().
+*/
+/* ARGSUSED */
+void __glEmptyImage(__GLXcontext *gc, GLint dim, GLint width, GLint height, 
+		    GLint depth, GLenum format, GLenum type,
+		    const GLubyte *sourceImage, GLvoid *userdata)
+{
+    const __GLXattribute * state = gc->client_state_private;
+    GLint rowLength = state->storePack.rowLength;
+    GLint imageHeight = state->storePack.imageHeight;
+    GLint alignment = state->storePack.alignment;
+    GLint skipPixels = state->storePack.skipPixels;
+    GLint skipRows = state->storePack.skipRows;
+    GLint skipImages = state->storePack.skipImages;
+    GLint components, elementSize, rowSize, padding, groupsPerRow, groupSize;
+    GLint elementsPerRow, sourceRowSize, sourcePadding, h, i;
+    GLint imageSize, rowsPerImage;
+    GLubyte *start, *iter, *itera;
+
+    if (type == GL_BITMAP) {
+	EmptyBitmap(gc, width, height, format, sourceImage, userdata);
+    } else {
+	components = __glElementsPerGroup(format,type);
+	if (rowLength > 0) {
+	    groupsPerRow = rowLength;
+	} else {
+	    groupsPerRow = width;
+	}
+	if (imageHeight > 0) {
+	    rowsPerImage = imageHeight;
+	} else {
+	    rowsPerImage = height;
+	}
+	elementSize = __glBytesPerElement(type);
+	groupSize = elementSize * components;
+	rowSize = groupsPerRow * groupSize;
+	padding = (rowSize % alignment);
+	if (padding) {
+	    rowSize += alignment - padding;
+	}
+	sourceRowSize = width * groupSize;
+	sourcePadding = (sourceRowSize % 4);
+	if (sourcePadding) {
+	    sourceRowSize += 4 - sourcePadding;
+	}
+	imageSize = sourceRowSize * rowsPerImage;
+	start = ((GLubyte*) userdata) + skipImages * imageSize +
+		skipRows * rowSize + skipPixels * groupSize;
+	elementsPerRow = width * components;
+
+	itera = start;
+	for (h = 0; h < depth; h++) {
+	    if ((rowSize == sourceRowSize) && (sourcePadding == 0)) {
+		/* Ha!  This is mondo easy! */
+		__GLX_MEM_COPY(itera, sourceImage,
+			       elementsPerRow * elementSize * height);
+		sourceImage += elementsPerRow * elementSize * height;
+	    } else {
+		iter = itera;
+		for (i = 0; i < height; i++) {
+		    __GLX_MEM_COPY(iter, sourceImage,
+				   elementsPerRow * elementSize);
+		    sourceImage += sourceRowSize;
+		    iter += rowSize;
+		}
+	    }
+	    itera += imageSize;
+	}
+    }
+}
diff --git a/src/glx/x11/pixelstore.c b/src/glx/x11/pixelstore.c
new file mode 100644
index 00000000000..3bf1b35ba3c
--- /dev/null
+++ b/src/glx/x11/pixelstore.c
@@ -0,0 +1,337 @@
+/* $XFree86: xc/lib/GL/glx/pixelstore.c,v 1.4 2004/01/28 18:11:43 alanh Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include "glxclient.h"
+#include "indirect.h"
+
+/**
+ * Send glPixelStore command to the server
+ * 
+ * \param gc     Current GLX context
+ * \param sop    Either \c X_GLsop_PixelStoref or \c X_GLsop_PixelStorei
+ * \param pname  Selector of which pixel parameter is to be set.
+ * \param param  Value that \c pname is set to.
+ *
+ * \sa __indirect_glPixelStorei,  __indirect_glPixelStoref
+ */
+static void
+send_PixelStore( __GLXcontext * gc, unsigned sop, GLenum pname, 
+		 const void * param )
+{
+    Display * const dpy = gc->currentDpy;
+    const GLuint cmdlen = 8;
+    if (__builtin_expect(dpy != NULL, 1)) {
+        GLubyte const * pc = __glXSetupSingleRequest(gc, sop, cmdlen);
+        (void) memcpy((void *)(pc + 0), (void *)(&pname), 4);
+        (void) memcpy((void *)(pc + 4), param, 4);
+        UnlockDisplay(dpy); SyncHandle();
+    }
+    return;
+}
+
+/*
+** Specify parameters that control the storage format of pixel arrays.
+*/
+void __indirect_glPixelStoref(GLenum pname, GLfloat param)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = gc->client_state_private;
+    Display *dpy = gc->currentDpy;
+    GLuint a;
+
+    if (!dpy) return;
+
+    switch (pname) {
+      case GL_PACK_ROW_LENGTH:
+	a = (GLuint) (param + 0.5);
+	if (((GLint) a) < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storePack.rowLength = a;
+	break;
+      case GL_PACK_IMAGE_HEIGHT:
+        a = (GLuint) (param + 0.5);
+        if (((GLint) a) < 0) {
+            __glXSetError(gc, GL_INVALID_VALUE);
+            return;
+        }
+        state->storePack.imageHeight = a;
+        break;
+      case GL_PACK_SKIP_ROWS:
+	a = (GLuint) (param + 0.5);
+	if (((GLint) a) < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storePack.skipRows = a;
+	break;
+      case GL_PACK_SKIP_PIXELS:
+	a = (GLuint) (param + 0.5);
+	if (((GLint) a) < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storePack.skipPixels = a;
+	break;
+      case GL_PACK_SKIP_IMAGES:
+        a = (GLuint) (param + 0.5);
+        if (((GLint) a) < 0) {
+            __glXSetError(gc, GL_INVALID_VALUE);
+            return;
+        }
+        state->storePack.skipImages = a;
+        break;
+      case GL_PACK_ALIGNMENT:
+	a = (GLint) (param + 0.5);
+	switch (a) {
+	  case 1: case 2: case 4: case 8:
+	    state->storePack.alignment = a;
+	    break;
+	  default:
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	break;
+      case GL_PACK_SWAP_BYTES:
+	state->storePack.swapEndian = (param != 0);
+	break;
+      case GL_PACK_LSB_FIRST:
+	state->storePack.lsbFirst = (param != 0);
+	break;
+
+      case GL_UNPACK_ROW_LENGTH:
+	a = (GLuint) (param + 0.5);
+	if (((GLint) a) < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storeUnpack.rowLength = a;
+	break;
+      case GL_UNPACK_IMAGE_HEIGHT:
+        a = (GLuint) (param + 0.5);
+        if (((GLint) a) < 0) {
+            __glXSetError(gc, GL_INVALID_VALUE);
+            return;
+        }
+        state->storeUnpack.imageHeight = a;
+        break;
+      case GL_UNPACK_SKIP_ROWS:
+	a = (GLuint) (param + 0.5);
+	if (((GLint) a) < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storeUnpack.skipRows = a;
+	break;
+      case GL_UNPACK_SKIP_PIXELS:
+	a = (GLuint) (param + 0.5);
+	if (((GLint) a) < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storeUnpack.skipPixels = a;
+	break;
+      case GL_UNPACK_SKIP_IMAGES:
+        a = (GLuint) (param + 0.5);
+        if (((GLint) a) < 0) {
+            __glXSetError(gc, GL_INVALID_VALUE);
+            return;
+        }
+        state->storeUnpack.skipImages = a;
+        break;
+      case GL_UNPACK_ALIGNMENT:
+	a = (GLint) (param + 0.5);
+	switch (a) {
+	  case 1: case 2: case 4: case 8:
+	    state->storeUnpack.alignment = a;
+	    break;
+	  default:
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	break;
+      case GL_UNPACK_SWAP_BYTES:
+	state->storeUnpack.swapEndian = (param != 0);
+	break;
+      case GL_UNPACK_LSB_FIRST:
+	state->storeUnpack.lsbFirst = (param != 0);
+	break;
+
+      /* Group all of the pixel store modes that need to be sent to the
+       * server here.  Care must be used to only send modes to the server that
+       * won't affect the size of the data sent to or received from the
+       * server.  GL_PACK_INVERT_MESA is safe in this respect, but other,
+       * future modes may not be.
+       */
+      case GL_PACK_INVERT_MESA:
+	send_PixelStore( gc, X_GLsop_PixelStoref, pname, & param );
+	break;
+
+      default:
+	__glXSetError(gc, GL_INVALID_ENUM);
+	break;
+    }
+}
+
+void __indirect_glPixelStorei(GLenum pname, GLint param)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = gc->client_state_private;
+    Display *dpy = gc->currentDpy;
+
+    if (!dpy) return;
+
+    switch (pname) {
+      case GL_PACK_ROW_LENGTH:
+	if (param < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storePack.rowLength = param;
+	break;
+      case GL_PACK_IMAGE_HEIGHT:
+        if (param < 0) {
+            __glXSetError(gc, GL_INVALID_VALUE);
+            return;
+        }
+        state->storePack.imageHeight = param;
+        break;
+      case GL_PACK_SKIP_ROWS:
+	if (param < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storePack.skipRows = param;
+	break;
+      case GL_PACK_SKIP_PIXELS:
+	if (param < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storePack.skipPixels = param;
+	break;
+      case GL_PACK_SKIP_IMAGES:
+        if (param < 0) {
+            __glXSetError(gc, GL_INVALID_VALUE);
+            return;
+        }
+        state->storePack.skipImages = param;
+        break;
+      case GL_PACK_ALIGNMENT:
+	switch (param) {
+	  case 1: case 2: case 4: case 8:
+	    state->storePack.alignment = param;
+	    break;
+	  default:
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	break;
+      case GL_PACK_SWAP_BYTES:
+	state->storePack.swapEndian = (param != 0);
+	break;
+      case GL_PACK_LSB_FIRST:
+	state->storePack.lsbFirst = (param != 0);
+	break;
+
+      case GL_UNPACK_ROW_LENGTH:
+	if (param < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storeUnpack.rowLength = param;
+	break;
+      case GL_UNPACK_IMAGE_HEIGHT:
+        if (param < 0) {
+            __glXSetError(gc, GL_INVALID_VALUE);
+            return;
+        }
+        state->storeUnpack.imageHeight = param;
+        break;
+      case GL_UNPACK_SKIP_ROWS:
+	if (param < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storeUnpack.skipRows = param;
+	break;
+      case GL_UNPACK_SKIP_PIXELS:
+	if (param < 0) {
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	state->storeUnpack.skipPixels = param;
+	break;
+      case GL_UNPACK_SKIP_IMAGES:
+        if (param < 0) {
+            __glXSetError(gc, GL_INVALID_VALUE);
+            return;
+        }
+        state->storeUnpack.skipImages = param;
+        break;
+      case GL_UNPACK_ALIGNMENT:
+	switch (param) {
+	  case 1: case 2: case 4: case 8:
+	    state->storeUnpack.alignment = param;
+	    break;
+	  default:
+	    __glXSetError(gc, GL_INVALID_VALUE);
+	    return;
+	}
+	break;
+      case GL_UNPACK_SWAP_BYTES:
+	state->storeUnpack.swapEndian = (param != 0);
+	break;
+      case GL_UNPACK_LSB_FIRST:
+	state->storeUnpack.lsbFirst = (param != 0);
+	break;
+
+      /* Group all of the pixel store modes that need to be sent to the
+       * server here.  Care must be used to only send modes to the server that
+       * won't affect the size of the data sent to or received from the
+       * server.  GL_PACK_INVERT_MESA is safe in this respect, but other,
+       * future modes may not be.
+       */
+      case GL_PACK_INVERT_MESA:
+	send_PixelStore( gc, X_GLsop_PixelStorei, pname, & param );
+	break;
+
+      default:
+	__glXSetError(gc, GL_INVALID_ENUM);
+	break;
+    }
+}
diff --git a/src/glx/x11/render2.c b/src/glx/x11/render2.c
new file mode 100644
index 00000000000..21ba2709982
--- /dev/null
+++ b/src/glx/x11/render2.c
@@ -0,0 +1,363 @@
+/* $XFree86: xc/lib/GL/glx/render2.c,v 1.6 2004/01/31 09:29:33 alanh Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include "packrender.h"
+#include "indirect.h"
+#include "indirect_size.h"
+
+/*
+** This file contains routines that might need to be transported as
+** GLXRender or GLXRenderLarge commands, and these commands don't
+** use the pixel header.  See renderpix.c for those routines.
+*/
+
+void __indirect_glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride,
+	     GLint order, const GLdouble *pnts)
+{
+    __GLX_DECLARE_VARIABLES();
+    GLint k;
+
+    __GLX_LOAD_VARIABLES();
+    k = __glMap1d_size(target);
+    if (k == 0) {
+	__glXSetError(gc, GL_INVALID_ENUM);
+	return;
+    } else if (stride < k || order <= 0) {
+	__glXSetError(gc, GL_INVALID_VALUE);
+	return;
+    }
+    compsize = k * order * __GLX_SIZE_FLOAT64;
+    cmdlen = 28+compsize;
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE(X_GLrop_Map1d,cmdlen);
+	__GLX_PUT_DOUBLE(4,u1);
+	__GLX_PUT_DOUBLE(12,u2);
+	__GLX_PUT_LONG(20,target);
+	__GLX_PUT_LONG(24,order);
+	/*
+	** NOTE: the doubles that follow are not aligned because of 3
+	** longs preceeding
+	*/
+	__glFillMap1d(k, order, stride, pnts, (pc+28));
+	__GLX_END(cmdlen);
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map1d,cmdlen+4);
+	__GLX_PUT_DOUBLE(8,u1);
+	__GLX_PUT_DOUBLE(16,u2);
+	__GLX_PUT_LONG(24,target);
+	__GLX_PUT_LONG(28,order);
+
+	/*
+	** NOTE: the doubles that follow are not aligned because of 3
+	** longs preceeding
+	*/
+	if (stride != k) {
+	    GLubyte *buf;
+
+	    buf = (GLubyte *) Xmalloc(compsize);
+	    if (!buf) {
+		__glXSetError(gc, GL_OUT_OF_MEMORY);
+		return;
+	    }
+	    __glFillMap1d(k, order, stride, pnts, buf);
+	    __glXSendLargeCommand(gc, pc, 32, buf, compsize);
+	    Xfree((char*) buf);
+	} else {
+	    /* Data is already packed.  Just send it out */
+	    __glXSendLargeCommand(gc, pc, 32, pnts, compsize);
+	}
+    }
+}
+
+void __indirect_glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride,
+	     GLint order, const GLfloat *pnts)
+{
+    __GLX_DECLARE_VARIABLES();
+    GLint k;
+
+    __GLX_LOAD_VARIABLES();
+    k = __glMap1f_size(target);
+    if (k == 0) {
+	__glXSetError(gc, GL_INVALID_ENUM);
+	return;
+    } else if (stride < k || order <= 0) {
+	__glXSetError(gc, GL_INVALID_VALUE);
+	return;
+    }
+    compsize = k * order * __GLX_SIZE_FLOAT32;
+    cmdlen = 20+compsize;
+    if (!gc->currentDpy) return;
+
+    /*
+    ** The order that arguments are packed is different from the order
+    ** for glMap1d.
+    */
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE(X_GLrop_Map1f,cmdlen);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_FLOAT(8,u1);
+	__GLX_PUT_FLOAT(12,u2);
+	__GLX_PUT_LONG(16,order);
+	__glFillMap1f(k, order, stride, pnts, (GLubyte*) (pc+20));
+	__GLX_END(cmdlen);
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map1f,cmdlen+4);
+	__GLX_PUT_LONG(8,target);
+	__GLX_PUT_FLOAT(12,u1);
+	__GLX_PUT_FLOAT(16,u2);
+	__GLX_PUT_LONG(20,order);
+
+	if (stride != k) {
+	    GLubyte *buf;
+
+	    buf = (GLubyte *) Xmalloc(compsize);
+	    if (!buf) {
+		__glXSetError(gc, GL_OUT_OF_MEMORY);
+		return;
+	    }
+	    __glFillMap1f(k, order, stride, pnts, buf);
+	    __glXSendLargeCommand(gc, pc, 24, buf, compsize);
+	    Xfree((char*) buf);
+	} else {
+	    /* Data is already packed.  Just send it out */
+	    __glXSendLargeCommand(gc, pc, 24, pnts, compsize);
+	}
+    }
+}
+
+void __indirect_glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustr, GLint uord,
+	     GLdouble v1, GLdouble v2, GLint vstr, GLint vord,
+	     const GLdouble *pnts)
+{
+    __GLX_DECLARE_VARIABLES();
+    GLint k;
+
+    __GLX_LOAD_VARIABLES();
+    k = __glMap2d_size(target);
+    if (k == 0) {
+	__glXSetError(gc, GL_INVALID_ENUM);
+	return;
+    } else if (vstr < k || ustr < k || vord <= 0 || uord <= 0) {
+	__glXSetError(gc, GL_INVALID_VALUE);
+	return;
+    }
+    compsize = k * uord * vord * __GLX_SIZE_FLOAT64;
+    cmdlen = 48+compsize; 
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE(X_GLrop_Map2d,cmdlen);
+	__GLX_PUT_DOUBLE(4,u1);
+	__GLX_PUT_DOUBLE(12,u2);
+	__GLX_PUT_DOUBLE(20,v1);
+	__GLX_PUT_DOUBLE(28,v2);
+	__GLX_PUT_LONG(36,target);
+	__GLX_PUT_LONG(40,uord);
+	__GLX_PUT_LONG(44,vord);
+	/*
+	** Pack into a u-major ordering.
+	** NOTE: the doubles that follow are not aligned because of 5
+	** longs preceeding
+	*/
+	__glFillMap2d(k, uord, vord, ustr, vstr, pnts, (GLdouble*) (pc+48));
+	__GLX_END(cmdlen);
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map2d,cmdlen+4);
+	__GLX_PUT_DOUBLE(8,u1);
+	__GLX_PUT_DOUBLE(16,u2);
+	__GLX_PUT_DOUBLE(24,v1);
+	__GLX_PUT_DOUBLE(32,v2);
+	__GLX_PUT_LONG(40,target);
+	__GLX_PUT_LONG(44,uord);
+	__GLX_PUT_LONG(48,vord);
+
+	/*
+	** NOTE: the doubles that follow are not aligned because of 5
+	** longs preceeding
+	*/
+	if ((vstr != k) || (ustr != k*vord)) {
+	    GLdouble *buf;
+
+	    buf = (GLdouble *) Xmalloc(compsize);
+	    if (!buf) {
+		__glXSetError(gc, GL_OUT_OF_MEMORY);
+		return;
+	    }
+	    /*
+	    ** Pack into a u-major ordering.
+	    */
+	    __glFillMap2d(k, uord, vord, ustr, vstr, pnts, buf);
+	    __glXSendLargeCommand(gc, pc, 52, buf, compsize);
+	    Xfree((char*) buf);
+	} else {
+	    /* Data is already packed.  Just send it out */
+	    __glXSendLargeCommand(gc, pc, 52, pnts, compsize);
+	}
+    }
+}
+
+void __indirect_glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustr, GLint uord,
+	     GLfloat v1, GLfloat v2, GLint vstr, GLint vord,
+	     const GLfloat *pnts)
+{
+    __GLX_DECLARE_VARIABLES();
+    GLint k;
+
+    __GLX_LOAD_VARIABLES();
+    k = __glMap2f_size(target);
+    if (k == 0) {
+	__glXSetError(gc, GL_INVALID_ENUM);
+	return;
+    } else if (vstr < k || ustr < k || vord <= 0 || uord <= 0) {
+	__glXSetError(gc, GL_INVALID_VALUE);
+	return;
+    }
+    compsize = k * uord * vord * __GLX_SIZE_FLOAT32;
+    cmdlen = 32+compsize; 
+    if (!gc->currentDpy) return;
+
+    /*
+    ** The order that arguments are packed is different from the order
+    ** for glMap2d.
+    */
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE(X_GLrop_Map2f,cmdlen);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_FLOAT(8,u1);
+	__GLX_PUT_FLOAT(12,u2);
+	__GLX_PUT_LONG(16,uord);
+	__GLX_PUT_FLOAT(20,v1);
+	__GLX_PUT_FLOAT(24,v2);
+	__GLX_PUT_LONG(28,vord);
+	/*
+	** Pack into a u-major ordering.
+	*/
+	__glFillMap2f(k, uord, vord, ustr, vstr, pnts, (GLfloat*) (pc+32));
+	__GLX_END(cmdlen);
+    } else {
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map2f,cmdlen+4);
+	__GLX_PUT_LONG(8,target);
+	__GLX_PUT_FLOAT(12,u1);
+	__GLX_PUT_FLOAT(16,u2);
+	__GLX_PUT_LONG(20,uord);
+	__GLX_PUT_FLOAT(24,v1);
+	__GLX_PUT_FLOAT(28,v2);
+	__GLX_PUT_LONG(32,vord);
+
+	if ((vstr != k) || (ustr != k*vord)) {
+	    GLfloat *buf;
+
+	    buf = (GLfloat *) Xmalloc(compsize);
+	    if (!buf) {
+		__glXSetError(gc, GL_OUT_OF_MEMORY);
+		return;
+	    }
+	    /*
+	    ** Pack into a u-major ordering.
+	    */
+	    __glFillMap2f(k, uord, vord, ustr, vstr, pnts, buf);
+	    __glXSendLargeCommand(gc, pc, 36, buf, compsize);
+	    Xfree((char*) buf);
+	} else {
+	    /* Data is already packed.  Just send it out */
+	    __glXSendLargeCommand(gc, pc, 36, pnts, compsize);
+	}
+    }
+}
+
+void __indirect_glEnable(GLenum cap)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if (!gc->currentDpy) return;
+
+    switch(cap) {
+	case GL_COLOR_ARRAY:
+	case GL_EDGE_FLAG_ARRAY:
+	case GL_INDEX_ARRAY:
+	case GL_NORMAL_ARRAY:
+	case GL_TEXTURE_COORD_ARRAY:
+	case GL_VERTEX_ARRAY:
+	case GL_SECONDARY_COLOR_ARRAY:
+	case GL_FOG_COORD_ARRAY:
+	    __indirect_glEnableClientState(cap);
+	    return;
+	default:
+	    break;
+    }
+
+    __GLX_BEGIN(X_GLrop_Enable,8);
+    __GLX_PUT_LONG(4,cap);
+    __GLX_END(8);
+}
+
+void __indirect_glDisable(GLenum cap)
+{
+    __GLX_DECLARE_VARIABLES();
+
+    __GLX_LOAD_VARIABLES();
+    if (!gc->currentDpy) return;
+
+    switch(cap) {
+	case GL_COLOR_ARRAY:
+	case GL_EDGE_FLAG_ARRAY:
+	case GL_INDEX_ARRAY:
+	case GL_NORMAL_ARRAY:
+	case GL_TEXTURE_COORD_ARRAY:
+	case GL_VERTEX_ARRAY:
+	case GL_SECONDARY_COLOR_ARRAY:
+	case GL_FOG_COORD_ARRAY:
+	    __indirect_glDisableClientState(cap);
+	    return;
+	default:
+	    break;
+    }
+
+    __GLX_BEGIN(X_GLrop_Disable,8);
+    __GLX_PUT_LONG(4,cap);
+    __GLX_END(8);
+}
diff --git a/src/glx/x11/renderpix.c b/src/glx/x11/renderpix.c
new file mode 100644
index 00000000000..b7d01dc6795
--- /dev/null
+++ b/src/glx/x11/renderpix.c
@@ -0,0 +1,215 @@
+/* $XFree86: xc/lib/GL/glx/renderpix.c,v 1.5 2003/09/28 20:15:04 alanh Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+/*
+ * (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 "packrender.h"
+#include "indirect.h"
+
+/**
+ * Send a large image to the server.  If necessary, a buffer is allocated
+ * to hold the unpacked data that is copied from the clients memory.
+ * 
+ * \param gc        Current GLX context
+ * \param compsize  Size, in bytes, of the image portion
+ * \param dim       Number of dimensions of the image
+ * \param width     Width of the image
+ * \param height    Height of the image, must be 1 for 1D images
+ * \param depth     Depth of the image, must be 1 for 1D or 2D images
+ * \param format    Format of the image
+ * \param type      Data type of the image
+ * \param src       Pointer to the image data
+ * \param pc        Pointer to end of the command header
+ * \param modes     Pointer to the pixel unpack data
+ *
+ * \todo
+ * Modify this function so that \c NULL images are sent using
+ * \c __glXSendLargeChunk instead of __glXSendLargeCommand.  Doing this
+ * will eliminate the need to allocate a buffer for that case.
+ *
+ * \bugs
+ * The \c fastImageUnpack path, which is thankfully never used, is completely
+ * broken.
+ */
+void
+__glXSendLargeImage(__GLXcontext *gc, GLint compsize, GLint dim,
+		    GLint width, GLint height, GLint depth,
+		    GLenum format, GLenum type, const GLvoid *src,
+		    GLubyte *pc, GLubyte *modes)
+{
+    if ( !gc->fastImageUnpack || (src == NULL) ) {
+	/* Allocate a temporary holding buffer */
+	GLubyte *buf = (GLubyte *) Xmalloc(compsize);
+	if (!buf) {
+	    __glXSetError(gc, GL_OUT_OF_MEMORY);
+	    return;
+	}
+
+	/* Apply pixel store unpack modes to copy data into buf */
+	if ( src != NULL ) {
+	    (*gc->fillImage)(gc, dim, width, height, depth, format, type,
+			     src, buf, modes);
+	}
+	else {
+	    if ( dim < 3 ) {
+		(void) memcpy( modes, __glXDefaultPixelStore + 4, 20 );
+	    }
+	    else {
+		(void) memcpy( modes, __glXDefaultPixelStore + 0, 36 );
+	    }
+	}
+
+	/* Send large command */
+	__glXSendLargeCommand(gc, gc->pc, pc - gc->pc, buf, compsize);
+
+	/* Free buffer */
+	Xfree((char*) buf);
+    } else {
+	/* Just send the data straight as is */
+	__glXSendLargeCommand(gc, gc->pc, pc - gc->pc, pc, compsize);
+    }
+}
+
+/************************************************************************/
+
+/**
+ * Implement GLX protocol for \c glSeparableFilter2D.
+ *
+ * \bugs
+ * The \c fastImageUnpack path, which is thankfully never used, is completely
+ * broken.
+ */
+void __indirect_glSeparableFilter2D(GLenum target, GLenum internalformat,
+				GLsizei width, GLsizei height, GLenum format,
+				GLenum type, const GLvoid *row,
+				const GLvoid *column)
+{
+    __GLX_DECLARE_VARIABLES();
+    GLuint compsize2, hdrlen, totalhdrlen, image1len, image2len;
+
+    __GLX_LOAD_VARIABLES();
+    compsize = __glImageSize(width, 1, 1, format, type, 0);
+    compsize2 = __glImageSize(height, 1, 1, format, type, 0);
+    totalhdrlen = __GLX_PAD(__GLX_CONV_FILT_CMD_HDR_SIZE);
+    hdrlen = __GLX_PAD(__GLX_CONV_FILT_HDR_SIZE);
+    image1len = __GLX_PAD(compsize);
+    image2len = __GLX_PAD(compsize2);
+    cmdlen = totalhdrlen + image1len + image2len;
+    if (!gc->currentDpy) return;
+
+    if (cmdlen <= gc->maxSmallRenderCommandSize) {
+	/* Use GLXRender protocol to send small command */
+	__GLX_BEGIN_VARIABLE_WITH_PIXEL(X_GLrop_SeparableFilter2D, cmdlen);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,internalformat);
+	__GLX_PUT_LONG(8,width);
+	__GLX_PUT_LONG(12,height);
+	__GLX_PUT_LONG(16,format);
+	__GLX_PUT_LONG(20,type);
+	pc += hdrlen;
+	if (compsize > 0) {
+	    (*gc->fillImage)(gc, 1, width, 1, 1, format, type,
+			     row, pc, pixelHeaderPC);
+	    pc += image1len;
+	}
+	if (compsize2 > 0) {
+            (*gc->fillImage)(gc, 1, height, 1, 1, format, type,
+			     column, pc, NULL);
+	    pc += image2len;
+	}
+	if ((compsize == 0) && (compsize2 == 0)) {
+	    /* Setup default store modes */
+	    (void) memcpy( pixelHeaderPC, __glXDefaultPixelStore + 4, 20 );
+	}
+	__GLX_END(0);
+    } else {
+	const GLint bufsize = image1len + image2len;
+
+	/* Use GLXRenderLarge protocol to send command */
+	__GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(X_GLrop_SeparableFilter2D,cmdlen+4);
+	__GLX_PUT_LONG(0,target);
+	__GLX_PUT_LONG(4,internalformat);
+	__GLX_PUT_LONG(8,width);
+	__GLX_PUT_LONG(12,height);
+	__GLX_PUT_LONG(16,format);
+	__GLX_PUT_LONG(20,type);
+	pc += hdrlen;
+
+	if (!gc->fastImageUnpack) {
+	    /* Allocate a temporary holding buffer */
+	    GLubyte *buf = (GLubyte *) Xmalloc(bufsize);
+	    if (!buf) {
+		__glXSetError(gc, GL_OUT_OF_MEMORY);
+		return;
+	    }
+	    (*gc->fillImage)(gc, 1, width, 1, 1, format, type, row, buf, pixelHeaderPC);
+
+	    (*gc->fillImage)(gc, 1, height, 1, 1, format, type, column,
+				 buf + image1len, pixelHeaderPC);
+
+	    /* Send large command */
+	    __glXSendLargeCommand(gc, gc->pc, (GLint)(pc - gc->pc), buf, bufsize);
+	    /* Free buffer */
+	    Xfree((char*) buf);
+	} else {
+	    /* Just send the data straight as is */
+	    __glXSendLargeCommand(gc, gc->pc, (GLint)(pc - gc->pc), pc, bufsize);
+	}
+    }
+}
diff --git a/src/glx/x11/single2.c b/src/glx/x11/single2.c
new file mode 100644
index 00000000000..1c3b8f08ee2
--- /dev/null
+++ b/src/glx/x11/single2.c
@@ -0,0 +1,833 @@
+/* $XFree86: xc/lib/GL/glx/single2.c,v 1.10 2004/02/11 19:48:16 dawes Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include <stdio.h>
+#include <assert.h>
+#include "glxclient.h"
+#include "packsingle.h"
+#include "glxextensions.h"
+#include "indirect.h"
+#include "indirect_vertex_array.h"
+
+/* Used for GL_ARB_transpose_matrix */
+static void TransposeMatrixf(GLfloat m[16])
+{
+    int i, j;
+    for (i = 0; i < 4; i++) {
+        for (j = 0; j < i; j++) {
+            GLfloat tmp = m[i*4+j];
+            m[i*4+j] = m[j*4+i];
+            m[j*4+i] = tmp;
+        }
+    }
+}
+
+/* Used for GL_ARB_transpose_matrix */
+static void TransposeMatrixb(GLboolean m[16])
+{
+    int i, j;
+    for (i = 0; i < 4; i++) {
+        for (j = 0; j < i; j++) {
+            GLboolean tmp = m[i*4+j];
+            m[i*4+j] = m[j*4+i];
+            m[j*4+i] = tmp;
+        }
+    }
+}
+
+/* Used for GL_ARB_transpose_matrix */
+static void TransposeMatrixd(GLdouble m[16])
+{
+    int i, j;
+    for (i = 0; i < 4; i++) {
+        for (j = 0; j < i; j++) {
+            GLdouble tmp = m[i*4+j];
+            m[i*4+j] = m[j*4+i];
+            m[j*4+i] = tmp;
+        }
+    }
+}
+
+/* Used for GL_ARB_transpose_matrix */
+static void TransposeMatrixi(GLint m[16])
+{
+    int i, j;
+    for (i = 0; i < 4; i++) {
+        for (j = 0; j < i; j++) {
+            GLint tmp = m[i*4+j];
+            m[i*4+j] = m[j*4+i];
+            m[j*4+i] = tmp;
+        }
+    }
+}
+
+
+/**
+ * Remap a transpose-matrix enum to a non-transpose-matrix enum.  Enums
+ * that are not transpose-matrix enums are unaffected.
+ */
+static GLenum
+RemapTransposeEnum( GLenum e )
+{
+    switch( e ) {
+    case GL_TRANSPOSE_MODELVIEW_MATRIX:
+    case GL_TRANSPOSE_PROJECTION_MATRIX:
+    case GL_TRANSPOSE_TEXTURE_MATRIX:
+	return e - (GL_TRANSPOSE_MODELVIEW_MATRIX - GL_MODELVIEW_MATRIX);
+    case GL_TRANSPOSE_COLOR_MATRIX:
+	return GL_COLOR_MATRIX;
+    default:
+	return e;
+    };
+}
+
+
+GLenum __indirect_glGetError(void)
+{
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    GLuint retval = GL_NO_ERROR;
+    xGLXGetErrorReply reply;
+
+    if (gc->error) {
+	/* Use internal error first */
+	retval = gc->error;
+	gc->error = GL_NO_ERROR;
+	return retval;
+    }
+
+    __GLX_SINGLE_LOAD_VARIABLES();
+    __GLX_SINGLE_BEGIN(X_GLsop_GetError,0);
+    __GLX_SINGLE_READ_XREPLY();
+    retval = reply.error;
+    __GLX_SINGLE_END();
+
+    return retval;
+}
+
+
+/**
+ * Get the selected attribute from the client state.
+ * 
+ * \returns
+ * On success \c GL_TRUE is returned.  Otherwise, \c GL_FALSE is returned.
+ */
+static GLboolean
+get_client_data( __GLXattribute * state, GLenum cap, GLintptr * data )
+{
+    GLboolean retval = GL_TRUE;
+    const GLint tex_unit = __glXGetActiveTextureUnit( state );
+
+
+    switch( cap ) {
+    case GL_VERTEX_ARRAY:
+    case GL_NORMAL_ARRAY:
+    case GL_COLOR_ARRAY:
+    case GL_INDEX_ARRAY:
+    case GL_EDGE_FLAG_ARRAY:
+    case GL_SECONDARY_COLOR_ARRAY:
+    case GL_FOG_COORD_ARRAY:
+	retval = __glXGetArrayEnable( state, cap, 0, data );
+	break;
+
+    case GL_VERTEX_ARRAY_SIZE:
+	retval = __glXGetArraySize( state, GL_VERTEX_ARRAY, 0, data );
+	break;
+    case GL_COLOR_ARRAY_SIZE:
+	retval = __glXGetArraySize( state, GL_COLOR_ARRAY, 0, data );
+	break;
+    case GL_SECONDARY_COLOR_ARRAY_SIZE:
+	retval = __glXGetArraySize( state, GL_SECONDARY_COLOR_ARRAY, 0, data );
+	break;
+
+    case GL_VERTEX_ARRAY_TYPE:
+	retval = __glXGetArrayType( state, GL_VERTEX_ARRAY, 0, data );
+	break;
+    case GL_NORMAL_ARRAY_TYPE:
+	retval = __glXGetArrayType( state, GL_NORMAL_ARRAY, 0, data );
+	break;
+    case GL_INDEX_ARRAY_TYPE:
+	retval = __glXGetArrayType( state, GL_INDEX_ARRAY, 0, data );
+	break;
+    case GL_COLOR_ARRAY_TYPE:
+	retval = __glXGetArrayType( state, GL_COLOR_ARRAY, 0, data );
+	break;
+    case GL_SECONDARY_COLOR_ARRAY_TYPE:
+	retval = __glXGetArrayType( state, GL_SECONDARY_COLOR_ARRAY, 0, data );
+	break;
+    case GL_FOG_COORD_ARRAY_TYPE:
+	retval = __glXGetArrayType( state, GL_FOG_COORD_ARRAY, 0, data );
+	break;
+
+    case GL_VERTEX_ARRAY_STRIDE:
+	retval = __glXGetArrayStride( state, GL_VERTEX_ARRAY, 0, data );
+	break;
+    case GL_NORMAL_ARRAY_STRIDE:
+	retval = __glXGetArrayStride( state, GL_NORMAL_ARRAY, 0, data );
+	break;
+    case GL_INDEX_ARRAY_STRIDE:
+	retval = __glXGetArrayStride( state, GL_INDEX_ARRAY, 0, data );
+	break;
+    case GL_EDGE_FLAG_ARRAY_STRIDE:
+	retval = __glXGetArrayStride( state, GL_EDGE_FLAG_ARRAY, 0, data );
+	break;
+    case GL_COLOR_ARRAY_STRIDE:
+	retval = __glXGetArrayStride( state, GL_COLOR_ARRAY, 0, data );
+	break;
+    case GL_SECONDARY_COLOR_ARRAY_STRIDE:
+	retval = __glXGetArrayStride( state, GL_SECONDARY_COLOR_ARRAY, 0, data );
+	break;
+    case GL_FOG_COORD_ARRAY_STRIDE:
+	retval = __glXGetArrayStride( state, GL_FOG_COORD_ARRAY, 0, data );
+	break;
+
+    case GL_TEXTURE_COORD_ARRAY:
+	retval = __glXGetArrayEnable( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
+	break;
+    case GL_TEXTURE_COORD_ARRAY_SIZE:
+	retval = __glXGetArraySize( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
+	break;
+    case GL_TEXTURE_COORD_ARRAY_TYPE:
+	retval = __glXGetArrayType( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
+	break;
+    case GL_TEXTURE_COORD_ARRAY_STRIDE:
+	retval = __glXGetArrayStride( state, GL_TEXTURE_COORD_ARRAY, tex_unit, data );
+	break;
+
+    case GL_MAX_ELEMENTS_VERTICES:
+    case GL_MAX_ELEMENTS_INDICES:
+	retval = GL_TRUE;
+	*data = ~0UL;
+	break;
+
+    
+    case GL_PACK_ROW_LENGTH:
+	*data = (GLintptr)state->storePack.rowLength;
+	break;
+    case GL_PACK_IMAGE_HEIGHT:
+	*data = (GLintptr)state->storePack.imageHeight;
+	break;
+    case GL_PACK_SKIP_ROWS:
+	*data = (GLintptr)state->storePack.skipRows;
+	break;
+    case GL_PACK_SKIP_PIXELS:
+	*data = (GLintptr)state->storePack.skipPixels;
+	break;
+    case GL_PACK_SKIP_IMAGES:
+	*data = (GLintptr)state->storePack.skipImages;
+	break;
+    case GL_PACK_ALIGNMENT:
+	*data = (GLintptr)state->storePack.alignment;
+	break;
+    case GL_PACK_SWAP_BYTES:
+	*data = (GLintptr)state->storePack.swapEndian;
+	break;
+    case GL_PACK_LSB_FIRST:
+	*data = (GLintptr)state->storePack.lsbFirst;
+	break;
+    case GL_UNPACK_ROW_LENGTH:
+	*data = (GLintptr)state->storeUnpack.rowLength;
+	break;
+    case GL_UNPACK_IMAGE_HEIGHT:
+	*data = (GLintptr)state->storeUnpack.imageHeight;
+	break;
+    case GL_UNPACK_SKIP_ROWS:
+	*data = (GLintptr)state->storeUnpack.skipRows;
+	break;
+    case GL_UNPACK_SKIP_PIXELS:
+	*data = (GLintptr)state->storeUnpack.skipPixels;
+	break;
+    case GL_UNPACK_SKIP_IMAGES:
+	*data = (GLintptr)state->storeUnpack.skipImages;
+	break;
+    case GL_UNPACK_ALIGNMENT:
+	*data = (GLintptr)state->storeUnpack.alignment;
+	break;
+    case GL_UNPACK_SWAP_BYTES:
+	*data = (GLintptr)state->storeUnpack.swapEndian;
+	break;
+    case GL_UNPACK_LSB_FIRST:
+	*data = (GLintptr)state->storeUnpack.lsbFirst;
+	break;
+    case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
+	*data = (GLintptr)__GL_CLIENT_ATTRIB_STACK_DEPTH;
+	break;
+    case GL_CLIENT_ACTIVE_TEXTURE:
+	*data = (GLintptr)(tex_unit + GL_TEXTURE0);
+	break;
+
+    default:
+	retval = GL_FALSE;
+	break;
+    }
+
+
+    return retval;
+}
+
+
+void __indirect_glGetBooleanv(GLenum val, GLboolean *b)
+{
+    const GLenum origVal = val;
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    xGLXSingleReply reply;
+
+    val = RemapTransposeEnum( val );
+
+    __GLX_SINGLE_LOAD_VARIABLES();
+    __GLX_SINGLE_BEGIN(X_GLsop_GetBooleanv,4);
+    __GLX_SINGLE_PUT_LONG(0,val);
+    __GLX_SINGLE_READ_XREPLY();
+    __GLX_SINGLE_GET_SIZE(compsize);
+
+    if (compsize == 0) {
+	/*
+	** Error occured; don't modify user's buffer.
+	*/
+    } else {
+	GLintptr data;
+
+	/*
+	** We still needed to send the request to the server in order to
+	** find out whether it was legal to make a query (it's illegal,
+	** for example, to call a query between glBegin() and glEnd()).
+	*/
+
+	if ( get_client_data( state, val, & data ) ) {
+	    *b = (GLboolean) data;
+	}
+	else {
+	    /*
+	     ** Not a local value, so use what we got from the server.
+	     */
+	    if (compsize == 1) {
+		__GLX_SINGLE_GET_CHAR(b);
+	    } else {
+		__GLX_SINGLE_GET_CHAR_ARRAY(b,compsize);
+		if (val != origVal) {
+		    /* matrix transpose */
+		    TransposeMatrixb(b);
+                }
+	    }
+	}
+    }
+    __GLX_SINGLE_END();
+}
+
+void __indirect_glGetDoublev(GLenum val, GLdouble *d)
+{
+    const GLenum origVal = val;
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    xGLXSingleReply reply;
+
+    val = RemapTransposeEnum( val );
+
+    __GLX_SINGLE_LOAD_VARIABLES();
+    __GLX_SINGLE_BEGIN(X_GLsop_GetDoublev,4);
+    __GLX_SINGLE_PUT_LONG(0,val);
+    __GLX_SINGLE_READ_XREPLY();
+    __GLX_SINGLE_GET_SIZE(compsize);
+
+    if (compsize == 0) {
+	/*
+	** Error occured; don't modify user's buffer.
+	*/
+    } else {
+	GLintptr data;
+
+	/*
+	** We still needed to send the request to the server in order to
+	** find out whether it was legal to make a query (it's illegal,
+	** for example, to call a query between glBegin() and glEnd()).
+	*/
+
+	if ( get_client_data( state, val, & data ) ) {
+	    *d = (GLdouble) data;
+	}
+	else {
+	    /*
+	     ** Not a local value, so use what we got from the server.
+	     */
+	    if (compsize == 1) {
+		__GLX_SINGLE_GET_DOUBLE(d);
+	    } else {
+		__GLX_SINGLE_GET_DOUBLE_ARRAY(d,compsize);
+		if (val != origVal) {
+		    /* matrix transpose */
+		    TransposeMatrixd(d);
+		}
+	    }
+	}
+    }
+    __GLX_SINGLE_END();
+}
+
+void __indirect_glGetFloatv(GLenum val, GLfloat *f)
+{
+    const GLenum origVal = val;
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    xGLXSingleReply reply;
+
+    val = RemapTransposeEnum( val );
+
+    __GLX_SINGLE_LOAD_VARIABLES();
+    __GLX_SINGLE_BEGIN(X_GLsop_GetFloatv,4);
+    __GLX_SINGLE_PUT_LONG(0,val);
+    __GLX_SINGLE_READ_XREPLY();
+    __GLX_SINGLE_GET_SIZE(compsize);
+
+    if (compsize == 0) {
+	/*
+	** Error occured; don't modify user's buffer.
+	*/
+    } else {
+	GLintptr data;
+
+	/*
+	** We still needed to send the request to the server in order to
+	** find out whether it was legal to make a query (it's illegal,
+	** for example, to call a query between glBegin() and glEnd()).
+	*/
+
+	if ( get_client_data( state, val, & data ) ) {
+	    *f = (GLfloat) data;
+	}
+	else {
+	    /*
+	     ** Not a local value, so use what we got from the server.
+	     */
+	    if (compsize == 1) {
+		__GLX_SINGLE_GET_FLOAT(f);
+	    } else {
+		__GLX_SINGLE_GET_FLOAT_ARRAY(f,compsize);
+		if (val != origVal) {
+		    /* matrix transpose */
+		    TransposeMatrixf(f);
+                }
+	    }
+	}
+    }
+    __GLX_SINGLE_END();
+}
+
+void __indirect_glGetIntegerv(GLenum val, GLint *i)
+{
+    const GLenum origVal = val;
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    xGLXSingleReply reply;
+
+    val = RemapTransposeEnum( val );
+
+    __GLX_SINGLE_LOAD_VARIABLES();
+    __GLX_SINGLE_BEGIN(X_GLsop_GetIntegerv,4);
+    __GLX_SINGLE_PUT_LONG(0,val);
+    __GLX_SINGLE_READ_XREPLY();
+    __GLX_SINGLE_GET_SIZE(compsize);
+
+    if (compsize == 0) {
+	/*
+	** Error occured; don't modify user's buffer.
+	*/
+    } else {
+	GLintptr data;
+
+	/*
+	** We still needed to send the request to the server in order to
+	** find out whether it was legal to make a query (it's illegal,
+	** for example, to call a query between glBegin() and glEnd()).
+	*/
+
+	if ( get_client_data( state, val, & data ) ) {
+	    *i = (GLint) data;
+	}
+	else {
+	    /*
+	     ** Not a local value, so use what we got from the server.
+	     */
+	    if (compsize == 1) {
+		__GLX_SINGLE_GET_LONG(i);
+	    } else {
+		__GLX_SINGLE_GET_LONG_ARRAY(i,compsize);
+		if (val != origVal) {
+		    /* matrix transpose */
+		    TransposeMatrixi(i);
+                }
+	    }
+	}
+    }
+    __GLX_SINGLE_END();
+}
+
+/*
+** Send all pending commands to server.
+*/
+void __indirect_glFlush(void)
+{
+    __GLX_SINGLE_DECLARE_VARIABLES();
+
+    if (!dpy) return;
+
+    __GLX_SINGLE_LOAD_VARIABLES();
+    __GLX_SINGLE_BEGIN(X_GLsop_Flush,0);
+    __GLX_SINGLE_END();
+
+    /* And finally flush the X protocol data */
+    XFlush(dpy);
+}
+
+void __indirect_glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
+{
+    __GLX_SINGLE_DECLARE_VARIABLES();
+
+    if (!dpy) return;
+
+    __GLX_SINGLE_LOAD_VARIABLES();
+    __GLX_SINGLE_BEGIN(X_GLsop_FeedbackBuffer,8);
+    __GLX_SINGLE_PUT_LONG(0,size);
+    __GLX_SINGLE_PUT_LONG(4,type);
+    __GLX_SINGLE_END();
+
+    gc->feedbackBuf = buffer;
+}
+
+void __indirect_glSelectBuffer(GLsizei numnames, GLuint *buffer)
+{
+    __GLX_SINGLE_DECLARE_VARIABLES();
+
+    if (!dpy) return;
+
+    __GLX_SINGLE_LOAD_VARIABLES();
+    __GLX_SINGLE_BEGIN(X_GLsop_SelectBuffer,4);
+    __GLX_SINGLE_PUT_LONG(0,numnames);
+    __GLX_SINGLE_END();
+
+    gc->selectBuf = buffer;
+}
+
+GLint __indirect_glRenderMode(GLenum mode)
+{
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    GLint retval = 0;
+    xGLXRenderModeReply reply;
+
+    if (!dpy) return -1;
+
+    __GLX_SINGLE_LOAD_VARIABLES();
+    __GLX_SINGLE_BEGIN(X_GLsop_RenderMode,4);
+    __GLX_SINGLE_PUT_LONG(0,mode);
+    __GLX_SINGLE_READ_XREPLY();
+    __GLX_SINGLE_GET_RETVAL(retval,GLint);
+
+    if (reply.newMode != mode) {
+	/*
+	** Switch to new mode did not take effect, therefore an error
+	** occured.  When an error happens the server won't send us any
+	** other data.
+	*/
+    } else {
+	/* Read the feedback or selection data */
+	if (gc->renderMode == GL_FEEDBACK) {
+	    __GLX_SINGLE_GET_SIZE(compsize);
+	    __GLX_SINGLE_GET_FLOAT_ARRAY(gc->feedbackBuf, compsize);
+	} else
+	if (gc->renderMode == GL_SELECT) {
+	    __GLX_SINGLE_GET_SIZE(compsize);
+	    __GLX_SINGLE_GET_LONG_ARRAY(gc->selectBuf, compsize);
+	}
+	gc->renderMode = mode;
+    }
+    __GLX_SINGLE_END();
+
+    return retval;
+}
+
+void __indirect_glFinish(void)
+{
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    xGLXSingleReply reply;
+
+    __GLX_SINGLE_LOAD_VARIABLES();
+    __GLX_SINGLE_BEGIN(X_GLsop_Finish,0);
+    __GLX_SINGLE_READ_XREPLY();
+    __GLX_SINGLE_END();
+}
+
+
+/**
+ * Extract the major and minor version numbers from a version string.
+ */
+static void
+version_from_string( const char * ver, 
+		     int * major_version, int * minor_version )
+{
+    const char * end;
+    long major;
+    long minor;
+
+    major = strtol( ver, (char **) & end, 10 );
+    minor = strtol( end + 1, NULL, 10 );
+    *major_version = major;
+    *minor_version = minor;
+}
+
+
+const GLubyte *__indirect_glGetString(GLenum name)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    Display *dpy = gc->currentDpy;
+    GLubyte *s = NULL;
+
+    if (!dpy) return 0;
+
+    /*
+    ** Return the cached copy if the string has already been fetched
+    */
+    switch(name) {
+      case GL_VENDOR:
+	if (gc->vendor) return gc->vendor;
+	break;
+      case GL_RENDERER:
+	if (gc->renderer) return gc->renderer;
+	break;
+      case GL_VERSION:
+	if (gc->version) return gc->version;
+	break;
+      case GL_EXTENSIONS:
+	if (gc->extensions) return gc->extensions;
+	break;
+      default:
+	__glXSetError(gc, GL_INVALID_ENUM);
+	return 0;
+    }
+
+    /*
+    ** Get requested string from server
+    */
+
+    (void) __glXFlushRenderBuffer( gc, gc->pc );
+    s = (GLubyte *) __glXGetStringFromServer( dpy, gc->majorOpcode,
+				  X_GLsop_GetString, gc->currentContextTag,
+				  name );
+    if (!s) {
+	/* Throw data on the floor */
+	__glXSetError(gc, GL_OUT_OF_MEMORY);
+    } else {
+	/*
+	** Update local cache
+	*/
+	switch(name) {
+	case GL_VENDOR:
+	    gc->vendor = s;
+	    break;
+
+	case GL_RENDERER:
+	    gc->renderer = s;
+	    break;
+
+	case GL_VERSION: {
+	    int client_major;
+	    int client_minor;
+
+	    version_from_string( (char *) s, 
+				 & gc->server_major, & gc->server_minor );
+	    __glXGetGLVersion( & client_major, & client_minor );
+
+	    if ( (gc->server_major < client_major)
+		 || ((gc->server_major == client_major) 
+		     && (gc->server_minor <= client_minor)) ) {
+		gc->version = s;
+	    }
+	    else {
+		/* Allow 7 bytes for the client-side GL version.  This allows
+		 * for upto version 999.999.  I'm not holding my breath for
+		 * that one!  The extra 4 is for the ' ()\0' that will be
+		 * added.
+		 */
+		const size_t size = 7 + strlen( (char *) s ) + 4;
+
+		gc->version = Xmalloc( size );
+		if ( gc->version == NULL ) {
+		    /* If we couldn't allocate memory for the new string,
+		     * make a best-effort and just copy the client-side version
+		     * to the string and use that.  It probably doesn't
+		     * matter what is done here.  If there not memory available
+		     * for a short string, the system is probably going to die
+		     * soon anyway.
+		     */
+		    snprintf( (char *) s, strlen( (char *) s ) + 1, "%u.%u",
+			      client_major, client_minor );
+		    gc->version = s;
+		}
+		else {
+		    snprintf( (char *)gc->version, size, "%u.%u (%s)",
+			      client_major, client_minor, s );
+		    Xfree( s );
+		    s = gc->version;
+		}
+	    }
+	    break;
+	}
+
+	case GL_EXTENSIONS: {
+	    int major = 1;
+	    int minor = 0;
+
+	    /* This code is currently disabled.  I was reminded that some
+	     * vendors intentionally exclude some extensions from their
+	     * extension string that are part of the core version they
+	     * advertise.  In particular, on Nvidia drivers this means that
+	     * the functionality is supported by the driver, but is not
+	     * hardware accelerated.  For example, a TNT will show core
+	     * version 1.5, but most of the post-1.2 functionality is a
+	     * software fallback.
+	     * 
+	     * I don't want to break applications that rely on this odd
+	     * behavior.  At the same time, the code is written and tested,
+	     * so I didn't want to throw it away.  Therefore, the code is here
+	     * but disabled.  In the future, we may wish to and an environment
+	     * variable to enable it.
+	     */
+	    
+#if 0
+	    /* Call glGetString just to make sure that gc->server_major and
+	     * gc->server_minor are set.  This version may be higher than we
+	     * can completely support, but it may imply support for some
+	     * extensions that we can support.
+	     * 
+	     * For example, at the time of this writing, the client-side
+	     * library only supports upto core GL version 1.2.  However, cubic
+	     * textures, multitexture, multisampling, and some other 1.3
+	     * features are supported.  If the server reports back version
+	     * 1.3, but does not report all of those extensions, we will
+	     * enable them.
+	     */
+	    (void *) glGetString( GL_VERSION );
+	    major = gc->server_major,
+	    minor = gc->server_minor;
+#endif
+
+	    __glXCalculateUsableGLExtensions( gc, (char *) s, major, minor );
+	    XFree( s );
+	    s = gc->extensions;
+	    break;
+	}
+	}
+    }
+    return s;
+}
+
+GLboolean __indirect_glIsEnabled(GLenum cap)
+{
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    xGLXSingleReply reply;
+    GLboolean retval = 0;
+    GLintptr enable;
+
+    if (!dpy) return 0;
+
+    switch(cap) {
+    case GL_VERTEX_ARRAY:
+    case GL_NORMAL_ARRAY:
+    case GL_COLOR_ARRAY:
+    case GL_INDEX_ARRAY:
+    case GL_EDGE_FLAG_ARRAY:
+    case GL_SECONDARY_COLOR_ARRAY:
+    case GL_FOG_COORD_ARRAY:
+	retval = __glXGetArrayEnable( state, cap, 0, & enable );
+	assert( retval );
+	return (GLboolean) enable;
+	break;
+    case GL_TEXTURE_COORD_ARRAY:
+	retval = __glXGetArrayEnable( state, GL_TEXTURE_COORD_ARRAY,
+				      __glXGetActiveTextureUnit( state ), & enable );
+	assert( retval );
+	return (GLboolean) enable;
+	break;
+    }
+
+    __GLX_SINGLE_LOAD_VARIABLES();
+    __GLX_SINGLE_BEGIN(X_GLsop_IsEnabled,4);
+    __GLX_SINGLE_PUT_LONG(0,cap);
+    __GLX_SINGLE_READ_XREPLY();
+    __GLX_SINGLE_GET_RETVAL(retval, GLboolean);
+    __GLX_SINGLE_END();
+    return retval;
+}
+
+void __indirect_glGetPointerv(GLenum pname, void **params)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+    Display *dpy = gc->currentDpy;
+
+    if (!dpy) return;
+
+    switch(pname) {
+    case GL_VERTEX_ARRAY_POINTER:
+    case GL_NORMAL_ARRAY_POINTER:
+    case GL_COLOR_ARRAY_POINTER:
+    case GL_INDEX_ARRAY_POINTER:
+    case GL_EDGE_FLAG_ARRAY_POINTER:
+	__glXGetArrayPointer( state, pname - GL_VERTEX_ARRAY_POINTER 
+			      + GL_VERTEX_ARRAY,
+			      0, params );
+	return;
+    case GL_TEXTURE_COORD_ARRAY_POINTER:
+	__glXGetArrayPointer( state, GL_TEXTURE_COORD_ARRAY, 
+			      __glXGetActiveTextureUnit( state ), params );
+	return;
+    case GL_SECONDARY_COLOR_ARRAY_POINTER:
+    case GL_FOG_COORD_ARRAY_POINTER:
+	__glXGetArrayPointer( state, pname - GL_FOG_COORD_ARRAY_POINTER
+			      + GL_FOG_COORD_ARRAY, 
+			      0, params );
+	return;
+    case GL_FEEDBACK_BUFFER_POINTER:
+	*params = (void *)gc->feedbackBuf;
+	return;
+    case GL_SELECTION_BUFFER_POINTER:
+	*params = (void *)gc->selectBuf;
+	return;
+    default:
+	__glXSetError(gc, GL_INVALID_ENUM);
+	return;
+    }
+}
+
diff --git a/src/glx/x11/singlepix.c b/src/glx/x11/singlepix.c
new file mode 100644
index 00000000000..4a10083b8fe
--- /dev/null
+++ b/src/glx/x11/singlepix.c
@@ -0,0 +1,105 @@
+/* $XFree86: xc/lib/GL/glx/singlepix.c,v 1.3 2001/03/21 16:04:39 dawes Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include "packsingle.h"
+#include "indirect.h"
+
+void __indirect_glGetSeparableFilter(GLenum target, GLenum format, GLenum type,
+			  GLvoid *row, GLvoid *column, GLvoid *span)
+{
+    __GLX_SINGLE_DECLARE_VARIABLES();
+    const __GLXattribute * state;
+    xGLXGetSeparableFilterReply reply;
+    GLubyte *rowBuf, *colBuf;
+
+    if (!dpy) return;
+    __GLX_SINGLE_LOAD_VARIABLES();
+    state = gc->client_state_private;
+
+    /* Send request */
+    __GLX_SINGLE_BEGIN(X_GLsop_GetSeparableFilter, __GLX_PAD(13));
+    __GLX_SINGLE_PUT_LONG(0,target);
+    __GLX_SINGLE_PUT_LONG(4,format);
+    __GLX_SINGLE_PUT_LONG(8,type);
+    __GLX_SINGLE_PUT_CHAR(12,state->storePack.swapEndian);
+    __GLX_SINGLE_READ_XREPLY();
+    compsize = reply.length << 2;
+
+    if (compsize != 0) {
+	GLint width, height;
+	GLint widthsize, heightsize;
+
+	width = reply.width;
+	height = reply.height;
+
+	widthsize = __glImageSize(width,1,1,format, type, 0);
+	heightsize = __glImageSize(height,1,1,format, type, 0);
+
+	/* Allocate a holding buffer to transform the data from */
+	rowBuf = (GLubyte*) Xmalloc(widthsize);
+	if (!rowBuf) {
+	    /* Throw data away */
+	    _XEatData(dpy, compsize);
+	    __glXSetError(gc, GL_OUT_OF_MEMORY);
+	    UnlockDisplay(dpy);
+	    SyncHandle();
+	    return;
+	} else {
+	    __GLX_SINGLE_GET_CHAR_ARRAY(((char*)rowBuf),widthsize);
+	    __glEmptyImage(gc, 1, width, 1, 1, format, type, rowBuf, row);
+	    Xfree((char*) rowBuf);
+	}
+	colBuf = (GLubyte*) Xmalloc(heightsize);
+	if (!colBuf) {
+	    /* Throw data away */
+	    _XEatData(dpy, compsize - __GLX_PAD(widthsize));
+	    __glXSetError(gc, GL_OUT_OF_MEMORY);
+	    UnlockDisplay(dpy);
+	    SyncHandle();
+	    return;
+	} else {
+	    __GLX_SINGLE_GET_CHAR_ARRAY(((char*)colBuf),heightsize);
+	    __glEmptyImage(gc, 1, height, 1, 1, format, type, colBuf, column);
+	    Xfree((char*) colBuf);
+	}
+    } else {
+	/*
+	** don't modify user's buffer.
+	*/
+    }
+    __GLX_SINGLE_END();
+    
+}
diff --git a/src/glx/x11/vertarr.c b/src/glx/x11/vertarr.c
new file mode 100644
index 00000000000..483a166ea2b
--- /dev/null
+++ b/src/glx/x11/vertarr.c
@@ -0,0 +1,203 @@
+/* $XFree86: xc/lib/GL/glx/vertarr.c,v 1.4 2001/03/25 05:32:00 tsi Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: The application programming interfaces
+** established by SGI in conjunction with the Original Code are The
+** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
+** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
+** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
+** Window System(R) (Version 1.3), released October 19, 1998. This software
+** was created using the OpenGL(R) version 1.2.1 Sample Implementation
+** published by SGI, but has not been independently verified as being
+** compliant with the OpenGL(R) version 1.2.1 Specification.
+**
+*/
+
+#include "glxclient.h"
+#include "indirect.h"
+#include "indirect_vertex_array.h"
+
+
+/*****************************************************************************/
+
+/**
+ * \name Vertex array pointer bridge functions
+ *
+ * When EXT_vertex_array was moved into the core GL spec, the \c count
+ * parameter was lost.  This libGL really only wants to implement the GL 1.1
+ * version, but we need to support applications that were written to the old
+ * interface.  These bridge functions are part of the glue that makes this
+ * happen.
+ */
+/*@{*/
+void __indirect_glColorPointerEXT(GLint size, GLenum type, GLsizei stride,
+			    GLsizei count, const GLvoid * pointer )
+{
+    (void) count; __indirect_glColorPointer( size, type, stride, pointer );
+}
+
+void __indirect_glEdgeFlagPointerEXT(GLsizei stride,
+			       GLsizei count, const GLboolean * pointer )
+{
+    (void) count; __indirect_glEdgeFlagPointer( stride, pointer );
+}
+
+void __indirect_glIndexPointerEXT(GLenum type, GLsizei stride,
+			    GLsizei count, const GLvoid * pointer )
+{
+    (void) count; __indirect_glIndexPointer( type, stride, pointer );
+}
+
+void __indirect_glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count,
+			     const GLvoid * pointer )
+{
+    (void) count; __indirect_glNormalPointer( type, stride, pointer );
+}
+
+void __indirect_glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride,
+			       GLsizei count, const GLvoid * pointer )
+{
+    (void) count; __indirect_glTexCoordPointer( size, type, stride, pointer );
+}
+
+void __indirect_glVertexPointerEXT(GLint size, GLenum type, GLsizei stride,
+			    GLsizei count, const GLvoid * pointer )
+{
+    (void) count; __indirect_glVertexPointer( size, type, stride, pointer );
+}
+/*@}*/
+
+/*****************************************************************************/
+
+void __indirect_glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
+{
+    __GLXcontext *gc = __glXGetCurrentContext();
+    __GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
+
+#define NONE  {0, 0, 0}
+#define F(x)  {GL_FLOAT, x, x * sizeof(GLfloat)}
+#define UB4   {GL_UNSIGNED_BYTE, 4, 4 * sizeof(GLubyte)}
+
+    /* Each row in this array describes the elements of a particular
+     * interleaved array mode.  Each column describes, in the order in which
+     * they appear in the interleaved arrays, one of the four possible types
+     * of vertex data that can appear in an interleaved array.
+     */
+    struct {
+        /**
+	 * The enum describing the GL type, as would be passed to the
+	 * appropriate gl*Pointer function.
+	 */
+	GLushort type;
+
+        /**
+	 * Number of elements in the subarray, as would be passed (as the
+	 * \c size parameter) to the appropriate gl*Pointer function.
+	 */
+        GLubyte count;
+       
+        /**
+	 * True size of a single element in the subarray, as would be passed
+	 * (as the \c stride parameter) to the appropriate gl*Pointer
+	 * function.
+	 */
+        GLubyte size;
+    }
+    static const modes[14][4] = {
+      /* texture color normal vertex */
+	{NONE,   NONE, NONE,  F(2)}, /* GL_V2F */
+	{NONE,   NONE, NONE,  F(3)}, /* GL_V3F */
+	{NONE,   UB4,  NONE,  F(2)}, /* GL_C4UB_V2F */
+	{NONE,   UB4,  NONE,  F(3)}, /* GL_C4UB_V3F */
+	{NONE,   F(3), NONE,  F(3)}, /* GL_C3F_V3F */
+	{NONE,   NONE, F(3),  F(3)}, /* GL_N3F_V3F */
+	{NONE,   F(4), F(3),  F(3)}, /* GL_C4F_N3F_V3F */
+	{F(2),   NONE, NONE,  F(3)}, /* GL_T2F_V3F */
+	{F(4),   NONE, NONE,  F(4)}, /* GL_T4F_V4F */
+	{F(2),   UB4,  NONE,  F(3)}, /* GL_T2F_C4UB_V3F */
+	{F(2),   F(3), NONE,  F(3)}, /* GL_T2F_C3F_V3F */
+	{F(2),   NONE, F(3),  F(3)}, /* GL_T2F_N3F_V3F */
+	{F(2),   F(4), F(3),  F(3)}, /* GL_T2F_C4F_N3F_V3F */
+	{F(4),   F(4), F(3),  F(4)}, /* GL_T4F_C4F_N3F_V4F */
+    };
+#undef NONE
+#undef F
+#undef UB4
+
+    GLint trueStride, size;
+    int offsets[4];
+    unsigned i;
+    const int idx = format - GL_V2F;
+
+   
+    /* All valid formats are on the range [GL_V2F, GL_V2F+0x0D].  Since idx
+     * is just the format biased by -GL_V2F, all valid idx values are on the
+     * range [0, 0x0D].
+     */
+    if ( (idx < 0) || (idx > 0x0D) ) {
+        __glXSetError(gc, GL_INVALID_ENUM);
+        return;
+    }
+
+    if ( stride < 0 ) {
+        __glXSetError(gc, GL_INVALID_VALUE);
+        return;
+    }
+
+
+    /* If the 'count' for a subarray is non-zero, then the offset of its
+     * first element is at the currently accumulated 'size'.
+     */
+    size = 0;
+    for ( i = 0 ; i < 4 ; i++ ) {
+        offsets[i] = (modes[idx][i].count != 0) ? size : -1;
+        size += modes[idx][i].size;
+    }
+
+    trueStride = (stride == 0) ? size : stride;
+
+    __glXArrayDisableAll( state );
+
+    if ( offsets[0] >= 0 ) {
+	__indirect_glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+	__indirect_glTexCoordPointer( modes[idx][0].count, GL_FLOAT,
+				      trueStride, 
+				      (const char *) pointer );
+    }
+    if ( offsets[1] >= 0 ) {
+	__indirect_glEnableClientState(GL_COLOR_ARRAY);
+	__indirect_glColorPointer( modes[idx][1].count, modes[idx][1].type,
+				   trueStride, 
+				   (const char *) pointer + offsets[1] );
+    }
+    if ( offsets[2] >= 0 ) {
+	__indirect_glEnableClientState(GL_NORMAL_ARRAY);
+	__indirect_glNormalPointer( GL_FLOAT, trueStride,
+				    (const char *)pointer + offsets[2] );
+    }
+    __indirect_glEnableClientState(GL_VERTEX_ARRAY);
+    __indirect_glVertexPointer( modes[idx][3].count, GL_FLOAT,
+				trueStride, 
+				(const char *)pointer + offsets[3] );
+}
diff --git a/src/glx/x11/xf86dri.h b/src/glx/x11/xf86dri.h
new file mode 100644
index 00000000000..0a2bb24971d
--- /dev/null
+++ b/src/glx/x11/xf86dri.h
@@ -0,0 +1,122 @@
+/* $XFree86: xc/lib/GL/dri/xf86dri.h,v 1.8 2002/10/30 12:51:25 alanh Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+Copyright 2000 VA Linux Systems, Inc.
+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 PRECISION INSIGHT AND/OR ITS 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.
+
+**************************************************************************/
+
+/**
+ * \file xf86dri.h
+ * Protocol numbers and function prototypes for DRI X protocol.
+ *
+ * \author Kevin E. Martin <[email protected]>
+ * \author Jens Owen <[email protected]>
+ * \author Rickard E. (Rik) Faith <[email protected]>
+ */
+
+#ifndef _XF86DRI_H_
+#define _XF86DRI_H_
+
+#include <X11/Xfuncproto.h>
+#include <xf86drm.h>
+
+#define X_XF86DRIQueryVersion			0
+#define X_XF86DRIQueryDirectRenderingCapable	1
+#define X_XF86DRIOpenConnection			2
+#define X_XF86DRICloseConnection		3
+#define X_XF86DRIGetClientDriverName		4
+#define X_XF86DRICreateContext			5
+#define X_XF86DRIDestroyContext			6
+#define X_XF86DRICreateDrawable			7
+#define X_XF86DRIDestroyDrawable		8
+#define X_XF86DRIGetDrawableInfo		9
+#define X_XF86DRIGetDeviceInfo			10
+#define X_XF86DRIAuthConnection                 11
+#define X_XF86DRIOpenFullScreen                 12   /* Deprecated */
+#define X_XF86DRICloseFullScreen                13   /* Deprecated */
+
+#define XF86DRINumberEvents		0
+
+#define XF86DRIClientNotLocal		0
+#define XF86DRIOperationNotSupported	1
+#define XF86DRINumberErrors		(XF86DRIOperationNotSupported + 1)
+
+#ifndef _XF86DRI_SERVER_
+
+#include <GL/internal/dri_interface.h>
+
+_XFUNCPROTOBEGIN
+
+Bool XF86DRIQueryExtension( Display *dpy, int *event_base, int *error_base );
+
+Bool XF86DRIQueryVersion( Display *dpy, int *majorVersion, int *minorVersion,
+    int *patchVersion );
+
+Bool XF86DRIQueryDirectRenderingCapable( Display *dpy, int screen,
+    Bool *isCapable );
+
+Bool XF86DRIOpenConnection( Display *dpy, int screen, drm_handle_t *hSAREA,
+    char **busIDString );
+
+Bool XF86DRIAuthConnection( Display *dpy, int screen, drm_magic_t magic );
+
+Bool XF86DRICloseConnection( Display *dpy, int screen );
+
+Bool XF86DRIGetClientDriverName( Display *dpy, int screen,
+    int *ddxDriverMajorVersion, int *ddxDriverMinorVersion,
+    int *ddxDriverPatchVersion, char **clientDriverName );
+
+Bool XF86DRICreateContext( Display *dpy, int screen, Visual *visual,
+    XID *ptr_to_returned_context_id, drm_context_t *hHWContext );
+
+Bool XF86DRICreateContextWithConfig( Display *dpy, int screen, int configID,
+    XID *ptr_to_returned_context_id, drm_context_t *hHWContext );
+
+extern GLboolean XF86DRIDestroyContext( __DRInativeDisplay *dpy, int screen,
+    __DRIid context_id );
+
+extern GLboolean XF86DRICreateDrawable( __DRInativeDisplay *dpy, int screen,
+    __DRIid drawable, drm_drawable_t *hHWDrawable );
+
+extern GLboolean XF86DRIDestroyDrawable( __DRInativeDisplay *dpy, int screen, 
+    __DRIid drawable);
+
+Bool XF86DRIGetDrawableInfo( Display *dpy, int screen, Drawable drawable,
+    unsigned int *index, unsigned int *stamp, 
+    int *X, int *Y, int *W, int *H,
+    int *numClipRects, drm_clip_rect_t ** pClipRects,
+    int *backX, int *backY,
+    int *numBackClipRects, drm_clip_rect_t **pBackClipRects );
+
+Bool XF86DRIGetDeviceInfo( Display *dpy, int screen,
+    drm_handle_t *hFrameBuffer, int *fbOrigin, int *fbSize,
+    int *fbStride, int *devPrivateSize, void **pDevPrivate );
+
+_XFUNCPROTOEND
+
+#endif /* _XF86DRI_SERVER_ */
+
+#endif /* _XF86DRI_H_ */
+
diff --git a/src/glx/x11/xf86dristr.h b/src/glx/x11/xf86dristr.h
new file mode 100644
index 00000000000..ac05b183b3c
--- /dev/null
+++ b/src/glx/x11/xf86dristr.h
@@ -0,0 +1,343 @@
+/* $XFree86: xc/lib/GL/dri/xf86dristr.h,v 1.10 2002/10/30 12:51:25 alanh Exp $ */
+/**************************************************************************
+
+Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+Copyright 2000 VA Linux Systems, Inc.
+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 PRECISION INSIGHT AND/OR ITS 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.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Kevin E. Martin <[email protected]>
+ *   Jens Owen <[email protected]>
+ *   Rickard E. (Rik) Fiath <[email protected]>
+ *
+ */
+
+#ifndef _XF86DRISTR_H_
+#define _XF86DRISTR_H_
+
+#include "xf86dri.h"
+
+#define XF86DRINAME "XFree86-DRI"
+
+/* The DRI version number.  This was originally set to be the same of the
+ * XFree86 version number.  However, this version is really indepedent of
+ * the XFree86 version.
+ *
+ * Version History:
+ *    4.0.0: Original
+ *    4.0.1: Patch to bump clipstamp when windows are destroyed, 28 May 02
+ *    4.1.0: Add transition from single to multi in DRMInfo rec, 24 Jun 02
+ */
+#define XF86DRI_MAJOR_VERSION	4
+#define XF86DRI_MINOR_VERSION	1
+#define XF86DRI_PATCH_VERSION	0
+
+typedef struct _XF86DRIQueryVersion {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIQueryVersion */
+    CARD16	length B16;
+} xXF86DRIQueryVersionReq;
+#define sz_xXF86DRIQueryVersionReq	4
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber B16;
+    CARD32	length B32;
+    CARD16	majorVersion B16;	/* major version of DRI protocol */
+    CARD16	minorVersion B16;	/* minor version of DRI protocol */
+    CARD32	patchVersion B32;       /* patch version of DRI protocol */
+    CARD32	pad3 B32;
+    CARD32	pad4 B32;
+    CARD32	pad5 B32;
+    CARD32	pad6 B32;
+} xXF86DRIQueryVersionReply;
+#define sz_xXF86DRIQueryVersionReply	32
+
+typedef struct _XF86DRIQueryDirectRenderingCapable {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* X_DRIQueryDirectRenderingCapable */
+    CARD16	length B16;
+    CARD32	screen B32;
+} xXF86DRIQueryDirectRenderingCapableReq;
+#define sz_xXF86DRIQueryDirectRenderingCapableReq	8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber B16;
+    CARD32	length B32;
+    BOOL	isCapable;
+    BOOL	pad2;
+    BOOL	pad3;
+    BOOL	pad4;
+    CARD32	pad5 B32;
+    CARD32	pad6 B32;
+    CARD32	pad7 B32;
+    CARD32	pad8 B32;
+    CARD32	pad9 B32;
+} xXF86DRIQueryDirectRenderingCapableReply;
+#define sz_xXF86DRIQueryDirectRenderingCapableReply	32
+
+typedef struct _XF86DRIOpenConnection {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIOpenConnection */
+    CARD16	length B16;
+    CARD32	screen B32;
+} xXF86DRIOpenConnectionReq;
+#define sz_xXF86DRIOpenConnectionReq	8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber B16;
+    CARD32	length B32;
+    CARD32	hSAREALow B32;
+    CARD32	hSAREAHigh B32;
+    CARD32	busIdStringLength B32;
+    CARD32	pad6 B32;
+    CARD32	pad7 B32;
+    CARD32	pad8 B32;
+} xXF86DRIOpenConnectionReply;
+#define sz_xXF86DRIOpenConnectionReply	32
+
+typedef struct _XF86DRIAuthConnection {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRICloseConnection */
+    CARD16	length B16;
+    CARD32	screen B32;
+    CARD32      magic B32;
+} xXF86DRIAuthConnectionReq;
+#define sz_xXF86DRIAuthConnectionReq	12
+
+typedef struct {
+    BYTE        type;
+    BOOL        pad1;
+    CARD16      sequenceNumber B16;
+    CARD32      length B32;
+    CARD32      authenticated B32;
+    CARD32      pad2 B32;
+    CARD32      pad3 B32;
+    CARD32      pad4 B32;
+    CARD32      pad5 B32;
+    CARD32      pad6 B32;
+} xXF86DRIAuthConnectionReply;
+#define zx_xXF86DRIAuthConnectionReply  32
+
+typedef struct _XF86DRICloseConnection {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRICloseConnection */
+    CARD16	length B16;
+    CARD32	screen B32;
+} xXF86DRICloseConnectionReq;
+#define sz_xXF86DRICloseConnectionReq	8
+
+typedef struct _XF86DRIGetClientDriverName {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIGetClientDriverName */
+    CARD16	length B16;
+    CARD32	screen B32;
+} xXF86DRIGetClientDriverNameReq;
+#define sz_xXF86DRIGetClientDriverNameReq	8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber B16;
+    CARD32	length B32;
+    CARD32	ddxDriverMajorVersion B32;
+    CARD32	ddxDriverMinorVersion B32;
+    CARD32	ddxDriverPatchVersion B32;
+    CARD32	clientDriverNameLength B32;
+    CARD32	pad5 B32;
+    CARD32	pad6 B32;
+} xXF86DRIGetClientDriverNameReply;
+#define sz_xXF86DRIGetClientDriverNameReply	32
+
+typedef struct _XF86DRICreateContext {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRICreateContext */
+    CARD16	length B16;
+    CARD32	screen B32;
+    CARD32	visual B32;
+    CARD32	context B32;
+} xXF86DRICreateContextReq;
+#define sz_xXF86DRICreateContextReq	16
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber B16;
+    CARD32	length B32;
+    CARD32	hHWContext B32;
+    CARD32	pad2 B32;
+    CARD32	pad3 B32;
+    CARD32	pad4 B32;
+    CARD32	pad5 B32;
+    CARD32	pad6 B32;
+} xXF86DRICreateContextReply;
+#define sz_xXF86DRICreateContextReply	32
+
+typedef struct _XF86DRIDestroyContext {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIDestroyContext */
+    CARD16	length B16;
+    CARD32	screen B32;
+    CARD32	context B32;
+} xXF86DRIDestroyContextReq;
+#define sz_xXF86DRIDestroyContextReq	12
+
+typedef struct _XF86DRICreateDrawable {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRICreateDrawable */
+    CARD16	length B16;
+    CARD32	screen B32;
+    CARD32	drawable B32;
+} xXF86DRICreateDrawableReq;
+#define sz_xXF86DRICreateDrawableReq	12
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber B16;
+    CARD32	length B32;
+    CARD32	hHWDrawable B32;
+    CARD32	pad2 B32;
+    CARD32	pad3 B32;
+    CARD32	pad4 B32;
+    CARD32	pad5 B32;
+    CARD32	pad6 B32;
+} xXF86DRICreateDrawableReply;
+#define sz_xXF86DRICreateDrawableReply	32
+
+typedef struct _XF86DRIDestroyDrawable {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIDestroyDrawable */
+    CARD16	length B16;
+    CARD32	screen B32;
+    CARD32	drawable B32;
+} xXF86DRIDestroyDrawableReq;
+#define sz_xXF86DRIDestroyDrawableReq	12
+
+typedef struct _XF86DRIGetDrawableInfo {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIGetDrawableInfo */
+    CARD16	length B16;
+    CARD32	screen B32;
+    CARD32	drawable B32;
+} xXF86DRIGetDrawableInfoReq;
+#define sz_xXF86DRIGetDrawableInfoReq	12
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber B16;
+    CARD32	length B32;
+    CARD32	drawableTableIndex B32;
+    CARD32	drawableTableStamp B32;
+    INT16	drawableX B16;
+    INT16	drawableY B16;
+    INT16	drawableWidth B16;
+    INT16	drawableHeight B16;
+    CARD32	numClipRects B32;
+    INT16       backX B16;
+    INT16       backY B16;
+    CARD32      numBackClipRects B32;
+} xXF86DRIGetDrawableInfoReply;
+
+#define sz_xXF86DRIGetDrawableInfoReply	36
+
+
+typedef struct _XF86DRIGetDeviceInfo {
+    CARD8	reqType;		/* always DRIReqCode */
+    CARD8	driReqType;		/* always X_DRIGetDeviceInfo */
+    CARD16	length B16;
+    CARD32	screen B32;
+} xXF86DRIGetDeviceInfoReq;
+#define sz_xXF86DRIGetDeviceInfoReq	8
+
+typedef struct {
+    BYTE	type;			/* X_Reply */
+    BOOL	pad1;
+    CARD16	sequenceNumber B16;
+    CARD32	length B32;
+    CARD32	hFrameBufferLow B32;
+    CARD32	hFrameBufferHigh B32;
+    CARD32	framebufferOrigin B32;
+    CARD32	framebufferSize B32;
+    CARD32	framebufferStride B32;
+    CARD32	devPrivateSize B32;
+} xXF86DRIGetDeviceInfoReply;
+#define sz_xXF86DRIGetDeviceInfoReply	32
+
+typedef struct _XF86DRIOpenFullScreen {
+    CARD8       reqType;	/* always DRIReqCode */
+    CARD8       driReqType;	/* always X_DRIOpenFullScreen */
+    CARD16      length B16;
+    CARD32      screen B32;
+    CARD32      drawable B32;
+} xXF86DRIOpenFullScreenReq;
+#define sz_xXF86DRIOpenFullScreenReq    12
+
+typedef struct {
+    BYTE        type;
+    BOOL        pad1;
+    CARD16      sequenceNumber B16;
+    CARD32      length B32;
+    CARD32      isFullScreen B32;
+    CARD32      pad2 B32;
+    CARD32      pad3 B32;
+    CARD32      pad4 B32;
+    CARD32      pad5 B32;
+    CARD32      pad6 B32;
+} xXF86DRIOpenFullScreenReply;
+#define sz_xXF86DRIOpenFullScreenReply  32
+
+typedef struct _XF86DRICloseFullScreen {
+    CARD8       reqType;	/* always DRIReqCode */
+    CARD8       driReqType;	/* always X_DRICloseFullScreen */
+    CARD16      length B16;
+    CARD32      screen B32;
+    CARD32      drawable B32;
+} xXF86DRICloseFullScreenReq;
+#define sz_xXF86DRICloseFullScreenReq   12
+
+typedef struct {
+    BYTE        type;
+    BOOL        pad1;
+    CARD16      sequenceNumber B16;
+    CARD32      length B32;
+    CARD32      pad2 B32;
+    CARD32      pad3 B32;
+    CARD32      pad4 B32;
+    CARD32      pad5 B32;
+    CARD32      pad6 B32;
+    CARD32      pad7 B32;
+} xXF86DRICloseFullScreenReply;
+#define sz_xXF86DRICloseFullScreenReply  32
+
+
+#endif /* _XF86DRISTR_H_ */
diff --git a/src/glx/x11/xfont.c b/src/glx/x11/xfont.c
new file mode 100644
index 00000000000..5f23a796221
--- /dev/null
+++ b/src/glx/x11/xfont.c
@@ -0,0 +1,377 @@
+/* $XFree86: xc/lib/GL/glx/xfont.c,v 1.6 2001/05/02 15:06:02 dawes Exp $ */
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.1
+ *
+ * Copyright (C) 1999  Brian Paul   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, sublicense,
+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL 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.
+ */
+
+
+/* xfonts.c -- glXUseXFont() for Mesa written by
+ * Copyright (C) 1995 Thorsten.Ohl @ Physik.TH-Darmstadt.de
+ */
+
+/*
+  This was take from Mesa and modified to work in the real GLX structure.
+  It provides a fully client side implementation of glXUseXFont and is
+  called by that routine when direct rendering is enabled.
+*/
+
+
+#include "glxclient.h"
+
+/* Some debugging info.  */
+
+#ifdef DEBUG
+#undef _R
+#undef _G
+#undef _B
+#include <ctype.h>
+
+int debug_xfonts = 0;
+
+static void
+dump_char_struct (XCharStruct *ch, char *prefix)
+{
+  printf ("%slbearing = %d, rbearing = %d, width = %d\n",
+          prefix, ch->lbearing, ch->rbearing, ch->width);
+  printf ("%sascent = %d, descent = %d, attributes = %u\n",
+          prefix, ch->ascent, ch->descent, (unsigned int) ch->attributes);
+}
+
+static void
+dump_font_struct (XFontStruct *font)
+{
+  printf ("ascent = %d, descent = %d\n", font->ascent, font->descent);
+  printf ("char_or_byte2 = (%u,%u)\n",
+          font->min_char_or_byte2, font->max_char_or_byte2);
+  printf ("byte1 = (%u,%u)\n", font->min_byte1, font->max_byte1);
+  printf ("all_chars_exist = %s\n", font->all_chars_exist ? "True" : 
+"False");
+  printf ("default_char = %c (\\%03o)\n",
+          (char) (isprint (font->default_char) ? font->default_char : ' '),
+          font->default_char);
+  dump_char_struct (&font->min_bounds, "min> ");
+  dump_char_struct (&font->max_bounds, "max> ");
+#if 0
+  for (c = font->min_char_or_byte2; c <= font->max_char_or_byte2; c++)
+    {
+      char prefix[8];
+      sprintf (prefix, "%d> ", c);
+      dump_char_struct (&font->per_char[c], prefix);
+    }
+#endif
+}
+
+static void
+dump_bitmap (unsigned int width, unsigned int height, GLubyte *bitmap)
+{
+  unsigned int x, y;
+
+  printf ("    ");
+  for (x = 0; x < 8*width; x++)
+    printf ("%o", 7 - (x % 8));
+  putchar ('\n');
+  for (y = 0; y < height; y++)
+    {
+      printf ("%3o:", y);
+      for (x = 0; x < 8*width; x++)
+        putchar ((bitmap[width*(height - y - 1) + x/8] & (1 << (7 - (x % 
+8))))
+                 ? '*' : '.');
+      printf ("   ");
+      for (x = 0; x < width; x++)
+        printf ("0x%02x, ", bitmap[width*(height - y - 1) + x]);
+      putchar ('\n');
+    }
+}
+#endif /* DEBUG */
+
+
+/* Implementation.  */
+
+/* Fill a BITMAP with a character C from thew current font
+   in the graphics context GC.  WIDTH is the width in bytes
+   and HEIGHT is the height in bits.
+
+   Note that the generated bitmaps must be used with
+
+        glPixelStorei (GL_UNPACK_SWAP_BYTES, GL_FALSE);
+        glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE);
+        glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);
+        glPixelStorei (GL_UNPACK_SKIP_ROWS, 0);
+        glPixelStorei (GL_UNPACK_SKIP_PIXELS, 0);
+        glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
+
+   Possible optimizations:
+
+     * use only one reusable pixmap with the maximum dimensions.
+     * draw the entire font into a single pixmap (careful with
+       proportional fonts!).
+*/
+
+
+/*
+ * Generate OpenGL-compatible bitmap.
+ */
+static void
+fill_bitmap (Display *dpy, Window win, GC gc,
+             unsigned int width, unsigned int height,
+             int x0, int y0, unsigned int c, GLubyte *bitmap)
+{
+  XImage *image;
+  unsigned int x, y;
+  Pixmap pixmap;
+  XChar2b char2b;
+
+  pixmap = XCreatePixmap (dpy, win, 8*width, height, 1);
+  XSetForeground(dpy, gc, 0);
+  XFillRectangle (dpy, pixmap, gc, 0, 0, 8*width, height);
+  XSetForeground(dpy, gc, 1);
+
+  char2b.byte1 = (c >> 8) & 0xff;
+  char2b.byte2 = (c & 0xff);
+
+  XDrawString16 (dpy, pixmap, gc, x0, y0, &char2b, 1);
+
+  image = XGetImage (dpy, pixmap, 0, 0, 8*width, height, 1, XYPixmap);
+  if (image) {
+    /* Fill the bitmap (X11 and OpenGL are upside down wrt each other).  */
+    for (y = 0; y < height; y++)
+      for (x = 0; x < 8*width; x++)
+        if (XGetPixel (image, x, y))
+          bitmap[width*(height - y - 1) + x/8] |= (1 << (7 - (x % 8)));
+    XDestroyImage (image);
+  }
+
+  XFreePixmap (dpy, pixmap);
+}
+
+/*
+ * determine if a given glyph is valid and return the
+ * corresponding XCharStruct.
+ */
+static XCharStruct *isvalid(XFontStruct *fs, int which)
+{
+  unsigned int  rows,pages;
+  int           byte1 = 0, byte2 = 0;
+  int           i,valid = 1;
+
+  rows = fs->max_byte1 - fs->min_byte1 + 1;
+  pages = fs->max_char_or_byte2 - fs->min_char_or_byte2 + 1;
+
+  if (rows == 1) {
+    /* "linear" fonts */
+    if ((fs->min_char_or_byte2 > which) ||
+        (fs->max_char_or_byte2 < which)) valid = 0;
+  } else {
+    /* "matrix" fonts */
+    byte2 = which & 0xff;
+    byte1 = which >> 8;
+    if ((fs->min_char_or_byte2 > byte2) ||
+        (fs->max_char_or_byte2 < byte2) ||
+        (fs->min_byte1 > byte1) ||
+        (fs->max_byte1 < byte1)) valid = 0;
+  }
+
+  if (valid) {
+    if (fs->per_char) {
+      if (rows == 1) {
+        /* "linear" fonts */
+        return(fs->per_char + (which-fs->min_char_or_byte2) );
+      } else {
+        /* "matrix" fonts */
+        i = ((byte1 - fs->min_byte1) * pages) +
+             (byte2 - fs->min_char_or_byte2);
+        return(fs->per_char + i);
+      }
+    } else {
+        return(&fs->min_bounds);
+    }
+  }
+  return(NULL);
+}
+
+
+void DRI_glXUseXFont( Font font, int first, int count, int listbase )
+{
+  GLXContext CC;
+  Display *dpy;
+  Window win;
+  Pixmap pixmap;
+  GC gc;
+  XGCValues values;
+  unsigned long valuemask;
+  XFontStruct *fs;
+
+  GLint swapbytes, lsbfirst, rowlength;
+  GLint skiprows, skippixels, alignment;
+
+  unsigned int max_width, max_height, max_bm_width, max_bm_height;
+  GLubyte *bm;
+
+  int i;
+
+  CC = __glXGetCurrentContext();
+  dpy = CC->currentDpy;
+  win = CC->currentDrawable;
+
+  fs = XQueryFont (dpy, font);
+  if (!fs)
+    {
+      __glXSetError(CC, GL_INVALID_VALUE);
+      return;
+    }
+
+  /* Allocate a bitmap that can fit all characters.  */
+  max_width = fs->max_bounds.rbearing - fs->min_bounds.lbearing;
+  max_height = fs->max_bounds.ascent + fs->max_bounds.descent;
+  max_bm_width = (max_width + 7) / 8;
+  max_bm_height = max_height;
+
+  bm = (GLubyte *) Xmalloc((max_bm_width * max_bm_height) * sizeof 
+(GLubyte));
+  if (!bm) {
+      XFreeFontInfo( NULL, fs, 1 );
+      __glXSetError(CC, GL_OUT_OF_MEMORY);
+      return;
+    }
+
+#if 0
+  /* get the page info */
+  pages = fs->max_char_or_byte2 - fs->min_char_or_byte2 + 1;
+  firstchar = (fs->min_byte1 << 8) + fs->min_char_or_byte2;
+  lastchar = (fs->max_byte1 << 8) + fs->max_char_or_byte2;
+  rows = fs->max_byte1 - fs->min_byte1 + 1;
+  unsigned int first_char, last_char, pages, rows;
+#endif
+
+  /* Save the current packing mode for bitmaps.  */
+  glGetIntegerv (GL_UNPACK_SWAP_BYTES, &swapbytes);
+  glGetIntegerv (GL_UNPACK_LSB_FIRST, &lsbfirst);
+  glGetIntegerv (GL_UNPACK_ROW_LENGTH, &rowlength);
+  glGetIntegerv (GL_UNPACK_SKIP_ROWS, &skiprows);
+  glGetIntegerv (GL_UNPACK_SKIP_PIXELS, &skippixels);
+  glGetIntegerv (GL_UNPACK_ALIGNMENT, &alignment);
+
+  /* Enforce a standard packing mode which is compatible with
+     fill_bitmap() from above.  This is actually the default mode,
+     except for the (non)alignment.  */
+  glPixelStorei (GL_UNPACK_SWAP_BYTES, GL_FALSE);
+  glPixelStorei (GL_UNPACK_LSB_FIRST, GL_FALSE);
+  glPixelStorei (GL_UNPACK_ROW_LENGTH, 0);
+  glPixelStorei (GL_UNPACK_SKIP_ROWS, 0);
+  glPixelStorei (GL_UNPACK_SKIP_PIXELS, 0);
+  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
+
+  pixmap = XCreatePixmap (dpy, win, 10, 10, 1);
+  values.foreground = BlackPixel (dpy, DefaultScreen (dpy));
+  values.background = WhitePixel (dpy, DefaultScreen (dpy));
+  values.font = fs->fid;
+  valuemask = GCForeground | GCBackground | GCFont;
+  gc = XCreateGC (dpy, pixmap, valuemask, &values);
+  XFreePixmap (dpy, pixmap);
+
+#ifdef DEBUG
+  if (debug_xfonts)
+    dump_font_struct (fs);
+#endif
+
+  for (i = 0; i < count; i++)
+    {
+      unsigned int width, height, bm_width, bm_height;
+      GLfloat x0, y0, dx, dy;
+      XCharStruct *ch;
+      int x, y;
+      unsigned int c = first + i;
+      int list = listbase + i;
+      int valid;
+
+      /* check on index validity and get the bounds */
+      ch = isvalid(fs, c);
+      if (!ch) {
+        ch = &fs->max_bounds;
+        valid = 0;
+      } else {
+        valid = 1;
+      }
+
+#ifdef DEBUG
+      if (debug_xfonts) {
+          char s[7];
+          sprintf (s, isprint (c) ? "%c> " : "\\%03o> ", c);
+          dump_char_struct (ch, s);
+      }
+#endif
+
+      /* glBitmap()' parameters:
+         straight from the glXUseXFont(3) manpage.  */
+      width = ch->rbearing - ch->lbearing;
+      height = ch->ascent + ch->descent;
+      x0 = - ch->lbearing;
+      y0 = ch->descent - 1;
+      dx = ch->width;
+      dy = 0;
+
+      /* X11's starting point.  */
+      x = - ch->lbearing;
+      y = ch->ascent;
+
+      /* Round the width to a multiple of eight.  We will use this also
+         for the pixmap for capturing the X11 font.  This is slightly
+         inefficient, but it makes the OpenGL part real easy.  */
+      bm_width = (width + 7) / 8;
+      bm_height = height;
+
+      glNewList (list, GL_COMPILE);
+        if (valid && (bm_width > 0) && (bm_height > 0)) {
+
+            memset (bm, '\0', bm_width * bm_height);
+            fill_bitmap (dpy, win, gc, bm_width, bm_height, x, y, c, bm);
+
+            glBitmap (width, height, x0, y0, dx, dy, bm);
+#ifdef DEBUG
+            if (debug_xfonts) {
+                printf ("width/height = %u/%u\n", width, height);
+                printf ("bm_width/bm_height = %u/%u\n", bm_width, 
+bm_height);
+                dump_bitmap (bm_width, bm_height, bm);
+              }
+#endif
+          } else {
+            glBitmap (0, 0, 0.0, 0.0, dx, dy, NULL);
+          }
+      glEndList ();
+    }
+
+  Xfree(bm);
+  XFreeFontInfo( NULL, fs, 1 );
+  XFreeGC (dpy, gc);
+
+  /* Restore saved packing modes.  */
+  glPixelStorei(GL_UNPACK_SWAP_BYTES, swapbytes);
+  glPixelStorei(GL_UNPACK_LSB_FIRST, lsbfirst);
+  glPixelStorei(GL_UNPACK_ROW_LENGTH, rowlength);
+  glPixelStorei(GL_UNPACK_SKIP_ROWS, skiprows);
+  glPixelStorei(GL_UNPACK_SKIP_PIXELS, skippixels);
+  glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
+}
+
+/* The End. */