Merge remote-tracking branch 'origin/released'

Conflicts:
	xorg-server/glx/dispatch.h
	xorg-server/glx/glapi.c
	xorg-server/glx/indirect_dispatch.h
	xorg-server/glx/indirect_reqsize.c
	xorg-server/glx/indirect_reqsize.h
	xorg-server/glx/indirect_size.h
	xorg-server/glx/indirect_size_get.c
	xorg-server/glx/indirect_size_get.h
	xorg-server/glx/indirect_table.c
	xorg-server/mi/mieq.c

60 files changed, 7701 insertions, 4363 deletions

diff --git a/xorg-server/Xi/exevents.c b/xorg-server/Xi/exevents.c
index 1c8633a8f..6363192b2 100644
--- a/xorg-server/Xi/exevents.c
+++ b/xorg-server/Xi/exevents.c
@@ -44,6 +44,32 @@ SOFTWARE.
 
 ********************************************************/
 
+/*
+ * Copyright © 2010 Collabora Ltd.
+ * Copyright © 2011 Red Hat, Inc.
+ *
+ * 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 (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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
+ *
+ * Author: Daniel Stone <daniel@fooishbar.org>
+ */
+
 /********************************************************************
  *
  *  Routines to register and initialize extension input devices.
@@ -80,6 +106,7 @@ SOFTWARE.
 #include "eventconvert.h"
 #include "eventstr.h"
 #include "inpututils.h"
+#include "mi.h"
 
 #include <X11/extensions/XKBproto.h>
 #include "xkbsrv.h"
@@ -130,6 +157,21 @@ IsPointerEvent(InternalEvent* event)
     return FALSE;
 }
 
+Bool
+IsTouchEvent(InternalEvent* event)
+{
+    switch(event->any.type)
+    {
+        case ET_TouchBegin:
+        case ET_TouchUpdate:
+        case ET_TouchEnd:
+            return TRUE;
+        default:
+            break;
+    }
+    return FALSE;
+}
+
 /**
  * @return the device matching the deviceid of the device set in the event, or
  * NULL if the event is not an XInput event.
@@ -494,6 +536,8 @@ DeepCopyKeyboardClasses(DeviceIntPtr from, DeviceIntPtr to)
 
 }
 
+/* FIXME: this should really be shared with the InitValuatorAxisClassRec and
+ * similar */
 static void
 DeepCopyPointerClasses(DeviceIntPtr from, DeviceIntPtr to)
 {
@@ -626,6 +670,41 @@ DeepCopyPointerClasses(DeviceIntPtr from, DeviceIntPtr to)
         classes->proximity = to->proximity;
         to->proximity      = NULL;
     }
+
+    if (from->touch)
+    {
+        TouchPointInfoPtr tmp;
+        if (!to->touch)
+        {
+            classes = to->unused_classes;
+            to->touch = classes->touch;
+            if (!to->touch)
+            {
+                int i;
+                to->touch = calloc(1, sizeof(TouchClassRec));
+                if (!to->touch)
+                    FatalError("[Xi] no memory for class shift.\n");
+                to->touch->num_touches = from->touch->num_touches;
+                to->touch->touches = calloc(to->touch->num_touches,
+                                            sizeof(TouchPointInfoRec));
+                for (i = 0; i < to->touch->num_touches; i++)
+                    TouchInitTouchPoint(to->touch, to->valuator, i);
+                if (!to->touch)
+                    FatalError("[Xi] no memory for class shift.\n");
+            } else
+                classes->touch = NULL;
+        }
+        tmp = to->touch->touches;
+        memcpy(to->touch, from->touch, sizeof(TouchClassRec));
+        to->touch->touches = tmp;
+        to->touch->sourceid = from->id;
+    } else if (to->touch)
+    {
+        ClassesPtr classes;
+        classes = to->unused_classes;
+        classes->touch = to->touch;
+        to->touch      = NULL;
+    }
 }
 
 /**
@@ -773,6 +852,7 @@ UpdateDeviceState(DeviceIntPtr device, DeviceEvent* event)
     KeyClassPtr k       = NULL;
     ButtonClassPtr b    = NULL;
     ValuatorClassPtr v  = NULL;
+    TouchClassPtr t     = NULL;
 
     /* This event is always the first we get, before the actual events with
      * the data. However, the way how the DDX is set up, "device" will
@@ -790,6 +870,9 @@ UpdateDeviceState(DeviceIntPtr device, DeviceEvent* event)
         case ET_KeyRelease:
         case ET_ProximityIn:
         case ET_ProximityOut:
+        case ET_TouchBegin:
+        case ET_TouchUpdate:
+        case ET_TouchEnd:
             break;
         default:
             /* other events don't update the device */
@@ -799,6 +882,7 @@ UpdateDeviceState(DeviceIntPtr device, DeviceEvent* event)
     k = device->key;
     v = device->valuator;
     b = device->button;
+    t = device->touch;
 
     key = event->detail.key;
 
@@ -900,17 +984,602 @@ UpdateDeviceState(DeviceIntPtr device, DeviceEvent* event)
 	device->proximity->in_proximity = TRUE;
     else if (event->type == ET_ProximityOut)
 	device->proximity->in_proximity = FALSE;
+    else if (event->type == ET_TouchBegin) {
+        BUG_WARN(!b || !v);
+        BUG_WARN(!t);
+
+        if (!b || !t || !b->map[key])
+            return DONT_PROCESS;
+
+        if (!(event->flags & TOUCH_POINTER_EMULATED) ||
+            (event->flags & TOUCH_REPLAYING))
+            return DONT_PROCESS;
+
+        IncreaseButtonCount(device, key, &t->buttonsDown, &t->motionMask, &t->state);
+        UpdateDeviceMotionMask(device, t->state, DeviceButtonMotionMask);
+    } else if (event->type == ET_TouchEnd) {
+        BUG_WARN(!b || !v);
+        BUG_WARN(!t);
+
+        if (!b || !t || t->buttonsDown <= 0 || !b->map[key])
+            return DONT_PROCESS;
+
+        if (!(event->flags & TOUCH_POINTER_EMULATED))
+            return DONT_PROCESS;
+        if (!(event->flags & TOUCH_END))
+            return DONT_PROCESS;
+
+        DecreaseButtonCount(device, key, &t->buttonsDown, &t->motionMask, &t->state);
+        UpdateDeviceMotionMask(device, t->state, DeviceButtonMotionMask);
+    }
 
     return DEFAULT;
 }
 
 /**
- * Main device event processing function.
- * Called from when processing the events from the event queue.
+ * A client that does not have the TouchOwnership mask set may not receive a
+ * TouchBegin event if there is at least one grab active.
  *
+ * @return TRUE if the client selected for ownership events on the given
+ * window for this device, FALSE otherwise
  */
-void
-ProcessOtherEvent(InternalEvent *ev, DeviceIntPtr device)
+static inline Bool
+TouchClientWantsOwnershipEvents(ClientPtr client, DeviceIntPtr dev, WindowPtr win)
+{
+    InputClients *iclient;
+
+    nt_list_for_each_entry(iclient, wOtherInputMasks(win)->inputClients, next)
+    {
+        if (rClient(iclient) != client)
+            continue;
+
+        return xi2mask_isset(iclient->xi2mask, dev, XI_TouchOwnership);
+    }
+
+    return FALSE;
+}
+
+static void
+TouchSendOwnershipEvent(DeviceIntPtr dev, TouchPointInfoPtr ti, int reason, XID resource)
+{
+    int nev, i;
+    InternalEvent *tel = InitEventList(GetMaximumEventsNum());
+
+    nev = GetTouchOwnershipEvents(tel, dev, ti, reason, resource, 0);
+    for (i = 0; i < nev; i++)
+        mieqProcessDeviceEvent(dev, tel + i, NULL);
+
+    FreeEventList(tel, GetMaximumEventsNum());
+}
+
+/**
+ * Attempts to deliver a touch event to the given client.
+ */
+static Bool
+DeliverOneTouchEvent(ClientPtr client, DeviceIntPtr dev, TouchPointInfoPtr ti,
+                     GrabPtr grab, WindowPtr win, InternalEvent *ev)
+{
+    int err;
+    xEvent *xi2;
+    Mask filter;
+    Window child = DeepestSpriteWin(&ti->sprite)->drawable.id;
+
+    /* FIXME: owner event handling */
+
+    /* If the client does not have the ownership mask set and is not
+     * the current owner of the touch, only pretend we delivered */
+    if (!grab && ti->num_grabs != 0 &&
+           !TouchClientWantsOwnershipEvents(client, dev,win))
+           return TRUE;
+
+    /* If we fail here, we're going to leave a client hanging. */
+    err = EventToXI2(ev, &xi2);
+    if (err != Success)
+        FatalError("[Xi] %s: XI2 conversion failed in %s"
+                   " (%d)\n", dev->name, __func__, err);
+
+    FixUpEventFromWindow(&ti->sprite, xi2, win, child, FALSE);
+    filter = GetEventFilter(dev, xi2);
+    if (XaceHook(XACE_RECEIVE_ACCESS, client, win, xi2, 1) != Success)
+        return FALSE;
+    err = TryClientEvents(client, dev, xi2, 1, filter, filter, NullGrab);
+    free(xi2);
+
+    /* Returning the value from TryClientEvents isn't useful, since all our
+     * resource-gone cleanups will update the delivery list anyway. */
+    return TRUE;
+}
+
+/**
+ * If the current owner has rejected the event, deliver the
+ * TouchOwnership/TouchBegin to the next item in the sprite stack.
+ */
+static void
+TouchPuntToNextOwner(DeviceIntPtr dev, TouchPointInfoPtr ti,
+                     TouchOwnershipEvent *ev)
+{
+    InternalEvent *tel = InitEventList(GetMaximumEventsNum());
+    ValuatorMask *mask = valuator_mask_new(2);
+    int i, nev;
+
+    /* Deliver the ownership */
+    if (ti->listeners[0].state == LISTENER_AWAITING_OWNER)
+        DeliverTouchEvents(dev, ti, (InternalEvent*)ev, ti->listeners[0].listener);
+    else if (ti->listeners[0].state == LISTENER_AWAITING_BEGIN)
+        TouchEventHistoryReplay(ti, dev, ti->listeners[0].listener);
+
+    /* If we've just removed the last grab and the touch has physically
+     * ended, send a TouchEnd event too and finalise the touch. */
+    if (ti->num_listeners == 1 && ti->num_grabs == 0 &&
+            ti->pending_finish)
+    {
+        int flags;
+        valuator_mask_set_double(mask, 0,
+                                 valuator_mask_get_double(ti->valuators, 0));
+        valuator_mask_set_double(mask, 1,
+                                 valuator_mask_get_double(ti->valuators, 1));
+
+        flags = TOUCH_CLIENT_ID;
+        if (ti->emulate_pointer)
+            flags |= TOUCH_POINTER_EMULATED;
+        nev = GetTouchEvents(tel, dev, ti->client_id, XI_TouchEnd, flags, mask);
+        for (i = 0; i < nev; i++)
+            DeliverTouchEvents(dev, ti, tel + i, 0);
+        TouchEndTouch(dev, ti);
+    }
+
+    valuator_mask_free(&mask);
+    FreeEventList(tel, GetMaximumEventsNum());
+}
+
+static void
+TouchEventRejected(DeviceIntPtr sourcedev, TouchPointInfoPtr ti,
+                   TouchOwnershipEvent *ev)
+{
+    InternalEvent *tel = InitEventList(GetMaximumEventsNum());
+    ValuatorMask *mask = valuator_mask_new(2);
+    Bool was_owner = (ev->resource == ti->listeners[0].listener);
+    void *grab;
+    int nev, i;
+
+
+    /* Send a TouchEnd event to the resource being removed, but only if they
+     * haven't received one yet already */
+    if (ti->listeners[0].state != LISTENER_HAS_END)
+    {
+        int flags;
+        valuator_mask_set_double(mask, 0,
+                                 valuator_mask_get_double(ti->valuators, 0));
+        valuator_mask_set_double(mask, 1,
+                                 valuator_mask_get_double(ti->valuators, 1));
+
+        flags = TOUCH_CLIENT_ID|TOUCH_REJECT;
+        if (ti->emulate_pointer)
+            flags |= TOUCH_POINTER_EMULATED;
+        nev = GetTouchEvents(tel, sourcedev, ti->client_id, XI_TouchEnd, flags, mask);
+        for (i = 0; i < nev; i++)
+            DeliverTouchEvents(sourcedev, ti, tel + i, ev->resource);
+    }
+
+    /* If there are no other listeners left, then don't bother sending an
+     * ownership change event to no-one; if the touchpoint is pending
+     * finish, then we can just kill it now. */
+    if (ti->num_listeners == 1)
+    {
+        if (ti->pending_finish)
+            TouchEndTouch(sourcedev, ti);
+        goto out;
+    }
+
+    /* Remove the resource from the listener list, updating
+     * ti->num_listeners, as well as ti->num_grabs if it was a grab. */
+    if (TouchRemoveListener(ti, ev->resource))
+    {
+        if (dixLookupResourceByType(&grab, ev->resource, RT_PASSIVEGRAB,
+                                    serverClient, DixGetAttrAccess) == Success)
+            ti->num_grabs--;
+    }
+
+    /* If the current owner was removed, deliver the TouchOwnership or TouchBegin
+       event to the new owner. */
+    if (was_owner)
+        TouchPuntToNextOwner(sourcedev, ti, ev);
+
+out:
+    FreeEventList(tel, GetMaximumEventsNum());
+    valuator_mask_free(&mask);
+}
+
+/**
+ * Processes a TouchOwnership event, indicating a grab has accepted the touch
+ * it currently owns, or a grab or selection has been removed.  Will generate
+ * and send TouchEnd events to all clients removed from the delivery list, as
+ * well as possibly sending the new TouchOwnership event.  May end the
+ * touchpoint if it is pending finish.
+ */
+static void
+ProcessTouchOwnershipEvent(DeviceIntPtr dev, TouchPointInfoPtr ti,
+                           TouchOwnershipEvent *ev)
+{
+
+    if (ev->reason == XIRejectTouch)
+        TouchEventRejected(dev, ti, ev);
+    else if (ev->reason == XIAcceptTouch) {
+        int flags;
+        int nev, i;
+        ValuatorMask *mask;
+
+        InternalEvent *tel = InitEventList(GetMaximumEventsNum());
+
+        mask = valuator_mask_new(dev->valuator->numAxes);
+        valuator_mask_set_double(mask, 0,
+                                 valuator_mask_get_double(ti->valuators, 0));
+        valuator_mask_set_double(mask, 1,
+                                 valuator_mask_get_double(ti->valuators, 1));
+
+        /* FIXME: what about early acceptance? a client may accept before it
+         * owns the touch. */
+
+        /* The touch owner has accepted the touch.  Send TouchEnd events to
+         * everyone else, and truncate the list of listeners. */
+        flags = TOUCH_ACCEPT|TOUCH_CLIENT_ID;
+        if (ti->emulate_pointer)
+            flags |= TOUCH_POINTER_EMULATED;
+        nev = GetTouchEvents(tel, dev, ti->client_id, XI_TouchEnd,
+                             flags, mask);
+        for (i = 0; i < nev; i++)
+            DeliverTouchEvents(dev, ti, tel + i, 0);
+
+        FreeEventList(tel, GetMaximumEventsNum());
+        valuator_mask_free(&mask);
+
+        while (ti->num_listeners > 1)
+            TouchRemoveListener(ti, ti->listeners[1].listener);
+        /* Owner accepted after receiving end */
+        if (ti->listeners[0].state == LISTENER_HAS_END)
+            TouchEndTouch(dev, ti);
+    } else { /* this is the very first ownership event for a grab */
+        DeliverTouchEvents(dev, ti, (InternalEvent*)ev, ev->resource);
+    }
+}
+
+/**
+ * Copy the event's valuator information into the touchpoint, we may need
+ * this for emulated TouchEnd events.
+ */
+static void
+TouchCopyValuatorData(DeviceEvent *ev, TouchPointInfoPtr ti)
+{
+    int i;
+    for (i = 0; i < sizeof(ev->valuators.mask) * 8; i++)
+        if (BitIsOn(ev->valuators.mask, i))
+            valuator_mask_set_double(ti->valuators, i, ev->valuators.data[i]);
+}
+
+/**
+ * Given a touch event and a potential listener, retrieve info needed for
+ * processing the event.
+ *
+ * @param dev The device generating the touch event.
+ * @param ti The touch point info record for the touch event.
+ * @param ev The touch event to process.
+ * @param listener The touch event listener that may receive the touch event.
+ * @param[out] client The client that should receive the touch event.
+ * @param[out] win The window to deliver the event on.
+ * @param[out] grab The grab to deliver the event through, if any.
+ * @param[out] mask The XI 2.x event mask of the grab or selection, if any.
+ * @return TRUE if an event should be delivered to the listener, FALSE
+ *         otherwise.
+ */
+static Bool
+RetrieveTouchDeliveryData(DeviceIntPtr dev, TouchPointInfoPtr ti,
+                          InternalEvent *ev, TouchListener *listener,
+                          ClientPtr *client, WindowPtr *win, GrabPtr *grab,
+                          XI2Mask **mask)
+{
+     int rc;
+     InputClients *iclients = NULL;
+
+    if (listener->type == LISTENER_GRAB ||
+        listener->type == LISTENER_POINTER_GRAB)
+    {
+        rc = dixLookupResourceByType((pointer*)grab, listener->listener,
+                RT_PASSIVEGRAB,
+                serverClient, DixSendAccess);
+        if (rc != Success)
+        {
+            /* the grab doesn't exist but we have a grabbing listener - this
+             * is an implicit/active grab */
+            rc = dixLookupClient(client, listener->listener, serverClient, DixSendAccess);
+            if (rc != Success)
+                return FALSE;
+
+            *grab = dev->deviceGrab.grab;
+            if (!*grab)
+                return FALSE;
+        }
+
+        *client = rClient(*grab);
+        *win = (*grab)->window;
+        *mask = (*grab)->xi2mask;
+    } else {
+        if (listener->level == CORE)
+            rc = dixLookupWindow(win, listener->listener,
+                                 serverClient, DixSendAccess);
+        else
+            rc = dixLookupResourceByType((pointer*)win, listener->listener,
+                                         RT_INPUTCLIENT,
+                                         serverClient, DixSendAccess);
+        if (rc != Success)
+            return FALSE;
+
+
+        if (listener->level == XI2)
+        {
+            int evtype;
+            if (ti->emulate_pointer && listener->type == LISTENER_POINTER_REGULAR)
+                evtype = GetXI2Type(TouchGetPointerEventType(ev));
+            else
+                evtype = GetXI2Type(ev->any.type);
+
+            nt_list_for_each_entry(iclients, wOtherInputMasks(*win)->inputClients, next)
+                if (xi2mask_isset(iclients->xi2mask, dev, evtype))
+                    break;
+            BUG_WARN(!iclients);
+            if (!iclients)
+                return FALSE;
+        } else if (listener->level == XI)
+        {
+            int xi_type = GetXIType(TouchGetPointerEventType(ev));
+            Mask xi_filter = event_get_filter_from_type(dev, xi_type);
+            nt_list_for_each_entry(iclients, wOtherInputMasks(*win)->inputClients, next)
+                if (iclients->mask[dev->id] & xi_filter)
+                    break;
+            BUG_WARN(!iclients);
+            if (!iclients)
+                return FALSE;
+        } else
+        {
+            int coretype = GetCoreType(TouchGetPointerEventType(ev));
+            Mask core_filter = event_get_filter_from_type(dev, coretype);
+
+            /* all others */
+            nt_list_for_each_entry(iclients, (InputClients*)wOtherClients(*win), next)
+                if (iclients->mask[XIAllDevices] & core_filter)
+                    break;
+            /* if owner selected, iclients is NULL */
+        }
+
+        *client = iclients ? rClient(iclients) : wClient(*win);
+        *mask = iclients ? iclients->xi2mask : NULL;
+        *grab = NULL;
+    }
+
+    return TRUE;
+}
+
+static int
+DeliverTouchEmulatedEvent(DeviceIntPtr dev, TouchPointInfoPtr ti, InternalEvent *ev,
+                          TouchListener *listener, ClientPtr client,
+                          WindowPtr win, GrabPtr grab, XI2Mask *xi2mask)
+{
+    InternalEvent motion, button;
+    InternalEvent *ptrev = &motion;
+    int nevents;
+    DeviceIntPtr kbd;
+
+    /* We don't deliver pointer events to non-owners */
+    if (!TouchResourceIsOwner(ti, listener->listener))
+        return Success;
+
+    nevents = TouchConvertToPointerEvent(ev, &motion, &button);
+    BUG_WARN(nevents == 0);
+    if (nevents == 0)
+        return BadValue;
+
+    if (nevents > 1)
+        ptrev = &button;
+
+    kbd = GetMaster(dev, KEYBOARD_OR_FLOAT);
+    event_set_state(dev, kbd, &ptrev->device_event);
+    ptrev->device_event.corestate = event_get_corestate(dev, kbd);
+
+    if (grab)
+    {
+        /* this side-steps the usual activation mechansims, but... */
+        if (ev->any.type == ET_TouchBegin && !dev->deviceGrab.grab)
+                ActivatePassiveGrab(dev, grab, ptrev, ev); /* also delivers the event */
+        else {
+            int deliveries = 0;
+            /* 'grab' is the passive grab, but if the grab isn't active,
+             * don't deliver */
+            if (!dev->deviceGrab.grab)
+                return Success;
+
+            if (grab->ownerEvents)
+            {
+                WindowPtr focus = NullWindow;
+                WindowPtr win = dev->spriteInfo->sprite->win;
+                deliveries = DeliverDeviceEvents(win, ptrev, grab, focus, dev);
+            }
+
+            if (!deliveries)
+                DeliverOneGrabbedEvent(ptrev, dev, grab->grabtype);
+
+            if (ev->any.type == ET_TouchEnd &&
+                !dev->button->buttonsDown &&
+                dev->deviceGrab.fromPassiveGrab &&
+                GrabIsPointerGrab(grab))
+                (*dev->deviceGrab.DeactivateGrab)(dev);
+        }
+    } else
+    {
+        GrabPtr devgrab = dev->deviceGrab.grab;
+
+        DeliverDeviceEvents(win, ptrev, grab, win, dev);
+        /* FIXME: bad hack
+         * Implicit passive grab activated in response to this event. Store
+         * the event.
+         */
+        if (!devgrab && dev->deviceGrab.grab && dev->deviceGrab.implicitGrab)
+        {
+            TouchListener *listener;
+
+            devgrab = dev->deviceGrab.grab;
+
+            *dev->deviceGrab.sync.event = ev->device_event;
+
+            /* The listener array has a sequence of grabs and then one event
+             * selection. Implicit grab activation occurs through delivering an
+             * event selection. Thus, we update the last listener in the array.
+             */
+            listener = &ti->listeners[ti->num_listeners - 1];
+            listener->listener = devgrab->resource;
+
+            if (devgrab->grabtype != XI2 ||
+                devgrab->type != XI_TouchBegin)
+                listener->type = LISTENER_POINTER_GRAB;
+            else
+                listener->type = LISTENER_GRAB;
+        }
+
+    }
+    if (ev->any.type == ET_TouchBegin)
+        listener->state = LISTENER_IS_OWNER;
+    else if (ev->any.type == ET_TouchEnd)
+        listener->state = LISTENER_HAS_END;
+
+    return Success;
+}
+
+
+
+
+static void
+DeliverEmulatedMotionEvent(DeviceIntPtr dev, TouchPointInfoPtr ti,
+                           InternalEvent *ev)
+{
+    InternalEvent motion;
+
+    if (ti->num_listeners)
+    {
+        ClientPtr client;
+        WindowPtr win;
+        GrabPtr grab;
+        XI2Mask *mask;
+
+        if (ti->listeners[0].type != LISTENER_POINTER_REGULAR ||
+            ti->listeners[0].type != LISTENER_POINTER_GRAB)
+            return;
+
+        motion = *ev;
+        motion.any.type = ET_TouchUpdate;
+        motion.device_event.detail.button = 0;
+
+        if (!RetrieveTouchDeliveryData(dev, ti, &motion,
+                                       &ti->listeners[0], &client, &win, &grab,
+                                       &mask))
+            return;
+
+        /* There may be a pointer grab on the device */
+        if (!grab)
+        {
+            grab = dev->deviceGrab.grab;
+            if (grab)
+            {
+                win = grab->window;
+                mask = grab->xi2mask;
+                client = rClient(grab);
+            }
+        }
+
+        DeliverTouchEmulatedEvent(dev, ti, &motion, &ti->listeners[0], client, win, grab, mask);
+    } else {
+        InternalEvent button;
+        int converted;
+        converted = TouchConvertToPointerEvent(ev, &motion, &button);
+
+        BUG_WARN(converted == 0);
+        if (converted)
+            ProcessOtherEvent(&motion, dev);
+    }
+}
+
+/**
+ * Processes and delivers a TouchBegin, TouchUpdate, or a
+ * TouchEnd event.
+ *
+ * Due to having rather different delivery semantics (see the Xi 2.2 protocol
+ * spec for more information), this implements its own grab and event-selection
+ * delivery logic.
+ */
+static void
+ProcessTouchEvent(InternalEvent *ev, DeviceIntPtr dev)
+{
+    TouchClassPtr t = dev->touch;
+    TouchPointInfoPtr ti;
+    uint32_t touchid;
+    int type = ev->any.type;
+    int emulate_pointer = !!(ev->device_event.flags & TOUCH_POINTER_EMULATED);
+
+    if (!t)
+        return;
+
+    if (ev->any.type == ET_TouchOwnership)
+        touchid = ev->touch_ownership_event.touchid;
+    else
+        touchid = ev->device_event.touchid;
+
+    if (type == ET_TouchBegin) {
+        ti = TouchBeginTouch(dev, ev->device_event.sourceid, touchid,
+                             emulate_pointer);
+    } else
+        ti = TouchFindByClientID(dev, touchid);
+
+    if (!ti)
+    {
+        DebugF("[Xi] %s: Failed to get event %d for touchpoint %d\n",
+               dev->name, type, touchid);
+        return;
+    }
+
+
+    /* if emulate_pointer is set, emulate the motion event right
+     * here, so we can ignore it for button event emulation. TouchUpdate
+     * events which _only_ emulate motion just work normally */
+    if (emulate_pointer && ev->any.type != ET_TouchUpdate)
+        DeliverEmulatedMotionEvent(dev, ti, ev);
+    if (emulate_pointer && IsMaster(dev))
+        CheckMotion(&ev->device_event, dev);
+
+    /* Make sure we have a valid window trace for event delivery; must be
+     * called after event type mutation. */
+    /* FIXME: check this */
+    if (!TouchEnsureSprite(dev, ti, ev))
+        return;
+
+    /* TouchOwnership events are handled separately from the rest, as they
+     * have more complex semantics. */
+    if (ev->any.type == ET_TouchOwnership)
+        ProcessTouchOwnershipEvent(dev, ti, &ev->touch_ownership_event);
+    else
+    {
+        TouchCopyValuatorData(&ev->device_event, ti);
+        /* WARNING: the event type may change to TouchUpdate in
+         * DeliverTouchEvents if a TouchEnd was delivered to a grabbing
+         * owner */
+        DeliverTouchEvents(dev, ti, (InternalEvent *) ev, 0);
+        if (ev->any.type == ET_TouchEnd)
+            TouchEndTouch(dev, ti);
+    }
+}
+
+
+/**
+ * Process DeviceEvents and DeviceChangedEvents.
+ */
+static void
+ProcessDeviceEvent(InternalEvent *ev, DeviceIntPtr device)
 {
     GrabPtr grab;
     Bool deactivateDeviceGrab = FALSE;
@@ -921,18 +1590,6 @@ ProcessOtherEvent(InternalEvent *ev, DeviceIntPtr device)
     DeviceIntPtr mouse = NULL, kbd = NULL;
     DeviceEvent *event = &ev->device_event;
 
-    verify_internal_event(ev);
-
-    if (ev->any.type == ET_RawKeyPress ||
-        ev->any.type == ET_RawKeyRelease ||
-        ev->any.type == ET_RawButtonPress ||
-        ev->any.type == ET_RawButtonRelease ||
-        ev->any.type == ET_RawMotion)
-    {
-        DeliverRawEvent(&ev->raw_event, device);
-        return;
-    }
-
     if (IsPointerDevice(device))
     {
         kbd = GetMaster(device, KEYBOARD_OR_FLOAT);
@@ -1046,6 +1703,204 @@ ProcessOtherEvent(InternalEvent *ev, DeviceIntPtr device)
     event->detail.key = key;
 }
 
+/**
+ * Main device event processing function.
+ * Called from when processing the events from the event queue.
+ *
+ */
+void
+ProcessOtherEvent(InternalEvent *ev, DeviceIntPtr device)
+{
+    verify_internal_event(ev);
+
+    switch(ev->any.type)
+    {
+        case  ET_RawKeyPress:
+        case  ET_RawKeyRelease:
+        case  ET_RawButtonPress:
+        case  ET_RawButtonRelease:
+        case  ET_RawMotion:
+        case  ET_RawTouchBegin:
+        case  ET_RawTouchUpdate:
+        case  ET_RawTouchEnd:
+            DeliverRawEvent(&ev->raw_event, device);
+            break;
+        case  ET_TouchBegin:
+        case  ET_TouchUpdate:
+        case  ET_TouchOwnership:
+        case  ET_TouchEnd:
+            ProcessTouchEvent(ev, device);
+            break;
+        default:
+            ProcessDeviceEvent(ev, device);
+            break;
+    }
+}
+
+static int
+DeliverTouchBeginEvent(DeviceIntPtr dev, TouchPointInfoPtr ti, InternalEvent *ev,
+                       TouchListener *listener, ClientPtr client,
+                       WindowPtr win, GrabPtr grab, XI2Mask *xi2mask)
+{
+    enum TouchListenerState state;
+    int rc = Success;
+    Bool has_ownershipmask;
+
+    if (listener->type == LISTENER_POINTER_REGULAR ||
+        listener->type == LISTENER_POINTER_GRAB)
+    {
+        rc = DeliverTouchEmulatedEvent(dev, ti, ev, listener, client, win,
+                                       grab, xi2mask);
+        goto out;
+    }
+
+
+    has_ownershipmask = xi2mask_isset(xi2mask, dev, XI_TouchOwnership);
+
+    if (TouchResourceIsOwner(ti, listener->listener) || has_ownershipmask)
+        rc = DeliverOneTouchEvent(client, dev, ti, grab, win, ev);
+    if (!TouchResourceIsOwner(ti, listener->listener))
+    {
+        if (has_ownershipmask)
+            state = LISTENER_AWAITING_OWNER;
+        else
+            state = LISTENER_AWAITING_BEGIN;
+    } else
+    {
+        if (has_ownershipmask)
+            TouchSendOwnershipEvent(dev, ti, 0, listener->listener);
+        state = LISTENER_IS_OWNER;
+    }
+    listener->state = state;
+
+out:
+    return rc;
+}
+
+static int
+DeliverTouchEndEvent(DeviceIntPtr dev, TouchPointInfoPtr ti, InternalEvent *ev,
+                     TouchListener *listener, ClientPtr client,
+                     WindowPtr win, GrabPtr grab, XI2Mask *xi2mask)
+{
+    int rc = Success;
+
+    if (listener->type == LISTENER_POINTER_REGULAR ||
+        listener->type == LISTENER_POINTER_GRAB)
+    {
+        rc = DeliverTouchEmulatedEvent(dev, ti, ev, listener, client, win,
+                                       grab, xi2mask);
+        goto out;
+    }
+
+    /* Event in response to reject */
+    if (ev->device_event.flags & TOUCH_REJECT)
+    {
+        if (listener->state != LISTENER_HAS_END)
+            rc = DeliverOneTouchEvent(client, dev, ti, grab, win, ev);
+        listener->state = LISTENER_HAS_END;
+    } else if (TouchResourceIsOwner(ti, listener->listener))
+    {
+        /* FIXME: what about early acceptance */
+        if (!(ev->device_event.flags & TOUCH_ACCEPT))
+        {
+            if (listener->state != LISTENER_HAS_END)
+                rc = DeliverOneTouchEvent(client, dev, ti, grab, win, ev);
+            listener->state = LISTENER_HAS_END;
+        }
+        if (ti->num_listeners > 1 &&
+           (ev->device_event.flags & (TOUCH_ACCEPT|TOUCH_REJECT)) == 0)
+        {
+            ev->any.type = ET_TouchUpdate;
+            ev->device_event.flags |= TOUCH_PENDING_END;
+            ti->pending_finish = TRUE;
+        }
+    }
+
+out:
+    return rc;
+}
+
+static int
+DeliverTouchEvent(DeviceIntPtr dev, TouchPointInfoPtr ti, InternalEvent *ev,
+                  TouchListener *listener, ClientPtr client,
+                  WindowPtr win, GrabPtr grab, XI2Mask *xi2mask)
+{
+    Bool has_ownershipmask = FALSE;
+    int rc = Success;
+
+    if (xi2mask)
+        has_ownershipmask = xi2mask_isset(xi2mask, dev, XI_TouchOwnership);
+
+    if (ev->any.type == ET_TouchOwnership)
+    {
+        ev->touch_ownership_event.deviceid = dev->id;
+        if (!TouchResourceIsOwner(ti, listener->listener))
+            goto out;
+        rc = DeliverOneTouchEvent(client, dev, ti, grab, win, ev);
+        listener->state = LISTENER_IS_OWNER;
+    } else
+        ev->device_event.deviceid = dev->id;
+
+    if (ev->any.type == ET_TouchBegin)
+    {
+        rc = DeliverTouchBeginEvent(dev, ti, ev, listener, client, win, grab, xi2mask);
+    } else if (ev->any.type == ET_TouchUpdate)
+    {
+        if (listener->type == LISTENER_POINTER_REGULAR ||
+            listener->type == LISTENER_POINTER_GRAB)
+            DeliverTouchEmulatedEvent(dev, ti, ev, listener, client, win, grab, xi2mask);
+        else if (TouchResourceIsOwner(ti, listener->listener) || has_ownershipmask)
+            rc = DeliverOneTouchEvent(client, dev, ti, grab, win, ev);
+    } else if (ev->any.type == ET_TouchEnd)
+        rc = DeliverTouchEndEvent(dev, ti, ev, listener, client, win, grab, xi2mask);
+
+out:
+    return rc;
+}
+
+/**
+ * Delivers a touch events to all interested clients.  For TouchBegin events,
+ * will update ti->listeners, ti->num_listeners, and ti->num_grabs.
+ * May also mutate ev (type and flags) upon successful delivery.  If
+ * @resource is non-zero, will only attempt delivery to the owner of that
+ * resource.
+ *
+ * @return TRUE if the event was delivered at least once, FALSE otherwise
+ */
+void
+DeliverTouchEvents(DeviceIntPtr dev, TouchPointInfoPtr ti,
+                   InternalEvent *ev, XID resource)
+{
+    int i;
+
+    if (ev->any.type == ET_TouchBegin &&
+        !(ev->device_event.flags & (TOUCH_CLIENT_ID|TOUCH_REPLAYING)))
+        TouchSetupListeners(dev, ti, ev);
+
+    TouchEventHistoryPush(ti, &ev->device_event);
+
+    for (i = 0; i < ti->num_listeners; i++)
+    {
+        GrabPtr grab = NULL;
+        ClientPtr client;
+        WindowPtr win;
+        XI2Mask *mask;
+        TouchListener *listener = &ti->listeners[i];
+
+        if (resource && listener->listener != resource)
+            continue;
+
+        if (!RetrieveTouchDeliveryData(dev, ti, ev, listener, &client, &win,
+                                       &grab, &mask))
+            continue;
+
+        DeliverTouchEvent(dev, ti, ev, listener, client, win, grab, mask);
+    }
+
+    if (ti->emulate_pointer)
+        UpdateDeviceState(dev, &ev->device_event);
+}
+
 int
 InitProximityClassDeviceStruct(DeviceIntPtr dev)
 {
@@ -1402,12 +2257,14 @@ CheckGrabValues(ClientPtr client, GrabParameters* param)
     }
 
     if ((param->this_device_mode != GrabModeSync) &&
-	(param->this_device_mode != GrabModeAsync)) {
+	(param->this_device_mode != GrabModeAsync) &&
+        (param->this_device_mode != XIGrabModeTouch)) {
 	client->errorValue = param->this_device_mode;
 	return BadValue;
     }
     if ((param->other_devices_mode != GrabModeSync) &&
-	(param->other_devices_mode != GrabModeAsync)) {
+	(param->other_devices_mode != GrabModeAsync) &&
+        (param->other_devices_mode != XIGrabModeTouch)) {
 	client->errorValue = param->other_devices_mode;
 	return BadValue;
     }
@@ -1572,6 +2429,34 @@ GrabWindow(ClientPtr client, DeviceIntPtr dev, int type,
     return AddPassiveGrabToList(client, grab);
 }
 
+/* Touch grab */
+int
+GrabTouch(ClientPtr client, DeviceIntPtr dev, DeviceIntPtr mod_dev,
+          GrabParameters *param, GrabMask *mask)
+{
+    WindowPtr pWin;
+    GrabPtr grab;
+    int rc;
+
+    rc = CheckGrabValues(client, param);
+    if (rc != Success)
+        return rc;
+
+    rc = dixLookupWindow(&pWin, param->grabWindow, client, DixSetAttrAccess);
+    if (rc != Success)
+       return rc;
+    rc = XaceHook(XACE_DEVICE_ACCESS, client, dev, DixGrabAccess);
+    if (rc != Success)
+       return rc;
+
+    grab = CreateGrab(client->index, dev, mod_dev, pWin, XI2,
+                      mask, param, XI_TouchBegin, 0, NullWindow, NullCursor);
+    if (!grab)
+        return BadAlloc;
+
+    return AddPassiveGrabToList(client, grab);
+}
+
 int
 SelectForWindow(DeviceIntPtr dev, WindowPtr pWin, ClientPtr client,
 		Mask mask, Mask exclusivemasks)
@@ -1781,6 +2666,36 @@ InputClientGone(WindowPtr pWin, XID id)
     FatalError("client not on device event list");
 }
 
+/**
+ * Search for window in each touch trace for each device. Remove the window
+ * and all its subwindows from the trace when found. The initial window
+ * order is preserved.
+ */
+void WindowGone(WindowPtr win)
+{
+    DeviceIntPtr dev;
+
+    for (dev = inputInfo.devices; dev; dev = dev->next) {
+        TouchClassPtr t = dev->touch;
+        int i;
+
+        if (!t)
+            continue;
+
+        for (i = 0; i < t->num_touches; i++) {
+            SpritePtr sprite = &t->touches[i].sprite;
+            int j;
+
+            for (j = 0; j < sprite->spriteTraceGood; j++) {
+                if (sprite->spriteTrace[j] == win) {
+                    sprite->spriteTraceGood = j;
+                    break;
+                }
+            }
+        }
+    }
+}
+
 int
 SendEvent(ClientPtr client, DeviceIntPtr d, Window dest, Bool propagate,
 	  xEvent * ev, Mask mask, int count)
diff --git a/xorg-server/Xi/extinit.c b/xorg-server/Xi/extinit.c
index b43f9bbc0..a81c8f1ff 100644
--- a/xorg-server/Xi/extinit.c
+++ b/xorg-server/Xi/extinit.c
@@ -829,6 +829,22 @@ static void SRawEvent(xXIRawEvent *from, xXIRawEvent *to)
     swaps(&to->valuators_len);
 }
 
+static void STouchOwnershipEvent(xXITouchOwnershipEvent *from,
+                                 xXITouchOwnershipEvent *to)
+{
+    *to = *from;
+    swaps(&to->sequenceNumber);
+    swapl(&to->length);
+    swaps(&to->evtype);
+    swaps(&to->deviceid);
+    swapl(&to->time);
+    swaps(&to->sourceid);
+    swapl(&to->touchid);
+    swapl(&to->flags);
+    swapl(&to->root);
+    swapl(&to->event);
+    swapl(&to->child);
+}
 
 /** Event swapping function for XI2 events. */
 void
@@ -858,13 +874,23 @@ XI2EventSwap(xGenericEvent *from, xGenericEvent *to)
         case XI_KeyRelease:
         case XI_ButtonPress:
         case XI_ButtonRelease:
+        case XI_TouchBegin:
+        case XI_TouchUpdate:
+        case XI_TouchEnd:
             SDeviceEvent((xXIDeviceEvent*)from, (xXIDeviceEvent*)to);
             break;
+        case XI_TouchOwnership:
+            STouchOwnershipEvent((xXITouchOwnershipEvent*)from,
+                                 (xXITouchOwnershipEvent*)to);
+            break;
         case XI_RawMotion:
         case XI_RawKeyPress:
         case XI_RawKeyRelease:
         case XI_RawButtonPress:
         case XI_RawButtonRelease:
+        case XI_RawTouchBegin:
+        case XI_RawTouchUpdate:
+        case XI_RawTouchEnd:
             SRawEvent((xXIRawEvent*)from, (xXIRawEvent*)to);
             break;
         default:
diff --git a/xorg-server/Xi/xiallowev.c b/xorg-server/Xi/xiallowev.c
index 0d45b3654..a4b2f5782 100644
--- a/xorg-server/Xi/xiallowev.c
+++ b/xorg-server/Xi/xiallowev.c
@@ -35,6 +35,8 @@
 
 #include "inputstr.h"	/* DeviceIntPtr      */
 #include "windowstr.h"	/* window structure  */
+#include "mi.h"
+#include "eventstr.h"
 #include <X11/extensions/XI2.h>
 #include <X11/extensions/XI2proto.h>
 
@@ -49,10 +51,53 @@ SProcXIAllowEvents(ClientPtr client)
     swaps(&stuff->length);
     swaps(&stuff->deviceid);
     swapl(&stuff->time);
+    /* FIXME swap touchid */
+    /* FIXME swap window */
 
     return ProcXIAllowEvents(client);
 }
 
+static int
+AllowTouch(ClientPtr client, DeviceIntPtr dev, int mode, uint32_t touchid, XID *error)
+{
+    TouchPointInfoPtr ti;
+    int nev, i;
+    InternalEvent *events = InitEventList(GetMaximumEventsNum());
+
+    if (!events)
+        return BadAlloc;
+
+    if (!dev->touch)
+    {
+        *error = dev->id;
+        return BadDevice;
+    }
+
+    /* FIXME window is unhandled */
+
+    ti = TouchFindByClientID(dev, touchid);
+    if (!ti)
+    {
+        *error = touchid;
+        return BadValue;
+    }
+
+    /* FIXME: Allow for early accept */
+    if (ti->num_listeners == 0 || CLIENT_ID(ti->listeners[0].listener) != client->index)
+        return BadAccess;
+
+    nev = GetTouchOwnershipEvents(events, dev, ti, mode, ti->listeners[0].listener, 0);
+    if (nev == 0)
+        return BadAlloc;
+    for (i = 0; i < nev; i++)
+        mieqProcessDeviceEvent(dev, events + i, NULL);
+
+    ProcessInputEvents();
+
+    FreeEventList(events, GetMaximumEventsNum());
+    return Success;
+}
+
 int
 ProcXIAllowEvents(ClientPtr client)
 {
@@ -61,7 +106,7 @@ ProcXIAllowEvents(ClientPtr client)
     int ret = Success;
 
     REQUEST(xXIAllowEventsReq);
-    REQUEST_SIZE_MATCH(xXIAllowEventsReq);
+    /* FIXME: check request length, 12 for XI 2.0+, 20 for XI 2.2+ */
 
     ret = dixLookupDevice(&dev, stuff->deviceid, client, DixGetAttrAccess);
     if (ret != Success)
@@ -91,6 +136,12 @@ ProcXIAllowEvents(ClientPtr client)
         if (IsMaster(dev))
             AllowSome(client, time, dev, THAWED_BOTH);
 	break;
+    case XIRejectTouch:
+    case XIAcceptTouch:
+        ret = AllowTouch(client, dev,
+                         stuff->mode, stuff->touchid,
+                         &client->errorValue);
+        break;
     default:
 	client->errorValue = stuff->mode;
 	ret = BadValue;
diff --git a/xorg-server/Xi/xipassivegrab.c b/xorg-server/Xi/xipassivegrab.c
index 713a1654e..c80da8044 100644
--- a/xorg-server/Xi/xipassivegrab.c
+++ b/xorg-server/Xi/xipassivegrab.c
@@ -108,19 +108,29 @@ ProcXIPassiveGrabDevice(ClientPtr client)
     if (stuff->grab_type != XIGrabtypeButton &&
         stuff->grab_type != XIGrabtypeKeycode &&
         stuff->grab_type != XIGrabtypeEnter &&
-        stuff->grab_type != XIGrabtypeFocusIn)
+        stuff->grab_type != XIGrabtypeFocusIn &&
+        stuff->grab_type != XIGrabtypeTouchBegin)
     {
         client->errorValue = stuff->grab_type;
         return BadValue;
     }
 
     if ((stuff->grab_type == XIGrabtypeEnter ||
-         stuff->grab_type == XIGrabtypeFocusIn) && stuff->detail != 0)
+         stuff->grab_type == XIGrabtypeFocusIn ||
+         stuff->grab_type == XIGrabtypeTouchBegin) && stuff->detail != 0)
     {
         client->errorValue = stuff->detail;
         return BadValue;
     }
 
+    if (stuff->grab_type == XIGrabtypeTouchBegin &&
+        (stuff->grab_mode != XIGrabModeTouch ||
+         stuff->paired_device_mode != GrabModeAsync))
+    {
+        client->errorValue = stuff->grab_mode;
+        return BadValue;
+    }
+
     if (XICheckInvalidMaskBits(client, (unsigned char*)&stuff[1],
                                stuff->mask_len * 4) != Success)
         return BadValue;
@@ -141,11 +151,17 @@ ProcXIPassiveGrabDevice(ClientPtr client)
     memset(&param, 0, sizeof(param));
     param.grabtype = XI2;
     param.ownerEvents = stuff->owner_events;
-    param.this_device_mode = stuff->grab_mode;
-    param.other_devices_mode = stuff->paired_device_mode;
     param.grabWindow = stuff->grab_window;
     param.cursor = stuff->cursor;
 
+    if (IsKeyboardDevice(dev)) {
+        param.this_device_mode = stuff->grab_mode;
+        param.other_devices_mode = stuff->paired_device_mode;
+    } else {
+        param.this_device_mode = stuff->paired_device_mode;
+        param.other_devices_mode = stuff->grab_mode;
+    }
+
     if (stuff->cursor != None)
     {
         ret = dixLookupResourceByType(&tmp, stuff->cursor,
@@ -194,6 +210,9 @@ ProcXIPassiveGrabDevice(ClientPtr client)
                 status = GrabWindow(client, dev, stuff->grab_type,
                                     &param, &mask);
                 break;
+            case XIGrabtypeTouchBegin:
+                status = GrabTouch(client, dev, mod_dev, &param, &mask);
+                break;
         }
 
         if (status != GrabSuccess)
diff --git a/xorg-server/Xi/xiquerydevice.c b/xorg-server/Xi/xiquerydevice.c
index 5f543f620..0879080ad 100644
--- a/xorg-server/Xi/xiquerydevice.c
+++ b/xorg-server/Xi/xiquerydevice.c
@@ -240,6 +240,8 @@ SizeDeviceClasses(DeviceIntPtr dev)
         }
     }
 
+    if (dev->touch)
+        len += sizeof(xXITouchInfo);
 
     return len;
 }
@@ -427,6 +429,31 @@ SwapScrollInfo(DeviceIntPtr dev, xXIScrollInfo* info)
     swapl(&info->increment.frac);
 }
 
+/**
+ * List multitouch information
+ *
+ * @return The number of bytes written into info.
+ */
+int
+ListTouchInfo(DeviceIntPtr dev, xXITouchInfo *touch)
+{
+    touch->type = XITouchClass;
+    touch->length = sizeof(xXITouchInfo) >> 2;
+    touch->sourceid = touch->sourceid;
+    touch->mode = dev->touch->mode;
+    touch->num_touches = dev->touch->num_touches;
+
+    return touch->length << 2;
+}
+
+static void
+SwapTouchInfo(DeviceIntPtr dev, xXITouchInfo* touch)
+{
+    swaps(&touch->type);
+    swaps(&touch->length);
+    swaps(&touch->sourceid);
+}
+
 int GetDeviceUse(DeviceIntPtr dev, uint16_t *attachment)
 {
     DeviceIntPtr master = GetMaster(dev, MASTER_ATTACHED);
@@ -525,6 +552,14 @@ ListDeviceClasses(ClientPtr client, DeviceIntPtr dev,
         total_len += len;
     }
 
+    if (dev->touch)
+    {
+        (*nclasses)++;
+        len = ListTouchInfo(dev, (xXITouchInfo*)any);
+        any += len;
+        total_len += len;
+    }
+
     return total_len;
 }
 
@@ -554,6 +589,10 @@ SwapDeviceInfo(DeviceIntPtr dev, xXIDeviceInfo* info)
             case XIScrollClass:
                 SwapScrollInfo(dev, (xXIScrollInfo*)any);
                 break;
+            case XITouchClass:
+                SwapTouchInfo(dev, (xXITouchInfo*)any);
+                break;
+
         }
 
         any += len * 4;
diff --git a/xorg-server/Xi/xiquerydevice.h b/xorg-server/Xi/xiquerydevice.h
index 9db6aa293..632c42eeb 100644
--- a/xorg-server/Xi/xiquerydevice.h
+++ b/xorg-server/Xi/xiquerydevice.h
@@ -45,4 +45,5 @@ int ListKeyInfo(DeviceIntPtr dev, xXIKeyInfo* info);
 int ListValuatorInfo(DeviceIntPtr dev, xXIValuatorInfo* info,
 		     int axisnumber, Bool reportState);
 int ListScrollInfo(DeviceIntPtr dev, xXIScrollInfo* info, int axisnumber);
+int ListTouchInfo(DeviceIntPtr dev, xXITouchInfo* info);
 #endif /* QUERYDEV_H */
diff --git a/xorg-server/Xi/xiselectev.c b/xorg-server/Xi/xiselectev.c
index ee14edb6d..1b6c47a87 100644
--- a/xorg-server/Xi/xiselectev.c
+++ b/xorg-server/Xi/xiselectev.c
@@ -145,13 +145,59 @@ ProcXISelectEvents(ClientPtr client)
                 BitIsOn(bits, XI_RawKeyRelease) ||
                 BitIsOn(bits, XI_RawButtonPress) ||
                 BitIsOn(bits, XI_RawButtonRelease) ||
-                BitIsOn(bits, XI_RawMotion))
+                BitIsOn(bits, XI_RawMotion) ||
+                BitIsOn(bits, XI_RawTouchBegin) ||
+                BitIsOn(bits, XI_RawTouchUpdate) ||
+                BitIsOn(bits, XI_RawTouchEnd))
             {
                 client->errorValue = XI_RawKeyPress;
                 return BadValue;
             }
         }
 
+        if (evmask->mask_len >= 1)
+        {
+            unsigned char *bits = (unsigned char*)&evmask[1];
+
+            /* All three touch events must be selected at once */
+            if ((BitIsOn(bits, XI_TouchBegin) ||
+                 BitIsOn(bits, XI_TouchUpdate) ||
+                 BitIsOn(bits, XI_TouchOwnership) ||
+                 BitIsOn(bits, XI_TouchEnd)) &&
+                (!BitIsOn(bits, XI_TouchBegin) ||
+                 !BitIsOn(bits, XI_TouchUpdate) ||
+                 !BitIsOn(bits, XI_TouchEnd)))
+            {
+                client->errorValue = XI_TouchBegin;
+                return BadValue;
+            }
+
+            /* Only one client per window may select for touch events on the
+             * same devices, including master devices.
+             * XXX: This breaks if a device goes from floating to attached. */
+            if (BitIsOn(bits, XI_TouchBegin))
+            {
+                OtherInputMasks *inputMasks = wOtherInputMasks(win);
+                InputClients *iclient = NULL;
+                if (inputMasks)
+                    iclient = inputMasks->inputClients;
+                for (; iclient; iclient = iclient->next)
+                {
+                    DeviceIntPtr dummy;
+
+                    if (CLIENT_ID(iclient->resource) == client->index)
+                        continue;
+
+                    dixLookupDevice(&dummy, evmask->deviceid, serverClient, DixReadAccess);
+                    if (!dummy)
+                        return BadImplementation; /* this shouldn't happen */
+
+                    if (xi2mask_isset(iclient->xi2mask, dummy, XI_TouchBegin))
+                        return BadAccess;
+                }
+            }
+        }
+
         if (XICheckInvalidMaskBits(client, (unsigned char*)&evmask[1],
                                    evmask->mask_len * 4) != Success)
             return BadValue;
diff --git a/xorg-server/configure.ac b/xorg-server/configure.ac
index 518eb06a9..261af5f68 100644
--- a/xorg-server/configure.ac
+++ b/xorg-server/configure.ac
@@ -26,8 +26,8 @@ dnl
 dnl Process this file with autoconf to create configure.
 
 AC_PREREQ(2.60)
-AC_INIT([xorg-server], 1.11.99.1, [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], xorg-server)
-RELEASE_DATE="2011-11-20"
+AC_INIT([xorg-server], 1.11.99.2, [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], xorg-server)
+RELEASE_DATE="2011-12-17"
 AC_CONFIG_SRCDIR([Makefile.am])
 AM_INIT_AUTOMAKE([foreign dist-bzip2])
 AM_MAINTAINER_MODE
@@ -776,7 +776,7 @@ XPROTO="xproto >= 7.0.22"
 RANDRPROTO="randrproto >= 1.2.99.3"
 RENDERPROTO="renderproto >= 0.11"
 XEXTPROTO="xextproto >= 7.1.99"
-INPUTPROTO="inputproto >= 2.0.99.1"
+INPUTPROTO="inputproto >= 2.1.99.3"
 KBPROTO="kbproto >= 1.0.3"
 FONTSPROTO="fontsproto"
 FIXESPROTO="fixesproto >= 5.0"
@@ -2020,12 +2020,10 @@ if test "$KDRIVE" = yes; then
         XEPHYR_REQUIRED_LIBS="$XEPHYR_REQUIRED_LIBS $LIBGL libdrm"
     fi
 
-    PKG_CHECK_MODULES(XEPHYR, $XEPHYR_REQUIRED_LIBS, [xephyr="yes"], [xephyr="no"])
     if test "x$XEPHYR" = xauto; then
-        XEPHYR=$xephyr
-    fi
-    if test "x$XEPHYR" = xyes && test "x$xephyr" = xno; then	
-        AC_MSG_ERROR([Xephyr dependencies missing])
+        PKG_CHECK_MODULES(XEPHYR, $XEPHYR_REQUIRED_LIBS, [XEPHYR="yes"], [XEPHYR="no"])
+    elif test "x$XEPHYR" = xyes ; then
+        PKG_CHECK_MODULES(XEPHYR, $XEPHYR_REQUIRED_LIBS)
     fi
 
     # Xephyr needs nanosleep() which is in librt on Solaris
diff --git a/xorg-server/dix/Makefile.am b/xorg-server/dix/Makefile.am
index f5af619e3..b7358aa72 100644
--- a/xorg-server/dix/Makefile.am
+++ b/xorg-server/dix/Makefile.am
@@ -39,6 +39,7 @@ libdix_la_SOURCES = 	\
 	swaprep.c	\
 	swapreq.c	\
 	tables.c	\
+	touch.c		\
 	window.c
 
 EXTRA_DIST = buildatoms BuiltInAtoms Xserver.d Xserver-dtrace.h.in
diff --git a/xorg-server/dix/devices.c b/xorg-server/dix/devices.c
index e79ea5996..f01857e77 100644
--- a/xorg-server/dix/devices.c
+++ b/xorg-server/dix/devices.c
@@ -267,6 +267,7 @@ AddInputDevice(ClientPtr client, DeviceProc deviceProc, Bool autoStart)
 	return (DeviceIntPtr)NULL;
 
     dev->last.scroll = NULL;
+    dev->last.touches = NULL;
     dev->id = devid;
     dev->public.processInputProc = ProcessOtherEvent;
     dev->public.realInputProc = ProcessOtherEvent;
@@ -765,6 +766,21 @@ FreeDeviceClass(int type, pointer *class)
                 free((*v));
                 break;
             }
+        case XITouchClass:
+            {
+                TouchClassPtr *t = (TouchClassPtr*)class;
+                int i;
+
+                for (i = 0; i < (*t)->num_touches; i++)
+                {
+                    free((*t)->touches[i].sprite.spriteTrace);
+                    free((*t)->touches[i].listeners);
+                    free((*t)->touches[i].valuators);
+                }
+
+                free((*t));
+                break;
+            }
         case FocusClass:
             {
                 FocusClassPtr *f = (FocusClassPtr*)class;
@@ -873,6 +889,7 @@ FreeAllDeviceClasses(ClassesPtr classes)
 
     FreeDeviceClass(KeyClass, (pointer)&classes->key);
     FreeDeviceClass(ValuatorClass, (pointer)&classes->valuator);
+    FreeDeviceClass(XITouchClass, (pointer)&classes->touch);
     FreeDeviceClass(ButtonClass, (pointer)&classes->button);
     FreeDeviceClass(FocusClass, (pointer)&classes->focus);
     FreeDeviceClass(ProximityClass, (pointer)&classes->proximity);
@@ -952,6 +969,9 @@ CloseDevice(DeviceIntPtr dev)
     free(dev->deviceGrab.sync.event);
     free(dev->config_info);     /* Allocated in xf86ActivateDevice. */
     free(dev->last.scroll);
+    for (j = 0; j < dev->last.num_touches; j++)
+        free(dev->last.touches[j].valuators);
+    free(dev->last.touches);
     dev->config_info = NULL;
     dixFreeObjectWithPrivates(dev, PRIVATE_DEVICE);
 }
@@ -1427,7 +1447,6 @@ InitPtrFeedbackClassDeviceStruct(DeviceIntPtr dev, PtrCtrlProcPtr controlProc)
     return TRUE;
 }
 
-
 static LedCtrl defaultLedControl = {
 	DEFAULT_LEDS, DEFAULT_LEDS_MASK, 0};
 
@@ -1550,6 +1569,72 @@ InitPointerDeviceStruct(DevicePtr device, CARD8 *map, int numButtons, Atom* btn_
 	   InitPtrFeedbackClassDeviceStruct(dev, controlProc));
 }
 
+/**
+ * Sets up multitouch capabilities on @device.
+ *
+ * @max_touches The maximum number of simultaneous touches, or 0 for unlimited.
+ * @mode The mode of the touch device (XIDirectTouch or XIDependentTouch).
+ * @num_axes The number of touch valuator axes.
+ */
+Bool
+InitTouchClassDeviceStruct(DeviceIntPtr device, unsigned int max_touches,
+                           unsigned int mode, unsigned int num_axes)
+{
+    TouchClassPtr touch;
+    int i;
+
+    if (device->touch || !device->valuator)
+        return FALSE;
+
+    /* Check the mode is valid, and at least X and Y axes. */
+    if (mode != XIDirectTouch && mode != XIDependentTouch)
+        return FALSE;
+    if (num_axes < 2)
+        return FALSE;
+
+    if (num_axes > MAX_VALUATORS)
+    {
+        LogMessage(X_WARNING,
+                   "Device '%s' has %d touch axes, only using first %d.\n",
+                   device->name, num_axes, MAX_VALUATORS);
+        num_axes = MAX_VALUATORS;
+    }
+
+    touch = calloc(1, sizeof(*touch));
+    if (!touch)
+        return FALSE;
+
+    touch->max_touches = max_touches;
+    if (max_touches == 0)
+        max_touches = 5; /* arbitrary number plucked out of the air */
+    touch->touches = calloc(max_touches, sizeof(*touch->touches));
+    if (!touch->touches)
+        goto err;
+    touch->num_touches = max_touches;
+    for (i = 0; i < max_touches; i++)
+        TouchInitTouchPoint(touch, device->valuator, i);
+
+    touch->mode = mode;
+    touch->sourceid = device->id;
+
+    device->touch = touch;
+    device->last.touches = calloc(max_touches, sizeof(*device->last.touches));
+    device->last.num_touches = touch->num_touches;
+    for (i = 0; i < touch->num_touches; i++)
+        TouchInitDDXTouchPoint(device, &device->last.touches[i]);
+
+    return TRUE;
+
+err:
+    for (i = 0; i < touch->num_touches; i++)
+        TouchFreeTouchPoint(device, i);
+
+    free(touch->touches);
+    free(touch);
+
+    return FALSE;
+}
+
 /*
  * Check if the given buffer contains elements between low (inclusive) and
  * high (inclusive) only.
diff --git a/xorg-server/dix/eventconvert.c b/xorg-server/dix/eventconvert.c
index 5caae0551..84c7f5f1d 100644
--- a/xorg-server/dix/eventconvert.c
+++ b/xorg-server/dix/eventconvert.c
@@ -58,6 +58,7 @@ static int eventToKeyButtonPointer(DeviceEvent *ev, xEvent **xi, int *count);
 static int eventToDeviceChanged(DeviceChangedEvent *ev, xEvent **dcce);
 static int eventToDeviceEvent(DeviceEvent *ev, xEvent **xi);
 static int eventToRawEvent(RawDeviceEvent *ev, xEvent **xi);
+static int eventToTouchOwnershipEvent(TouchOwnershipEvent *ev, xEvent **xi);
 
 /* Do not use, read comments below */
 BOOL EventIsKeyRepeat(xEvent *event);
@@ -158,6 +159,13 @@ EventToCore(InternalEvent *event, xEvent **core_out, int *count_out)
         case ET_RawButtonPress:
         case ET_RawButtonRelease:
         case ET_RawMotion:
+        case ET_RawTouchBegin:
+        case ET_RawTouchUpdate:
+        case ET_RawTouchEnd:
+        case ET_TouchBegin:
+        case ET_TouchUpdate:
+        case ET_TouchEnd:
+        case ET_TouchOwnership:
             ret = BadMatch;
             break;
         default:
@@ -208,6 +216,13 @@ EventToXI(InternalEvent *ev, xEvent **xi, int *count)
         case ET_RawButtonPress:
         case ET_RawButtonRelease:
         case ET_RawMotion:
+        case ET_RawTouchBegin:
+        case ET_RawTouchUpdate:
+        case ET_RawTouchEnd:
+        case ET_TouchBegin:
+        case ET_TouchUpdate:
+        case ET_TouchEnd:
+        case ET_TouchOwnership:
             *count = 0;
             *xi = NULL;
             return BadMatch;
@@ -249,7 +264,12 @@ EventToXI2(InternalEvent *ev, xEvent **xi)
         case ET_ButtonRelease:
         case ET_KeyPress:
         case ET_KeyRelease:
+        case ET_TouchBegin:
+        case ET_TouchUpdate:
+        case ET_TouchEnd:
             return eventToDeviceEvent(&ev->device_event, xi);
+        case ET_TouchOwnership:
+            return eventToTouchOwnershipEvent(&ev->touch_ownership_event, xi);
         case ET_ProximityIn:
         case ET_ProximityOut:
             *xi = NULL;
@@ -261,6 +281,9 @@ EventToXI2(InternalEvent *ev, xEvent **xi)
         case ET_RawButtonPress:
         case ET_RawButtonRelease:
         case ET_RawMotion:
+        case ET_RawTouchBegin:
+        case ET_RawTouchUpdate:
+        case ET_RawTouchEnd:
             return eventToRawEvent(&ev->raw_event, xi);
         default:
             break;
@@ -650,7 +673,11 @@ eventToDeviceEvent(DeviceEvent *ev, xEvent **xi)
     xde->evtype         = GetXI2Type(ev->type);
     xde->time           = ev->time;
     xde->length         = bytes_to_int32(len - sizeof(xEvent));
-    xde->detail         = ev->detail.button;
+    if (IsTouchEvent((InternalEvent*)ev))
+        xde->detail     = ev->touchid;
+    else
+        xde->detail     = ev->detail.button;
+
     xde->root           = ev->root;
     xde->buttons_len    = btlen;
     xde->valuators_len  = vallen;
@@ -659,7 +686,11 @@ eventToDeviceEvent(DeviceEvent *ev, xEvent **xi)
     xde->root_x         = FP1616(ev->root_x, ev->root_x_frac);
     xde->root_y         = FP1616(ev->root_y, ev->root_y_frac);
 
-    xde->flags          = ev->flags;
+    if (ev->type == ET_TouchUpdate)
+        xde->flags |= (ev->flags & TOUCH_PENDING_END) ? XITouchPendingEnd : 0;
+    else
+        xde->flags = ev->flags;
+
     if (ev->key_repeat)
         xde->flags      |= XIKeyRepeat;
 
@@ -696,6 +727,27 @@ eventToDeviceEvent(DeviceEvent *ev, xEvent **xi)
 }
 
 static int
+eventToTouchOwnershipEvent(TouchOwnershipEvent *ev, xEvent **xi)
+{
+    int len = sizeof(xXITouchOwnershipEvent);
+    xXITouchOwnershipEvent *xtoe;
+
+    *xi = calloc(1, len);
+    xtoe = (xXITouchOwnershipEvent*)*xi;
+    xtoe->type          = GenericEvent;
+    xtoe->extension     = IReqCode;
+    xtoe->length        = bytes_to_int32(len - sizeof(xEvent));
+    xtoe->evtype        = GetXI2Type(ev->type);
+    xtoe->deviceid      = ev->deviceid;
+    xtoe->time          = ev->time;
+    xtoe->sourceid      = ev->sourceid;
+    xtoe->touchid       = ev->touchid;
+    xtoe->flags         = 0; /* we don't have wire flags for ownership yet */
+
+    return Success;
+}
+
+static int
 eventToRawEvent(RawDeviceEvent *ev, xEvent **xi)
 {
     xXIRawEvent* raw;
@@ -810,8 +862,15 @@ GetXI2Type(enum EventType type)
         case ET_RawButtonPress: xi2type = XI_RawButtonPress;   break;
         case ET_RawButtonRelease: xi2type = XI_RawButtonRelease; break;
         case ET_RawMotion:      xi2type = XI_RawMotion;        break;
+        case ET_RawTouchBegin:  xi2type = XI_RawTouchBegin;    break;
+        case ET_RawTouchUpdate: xi2type = XI_RawTouchUpdate;  break;
+        case ET_RawTouchEnd:    xi2type = XI_RawTouchEnd;      break;
         case ET_FocusIn:        xi2type = XI_FocusIn;          break;
         case ET_FocusOut:       xi2type = XI_FocusOut;         break;
+        case ET_TouchBegin:     xi2type = XI_TouchBegin;       break;
+        case ET_TouchEnd:       xi2type = XI_TouchEnd;         break;
+        case ET_TouchUpdate:    xi2type = XI_TouchUpdate;      break;
+        case ET_TouchOwnership: xi2type = XI_TouchOwnership;   break;
         default:
             break;
     }
diff --git a/xorg-server/dix/events.c b/xorg-server/dix/events.c
index 42f7c1b06..9c15ad429 100644
--- a/xorg-server/dix/events.c
+++ b/xorg-server/dix/events.c
@@ -152,6 +152,7 @@ typedef const char *string;
 #include "eventstr.h"
 #include "enterleave.h"
 #include "eventconvert.h"
+#include "mi.h"
 
 /* Extension events type numbering starts at EXTENSION_EVENT_BASE.  */
 #define NoSuchEvent 0x80000000	/* so doesn't match NoEventMask */
@@ -1118,13 +1119,14 @@ NoticeEventTime(InternalEvent *ev)
 void
 EnqueueEvent(InternalEvent *ev, DeviceIntPtr device)
 {
-    QdEventPtr	tail;
+    QdEventPtr	tail = NULL;
     QdEventPtr	qe;
     SpritePtr	pSprite = device->spriteInfo->sprite;
     int		eventlen;
     DeviceEvent *event = &ev->device_event;
 
-    tail = list_last_entry(&syncEvents.pending, QdEventRec, next);
+    if (!list_is_empty(&syncEvents.pending))
+        tail = list_last_entry(&syncEvents.pending, QdEventRec, next);
 
     NoticeTime((InternalEvent*)event);
 
@@ -1311,7 +1313,17 @@ ComputeFreezes(void)
                        event->root_x, event->root_y);
         if (!CheckDeviceGrabs(replayDev, event, syncEvents.replayWin))
         {
-            if (replayDev->focus && !IsPointerEvent((InternalEvent*)event))
+            if (IsTouchEvent((InternalEvent*)event))
+            {
+                InternalEvent *events = InitEventList(GetMaximumEventsNum());
+                int i, nev;
+                TouchPointInfoPtr ti = TouchFindByClientID(replayDev, event->touchid);
+                BUG_WARN(!ti);
+                nev = GetTouchOwnershipEvents(events, replayDev, ti, XIRejectTouch, ti->listeners[0].listener, 0);
+                for (i = 0; i < nev; i++)
+                    mieqProcessDeviceEvent(replayDev, events + i, NULL);
+                ProcessInputEvents();
+            } else if (replayDev->focus && !IsPointerEvent((InternalEvent*)event))
                 DeliverFocusedEvent(replayDev, (InternalEvent*)event, w);
             else
                 DeliverDeviceEvents(w, (InternalEvent*)event, NullGrab,
@@ -1516,6 +1528,8 @@ DeactivatePointerGrab(DeviceIntPtr mouse)
     Bool wasImplicit = (mouse->deviceGrab.fromPassiveGrab &&
                         mouse->deviceGrab.implicitGrab);
 
+    TouchRemovePointerGrab(mouse);
+
     mouse->valuator->motionHintWindow = NullWindow;
     mouse->deviceGrab.grab = NullGrab;
     mouse->deviceGrab.sync.state = NOT_GRABBED;
@@ -2466,6 +2480,9 @@ FixUpEventFromWindow(
             case XI_RawButtonPress:
             case XI_RawButtonRelease:
             case XI_RawMotion:
+            case XI_RawTouchBegin:
+            case XI_RawTouchUpdate:
+            case XI_RawTouchEnd:
             case XI_DeviceChanged:
             case XI_HierarchyChanged:
             case XI_PropertyEvent:
@@ -2476,6 +2493,13 @@ FixUpEventFromWindow(
 
         event->root = RootWindow(pSprite)->drawable.id;
         event->event = pWin->drawable.id;
+
+        if (evtype == XI_TouchOwnership)
+        {
+            event->child = child;
+            return;
+        }
+
         if (pSprite->hot.pScreen == pWin->drawable.pScreen)
         {
             event->event_x = event->root_x - FP1616(pWin->drawable.x, 0);
@@ -2984,6 +3008,9 @@ CheckMotion(DeviceEvent *ev, DeviceIntPtr pDev)
             case ET_ButtonPress:
             case ET_ButtonRelease:
             case ET_Motion:
+            case ET_TouchBegin:
+            case ET_TouchUpdate:
+            case ET_TouchEnd:
                 break;
             default:
                 /* all other events return FALSE */
@@ -3636,11 +3663,15 @@ BorderSizeNotEmpty(DeviceIntPtr pDev, WindowPtr pWin)
  * @param device The device of the event to check.
  * @param grab The grab to check.
  * @param event The current device event.
+ * @param real_event The original event, in case of touch emulation. The
+ * real event is the one stored in the sync queue.
  *
  * @return Whether the grab has been activated.
  */
 Bool
-ActivatePassiveGrab(DeviceIntPtr device, GrabPtr grab, InternalEvent *event)
+ActivatePassiveGrab(DeviceIntPtr device, GrabPtr grab, InternalEvent *event,
+                    InternalEvent *real_event)
+
 {
     SpritePtr pSprite = device->spriteInfo->sprite;
     GrabInfoPtr grabinfo = &device->deviceGrab;
@@ -3712,7 +3743,7 @@ ActivatePassiveGrab(DeviceIntPtr device, GrabPtr grab, InternalEvent *event)
 
     if (grabinfo->sync.state == FROZEN_NO_EVENT)
         grabinfo->sync.state = FROZEN_WITH_EVENT;
-    *grabinfo->sync.event = event->device_event;
+    *grabinfo->sync.event = real_event->device_event;
 
     free(xE);
     return TRUE;
@@ -3818,6 +3849,7 @@ CheckPassiveGrab(DeviceIntPtr device, GrabPtr grab, InternalEvent *event,
     DeviceIntPtr gdev;
     XkbSrvInfoPtr xkbi = NULL;
     enum MatchFlags match = 0;
+    int emulated_type = 0;
 
     gdev = grab->modifierDevice;
     if (grab->grabtype == CORE)
@@ -3839,13 +3871,26 @@ CheckPassiveGrab(DeviceIntPtr device, GrabPtr grab, InternalEvent *event,
     tempGrab->modifiersDetail.exact = xkbi ? xkbi->state.grab_mods : 0;
 
     /* Check for XI2 and XI grabs first */
-    match = MatchForType(grab, tempGrab, XI2, GetXI2Type(event->any.type));
+    match = MatchForType(grab, tempGrab, XI2, event->any.type);
+
+    if (!match && IsTouchEvent(event) && (event->device_event.flags & TOUCH_POINTER_EMULATED))
+    {
+        emulated_type = TouchGetPointerEventType(event);
+        match = MatchForType(grab, tempGrab, XI2, emulated_type);
+    }
 
     if (!match)
-        match = MatchForType(grab, tempGrab, XI, GetXIType(event->any.type));
+        match = MatchForType(grab, tempGrab, XI, event->any.type);
+
+    if (!match && emulated_type)
+        match = MatchForType(grab, tempGrab, XI, emulated_type);
 
     if (!match && checkCore)
-        match = MatchForType(grab, tempGrab, CORE, GetCoreType(event->any.type));
+    {
+        match = MatchForType(grab, tempGrab, CORE, event->any.type);
+        if (!match && emulated_type)
+            match = MatchForType(grab, tempGrab, CORE, emulated_type);
+    }
 
     if (!match || (grab->confineTo &&
                    (!grab->confineTo->realized ||
@@ -3919,6 +3964,8 @@ CheckPassiveGrabsOnWindow(
             break;
         case ET_ButtonPress:
         case ET_ButtonRelease:
+        case ET_TouchBegin:
+        case ET_TouchEnd:
             tempGrab->detail.exact = event->device_event.detail.button;
             break;
         default:
@@ -3936,7 +3983,7 @@ CheckPassiveGrabsOnWindow(
         if (!CheckPassiveGrab(device, grab, event, checkCore, tempGrab))
             continue;
 
-        if (activate && !ActivatePassiveGrab(device, grab, event))
+        if (activate && !ActivatePassiveGrab(device, grab, event, event))
             continue;
 
         break;
@@ -4151,8 +4198,8 @@ DeliverOneGrabbedEvent(InternalEvent *event, DeviceIntPtr dev, enum InputLevel l
             if (rc == Success)
             {
                 int evtype = xi2_get_type(xE);
-                mask = xi2mask_isset(grab->xi2mask, dev, evtype);
-                filter = 1;
+                mask = GetXI2MaskByte(grab->xi2mask, dev, evtype);
+                filter = GetEventFilter(dev, xE);
             }
             break;
         case XI:
diff --git a/xorg-server/dix/getevents.c b/xorg-server/dix/getevents.c
index c843568b3..cdb00ccb4 100644
--- a/xorg-server/dix/getevents.c
+++ b/xorg-server/dix/getevents.c
@@ -49,6 +49,7 @@
 #include "eventconvert.h"
 #include "inpututils.h"
 #include "mi.h"
+#include "windowstr.h"
 
 #include <X11/extensions/XKBproto.h>
 #include "xkbsrv.h"
@@ -171,12 +172,43 @@ key_autorepeats(DeviceIntPtr pDev, int key_code)
 }
 
 static void
+init_event(DeviceIntPtr dev, DeviceEvent* event, Time ms)
+{
+    memset(event, 0, sizeof(DeviceEvent));
+    event->header = ET_Internal;
+    event->length = sizeof(DeviceEvent);
+    event->time = ms;
+    event->deviceid = dev->id;
+    event->sourceid = dev->id;
+}
+
+static void
+init_touch_ownership(DeviceIntPtr dev, TouchOwnershipEvent *event, Time ms)
+{
+    memset(event, 0, sizeof(TouchOwnershipEvent));
+    event->header = ET_Internal;
+    event->type = ET_TouchOwnership;
+    event->length = sizeof(TouchOwnershipEvent);
+    event->time = ms;
+    event->deviceid = dev->id;
+}
+
+static void
 init_raw(DeviceIntPtr dev, RawDeviceEvent *event, Time ms, int type, int detail)
 {
     memset(event, 0, sizeof(RawDeviceEvent));
     event->header = ET_Internal;
     event->length = sizeof(RawDeviceEvent);
-    event->type = ET_RawKeyPress - ET_KeyPress + type;
+    switch(type) {
+        case MotionNotify:      event->type = ET_RawMotion; break;
+        case ButtonPress:       event->type = ET_RawButtonPress; break;
+        case ButtonRelease:     event->type = ET_RawButtonRelease; break;
+        case KeyPress:          event->type = ET_RawKeyPress; break;
+        case KeyRelease:        event->type = ET_RawKeyRelease; break;
+        case XI_TouchBegin:     event->type = ET_RawTouchBegin; break;
+        case XI_TouchUpdate:    event->type = ET_RawTouchUpdate; break;
+        case XI_TouchEnd:       event->type = ET_RawTouchEnd; break;
+    }
     event->time = ms;
     event->deviceid = dev->id;
     event->sourceid = dev->id;
@@ -801,36 +833,28 @@ scale_from_screen(DeviceIntPtr dev, ValuatorMask *mask)
 
 
 /**
- * If we have HW cursors, this actually moves the visible sprite. If not, we
- * just do all the screen crossing, etc.
+ * Scale from (absolute) device to screen coordinates here,
  *
- * We scale from device to screen coordinates here, call
- * miPointerSetPosition() and then scale back into device coordinates (if
- * needed). miPSP will change x/y if the screen was crossed.
- *
- * The coordinates provided are always absolute. The parameter mode
- * specifies whether it was relative or absolute movement that landed us at
- * those coordinates. see fill_pointer_events for information on coordinate
- * systems.
+ * The coordinates provided are always absolute. see fill_pointer_events for
+ * information on coordinate systems.
  *
  * @param dev The device to be moved.
- * @param mode Movement mode (Absolute or Relative)
- * @param[in,out] mask Mask of axis values for this event, returns the
- * per-screen device coordinates after confinement
+ * @param mask Mask of axis values for this event
  * @param[out] devx x desktop-wide coordinate in device coordinate system
  * @param[out] devy y desktop-wide coordinate in device coordinate system
  * @param[out] screenx x coordinate in desktop coordinate system
  * @param[out] screeny y coordinate in desktop coordinate system
  */
 static ScreenPtr
-positionSprite(DeviceIntPtr dev, int mode, ValuatorMask *mask,
-               double *devx, double *devy,
-               double *screenx, double *screeny)
+scale_to_desktop(DeviceIntPtr dev, ValuatorMask *mask,
+                 double *devx, double *devy,
+                 double *screenx, double *screeny)
 {
-    double x, y;
-    double tmpx, tmpy;
     ScreenPtr scr = miPointerGetScreen(dev);
+    double x, y;
 
+    BUG_WARN(!dev->valuator);
+    BUG_WARN(dev->valuator->numAxes < 2);
     if (!dev->valuator || dev->valuator->numAxes < 2)
         return scr;
 
@@ -849,11 +873,48 @@ positionSprite(DeviceIntPtr dev, int mode, ValuatorMask *mask,
     *screeny = rescaleValuatorAxis(y, dev->valuator->axes + 1, NULL,
                                    screenInfo.y, screenInfo.height);
 
-    tmpx = *screenx;
-    tmpy = *screeny;
     *devx = x;
     *devy = y;
 
+    return scr;
+}
+
+/**
+ * If we have HW cursors, this actually moves the visible sprite. If not, we
+ * just do all the screen crossing, etc.
+ *
+ * We use the screen coordinates here, call miPointerSetPosition() and then
+ * scale back into device coordinates (if needed). miPSP will change x/y if
+ * the screen was crossed.
+ *
+ * The coordinates provided are always absolute. The parameter mode
+ * specifies whether it was relative or absolute movement that landed us at
+ * those coordinates. see fill_pointer_events for information on coordinate
+ * systems.
+ *
+ * @param dev The device to be moved.
+ * @param mode Movement mode (Absolute or Relative)
+ * @param[out] mask Mask of axis values for this event, returns the
+ * per-screen device coordinates after confinement
+ * @param[in,out] devx x desktop-wide coordinate in device coordinate system
+ * @param[in,out] devy y desktop-wide coordinate in device coordinate system
+ * @param[in,out] screenx x coordinate in desktop coordinate system
+ * @param[in,out] screeny y coordinate in desktop coordinate system
+ */
+static ScreenPtr
+positionSprite(DeviceIntPtr dev, int mode, ValuatorMask *mask,
+               double *devx, double *devy,
+               double *screenx, double *screeny)
+{
+    ScreenPtr scr = miPointerGetScreen(dev);
+    double tmpx, tmpy;
+
+    if (!dev->valuator || dev->valuator->numAxes < 2)
+        return scr;
+
+    tmpx = *screenx;
+    tmpy = *screeny;
+
     /* miPointerSetPosition takes care of crossing screens for us, as well as
      * clipping to the current screen. Coordinates returned are in desktop
      * coord system */
@@ -873,11 +934,13 @@ positionSprite(DeviceIntPtr dev, int mode, ValuatorMask *mask,
 
     /* Recalculate the per-screen device coordinates */
     if (valuator_mask_isset(mask, 0)) {
+        double x;
         x = rescaleValuatorAxis(*screenx - scr->x, NULL, dev->valuator->axes + 0,
                                 0, scr->width);
         valuator_mask_set_double(mask, 0, x);
     }
     if (valuator_mask_isset(mask, 1)) {
+        double y;
         y = rescaleValuatorAxis(*screeny - scr->y, NULL, dev->valuator->axes + 1,
                                 0, scr->height);
         valuator_mask_set_double(mask, 1, y);
@@ -1272,6 +1335,7 @@ fill_pointer_events(InternalEvent *events, DeviceIntPtr pDev, int type,
     if ((flags & POINTER_NORAW) == 0)
         set_raw_valuators(raw, &mask, raw->valuators.data);
 
+    scale_to_desktop(pDev, &mask, &devx, &devy, &screenx, &screeny);
     scr = positionSprite(pDev, (flags & POINTER_ABSOLUTE) ? Absolute : Relative,
                          &mask, &devx, &devy, &screenx, &screeny);
 
@@ -1611,6 +1675,252 @@ GetProximityEvents(InternalEvent *events, DeviceIntPtr pDev, int type, const Val
     return num_events;
 }
 
+int
+GetTouchOwnershipEvents(InternalEvent *events, DeviceIntPtr pDev,
+                        TouchPointInfoPtr ti, uint8_t reason, XID resource,
+                        uint32_t flags)
+{
+    TouchClassPtr t = pDev->touch;
+    TouchOwnershipEvent *event;
+    CARD32 ms = GetTimeInMillis();
+
+    if (!pDev->enabled || !t || !ti)
+        return 0;
+
+    event = &events->touch_ownership_event;
+    init_touch_ownership(pDev, event, ms);
+
+    event->touchid = ti->client_id;
+    event->sourceid = ti->sourceid;
+    event->resource = resource;
+    event->flags = flags;
+    event->reason = reason;
+
+    return 1;
+}
+
+/**
+ * Generate internal events representing this touch event and enqueue them
+ * on the event queue.
+ *
+ * This function is not reentrant. Disable signals before calling.
+ *
+ * @param device The device to generate the event for
+ * @param type Event type, one of XI_TouchBegin, XI_TouchUpdate, XI_TouchEnd
+ * @param touchid Touch point ID
+ * @param flags Event modification flags
+ * @param mask Valuator mask for valuators present for this event.
+ */
+void
+QueueTouchEvents(DeviceIntPtr device, int type,
+                 uint32_t ddx_touchid, int flags, const ValuatorMask *mask)
+{
+    int nevents;
+
+    nevents = GetTouchEvents(InputEventList, device, ddx_touchid, type, flags, mask);
+    queueEventList(device, InputEventList, nevents);
+}
+
+/**
+ * Get events for a touch. Generates a TouchBegin event if end is not set and
+ * the touch id is not active. Generates a TouchUpdate event if end is not set
+ * and the touch id is active. Generates a TouchEnd event if end is set and the
+ * touch id is active.
+ *
+ * events is not NULL-terminated; the return value is the number of events.
+ * The DDX is responsible for allocating the event structure in the first
+ * place via GetMaximumEventsNum(), and for freeing it.
+ *
+ * @param[out] events The list of events generated
+ * @param dev The device to generate the events for
+ * @param ddx_touchid The touch ID as assigned by the DDX
+ * @param type XI_TouchBegin, XI_TouchUpdate or XI_TouchEnd
+ * @param flags Event flags
+ * @param mask_in Valuator information for this event
+ */
+int
+GetTouchEvents(InternalEvent *events, DeviceIntPtr dev, uint32_t ddx_touchid,
+               uint16_t type, uint32_t flags, const ValuatorMask *mask_in)
+{
+    ScreenPtr scr = dev->spriteInfo->sprite->hotPhys.pScreen;
+    TouchClassPtr t = dev->touch;
+    ValuatorClassPtr v = dev->valuator;
+    DeviceEvent *event;
+    CARD32 ms = GetTimeInMillis();
+    ValuatorMask mask;
+    double screenx = 0.0, screeny = 0.0; /* desktop coordinate system */
+    double devx = 0.0, devy = 0.0; /* desktop-wide in device coords */
+    int i;
+    int num_events = 0;
+    RawDeviceEvent *raw;
+    union touch {
+        TouchPointInfoPtr dix_ti;
+        DDXTouchPointInfoPtr ti;
+    } touchpoint;
+    int need_rawevent = TRUE;
+    Bool emulate_pointer = FALSE;
+    int client_id = 0;
+
+    if (!dev->enabled || !t || !v)
+        return 0;
+
+    /* Find and/or create the DDX touch info */
+
+    if (flags & TOUCH_CLIENT_ID) /* A DIX-submitted TouchEnd */
+    {
+        touchpoint.dix_ti = TouchFindByClientID(dev, ddx_touchid);
+        BUG_WARN(!touchpoint.dix_ti);
+
+        if (!touchpoint.dix_ti)
+            return 0;
+
+        if (!mask_in ||
+            !valuator_mask_isset(mask_in, 0) ||
+            !valuator_mask_isset(mask_in, 1))
+        {
+            ErrorF("[dix] dix-submitted events must have x/y valuator information.\n");
+            return 0;
+        }
+
+        need_rawevent = FALSE;
+        client_id = touchpoint.dix_ti->client_id;
+    } else /* a DDX-submitted touch */
+    {
+        touchpoint.ti = TouchFindByDDXID(dev, ddx_touchid, (type == XI_TouchBegin));
+        if (!touchpoint.ti)
+        {
+            ErrorF("[dix] %s: unable to %s touch point %x\n", dev->name,
+                    type == XI_TouchBegin ? "begin" : "find", ddx_touchid);
+            return 0;
+        }
+        client_id = touchpoint.ti->client_id;
+    }
+
+    if (!(flags & TOUCH_CLIENT_ID))
+        emulate_pointer =  touchpoint.ti->emulate_pointer;
+    else
+        emulate_pointer = !!(flags & TOUCH_POINTER_EMULATED);
+
+    if (!IsMaster(dev))
+        events = UpdateFromMaster(events, dev, DEVCHANGE_POINTER_EVENT, &num_events);
+
+    valuator_mask_copy(&mask, mask_in);
+
+    if (need_rawevent)
+    {
+        raw = &events->raw_event;
+        events++;
+        num_events++;
+        init_raw(dev, raw, ms, type, client_id);
+        set_raw_valuators(raw, &mask, raw->valuators.data_raw);
+    }
+
+    event = &events->device_event;
+    num_events++;
+
+    init_event(dev, event, ms);
+    /* if submitted for master device, get the sourceid from there */
+    if (flags & TOUCH_CLIENT_ID)
+    {
+        event->sourceid = touchpoint.dix_ti->sourceid;
+        /* TOUCH_CLIENT_ID implies norawevent */
+    }
+
+    switch (type) {
+    case XI_TouchBegin:
+        event->type = ET_TouchBegin;
+        /* If we're starting a touch, we must have x & y co-ordinates. */
+        if (!mask_in ||
+            !valuator_mask_isset(mask_in, 0) ||
+            !valuator_mask_isset(mask_in, 1))
+        {
+            ErrorF("%s: Attempted to start touch without x/y (driver bug)\n",
+                   dev->name);
+            return 0;
+        }
+        break;
+    case XI_TouchUpdate:
+        event->type = ET_TouchUpdate;
+        if (!mask_in || valuator_mask_num_valuators(mask_in) <= 0)
+        {
+            ErrorF("%s: TouchUpdate with no valuators? Driver bug\n",
+                    dev->name);
+        }
+        break;
+    case XI_TouchEnd:
+        event->type = ET_TouchEnd;
+        /* We can end the DDX touch here, since we don't use the active
+         * field below */
+        if (!(flags & TOUCH_CLIENT_ID))
+            TouchEndDDXTouch(dev, touchpoint.ti);
+        break;
+    default:
+        return 0;
+    }
+    if (!(flags & TOUCH_CLIENT_ID))
+    {
+        if (!valuator_mask_isset(&mask, 0))
+            valuator_mask_set_double(&mask, 0, valuator_mask_get_double(touchpoint.ti->valuators, 0));
+        if (!valuator_mask_isset(&mask, 1))
+            valuator_mask_set_double(&mask, 1, valuator_mask_get_double(touchpoint.ti->valuators, 1));
+    }
+
+    /* Get our screen event co-ordinates (root_x/root_y/event_x/event_y):
+     * these come from the touchpoint in Absolute mode, or the sprite in
+     * Relative. */
+    if (t->mode == XIDirectTouch) {
+        transformAbsolute(dev, &mask);
+
+        if (!(flags & TOUCH_CLIENT_ID)) {
+            for (i = 0; i < valuator_mask_size(&mask); i++) {
+                double val;
+                if (valuator_mask_fetch_double(&mask, i, &val))
+                    valuator_mask_set_double(touchpoint.ti->valuators, i, val);
+            }
+        }
+
+        clipAbsolute(dev, &mask);
+    }
+    else {
+        screenx = dev->spriteInfo->sprite->hotPhys.x;
+        screeny = dev->spriteInfo->sprite->hotPhys.y;
+    }
+    if (need_rawevent)
+        set_raw_valuators(raw, &mask, raw->valuators.data);
+
+    scr = scale_to_desktop(dev, &mask, &devx, &devy, &screenx, &screeny);
+    if (emulate_pointer)
+        scr = positionSprite(dev, Absolute, &mask,
+                             &devx, &devy, &screenx, &screeny);
+
+    /* see fill_pointer_events for coordinate systems */
+    updateHistory(dev, &mask, ms);
+    clipValuators(dev, &mask);
+    storeLastValuators(dev, &mask, 0, 1, devx, devy);
+
+    event->root = scr->root->drawable.id;
+
+    event_set_root_coordinates(event, screenx, screeny);
+    event->touchid = client_id;
+    event->flags = flags;
+
+    if (emulate_pointer)
+    {
+        event->flags |= TOUCH_POINTER_EMULATED;
+        event->detail.button = 1;
+    }
+
+    set_valuators(dev, event, &mask);
+    for (i = 0; i < v->numAxes; i++)
+    {
+        if (valuator_mask_isset(&mask, i))
+            v->axisVal[i] = valuator_mask_get(&mask, i);
+    }
+
+    return num_events;
+}
+
+
 /**
  * Synthesize a single motion event for the core pointer.
  *
diff --git a/xorg-server/dix/grabs.c b/xorg-server/dix/grabs.c
index da014dfc3..701470c83 100644
--- a/xorg-server/dix/grabs.c
+++ b/xorg-server/dix/grabs.c
@@ -266,6 +266,9 @@ CreateGrab(
 void
 FreeGrab(GrabPtr pGrab)
 {
+    if (pGrab->grabtype == XI2 && pGrab->type == XI_TouchBegin)
+        TouchListenerGone(pGrab->resource);
+
     free(pGrab->modifiersDetail.pMask);
     free(pGrab->detail.pMask);
 
diff --git a/xorg-server/dix/inpututils.c b/xorg-server/dix/inpututils.c
index 8cd4d5921..d279c1d75 100644
--- a/xorg-server/dix/inpututils.c
+++ b/xorg-server/dix/inpututils.c
@@ -663,6 +663,8 @@ int event_get_corestate(DeviceIntPtr mouse, DeviceIntPtr kbd)
     /* core state needs to be assembled BEFORE the device is updated. */
     corestate = (kbd && kbd->key) ? XkbStateFieldFromRec(&kbd->key->xkbInfo->state) : 0;
     corestate |= (mouse && mouse->button) ? (mouse->button->state) : 0;
+    corestate |= (mouse && mouse->touch) ? (mouse->touch->state) : 0;
+
     return corestate;
 }
 
@@ -672,7 +674,10 @@ void event_set_state(DeviceIntPtr mouse, DeviceIntPtr kbd, DeviceEvent *event)
 
     for (i = 0; mouse && mouse->button && i < mouse->button->numButtons; i++)
         if (BitIsOn(mouse->button->down, i))
-            SetBit(event->buttons, i);
+            SetBit(event->buttons, mouse->button->map[i]);
+
+    if (mouse && mouse->touch && mouse->touch->buttonsDown > 0)
+        SetBit(event->buttons, mouse->button->map[1]);
 
     if (kbd && kbd->key)
     {
diff --git a/xorg-server/dix/touch.c b/xorg-server/dix/touch.c
new file mode 100644
index 000000000..db0bf334a
--- /dev/null
+++ b/xorg-server/dix/touch.c
@@ -0,0 +1,982 @@
+/*
+ * Copyright © 2011 Collabra Ltd.
+ * Copyright © 2011 Red Hat, Inc.
+ *
+ * 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 (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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
+ *
+ * Author: Daniel Stone <daniel@fooishbar.org>
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "inputstr.h"
+#include "scrnintstr.h"
+#include "dixgrabs.h"
+
+#include "eventstr.h"
+#include "exevents.h"
+#include "inpututils.h"
+#include "eventconvert.h"
+#include "windowstr.h"
+#include "mi.h"
+
+#define TOUCH_HISTORY_SIZE 100
+
+
+/* If a touch queue resize is needed, the device id's bit is set. */
+static unsigned char resize_waiting[(MAXDEVICES + 7)/8];
+
+/**
+ * Some documentation about touch points:
+ * The driver submits touch events with it's own (unique) touch point ID.
+ * The driver may re-use those IDs, the DDX doesn't care. It just passes on
+ * the data to the DIX. In the server, the driver's ID is referred to as the
+ * DDX id anyway.
+ *
+ * On a TouchBegin, we create a DDXTouchPointInfo that contains the DDX id
+ * and the client ID that this touchpoint will have. The client ID is the
+ * one visible on the protocol.
+ *
+ * TouchUpdate and TouchEnd will only be processed if there is an active
+ * touchpoint with the same DDX id.
+ *
+ * The DDXTouchPointInfo struct is stored dev->last.touches. When the event
+ * being processed, it becomes a TouchPointInfo in dev->touch-touches which
+ * contains amongst other things the sprite trace and delivery information.
+ */
+
+/**
+ * Check which devices need a bigger touch event queue and grow their
+ * last.touches by half it's current size.
+ *
+ * @param client Always the serverClient
+ * @param closure Always NULL
+ *
+ * @return Always True. If we fail to grow we probably will topple over soon
+ * anyway and re-executing this won't help.
+ */
+static Bool
+TouchResizeQueue(ClientPtr client, pointer closure)
+{
+    int i;
+
+    OsBlockSignals();
+
+    /* first two ids are reserved */
+    for (i = 2; i < MAXDEVICES; i++)
+    {
+        DeviceIntPtr dev;
+        DDXTouchPointInfoPtr tmp;
+        size_t size;
+
+        if (!BitIsOn(resize_waiting, i))
+            continue;
+
+        ClearBit(resize_waiting, i);
+
+        /* device may have disappeared by now */
+        dixLookupDevice(&dev, i, serverClient, DixWriteAccess);
+        if (!dev)
+            continue;
+
+        /* Need to grow the queue means dropping events. Grow sufficiently so we
+         * don't need to do it often */
+        size = dev->last.num_touches + dev->last.num_touches/2 + 1;
+
+        tmp = realloc(dev->last.touches, size *  sizeof(*dev->last.touches));
+        if (tmp)
+        {
+            int i;
+            dev->last.touches = tmp;
+            for (i = dev->last.num_touches; i < size; i++)
+                TouchInitDDXTouchPoint(dev, &dev->last.touches[i]);
+            dev->last.num_touches = size;
+        }
+
+    }
+    OsReleaseSignals();
+
+    return TRUE;
+}
+
+/**
+ * Given the DDX-facing ID (which is _not_ DeviceEvent::detail.touch), find the
+ * associated DDXTouchPointInfoRec.
+ *
+ * @param dev The device to create the touch point for
+ * @param ddx_id Touch id assigned by the driver/ddx
+ * @param create Create the touchpoint if it cannot be found
+ */
+DDXTouchPointInfoPtr
+TouchFindByDDXID(DeviceIntPtr dev, uint32_t ddx_id, Bool create)
+{
+    DDXTouchPointInfoPtr ti;
+    int i;
+
+    if (!dev->touch)
+        return NULL;
+
+    for (i = 0; i < dev->last.num_touches; i++)
+    {
+        ti = &dev->last.touches[i];
+        if (ti->active && ti->ddx_id == ddx_id)
+            return ti;
+    }
+
+    return create ? TouchBeginDDXTouch(dev, ddx_id) : NULL;
+}
+
+/**
+ * Given a unique DDX ID for a touchpoint, create a touchpoint record and
+ * return it.
+ *
+ * If no other touch points are active, mark new touchpoint for pointer
+ * emulation.
+ *
+ * Returns NULL on failure (i.e. if another touch with that ID is already active,
+ * allocation failure).
+ */
+DDXTouchPointInfoPtr
+TouchBeginDDXTouch(DeviceIntPtr dev, uint32_t ddx_id)
+{
+    static int next_client_id = 1;
+    int i;
+    TouchClassPtr t = dev->touch;
+    DDXTouchPointInfoPtr ti = NULL;
+    Bool emulate_pointer = (t->mode == XIDirectTouch);
+
+    if (!t)
+        return NULL;
+
+    /* Look for another active touchpoint with the same DDX ID. DDX
+     * touchpoints must be unique. */
+    if (TouchFindByDDXID(dev, ddx_id, FALSE))
+        return NULL;
+
+    for (i = 0; i < dev->last.num_touches; i++)
+    {
+        /* Only emulate pointer events on the first touch */
+        if (dev->last.touches[i].active)
+            emulate_pointer = FALSE;
+        else if (!ti) /* ti is now first non-active touch rec */
+            ti = &dev->last.touches[i];
+
+        if (!emulate_pointer && ti)
+            break;
+    }
+
+    if (ti)
+    {
+        int client_id;
+        ti->active = TRUE;
+        ti->ddx_id = ddx_id;
+        client_id = next_client_id;
+        next_client_id++;
+        if (next_client_id == 0)
+            next_client_id = 1;
+        ti->client_id = client_id;
+        ti->emulate_pointer = emulate_pointer;
+        return ti;
+    }
+
+    /* If we get here, then we've run out of touches and we need to drop the
+     * event (we're inside the SIGIO handler here) schedule a WorkProc to
+     * grow the queue for us for next time. */
+    ErrorF("%s: not enough space for touch events (max %d touchpoints). "
+           "Dropping this event.\n", dev->name, dev->last.num_touches);
+    if (!BitIsOn(resize_waiting, dev->id)) {
+        SetBit(resize_waiting, dev->id);
+        QueueWorkProc(TouchResizeQueue, serverClient, NULL);
+    }
+
+    return NULL;
+}
+
+void
+TouchEndDDXTouch(DeviceIntPtr dev, DDXTouchPointInfoPtr ti)
+{
+    TouchClassPtr t = dev->touch;
+
+    if (!t)
+        return;
+
+    ti->active = FALSE;
+}
+
+void
+TouchInitDDXTouchPoint(DeviceIntPtr dev, DDXTouchPointInfoPtr ddxtouch)
+{
+    memset(ddxtouch, 0, sizeof(*ddxtouch));
+    ddxtouch->valuators = valuator_mask_new(dev->valuator->numAxes);
+}
+
+
+Bool
+TouchInitTouchPoint(TouchClassPtr t, ValuatorClassPtr v, int index)
+{
+    TouchPointInfoPtr ti;
+
+    if (index >= t->num_touches)
+        return FALSE;
+    ti = &t->touches[index];
+
+    memset(ti, 0, sizeof(*ti));
+
+    ti->valuators = valuator_mask_new(v->numAxes);
+    if (!ti->valuators)
+        return FALSE;
+
+    ti->sprite.spriteTrace = calloc(32, sizeof(*ti->sprite.spriteTrace));
+    if (!ti->sprite.spriteTrace)
+    {
+        valuator_mask_free(&ti->valuators);
+        return FALSE;
+    }
+    ti->sprite.spriteTraceSize = 32;
+    ti->sprite.spriteTrace[0] = screenInfo.screens[0]->root;
+    ti->sprite.hot.pScreen = screenInfo.screens[0];
+    ti->sprite.hotPhys.pScreen = screenInfo.screens[0];
+
+    ti->client_id = -1;
+
+    return TRUE;
+}
+
+void
+TouchFreeTouchPoint(DeviceIntPtr device, int index)
+{
+    TouchPointInfoPtr ti;
+
+    if (!device->touch || index >= device->touch->num_touches)
+        return;
+    ti = &device->touch->touches[index];
+
+    if (ti->active)
+        TouchEndTouch(device, ti);
+
+    valuator_mask_free(&ti->valuators);
+    free(ti->sprite.spriteTrace);
+    ti->sprite.spriteTrace = NULL;
+    free(ti->listeners);
+    ti->listeners = NULL;
+    free(ti->history);
+    ti->history = NULL;
+    ti->history_size = 0;
+    ti->history_elements = 0;
+}
+
+/**
+ * Given a client-facing ID (e.g. DeviceEvent::detail.touch), find the
+ * associated TouchPointInfoRec.
+ */
+TouchPointInfoPtr
+TouchFindByClientID(DeviceIntPtr dev, uint32_t client_id)
+{
+    TouchClassPtr t = dev->touch;
+    TouchPointInfoPtr ti;
+    int i;
+
+    if (!t)
+        return NULL;
+
+    for (i = 0; i < t->num_touches; i++)
+    {
+        ti = &t->touches[i];
+        if (ti->active && ti->client_id == client_id)
+            return ti;
+    }
+
+    return NULL;
+}
+
+
+/**
+ * Given a unique ID for a touchpoint, create a touchpoint record in the
+ * server.
+ *
+ * Returns NULL on failure (i.e. if another touch with that ID is already active,
+ * allocation failure).
+ */
+TouchPointInfoPtr
+TouchBeginTouch(DeviceIntPtr dev, int sourceid, uint32_t touchid,
+                Bool emulate_pointer)
+{
+    int i;
+    TouchClassPtr t = dev->touch;
+    TouchPointInfoPtr ti;
+    void *tmp;
+
+    if (!t)
+        return NULL;
+
+    /* Look for another active touchpoint with the same client ID.  It's
+     * technically legitimate for a touchpoint to still exist with the same
+     * ID but only once the 32 bits wrap over and you've used up 4 billion
+     * touch ids without lifting that one finger off once. In which case
+     * you deserve a medal or something, but not error handling code. */
+    if (TouchFindByClientID(dev, touchid))
+        return NULL;
+
+try_find_touch:
+    for (i = 0; i < t->num_touches; i++)
+    {
+        ti = &t->touches[i];
+        if (!ti->active) {
+            ti->active = TRUE;
+            ti->client_id = touchid;
+            ti->sourceid = sourceid;
+            ti->emulate_pointer = emulate_pointer;
+            return ti;
+        }
+    }
+
+    /* If we get here, then we've run out of touches: enlarge dev->touch and
+     * try again. */
+    tmp = realloc(t->touches, (t->num_touches + 1) * sizeof(*ti));
+    if (tmp)
+    {
+        t->touches = tmp;
+        t->num_touches++;
+        if (TouchInitTouchPoint(t, dev->valuator, t->num_touches - 1))
+            goto try_find_touch;
+    }
+
+    return NULL;
+}
+
+/**
+ * Releases a touchpoint for use: this must only be called after all events
+ * related to that touchpoint have been sent and finalised.  Called from
+ * ProcessTouchEvent and friends.  Not by you.
+ */
+void
+TouchEndTouch(DeviceIntPtr dev, TouchPointInfoPtr ti)
+{
+    if (ti->emulate_pointer)
+    {
+        GrabPtr grab;
+        DeviceEvent ev;
+        memset(&ev, 0, sizeof(ev));
+        ev.type = ET_TouchEnd;
+        ev.detail.button = 1;
+        ev.touchid = ti->client_id;
+        ev.flags = TOUCH_POINTER_EMULATED|TOUCH_END;
+        UpdateDeviceState(dev, &ev);
+
+        if ((grab = dev->deviceGrab.grab))
+        {
+            if (dev->deviceGrab.fromPassiveGrab &&
+                !dev->button->buttonsDown &&
+                !dev->touch->buttonsDown &&
+                GrabIsPointerGrab(grab))
+                (*dev->deviceGrab.DeactivateGrab)(dev);
+        }
+    }
+
+    ti->active = FALSE;
+    ti->pending_finish = FALSE;
+    ti->sprite.spriteTraceGood = 0;
+    free(ti->listeners);
+    ti->listeners = NULL;
+    ti->num_listeners = 0;
+    ti->num_grabs = 0;
+    ti->client_id = 0;
+
+    TouchEventHistoryFree(ti);
+
+    valuator_mask_zero(ti->valuators);
+}
+
+/**
+ * Allocate the event history for this touch pointer. Calling this on a
+ * touchpoint that already has an event history does nothing but counts as
+ * as success.
+ *
+ * @return TRUE on success, FALSE on allocation errors
+ */
+Bool
+TouchEventHistoryAllocate(TouchPointInfoPtr ti)
+{
+    if (ti->history)
+        return TRUE;
+
+    ti->history = calloc(TOUCH_HISTORY_SIZE, sizeof(*ti->history));
+    ti->history_elements = 0;
+    if (ti->history)
+        ti->history_size = TOUCH_HISTORY_SIZE;
+    return ti->history != NULL;
+}
+
+void
+TouchEventHistoryFree(TouchPointInfoPtr ti)
+{
+    free(ti->history);
+    ti->history = NULL;
+    ti->history_size = 0;
+    ti->history_elements = 0;
+}
+
+/**
+ * Store the given event on the event history (if one exists)
+ * A touch event history consists of one TouchBegin and several TouchUpdate
+ * events (if applicable) but no TouchEnd event.
+ * If more than one TouchBegin is pushed onto the stack, the push is
+ * ignored, calling this function multiple times for the TouchBegin is
+ * valid.
+ */
+void
+TouchEventHistoryPush(TouchPointInfoPtr ti, const DeviceEvent *ev)
+{
+    if (!ti->history)
+        return;
+
+    switch(ev->type)
+    {
+        case ET_TouchBegin:
+            /* don't store the same touchbegin twice */
+            if (ti->history_elements > 0)
+                return;
+            break;
+        case ET_TouchUpdate:
+            break;
+        case ET_TouchEnd:
+            return; /* no TouchEnd events in the history */
+        default:
+            return;
+    }
+
+    /* We only store real events in the history */
+    if (ev->flags & (TOUCH_CLIENT_ID|TOUCH_REPLAYING))
+        return;
+
+    ti->history[ti->history_elements++] = *ev;
+    /* FIXME: proper overflow fixes */
+    if (ti->history_elements > ti->history_size - 1)
+    {
+        ti->history_elements = ti->history_size - 1;
+        DebugF("source device %d: history size %d overflowing for touch %u\n",
+                ti->sourceid, ti->history_size, ti->client_id);
+    }
+}
+
+void
+TouchEventHistoryReplay(TouchPointInfoPtr ti, DeviceIntPtr dev, XID resource)
+{
+    InternalEvent *tel = InitEventList(GetMaximumEventsNum());
+    ValuatorMask *mask = valuator_mask_new(0);
+    int i, nev;
+    int flags;
+
+    if (!ti->history)
+        return;
+
+    valuator_mask_set_double(mask, 0, ti->history[0].valuators.data[0]);
+    valuator_mask_set_double(mask, 1, ti->history[0].valuators.data[1]);
+
+    flags = TOUCH_CLIENT_ID|TOUCH_REPLAYING;
+    if (ti->emulate_pointer)
+        flags |= TOUCH_POINTER_EMULATED;
+    /* send fake begin event to next owner */
+    nev = GetTouchEvents(tel, dev, ti->client_id, XI_TouchBegin, flags, mask);
+    for (i = 0; i < nev; i++)
+        DeliverTouchEvents(dev, ti, tel + i, resource);
+
+    valuator_mask_free(&mask);
+    FreeEventList(tel, GetMaximumEventsNum());
+
+    /* First event was TouchBegin, already replayed that one */
+    for (i = 1; i < ti->history_elements; i++)
+    {
+        DeviceEvent *ev = &ti->history[i];
+        ev->flags |= TOUCH_REPLAYING;
+        DeliverTouchEvents(dev, ti, (InternalEvent*)ev, resource);
+    }
+}
+
+Bool
+TouchBuildDependentSpriteTrace(DeviceIntPtr dev, SpritePtr sprite)
+{
+    int i;
+    TouchClassPtr t = dev->touch;
+    WindowPtr *trace;
+    SpritePtr srcsprite;
+
+    /* All touches should have the same sprite trace, so find and reuse an
+     * existing touch's sprite if possible, else use the device's sprite. */
+    for (i = 0; i < t->num_touches; i++)
+        if (t->touches[i].sprite.spriteTraceGood > 0)
+            break;
+    if (i < t->num_touches)
+        srcsprite = &t->touches[i].sprite;
+    else if (dev->spriteInfo->sprite)
+        srcsprite = dev->spriteInfo->sprite;
+    else
+        return FALSE;
+
+    if (srcsprite->spriteTraceGood > sprite->spriteTraceSize)
+    {
+        trace = realloc(sprite->spriteTrace,
+                srcsprite->spriteTraceSize * sizeof(*trace));
+        if (!trace)
+        {
+            sprite->spriteTraceGood = 0;
+            return FALSE;
+        }
+        sprite->spriteTrace = trace;
+        sprite->spriteTraceSize = srcsprite->spriteTraceGood;
+    }
+    memcpy(sprite->spriteTrace, srcsprite->spriteTrace,
+            srcsprite->spriteTraceGood * sizeof(*trace));
+    sprite->spriteTraceGood = srcsprite->spriteTraceGood;
+
+    return TRUE;
+}
+
+/**
+ * Ensure a window trace is present in ti->sprite, constructing one for
+ * TouchBegin events.
+ */
+Bool
+TouchEnsureSprite(DeviceIntPtr sourcedev, TouchPointInfoPtr ti,
+                  InternalEvent *ev)
+{
+    TouchClassPtr t = sourcedev->touch;
+    SpritePtr sprite = &ti->sprite;
+
+    /* We may not have a sprite if there are no applicable grabs or
+     * event selections, or if they've disappeared, or if all the grab
+     * owners have rejected the touch.  Don't bother delivering motion
+     * events if not, but TouchEnd events still need to be processed so
+     * we can call FinishTouchPoint and release it for later use. */
+    if (ev->any.type == ET_TouchEnd)
+        return TRUE;
+    else if (ev->any.type != ET_TouchBegin)
+        return (sprite->spriteTraceGood > 0);
+
+    if (t->mode == XIDirectTouch)
+    {
+        /* Focus immediately under the touchpoint in direct touch mode.
+         * XXX: Do we need to handle crossing screens here? */
+        sprite->spriteTrace[0] =
+            sourcedev->spriteInfo->sprite->hotPhys.pScreen->root;
+        XYToWindow(sprite, ev->device_event.root_x, ev->device_event.root_y);
+    }
+    else if (!TouchBuildDependentSpriteTrace(sourcedev, sprite))
+        return FALSE;
+
+    if (sprite->spriteTraceGood <= 0)
+        return FALSE;
+
+    /* Mark which grabs/event selections we're delivering to: max one grab per
+     * window plus the bottom-most event selection. */
+    ti->listeners = calloc(sprite->spriteTraceGood + 1, sizeof(*ti->listeners));
+    if (!ti->listeners)
+    {
+        sprite->spriteTraceGood = 0;
+        return FALSE;
+    }
+    ti->num_listeners = 0;
+
+    return TRUE;
+}
+
+/**
+ * Copy the touch event into the pointer_event, switching the required
+ * fields to make it a correct pointer event.
+ *
+ * @param event The original touch event
+ * @param[in] motion_event The respective motion event
+ * @param[in] button_event The respective button event (if any)
+ *
+ * @returns The number of converted events.
+ * @retval 0 An error occured
+ * @retval 1 only the motion event is valid
+ * @retval 2 motion and button event are valid
+ */
+int
+TouchConvertToPointerEvent(const InternalEvent *event,
+                           InternalEvent *motion_event,
+                           InternalEvent *button_event)
+{
+    int ptrtype;
+    int nevents = 0;
+
+    BUG_WARN(!event);
+    BUG_WARN(!motion_event);
+
+    switch(event->any.type)
+    {
+        case ET_TouchUpdate:
+            nevents = 1;
+            break;
+        case ET_TouchBegin:
+            nevents = 2; /* motion + press */
+            ptrtype = ET_ButtonPress;
+            break;
+        case ET_TouchEnd:
+            nevents = 2; /* motion + release */
+            ptrtype = ET_ButtonRelease;
+            break;
+        default:
+            BUG_WARN_MSG(1,"Invalid event type %d\n", event->any.type);
+            return 0;
+    }
+
+    BUG_WARN_MSG(!(event->device_event.flags & TOUCH_POINTER_EMULATED),
+                 "Non-emulating touch event\n");
+
+    *motion_event = *event;
+    motion_event->any.type = ET_Motion;
+    motion_event->device_event.detail.button = 0;
+    motion_event->device_event.flags = XIPointerEmulated;
+
+    if (nevents > 1)
+    {
+        BUG_WARN(!button_event);
+        *button_event = *event;
+        button_event->any.type = ptrtype;
+        button_event->device_event.flags = XIPointerEmulated;
+        /* detail is already correct */
+    }
+
+    return nevents;
+}
+
+/**
+ * Return the corresponding pointer emulation internal event type for the given
+ * touch event or 0 if no such event type exists.
+ */
+int
+TouchGetPointerEventType(const InternalEvent *event)
+{
+    int type = 0;
+
+    switch(event->any.type)
+    {
+        case ET_TouchBegin:  type = ET_ButtonPress;   break;
+        case ET_TouchUpdate: type = ET_Motion;        break;
+        case ET_TouchEnd:    type = ET_ButtonRelease; break;
+        default:
+            break;
+    }
+    return type;
+}
+
+
+/**
+ * @returns TRUE if the specified grab or selection is the current owner of
+ * the touch sequence.
+ */
+Bool
+TouchResourceIsOwner(TouchPointInfoPtr ti, XID resource)
+{
+    return (ti->listeners[0].listener == resource);
+}
+
+/**
+ * Add the resource to this touch's listeners.
+ */
+void
+TouchAddListener(TouchPointInfoPtr ti, XID resource, enum InputLevel level,
+                 enum TouchListenerType type, enum TouchListenerState state)
+{
+    ti->listeners[ti->num_listeners].listener = resource;
+    ti->listeners[ti->num_listeners].level = level;
+    ti->listeners[ti->num_listeners].state = state;
+    ti->listeners[ti->num_listeners].type = type;
+    ti->num_listeners++;
+}
+
+/**
+ * Remove the resource from this touch's listeners.
+ *
+ * @return TRUE if the resource was removed, FALSE if the resource was not
+ * in the list
+ */
+Bool
+TouchRemoveListener(TouchPointInfoPtr ti, XID resource)
+{
+    int i;
+    for (i = 0; i < ti->num_listeners; i++)
+    {
+        if (ti->listeners[i].listener == resource)
+        {
+            int j;
+            for (j = i; j< ti->num_listeners - 1; j++)
+                ti->listeners[j] = ti->listeners[j + 1];
+            ti->num_listeners--;
+            ti->listeners[ti->num_listeners].listener = 0;
+            ti->listeners[ti->num_listeners].state = LISTENER_AWAITING_BEGIN;
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+static void
+TouchAddGrabListener(DeviceIntPtr dev, TouchPointInfoPtr ti,
+                     InternalEvent *ev, GrabPtr grab)
+{
+    enum TouchListenerType type = LISTENER_GRAB;
+
+    /* FIXME: owner_events */
+
+    if (grab->grabtype == XI2)
+    {
+        if (!xi2mask_isset(grab->xi2mask, dev, XI_TouchOwnership))
+            TouchEventHistoryAllocate(ti);
+        if (!xi2mask_isset(grab->xi2mask, dev, XI_TouchBegin))
+            type = LISTENER_POINTER_GRAB;
+    } else if (grab->grabtype == XI || grab->grabtype == CORE)
+    {
+        TouchEventHistoryAllocate(ti);
+        type = LISTENER_POINTER_GRAB;
+    }
+
+    TouchAddListener(ti, grab->resource, grab->grabtype,
+                     type, LISTENER_AWAITING_BEGIN);
+    ti->num_grabs++;
+}
+
+/**
+ * Add one listener if there is a grab on the given window.
+ */
+static void
+TouchAddPassiveGrabListener(DeviceIntPtr dev, TouchPointInfoPtr ti,
+                            WindowPtr win, InternalEvent *ev)
+{
+    GrabPtr grab;
+    Bool check_core = IsMaster(dev) && ti->emulate_pointer;
+
+    /* FIXME: make CheckPassiveGrabsOnWindow only trigger on TouchBegin */
+    grab = CheckPassiveGrabsOnWindow(win, dev, ev, check_core, FALSE);
+    if (!grab)
+        return;
+
+    TouchAddGrabListener(dev, ti, ev, grab);
+}
+
+static Bool
+TouchAddRegularListener(DeviceIntPtr dev, TouchPointInfoPtr ti,
+                        WindowPtr win, InternalEvent *ev)
+{
+    InputClients *iclients = NULL;
+    OtherInputMasks *inputMasks = NULL;
+    uint16_t evtype = 0; /* may be event type or emulated event type */
+    enum TouchListenerType type = LISTENER_REGULAR;
+    int mask;
+
+    evtype = GetXI2Type(ev->any.type);
+    mask = EventIsDeliverable(dev, ev->any.type, win);
+    if (!mask && !ti->emulate_pointer)
+        return FALSE;
+    else if (!mask)/* now try for pointer event */
+    {
+        mask = EventIsDeliverable(dev, TouchGetPointerEventType(ev), win);
+        if (mask)
+        {
+            evtype = GetXI2Type(TouchGetPointerEventType(ev));
+            type = LISTENER_POINTER_REGULAR;
+        }
+    }
+    if (!mask)
+        return FALSE;
+
+    inputMasks = wOtherInputMasks(win);
+
+    if (mask & EVENT_XI2_MASK)
+    {
+        nt_list_for_each_entry(iclients, inputMasks->inputClients, next)
+        {
+            if (!xi2mask_isset(iclients->xi2mask, dev, evtype))
+                continue;
+
+            if (!xi2mask_isset(iclients->xi2mask, dev, XI_TouchOwnership))
+                TouchEventHistoryAllocate(ti);
+
+            TouchAddListener(ti, iclients->resource, XI2,
+                             type, LISTENER_AWAITING_BEGIN);
+            return TRUE;
+        }
+    }
+
+    if (mask & EVENT_XI1_MASK)
+    {
+        int xitype = GetXIType(TouchGetPointerEventType(ev));
+        Mask xi_filter = event_get_filter_from_type(dev, xitype);
+        nt_list_for_each_entry(iclients, inputMasks->inputClients, next)
+        {
+            if (!(iclients->mask[dev->id] & xi_filter))
+                continue;
+
+            TouchEventHistoryAllocate(ti);
+            TouchAddListener(ti, iclients->resource, XI,
+                             LISTENER_POINTER_REGULAR, LISTENER_AWAITING_BEGIN);
+            return TRUE;
+        }
+    }
+
+    if (mask & EVENT_CORE_MASK)
+    {
+        int coretype = GetCoreType(TouchGetPointerEventType(ev));
+        Mask core_filter = event_get_filter_from_type(dev, coretype);
+
+        /* window owner */
+        if (IsMaster(dev) && (win->eventMask & core_filter))
+        {
+            TouchEventHistoryAllocate(ti);
+            TouchAddListener(ti, win->drawable.id, CORE,
+                             LISTENER_POINTER_REGULAR, LISTENER_AWAITING_BEGIN);
+            return TRUE;
+        }
+
+        /* all others */
+        nt_list_for_each_entry(iclients, (InputClients*)wOtherClients(win), next)
+        {
+            if (!(iclients->mask[XIAllDevices] & core_filter))
+                continue;
+
+            TouchEventHistoryAllocate(ti);
+            TouchAddListener(ti, iclients->resource, CORE,
+                             type, LISTENER_AWAITING_BEGIN);
+            return TRUE;
+        }
+    }
+
+    return FALSE;
+}
+
+static void
+TouchAddActiveGrabListener(DeviceIntPtr dev, TouchPointInfoPtr ti,
+                           InternalEvent *ev, GrabPtr grab)
+{
+    if (!ti->emulate_pointer &&
+        (grab->grabtype == CORE || grab->grabtype == XI))
+        return;
+
+    if (!ti->emulate_pointer &&
+        grab->grabtype == XI2 &&
+        (grab->type != XI_TouchBegin && grab->type != XI_TouchEnd && grab->type != XI_TouchUpdate))
+        return;
+
+    TouchAddGrabListener(dev, ti, ev, grab);
+}
+
+void
+TouchSetupListeners(DeviceIntPtr dev, TouchPointInfoPtr ti, InternalEvent *ev)
+{
+    int i;
+    SpritePtr sprite = &ti->sprite;
+    WindowPtr win;
+
+    if (dev->deviceGrab.grab)
+        TouchAddActiveGrabListener(dev, ti, ev, dev->deviceGrab.grab);
+
+    /* First, find all grabbing clients from the root window down
+     * to the deepest child window. */
+    for (i = 0; i < sprite->spriteTraceGood; i++)
+    {
+        win = sprite->spriteTrace[i];
+        TouchAddPassiveGrabListener(dev, ti, win, ev);
+    }
+
+    /* Find the first client with an applicable event selection,
+     * going from deepest child window back up to the root window. */
+    for (i = sprite->spriteTraceGood - 1; i >= 0; i--)
+    {
+        Bool delivered;
+
+        win = sprite->spriteTrace[i];
+        delivered = TouchAddRegularListener(dev, ti, win, ev);
+        if (delivered)
+            return;
+    }
+}
+
+/**
+ * Remove the touch pointer grab from the device. Called from AllowSome()
+ */
+void
+TouchRemovePointerGrab(DeviceIntPtr dev)
+{
+    TouchPointInfoPtr ti;
+    GrabPtr grab;
+    DeviceEvent *ev;
+
+    if (!dev->touch)
+        return;
+
+    grab = dev->deviceGrab.grab;
+    if (!grab)
+        return;
+
+    ev = dev->deviceGrab.sync.event;
+    if (!IsTouchEvent((InternalEvent*)ev))
+        return;
+
+    ti = TouchFindByClientID(dev, ev->touchid);
+    if (!ti)
+        return;
+}
+
+/* As touch grabs don't turn into active grabs with their own resources, we
+ * need to walk all the touches and remove this grab from any delivery
+ * lists. */
+void
+TouchListenerGone(XID resource)
+{
+    TouchPointInfoPtr ti;
+    DeviceIntPtr dev;
+    InternalEvent *events = InitEventList(GetMaximumEventsNum());
+    int i, j, k, nev;
+
+    if (!events)
+        FatalError("TouchListenerGone: couldn't allocate events\n");
+
+    for (dev = inputInfo.devices; dev; dev = dev->next)
+    {
+        if (!dev->touch)
+            continue;
+
+        for (i = 0; i < dev->touch->num_touches; i++)
+        {
+            ti = &dev->touch->touches[i];
+            if (!ti->active)
+                continue;
+
+            for (j = 0; j < ti->num_listeners; j++)
+            {
+                if (ti->listeners[j].listener != resource)
+                    continue;
+
+                nev = GetTouchOwnershipEvents(events, dev, ti, XIRejectTouch,
+                                              resource, 0);
+                for (k = 0; k < nev; k++)
+                    mieqProcessDeviceEvent(dev, events + k, NULL);
+
+                break;
+            }
+        }
+    }
+
+    FreeEventList(events, GetMaximumEventsNum());
+}
diff --git a/xorg-server/dix/window.c b/xorg-server/dix/window.c
index 1953f025b..823294b9a 100644
--- a/xorg-server/dix/window.c
+++ b/xorg-server/dix/window.c
@@ -131,6 +131,7 @@ Equipment Corporation.
 
 #include "privates.h"
 #include "xace.h"
+#include "exevents.h"
 
 #include <X11/Xatom.h> /* must come after server includes */
 
@@ -2971,8 +2972,10 @@ UnmapWindow(WindowPtr pWin, Bool fromConfigure)
 	if (!fromConfigure && pScreen->PostValidateTree)
 	    (*pScreen->PostValidateTree)(pLayerWin->parent, pWin, VTUnmap);
     }
-    if (wasRealized && !fromConfigure)
+    if (wasRealized && !fromConfigure) {
 	WindowsRestructured ();
+	WindowGone(pWin);
+    }
     return Success;
 }
 
@@ -3055,8 +3058,10 @@ UnmapSubwindows(WindowPtr pWin)
 	if (anyMarked && pScreen->PostValidateTree)
 	    (*pScreen->PostValidateTree)(pLayerWin->parent, pHead, VTUnmap);
     }
-    if (wasRealized)
+    if (wasRealized) {
 	WindowsRestructured ();
+	WindowGone(pWin);
+    }
 }
 
 
diff --git a/xorg-server/glx/Makefile.am b/xorg-server/glx/Makefile.am
index 34be4ae49..f61a4081a 100644
--- a/xorg-server/glx/Makefile.am
+++ b/xorg-server/glx/Makefile.am
@@ -63,6 +63,8 @@ libglxdri_la_LIBADD = $(DLOPEN_LIBS)
 libglx_la_SOURCES = \
 	$(indirect_sources) \
 	$(glapi_sources) \
+	clientinfo.c \
+	createcontext.c \
 	extension_string.c \
 	extension_string.h \
 	indirect_util.c \
diff --git a/xorg-server/glx/clientinfo.c b/xorg-server/glx/clientinfo.c
new file mode 100644
index 000000000..3c0e7de45
--- /dev/null
+++ b/xorg-server/glx/clientinfo.c
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2011 Intel Corporation
+ *
+ * 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 (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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
+ */
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "glxserver.h"
+#include "indirect_dispatch.h"
+
+int __glXDisp_SetClientInfoARB(__GLXclientState *cl, GLbyte *pc)
+{
+    return BadRequest;
+}
+
+int __glXDispSwap_SetClientInfoARB(__GLXclientState *cl, GLbyte *pc)
+{
+    return BadRequest;
+}
+
+int __glXDisp_SetClientInfo2ARB(__GLXclientState *cl, GLbyte *pc)
+{
+    return BadRequest;
+}
+
+int __glXDispSwap_SetClientInfo2ARB(__GLXclientState *cl, GLbyte *pc)
+{
+    return BadRequest;
+}
diff --git a/xorg-server/glx/createcontext.c b/xorg-server/glx/createcontext.c
new file mode 100644
index 000000000..785061d5b
--- /dev/null
+++ b/xorg-server/glx/createcontext.c
@@ -0,0 +1,38 @@
+/*
+ * Copyright © 2011 Intel Corporation
+ *
+ * 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 (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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
+ */
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include "glxserver.h"
+#include "indirect_dispatch.h"
+
+int __glXDisp_CreateContextAttribsARB(__GLXclientState *cl, GLbyte *pc)
+{
+    return BadRequest;
+}
+
+int __glXDispSwap_CreateContextAttribsARB(__GLXclientState *cl, GLbyte *pc)
+{
+    return BadRequest;
+}
diff --git a/xorg-server/glx/dispatch.h b/xorg-server/glx/dispatch.h
index 1589f9877..56d7321b1 100644
--- a/xorg-server/glx/dispatch.h
+++ b/xorg-server/glx/dispatch.h
@@ -29,7 +29,6 @@
 #  define _DISPATCH_H_
 
 
-#include "glapitable.h"
 /**
  * \file main/dispatch.h
  * Macros for handling GL dispatch tables.
diff --git a/xorg-server/glx/glapi.c b/xorg-server/glx/glapi.c
index 481d59f81..a7913a3a1 100644
--- a/xorg-server/glx/glapi.c
+++ b/xorg-server/glx/glapi.c
@@ -49,9 +49,10 @@
 #include <unistd.h>
 
 #include "glapi.h"
+#include "dispatch.h"
 #include "glapitable.h"
 
-#define _gloffset_FIRST_DYNAMIC (sizeof(struct _glapi_table) / sizeof(void *))
+#define FIRST_DYNAMIC_OFFSET (sizeof(struct _glapi_table) / sizeof(void *))
 
 #if defined(PTHREADS) || defined(GLX_USE_TLS)
 static void init_glapi_relocs(void);
@@ -206,7 +207,7 @@ _glapi_get_dispatch(void)
  ***/
 
 #if defined(USE_X64_64_ASM) && defined(GLX_USE_TLS)
-#  define DISPATCH_FUNCTION_SIZE  16
+# define DISPATCH_FUNCTION_SIZE  16
 #elif defined(USE_X86_ASM)
 # if defined(THREADS) && !defined(GLX_USE_TLS)
 #  define DISPATCH_FUNCTION_SIZE  32
@@ -386,7 +387,7 @@ PUBLIC int
 _glapi_add_dispatch( const char * const * function_names,
 		     const char * parameter_signature )
 {
-   static int next_dynamic_offset = _gloffset_FIRST_DYNAMIC;
+   static int next_dynamic_offset = FIRST_DYNAMIC_OFFSET;
    const char * const real_sig = (parameter_signature != NULL)
      ? parameter_signature : "";
    struct _glapi_function * entry[8];
diff --git a/xorg-server/glx/glxdri2.c b/xorg-server/glx/glxdri2.c
index 8187a3edd..5e524db99 100644
--- a/xorg-server/glx/glxdri2.c
+++ b/xorg-server/glx/glxdri2.c
@@ -423,7 +423,7 @@ __glXDRIscreenCreateContext(__GLXscreen *baseScreen,
 }
 
 static void
-__glXDRIinvalidateBuffers(DrawablePtr pDraw, void *priv)
+__glXDRIinvalidateBuffers(DrawablePtr pDraw, void *priv, XID id)
 {
 #if __DRI2_FLUSH_VERSION >= 3
     __GLXDRIdrawable *private = priv;
diff --git a/xorg-server/glx/glxext.h b/xorg-server/glx/glxext.h
index e76207910..3c1be9c54 100644
--- a/xorg-server/glx/glxext.h
+++ b/xorg-server/glx/glxext.h
@@ -50,8 +50,6 @@ extern void __glXClearErrorOccured(void);
 extern GLboolean __glXErrorOccured(void);
 extern void __glXResetLargeCommandStatus(__GLXclientState*);
 
-extern void GlxExtensionInit(void);
-
 extern const char GLServerVersion[];
 extern int DoGetString(__GLXclientState *cl, GLbyte *pc, GLboolean need_swap);
 
diff --git a/xorg-server/glx/indirect_dispatch.c b/xorg-server/glx/indirect_dispatch.c
index 5c325d25e..adbafdfee 100644
--- a/xorg-server/glx/indirect_dispatch.c
+++ b/xorg-server/glx/indirect_dispatch.c
@@ -106,6 +106,8 @@ void __glXDisp_CallLists(GLbyte * pc)
     const GLenum type = *(GLenum   *)(pc +  4);
     const GLvoid * lists =  (const GLvoid *)(pc +  8);
 
+    lists = (const GLvoid *) (pc + 8);
+
     CALL_CallLists( GET_DISPATCH(), (
         n,
         type,
@@ -166,7 +168,7 @@ void __glXDisp_Begin(GLbyte * pc)
 
 void __glXDisp_Bitmap(GLbyte * pc)
 {
-    const GLubyte * const bitmap = (const GLubyte *) (pc + 44);
+    const GLubyte * const bitmap = (const GLubyte *) ((pc + 44));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
@@ -1043,7 +1045,7 @@ void __glXDisp_PolygonMode(GLbyte * pc)
 
 void __glXDisp_PolygonStipple(GLbyte * pc)
 {
-    const GLubyte * const mask = (const GLubyte *) (pc + 20);
+    const GLubyte * const mask = (const GLubyte *) ((pc + 20));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
@@ -1122,7 +1124,7 @@ void __glXDisp_TexParameteriv(GLbyte * pc)
 
 void __glXDisp_TexImage1D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 52);
+    const GLvoid * const pixels = (const GLvoid *) ((pc + 52));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
@@ -1146,7 +1148,7 @@ void __glXDisp_TexImage1D(GLbyte * pc)
 
 void __glXDisp_TexImage2D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 52);
+    const GLvoid * const pixels = (const GLvoid *) ((pc + 52));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
@@ -1752,7 +1754,7 @@ void __glXDisp_CopyPixels(GLbyte * pc)
 
 void __glXDisp_DrawPixels(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 36);
+    const GLvoid * const pixels = (const GLvoid *) ((pc + 36));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
@@ -2978,7 +2980,7 @@ void __glXDisp_PrioritizeTextures(GLbyte * pc)
 
 void __glXDisp_TexSubImage1D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 56);
+    const GLvoid * const pixels = (const GLvoid *) ((pc + 56));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
@@ -3001,7 +3003,7 @@ void __glXDisp_TexSubImage1D(GLbyte * pc)
 
 void __glXDisp_TexSubImage2D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 56);
+    const GLvoid * const pixels = (const GLvoid *) ((pc + 56));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
@@ -3043,7 +3045,7 @@ void __glXDisp_BlendEquation(GLbyte * pc)
 
 void __glXDisp_ColorTable(GLbyte * pc)
 {
-    const GLvoid * const table = (const GLvoid *) (pc + 40);
+    const GLvoid * const table = (const GLvoid *) ((pc + 40));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
@@ -3220,7 +3222,7 @@ int __glXDisp_GetColorTableParameterivSGI(__GLXclientState *cl, GLbyte *pc)
 
 void __glXDisp_ColorSubTable(GLbyte * pc)
 {
-    const GLvoid * const data = (const GLvoid *) (pc + 40);
+    const GLvoid * const data = (const GLvoid *) ((pc + 40));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
@@ -3253,7 +3255,7 @@ void __glXDisp_CopyColorSubTable(GLbyte * pc)
 
 void __glXDisp_ConvolutionFilter1D(GLbyte * pc)
 {
-    const GLvoid * const image = (const GLvoid *) (pc + 44);
+    const GLvoid * const image = (const GLvoid *) ((pc + 44));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
@@ -3275,7 +3277,7 @@ void __glXDisp_ConvolutionFilter1D(GLbyte * pc)
 
 void __glXDisp_ConvolutionFilter2D(GLbyte * pc)
 {
-    const GLvoid * const image = (const GLvoid *) (pc + 44);
+    const GLvoid * const image = (const GLvoid *) ((pc + 44));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
@@ -3777,7 +3779,7 @@ void __glXDisp_TexImage3D(GLbyte * pc)
 
 void __glXDisp_TexSubImage3D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 88);
+    const GLvoid * const pixels = (const GLvoid *) ((pc + 88));
     __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
diff --git a/xorg-server/glx/indirect_dispatch.h b/xorg-server/glx/indirect_dispatch.h
index 9220638be..4418131ce 100644
--- a/xorg-server/glx/indirect_dispatch.h
+++ b/xorg-server/glx/indirect_dispatch.h
@@ -1,1050 +1,1050 @@
-/* DO NOT EDIT - This file generated automatically by glX_proto_recv.py (from Mesa) script */

-

-/*

- * (C) Copyright IBM Corporation 2005

- * All Rights Reserved.

- * 

- * Permission is hereby granted, free of charge, to any person obtaining a

- * copy of this software and associated documentation files (the "Software"),

- * to deal in the Software without restriction, including without limitation

- * the rights to use, copy, modify, merge, publish, distribute, sub license,

- * and/or sell copies of the Software, and to permit persons to whom the

- * Software is furnished to do so, subject to the following conditions:

- * 

- * The above copyright notice and this permission notice (including the next

- * paragraph) shall be included in all copies or substantial portions of the

- * Software.

- * 

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL

- * IBM,

- * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

- * SOFTWARE.

- */

-

-#if !defined( _INDIRECT_DISPATCH_H_ )

-#  define _INDIRECT_DISPATCH_H_

-

-#  include <X11/Xfuncproto.h>

-

-struct __GLXclientStateRec;

-

-extern _X_HIDDEN void __glXDisp_MapGrid1d(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MapGrid1d(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_MapGrid1f(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MapGrid1f(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_NewList(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_NewList(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_LoadIdentity(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_LoadIdentity(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_SampleCoverageARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_SampleCoverageARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ConvolutionFilter1D(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ConvolutionFilter1D(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_BeginQueryARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_BeginQueryARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_RasterPos3dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_RasterPos3dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_PointParameteriNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PointParameteriNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexCoord1iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexCoord1iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexCoord4sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexCoord4sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ActiveTextureARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ActiveTextureARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_BlitFramebufferEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_BlitFramebufferEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib4ubvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib4ubvNV(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetProgramNamedParameterdvNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetProgramNamedParameterdvNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Histogram(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Histogram(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetMapfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetMapfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_RasterPos4dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_RasterPos4dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_PolygonStipple(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PolygonStipple(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_BlendEquationSeparateEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_BlendEquationSeparateEXT(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetPixelMapfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetPixelMapfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Color3uiv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Color3uiv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_IsEnabled(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_IsEnabled(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_VertexAttrib4svNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib4svNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_EvalCoord2fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_EvalCoord2fv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_DestroyPixmap(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_DestroyPixmap(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetMapiv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetMapiv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_SwapBuffers(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_SwapBuffers(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Indexubv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Indexubv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_Render(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_Render(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetQueryivARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetQueryivARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_TexImage3D(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexImage3D(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_MakeContextCurrent(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_MakeContextCurrent(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetFBConfigs(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetFBConfigs(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Color3ubv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Color3ubv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetQueryObjectivARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetQueryObjectivARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Vertex3dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Vertex3dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_CompressedTexSubImage2DARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_CompressedTexSubImage2DARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttribs3fvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttribs3fvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_LightModeliv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_LightModeliv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib1svARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib1svARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttribs1dvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttribs1dvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Normal3bv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Normal3bv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_VendorPrivate(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_VendorPrivate(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_CreateGLXPixmapWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_VertexAttrib1fvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib1fvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Vertex3iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Vertex3iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_CopyConvolutionFilter1D(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_CopyConvolutionFilter1D(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_BlendColor(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_BlendColor(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Scalef(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Scalef(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Normal3iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Normal3iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_PassThrough(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PassThrough(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_FramebufferTextureLayerEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_FramebufferTextureLayerEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Viewport(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Viewport(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib4NusvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib4NusvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_CopyTexSubImage2D(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_CopyTexSubImage2D(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_DepthRange(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_DepthRange(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ResetHistogram(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ResetHistogram(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetProgramNamedParameterfvNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetProgramNamedParameterfvNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_PointParameterfEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PointParameterfEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexCoord2sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexCoord2sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Vertex4dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Vertex4dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_CompressedTexImage3DARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_CompressedTexImage3DARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Color3sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Color3sv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetConvolutionParameteriv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetConvolutionParameteriv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetConvolutionParameterivEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetConvolutionParameterivEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Vertex2dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Vertex2dv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetVisualConfigs(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetVisualConfigs(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_MultiTexCoord1fvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MultiTexCoord1fvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexCoord3iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexCoord3iv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_CopyContext(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_CopyContext(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Color3fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Color3fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_PointSize(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PointSize(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_PopName(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PopName(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib4NbvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib4NbvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Vertex4sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Vertex4sv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetTexEnvfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetTexEnvfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_LineStipple(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_LineStipple(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexEnvi(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexEnvi(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetClipPlane(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetClipPlane(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_VertexAttribs3dvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttribs3dvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_LightModeli(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_LightModeli(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttribs4fvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttribs4fvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Scaled(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Scaled(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_CallLists(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_CallLists(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_AlphaFunc(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_AlphaFunc(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexCoord2iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexCoord2iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_CompressedTexImage1DARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_CompressedTexImage1DARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Rotated(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Rotated(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_ReadPixels(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_ReadPixels(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_EdgeFlagv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_EdgeFlagv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexParameterf(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexParameterf(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexParameteri(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexParameteri(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_DestroyContext(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_DestroyContext(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_DrawPixels(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_DrawPixels(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_MultiTexCoord2svARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MultiTexCoord2svARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_GenerateMipmapEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_GenerateMipmapEXT(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GenLists(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GenLists(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_MapGrid2d(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MapGrid2d(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_MapGrid2f(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MapGrid2f(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Scissor(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Scissor(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Fogf(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Fogf(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexSubImage1D(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexSubImage1D(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Color4usv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Color4usv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Fogi(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Fogi(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_RasterPos3iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_RasterPos3iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_PixelMapfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PixelMapfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Color3usv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Color3usv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_AreTexturesResident(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_AreTexturesResident(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_AreTexturesResidentEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_AreTexturesResidentEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_PointParameterfvEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PointParameterfvEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Color3bv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Color3bv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_SecondaryColor3bvEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_SecondaryColor3bvEXT(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetProgramLocalParameterfvARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetProgramLocalParameterfvARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_RenderbufferStorageEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_RenderbufferStorageEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ColorTable(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ColorTable(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Accum(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Accum(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetTexImage(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetTexImage(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_ConvolutionFilter2D(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ConvolutionFilter2D(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_Finish(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_Finish(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_ClearStencil(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ClearStencil(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib3dvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib3dvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttribs4ubvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttribs4ubvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ConvolutionParameteriv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ConvolutionParameteriv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_RasterPos2fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_RasterPos2fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexCoord1fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexCoord1fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ProgramEnvParameter4fvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ProgramEnvParameter4fvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_RasterPos4fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_RasterPos4fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ClearIndex(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ClearIndex(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_LoadMatrixd(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_LoadMatrixd(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_PushMatrix(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PushMatrix(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ConvolutionParameterfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ConvolutionParameterfv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetTexGendv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetTexGendv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetVertexAttribfvNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetVertexAttribfvNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_LoadProgramNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_LoadProgramNV(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_EndList(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_EndList(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_VertexAttrib4fvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib4fvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_EvalCoord1fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_EvalCoord1fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_EvalMesh2(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_EvalMesh2(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Vertex4fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Vertex4fv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_CheckFramebufferStatusEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_CheckFramebufferStatusEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetVertexAttribivARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetVertexAttribivARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetFBConfigsSGIX(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetFBConfigsSGIX(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_CreateNewContext(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_CreateNewContext(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetMinmax(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetMinmax(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetMinmaxEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetMinmaxEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Normal3fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Normal3fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib4ivARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib4ivARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_End(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_End(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttribs2dvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttribs2dvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_MultiTexCoord3fvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MultiTexCoord3fvARB(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetProgramParameterfvNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetProgramParameterfvNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_BindTexture(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_BindTexture(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexSubImage2D(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexSubImage2D(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexGenfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexGenfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib4bvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib4bvARB(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_CreateContextWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_CreateContextWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_FramebufferTexture3DEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_FramebufferTexture3DEXT(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_CopySubBufferMESA(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_CopySubBufferMESA(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_BlendEquation(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_BlendEquation(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetError(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetError(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_TexCoord3dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexCoord3dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Indexdv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Indexdv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_FramebufferTexture2DEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_FramebufferTexture2DEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_PushName(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PushName(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_MultiTexCoord2dvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MultiTexCoord2dvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ProgramNamedParameter4fvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ProgramNamedParameter4fvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib4fvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib4fvARB(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_CreateGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_CreateGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_MultiTexCoord1svARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MultiTexCoord1svARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_EndQueryARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_EndQueryARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_DepthMask(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_DepthMask(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Color4iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Color4iv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_StencilOp(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_StencilOp(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_MultiTexCoord3svARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MultiTexCoord3svARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexEnvfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexEnvfv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_QueryServerString(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_QueryServerString(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_LoadMatrixf(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_LoadMatrixf(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Color4bv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Color4bv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_SecondaryColor3usvEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_SecondaryColor3usvEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib2fvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib2fvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ProgramLocalParameter4dvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ProgramLocalParameter4dvARB(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_DeleteLists(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_DeleteLists(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_LogicOp(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_LogicOp(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_RenderbufferStorageMultisample(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_RenderbufferStorageMultisample(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexCoord4fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexCoord4fv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_WaitX(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_WaitX(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_SecondaryColor3uivEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_SecondaryColor3uivEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_FramebufferRenderbufferEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_FramebufferRenderbufferEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib1dvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib1dvNV(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GenTextures(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GenTextures(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GenTexturesEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GenTexturesEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_FramebufferTexture1DEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_FramebufferTexture1DEXT(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_RasterPos2sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_RasterPos2sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Color4ubv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Color4ubv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_DrawBuffer(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_DrawBuffer(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexCoord2fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexCoord2fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexCoord1sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexCoord1sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexGeniv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexGeniv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_DepthFunc(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_DepthFunc(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_PixelMapusv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PixelMapusv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_PointParameterivNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PointParameterivNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_BlendFunc(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_BlendFunc(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_WaitGL(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_WaitGL(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_MultiTexCoord3dvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MultiTexCoord3dvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ProgramNamedParameter4dvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ProgramNamedParameter4dvNV(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_Flush(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_Flush(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Color4uiv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Color4uiv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_RasterPos3sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_RasterPos3sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_BindFramebufferEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_BindFramebufferEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_PushAttrib(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PushAttrib(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_DestroyPbuffer(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_DestroyPbuffer(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_TexParameteriv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexParameteriv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_WindowPos3fvMESA(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_WindowPos3fvMESA(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib1svNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib1svNV(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_QueryExtensionsString(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_QueryExtensionsString(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_RasterPos3fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_RasterPos3fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_CopyTexSubImage3D(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_CopyTexSubImage3D(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetColorTable(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetColorTable(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetColorTableSGI(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetColorTableSGI(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Indexiv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Indexiv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_CreateContext(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_CreateContext(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_CopyColorTable(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_CopyColorTable(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetHistogramParameterfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetHistogramParameterfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetHistogramParameterfvEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetHistogramParameterfvEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Frustum(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Frustum(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetString(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetString(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_CreateGLXPixmap(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_CreateGLXPixmap(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_TexEnvf(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexEnvf(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_MultiTexCoord3ivARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MultiTexCoord3ivARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib1dvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib1dvARB(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_DeleteTextures(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_DeleteTextures(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_DeleteTexturesEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_DeleteTexturesEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetTexLevelParameteriv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetTexLevelParameteriv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_ClearAccum(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ClearAccum(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_QueryVersion(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_QueryVersion(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetVertexAttribfvARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetVertexAttribfvARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_SecondaryColor3ivEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_SecondaryColor3ivEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexCoord4iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexCoord4iv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_ColorTableParameteriv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ColorTableParameteriv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib4ubvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib4ubvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_CopyTexImage2D(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_CopyTexImage2D(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Lightfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Lightfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ClearDepth(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ClearDepth(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ColorSubTable(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ColorSubTable(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Color4fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Color4fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_MultiTexCoord4ivARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MultiTexCoord4ivARB(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_CreatePixmap(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_CreatePixmap(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Lightiv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Lightiv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetQueryObjectuivARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetQueryObjectuivARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetTexParameteriv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetTexParameteriv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GenRenderbuffersEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GenRenderbuffersEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_VertexAttrib2dvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib2dvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttribs2svNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttribs2svNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Rectdv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Rectdv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib4NivARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib4NivARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Materialiv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Materialiv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_SampleMaskSGIS(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_SampleMaskSGIS(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_SecondaryColor3fvEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_SecondaryColor3fvEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_PolygonMode(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PolygonMode(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_CompressedTexSubImage1DARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_CompressedTexSubImage1DARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib2dvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib2dvNV(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetVertexAttribivNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetVertexAttribivNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_IsQueryARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_IsQueryARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_TexGeni(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexGeni(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexGenf(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexGenf(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexGend(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexGend(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetPolygonStipple(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetPolygonStipple(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_VertexAttrib2svNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib2svNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib4NuivARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib4NuivARB(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_DestroyWindow(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_DestroyWindow(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Color4sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Color4sv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_IsProgramNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_IsProgramNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_PixelZoom(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PixelZoom(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ColorTableParameterfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ColorTableParameterfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_PixelMapuiv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PixelMapuiv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Color3dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Color3dv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_IsTexture(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_IsTexture(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_IsTextureEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_IsTextureEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_DeleteQueriesARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_DeleteQueriesARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetMapdv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetMapdv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_DestroyGLXPixmap(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_DestroyGLXPixmap(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_SamplePatternSGIS(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_SamplePatternSGIS(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_PixelStoref(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_PixelStoref(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_PrioritizeTextures(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PrioritizeTextures(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_PixelStorei(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_PixelStorei(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_VertexAttrib4usvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib4usvARB(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_DestroyGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_DestroyGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_EvalCoord2dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_EvalCoord2dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib3svARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib3svARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ColorMaterial(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ColorMaterial(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_CompressedTexSubImage3DARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_CompressedTexSubImage3DARB(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_IsFramebufferEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_IsFramebufferEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetVertexAttribdvARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetVertexAttribdvARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetSeparableFilter(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetSeparableFilter(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetSeparableFilterEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetSeparableFilterEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_RequestResidentProgramsNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_RequestResidentProgramsNV(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_FeedbackBuffer(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_FeedbackBuffer(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_RasterPos2iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_RasterPos2iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexImage1D(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexImage1D(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_FrontFace(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_FrontFace(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_RenderLarge(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_RenderLarge(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_VertexAttrib4dvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib4dvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_PolygonOffset(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PolygonOffset(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ExecuteProgramNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ExecuteProgramNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Normal3dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Normal3dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Lightf(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Lightf(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_MatrixMode(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MatrixMode(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetPixelMapusv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetPixelMapusv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Lighti(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Lighti(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetFramebufferAttachmentParameterivEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetFramebufferAttachmentParameterivEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_ChangeDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_ChangeDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_MultiTexCoord4dvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MultiTexCoord4dvARB(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_CreatePbuffer(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_CreatePbuffer(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetDoublev(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetDoublev(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_MultMatrixd(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MultMatrixd(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_MultMatrixf(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MultMatrixf(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_MultiTexCoord4fvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MultiTexCoord4fvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_RasterPos4sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_RasterPos4sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib4NsvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib4NsvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib3fvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib3fvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ClearColor(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ClearColor(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_IsDirect(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_IsDirect(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_DeleteFramebuffersEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_DeleteFramebuffersEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexEnviv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexEnviv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexSubImage3D(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexSubImage3D(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_SwapIntervalSGI(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_SwapIntervalSGI(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetColorTableParameterfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetColorTableParameterfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetColorTableParameterfvSGI(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetColorTableParameterfvSGI(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Bitmap(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Bitmap(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetTexLevelParameterfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetTexLevelParameterfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GenFramebuffersEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GenFramebuffersEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetProgramParameterdvNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetProgramParameterdvNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Vertex2sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Vertex2sv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetIntegerv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetIntegerv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetProgramEnvParameterfvARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetProgramEnvParameterfvARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetTrackMatrixivNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetTrackMatrixivNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_VertexAttrib3svNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib3svNV(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetTexEnviv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetTexEnviv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_VendorPrivateWithReply(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_VendorPrivateWithReply(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_SeparableFilter2D(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_SeparableFilter2D(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Map1d(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Map1d(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Map1f(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Map1f(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_CompressedTexImage2DARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_CompressedTexImage2DARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexImage2D(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexImage2D(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ProgramParameters4fvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ProgramParameters4fvNV(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetProgramivNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetProgramivNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_ChangeDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_ChangeDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetMinmaxParameteriv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetMinmaxParameteriv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetMinmaxParameterivEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetMinmaxParameterivEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_PixelTransferf(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PixelTransferf(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_CopyTexImage1D(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_CopyTexImage1D(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_RasterPos2dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_RasterPos2dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Fogiv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Fogiv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexCoord1dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexCoord1dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_PixelTransferi(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PixelTransferi(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_SecondaryColor3ubvEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_SecondaryColor3ubvEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib3fvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib3fvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Clear(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Clear(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ReadBuffer(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ReadBuffer(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ConvolutionParameteri(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ConvolutionParameteri(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Ortho(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Ortho(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ListBase(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ListBase(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ConvolutionParameterf(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ConvolutionParameterf(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetColorTableParameteriv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetColorTableParameteriv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetColorTableParameterivSGI(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetColorTableParameterivSGI(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_ReleaseTexImageEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_ReleaseTexImageEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_CallList(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_CallList(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttribs2fvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttribs2fvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Rectiv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Rectiv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_SecondaryColor3dvEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_SecondaryColor3dvEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Vertex2fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Vertex2fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_BindRenderbufferEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_BindRenderbufferEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Vertex3sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Vertex3sv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_BindTexImageEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_BindTexImageEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_ProgramLocalParameter4fvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ProgramLocalParameter4fvARB(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_DeleteProgramsNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_DeleteProgramsNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_EvalMesh1(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_EvalMesh1(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttribs1fvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttribs1fvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_MultiTexCoord1dvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MultiTexCoord1dvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Vertex2iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Vertex2iv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetProgramStringNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetProgramStringNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_LineWidth(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_LineWidth(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib2fvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib2fvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexGendv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexGendv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ResetMinmax(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ResetMinmax(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetConvolutionParameterfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetConvolutionParameterfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetConvolutionParameterfvEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetConvolutionParameterfvEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_VertexAttribs4dvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttribs4dvNV(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetMaterialfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetMaterialfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_UseXFont(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_UseXFont(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_ShadeModel(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ShadeModel(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Materialfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Materialfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexCoord3fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexCoord3fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_FogCoordfvEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_FogCoordfvEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_MultiTexCoord1ivARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MultiTexCoord1ivARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_MultiTexCoord2ivARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MultiTexCoord2ivARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_DrawArrays(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_DrawArrays(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Color3iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Color3iv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetProgramLocalParameterdvARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetProgramLocalParameterdvARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetHistogramParameteriv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetHistogramParameteriv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetHistogramParameterivEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetHistogramParameterivEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Rotatef(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Rotatef(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetProgramivARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetProgramivARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_BlendFuncSeparateEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_BlendFuncSeparateEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ProgramParameters4dvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ProgramParameters4dvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_EvalPoint2(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_EvalPoint2(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_EvalPoint1(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_EvalPoint1(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_PopMatrix(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PopMatrix(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_MakeCurrentReadSGI(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_MakeCurrentReadSGI(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetTexGeniv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetTexGeniv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_MakeCurrent(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_MakeCurrent(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Map2d(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Map2d(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Map2f(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Map2f(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ProgramStringARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ProgramStringARB(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetConvolutionFilter(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetConvolutionFilter(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetConvolutionFilterEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetConvolutionFilterEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetCompressedTexImageARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetCompressedTexImageARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetTexGenfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetTexGenfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetHistogram(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetHistogram(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetHistogramEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetHistogramEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_ActiveStencilFaceEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ActiveStencilFaceEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Materialf(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Materialf(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Materiali(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Materiali(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Indexsv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Indexsv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_MultiTexCoord4svARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MultiTexCoord4svARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_LightModelfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_LightModelfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexCoord2dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexCoord2dv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GenQueriesARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GenQueriesARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_EvalCoord1dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_EvalCoord1dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Translated(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Translated(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Translatef(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Translatef(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_StencilMask(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_StencilMask(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ClampColorARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ClampColorARB(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_CreateWindow(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_CreateWindow(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetLightiv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetLightiv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_IsList(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_IsList(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_RenderMode(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_RenderMode(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_DrawBuffersARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_DrawBuffersARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_LoadName(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_LoadName(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_CopyTexSubImage1D(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_CopyTexSubImage1D(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_CullFace(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_CullFace(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_QueryContextInfoEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_QueryContextInfoEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_VertexAttribs3svNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttribs3svNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_StencilFunc(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_StencilFunc(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_CopyPixels(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_CopyPixels(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Rectsv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Rectsv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_CopyConvolutionFilter2D(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_CopyConvolutionFilter2D(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TexParameterfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexParameterfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib4uivARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib4uivARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_ClipPlane(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ClipPlane(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_TrackMatrixNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TrackMatrixNV(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetPixelMapuiv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetPixelMapuiv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Indexfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Indexfv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_QueryContext(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_QueryContext(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_SecondaryColor3svEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_SecondaryColor3svEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_IndexMask(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_IndexMask(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_BindProgramNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_BindProgramNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib4svARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib4svARB(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetFloatv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetFloatv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_TexCoord3sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexCoord3sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_PopAttrib(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_PopAttrib(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Fogfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Fogfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_InitNames(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_InitNames(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Normal3sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Normal3sv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Minmax(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Minmax(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_FogCoorddvEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_FogCoorddvEXT(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetBooleanv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetBooleanv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Hint(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Hint(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Color4dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Color4dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib2svARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib2svARB(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_AreProgramsResidentNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_AreProgramsResidentNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_CopyColorSubTable(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_CopyColorSubTable(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_DeleteRenderbuffersEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_DeleteRenderbuffersEXT(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib4NubvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib4NubvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttrib3dvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib3dvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Vertex4iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Vertex4iv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetProgramEnvParameterdvARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetProgramEnvParameterdvARB(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_TexCoord4dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_TexCoord4dv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Begin(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Begin(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_ClientInfo(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_ClientInfo(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Rectfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Rectfv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_LightModelf(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_LightModelf(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetTexParameterfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetTexParameterfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetLightfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetLightfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_Disable(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Disable(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_MultiTexCoord2fvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_MultiTexCoord2fvARB(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetRenderbufferParameterivEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetRenderbufferParameterivEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_ColorMask(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_ColorMask(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_RasterPos4iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_RasterPos4iv(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Enable(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Enable(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttribs4svNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttribs4svNV(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_GetMinmaxParameterfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetMinmaxParameterfv(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GetMinmaxParameterfvEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GetMinmaxParameterfvEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_VertexAttrib1fvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib1fvARB(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_VertexAttribs1svNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttribs1svNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDisp_Vertex3fv(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_Vertex3fv(GLbyte * pc);

-extern _X_HIDDEN int __glXDisp_IsRenderbufferEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_IsRenderbufferEXT(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDisp_GenProgramsNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN int __glXDispSwap_GenProgramsNV(struct __GLXclientStateRec *, GLbyte *);

-extern _X_HIDDEN void __glXDisp_VertexAttrib4dvNV(GLbyte * pc);

-extern _X_HIDDEN void __glXDispSwap_VertexAttrib4dvNV(GLbyte * pc);

-

-#endif /* !defined( _INDIRECT_DISPATCH_H_ ) */

+/* DO NOT EDIT - This file generated automatically by glX_proto_recv.py (from Mesa) script */
+
+/*
+ * (C) Copyright IBM Corporation 2005
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * IBM,
+ * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#if !defined( _INDIRECT_DISPATCH_H_ )
+#  define _INDIRECT_DISPATCH_H_
+
+#  include <X11/Xfuncproto.h>
+
+struct __GLXclientStateRec;
+
+extern _X_HIDDEN void __glXDisp_MapGrid1d(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MapGrid1d(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_MapGrid1f(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MapGrid1f(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_NewList(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_NewList(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_LoadIdentity(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_LoadIdentity(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_SampleCoverageARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_SampleCoverageARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ConvolutionFilter1D(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ConvolutionFilter1D(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_BeginQueryARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_BeginQueryARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_RasterPos3dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_RasterPos3dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_PointParameteriNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PointParameteriNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexCoord1iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexCoord1iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexCoord4sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexCoord4sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ActiveTextureARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ActiveTextureARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_BlitFramebufferEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_BlitFramebufferEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib4ubvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib4ubvNV(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetProgramNamedParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetProgramNamedParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Histogram(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Histogram(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetMapfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetMapfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_RasterPos4dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_RasterPos4dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_PolygonStipple(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PolygonStipple(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_BlendEquationSeparateEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_BlendEquationSeparateEXT(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetPixelMapfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetPixelMapfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Color3uiv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Color3uiv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_IsEnabled(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_IsEnabled(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_VertexAttrib4svNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib4svNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_EvalCoord2fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_EvalCoord2fv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_DestroyPixmap(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_DestroyPixmap(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetMapiv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetMapiv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_SwapBuffers(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_SwapBuffers(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Indexubv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Indexubv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_Render(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_Render(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetQueryivARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetQueryivARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_TexImage3D(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexImage3D(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_MakeContextCurrent(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_MakeContextCurrent(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetFBConfigs(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetFBConfigs(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Color3ubv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Color3ubv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetQueryObjectivARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetQueryObjectivARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Vertex3dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Vertex3dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_CompressedTexSubImage2DARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_CompressedTexSubImage2DARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttribs3fvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttribs3fvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_LightModeliv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_LightModeliv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib1svARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib1svARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttribs1dvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttribs1dvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Normal3bv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Normal3bv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_VendorPrivate(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_VendorPrivate(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_CreateGLXPixmapWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_VertexAttrib1fvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib1fvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Vertex3iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Vertex3iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_CopyConvolutionFilter1D(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_CopyConvolutionFilter1D(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_BlendColor(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_BlendColor(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Scalef(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Scalef(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Normal3iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Normal3iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_PassThrough(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PassThrough(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_FramebufferTextureLayerEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_FramebufferTextureLayerEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Viewport(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Viewport(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib4NusvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib4NusvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_CopyTexSubImage2D(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_CopyTexSubImage2D(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_DepthRange(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_DepthRange(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ResetHistogram(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ResetHistogram(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetProgramNamedParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetProgramNamedParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_PointParameterfEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PointParameterfEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexCoord2sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexCoord2sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Vertex4dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Vertex4dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_CompressedTexImage3DARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_CompressedTexImage3DARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Color3sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Color3sv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetConvolutionParameteriv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetConvolutionParameteriv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetConvolutionParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetConvolutionParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Vertex2dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Vertex2dv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetVisualConfigs(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetVisualConfigs(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_MultiTexCoord1fvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MultiTexCoord1fvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexCoord3iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexCoord3iv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_CopyContext(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_CopyContext(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Color3fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Color3fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_PointSize(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PointSize(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_PopName(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PopName(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib4NbvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib4NbvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Vertex4sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Vertex4sv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetTexEnvfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetTexEnvfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_LineStipple(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_LineStipple(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexEnvi(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexEnvi(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetClipPlane(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetClipPlane(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_VertexAttribs3dvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttribs3dvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_LightModeli(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_LightModeli(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttribs4fvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttribs4fvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Scaled(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Scaled(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_CallLists(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_CallLists(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_AlphaFunc(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_AlphaFunc(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexCoord2iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexCoord2iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_CompressedTexImage1DARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_CompressedTexImage1DARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Rotated(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Rotated(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_EdgeFlagv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_EdgeFlagv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexParameterf(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexParameterf(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexParameteri(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexParameteri(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_DestroyContext(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_DestroyContext(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_DrawPixels(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_DrawPixels(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_MultiTexCoord2svARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MultiTexCoord2svARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_GenerateMipmapEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_GenerateMipmapEXT(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GenLists(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GenLists(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_MapGrid2d(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MapGrid2d(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_MapGrid2f(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MapGrid2f(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Scissor(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Scissor(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Fogf(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Fogf(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexSubImage1D(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexSubImage1D(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Color4usv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Color4usv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Fogi(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Fogi(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_RasterPos3iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_RasterPos3iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_PixelMapfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PixelMapfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Color3usv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Color3usv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_AreTexturesResident(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_AreTexturesResident(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_AreTexturesResidentEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_AreTexturesResidentEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_PointParameterfvEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PointParameterfvEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Color3bv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Color3bv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_SecondaryColor3bvEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_SecondaryColor3bvEXT(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetProgramLocalParameterfvARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetProgramLocalParameterfvARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_RenderbufferStorageEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_RenderbufferStorageEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ColorTable(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ColorTable(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Accum(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Accum(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetTexImage(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetTexImage(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_ConvolutionFilter2D(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ConvolutionFilter2D(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_Finish(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_Finish(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_ClearStencil(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ClearStencil(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib3dvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib3dvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttribs4ubvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttribs4ubvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ConvolutionParameteriv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ConvolutionParameteriv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_RasterPos2fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_RasterPos2fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexCoord1fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexCoord1fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ProgramEnvParameter4fvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ProgramEnvParameter4fvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_RasterPos4fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_RasterPos4fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ClearIndex(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ClearIndex(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_LoadMatrixd(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_LoadMatrixd(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_PushMatrix(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PushMatrix(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ConvolutionParameterfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ConvolutionParameterfv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetTexGendv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetTexGendv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetVertexAttribfvNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetVertexAttribfvNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_LoadProgramNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_LoadProgramNV(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_EndList(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_EndList(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_VertexAttrib4fvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib4fvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_EvalCoord1fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_EvalCoord1fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_EvalMesh2(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_EvalMesh2(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Vertex4fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Vertex4fv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_CheckFramebufferStatusEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_CheckFramebufferStatusEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetVertexAttribivARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetVertexAttribivARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetFBConfigsSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetFBConfigsSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_CreateNewContext(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_CreateNewContext(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetMinmax(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetMinmax(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetMinmaxEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetMinmaxEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Normal3fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Normal3fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib4ivARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib4ivARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_End(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_End(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttribs2dvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttribs2dvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_MultiTexCoord3fvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MultiTexCoord3fvARB(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetProgramParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetProgramParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_BindTexture(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_BindTexture(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexSubImage2D(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexSubImage2D(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexGenfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexGenfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib4bvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib4bvARB(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_CreateContextWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_CreateContextWithConfigSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_FramebufferTexture3DEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_FramebufferTexture3DEXT(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_CopySubBufferMESA(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_CopySubBufferMESA(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_BlendEquation(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_BlendEquation(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetError(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetError(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_TexCoord3dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexCoord3dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Indexdv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Indexdv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_FramebufferTexture2DEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_FramebufferTexture2DEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_PushName(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PushName(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_MultiTexCoord2dvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MultiTexCoord2dvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ProgramNamedParameter4fvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ProgramNamedParameter4fvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib4fvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib4fvARB(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_CreateGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_CreateGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_MultiTexCoord1svARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MultiTexCoord1svARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_EndQueryARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_EndQueryARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_DepthMask(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_DepthMask(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Color4iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Color4iv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_StencilOp(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_StencilOp(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_MultiTexCoord3svARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MultiTexCoord3svARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexEnvfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexEnvfv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_QueryServerString(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_QueryServerString(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_LoadMatrixf(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_LoadMatrixf(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Color4bv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Color4bv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_SecondaryColor3usvEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_SecondaryColor3usvEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib2fvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib2fvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ProgramLocalParameter4dvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ProgramLocalParameter4dvARB(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_DeleteLists(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_DeleteLists(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_LogicOp(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_LogicOp(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_RenderbufferStorageMultisample(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_RenderbufferStorageMultisample(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexCoord4fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexCoord4fv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_WaitX(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_WaitX(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_SecondaryColor3uivEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_SecondaryColor3uivEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_FramebufferRenderbufferEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_FramebufferRenderbufferEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib1dvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib1dvNV(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GenTextures(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GenTextures(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GenTexturesEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GenTexturesEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_FramebufferTexture1DEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_FramebufferTexture1DEXT(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_RasterPos2sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_RasterPos2sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Color4ubv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Color4ubv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_DrawBuffer(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_DrawBuffer(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexCoord2fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexCoord2fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexCoord1sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexCoord1sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexGeniv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexGeniv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_DepthFunc(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_DepthFunc(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_PixelMapusv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PixelMapusv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_PointParameterivNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PointParameterivNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_BlendFunc(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_BlendFunc(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_WaitGL(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_WaitGL(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_MultiTexCoord3dvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MultiTexCoord3dvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ProgramNamedParameter4dvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ProgramNamedParameter4dvNV(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_Flush(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_Flush(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Color4uiv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Color4uiv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_RasterPos3sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_RasterPos3sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_BindFramebufferEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_BindFramebufferEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_PushAttrib(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PushAttrib(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_DestroyPbuffer(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_DestroyPbuffer(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_TexParameteriv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexParameteriv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_WindowPos3fvMESA(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_WindowPos3fvMESA(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib1svNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib1svNV(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_QueryExtensionsString(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_QueryExtensionsString(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_RasterPos3fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_RasterPos3fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_CopyTexSubImage3D(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_CopyTexSubImage3D(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetColorTable(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetColorTable(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetColorTableSGI(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetColorTableSGI(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Indexiv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Indexiv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_CreateContext(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_CreateContext(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_CopyColorTable(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_CopyColorTable(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetHistogramParameterfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetHistogramParameterfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetHistogramParameterfvEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetHistogramParameterfvEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Frustum(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Frustum(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetString(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetString(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_CreateGLXPixmap(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_CreateGLXPixmap(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_TexEnvf(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexEnvf(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_MultiTexCoord3ivARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MultiTexCoord3ivARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib1dvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib1dvARB(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_DeleteTextures(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_DeleteTextures(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_DeleteTexturesEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_DeleteTexturesEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetTexLevelParameteriv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetTexLevelParameteriv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_ClearAccum(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ClearAccum(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_QueryVersion(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_QueryVersion(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetVertexAttribfvARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetVertexAttribfvARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_SecondaryColor3ivEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_SecondaryColor3ivEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexCoord4iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexCoord4iv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_ColorTableParameteriv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ColorTableParameteriv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib4ubvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib4ubvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_CopyTexImage2D(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_CopyTexImage2D(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Lightfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Lightfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ClearDepth(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ClearDepth(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ColorSubTable(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ColorSubTable(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Color4fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Color4fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_MultiTexCoord4ivARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MultiTexCoord4ivARB(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_CreatePixmap(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_CreatePixmap(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Lightiv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Lightiv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetQueryObjectuivARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetQueryObjectuivARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetTexParameteriv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetTexParameteriv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GenRenderbuffersEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GenRenderbuffersEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_VertexAttrib2dvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib2dvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttribs2svNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttribs2svNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Rectdv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Rectdv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib4NivARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib4NivARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Materialiv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Materialiv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_SampleMaskSGIS(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_SampleMaskSGIS(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_SecondaryColor3fvEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_SecondaryColor3fvEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_PolygonMode(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PolygonMode(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_CompressedTexSubImage1DARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_CompressedTexSubImage1DARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib2dvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib2dvNV(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetVertexAttribivNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetVertexAttribivNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_IsQueryARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_IsQueryARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_TexGeni(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexGeni(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexGenf(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexGenf(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexGend(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexGend(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetPolygonStipple(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetPolygonStipple(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_VertexAttrib2svNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib2svNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib4NuivARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib4NuivARB(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_DestroyWindow(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_DestroyWindow(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Color4sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Color4sv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_IsProgramNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_IsProgramNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_PixelZoom(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PixelZoom(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ColorTableParameterfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ColorTableParameterfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_PixelMapuiv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PixelMapuiv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Color3dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Color3dv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_IsTexture(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_IsTexture(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_IsTextureEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_IsTextureEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_DeleteQueriesARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_DeleteQueriesARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetMapdv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetMapdv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_DestroyGLXPixmap(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_DestroyGLXPixmap(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_SamplePatternSGIS(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_SamplePatternSGIS(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_PixelStoref(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_PixelStoref(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_PrioritizeTextures(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PrioritizeTextures(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_VertexAttrib4usvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib4usvARB(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_DestroyGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_DestroyGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_EvalCoord2dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_EvalCoord2dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib3svARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib3svARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ColorMaterial(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ColorMaterial(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_CompressedTexSubImage3DARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_CompressedTexSubImage3DARB(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_IsFramebufferEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_IsFramebufferEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetVertexAttribdvARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetVertexAttribdvARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetSeparableFilter(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetSeparableFilter(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetSeparableFilterEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetSeparableFilterEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_RequestResidentProgramsNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_RequestResidentProgramsNV(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_FeedbackBuffer(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_FeedbackBuffer(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_RasterPos2iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_RasterPos2iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexImage1D(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexImage1D(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_FrontFace(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_FrontFace(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_RenderLarge(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_RenderLarge(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_VertexAttrib4dvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib4dvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_PolygonOffset(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PolygonOffset(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ExecuteProgramNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ExecuteProgramNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Normal3dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Normal3dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Lightf(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Lightf(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_MatrixMode(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MatrixMode(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetPixelMapusv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetPixelMapusv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Lighti(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Lighti(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetFramebufferAttachmentParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetFramebufferAttachmentParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_ChangeDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_ChangeDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_MultiTexCoord4dvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MultiTexCoord4dvARB(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_CreatePbuffer(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_CreatePbuffer(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetDoublev(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetDoublev(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_MultMatrixd(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MultMatrixd(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_MultMatrixf(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MultMatrixf(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_MultiTexCoord4fvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MultiTexCoord4fvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_RasterPos4sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_RasterPos4sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib4NsvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib4NsvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib3fvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib3fvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ClearColor(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ClearColor(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_IsDirect(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_IsDirect(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_DeleteFramebuffersEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_DeleteFramebuffersEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexEnviv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexEnviv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexSubImage3D(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexSubImage3D(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_SwapIntervalSGI(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_SwapIntervalSGI(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetColorTableParameterfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetColorTableParameterfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetColorTableParameterfvSGI(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetColorTableParameterfvSGI(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Bitmap(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Bitmap(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetTexLevelParameterfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetTexLevelParameterfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GenFramebuffersEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GenFramebuffersEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetProgramParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetProgramParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Vertex2sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Vertex2sv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetIntegerv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetIntegerv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetProgramEnvParameterfvARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetProgramEnvParameterfvARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetTrackMatrixivNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetTrackMatrixivNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_VertexAttrib3svNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib3svNV(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetTexEnviv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetTexEnviv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_VendorPrivateWithReply(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_VendorPrivateWithReply(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_SeparableFilter2D(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_SeparableFilter2D(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Map1d(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Map1d(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Map1f(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Map1f(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_CompressedTexImage2DARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_CompressedTexImage2DARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexImage2D(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexImage2D(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ProgramParameters4fvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ProgramParameters4fvNV(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetProgramivNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetProgramivNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_ChangeDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_ChangeDrawableAttributes(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetMinmaxParameteriv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetMinmaxParameteriv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetMinmaxParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetMinmaxParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_PixelTransferf(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PixelTransferf(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_CopyTexImage1D(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_CopyTexImage1D(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_RasterPos2dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_RasterPos2dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Fogiv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Fogiv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexCoord1dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexCoord1dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_PixelTransferi(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PixelTransferi(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_SecondaryColor3ubvEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_SecondaryColor3ubvEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib3fvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib3fvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Clear(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Clear(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ReadBuffer(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ReadBuffer(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ConvolutionParameteri(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ConvolutionParameteri(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Ortho(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Ortho(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ListBase(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ListBase(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ConvolutionParameterf(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ConvolutionParameterf(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetColorTableParameteriv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetColorTableParameteriv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetColorTableParameterivSGI(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetColorTableParameterivSGI(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_ReleaseTexImageEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_ReleaseTexImageEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_CallList(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_CallList(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttribs2fvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttribs2fvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Rectiv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Rectiv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_SecondaryColor3dvEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_SecondaryColor3dvEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Vertex2fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Vertex2fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_BindRenderbufferEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_BindRenderbufferEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Vertex3sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Vertex3sv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_BindTexImageEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_BindTexImageEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_ProgramLocalParameter4fvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ProgramLocalParameter4fvARB(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_DeleteProgramsNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_DeleteProgramsNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_EvalMesh1(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_EvalMesh1(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttribs1fvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttribs1fvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_MultiTexCoord1dvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MultiTexCoord1dvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Vertex2iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Vertex2iv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetProgramStringNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetProgramStringNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_LineWidth(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_LineWidth(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib2fvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib2fvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexGendv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexGendv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ResetMinmax(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ResetMinmax(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetConvolutionParameterfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetConvolutionParameterfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetConvolutionParameterfvEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetConvolutionParameterfvEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_VertexAttribs4dvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttribs4dvNV(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetMaterialfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetMaterialfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_UseXFont(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_UseXFont(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_ShadeModel(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ShadeModel(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Materialfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Materialfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexCoord3fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexCoord3fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_FogCoordfvEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_FogCoordfvEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_MultiTexCoord1ivARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MultiTexCoord1ivARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_MultiTexCoord2ivARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MultiTexCoord2ivARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_DrawArrays(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_DrawArrays(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Color3iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Color3iv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetProgramLocalParameterdvARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetProgramLocalParameterdvARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetHistogramParameteriv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetHistogramParameteriv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetHistogramParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetHistogramParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Rotatef(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Rotatef(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetProgramivARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetProgramivARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_BlendFuncSeparateEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_BlendFuncSeparateEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ProgramParameters4dvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ProgramParameters4dvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_EvalPoint2(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_EvalPoint2(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_EvalPoint1(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_EvalPoint1(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_PopMatrix(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PopMatrix(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_MakeCurrentReadSGI(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_MakeCurrentReadSGI(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetTexGeniv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetTexGeniv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_MakeCurrent(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_MakeCurrent(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Map2d(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Map2d(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Map2f(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Map2f(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ProgramStringARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ProgramStringARB(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetConvolutionFilter(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetConvolutionFilter(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetConvolutionFilterEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetConvolutionFilterEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetCompressedTexImageARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetCompressedTexImageARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetTexGenfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetTexGenfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetHistogram(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetHistogram(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetHistogramEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetHistogramEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_ActiveStencilFaceEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ActiveStencilFaceEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Materialf(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Materialf(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Materiali(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Materiali(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Indexsv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Indexsv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_MultiTexCoord4svARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MultiTexCoord4svARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_LightModelfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_LightModelfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexCoord2dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexCoord2dv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GenQueriesARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GenQueriesARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_EvalCoord1dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_EvalCoord1dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Translated(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Translated(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Translatef(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Translatef(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_StencilMask(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_StencilMask(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ClampColorARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ClampColorARB(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_CreateWindow(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_CreateWindow(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetLightiv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetLightiv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_IsList(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_IsList(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_RenderMode(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_RenderMode(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_DrawBuffersARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_DrawBuffersARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_LoadName(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_LoadName(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_CopyTexSubImage1D(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_CopyTexSubImage1D(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_CullFace(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_CullFace(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_QueryContextInfoEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_QueryContextInfoEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_VertexAttribs3svNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttribs3svNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_StencilFunc(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_StencilFunc(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_CopyPixels(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_CopyPixels(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Rectsv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Rectsv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_CopyConvolutionFilter2D(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_CopyConvolutionFilter2D(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TexParameterfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexParameterfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib4uivARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib4uivARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_ClipPlane(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ClipPlane(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_TrackMatrixNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TrackMatrixNV(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetPixelMapuiv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetPixelMapuiv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Indexfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Indexfv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_QueryContext(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_QueryContext(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_SecondaryColor3svEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_SecondaryColor3svEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_IndexMask(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_IndexMask(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_BindProgramNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_BindProgramNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib4svARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib4svARB(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetFloatv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetFloatv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_TexCoord3sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexCoord3sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_PopAttrib(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_PopAttrib(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Fogfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Fogfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_InitNames(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_InitNames(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Normal3sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Normal3sv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Minmax(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Minmax(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_FogCoorddvEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_FogCoorddvEXT(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetBooleanv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetBooleanv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Hint(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Hint(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Color4dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Color4dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib2svARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib2svARB(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_AreProgramsResidentNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_AreProgramsResidentNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_CopyColorSubTable(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_CopyColorSubTable(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_DeleteRenderbuffersEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_DeleteRenderbuffersEXT(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib4NubvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib4NubvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttrib3dvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib3dvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Vertex4iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Vertex4iv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetProgramEnvParameterdvARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetProgramEnvParameterdvARB(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_TexCoord4dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_TexCoord4dv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Begin(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Begin(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_ClientInfo(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_ClientInfo(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Rectfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Rectfv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_LightModelf(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_LightModelf(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetTexParameterfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetTexParameterfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetLightfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetLightfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_Disable(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Disable(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_MultiTexCoord2fvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_MultiTexCoord2fvARB(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetRenderbufferParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetRenderbufferParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_ColorMask(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_ColorMask(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_RasterPos4iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_RasterPos4iv(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Enable(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Enable(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttribs4svNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttribs4svNV(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_GetMinmaxParameterfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetMinmaxParameterfv(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GetMinmaxParameterfvEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GetMinmaxParameterfvEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_VertexAttrib1fvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib1fvARB(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_VertexAttribs1svNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttribs1svNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDisp_Vertex3fv(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_Vertex3fv(GLbyte * pc);
+extern _X_HIDDEN int __glXDisp_IsRenderbufferEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_IsRenderbufferEXT(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDisp_GenProgramsNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN int __glXDispSwap_GenProgramsNV(struct __GLXclientStateRec *, GLbyte *);
+extern _X_HIDDEN void __glXDisp_VertexAttrib4dvNV(GLbyte * pc);
+extern _X_HIDDEN void __glXDispSwap_VertexAttrib4dvNV(GLbyte * pc);
+
+#endif /* !defined( _INDIRECT_DISPATCH_H_ ) */
diff --git a/xorg-server/glx/indirect_dispatch_swap.c b/xorg-server/glx/indirect_dispatch_swap.c
index 096bd7f30..f5cffe431 100644
--- a/xorg-server/glx/indirect_dispatch_swap.c
+++ b/xorg-server/glx/indirect_dispatch_swap.c
@@ -271,7 +271,7 @@ void __glXDispSwap_Begin(GLbyte * pc)
 
 void __glXDispSwap_Bitmap(GLbyte * pc)
 {
-    const GLubyte * const bitmap = (const GLubyte *) (pc + 44);
+    const GLubyte * const bitmap = (const GLubyte *) ((pc + 44));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
@@ -1148,7 +1148,7 @@ void __glXDispSwap_PolygonMode(GLbyte * pc)
 
 void __glXDispSwap_PolygonStipple(GLbyte * pc)
 {
-    const GLubyte * const mask = (const GLubyte *) (pc + 20);
+    const GLubyte * const mask = (const GLubyte *) ((pc + 20));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
@@ -1227,7 +1227,7 @@ void __glXDispSwap_TexParameteriv(GLbyte * pc)
 
 void __glXDispSwap_TexImage1D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 52);
+    const GLvoid * const pixels = (const GLvoid *) ((pc + 52));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
@@ -1251,7 +1251,7 @@ void __glXDispSwap_TexImage1D(GLbyte * pc)
 
 void __glXDispSwap_TexImage2D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 52);
+    const GLvoid * const pixels = (const GLvoid *) ((pc + 52));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
@@ -1857,7 +1857,7 @@ void __glXDispSwap_CopyPixels(GLbyte * pc)
 
 void __glXDispSwap_DrawPixels(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 36);
+    const GLvoid * const pixels = (const GLvoid *) ((pc + 36));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
@@ -3108,7 +3108,7 @@ void __glXDispSwap_PrioritizeTextures(GLbyte * pc)
 
 void __glXDispSwap_TexSubImage1D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 56);
+    const GLvoid * const pixels = (const GLvoid *) ((pc + 56));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
@@ -3131,7 +3131,7 @@ void __glXDispSwap_TexSubImage1D(GLbyte * pc)
 
 void __glXDispSwap_TexSubImage2D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 56);
+    const GLvoid * const pixels = (const GLvoid *) ((pc + 56));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
@@ -3173,7 +3173,7 @@ void __glXDispSwap_BlendEquation(GLbyte * pc)
 
 void __glXDispSwap_ColorTable(GLbyte * pc)
 {
-    const GLvoid * const table = (const GLvoid *) (pc + 40);
+    const GLvoid * const table = (const GLvoid *) ((pc + 40));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
@@ -3354,7 +3354,7 @@ int __glXDispSwap_GetColorTableParameterivSGI(__GLXclientState *cl, GLbyte *pc)
 
 void __glXDispSwap_ColorSubTable(GLbyte * pc)
 {
-    const GLvoid * const data = (const GLvoid *) (pc + 40);
+    const GLvoid * const data = (const GLvoid *) ((pc + 40));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
@@ -3387,7 +3387,7 @@ void __glXDispSwap_CopyColorSubTable(GLbyte * pc)
 
 void __glXDispSwap_ConvolutionFilter1D(GLbyte * pc)
 {
-    const GLvoid * const image = (const GLvoid *) (pc + 44);
+    const GLvoid * const image = (const GLvoid *) ((pc + 44));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
@@ -3409,7 +3409,7 @@ void __glXDispSwap_ConvolutionFilter1D(GLbyte * pc)
 
 void __glXDispSwap_ConvolutionFilter2D(GLbyte * pc)
 {
-    const GLvoid * const image = (const GLvoid *) (pc + 44);
+    const GLvoid * const image = (const GLvoid *) ((pc + 44));
     __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
@@ -3923,7 +3923,7 @@ void __glXDispSwap_TexImage3D(GLbyte * pc)
 
 void __glXDispSwap_TexSubImage3D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 88);
+    const GLvoid * const pixels = (const GLvoid *) ((pc + 88));
     __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc);
 
     CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
diff --git a/xorg-server/glx/indirect_reqsize.h b/xorg-server/glx/indirect_reqsize.h
index b6d5e52f7..0ee29e1d0 100644
--- a/xorg-server/glx/indirect_reqsize.h
+++ b/xorg-server/glx/indirect_reqsize.h
@@ -1,116 +1,116 @@
-/* DO NOT EDIT - This file generated automatically by glX_proto_size.py (from Mesa) script */

-

-/*

- * (C) Copyright IBM Corporation 2005

- * All Rights Reserved.

- * 

- * Permission is hereby granted, free of charge, to any person obtaining a

- * copy of this software and associated documentation files (the "Software"),

- * to deal in the Software without restriction, including without limitation

- * the rights to use, copy, modify, merge, publish, distribute, sub license,

- * and/or sell copies of the Software, and to permit persons to whom the

- * Software is furnished to do so, subject to the following conditions:

- * 

- * The above copyright notice and this permission notice (including the next

- * paragraph) shall be included in all copies or substantial portions of the

- * Software.

- * 

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL

- * IBM,

- * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

- * SOFTWARE.

- */

-

-#if !defined( _INDIRECT_REQSIZE_H_ )

-#  define _INDIRECT_REQSIZE_H_

-

-#include <X11/Xfuncproto.h>

-

-#  if defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590))

-#    define PURE __attribute__((pure))

-#  else

-#    define PURE

-#  endif

-

-extern PURE _X_HIDDEN int __glXCallListsReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXBitmapReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXFogfvReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXFogivReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXLightfvReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXLightivReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXLightModelfvReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXLightModelivReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXMaterialfvReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXMaterialivReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXPolygonStippleReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXTexParameterfvReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXTexParameterivReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXTexImage1DReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXTexImage2DReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXTexEnvfvReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXTexEnvivReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXTexGendvReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXTexGenfvReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXTexGenivReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXMap1dReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXMap1fReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXMap2dReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXMap2fReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXPixelMapfvReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXPixelMapuivReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXPixelMapusvReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXDrawPixelsReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXDrawArraysReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXPrioritizeTexturesReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXTexSubImage1DReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXTexSubImage2DReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXColorTableReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXColorTableParameterfvReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXColorTableParameterivReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXColorSubTableReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXConvolutionFilter1DReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXConvolutionFilter2DReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXConvolutionParameterfvReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXConvolutionParameterivReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXSeparableFilter2DReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXTexImage3DReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXTexSubImage3DReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXCompressedTexImage1DARBReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXCompressedTexImage2DARBReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXCompressedTexImage3DARBReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXCompressedTexSubImage1DARBReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXCompressedTexSubImage2DARBReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXCompressedTexSubImage3DARBReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXProgramStringARBReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXDrawBuffersARBReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXPointParameterfvEXTReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXLoadProgramNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXProgramParameters4dvNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXProgramParameters4fvNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXRequestResidentProgramsNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXVertexAttribs1dvNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXVertexAttribs1fvNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXVertexAttribs1svNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXVertexAttribs2dvNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXVertexAttribs2fvNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXVertexAttribs2svNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXVertexAttribs3dvNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXVertexAttribs3fvNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXVertexAttribs3svNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXVertexAttribs4dvNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXVertexAttribs4fvNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXVertexAttribs4svNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXVertexAttribs4ubvNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXPointParameterivNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXProgramNamedParameter4dvNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXProgramNamedParameter4fvNVReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXDeleteFramebuffersEXTReqSize(const GLbyte *pc, Bool swap);

-extern PURE _X_HIDDEN int __glXDeleteRenderbuffersEXTReqSize(const GLbyte *pc, Bool swap);

-

-#  undef PURE

-

-#endif /* !defined( _INDIRECT_REQSIZE_H_ ) */

+/* DO NOT EDIT - This file generated automatically by glX_proto_size.py (from Mesa) script */
+
+/*
+ * (C) Copyright IBM Corporation 2005
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * IBM,
+ * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#if !defined( _INDIRECT_REQSIZE_H_ )
+#define _INDIRECT_REQSIZE_H_
+
+#include <X11/Xfuncproto.h>
+
+#  if defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590))
+#    define PURE __attribute__((pure))
+#  else
+#    define PURE
+#  endif
+
+extern PURE _X_HIDDEN int __glXCallListsReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXBitmapReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXFogfvReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXFogivReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXLightfvReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXLightivReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXLightModelfvReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXLightModelivReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXMaterialfvReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXMaterialivReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXPolygonStippleReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXTexParameterfvReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXTexParameterivReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXTexImage1DReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXTexImage2DReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXTexEnvfvReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXTexEnvivReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXTexGendvReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXTexGenfvReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXTexGenivReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXMap1dReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXMap1fReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXMap2dReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXMap2fReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXPixelMapfvReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXPixelMapuivReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXPixelMapusvReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXDrawPixelsReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXDrawArraysReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXPrioritizeTexturesReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXTexSubImage1DReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXTexSubImage2DReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXColorTableReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXColorTableParameterfvReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXColorTableParameterivReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXColorSubTableReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXConvolutionFilter1DReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXConvolutionFilter2DReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXConvolutionParameterfvReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXConvolutionParameterivReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXSeparableFilter2DReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXTexImage3DReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXTexSubImage3DReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXCompressedTexImage1DARBReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXCompressedTexImage2DARBReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXCompressedTexImage3DARBReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXCompressedTexSubImage1DARBReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXCompressedTexSubImage2DARBReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXCompressedTexSubImage3DARBReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXProgramStringARBReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXDrawBuffersARBReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXPointParameterfvEXTReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXLoadProgramNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXProgramParameters4dvNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXProgramParameters4fvNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXRequestResidentProgramsNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXVertexAttribs1dvNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXVertexAttribs1fvNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXVertexAttribs1svNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXVertexAttribs2dvNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXVertexAttribs2fvNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXVertexAttribs2svNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXVertexAttribs3dvNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXVertexAttribs3fvNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXVertexAttribs3svNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXVertexAttribs4dvNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXVertexAttribs4fvNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXVertexAttribs4svNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXVertexAttribs4ubvNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXPointParameterivNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXProgramNamedParameter4dvNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXProgramNamedParameter4fvNVReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXDeleteFramebuffersEXTReqSize(const GLbyte *pc, Bool swap);
+extern PURE _X_HIDDEN int __glXDeleteRenderbuffersEXTReqSize(const GLbyte *pc, Bool swap);
+
+#  undef PURE
+
+#endif /* !defined( _INDIRECT_REQSIZE_H_ ) */
diff --git a/xorg-server/glx/indirect_size.h b/xorg-server/glx/indirect_size.h
index b1be16b3c..238d8d495 100644
--- a/xorg-server/glx/indirect_size.h
+++ b/xorg-server/glx/indirect_size.h
@@ -1,57 +1,57 @@
-/* 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 <idr@us.ibm.com>

- */

-

-#include <X11/Xfuncproto.h>

-

-#  if defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590))

-#    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

-

-

-#  undef PURE

-#  undef FASTCALL

-

-#endif /* !defined( _INDIRECT_SIZE_H_ ) */

+/* 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 <idr@us.ibm.com>
+ */
+
+#include <X11/Xfuncproto.h>
+
+#  if defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590))
+#    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
+
+
+#  undef PURE
+#  undef FASTCALL
+
+#endif /* !defined( _INDIRECT_SIZE_H_ ) */
diff --git a/xorg-server/glx/indirect_size_get.c b/xorg-server/glx/indirect_size_get.c
index ae7095c69..29c3b9cd2 100644
--- a/xorg-server/glx/indirect_size_get.c
+++ b/xorg-server/glx/indirect_size_get.c
@@ -1,1222 +1,1222 @@
-/* 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.

- */

-

-

-#ifdef HAVE_DIX_CONFIG_H

-#include <dix-config.h>

-#else

-

-#include "glheader.h"

-

-#endif

-

-#include <GL/gl.h>

-#include "indirect_size_get.h"

-#include "glxserver.h"

-#include "indirect_util.h"

-#include "indirect_size.h"

-

-#  if defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590))

-#    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 defined(__CYGWIN__) || defined(__MINGW32__) || defined(GLX_USE_APPLEGL)

-#  undef HAVE_ALIAS

-#endif

-#ifdef HAVE_ALIAS

-#  define ALIAS2(from,to) \

-    _X_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) \

-    _X_INTERNAL PURE FASTCALL GLint __gl ## from ## _size( GLenum e ) \

-    { return __gl ## to ## _size( e ); }

-#endif

-

-

-_X_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:

-        case GL_HALF_FLOAT:

-            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;

-    }

-}

-

-_X_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;

-    }

-}

-

-_X_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;

-    }

-}

-

-_X_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;

-    }

-}

-

-_X_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;

-    }

-}

-

-_X_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_TEXTURE_STORAGE_HINT_APPLE:

-        case GL_STORAGE_PRIVATE_APPLE:

-        case GL_STORAGE_CACHED_APPLE:

-        case GL_STORAGE_SHARED_APPLE:

-        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;

-    }

-}

-

-_X_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_BUMP_TARGET_ATI:

-        case GL_COORD_REPLACE_ARB:

-/*      case GL_COORD_REPLACE_NV:*/

-            return 1;

-        case GL_TEXTURE_ENV_COLOR:

-            return 4;

-        default: return 0;

-    }

-}

-

-_X_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;

-    }

-}

-

-_X_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;

-    }

-}

-

-_X_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;

-    }

-}

-

-_X_INTERNAL PURE FASTCALL GLint

-__glGetBooleanv_size( GLenum e )

-{

-    switch( e ) {

-        case GL_CURRENT_INDEX:

-        case GL_CURRENT_RASTER_INDEX:

-        case GL_CURRENT_RASTER_POSITION_VALID:

-        case GL_CURRENT_RASTER_DISTANCE:

-        case GL_POINT_SMOOTH:

-        case GL_POINT_SIZE:

-        case GL_SMOOTH_POINT_SIZE_GRANULARITY:

-        case GL_LINE_SMOOTH:

-        case GL_LINE_WIDTH:

-        case GL_LINE_WIDTH_GRANULARITY:

-        case GL_LINE_STIPPLE:

-        case GL_LINE_STIPPLE_PATTERN:

-        case GL_LINE_STIPPLE_REPEAT:

-        case GL_LIST_MODE:

-        case GL_MAX_LIST_NESTING:

-        case GL_LIST_BASE:

-        case GL_LIST_INDEX:

-        case GL_POLYGON_SMOOTH:

-        case GL_POLYGON_STIPPLE:

-        case GL_EDGE_FLAG:

-        case GL_CULL_FACE:

-        case GL_CULL_FACE_MODE:

-        case GL_FRONT_FACE:

-        case GL_LIGHTING:

-        case GL_LIGHT_MODEL_LOCAL_VIEWER:

-        case GL_LIGHT_MODEL_TWO_SIDE:

-        case GL_SHADE_MODEL:

-        case GL_COLOR_MATERIAL_FACE:

-        case GL_COLOR_MATERIAL_PARAMETER:

-        case GL_COLOR_MATERIAL:

-        case GL_FOG:

-        case GL_FOG_INDEX:

-        case GL_FOG_DENSITY:

-        case GL_FOG_START:

-        case GL_FOG_END:

-        case GL_FOG_MODE:

-        case GL_DEPTH_TEST:

-        case GL_DEPTH_WRITEMASK:

-        case GL_DEPTH_CLEAR_VALUE:

-        case GL_DEPTH_FUNC:

-        case GL_STENCIL_TEST:

-        case GL_STENCIL_CLEAR_VALUE:

-        case GL_STENCIL_FUNC:

-        case GL_STENCIL_VALUE_MASK:

-        case GL_STENCIL_FAIL:

-        case GL_STENCIL_PASS_DEPTH_FAIL:

-        case GL_STENCIL_PASS_DEPTH_PASS:

-        case GL_STENCIL_REF:

-        case GL_STENCIL_WRITEMASK:

-        case GL_MATRIX_MODE:

-        case GL_NORMALIZE:

-        case GL_MODELVIEW_STACK_DEPTH:

-        case GL_PROJECTION_STACK_DEPTH:

-        case GL_TEXTURE_STACK_DEPTH:

-        case GL_ATTRIB_STACK_DEPTH:

-        case GL_CLIENT_ATTRIB_STACK_DEPTH:

-        case GL_ALPHA_TEST:

-        case GL_ALPHA_TEST_FUNC:

-        case GL_ALPHA_TEST_REF:

-        case GL_DITHER:

-        case GL_BLEND_DST:

-        case GL_BLEND_SRC:

-        case GL_BLEND:

-        case GL_LOGIC_OP_MODE:

-        case GL_LOGIC_OP:

-        case GL_AUX_BUFFERS:

-        case GL_DRAW_BUFFER:

-        case GL_READ_BUFFER:

-        case GL_SCISSOR_TEST:

-        case GL_INDEX_CLEAR_VALUE:

-        case GL_INDEX_WRITEMASK:

-        case GL_INDEX_MODE:

-        case GL_RGBA_MODE:

-        case GL_DOUBLEBUFFER:

-        case GL_STEREO:

-        case GL_RENDER_MODE:

-        case GL_PERSPECTIVE_CORRECTION_HINT:

-        case GL_POINT_SMOOTH_HINT:

-        case GL_LINE_SMOOTH_HINT:

-        case GL_POLYGON_SMOOTH_HINT:

-        case GL_FOG_HINT:

-        case GL_TEXTURE_GEN_S:

-        case GL_TEXTURE_GEN_T:

-        case GL_TEXTURE_GEN_R:

-        case GL_TEXTURE_GEN_Q:

-        case GL_PIXEL_MAP_I_TO_I:

-        case GL_PIXEL_MAP_I_TO_I_SIZE:

-        case GL_PIXEL_MAP_S_TO_S_SIZE:

-        case GL_PIXEL_MAP_I_TO_R_SIZE:

-        case GL_PIXEL_MAP_I_TO_G_SIZE:

-        case GL_PIXEL_MAP_I_TO_B_SIZE:

-        case GL_PIXEL_MAP_I_TO_A_SIZE:

-        case GL_PIXEL_MAP_R_TO_R_SIZE:

-        case GL_PIXEL_MAP_G_TO_G_SIZE:

-        case GL_PIXEL_MAP_B_TO_B_SIZE:

-        case GL_PIXEL_MAP_A_TO_A_SIZE:

-        case GL_UNPACK_SWAP_BYTES:

-        case GL_UNPACK_LSB_FIRST:

-        case GL_UNPACK_ROW_LENGTH:

-        case GL_UNPACK_SKIP_ROWS:

-        case GL_UNPACK_SKIP_PIXELS:

-        case GL_UNPACK_ALIGNMENT:

-        case GL_PACK_SWAP_BYTES:

-        case GL_PACK_LSB_FIRST:

-        case GL_PACK_ROW_LENGTH:

-        case GL_PACK_SKIP_ROWS:

-        case GL_PACK_SKIP_PIXELS:

-        case GL_PACK_ALIGNMENT:

-        case GL_MAP_COLOR:

-        case GL_MAP_STENCIL:

-        case GL_INDEX_SHIFT:

-        case GL_INDEX_OFFSET:

-        case GL_RED_SCALE:

-        case GL_RED_BIAS:

-        case GL_ZOOM_X:

-        case GL_ZOOM_Y:

-        case GL_GREEN_SCALE:

-        case GL_GREEN_BIAS:

-        case GL_BLUE_SCALE:

-        case GL_BLUE_BIAS:

-        case GL_ALPHA_SCALE:

-        case GL_ALPHA_BIAS:

-        case GL_DEPTH_SCALE:

-        case GL_DEPTH_BIAS:

-        case GL_MAX_EVAL_ORDER:

-        case GL_MAX_LIGHTS:

-        case GL_MAX_CLIP_PLANES:

-        case GL_MAX_TEXTURE_SIZE:

-        case GL_MAX_PIXEL_MAP_TABLE:

-        case GL_MAX_ATTRIB_STACK_DEPTH:

-        case GL_MAX_MODELVIEW_STACK_DEPTH:

-        case GL_MAX_NAME_STACK_DEPTH:

-        case GL_MAX_PROJECTION_STACK_DEPTH:

-        case GL_MAX_TEXTURE_STACK_DEPTH:

-        case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:

-        case GL_SUBPIXEL_BITS:

-        case GL_INDEX_BITS:

-        case GL_RED_BITS:

-        case GL_GREEN_BITS:

-        case GL_BLUE_BITS:

-        case GL_ALPHA_BITS:

-        case GL_DEPTH_BITS:

-        case GL_STENCIL_BITS:

-        case GL_ACCUM_RED_BITS:

-        case GL_ACCUM_GREEN_BITS:

-        case GL_ACCUM_BLUE_BITS:

-        case GL_ACCUM_ALPHA_BITS:

-        case GL_NAME_STACK_DEPTH:

-        case GL_AUTO_NORMAL:

-        case GL_MAP1_COLOR_4:

-        case GL_MAP1_INDEX:

-        case GL_MAP1_NORMAL:

-        case GL_MAP1_TEXTURE_COORD_1:

-        case GL_MAP1_TEXTURE_COORD_2:

-        case GL_MAP1_TEXTURE_COORD_3:

-        case GL_MAP1_TEXTURE_COORD_4:

-        case GL_MAP1_VERTEX_3:

-        case GL_MAP1_VERTEX_4:

-        case GL_MAP2_COLOR_4:

-        case GL_MAP2_INDEX:

-        case GL_MAP2_NORMAL:

-        case GL_MAP2_TEXTURE_COORD_1:

-        case GL_MAP2_TEXTURE_COORD_2:

-        case GL_MAP2_TEXTURE_COORD_3:

-        case GL_MAP2_TEXTURE_COORD_4:

-        case GL_MAP2_VERTEX_3:

-        case GL_MAP2_VERTEX_4:

-        case GL_MAP1_GRID_SEGMENTS:

-        case GL_TEXTURE_1D:

-        case GL_TEXTURE_2D:

-        case GL_POLYGON_OFFSET_UNITS:

-        case GL_CLIP_PLANE0:

-        case GL_CLIP_PLANE1:

-        case GL_CLIP_PLANE2:

-        case GL_CLIP_PLANE3:

-        case GL_CLIP_PLANE4:

-        case GL_CLIP_PLANE5:

-        case GL_LIGHT0:

-        case GL_LIGHT1:

-        case GL_LIGHT2:

-        case GL_LIGHT3:

-        case GL_LIGHT4:

-        case GL_LIGHT5:

-        case GL_LIGHT6:

-        case GL_LIGHT7:

-        case GL_BLEND_EQUATION:

-/*      case GL_BLEND_EQUATION_EXT:*/

-        case GL_CONVOLUTION_1D:

-        case GL_CONVOLUTION_2D:

-        case GL_SEPARABLE_2D:

-        case GL_MAX_CONVOLUTION_WIDTH:

-/*      case GL_MAX_CONVOLUTION_WIDTH_EXT:*/

-        case GL_MAX_CONVOLUTION_HEIGHT:

-/*      case GL_MAX_CONVOLUTION_HEIGHT_EXT:*/

-        case GL_POST_CONVOLUTION_RED_SCALE:

-/*      case GL_POST_CONVOLUTION_RED_SCALE_EXT:*/

-        case GL_POST_CONVOLUTION_GREEN_SCALE:

-/*      case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:*/

-        case GL_POST_CONVOLUTION_BLUE_SCALE:

-/*      case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:*/

-        case GL_POST_CONVOLUTION_ALPHA_SCALE:

-/*      case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:*/

-        case GL_POST_CONVOLUTION_RED_BIAS:

-/*      case GL_POST_CONVOLUTION_RED_BIAS_EXT:*/

-        case GL_POST_CONVOLUTION_GREEN_BIAS:

-/*      case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:*/

-        case GL_POST_CONVOLUTION_BLUE_BIAS:

-/*      case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:*/

-        case GL_POST_CONVOLUTION_ALPHA_BIAS:

-/*      case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:*/

-        case GL_HISTOGRAM:

-        case GL_MINMAX:

-        case GL_POLYGON_OFFSET_FACTOR:

-        case GL_RESCALE_NORMAL:

-/*      case GL_RESCALE_NORMAL_EXT:*/

-        case GL_TEXTURE_BINDING_1D:

-        case GL_TEXTURE_BINDING_2D:

-        case GL_TEXTURE_BINDING_3D:

-        case GL_PACK_SKIP_IMAGES:

-        case GL_PACK_IMAGE_HEIGHT:

-        case GL_UNPACK_SKIP_IMAGES:

-        case GL_UNPACK_IMAGE_HEIGHT:

-        case GL_TEXTURE_3D:

-        case GL_MAX_3D_TEXTURE_SIZE:

-        case GL_VERTEX_ARRAY:

-        case GL_NORMAL_ARRAY:

-        case GL_COLOR_ARRAY:

-        case GL_INDEX_ARRAY:

-        case GL_TEXTURE_COORD_ARRAY:

-        case GL_EDGE_FLAG_ARRAY:

-        case GL_VERTEX_ARRAY_SIZE:

-        case GL_VERTEX_ARRAY_TYPE:

-        case GL_VERTEX_ARRAY_STRIDE:

-        case GL_NORMAL_ARRAY_TYPE:

-        case GL_NORMAL_ARRAY_STRIDE:

-        case GL_COLOR_ARRAY_SIZE:

-        case GL_COLOR_ARRAY_TYPE:

-        case GL_COLOR_ARRAY_STRIDE:

-        case GL_INDEX_ARRAY_TYPE:

-        case GL_INDEX_ARRAY_STRIDE:

-        case GL_TEXTURE_COORD_ARRAY_SIZE:

-        case GL_TEXTURE_COORD_ARRAY_TYPE:

-        case GL_TEXTURE_COORD_ARRAY_STRIDE:

-        case GL_EDGE_FLAG_ARRAY_STRIDE:

-        case GL_MULTISAMPLE:

-/*      case GL_MULTISAMPLE_ARB:*/

-        case GL_SAMPLE_ALPHA_TO_COVERAGE:

-/*      case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:*/

-        case GL_SAMPLE_ALPHA_TO_ONE:

-/*      case GL_SAMPLE_ALPHA_TO_ONE_ARB:*/

-        case GL_SAMPLE_COVERAGE:

-/*      case GL_SAMPLE_COVERAGE_ARB:*/

-        case GL_SAMPLE_BUFFERS:

-/*      case GL_SAMPLE_BUFFERS_ARB:*/

-        case GL_SAMPLES:

-/*      case GL_SAMPLES_ARB:*/

-        case GL_SAMPLE_COVERAGE_VALUE:

-/*      case GL_SAMPLE_COVERAGE_VALUE_ARB:*/

-        case GL_SAMPLE_COVERAGE_INVERT:

-/*      case GL_SAMPLE_COVERAGE_INVERT_ARB:*/

-        case GL_COLOR_MATRIX_STACK_DEPTH:

-        case GL_MAX_COLOR_MATRIX_STACK_DEPTH:

-        case GL_POST_COLOR_MATRIX_RED_SCALE:

-        case GL_POST_COLOR_MATRIX_GREEN_SCALE:

-        case GL_POST_COLOR_MATRIX_BLUE_SCALE:

-        case GL_POST_COLOR_MATRIX_ALPHA_SCALE:

-        case GL_POST_COLOR_MATRIX_RED_BIAS:

-        case GL_POST_COLOR_MATRIX_GREEN_BIAS:

-        case GL_POST_COLOR_MATRIX_BLUE_BIAS:

-        case GL_POST_COLOR_MATRIX_ALPHA_BIAS:

-        case GL_BLEND_DST_RGB:

-        case GL_BLEND_SRC_RGB:

-        case GL_BLEND_DST_ALPHA:

-        case GL_BLEND_SRC_ALPHA:

-        case GL_COLOR_TABLE:

-        case GL_POST_CONVOLUTION_COLOR_TABLE:

-        case GL_POST_COLOR_MATRIX_COLOR_TABLE:

-        case GL_MAX_ELEMENTS_VERTICES:

-        case GL_MAX_ELEMENTS_INDICES:

-        case GL_CLIP_VOLUME_CLIPPING_HINT_EXT:

-        case GL_POINT_SIZE_MIN:

-        case GL_POINT_SIZE_MAX:

-        case GL_POINT_FADE_THRESHOLD_SIZE:

-        case GL_OCCLUSION_TEST_HP:

-        case GL_OCCLUSION_TEST_RESULT_HP:

-        case GL_LIGHT_MODEL_COLOR_CONTROL:

-        case GL_RESET_NOTIFICATION_STRATEGY_ARB:

-        case GL_CURRENT_FOG_COORD:

-        case GL_FOG_COORDINATE_ARRAY_TYPE:

-        case GL_FOG_COORDINATE_ARRAY_STRIDE:

-        case GL_FOG_COORD_ARRAY:

-        case GL_COLOR_SUM_ARB:

-        case GL_SECONDARY_COLOR_ARRAY_SIZE:

-        case GL_SECONDARY_COLOR_ARRAY_TYPE:

-        case GL_SECONDARY_COLOR_ARRAY_STRIDE:

-        case GL_SECONDARY_COLOR_ARRAY:

-        case GL_ACTIVE_TEXTURE:

-/*      case GL_ACTIVE_TEXTURE_ARB:*/

-        case GL_CLIENT_ACTIVE_TEXTURE:

-/*      case GL_CLIENT_ACTIVE_TEXTURE_ARB:*/

-        case GL_MAX_TEXTURE_UNITS:

-/*      case GL_MAX_TEXTURE_UNITS_ARB:*/

-        case GL_MAX_RENDERBUFFER_SIZE:

-/*      case GL_MAX_RENDERBUFFER_SIZE_EXT:*/

-        case GL_TEXTURE_COMPRESSION_HINT:

-/*      case GL_TEXTURE_COMPRESSION_HINT_ARB:*/

-        case GL_TEXTURE_RECTANGLE_ARB:

-/*      case GL_TEXTURE_RECTANGLE_NV:*/

-        case GL_TEXTURE_BINDING_RECTANGLE_ARB:

-/*      case GL_TEXTURE_BINDING_RECTANGLE_NV:*/

-        case GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB:

-/*      case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:*/

-        case GL_MAX_TEXTURE_LOD_BIAS:

-        case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:

-        case GL_MAX_SHININESS_NV:

-        case GL_MAX_SPOT_EXPONENT_NV:

-        case GL_TEXTURE_CUBE_MAP:

-/*      case GL_TEXTURE_CUBE_MAP_ARB:*/

-        case GL_TEXTURE_BINDING_CUBE_MAP:

-/*      case GL_TEXTURE_BINDING_CUBE_MAP_ARB:*/

-        case GL_MAX_CUBE_MAP_TEXTURE_SIZE:

-/*      case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:*/

-        case GL_MULTISAMPLE_FILTER_HINT_NV:

-        case GL_FOG_DISTANCE_MODE_NV:

-        case GL_VERTEX_PROGRAM_ARB:

-        case GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB:

-        case GL_MAX_PROGRAM_MATRICES_ARB:

-        case GL_CURRENT_MATRIX_STACK_DEPTH_ARB:

-        case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:

-        case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:

-        case GL_PROGRAM_ERROR_POSITION_ARB:

-        case GL_DEPTH_CLAMP:

-/*      case GL_DEPTH_CLAMP_NV:*/

-        case GL_NUM_COMPRESSED_TEXTURE_FORMATS:

-/*      case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:*/

-        case GL_MAX_VERTEX_UNITS_ARB:

-        case GL_ACTIVE_VERTEX_UNITS_ARB:

-        case GL_WEIGHT_SUM_UNITY_ARB:

-        case GL_VERTEX_BLEND_ARB:

-        case GL_CURRENT_WEIGHT_ARB:

-        case GL_WEIGHT_ARRAY_TYPE_ARB:

-        case GL_WEIGHT_ARRAY_STRIDE_ARB:

-        case GL_WEIGHT_ARRAY_SIZE_ARB:

-        case GL_WEIGHT_ARRAY_ARB:

-        case GL_PACK_INVERT_MESA:

-        case GL_STENCIL_BACK_FUNC_ATI:

-        case GL_STENCIL_BACK_FAIL_ATI:

-        case GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI:

-        case GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI:

-        case GL_FRAGMENT_PROGRAM_ARB:

-        case GL_MAX_DRAW_BUFFERS_ARB:

-/*      case GL_MAX_DRAW_BUFFERS_NV:*/

-        case GL_DRAW_BUFFER0_ARB:

-/*      case GL_DRAW_BUFFER0_ATI:*/

-        case GL_DRAW_BUFFER1_ARB:

-/*      case GL_DRAW_BUFFER1_NV:*/

-        case GL_DRAW_BUFFER2_ARB:

-/*      case GL_DRAW_BUFFER2_ATI:*/

-        case GL_DRAW_BUFFER3_ARB:

-/*      case GL_DRAW_BUFFER3_ATI:*/

-        case GL_DRAW_BUFFER4_ARB:

-/*      case GL_DRAW_BUFFER4_ATI:*/

-        case GL_DRAW_BUFFER5_ARB:

-/*      case GL_DRAW_BUFFER5_ATI:*/

-        case GL_DRAW_BUFFER6_ARB:

-/*      case GL_DRAW_BUFFER6_ATI:*/

-        case GL_DRAW_BUFFER7_ARB:

-/*      case GL_DRAW_BUFFER7_ATI:*/

-        case GL_DRAW_BUFFER8_ARB:

-/*      case GL_DRAW_BUFFER8_ATI:*/

-        case GL_DRAW_BUFFER9_ARB:

-/*      case GL_DRAW_BUFFER9_ATI:*/

-        case GL_DRAW_BUFFER10_ARB:

-/*      case GL_DRAW_BUFFER10_NV:*/

-        case GL_DRAW_BUFFER11_ARB:

-/*      case GL_DRAW_BUFFER11_NV:*/

-        case GL_DRAW_BUFFER12_ARB:

-/*      case GL_DRAW_BUFFER12_ATI:*/

-        case GL_DRAW_BUFFER13_ARB:

-/*      case GL_DRAW_BUFFER13_ATI:*/

-        case GL_DRAW_BUFFER14_ARB:

-/*      case GL_DRAW_BUFFER14_NV:*/

-        case GL_DRAW_BUFFER15_ARB:

-/*      case GL_DRAW_BUFFER15_ATI:*/

-        case GL_BLEND_EQUATION_ALPHA_EXT:

-        case GL_MATRIX_PALETTE_ARB:

-        case GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB:

-        case GL_MAX_PALETTE_MATRICES_ARB:

-        case GL_CURRENT_PALETTE_MATRIX_ARB:

-        case GL_MATRIX_INDEX_ARRAY_ARB:

-        case GL_CURRENT_MATRIX_INDEX_ARB:

-        case GL_MATRIX_INDEX_ARRAY_SIZE_ARB:

-        case GL_MATRIX_INDEX_ARRAY_TYPE_ARB:

-        case GL_MATRIX_INDEX_ARRAY_STRIDE_ARB:

-        case GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT:

-        case GL_POINT_SPRITE_ARB:

-/*      case GL_POINT_SPRITE_NV:*/

-        case GL_POINT_SPRITE_R_MODE_NV:

-        case GL_MAX_VERTEX_ATTRIBS_ARB:

-        case GL_MAX_TEXTURE_COORDS_ARB:

-        case GL_MAX_TEXTURE_IMAGE_UNITS_ARB:

-        case GL_DEPTH_BOUNDS_TEST_EXT:

-        case GL_ARRAY_BUFFER_BINDING_ARB:

-        case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:

-        case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:

-        case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:

-        case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:

-        case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:

-        case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:

-        case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:

-        case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:

-        case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:

-        case GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB:

-        case GL_TEXTURE_CUBE_MAP_SEAMLESS:

-        case GL_MAX_ARRAY_TEXTURE_LAYERS_EXT:

-        case GL_STENCIL_TEST_TWO_SIDE_EXT:

-        case GL_ACTIVE_STENCIL_FACE_EXT:

-        case GL_SAMPLER_BINDING:

-        case GL_TEXTURE_BINDING_1D_ARRAY_EXT:

-        case GL_TEXTURE_BINDING_2D_ARRAY_EXT:

-        case GL_FRAMEBUFFER_BINDING:

-/*      case GL_DRAW_FRAMEBUFFER_BINDING_EXT:*/

-        case GL_RENDERBUFFER_BINDING:

-/*      case GL_RENDERBUFFER_BINDING_EXT:*/

-        case GL_READ_FRAMEBUFFER_BINDING:

-/*      case GL_READ_FRAMEBUFFER_BINDING_EXT:*/

-        case GL_MAX_COLOR_ATTACHMENTS:

-/*      case GL_MAX_COLOR_ATTACHMENTS_EXT:*/

-        case GL_MAX_SAMPLES:

-/*      case GL_MAX_SAMPLES_EXT:*/

-        case GL_MAX_SERVER_WAIT_TIMEOUT:

-        case GL_RASTER_POSITION_UNCLIPPED_IBM:

-            return 1;

-        case GL_SMOOTH_POINT_SIZE_RANGE:

-        case GL_LINE_WIDTH_RANGE:

-        case GL_POLYGON_MODE:

-        case GL_DEPTH_RANGE:

-        case GL_MAX_VIEWPORT_DIMS:

-        case GL_MAP1_GRID_DOMAIN:

-        case GL_MAP2_GRID_SEGMENTS:

-        case GL_ALIASED_POINT_SIZE_RANGE:

-        case GL_ALIASED_LINE_WIDTH_RANGE:

-        case GL_DEPTH_BOUNDS_EXT:

-            return 2;

-        case GL_CURRENT_NORMAL:

-        case GL_POINT_DISTANCE_ATTENUATION:

-            return 3;

-        case GL_CURRENT_COLOR:

-        case GL_CURRENT_TEXTURE_COORDS:

-        case GL_CURRENT_RASTER_COLOR:

-        case GL_CURRENT_RASTER_TEXTURE_COORDS:

-        case GL_CURRENT_RASTER_POSITION:

-        case GL_LIGHT_MODEL_AMBIENT:

-        case GL_FOG_COLOR:

-        case GL_ACCUM_CLEAR_VALUE:

-        case GL_VIEWPORT:

-        case GL_SCISSOR_BOX:

-        case GL_COLOR_CLEAR_VALUE:

-        case GL_COLOR_WRITEMASK:

-        case GL_MAP2_GRID_DOMAIN:

-        case GL_BLEND_COLOR:

-/*      case GL_BLEND_COLOR_EXT:*/

-        case GL_CURRENT_SECONDARY_COLOR:

-            return 4;

-        case GL_MODELVIEW_MATRIX:

-        case GL_PROJECTION_MATRIX:

-        case GL_TEXTURE_MATRIX:

-        case GL_MODELVIEW0_ARB:

-        case GL_COLOR_MATRIX:

-        case GL_MODELVIEW1_ARB:

-        case GL_CURRENT_MATRIX_ARB:

-        case GL_MODELVIEW2_ARB:

-        case GL_MODELVIEW3_ARB:

-        case GL_MODELVIEW4_ARB:

-        case GL_MODELVIEW5_ARB:

-        case GL_MODELVIEW6_ARB:

-        case GL_MODELVIEW7_ARB:

-        case GL_MODELVIEW8_ARB:

-        case GL_MODELVIEW9_ARB:

-        case GL_MODELVIEW10_ARB:

-        case GL_MODELVIEW11_ARB:

-        case GL_MODELVIEW12_ARB:

-        case GL_MODELVIEW13_ARB:

-        case GL_MODELVIEW14_ARB:

-        case GL_MODELVIEW15_ARB:

-        case GL_MODELVIEW16_ARB:

-        case GL_MODELVIEW17_ARB:

-        case GL_MODELVIEW18_ARB:

-        case GL_MODELVIEW19_ARB:

-        case GL_MODELVIEW20_ARB:

-        case GL_MODELVIEW21_ARB:

-        case GL_MODELVIEW22_ARB:

-        case GL_MODELVIEW23_ARB:

-        case GL_MODELVIEW24_ARB:

-        case GL_MODELVIEW25_ARB:

-        case GL_MODELVIEW26_ARB:

-        case GL_MODELVIEW27_ARB:

-        case GL_MODELVIEW28_ARB:

-        case GL_MODELVIEW29_ARB:

-        case GL_MODELVIEW30_ARB:

-        case GL_MODELVIEW31_ARB:

-        case GL_TRANSPOSE_CURRENT_MATRIX_ARB:

-            return 16;

-        case GL_FOG_COORDINATE_SOURCE:

-        case GL_COMPRESSED_TEXTURE_FORMATS:

-        case GL_MIN_PROGRAM_TEXEL_OFFSET:

-        case GL_MAX_PROGRAM_TEXEL_OFFSET:

-        case GL_RGBA_INTEGER_MODE_EXT:

-            return __glGetBooleanv_variable_size( e );

-        default: return 0;

-    }

-}

-

-_X_INTERNAL PURE FASTCALL GLint

-__glGetTexParameterfv_size( GLenum e )

-{

-    switch( e ) {

-        case GL_TEXTURE_MAG_FILTER:

-        case GL_TEXTURE_MIN_FILTER:

-        case GL_TEXTURE_WRAP_S:

-        case GL_TEXTURE_WRAP_T:

-        case GL_TEXTURE_PRIORITY:

-        case GL_TEXTURE_RESIDENT:

-        case GL_TEXTURE_WRAP_R:

-        case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:

-/*      case GL_SHADOW_AMBIENT_SGIX:*/

-        case GL_TEXTURE_MIN_LOD:

-        case GL_TEXTURE_MAX_LOD:

-        case GL_TEXTURE_BASE_LEVEL:

-        case GL_TEXTURE_MAX_LEVEL:

-        case GL_TEXTURE_CLIPMAP_FRAME_SGIX:

-        case GL_TEXTURE_LOD_BIAS_S_SGIX:

-        case GL_TEXTURE_LOD_BIAS_T_SGIX:

-        case GL_TEXTURE_LOD_BIAS_R_SGIX:

-        case GL_GENERATE_MIPMAP:

-/*      case GL_GENERATE_MIPMAP_SGIS:*/

-        case GL_TEXTURE_COMPARE_SGIX:

-        case GL_TEXTURE_COMPARE_OPERATOR_SGIX:

-        case GL_TEXTURE_MAX_CLAMP_S_SGIX:

-        case GL_TEXTURE_MAX_CLAMP_T_SGIX:

-        case GL_TEXTURE_MAX_CLAMP_R_SGIX:

-        case GL_TEXTURE_MAX_ANISOTROPY_EXT:

-        case GL_TEXTURE_LOD_BIAS:

-/*      case GL_TEXTURE_LOD_BIAS_EXT:*/

-        case GL_TEXTURE_RANGE_LENGTH_APPLE:

-        case GL_TEXTURE_STORAGE_HINT_APPLE:

-        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;

-    }

-}

-

-_X_INTERNAL PURE FASTCALL GLint

-__glGetTexLevelParameterfv_size( GLenum e )

-{

-    switch( e ) {

-        case GL_TEXTURE_WIDTH:

-        case GL_TEXTURE_HEIGHT:

-        case GL_TEXTURE_COMPONENTS:

-        case GL_TEXTURE_BORDER:

-        case GL_TEXTURE_RED_SIZE:

-/*      case GL_TEXTURE_RED_SIZE_EXT:*/

-        case GL_TEXTURE_GREEN_SIZE:

-/*      case GL_TEXTURE_GREEN_SIZE_EXT:*/

-        case GL_TEXTURE_BLUE_SIZE:

-/*      case GL_TEXTURE_BLUE_SIZE_EXT:*/

-        case GL_TEXTURE_ALPHA_SIZE:

-/*      case GL_TEXTURE_ALPHA_SIZE_EXT:*/

-        case GL_TEXTURE_LUMINANCE_SIZE:

-/*      case GL_TEXTURE_LUMINANCE_SIZE_EXT:*/

-        case GL_TEXTURE_INTENSITY_SIZE:

-/*      case GL_TEXTURE_INTENSITY_SIZE_EXT:*/

-        case GL_TEXTURE_DEPTH:

-        case GL_TEXTURE_INDEX_SIZE_EXT:

-        case GL_TEXTURE_COMPRESSED_IMAGE_SIZE:

-/*      case GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB:*/

-        case GL_TEXTURE_COMPRESSED:

-/*      case GL_TEXTURE_COMPRESSED_ARB:*/

-        case GL_TEXTURE_DEPTH_SIZE:

-/*      case GL_TEXTURE_DEPTH_SIZE_ARB:*/

-        case GL_TEXTURE_STENCIL_SIZE:

-/*      case GL_TEXTURE_STENCIL_SIZE_EXT:*/

-            return 1;

-        default: return 0;

-    }

-}

-

-_X_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;

-    }

-}

-

-_X_INTERNAL PURE FASTCALL GLint

-__glGetColorTableParameterfv_size( GLenum e )

-{

-    switch( e ) {

-        case GL_COLOR_TABLE_FORMAT:

-/*      case GL_COLOR_TABLE_FORMAT_EXT:*/

-        case GL_COLOR_TABLE_WIDTH:

-/*      case GL_COLOR_TABLE_WIDTH_EXT:*/

-        case GL_COLOR_TABLE_RED_SIZE:

-/*      case GL_COLOR_TABLE_RED_SIZE_EXT:*/

-        case GL_COLOR_TABLE_GREEN_SIZE:

-/*      case GL_COLOR_TABLE_GREEN_SIZE_EXT:*/

-        case GL_COLOR_TABLE_BLUE_SIZE:

-/*      case GL_COLOR_TABLE_BLUE_SIZE_EXT:*/

-        case GL_COLOR_TABLE_ALPHA_SIZE:

-/*      case GL_COLOR_TABLE_ALPHA_SIZE_EXT:*/

-        case GL_COLOR_TABLE_LUMINANCE_SIZE:

-/*      case GL_COLOR_TABLE_LUMINANCE_SIZE_EXT:*/

-        case GL_COLOR_TABLE_INTENSITY_SIZE:

-/*      case GL_COLOR_TABLE_INTENSITY_SIZE_EXT:*/

-            return 1;

-        case GL_COLOR_TABLE_SCALE:

-        case GL_COLOR_TABLE_BIAS:

-            return 4;

-        default: return 0;

-    }

-}

-

-_X_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;

-    }

-}

-

-_X_INTERNAL PURE FASTCALL GLint

-__glGetConvolutionParameterfv_size( GLenum e )

-{

-    switch( e ) {

-        case GL_CONVOLUTION_BORDER_MODE:

-/*      case GL_CONVOLUTION_BORDER_MODE_EXT:*/

-        case GL_CONVOLUTION_FORMAT:

-/*      case GL_CONVOLUTION_FORMAT_EXT:*/

-        case GL_CONVOLUTION_WIDTH:

-/*      case GL_CONVOLUTION_WIDTH_EXT:*/

-        case GL_CONVOLUTION_HEIGHT:

-/*      case GL_CONVOLUTION_HEIGHT_EXT:*/

-        case GL_MAX_CONVOLUTION_WIDTH:

-/*      case GL_MAX_CONVOLUTION_WIDTH_EXT:*/

-        case GL_MAX_CONVOLUTION_HEIGHT:

-/*      case GL_MAX_CONVOLUTION_HEIGHT_EXT:*/

-            return 1;

-        case GL_CONVOLUTION_FILTER_SCALE:

-/*      case GL_CONVOLUTION_FILTER_SCALE_EXT:*/

-        case GL_CONVOLUTION_FILTER_BIAS:

-/*      case GL_CONVOLUTION_FILTER_BIAS_EXT:*/

-        case GL_CONVOLUTION_BORDER_COLOR:

-/*      case GL_CONVOLUTION_BORDER_COLOR_HP:*/

-            return 4;

-        default: return 0;

-    }

-}

-

-_X_INTERNAL PURE FASTCALL GLint

-__glGetHistogramParameterfv_size( GLenum e )

-{

-    switch( e ) {

-        case GL_HISTOGRAM_WIDTH:

-        case GL_HISTOGRAM_FORMAT:

-        case GL_HISTOGRAM_RED_SIZE:

-        case GL_HISTOGRAM_GREEN_SIZE:

-        case GL_HISTOGRAM_BLUE_SIZE:

-        case GL_HISTOGRAM_ALPHA_SIZE:

-        case GL_HISTOGRAM_LUMINANCE_SIZE:

-        case GL_HISTOGRAM_SINK:

-            return 1;

-        default: return 0;

-    }

-}

-

-_X_INTERNAL PURE FASTCALL GLint

-__glGetMinmaxParameterfv_size( GLenum e )

-{

-    switch( e ) {

-        case GL_MINMAX_FORMAT:

-        case GL_MINMAX_SINK:

-            return 1;

-        default: return 0;

-    }

-}

-

-_X_INTERNAL PURE FASTCALL GLint

-__glGetProgramivARB_size( GLenum e )

-{

-    switch( e ) {

-        case GL_PROGRAM_LENGTH_ARB:

-        case GL_PROGRAM_BINDING_ARB:

-        case GL_PROGRAM_ALU_INSTRUCTIONS_ARB:

-        case GL_PROGRAM_TEX_INSTRUCTIONS_ARB:

-        case GL_PROGRAM_TEX_INDIRECTIONS_ARB:

-        case GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB:

-        case GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB:

-        case GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB:

-        case GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB:

-        case GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB:

-        case GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB:

-        case GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB:

-        case GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB:

-        case GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB:

-        case GL_PROGRAM_FORMAT_ARB:

-        case GL_PROGRAM_INSTRUCTIONS_ARB:

-        case GL_MAX_PROGRAM_INSTRUCTIONS_ARB:

-        case GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB:

-        case GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB:

-        case GL_PROGRAM_TEMPORARIES_ARB:

-        case GL_MAX_PROGRAM_TEMPORARIES_ARB:

-        case GL_PROGRAM_NATIVE_TEMPORARIES_ARB:

-        case GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB:

-        case GL_PROGRAM_PARAMETERS_ARB:

-        case GL_MAX_PROGRAM_PARAMETERS_ARB:

-        case GL_PROGRAM_NATIVE_PARAMETERS_ARB:

-        case GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB:

-        case GL_PROGRAM_ATTRIBS_ARB:

-        case GL_MAX_PROGRAM_ATTRIBS_ARB:

-        case GL_PROGRAM_NATIVE_ATTRIBS_ARB:

-        case GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB:

-        case GL_PROGRAM_ADDRESS_REGISTERS_ARB:

-        case GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB:

-        case GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB:

-        case GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB:

-        case GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB:

-        case GL_MAX_PROGRAM_ENV_PARAMETERS_ARB:

-        case GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB:

-        case GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV:

-        case GL_MAX_PROGRAM_CALL_DEPTH_NV:

-        case GL_MAX_PROGRAM_IF_DEPTH_NV:

-        case GL_MAX_PROGRAM_LOOP_DEPTH_NV:

-        case GL_MAX_PROGRAM_LOOP_COUNT_NV:

-            return 1;

-        default: return 0;

-    }

-}

-

-_X_INTERNAL PURE FASTCALL GLint

-__glGetVertexAttribdvARB_size( GLenum e )

-{

-    switch( e ) {

-        case GL_VERTEX_PROGRAM_ARB:

-        case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB:

-        case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB:

-        case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB:

-        case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB:

-        case GL_CURRENT_VERTEX_ATTRIB_ARB:

-        case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB:

-            return 1;

-        default: return 0;

-    }

-}

-

-_X_INTERNAL PURE FASTCALL GLint

-__glGetQueryObjectivARB_size( GLenum e )

-{

-    switch( e ) {

-        case GL_QUERY_RESULT_ARB:

-        case GL_QUERY_RESULT_AVAILABLE_ARB:

-            return 1;

-        default: return 0;

-    }

-}

-

-_X_INTERNAL PURE FASTCALL GLint

-__glGetQueryivARB_size( GLenum e )

-{

-    switch( e ) {

-        case GL_QUERY_COUNTER_BITS_ARB:

-        case GL_CURRENT_QUERY_ARB:

-            return 1;

-        default: return 0;

-    }

-}

-

-_X_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;

-    }

-}

-

-_X_INTERNAL PURE FASTCALL GLint

-__glGetProgramivNV_size( GLenum e )

-{

-    switch( e ) {

-        case GL_PROGRAM_LENGTH_NV:

-        case GL_PROGRAM_TARGET_NV:

-        case GL_PROGRAM_RESIDENT_NV:

-            return 1;

-        default: return 0;

-    }

-}

-

-_X_INTERNAL PURE FASTCALL GLint

-__glGetVertexAttribdvNV_size( GLenum e )

-{

-    switch( e ) {

-        case GL_ATTRIB_ARRAY_SIZE_NV:

-        case GL_ATTRIB_ARRAY_STRIDE_NV:

-        case GL_ATTRIB_ARRAY_TYPE_NV:

-        case GL_CURRENT_ATTRIB_NV:

-            return 1;

-        default: return 0;

-    }

-}

-

-_X_INTERNAL PURE FASTCALL GLint

-__glGetFramebufferAttachmentParameterivEXT_size( GLenum e )

-{

-    switch( e ) {

-        case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT:

-        case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT:

-        case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT:

-        case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT:

-        case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT:

-            return 1;

-        default: return 0;

-    }

-}

-

-ALIAS( Fogiv, Fogfv )

-ALIAS( Lightiv, Lightfv )

-ALIAS( LightModeliv, LightModelfv )

-ALIAS( Materialiv, Materialfv )

-ALIAS( TexParameteriv, TexParameterfv )

-ALIAS( TexEnviv, TexEnvfv )

-ALIAS( TexGenfv, TexGendv )

-ALIAS( TexGeniv, TexGendv )

-ALIAS( Map1f, Map1d )

-ALIAS( Map2f, Map2d )

-ALIAS( GetDoublev, GetBooleanv )

-ALIAS( GetFloatv, GetBooleanv )

-ALIAS( GetIntegerv, GetBooleanv )

-ALIAS( GetLightfv, Lightfv )

-ALIAS( GetLightiv, Lightfv )

-ALIAS( GetMaterialfv, Materialfv )

-ALIAS( GetMaterialiv, Materialfv )

-ALIAS( GetTexEnvfv, TexEnvfv )

-ALIAS( GetTexEnviv, TexEnvfv )

-ALIAS( GetTexGendv, TexGendv )

-ALIAS( GetTexGenfv, TexGendv )

-ALIAS( GetTexGeniv, TexGendv )

-ALIAS( GetTexParameteriv, GetTexParameterfv )

-ALIAS( GetTexLevelParameteriv, GetTexLevelParameterfv )

-ALIAS( ColorTableParameteriv, ColorTableParameterfv )

-ALIAS( GetColorTableParameteriv, GetColorTableParameterfv )

-ALIAS( ConvolutionParameteriv, ConvolutionParameterfv )

-ALIAS( GetConvolutionParameteriv, GetConvolutionParameterfv )

-ALIAS( GetHistogramParameteriv, GetHistogramParameterfv )

-ALIAS( GetMinmaxParameteriv, GetMinmaxParameterfv )

-ALIAS( GetVertexAttribfvARB, GetVertexAttribdvARB )

-ALIAS( GetVertexAttribivARB, GetVertexAttribdvARB )

-ALIAS( GetQueryObjectuivARB, GetQueryObjectivARB )

-ALIAS( GetVertexAttribfvNV, GetVertexAttribdvNV )

-ALIAS( GetVertexAttribivNV, GetVertexAttribdvNV )

-ALIAS( PointParameterivNV, PointParameterfvEXT )

-

-#  undef PURE

-#  undef FASTCALL

+/* 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.
+ */
+
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#else
+
+#include "glheader.h"
+
+#endif
+
+#include <GL/gl.h>
+#include "indirect_size_get.h"
+#include "glxserver.h"
+#include "indirect_util.h"
+#include "indirect_size.h"
+
+#  if defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590))
+#    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 defined(__CYGWIN__) || defined(__MINGW32__) || defined(GLX_USE_APPLEGL)
+#  undef HAVE_ALIAS
+#endif
+#ifdef HAVE_ALIAS
+#  define ALIAS2(from,to) \
+    _X_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) \
+    _X_INTERNAL PURE FASTCALL GLint __gl ## from ## _size( GLenum e ) \
+    { return __gl ## to ## _size( e ); }
+#endif
+
+
+_X_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:
+        case GL_HALF_FLOAT:
+            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;
+    }
+}
+
+_X_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;
+    }
+}
+
+_X_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;
+    }
+}
+
+_X_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;
+    }
+}
+
+_X_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;
+    }
+}
+
+_X_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_TEXTURE_STORAGE_HINT_APPLE:
+        case GL_STORAGE_PRIVATE_APPLE:
+        case GL_STORAGE_CACHED_APPLE:
+        case GL_STORAGE_SHARED_APPLE:
+        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;
+    }
+}
+
+_X_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_BUMP_TARGET_ATI:
+        case GL_COORD_REPLACE_ARB:
+/*      case GL_COORD_REPLACE_NV:*/
+            return 1;
+        case GL_TEXTURE_ENV_COLOR:
+            return 4;
+        default: return 0;
+    }
+}
+
+_X_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;
+    }
+}
+
+_X_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;
+    }
+}
+
+_X_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;
+    }
+}
+
+_X_INTERNAL PURE FASTCALL GLint
+__glGetBooleanv_size( GLenum e )
+{
+    switch( e ) {
+        case GL_CURRENT_INDEX:
+        case GL_CURRENT_RASTER_INDEX:
+        case GL_CURRENT_RASTER_POSITION_VALID:
+        case GL_CURRENT_RASTER_DISTANCE:
+        case GL_POINT_SMOOTH:
+        case GL_POINT_SIZE:
+        case GL_SMOOTH_POINT_SIZE_GRANULARITY:
+        case GL_LINE_SMOOTH:
+        case GL_LINE_WIDTH:
+        case GL_LINE_WIDTH_GRANULARITY:
+        case GL_LINE_STIPPLE:
+        case GL_LINE_STIPPLE_PATTERN:
+        case GL_LINE_STIPPLE_REPEAT:
+        case GL_LIST_MODE:
+        case GL_MAX_LIST_NESTING:
+        case GL_LIST_BASE:
+        case GL_LIST_INDEX:
+        case GL_POLYGON_SMOOTH:
+        case GL_POLYGON_STIPPLE:
+        case GL_EDGE_FLAG:
+        case GL_CULL_FACE:
+        case GL_CULL_FACE_MODE:
+        case GL_FRONT_FACE:
+        case GL_LIGHTING:
+        case GL_LIGHT_MODEL_LOCAL_VIEWER:
+        case GL_LIGHT_MODEL_TWO_SIDE:
+        case GL_SHADE_MODEL:
+        case GL_COLOR_MATERIAL_FACE:
+        case GL_COLOR_MATERIAL_PARAMETER:
+        case GL_COLOR_MATERIAL:
+        case GL_FOG:
+        case GL_FOG_INDEX:
+        case GL_FOG_DENSITY:
+        case GL_FOG_START:
+        case GL_FOG_END:
+        case GL_FOG_MODE:
+        case GL_DEPTH_TEST:
+        case GL_DEPTH_WRITEMASK:
+        case GL_DEPTH_CLEAR_VALUE:
+        case GL_DEPTH_FUNC:
+        case GL_STENCIL_TEST:
+        case GL_STENCIL_CLEAR_VALUE:
+        case GL_STENCIL_FUNC:
+        case GL_STENCIL_VALUE_MASK:
+        case GL_STENCIL_FAIL:
+        case GL_STENCIL_PASS_DEPTH_FAIL:
+        case GL_STENCIL_PASS_DEPTH_PASS:
+        case GL_STENCIL_REF:
+        case GL_STENCIL_WRITEMASK:
+        case GL_MATRIX_MODE:
+        case GL_NORMALIZE:
+        case GL_MODELVIEW_STACK_DEPTH:
+        case GL_PROJECTION_STACK_DEPTH:
+        case GL_TEXTURE_STACK_DEPTH:
+        case GL_ATTRIB_STACK_DEPTH:
+        case GL_CLIENT_ATTRIB_STACK_DEPTH:
+        case GL_ALPHA_TEST:
+        case GL_ALPHA_TEST_FUNC:
+        case GL_ALPHA_TEST_REF:
+        case GL_DITHER:
+        case GL_BLEND_DST:
+        case GL_BLEND_SRC:
+        case GL_BLEND:
+        case GL_LOGIC_OP_MODE:
+        case GL_LOGIC_OP:
+        case GL_AUX_BUFFERS:
+        case GL_DRAW_BUFFER:
+        case GL_READ_BUFFER:
+        case GL_SCISSOR_TEST:
+        case GL_INDEX_CLEAR_VALUE:
+        case GL_INDEX_WRITEMASK:
+        case GL_INDEX_MODE:
+        case GL_RGBA_MODE:
+        case GL_DOUBLEBUFFER:
+        case GL_STEREO:
+        case GL_RENDER_MODE:
+        case GL_PERSPECTIVE_CORRECTION_HINT:
+        case GL_POINT_SMOOTH_HINT:
+        case GL_LINE_SMOOTH_HINT:
+        case GL_POLYGON_SMOOTH_HINT:
+        case GL_FOG_HINT:
+        case GL_TEXTURE_GEN_S:
+        case GL_TEXTURE_GEN_T:
+        case GL_TEXTURE_GEN_R:
+        case GL_TEXTURE_GEN_Q:
+        case GL_PIXEL_MAP_I_TO_I:
+        case GL_PIXEL_MAP_I_TO_I_SIZE:
+        case GL_PIXEL_MAP_S_TO_S_SIZE:
+        case GL_PIXEL_MAP_I_TO_R_SIZE:
+        case GL_PIXEL_MAP_I_TO_G_SIZE:
+        case GL_PIXEL_MAP_I_TO_B_SIZE:
+        case GL_PIXEL_MAP_I_TO_A_SIZE:
+        case GL_PIXEL_MAP_R_TO_R_SIZE:
+        case GL_PIXEL_MAP_G_TO_G_SIZE:
+        case GL_PIXEL_MAP_B_TO_B_SIZE:
+        case GL_PIXEL_MAP_A_TO_A_SIZE:
+        case GL_UNPACK_SWAP_BYTES:
+        case GL_UNPACK_LSB_FIRST:
+        case GL_UNPACK_ROW_LENGTH:
+        case GL_UNPACK_SKIP_ROWS:
+        case GL_UNPACK_SKIP_PIXELS:
+        case GL_UNPACK_ALIGNMENT:
+        case GL_PACK_SWAP_BYTES:
+        case GL_PACK_LSB_FIRST:
+        case GL_PACK_ROW_LENGTH:
+        case GL_PACK_SKIP_ROWS:
+        case GL_PACK_SKIP_PIXELS:
+        case GL_PACK_ALIGNMENT:
+        case GL_MAP_COLOR:
+        case GL_MAP_STENCIL:
+        case GL_INDEX_SHIFT:
+        case GL_INDEX_OFFSET:
+        case GL_RED_SCALE:
+        case GL_RED_BIAS:
+        case GL_ZOOM_X:
+        case GL_ZOOM_Y:
+        case GL_GREEN_SCALE:
+        case GL_GREEN_BIAS:
+        case GL_BLUE_SCALE:
+        case GL_BLUE_BIAS:
+        case GL_ALPHA_SCALE:
+        case GL_ALPHA_BIAS:
+        case GL_DEPTH_SCALE:
+        case GL_DEPTH_BIAS:
+        case GL_MAX_EVAL_ORDER:
+        case GL_MAX_LIGHTS:
+        case GL_MAX_CLIP_PLANES:
+        case GL_MAX_TEXTURE_SIZE:
+        case GL_MAX_PIXEL_MAP_TABLE:
+        case GL_MAX_ATTRIB_STACK_DEPTH:
+        case GL_MAX_MODELVIEW_STACK_DEPTH:
+        case GL_MAX_NAME_STACK_DEPTH:
+        case GL_MAX_PROJECTION_STACK_DEPTH:
+        case GL_MAX_TEXTURE_STACK_DEPTH:
+        case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
+        case GL_SUBPIXEL_BITS:
+        case GL_INDEX_BITS:
+        case GL_RED_BITS:
+        case GL_GREEN_BITS:
+        case GL_BLUE_BITS:
+        case GL_ALPHA_BITS:
+        case GL_DEPTH_BITS:
+        case GL_STENCIL_BITS:
+        case GL_ACCUM_RED_BITS:
+        case GL_ACCUM_GREEN_BITS:
+        case GL_ACCUM_BLUE_BITS:
+        case GL_ACCUM_ALPHA_BITS:
+        case GL_NAME_STACK_DEPTH:
+        case GL_AUTO_NORMAL:
+        case GL_MAP1_COLOR_4:
+        case GL_MAP1_INDEX:
+        case GL_MAP1_NORMAL:
+        case GL_MAP1_TEXTURE_COORD_1:
+        case GL_MAP1_TEXTURE_COORD_2:
+        case GL_MAP1_TEXTURE_COORD_3:
+        case GL_MAP1_TEXTURE_COORD_4:
+        case GL_MAP1_VERTEX_3:
+        case GL_MAP1_VERTEX_4:
+        case GL_MAP2_COLOR_4:
+        case GL_MAP2_INDEX:
+        case GL_MAP2_NORMAL:
+        case GL_MAP2_TEXTURE_COORD_1:
+        case GL_MAP2_TEXTURE_COORD_2:
+        case GL_MAP2_TEXTURE_COORD_3:
+        case GL_MAP2_TEXTURE_COORD_4:
+        case GL_MAP2_VERTEX_3:
+        case GL_MAP2_VERTEX_4:
+        case GL_MAP1_GRID_SEGMENTS:
+        case GL_TEXTURE_1D:
+        case GL_TEXTURE_2D:
+        case GL_POLYGON_OFFSET_UNITS:
+        case GL_CLIP_PLANE0:
+        case GL_CLIP_PLANE1:
+        case GL_CLIP_PLANE2:
+        case GL_CLIP_PLANE3:
+        case GL_CLIP_PLANE4:
+        case GL_CLIP_PLANE5:
+        case GL_LIGHT0:
+        case GL_LIGHT1:
+        case GL_LIGHT2:
+        case GL_LIGHT3:
+        case GL_LIGHT4:
+        case GL_LIGHT5:
+        case GL_LIGHT6:
+        case GL_LIGHT7:
+        case GL_BLEND_EQUATION:
+/*      case GL_BLEND_EQUATION_EXT:*/
+        case GL_CONVOLUTION_1D:
+        case GL_CONVOLUTION_2D:
+        case GL_SEPARABLE_2D:
+        case GL_MAX_CONVOLUTION_WIDTH:
+/*      case GL_MAX_CONVOLUTION_WIDTH_EXT:*/
+        case GL_MAX_CONVOLUTION_HEIGHT:
+/*      case GL_MAX_CONVOLUTION_HEIGHT_EXT:*/
+        case GL_POST_CONVOLUTION_RED_SCALE:
+/*      case GL_POST_CONVOLUTION_RED_SCALE_EXT:*/
+        case GL_POST_CONVOLUTION_GREEN_SCALE:
+/*      case GL_POST_CONVOLUTION_GREEN_SCALE_EXT:*/
+        case GL_POST_CONVOLUTION_BLUE_SCALE:
+/*      case GL_POST_CONVOLUTION_BLUE_SCALE_EXT:*/
+        case GL_POST_CONVOLUTION_ALPHA_SCALE:
+/*      case GL_POST_CONVOLUTION_ALPHA_SCALE_EXT:*/
+        case GL_POST_CONVOLUTION_RED_BIAS:
+/*      case GL_POST_CONVOLUTION_RED_BIAS_EXT:*/
+        case GL_POST_CONVOLUTION_GREEN_BIAS:
+/*      case GL_POST_CONVOLUTION_GREEN_BIAS_EXT:*/
+        case GL_POST_CONVOLUTION_BLUE_BIAS:
+/*      case GL_POST_CONVOLUTION_BLUE_BIAS_EXT:*/
+        case GL_POST_CONVOLUTION_ALPHA_BIAS:
+/*      case GL_POST_CONVOLUTION_ALPHA_BIAS_EXT:*/
+        case GL_HISTOGRAM:
+        case GL_MINMAX:
+        case GL_POLYGON_OFFSET_FACTOR:
+        case GL_RESCALE_NORMAL:
+/*      case GL_RESCALE_NORMAL_EXT:*/
+        case GL_TEXTURE_BINDING_1D:
+        case GL_TEXTURE_BINDING_2D:
+        case GL_TEXTURE_BINDING_3D:
+        case GL_PACK_SKIP_IMAGES:
+        case GL_PACK_IMAGE_HEIGHT:
+        case GL_UNPACK_SKIP_IMAGES:
+        case GL_UNPACK_IMAGE_HEIGHT:
+        case GL_TEXTURE_3D:
+        case GL_MAX_3D_TEXTURE_SIZE:
+        case GL_VERTEX_ARRAY:
+        case GL_NORMAL_ARRAY:
+        case GL_COLOR_ARRAY:
+        case GL_INDEX_ARRAY:
+        case GL_TEXTURE_COORD_ARRAY:
+        case GL_EDGE_FLAG_ARRAY:
+        case GL_VERTEX_ARRAY_SIZE:
+        case GL_VERTEX_ARRAY_TYPE:
+        case GL_VERTEX_ARRAY_STRIDE:
+        case GL_NORMAL_ARRAY_TYPE:
+        case GL_NORMAL_ARRAY_STRIDE:
+        case GL_COLOR_ARRAY_SIZE:
+        case GL_COLOR_ARRAY_TYPE:
+        case GL_COLOR_ARRAY_STRIDE:
+        case GL_INDEX_ARRAY_TYPE:
+        case GL_INDEX_ARRAY_STRIDE:
+        case GL_TEXTURE_COORD_ARRAY_SIZE:
+        case GL_TEXTURE_COORD_ARRAY_TYPE:
+        case GL_TEXTURE_COORD_ARRAY_STRIDE:
+        case GL_EDGE_FLAG_ARRAY_STRIDE:
+        case GL_MULTISAMPLE:
+/*      case GL_MULTISAMPLE_ARB:*/
+        case GL_SAMPLE_ALPHA_TO_COVERAGE:
+/*      case GL_SAMPLE_ALPHA_TO_COVERAGE_ARB:*/
+        case GL_SAMPLE_ALPHA_TO_ONE:
+/*      case GL_SAMPLE_ALPHA_TO_ONE_ARB:*/
+        case GL_SAMPLE_COVERAGE:
+/*      case GL_SAMPLE_COVERAGE_ARB:*/
+        case GL_SAMPLE_BUFFERS:
+/*      case GL_SAMPLE_BUFFERS_ARB:*/
+        case GL_SAMPLES:
+/*      case GL_SAMPLES_ARB:*/
+        case GL_SAMPLE_COVERAGE_VALUE:
+/*      case GL_SAMPLE_COVERAGE_VALUE_ARB:*/
+        case GL_SAMPLE_COVERAGE_INVERT:
+/*      case GL_SAMPLE_COVERAGE_INVERT_ARB:*/
+        case GL_COLOR_MATRIX_STACK_DEPTH:
+        case GL_MAX_COLOR_MATRIX_STACK_DEPTH:
+        case GL_POST_COLOR_MATRIX_RED_SCALE:
+        case GL_POST_COLOR_MATRIX_GREEN_SCALE:
+        case GL_POST_COLOR_MATRIX_BLUE_SCALE:
+        case GL_POST_COLOR_MATRIX_ALPHA_SCALE:
+        case GL_POST_COLOR_MATRIX_RED_BIAS:
+        case GL_POST_COLOR_MATRIX_GREEN_BIAS:
+        case GL_POST_COLOR_MATRIX_BLUE_BIAS:
+        case GL_POST_COLOR_MATRIX_ALPHA_BIAS:
+        case GL_BLEND_DST_RGB:
+        case GL_BLEND_SRC_RGB:
+        case GL_BLEND_DST_ALPHA:
+        case GL_BLEND_SRC_ALPHA:
+        case GL_COLOR_TABLE:
+        case GL_POST_CONVOLUTION_COLOR_TABLE:
+        case GL_POST_COLOR_MATRIX_COLOR_TABLE:
+        case GL_MAX_ELEMENTS_VERTICES:
+        case GL_MAX_ELEMENTS_INDICES:
+        case GL_CLIP_VOLUME_CLIPPING_HINT_EXT:
+        case GL_POINT_SIZE_MIN:
+        case GL_POINT_SIZE_MAX:
+        case GL_POINT_FADE_THRESHOLD_SIZE:
+        case GL_OCCLUSION_TEST_HP:
+        case GL_OCCLUSION_TEST_RESULT_HP:
+        case GL_LIGHT_MODEL_COLOR_CONTROL:
+        case GL_RESET_NOTIFICATION_STRATEGY_ARB:
+        case GL_CURRENT_FOG_COORD:
+        case GL_FOG_COORDINATE_ARRAY_TYPE:
+        case GL_FOG_COORDINATE_ARRAY_STRIDE:
+        case GL_FOG_COORD_ARRAY:
+        case GL_COLOR_SUM_ARB:
+        case GL_SECONDARY_COLOR_ARRAY_SIZE:
+        case GL_SECONDARY_COLOR_ARRAY_TYPE:
+        case GL_SECONDARY_COLOR_ARRAY_STRIDE:
+        case GL_SECONDARY_COLOR_ARRAY:
+        case GL_ACTIVE_TEXTURE:
+/*      case GL_ACTIVE_TEXTURE_ARB:*/
+        case GL_CLIENT_ACTIVE_TEXTURE:
+/*      case GL_CLIENT_ACTIVE_TEXTURE_ARB:*/
+        case GL_MAX_TEXTURE_UNITS:
+/*      case GL_MAX_TEXTURE_UNITS_ARB:*/
+        case GL_MAX_RENDERBUFFER_SIZE:
+/*      case GL_MAX_RENDERBUFFER_SIZE_EXT:*/
+        case GL_TEXTURE_COMPRESSION_HINT:
+/*      case GL_TEXTURE_COMPRESSION_HINT_ARB:*/
+        case GL_TEXTURE_RECTANGLE_ARB:
+/*      case GL_TEXTURE_RECTANGLE_NV:*/
+        case GL_TEXTURE_BINDING_RECTANGLE_ARB:
+/*      case GL_TEXTURE_BINDING_RECTANGLE_NV:*/
+        case GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB:
+/*      case GL_MAX_RECTANGLE_TEXTURE_SIZE_NV:*/
+        case GL_MAX_TEXTURE_LOD_BIAS:
+        case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
+        case GL_MAX_SHININESS_NV:
+        case GL_MAX_SPOT_EXPONENT_NV:
+        case GL_TEXTURE_CUBE_MAP:
+/*      case GL_TEXTURE_CUBE_MAP_ARB:*/
+        case GL_TEXTURE_BINDING_CUBE_MAP:
+/*      case GL_TEXTURE_BINDING_CUBE_MAP_ARB:*/
+        case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
+/*      case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:*/
+        case GL_MULTISAMPLE_FILTER_HINT_NV:
+        case GL_FOG_DISTANCE_MODE_NV:
+        case GL_VERTEX_PROGRAM_ARB:
+        case GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB:
+        case GL_MAX_PROGRAM_MATRICES_ARB:
+        case GL_CURRENT_MATRIX_STACK_DEPTH_ARB:
+        case GL_VERTEX_PROGRAM_POINT_SIZE_ARB:
+        case GL_VERTEX_PROGRAM_TWO_SIDE_ARB:
+        case GL_PROGRAM_ERROR_POSITION_ARB:
+        case GL_DEPTH_CLAMP:
+/*      case GL_DEPTH_CLAMP_NV:*/
+        case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
+/*      case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:*/
+        case GL_MAX_VERTEX_UNITS_ARB:
+        case GL_ACTIVE_VERTEX_UNITS_ARB:
+        case GL_WEIGHT_SUM_UNITY_ARB:
+        case GL_VERTEX_BLEND_ARB:
+        case GL_CURRENT_WEIGHT_ARB:
+        case GL_WEIGHT_ARRAY_TYPE_ARB:
+        case GL_WEIGHT_ARRAY_STRIDE_ARB:
+        case GL_WEIGHT_ARRAY_SIZE_ARB:
+        case GL_WEIGHT_ARRAY_ARB:
+        case GL_PACK_INVERT_MESA:
+        case GL_STENCIL_BACK_FUNC_ATI:
+        case GL_STENCIL_BACK_FAIL_ATI:
+        case GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI:
+        case GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI:
+        case GL_FRAGMENT_PROGRAM_ARB:
+        case GL_MAX_DRAW_BUFFERS_ARB:
+/*      case GL_MAX_DRAW_BUFFERS_NV:*/
+        case GL_DRAW_BUFFER0_ARB:
+/*      case GL_DRAW_BUFFER0_ATI:*/
+        case GL_DRAW_BUFFER1_ARB:
+/*      case GL_DRAW_BUFFER1_NV:*/
+        case GL_DRAW_BUFFER2_ARB:
+/*      case GL_DRAW_BUFFER2_ATI:*/
+        case GL_DRAW_BUFFER3_ARB:
+/*      case GL_DRAW_BUFFER3_ATI:*/
+        case GL_DRAW_BUFFER4_ARB:
+/*      case GL_DRAW_BUFFER4_ATI:*/
+        case GL_DRAW_BUFFER5_ARB:
+/*      case GL_DRAW_BUFFER5_ATI:*/
+        case GL_DRAW_BUFFER6_ARB:
+/*      case GL_DRAW_BUFFER6_ATI:*/
+        case GL_DRAW_BUFFER7_ARB:
+/*      case GL_DRAW_BUFFER7_ATI:*/
+        case GL_DRAW_BUFFER8_ARB:
+/*      case GL_DRAW_BUFFER8_ATI:*/
+        case GL_DRAW_BUFFER9_ARB:
+/*      case GL_DRAW_BUFFER9_ATI:*/
+        case GL_DRAW_BUFFER10_ARB:
+/*      case GL_DRAW_BUFFER10_NV:*/
+        case GL_DRAW_BUFFER11_ARB:
+/*      case GL_DRAW_BUFFER11_NV:*/
+        case GL_DRAW_BUFFER12_ARB:
+/*      case GL_DRAW_BUFFER12_ATI:*/
+        case GL_DRAW_BUFFER13_ARB:
+/*      case GL_DRAW_BUFFER13_ATI:*/
+        case GL_DRAW_BUFFER14_ARB:
+/*      case GL_DRAW_BUFFER14_NV:*/
+        case GL_DRAW_BUFFER15_ARB:
+/*      case GL_DRAW_BUFFER15_ATI:*/
+        case GL_BLEND_EQUATION_ALPHA_EXT:
+        case GL_MATRIX_PALETTE_ARB:
+        case GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB:
+        case GL_MAX_PALETTE_MATRICES_ARB:
+        case GL_CURRENT_PALETTE_MATRIX_ARB:
+        case GL_MATRIX_INDEX_ARRAY_ARB:
+        case GL_CURRENT_MATRIX_INDEX_ARB:
+        case GL_MATRIX_INDEX_ARRAY_SIZE_ARB:
+        case GL_MATRIX_INDEX_ARRAY_TYPE_ARB:
+        case GL_MATRIX_INDEX_ARRAY_STRIDE_ARB:
+        case GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT:
+        case GL_POINT_SPRITE_ARB:
+/*      case GL_POINT_SPRITE_NV:*/
+        case GL_POINT_SPRITE_R_MODE_NV:
+        case GL_MAX_VERTEX_ATTRIBS_ARB:
+        case GL_MAX_TEXTURE_COORDS_ARB:
+        case GL_MAX_TEXTURE_IMAGE_UNITS_ARB:
+        case GL_DEPTH_BOUNDS_TEST_EXT:
+        case GL_ARRAY_BUFFER_BINDING_ARB:
+        case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
+        case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
+        case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
+        case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
+        case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
+        case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
+        case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
+        case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
+        case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
+        case GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB:
+        case GL_TEXTURE_CUBE_MAP_SEAMLESS:
+        case GL_MAX_ARRAY_TEXTURE_LAYERS_EXT:
+        case GL_STENCIL_TEST_TWO_SIDE_EXT:
+        case GL_ACTIVE_STENCIL_FACE_EXT:
+        case GL_SAMPLER_BINDING:
+        case GL_TEXTURE_BINDING_1D_ARRAY_EXT:
+        case GL_TEXTURE_BINDING_2D_ARRAY_EXT:
+        case GL_FRAMEBUFFER_BINDING:
+/*      case GL_DRAW_FRAMEBUFFER_BINDING_EXT:*/
+        case GL_RENDERBUFFER_BINDING:
+/*      case GL_RENDERBUFFER_BINDING_EXT:*/
+        case GL_READ_FRAMEBUFFER_BINDING:
+/*      case GL_READ_FRAMEBUFFER_BINDING_EXT:*/
+        case GL_MAX_COLOR_ATTACHMENTS:
+/*      case GL_MAX_COLOR_ATTACHMENTS_EXT:*/
+        case GL_MAX_SAMPLES:
+/*      case GL_MAX_SAMPLES_EXT:*/
+        case GL_MAX_SERVER_WAIT_TIMEOUT:
+        case GL_RASTER_POSITION_UNCLIPPED_IBM:
+            return 1;
+        case GL_SMOOTH_POINT_SIZE_RANGE:
+        case GL_LINE_WIDTH_RANGE:
+        case GL_POLYGON_MODE:
+        case GL_DEPTH_RANGE:
+        case GL_MAX_VIEWPORT_DIMS:
+        case GL_MAP1_GRID_DOMAIN:
+        case GL_MAP2_GRID_SEGMENTS:
+        case GL_ALIASED_POINT_SIZE_RANGE:
+        case GL_ALIASED_LINE_WIDTH_RANGE:
+        case GL_DEPTH_BOUNDS_EXT:
+            return 2;
+        case GL_CURRENT_NORMAL:
+        case GL_POINT_DISTANCE_ATTENUATION:
+            return 3;
+        case GL_CURRENT_COLOR:
+        case GL_CURRENT_TEXTURE_COORDS:
+        case GL_CURRENT_RASTER_COLOR:
+        case GL_CURRENT_RASTER_TEXTURE_COORDS:
+        case GL_CURRENT_RASTER_POSITION:
+        case GL_LIGHT_MODEL_AMBIENT:
+        case GL_FOG_COLOR:
+        case GL_ACCUM_CLEAR_VALUE:
+        case GL_VIEWPORT:
+        case GL_SCISSOR_BOX:
+        case GL_COLOR_CLEAR_VALUE:
+        case GL_COLOR_WRITEMASK:
+        case GL_MAP2_GRID_DOMAIN:
+        case GL_BLEND_COLOR:
+/*      case GL_BLEND_COLOR_EXT:*/
+        case GL_CURRENT_SECONDARY_COLOR:
+            return 4;
+        case GL_MODELVIEW_MATRIX:
+        case GL_PROJECTION_MATRIX:
+        case GL_TEXTURE_MATRIX:
+        case GL_MODELVIEW0_ARB:
+        case GL_COLOR_MATRIX:
+        case GL_MODELVIEW1_ARB:
+        case GL_CURRENT_MATRIX_ARB:
+        case GL_MODELVIEW2_ARB:
+        case GL_MODELVIEW3_ARB:
+        case GL_MODELVIEW4_ARB:
+        case GL_MODELVIEW5_ARB:
+        case GL_MODELVIEW6_ARB:
+        case GL_MODELVIEW7_ARB:
+        case GL_MODELVIEW8_ARB:
+        case GL_MODELVIEW9_ARB:
+        case GL_MODELVIEW10_ARB:
+        case GL_MODELVIEW11_ARB:
+        case GL_MODELVIEW12_ARB:
+        case GL_MODELVIEW13_ARB:
+        case GL_MODELVIEW14_ARB:
+        case GL_MODELVIEW15_ARB:
+        case GL_MODELVIEW16_ARB:
+        case GL_MODELVIEW17_ARB:
+        case GL_MODELVIEW18_ARB:
+        case GL_MODELVIEW19_ARB:
+        case GL_MODELVIEW20_ARB:
+        case GL_MODELVIEW21_ARB:
+        case GL_MODELVIEW22_ARB:
+        case GL_MODELVIEW23_ARB:
+        case GL_MODELVIEW24_ARB:
+        case GL_MODELVIEW25_ARB:
+        case GL_MODELVIEW26_ARB:
+        case GL_MODELVIEW27_ARB:
+        case GL_MODELVIEW28_ARB:
+        case GL_MODELVIEW29_ARB:
+        case GL_MODELVIEW30_ARB:
+        case GL_MODELVIEW31_ARB:
+        case GL_TRANSPOSE_CURRENT_MATRIX_ARB:
+            return 16;
+        case GL_FOG_COORDINATE_SOURCE:
+        case GL_COMPRESSED_TEXTURE_FORMATS:
+        case GL_MIN_PROGRAM_TEXEL_OFFSET:
+        case GL_MAX_PROGRAM_TEXEL_OFFSET:
+        case GL_RGBA_INTEGER_MODE_EXT:
+            return __glGetBooleanv_variable_size( e );
+        default: return 0;
+    }
+}
+
+_X_INTERNAL PURE FASTCALL GLint
+__glGetTexParameterfv_size( GLenum e )
+{
+    switch( e ) {
+        case GL_TEXTURE_MAG_FILTER:
+        case GL_TEXTURE_MIN_FILTER:
+        case GL_TEXTURE_WRAP_S:
+        case GL_TEXTURE_WRAP_T:
+        case GL_TEXTURE_PRIORITY:
+        case GL_TEXTURE_RESIDENT:
+        case GL_TEXTURE_WRAP_R:
+        case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
+/*      case GL_SHADOW_AMBIENT_SGIX:*/
+        case GL_TEXTURE_MIN_LOD:
+        case GL_TEXTURE_MAX_LOD:
+        case GL_TEXTURE_BASE_LEVEL:
+        case GL_TEXTURE_MAX_LEVEL:
+        case GL_TEXTURE_CLIPMAP_FRAME_SGIX:
+        case GL_TEXTURE_LOD_BIAS_S_SGIX:
+        case GL_TEXTURE_LOD_BIAS_T_SGIX:
+        case GL_TEXTURE_LOD_BIAS_R_SGIX:
+        case GL_GENERATE_MIPMAP:
+/*      case GL_GENERATE_MIPMAP_SGIS:*/
+        case GL_TEXTURE_COMPARE_SGIX:
+        case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
+        case GL_TEXTURE_MAX_CLAMP_S_SGIX:
+        case GL_TEXTURE_MAX_CLAMP_T_SGIX:
+        case GL_TEXTURE_MAX_CLAMP_R_SGIX:
+        case GL_TEXTURE_MAX_ANISOTROPY_EXT:
+        case GL_TEXTURE_LOD_BIAS:
+/*      case GL_TEXTURE_LOD_BIAS_EXT:*/
+        case GL_TEXTURE_RANGE_LENGTH_APPLE:
+        case GL_TEXTURE_STORAGE_HINT_APPLE:
+        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;
+    }
+}
+
+_X_INTERNAL PURE FASTCALL GLint
+__glGetTexLevelParameterfv_size( GLenum e )
+{
+    switch( e ) {
+        case GL_TEXTURE_WIDTH:
+        case GL_TEXTURE_HEIGHT:
+        case GL_TEXTURE_COMPONENTS:
+        case GL_TEXTURE_BORDER:
+        case GL_TEXTURE_RED_SIZE:
+/*      case GL_TEXTURE_RED_SIZE_EXT:*/
+        case GL_TEXTURE_GREEN_SIZE:
+/*      case GL_TEXTURE_GREEN_SIZE_EXT:*/
+        case GL_TEXTURE_BLUE_SIZE:
+/*      case GL_TEXTURE_BLUE_SIZE_EXT:*/
+        case GL_TEXTURE_ALPHA_SIZE:
+/*      case GL_TEXTURE_ALPHA_SIZE_EXT:*/
+        case GL_TEXTURE_LUMINANCE_SIZE:
+/*      case GL_TEXTURE_LUMINANCE_SIZE_EXT:*/
+        case GL_TEXTURE_INTENSITY_SIZE:
+/*      case GL_TEXTURE_INTENSITY_SIZE_EXT:*/
+        case GL_TEXTURE_DEPTH:
+        case GL_TEXTURE_INDEX_SIZE_EXT:
+        case GL_TEXTURE_COMPRESSED_IMAGE_SIZE:
+/*      case GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB:*/
+        case GL_TEXTURE_COMPRESSED:
+/*      case GL_TEXTURE_COMPRESSED_ARB:*/
+        case GL_TEXTURE_DEPTH_SIZE:
+/*      case GL_TEXTURE_DEPTH_SIZE_ARB:*/
+        case GL_TEXTURE_STENCIL_SIZE:
+/*      case GL_TEXTURE_STENCIL_SIZE_EXT:*/
+            return 1;
+        default: return 0;
+    }
+}
+
+_X_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;
+    }
+}
+
+_X_INTERNAL PURE FASTCALL GLint
+__glGetColorTableParameterfv_size( GLenum e )
+{
+    switch( e ) {
+        case GL_COLOR_TABLE_FORMAT:
+/*      case GL_COLOR_TABLE_FORMAT_EXT:*/
+        case GL_COLOR_TABLE_WIDTH:
+/*      case GL_COLOR_TABLE_WIDTH_EXT:*/
+        case GL_COLOR_TABLE_RED_SIZE:
+/*      case GL_COLOR_TABLE_RED_SIZE_EXT:*/
+        case GL_COLOR_TABLE_GREEN_SIZE:
+/*      case GL_COLOR_TABLE_GREEN_SIZE_EXT:*/
+        case GL_COLOR_TABLE_BLUE_SIZE:
+/*      case GL_COLOR_TABLE_BLUE_SIZE_EXT:*/
+        case GL_COLOR_TABLE_ALPHA_SIZE:
+/*      case GL_COLOR_TABLE_ALPHA_SIZE_EXT:*/
+        case GL_COLOR_TABLE_LUMINANCE_SIZE:
+/*      case GL_COLOR_TABLE_LUMINANCE_SIZE_EXT:*/
+        case GL_COLOR_TABLE_INTENSITY_SIZE:
+/*      case GL_COLOR_TABLE_INTENSITY_SIZE_EXT:*/
+            return 1;
+        case GL_COLOR_TABLE_SCALE:
+        case GL_COLOR_TABLE_BIAS:
+            return 4;
+        default: return 0;
+    }
+}
+
+_X_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;
+    }
+}
+
+_X_INTERNAL PURE FASTCALL GLint
+__glGetConvolutionParameterfv_size( GLenum e )
+{
+    switch( e ) {
+        case GL_CONVOLUTION_BORDER_MODE:
+/*      case GL_CONVOLUTION_BORDER_MODE_EXT:*/
+        case GL_CONVOLUTION_FORMAT:
+/*      case GL_CONVOLUTION_FORMAT_EXT:*/
+        case GL_CONVOLUTION_WIDTH:
+/*      case GL_CONVOLUTION_WIDTH_EXT:*/
+        case GL_CONVOLUTION_HEIGHT:
+/*      case GL_CONVOLUTION_HEIGHT_EXT:*/
+        case GL_MAX_CONVOLUTION_WIDTH:
+/*      case GL_MAX_CONVOLUTION_WIDTH_EXT:*/
+        case GL_MAX_CONVOLUTION_HEIGHT:
+/*      case GL_MAX_CONVOLUTION_HEIGHT_EXT:*/
+            return 1;
+        case GL_CONVOLUTION_FILTER_SCALE:
+/*      case GL_CONVOLUTION_FILTER_SCALE_EXT:*/
+        case GL_CONVOLUTION_FILTER_BIAS:
+/*      case GL_CONVOLUTION_FILTER_BIAS_EXT:*/
+        case GL_CONVOLUTION_BORDER_COLOR:
+/*      case GL_CONVOLUTION_BORDER_COLOR_HP:*/
+            return 4;
+        default: return 0;
+    }
+}
+
+_X_INTERNAL PURE FASTCALL GLint
+__glGetHistogramParameterfv_size( GLenum e )
+{
+    switch( e ) {
+        case GL_HISTOGRAM_WIDTH:
+        case GL_HISTOGRAM_FORMAT:
+        case GL_HISTOGRAM_RED_SIZE:
+        case GL_HISTOGRAM_GREEN_SIZE:
+        case GL_HISTOGRAM_BLUE_SIZE:
+        case GL_HISTOGRAM_ALPHA_SIZE:
+        case GL_HISTOGRAM_LUMINANCE_SIZE:
+        case GL_HISTOGRAM_SINK:
+            return 1;
+        default: return 0;
+    }
+}
+
+_X_INTERNAL PURE FASTCALL GLint
+__glGetMinmaxParameterfv_size( GLenum e )
+{
+    switch( e ) {
+        case GL_MINMAX_FORMAT:
+        case GL_MINMAX_SINK:
+            return 1;
+        default: return 0;
+    }
+}
+
+_X_INTERNAL PURE FASTCALL GLint
+__glGetProgramivARB_size( GLenum e )
+{
+    switch( e ) {
+        case GL_PROGRAM_LENGTH_ARB:
+        case GL_PROGRAM_BINDING_ARB:
+        case GL_PROGRAM_ALU_INSTRUCTIONS_ARB:
+        case GL_PROGRAM_TEX_INSTRUCTIONS_ARB:
+        case GL_PROGRAM_TEX_INDIRECTIONS_ARB:
+        case GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB:
+        case GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB:
+        case GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB:
+        case GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB:
+        case GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB:
+        case GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB:
+        case GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB:
+        case GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB:
+        case GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB:
+        case GL_PROGRAM_FORMAT_ARB:
+        case GL_PROGRAM_INSTRUCTIONS_ARB:
+        case GL_MAX_PROGRAM_INSTRUCTIONS_ARB:
+        case GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB:
+        case GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB:
+        case GL_PROGRAM_TEMPORARIES_ARB:
+        case GL_MAX_PROGRAM_TEMPORARIES_ARB:
+        case GL_PROGRAM_NATIVE_TEMPORARIES_ARB:
+        case GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB:
+        case GL_PROGRAM_PARAMETERS_ARB:
+        case GL_MAX_PROGRAM_PARAMETERS_ARB:
+        case GL_PROGRAM_NATIVE_PARAMETERS_ARB:
+        case GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB:
+        case GL_PROGRAM_ATTRIBS_ARB:
+        case GL_MAX_PROGRAM_ATTRIBS_ARB:
+        case GL_PROGRAM_NATIVE_ATTRIBS_ARB:
+        case GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB:
+        case GL_PROGRAM_ADDRESS_REGISTERS_ARB:
+        case GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB:
+        case GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB:
+        case GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB:
+        case GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB:
+        case GL_MAX_PROGRAM_ENV_PARAMETERS_ARB:
+        case GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB:
+        case GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV:
+        case GL_MAX_PROGRAM_CALL_DEPTH_NV:
+        case GL_MAX_PROGRAM_IF_DEPTH_NV:
+        case GL_MAX_PROGRAM_LOOP_DEPTH_NV:
+        case GL_MAX_PROGRAM_LOOP_COUNT_NV:
+            return 1;
+        default: return 0;
+    }
+}
+
+_X_INTERNAL PURE FASTCALL GLint
+__glGetVertexAttribdvARB_size( GLenum e )
+{
+    switch( e ) {
+        case GL_VERTEX_PROGRAM_ARB:
+        case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB:
+        case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB:
+        case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB:
+        case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB:
+        case GL_CURRENT_VERTEX_ATTRIB_ARB:
+        case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB:
+            return 1;
+        default: return 0;
+    }
+}
+
+_X_INTERNAL PURE FASTCALL GLint
+__glGetQueryObjectivARB_size( GLenum e )
+{
+    switch( e ) {
+        case GL_QUERY_RESULT_ARB:
+        case GL_QUERY_RESULT_AVAILABLE_ARB:
+            return 1;
+        default: return 0;
+    }
+}
+
+_X_INTERNAL PURE FASTCALL GLint
+__glGetQueryivARB_size( GLenum e )
+{
+    switch( e ) {
+        case GL_QUERY_COUNTER_BITS_ARB:
+        case GL_CURRENT_QUERY_ARB:
+            return 1;
+        default: return 0;
+    }
+}
+
+_X_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;
+    }
+}
+
+_X_INTERNAL PURE FASTCALL GLint
+__glGetProgramivNV_size( GLenum e )
+{
+    switch( e ) {
+        case GL_PROGRAM_LENGTH_NV:
+        case GL_PROGRAM_TARGET_NV:
+        case GL_PROGRAM_RESIDENT_NV:
+            return 1;
+        default: return 0;
+    }
+}
+
+_X_INTERNAL PURE FASTCALL GLint
+__glGetVertexAttribdvNV_size( GLenum e )
+{
+    switch( e ) {
+        case GL_ATTRIB_ARRAY_SIZE_NV:
+        case GL_ATTRIB_ARRAY_STRIDE_NV:
+        case GL_ATTRIB_ARRAY_TYPE_NV:
+        case GL_CURRENT_ATTRIB_NV:
+            return 1;
+        default: return 0;
+    }
+}
+
+_X_INTERNAL PURE FASTCALL GLint
+__glGetFramebufferAttachmentParameterivEXT_size( GLenum e )
+{
+    switch( e ) {
+        case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT:
+        case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT:
+        case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT:
+        case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT:
+        case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT:
+            return 1;
+        default: return 0;
+    }
+}
+
+ALIAS( Fogiv, Fogfv )
+ALIAS( Lightiv, Lightfv )
+ALIAS( LightModeliv, LightModelfv )
+ALIAS( Materialiv, Materialfv )
+ALIAS( TexParameteriv, TexParameterfv )
+ALIAS( TexEnviv, TexEnvfv )
+ALIAS( TexGenfv, TexGendv )
+ALIAS( TexGeniv, TexGendv )
+ALIAS( Map1f, Map1d )
+ALIAS( Map2f, Map2d )
+ALIAS( GetDoublev, GetBooleanv )
+ALIAS( GetFloatv, GetBooleanv )
+ALIAS( GetIntegerv, GetBooleanv )
+ALIAS( GetLightfv, Lightfv )
+ALIAS( GetLightiv, Lightfv )
+ALIAS( GetMaterialfv, Materialfv )
+ALIAS( GetMaterialiv, Materialfv )
+ALIAS( GetTexEnvfv, TexEnvfv )
+ALIAS( GetTexEnviv, TexEnvfv )
+ALIAS( GetTexGendv, TexGendv )
+ALIAS( GetTexGenfv, TexGendv )
+ALIAS( GetTexGeniv, TexGendv )
+ALIAS( GetTexParameteriv, GetTexParameterfv )
+ALIAS( GetTexLevelParameteriv, GetTexLevelParameterfv )
+ALIAS( ColorTableParameteriv, ColorTableParameterfv )
+ALIAS( GetColorTableParameteriv, GetColorTableParameterfv )
+ALIAS( ConvolutionParameteriv, ConvolutionParameterfv )
+ALIAS( GetConvolutionParameteriv, GetConvolutionParameterfv )
+ALIAS( GetHistogramParameteriv, GetHistogramParameterfv )
+ALIAS( GetMinmaxParameteriv, GetMinmaxParameterfv )
+ALIAS( GetVertexAttribfvARB, GetVertexAttribdvARB )
+ALIAS( GetVertexAttribivARB, GetVertexAttribdvARB )
+ALIAS( GetQueryObjectuivARB, GetQueryObjectivARB )
+ALIAS( GetVertexAttribfvNV, GetVertexAttribdvNV )
+ALIAS( GetVertexAttribivNV, GetVertexAttribdvNV )
+ALIAS( PointParameterivNV, PointParameterfvEXT )
+
+#  undef PURE
+#  undef FASTCALL
diff --git a/xorg-server/glx/indirect_size_get.h b/xorg-server/glx/indirect_size_get.h
index f1396c262..2ab8cedca 100644
--- a/xorg-server/glx/indirect_size_get.h
+++ b/xorg-server/glx/indirect_size_get.h
@@ -1,120 +1,120 @@
-/* DO NOT EDIT - This file generated automatically by glX_proto_size.py (from Mesa) script */

-

-/*

- * (C) Copyright IBM Corporation 2004

- * All Rights Reserved.

- * 

- * Permission is hereby granted, free of charge, to any person obtaining a

- * copy of this software and associated documentation files (the "Software"),

- * to deal in the Software without restriction, including without limitation

- * the rights to use, copy, modify, merge, publish, distribute, sub license,

- * and/or sell copies of the Software, and to permit persons to whom the

- * Software is furnished to do so, subject to the following conditions:

- * 

- * The above copyright notice and this permission notice (including the next

- * paragraph) shall be included in all copies or substantial portions of the

- * Software.

- * 

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL

- * IBM,

- * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

- * SOFTWARE.

- */

-

-#if !defined( _INDIRECT_SIZE_GET_H_ )

-#  define _INDIRECT_SIZE_GET_H_

-

-/**

- * \file

- * Prototypes for functions used to determine the number of data elements in

- * various GLX protocol messages.

- *

- * \author Ian Romanick <idr@us.ibm.com>

- */

-

-#include <X11/Xfuncproto.h>

-

-#  if defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590))

-#    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

-

-extern _X_INTERNAL PURE FASTCALL GLint __glCallLists_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glFogfv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glFogiv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glLightfv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glLightiv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glLightModelfv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glLightModeliv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glMaterialfv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glMaterialiv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glTexParameterfv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glTexParameteriv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glTexEnvfv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glTexEnviv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glTexGendv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glTexGenfv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glTexGeniv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glMap1d_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glMap1f_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glMap2d_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glMap2f_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetBooleanv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetDoublev_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetFloatv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetIntegerv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetLightfv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetLightiv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetMaterialfv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetMaterialiv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetTexEnvfv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetTexEnviv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetTexGendv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetTexGenfv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetTexGeniv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetTexParameterfv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetTexParameteriv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetTexLevelParameterfv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetTexLevelParameteriv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glColorTableParameterfv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glColorTableParameteriv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetColorTableParameterfv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetColorTableParameteriv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glConvolutionParameterfv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glConvolutionParameteriv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetConvolutionParameterfv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetConvolutionParameteriv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetHistogramParameterfv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetHistogramParameteriv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetMinmaxParameterfv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetMinmaxParameteriv_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetProgramivARB_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetVertexAttribdvARB_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetVertexAttribfvARB_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetVertexAttribivARB_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetQueryObjectivARB_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetQueryObjectuivARB_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetQueryivARB_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glPointParameterfvEXT_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetProgramivNV_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetVertexAttribdvNV_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetVertexAttribfvNV_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetVertexAttribivNV_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glPointParameterivNV_size(GLenum);

-extern _X_INTERNAL PURE FASTCALL GLint __glGetFramebufferAttachmentParameterivEXT_size(GLenum);

-

-#  undef PURE

-#  undef FASTCALL

-

-#endif /* !defined( _INDIRECT_SIZE_GET_H_ ) */

+/* DO NOT EDIT - This file generated automatically by glX_proto_size.py (from Mesa) script */
+
+/*
+ * (C) Copyright IBM Corporation 2004
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * IBM,
+ * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#if !defined( _INDIRECT_SIZE_GET_H_ )
+#  define _INDIRECT_SIZE_GET_H_
+
+/**
+ * \file
+ * Prototypes for functions used to determine the number of data elements in
+ * various GLX protocol messages.
+ *
+ * \author Ian Romanick <idr@us.ibm.com>
+ */
+
+#include <X11/Xfuncproto.h>
+
+#  if defined(__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590))
+#    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
+
+extern _X_INTERNAL PURE FASTCALL GLint __glCallLists_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glFogfv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glFogiv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glLightfv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glLightiv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glLightModelfv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glLightModeliv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glMaterialfv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glMaterialiv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glTexParameterfv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glTexParameteriv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glTexEnvfv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glTexEnviv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glTexGendv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glTexGenfv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glTexGeniv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glMap1d_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glMap1f_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glMap2d_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glMap2f_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetBooleanv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetDoublev_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetFloatv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetIntegerv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetLightfv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetLightiv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetMaterialfv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetMaterialiv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetTexEnvfv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetTexEnviv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetTexGendv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetTexGenfv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetTexGeniv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetTexParameterfv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetTexParameteriv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetTexLevelParameterfv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetTexLevelParameteriv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glColorTableParameterfv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glColorTableParameteriv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetColorTableParameterfv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetColorTableParameteriv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glConvolutionParameterfv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glConvolutionParameteriv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetConvolutionParameterfv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetConvolutionParameteriv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetHistogramParameterfv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetHistogramParameteriv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetMinmaxParameterfv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetMinmaxParameteriv_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetProgramivARB_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetVertexAttribdvARB_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetVertexAttribfvARB_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetVertexAttribivARB_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetQueryObjectivARB_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetQueryObjectuivARB_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetQueryivARB_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glPointParameterfvEXT_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetProgramivNV_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetVertexAttribdvNV_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetVertexAttribfvNV_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetVertexAttribivNV_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glPointParameterivNV_size(GLenum);
+extern _X_INTERNAL PURE FASTCALL GLint __glGetFramebufferAttachmentParameterivEXT_size(GLenum);
+
+#  undef PURE
+#  undef FASTCALL
+
+#endif /* !defined( _INDIRECT_SIZE_GET_H_ ) */
diff --git a/xorg-server/glx/indirect_table.c b/xorg-server/glx/indirect_table.c
index 746075655..6b2c6304c 100644
--- a/xorg-server/glx/indirect_table.c
+++ b/xorg-server/glx/indirect_table.c
@@ -1,1610 +1,1610 @@
-/* DO NOT EDIT - This file generated automatically by glX_server_table.py (from Mesa) script */

-

-/*

- * (C) Copyright IBM Corporation 2005, 2006

- * All Rights Reserved.

- * 

- * Permission is hereby granted, free of charge, to any person obtaining a

- * copy of this software and associated documentation files (the "Software"),

- * to deal in the Software without restriction, including without limitation

- * the rights to use, copy, modify, merge, publish, distribute, sub license,

- * and/or sell copies of the Software, and to permit persons to whom the

- * Software is furnished to do so, subject to the following conditions:

- * 

- * The above copyright notice and this permission notice (including the next

- * paragraph) shall be included in all copies or substantial portions of the

- * Software.

- * 

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL

- * IBM,

- * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF

- * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

- * SOFTWARE.

- */

-

-#ifndef HAVE_DIX_CONFIG_H

-#include "glheader.h"

-#endif

-

-#include <inttypes.h>

-#include "glxserver.h"

-#include "glxext.h"

-#include "indirect_dispatch.h"

-#include "indirect_reqsize.h"

-#include "indirect_table.h"

-

-/*****************************************************************/

-/* tree depth = 3 */

-static const int_fast16_t Single_dispatch_tree[24] = {

-    /* [0] -> opcode range [0, 256], node depth 1 */

-    2,

-    5,

-    13,

-    16,

-    EMPTY_LEAF,

-

-    /* [5] -> opcode range [0, 64], node depth 2 */

-    2,

-    LEAF(0),

-    LEAF(16),

-    10,

-    EMPTY_LEAF,

-

-    /* [10] -> opcode range [32, 48], node depth 3 */

-    1,

-    LEAF(32),

-    EMPTY_LEAF,

-

-    /* [13] -> opcode range [64, 128], node depth 2 */

-    1,

-    EMPTY_LEAF,

-    LEAF(40),

-

-    /* [16] -> opcode range [128, 192], node depth 2 */

-    2,

-    LEAF(72),

-    LEAF(88),

-    21,

-    EMPTY_LEAF,

-

-    /* [21] -> opcode range [160, 176], node depth 3 */

-    1,

-    LEAF(104),

-    EMPTY_LEAF,

-

-};

-

-static const void *Single_function_table[112][2] = {

-    /* [  0] =     0 */ {NULL, NULL},

-    /* [  1] =     1 */ {__glXDisp_Render, __glXDispSwap_Render},

-    /* [  2] =     2 */ {__glXDisp_RenderLarge, __glXDispSwap_RenderLarge},

-    /* [  3] =     3 */ {__glXDisp_CreateContext, __glXDispSwap_CreateContext},

-    /* [  4] =     4 */ {__glXDisp_DestroyContext, __glXDispSwap_DestroyContext},

-    /* [  5] =     5 */ {__glXDisp_MakeCurrent, __glXDispSwap_MakeCurrent},

-    /* [  6] =     6 */ {__glXDisp_IsDirect, __glXDispSwap_IsDirect},

-    /* [  7] =     7 */ {__glXDisp_QueryVersion, __glXDispSwap_QueryVersion},

-    /* [  8] =     8 */ {__glXDisp_WaitGL, __glXDispSwap_WaitGL},

-    /* [  9] =     9 */ {__glXDisp_WaitX, __glXDispSwap_WaitX},

-    /* [ 10] =    10 */ {__glXDisp_CopyContext, __glXDispSwap_CopyContext},

-    /* [ 11] =    11 */ {__glXDisp_SwapBuffers, __glXDispSwap_SwapBuffers},

-    /* [ 12] =    12 */ {__glXDisp_UseXFont, __glXDispSwap_UseXFont},

-    /* [ 13] =    13 */ {__glXDisp_CreateGLXPixmap, __glXDispSwap_CreateGLXPixmap},

-    /* [ 14] =    14 */ {__glXDisp_GetVisualConfigs, __glXDispSwap_GetVisualConfigs},

-    /* [ 15] =    15 */ {__glXDisp_DestroyGLXPixmap, __glXDispSwap_DestroyGLXPixmap},

-    /* [ 16] =    16 */ {__glXDisp_VendorPrivate, __glXDispSwap_VendorPrivate},

-    /* [ 17] =    17 */ {__glXDisp_VendorPrivateWithReply, __glXDispSwap_VendorPrivateWithReply},

-    /* [ 18] =    18 */ {__glXDisp_QueryExtensionsString, __glXDispSwap_QueryExtensionsString},

-    /* [ 19] =    19 */ {__glXDisp_QueryServerString, __glXDispSwap_QueryServerString},

-    /* [ 20] =    20 */ {__glXDisp_ClientInfo, __glXDispSwap_ClientInfo},

-    /* [ 21] =    21 */ {__glXDisp_GetFBConfigs, __glXDispSwap_GetFBConfigs},

-    /* [ 22] =    22 */ {__glXDisp_CreatePixmap, __glXDispSwap_CreatePixmap},

-    /* [ 23] =    23 */ {__glXDisp_DestroyPixmap, __glXDispSwap_DestroyPixmap},

-    /* [ 24] =    24 */ {__glXDisp_CreateNewContext, __glXDispSwap_CreateNewContext},

-    /* [ 25] =    25 */ {__glXDisp_QueryContext, __glXDispSwap_QueryContext},

-    /* [ 26] =    26 */ {__glXDisp_MakeContextCurrent, __glXDispSwap_MakeContextCurrent},

-    /* [ 27] =    27 */ {__glXDisp_CreatePbuffer, __glXDispSwap_CreatePbuffer},

-    /* [ 28] =    28 */ {__glXDisp_DestroyPbuffer, __glXDispSwap_DestroyPbuffer},

-    /* [ 29] =    29 */ {__glXDisp_GetDrawableAttributes, __glXDispSwap_GetDrawableAttributes},

-    /* [ 30] =    30 */ {__glXDisp_ChangeDrawableAttributes, __glXDispSwap_ChangeDrawableAttributes},

-    /* [ 31] =    31 */ {__glXDisp_CreateWindow, __glXDispSwap_CreateWindow},

-    /* [ 32] =    32 */ {__glXDisp_DestroyWindow, __glXDispSwap_DestroyWindow},

-    /* [ 33] =    33 */ {NULL, NULL},

-    /* [ 34] =    34 */ {NULL, NULL},

-    /* [ 35] =    35 */ {NULL, NULL},

-    /* [ 36] =    36 */ {NULL, NULL},

-    /* [ 37] =    37 */ {NULL, NULL},

-    /* [ 38] =    38 */ {NULL, NULL},

-    /* [ 39] =    39 */ {NULL, NULL},

-    /* [ 40] =    96 */ {NULL, NULL},

-    /* [ 41] =    97 */ {NULL, NULL},

-    /* [ 42] =    98 */ {NULL, NULL},

-    /* [ 43] =    99 */ {NULL, NULL},

-    /* [ 44] =   100 */ {NULL, NULL},

-    /* [ 45] =   101 */ {__glXDisp_NewList, __glXDispSwap_NewList},

-    /* [ 46] =   102 */ {__glXDisp_EndList, __glXDispSwap_EndList},

-    /* [ 47] =   103 */ {__glXDisp_DeleteLists, __glXDispSwap_DeleteLists},

-    /* [ 48] =   104 */ {__glXDisp_GenLists, __glXDispSwap_GenLists},

-    /* [ 49] =   105 */ {__glXDisp_FeedbackBuffer, __glXDispSwap_FeedbackBuffer},

-    /* [ 50] =   106 */ {__glXDisp_SelectBuffer, __glXDispSwap_SelectBuffer},

-    /* [ 51] =   107 */ {__glXDisp_RenderMode, __glXDispSwap_RenderMode},

-    /* [ 52] =   108 */ {__glXDisp_Finish, __glXDispSwap_Finish},

-    /* [ 53] =   109 */ {__glXDisp_PixelStoref, __glXDispSwap_PixelStoref},

-    /* [ 54] =   110 */ {__glXDisp_PixelStorei, __glXDispSwap_PixelStorei},

-    /* [ 55] =   111 */ {__glXDisp_ReadPixels, __glXDispSwap_ReadPixels},

-    /* [ 56] =   112 */ {__glXDisp_GetBooleanv, __glXDispSwap_GetBooleanv},

-    /* [ 57] =   113 */ {__glXDisp_GetClipPlane, __glXDispSwap_GetClipPlane},

-    /* [ 58] =   114 */ {__glXDisp_GetDoublev, __glXDispSwap_GetDoublev},

-    /* [ 59] =   115 */ {__glXDisp_GetError, __glXDispSwap_GetError},

-    /* [ 60] =   116 */ {__glXDisp_GetFloatv, __glXDispSwap_GetFloatv},

-    /* [ 61] =   117 */ {__glXDisp_GetIntegerv, __glXDispSwap_GetIntegerv},

-    /* [ 62] =   118 */ {__glXDisp_GetLightfv, __glXDispSwap_GetLightfv},

-    /* [ 63] =   119 */ {__glXDisp_GetLightiv, __glXDispSwap_GetLightiv},

-    /* [ 64] =   120 */ {__glXDisp_GetMapdv, __glXDispSwap_GetMapdv},

-    /* [ 65] =   121 */ {__glXDisp_GetMapfv, __glXDispSwap_GetMapfv},

-    /* [ 66] =   122 */ {__glXDisp_GetMapiv, __glXDispSwap_GetMapiv},

-    /* [ 67] =   123 */ {__glXDisp_GetMaterialfv, __glXDispSwap_GetMaterialfv},

-    /* [ 68] =   124 */ {__glXDisp_GetMaterialiv, __glXDispSwap_GetMaterialiv},

-    /* [ 69] =   125 */ {__glXDisp_GetPixelMapfv, __glXDispSwap_GetPixelMapfv},

-    /* [ 70] =   126 */ {__glXDisp_GetPixelMapuiv, __glXDispSwap_GetPixelMapuiv},

-    /* [ 71] =   127 */ {__glXDisp_GetPixelMapusv, __glXDispSwap_GetPixelMapusv},

-    /* [ 72] =   128 */ {__glXDisp_GetPolygonStipple, __glXDispSwap_GetPolygonStipple},

-    /* [ 73] =   129 */ {__glXDisp_GetString, __glXDispSwap_GetString},

-    /* [ 74] =   130 */ {__glXDisp_GetTexEnvfv, __glXDispSwap_GetTexEnvfv},

-    /* [ 75] =   131 */ {__glXDisp_GetTexEnviv, __glXDispSwap_GetTexEnviv},

-    /* [ 76] =   132 */ {__glXDisp_GetTexGendv, __glXDispSwap_GetTexGendv},

-    /* [ 77] =   133 */ {__glXDisp_GetTexGenfv, __glXDispSwap_GetTexGenfv},

-    /* [ 78] =   134 */ {__glXDisp_GetTexGeniv, __glXDispSwap_GetTexGeniv},

-    /* [ 79] =   135 */ {__glXDisp_GetTexImage, __glXDispSwap_GetTexImage},

-    /* [ 80] =   136 */ {__glXDisp_GetTexParameterfv, __glXDispSwap_GetTexParameterfv},

-    /* [ 81] =   137 */ {__glXDisp_GetTexParameteriv, __glXDispSwap_GetTexParameteriv},

-    /* [ 82] =   138 */ {__glXDisp_GetTexLevelParameterfv, __glXDispSwap_GetTexLevelParameterfv},

-    /* [ 83] =   139 */ {__glXDisp_GetTexLevelParameteriv, __glXDispSwap_GetTexLevelParameteriv},

-    /* [ 84] =   140 */ {__glXDisp_IsEnabled, __glXDispSwap_IsEnabled},

-    /* [ 85] =   141 */ {__glXDisp_IsList, __glXDispSwap_IsList},

-    /* [ 86] =   142 */ {__glXDisp_Flush, __glXDispSwap_Flush},

-    /* [ 87] =   143 */ {__glXDisp_AreTexturesResident, __glXDispSwap_AreTexturesResident},

-    /* [ 88] =   144 */ {__glXDisp_DeleteTextures, __glXDispSwap_DeleteTextures},

-    /* [ 89] =   145 */ {__glXDisp_GenTextures, __glXDispSwap_GenTextures},

-    /* [ 90] =   146 */ {__glXDisp_IsTexture, __glXDispSwap_IsTexture},

-    /* [ 91] =   147 */ {__glXDisp_GetColorTable, __glXDispSwap_GetColorTable},

-    /* [ 92] =   148 */ {__glXDisp_GetColorTableParameterfv, __glXDispSwap_GetColorTableParameterfv},

-    /* [ 93] =   149 */ {__glXDisp_GetColorTableParameteriv, __glXDispSwap_GetColorTableParameteriv},

-    /* [ 94] =   150 */ {__glXDisp_GetConvolutionFilter, __glXDispSwap_GetConvolutionFilter},

-    /* [ 95] =   151 */ {__glXDisp_GetConvolutionParameterfv, __glXDispSwap_GetConvolutionParameterfv},

-    /* [ 96] =   152 */ {__glXDisp_GetConvolutionParameteriv, __glXDispSwap_GetConvolutionParameteriv},

-    /* [ 97] =   153 */ {__glXDisp_GetSeparableFilter, __glXDispSwap_GetSeparableFilter},

-    /* [ 98] =   154 */ {__glXDisp_GetHistogram, __glXDispSwap_GetHistogram},

-    /* [ 99] =   155 */ {__glXDisp_GetHistogramParameterfv, __glXDispSwap_GetHistogramParameterfv},

-    /* [ 100] =   156 */ {__glXDisp_GetHistogramParameteriv, __glXDispSwap_GetHistogramParameteriv},

-    /* [ 101] =   157 */ {__glXDisp_GetMinmax, __glXDispSwap_GetMinmax},

-    /* [ 102] =   158 */ {__glXDisp_GetMinmaxParameterfv, __glXDispSwap_GetMinmaxParameterfv},

-    /* [ 103] =   159 */ {__glXDisp_GetMinmaxParameteriv, __glXDispSwap_GetMinmaxParameteriv},

-    /* [ 104] =   160 */ {__glXDisp_GetCompressedTexImageARB, __glXDispSwap_GetCompressedTexImageARB},

-    /* [ 105] =   161 */ {__glXDisp_DeleteQueriesARB, __glXDispSwap_DeleteQueriesARB},

-    /* [ 106] =   162 */ {__glXDisp_GenQueriesARB, __glXDispSwap_GenQueriesARB},

-    /* [ 107] =   163 */ {__glXDisp_IsQueryARB, __glXDispSwap_IsQueryARB},

-    /* [ 108] =   164 */ {__glXDisp_GetQueryivARB, __glXDispSwap_GetQueryivARB},

-    /* [ 109] =   165 */ {__glXDisp_GetQueryObjectivARB, __glXDispSwap_GetQueryObjectivARB},

-    /* [ 110] =   166 */ {__glXDisp_GetQueryObjectuivARB, __glXDispSwap_GetQueryObjectuivARB},

-    /* [ 111] =   167 */ {NULL, NULL},

-};

-

-const struct __glXDispatchInfo Single_dispatch_info = {

-    8,

-    Single_dispatch_tree,

-    Single_function_table,

-    NULL,

-    NULL

-};

-

-/*****************************************************************/

-/* tree depth = 8 */

-static const int_fast16_t Render_dispatch_tree[92] = {

-    /* [0] -> opcode range [0, 8192], node depth 1 */

-    2,

-    5,

-    31,

-    54,

-    EMPTY_LEAF,

-

-    /* [5] -> opcode range [0, 2048], node depth 2 */

-    1,

-    8,

-    EMPTY_LEAF,

-

-    /* [8] -> opcode range [0, 1024], node depth 3 */

-    1,

-    11,

-    EMPTY_LEAF,

-

-    /* [11] -> opcode range [0, 512], node depth 4 */

-    1,

-    14,

-    EMPTY_LEAF,

-

-    /* [14] -> opcode range [0, 256], node depth 5 */

-    4,

-    LEAF(0),

-    LEAF(16),

-    LEAF(32),

-    LEAF(48),

-    LEAF(64),

-    LEAF(80),

-    LEAF(96),

-    LEAF(112),

-    LEAF(128),

-    LEAF(144),

-    LEAF(160),

-    LEAF(176),

-    LEAF(192),

-    LEAF(208),

-    LEAF(224),

-    EMPTY_LEAF,

-

-    /* [31] -> opcode range [2048, 4096], node depth 2 */

-    1,

-    34,

-    EMPTY_LEAF,

-

-    /* [34] -> opcode range [2048, 3072], node depth 3 */

-    1,

-    37,

-    EMPTY_LEAF,

-

-    /* [37] -> opcode range [2048, 2560], node depth 4 */

-    1,

-    40,

-    EMPTY_LEAF,

-

-    /* [40] -> opcode range [2048, 2304], node depth 5 */

-    1,

-    43,

-    EMPTY_LEAF,

-

-    /* [43] -> opcode range [2048, 2176], node depth 6 */

-    1,

-    46,

-    EMPTY_LEAF,

-

-    /* [46] -> opcode range [2048, 2112], node depth 7 */

-    1,

-    49,

-    EMPTY_LEAF,

-

-    /* [49] -> opcode range [2048, 2080], node depth 8 */

-    2,

-    LEAF(240),

-    LEAF(248),

-    LEAF(256),

-    EMPTY_LEAF,

-

-    /* [54] -> opcode range [4096, 6144], node depth 2 */

-    1,

-    57,

-    EMPTY_LEAF,

-

-    /* [57] -> opcode range [4096, 5120], node depth 3 */

-    1,

-    60,

-    EMPTY_LEAF,

-

-    /* [60] -> opcode range [4096, 4608], node depth 4 */

-    1,

-    63,

-    EMPTY_LEAF,

-

-    /* [63] -> opcode range [4096, 4352], node depth 5 */

-    4,

-    LEAF(264),

-    LEAF(280),

-    80,

-    EMPTY_LEAF,

-    EMPTY_LEAF,

-    LEAF(296),

-    LEAF(312),

-    LEAF(328),

-    LEAF(344),

-    EMPTY_LEAF,

-    83,

-    86,

-    EMPTY_LEAF,

-    89,

-    LEAF(360),

-    EMPTY_LEAF,

-

-    /* [80] -> opcode range [4128, 4144], node depth 6 */

-    1,

-    LEAF(376),

-    EMPTY_LEAF,

-

-    /* [83] -> opcode range [4256, 4272], node depth 6 */

-    1,

-    EMPTY_LEAF,

-    LEAF(384),

-

-    /* [86] -> opcode range [4272, 4288], node depth 6 */

-    1,

-    LEAF(392),

-    EMPTY_LEAF,

-

-    /* [89] -> opcode range [4304, 4320], node depth 6 */

-    1,

-    EMPTY_LEAF,

-    LEAF(400),

-

-};

-

-static const void *Render_function_table[408][2] = {

-    /* [  0] =     0 */ {NULL, NULL},

-    /* [  1] =     1 */ {__glXDisp_CallList, __glXDispSwap_CallList},

-    /* [  2] =     2 */ {__glXDisp_CallLists, __glXDispSwap_CallLists},

-    /* [  3] =     3 */ {__glXDisp_ListBase, __glXDispSwap_ListBase},

-    /* [  4] =     4 */ {__glXDisp_Begin, __glXDispSwap_Begin},

-    /* [  5] =     5 */ {__glXDisp_Bitmap, __glXDispSwap_Bitmap},

-    /* [  6] =     6 */ {__glXDisp_Color3bv, __glXDispSwap_Color3bv},

-    /* [  7] =     7 */ {__glXDisp_Color3dv, __glXDispSwap_Color3dv},

-    /* [  8] =     8 */ {__glXDisp_Color3fv, __glXDispSwap_Color3fv},

-    /* [  9] =     9 */ {__glXDisp_Color3iv, __glXDispSwap_Color3iv},

-    /* [ 10] =    10 */ {__glXDisp_Color3sv, __glXDispSwap_Color3sv},

-    /* [ 11] =    11 */ {__glXDisp_Color3ubv, __glXDispSwap_Color3ubv},

-    /* [ 12] =    12 */ {__glXDisp_Color3uiv, __glXDispSwap_Color3uiv},

-    /* [ 13] =    13 */ {__glXDisp_Color3usv, __glXDispSwap_Color3usv},

-    /* [ 14] =    14 */ {__glXDisp_Color4bv, __glXDispSwap_Color4bv},

-    /* [ 15] =    15 */ {__glXDisp_Color4dv, __glXDispSwap_Color4dv},

-    /* [ 16] =    16 */ {__glXDisp_Color4fv, __glXDispSwap_Color4fv},

-    /* [ 17] =    17 */ {__glXDisp_Color4iv, __glXDispSwap_Color4iv},

-    /* [ 18] =    18 */ {__glXDisp_Color4sv, __glXDispSwap_Color4sv},

-    /* [ 19] =    19 */ {__glXDisp_Color4ubv, __glXDispSwap_Color4ubv},

-    /* [ 20] =    20 */ {__glXDisp_Color4uiv, __glXDispSwap_Color4uiv},

-    /* [ 21] =    21 */ {__glXDisp_Color4usv, __glXDispSwap_Color4usv},

-    /* [ 22] =    22 */ {__glXDisp_EdgeFlagv, __glXDispSwap_EdgeFlagv},

-    /* [ 23] =    23 */ {__glXDisp_End, __glXDispSwap_End},

-    /* [ 24] =    24 */ {__glXDisp_Indexdv, __glXDispSwap_Indexdv},

-    /* [ 25] =    25 */ {__glXDisp_Indexfv, __glXDispSwap_Indexfv},

-    /* [ 26] =    26 */ {__glXDisp_Indexiv, __glXDispSwap_Indexiv},

-    /* [ 27] =    27 */ {__glXDisp_Indexsv, __glXDispSwap_Indexsv},

-    /* [ 28] =    28 */ {__glXDisp_Normal3bv, __glXDispSwap_Normal3bv},

-    /* [ 29] =    29 */ {__glXDisp_Normal3dv, __glXDispSwap_Normal3dv},

-    /* [ 30] =    30 */ {__glXDisp_Normal3fv, __glXDispSwap_Normal3fv},

-    /* [ 31] =    31 */ {__glXDisp_Normal3iv, __glXDispSwap_Normal3iv},

-    /* [ 32] =    32 */ {__glXDisp_Normal3sv, __glXDispSwap_Normal3sv},

-    /* [ 33] =    33 */ {__glXDisp_RasterPos2dv, __glXDispSwap_RasterPos2dv},

-    /* [ 34] =    34 */ {__glXDisp_RasterPos2fv, __glXDispSwap_RasterPos2fv},

-    /* [ 35] =    35 */ {__glXDisp_RasterPos2iv, __glXDispSwap_RasterPos2iv},

-    /* [ 36] =    36 */ {__glXDisp_RasterPos2sv, __glXDispSwap_RasterPos2sv},

-    /* [ 37] =    37 */ {__glXDisp_RasterPos3dv, __glXDispSwap_RasterPos3dv},

-    /* [ 38] =    38 */ {__glXDisp_RasterPos3fv, __glXDispSwap_RasterPos3fv},

-    /* [ 39] =    39 */ {__glXDisp_RasterPos3iv, __glXDispSwap_RasterPos3iv},

-    /* [ 40] =    40 */ {__glXDisp_RasterPos3sv, __glXDispSwap_RasterPos3sv},

-    /* [ 41] =    41 */ {__glXDisp_RasterPos4dv, __glXDispSwap_RasterPos4dv},

-    /* [ 42] =    42 */ {__glXDisp_RasterPos4fv, __glXDispSwap_RasterPos4fv},

-    /* [ 43] =    43 */ {__glXDisp_RasterPos4iv, __glXDispSwap_RasterPos4iv},

-    /* [ 44] =    44 */ {__glXDisp_RasterPos4sv, __glXDispSwap_RasterPos4sv},

-    /* [ 45] =    45 */ {__glXDisp_Rectdv, __glXDispSwap_Rectdv},

-    /* [ 46] =    46 */ {__glXDisp_Rectfv, __glXDispSwap_Rectfv},

-    /* [ 47] =    47 */ {__glXDisp_Rectiv, __glXDispSwap_Rectiv},

-    /* [ 48] =    48 */ {__glXDisp_Rectsv, __glXDispSwap_Rectsv},

-    /* [ 49] =    49 */ {__glXDisp_TexCoord1dv, __glXDispSwap_TexCoord1dv},

-    /* [ 50] =    50 */ {__glXDisp_TexCoord1fv, __glXDispSwap_TexCoord1fv},

-    /* [ 51] =    51 */ {__glXDisp_TexCoord1iv, __glXDispSwap_TexCoord1iv},

-    /* [ 52] =    52 */ {__glXDisp_TexCoord1sv, __glXDispSwap_TexCoord1sv},

-    /* [ 53] =    53 */ {__glXDisp_TexCoord2dv, __glXDispSwap_TexCoord2dv},

-    /* [ 54] =    54 */ {__glXDisp_TexCoord2fv, __glXDispSwap_TexCoord2fv},

-    /* [ 55] =    55 */ {__glXDisp_TexCoord2iv, __glXDispSwap_TexCoord2iv},

-    /* [ 56] =    56 */ {__glXDisp_TexCoord2sv, __glXDispSwap_TexCoord2sv},

-    /* [ 57] =    57 */ {__glXDisp_TexCoord3dv, __glXDispSwap_TexCoord3dv},

-    /* [ 58] =    58 */ {__glXDisp_TexCoord3fv, __glXDispSwap_TexCoord3fv},

-    /* [ 59] =    59 */ {__glXDisp_TexCoord3iv, __glXDispSwap_TexCoord3iv},

-    /* [ 60] =    60 */ {__glXDisp_TexCoord3sv, __glXDispSwap_TexCoord3sv},

-    /* [ 61] =    61 */ {__glXDisp_TexCoord4dv, __glXDispSwap_TexCoord4dv},

-    /* [ 62] =    62 */ {__glXDisp_TexCoord4fv, __glXDispSwap_TexCoord4fv},

-    /* [ 63] =    63 */ {__glXDisp_TexCoord4iv, __glXDispSwap_TexCoord4iv},

-    /* [ 64] =    64 */ {__glXDisp_TexCoord4sv, __glXDispSwap_TexCoord4sv},

-    /* [ 65] =    65 */ {__glXDisp_Vertex2dv, __glXDispSwap_Vertex2dv},

-    /* [ 66] =    66 */ {__glXDisp_Vertex2fv, __glXDispSwap_Vertex2fv},

-    /* [ 67] =    67 */ {__glXDisp_Vertex2iv, __glXDispSwap_Vertex2iv},

-    /* [ 68] =    68 */ {__glXDisp_Vertex2sv, __glXDispSwap_Vertex2sv},

-    /* [ 69] =    69 */ {__glXDisp_Vertex3dv, __glXDispSwap_Vertex3dv},

-    /* [ 70] =    70 */ {__glXDisp_Vertex3fv, __glXDispSwap_Vertex3fv},

-    /* [ 71] =    71 */ {__glXDisp_Vertex3iv, __glXDispSwap_Vertex3iv},

-    /* [ 72] =    72 */ {__glXDisp_Vertex3sv, __glXDispSwap_Vertex3sv},

-    /* [ 73] =    73 */ {__glXDisp_Vertex4dv, __glXDispSwap_Vertex4dv},

-    /* [ 74] =    74 */ {__glXDisp_Vertex4fv, __glXDispSwap_Vertex4fv},

-    /* [ 75] =    75 */ {__glXDisp_Vertex4iv, __glXDispSwap_Vertex4iv},

-    /* [ 76] =    76 */ {__glXDisp_Vertex4sv, __glXDispSwap_Vertex4sv},

-    /* [ 77] =    77 */ {__glXDisp_ClipPlane, __glXDispSwap_ClipPlane},

-    /* [ 78] =    78 */ {__glXDisp_ColorMaterial, __glXDispSwap_ColorMaterial},

-    /* [ 79] =    79 */ {__glXDisp_CullFace, __glXDispSwap_CullFace},

-    /* [ 80] =    80 */ {__glXDisp_Fogf, __glXDispSwap_Fogf},

-    /* [ 81] =    81 */ {__glXDisp_Fogfv, __glXDispSwap_Fogfv},

-    /* [ 82] =    82 */ {__glXDisp_Fogi, __glXDispSwap_Fogi},

-    /* [ 83] =    83 */ {__glXDisp_Fogiv, __glXDispSwap_Fogiv},

-    /* [ 84] =    84 */ {__glXDisp_FrontFace, __glXDispSwap_FrontFace},

-    /* [ 85] =    85 */ {__glXDisp_Hint, __glXDispSwap_Hint},

-    /* [ 86] =    86 */ {__glXDisp_Lightf, __glXDispSwap_Lightf},

-    /* [ 87] =    87 */ {__glXDisp_Lightfv, __glXDispSwap_Lightfv},

-    /* [ 88] =    88 */ {__glXDisp_Lighti, __glXDispSwap_Lighti},

-    /* [ 89] =    89 */ {__glXDisp_Lightiv, __glXDispSwap_Lightiv},

-    /* [ 90] =    90 */ {__glXDisp_LightModelf, __glXDispSwap_LightModelf},

-    /* [ 91] =    91 */ {__glXDisp_LightModelfv, __glXDispSwap_LightModelfv},

-    /* [ 92] =    92 */ {__glXDisp_LightModeli, __glXDispSwap_LightModeli},

-    /* [ 93] =    93 */ {__glXDisp_LightModeliv, __glXDispSwap_LightModeliv},

-    /* [ 94] =    94 */ {__glXDisp_LineStipple, __glXDispSwap_LineStipple},

-    /* [ 95] =    95 */ {__glXDisp_LineWidth, __glXDispSwap_LineWidth},

-    /* [ 96] =    96 */ {__glXDisp_Materialf, __glXDispSwap_Materialf},

-    /* [ 97] =    97 */ {__glXDisp_Materialfv, __glXDispSwap_Materialfv},

-    /* [ 98] =    98 */ {__glXDisp_Materiali, __glXDispSwap_Materiali},

-    /* [ 99] =    99 */ {__glXDisp_Materialiv, __glXDispSwap_Materialiv},

-    /* [ 100] =   100 */ {__glXDisp_PointSize, __glXDispSwap_PointSize},

-    /* [ 101] =   101 */ {__glXDisp_PolygonMode, __glXDispSwap_PolygonMode},

-    /* [ 102] =   102 */ {__glXDisp_PolygonStipple, __glXDispSwap_PolygonStipple},

-    /* [ 103] =   103 */ {__glXDisp_Scissor, __glXDispSwap_Scissor},

-    /* [ 104] =   104 */ {__glXDisp_ShadeModel, __glXDispSwap_ShadeModel},

-    /* [ 105] =   105 */ {__glXDisp_TexParameterf, __glXDispSwap_TexParameterf},

-    /* [ 106] =   106 */ {__glXDisp_TexParameterfv, __glXDispSwap_TexParameterfv},

-    /* [ 107] =   107 */ {__glXDisp_TexParameteri, __glXDispSwap_TexParameteri},

-    /* [ 108] =   108 */ {__glXDisp_TexParameteriv, __glXDispSwap_TexParameteriv},

-    /* [ 109] =   109 */ {__glXDisp_TexImage1D, __glXDispSwap_TexImage1D},

-    /* [ 110] =   110 */ {__glXDisp_TexImage2D, __glXDispSwap_TexImage2D},

-    /* [ 111] =   111 */ {__glXDisp_TexEnvf, __glXDispSwap_TexEnvf},

-    /* [ 112] =   112 */ {__glXDisp_TexEnvfv, __glXDispSwap_TexEnvfv},

-    /* [ 113] =   113 */ {__glXDisp_TexEnvi, __glXDispSwap_TexEnvi},

-    /* [ 114] =   114 */ {__glXDisp_TexEnviv, __glXDispSwap_TexEnviv},

-    /* [ 115] =   115 */ {__glXDisp_TexGend, __glXDispSwap_TexGend},

-    /* [ 116] =   116 */ {__glXDisp_TexGendv, __glXDispSwap_TexGendv},

-    /* [ 117] =   117 */ {__glXDisp_TexGenf, __glXDispSwap_TexGenf},

-    /* [ 118] =   118 */ {__glXDisp_TexGenfv, __glXDispSwap_TexGenfv},

-    /* [ 119] =   119 */ {__glXDisp_TexGeni, __glXDispSwap_TexGeni},

-    /* [ 120] =   120 */ {__glXDisp_TexGeniv, __glXDispSwap_TexGeniv},

-    /* [ 121] =   121 */ {__glXDisp_InitNames, __glXDispSwap_InitNames},

-    /* [ 122] =   122 */ {__glXDisp_LoadName, __glXDispSwap_LoadName},

-    /* [ 123] =   123 */ {__glXDisp_PassThrough, __glXDispSwap_PassThrough},

-    /* [ 124] =   124 */ {__glXDisp_PopName, __glXDispSwap_PopName},

-    /* [ 125] =   125 */ {__glXDisp_PushName, __glXDispSwap_PushName},

-    /* [ 126] =   126 */ {__glXDisp_DrawBuffer, __glXDispSwap_DrawBuffer},

-    /* [ 127] =   127 */ {__glXDisp_Clear, __glXDispSwap_Clear},

-    /* [ 128] =   128 */ {__glXDisp_ClearAccum, __glXDispSwap_ClearAccum},

-    /* [ 129] =   129 */ {__glXDisp_ClearIndex, __glXDispSwap_ClearIndex},

-    /* [ 130] =   130 */ {__glXDisp_ClearColor, __glXDispSwap_ClearColor},

-    /* [ 131] =   131 */ {__glXDisp_ClearStencil, __glXDispSwap_ClearStencil},

-    /* [ 132] =   132 */ {__glXDisp_ClearDepth, __glXDispSwap_ClearDepth},

-    /* [ 133] =   133 */ {__glXDisp_StencilMask, __glXDispSwap_StencilMask},

-    /* [ 134] =   134 */ {__glXDisp_ColorMask, __glXDispSwap_ColorMask},

-    /* [ 135] =   135 */ {__glXDisp_DepthMask, __glXDispSwap_DepthMask},

-    /* [ 136] =   136 */ {__glXDisp_IndexMask, __glXDispSwap_IndexMask},

-    /* [ 137] =   137 */ {__glXDisp_Accum, __glXDispSwap_Accum},

-    /* [ 138] =   138 */ {__glXDisp_Disable, __glXDispSwap_Disable},

-    /* [ 139] =   139 */ {__glXDisp_Enable, __glXDispSwap_Enable},

-    /* [ 140] =   140 */ {NULL, NULL},

-    /* [ 141] =   141 */ {__glXDisp_PopAttrib, __glXDispSwap_PopAttrib},

-    /* [ 142] =   142 */ {__glXDisp_PushAttrib, __glXDispSwap_PushAttrib},

-    /* [ 143] =   143 */ {__glXDisp_Map1d, __glXDispSwap_Map1d},

-    /* [ 144] =   144 */ {__glXDisp_Map1f, __glXDispSwap_Map1f},

-    /* [ 145] =   145 */ {__glXDisp_Map2d, __glXDispSwap_Map2d},

-    /* [ 146] =   146 */ {__glXDisp_Map2f, __glXDispSwap_Map2f},

-    /* [ 147] =   147 */ {__glXDisp_MapGrid1d, __glXDispSwap_MapGrid1d},

-    /* [ 148] =   148 */ {__glXDisp_MapGrid1f, __glXDispSwap_MapGrid1f},

-    /* [ 149] =   149 */ {__glXDisp_MapGrid2d, __glXDispSwap_MapGrid2d},

-    /* [ 150] =   150 */ {__glXDisp_MapGrid2f, __glXDispSwap_MapGrid2f},

-    /* [ 151] =   151 */ {__glXDisp_EvalCoord1dv, __glXDispSwap_EvalCoord1dv},

-    /* [ 152] =   152 */ {__glXDisp_EvalCoord1fv, __glXDispSwap_EvalCoord1fv},

-    /* [ 153] =   153 */ {__glXDisp_EvalCoord2dv, __glXDispSwap_EvalCoord2dv},

-    /* [ 154] =   154 */ {__glXDisp_EvalCoord2fv, __glXDispSwap_EvalCoord2fv},

-    /* [ 155] =   155 */ {__glXDisp_EvalMesh1, __glXDispSwap_EvalMesh1},

-    /* [ 156] =   156 */ {__glXDisp_EvalPoint1, __glXDispSwap_EvalPoint1},

-    /* [ 157] =   157 */ {__glXDisp_EvalMesh2, __glXDispSwap_EvalMesh2},

-    /* [ 158] =   158 */ {__glXDisp_EvalPoint2, __glXDispSwap_EvalPoint2},

-    /* [ 159] =   159 */ {__glXDisp_AlphaFunc, __glXDispSwap_AlphaFunc},

-    /* [ 160] =   160 */ {__glXDisp_BlendFunc, __glXDispSwap_BlendFunc},

-    /* [ 161] =   161 */ {__glXDisp_LogicOp, __glXDispSwap_LogicOp},

-    /* [ 162] =   162 */ {__glXDisp_StencilFunc, __glXDispSwap_StencilFunc},

-    /* [ 163] =   163 */ {__glXDisp_StencilOp, __glXDispSwap_StencilOp},

-    /* [ 164] =   164 */ {__glXDisp_DepthFunc, __glXDispSwap_DepthFunc},

-    /* [ 165] =   165 */ {__glXDisp_PixelZoom, __glXDispSwap_PixelZoom},

-    /* [ 166] =   166 */ {__glXDisp_PixelTransferf, __glXDispSwap_PixelTransferf},

-    /* [ 167] =   167 */ {__glXDisp_PixelTransferi, __glXDispSwap_PixelTransferi},

-    /* [ 168] =   168 */ {__glXDisp_PixelMapfv, __glXDispSwap_PixelMapfv},

-    /* [ 169] =   169 */ {__glXDisp_PixelMapuiv, __glXDispSwap_PixelMapuiv},

-    /* [ 170] =   170 */ {__glXDisp_PixelMapusv, __glXDispSwap_PixelMapusv},

-    /* [ 171] =   171 */ {__glXDisp_ReadBuffer, __glXDispSwap_ReadBuffer},

-    /* [ 172] =   172 */ {__glXDisp_CopyPixels, __glXDispSwap_CopyPixels},

-    /* [ 173] =   173 */ {__glXDisp_DrawPixels, __glXDispSwap_DrawPixels},

-    /* [ 174] =   174 */ {__glXDisp_DepthRange, __glXDispSwap_DepthRange},

-    /* [ 175] =   175 */ {__glXDisp_Frustum, __glXDispSwap_Frustum},

-    /* [ 176] =   176 */ {__glXDisp_LoadIdentity, __glXDispSwap_LoadIdentity},

-    /* [ 177] =   177 */ {__glXDisp_LoadMatrixf, __glXDispSwap_LoadMatrixf},

-    /* [ 178] =   178 */ {__glXDisp_LoadMatrixd, __glXDispSwap_LoadMatrixd},

-    /* [ 179] =   179 */ {__glXDisp_MatrixMode, __glXDispSwap_MatrixMode},

-    /* [ 180] =   180 */ {__glXDisp_MultMatrixf, __glXDispSwap_MultMatrixf},

-    /* [ 181] =   181 */ {__glXDisp_MultMatrixd, __glXDispSwap_MultMatrixd},

-    /* [ 182] =   182 */ {__glXDisp_Ortho, __glXDispSwap_Ortho},

-    /* [ 183] =   183 */ {__glXDisp_PopMatrix, __glXDispSwap_PopMatrix},

-    /* [ 184] =   184 */ {__glXDisp_PushMatrix, __glXDispSwap_PushMatrix},

-    /* [ 185] =   185 */ {__glXDisp_Rotated, __glXDispSwap_Rotated},

-    /* [ 186] =   186 */ {__glXDisp_Rotatef, __glXDispSwap_Rotatef},

-    /* [ 187] =   187 */ {__glXDisp_Scaled, __glXDispSwap_Scaled},

-    /* [ 188] =   188 */ {__glXDisp_Scalef, __glXDispSwap_Scalef},

-    /* [ 189] =   189 */ {__glXDisp_Translated, __glXDispSwap_Translated},

-    /* [ 190] =   190 */ {__glXDisp_Translatef, __glXDispSwap_Translatef},

-    /* [ 191] =   191 */ {__glXDisp_Viewport, __glXDispSwap_Viewport},

-    /* [ 192] =   192 */ {__glXDisp_PolygonOffset, __glXDispSwap_PolygonOffset},

-    /* [ 193] =   193 */ {__glXDisp_DrawArrays, __glXDispSwap_DrawArrays},

-    /* [ 194] =   194 */ {__glXDisp_Indexubv, __glXDispSwap_Indexubv},

-    /* [ 195] =   195 */ {__glXDisp_ColorSubTable, __glXDispSwap_ColorSubTable},

-    /* [ 196] =   196 */ {__glXDisp_CopyColorSubTable, __glXDispSwap_CopyColorSubTable},

-    /* [ 197] =   197 */ {__glXDisp_ActiveTextureARB, __glXDispSwap_ActiveTextureARB},

-    /* [ 198] =   198 */ {__glXDisp_MultiTexCoord1dvARB, __glXDispSwap_MultiTexCoord1dvARB},

-    /* [ 199] =   199 */ {__glXDisp_MultiTexCoord1fvARB, __glXDispSwap_MultiTexCoord1fvARB},

-    /* [ 200] =   200 */ {__glXDisp_MultiTexCoord1ivARB, __glXDispSwap_MultiTexCoord1ivARB},

-    /* [ 201] =   201 */ {__glXDisp_MultiTexCoord1svARB, __glXDispSwap_MultiTexCoord1svARB},

-    /* [ 202] =   202 */ {__glXDisp_MultiTexCoord2dvARB, __glXDispSwap_MultiTexCoord2dvARB},

-    /* [ 203] =   203 */ {__glXDisp_MultiTexCoord2fvARB, __glXDispSwap_MultiTexCoord2fvARB},

-    /* [ 204] =   204 */ {__glXDisp_MultiTexCoord2ivARB, __glXDispSwap_MultiTexCoord2ivARB},

-    /* [ 205] =   205 */ {__glXDisp_MultiTexCoord2svARB, __glXDispSwap_MultiTexCoord2svARB},

-    /* [ 206] =   206 */ {__glXDisp_MultiTexCoord3dvARB, __glXDispSwap_MultiTexCoord3dvARB},

-    /* [ 207] =   207 */ {__glXDisp_MultiTexCoord3fvARB, __glXDispSwap_MultiTexCoord3fvARB},

-    /* [ 208] =   208 */ {__glXDisp_MultiTexCoord3ivARB, __glXDispSwap_MultiTexCoord3ivARB},

-    /* [ 209] =   209 */ {__glXDisp_MultiTexCoord3svARB, __glXDispSwap_MultiTexCoord3svARB},

-    /* [ 210] =   210 */ {__glXDisp_MultiTexCoord4dvARB, __glXDispSwap_MultiTexCoord4dvARB},

-    /* [ 211] =   211 */ {__glXDisp_MultiTexCoord4fvARB, __glXDispSwap_MultiTexCoord4fvARB},

-    /* [ 212] =   212 */ {__glXDisp_MultiTexCoord4ivARB, __glXDispSwap_MultiTexCoord4ivARB},

-    /* [ 213] =   213 */ {__glXDisp_MultiTexCoord4svARB, __glXDispSwap_MultiTexCoord4svARB},

-    /* [ 214] =   214 */ {__glXDisp_CompressedTexImage1DARB, __glXDispSwap_CompressedTexImage1DARB},

-    /* [ 215] =   215 */ {__glXDisp_CompressedTexImage2DARB, __glXDispSwap_CompressedTexImage2DARB},

-    /* [ 216] =   216 */ {__glXDisp_CompressedTexImage3DARB, __glXDispSwap_CompressedTexImage3DARB},

-    /* [ 217] =   217 */ {__glXDisp_CompressedTexSubImage1DARB, __glXDispSwap_CompressedTexSubImage1DARB},

-    /* [ 218] =   218 */ {__glXDisp_CompressedTexSubImage2DARB, __glXDispSwap_CompressedTexSubImage2DARB},

-    /* [ 219] =   219 */ {__glXDisp_CompressedTexSubImage3DARB, __glXDispSwap_CompressedTexSubImage3DARB},

-    /* [ 220] =   220 */ {NULL, NULL},

-    /* [ 221] =   221 */ {NULL, NULL},

-    /* [ 222] =   222 */ {NULL, NULL},

-    /* [ 223] =   223 */ {NULL, NULL},

-    /* [ 224] =   224 */ {NULL, NULL},

-    /* [ 225] =   225 */ {NULL, NULL},

-    /* [ 226] =   226 */ {NULL, NULL},

-    /* [ 227] =   227 */ {NULL, NULL},

-    /* [ 228] =   228 */ {NULL, NULL},

-    /* [ 229] =   229 */ {__glXDisp_SampleCoverageARB, __glXDispSwap_SampleCoverageARB},

-    /* [ 230] =   230 */ {__glXDisp_WindowPos3fvMESA, __glXDispSwap_WindowPos3fvMESA},

-    /* [ 231] =   231 */ {__glXDisp_BeginQueryARB, __glXDispSwap_BeginQueryARB},

-    /* [ 232] =   232 */ {__glXDisp_EndQueryARB, __glXDispSwap_EndQueryARB},

-    /* [ 233] =   233 */ {__glXDisp_DrawBuffersARB, __glXDispSwap_DrawBuffersARB},

-    /* [ 234] =   234 */ {__glXDisp_ClampColorARB, __glXDispSwap_ClampColorARB},

-    /* [ 235] =   235 */ {NULL, NULL},

-    /* [ 236] =   236 */ {NULL, NULL},

-    /* [ 237] =   237 */ {__glXDisp_FramebufferTextureLayerEXT, __glXDispSwap_FramebufferTextureLayerEXT},

-    /* [ 238] =   238 */ {NULL, NULL},

-    /* [ 239] =   239 */ {NULL, NULL},

-    /* [ 240] =  2048 */ {__glXDisp_SampleMaskSGIS, __glXDispSwap_SampleMaskSGIS},

-    /* [ 241] =  2049 */ {__glXDisp_SamplePatternSGIS, __glXDispSwap_SamplePatternSGIS},

-    /* [ 242] =  2050 */ {NULL, NULL},

-    /* [ 243] =  2051 */ {NULL, NULL},

-    /* [ 244] =  2052 */ {NULL, NULL},

-    /* [ 245] =  2053 */ {__glXDisp_ColorTable, __glXDispSwap_ColorTable},

-    /* [ 246] =  2054 */ {__glXDisp_ColorTableParameterfv, __glXDispSwap_ColorTableParameterfv},

-    /* [ 247] =  2055 */ {__glXDisp_ColorTableParameteriv, __glXDispSwap_ColorTableParameteriv},

-    /* [ 248] =  2056 */ {__glXDisp_CopyColorTable, __glXDispSwap_CopyColorTable},

-    /* [ 249] =  2057 */ {NULL, NULL},

-    /* [ 250] =  2058 */ {NULL, NULL},

-    /* [ 251] =  2059 */ {NULL, NULL},

-    /* [ 252] =  2060 */ {NULL, NULL},

-    /* [ 253] =  2061 */ {NULL, NULL},

-    /* [ 254] =  2062 */ {NULL, NULL},

-    /* [ 255] =  2063 */ {NULL, NULL},

-    /* [ 256] =  2064 */ {NULL, NULL},

-    /* [ 257] =  2065 */ {__glXDisp_PointParameterfEXT, __glXDispSwap_PointParameterfEXT},

-    /* [ 258] =  2066 */ {__glXDisp_PointParameterfvEXT, __glXDispSwap_PointParameterfvEXT},

-    /* [ 259] =  2067 */ {NULL, NULL},

-    /* [ 260] =  2068 */ {NULL, NULL},

-    /* [ 261] =  2069 */ {NULL, NULL},

-    /* [ 262] =  2070 */ {NULL, NULL},

-    /* [ 263] =  2071 */ {NULL, NULL},

-    /* [ 264] =  4096 */ {__glXDisp_BlendColor, __glXDispSwap_BlendColor},

-    /* [ 265] =  4097 */ {__glXDisp_BlendEquation, __glXDispSwap_BlendEquation},

-    /* [ 266] =  4098 */ {NULL, NULL},

-    /* [ 267] =  4099 */ {__glXDisp_TexSubImage1D, __glXDispSwap_TexSubImage1D},

-    /* [ 268] =  4100 */ {__glXDisp_TexSubImage2D, __glXDispSwap_TexSubImage2D},

-    /* [ 269] =  4101 */ {__glXDisp_ConvolutionFilter1D, __glXDispSwap_ConvolutionFilter1D},

-    /* [ 270] =  4102 */ {__glXDisp_ConvolutionFilter2D, __glXDispSwap_ConvolutionFilter2D},

-    /* [ 271] =  4103 */ {__glXDisp_ConvolutionParameterf, __glXDispSwap_ConvolutionParameterf},

-    /* [ 272] =  4104 */ {__glXDisp_ConvolutionParameterfv, __glXDispSwap_ConvolutionParameterfv},

-    /* [ 273] =  4105 */ {__glXDisp_ConvolutionParameteri, __glXDispSwap_ConvolutionParameteri},

-    /* [ 274] =  4106 */ {__glXDisp_ConvolutionParameteriv, __glXDispSwap_ConvolutionParameteriv},

-    /* [ 275] =  4107 */ {__glXDisp_CopyConvolutionFilter1D, __glXDispSwap_CopyConvolutionFilter1D},

-    /* [ 276] =  4108 */ {__glXDisp_CopyConvolutionFilter2D, __glXDispSwap_CopyConvolutionFilter2D},

-    /* [ 277] =  4109 */ {__glXDisp_SeparableFilter2D, __glXDispSwap_SeparableFilter2D},

-    /* [ 278] =  4110 */ {__glXDisp_Histogram, __glXDispSwap_Histogram},

-    /* [ 279] =  4111 */ {__glXDisp_Minmax, __glXDispSwap_Minmax},

-    /* [ 280] =  4112 */ {__glXDisp_ResetHistogram, __glXDispSwap_ResetHistogram},

-    /* [ 281] =  4113 */ {__glXDisp_ResetMinmax, __glXDispSwap_ResetMinmax},

-    /* [ 282] =  4114 */ {__glXDisp_TexImage3D, __glXDispSwap_TexImage3D},

-    /* [ 283] =  4115 */ {__glXDisp_TexSubImage3D, __glXDispSwap_TexSubImage3D},

-    /* [ 284] =  4116 */ {NULL, NULL},

-    /* [ 285] =  4117 */ {__glXDisp_BindTexture, __glXDispSwap_BindTexture},

-    /* [ 286] =  4118 */ {__glXDisp_PrioritizeTextures, __glXDispSwap_PrioritizeTextures},

-    /* [ 287] =  4119 */ {__glXDisp_CopyTexImage1D, __glXDispSwap_CopyTexImage1D},

-    /* [ 288] =  4120 */ {__glXDisp_CopyTexImage2D, __glXDispSwap_CopyTexImage2D},

-    /* [ 289] =  4121 */ {__glXDisp_CopyTexSubImage1D, __glXDispSwap_CopyTexSubImage1D},

-    /* [ 290] =  4122 */ {__glXDisp_CopyTexSubImage2D, __glXDispSwap_CopyTexSubImage2D},

-    /* [ 291] =  4123 */ {__glXDisp_CopyTexSubImage3D, __glXDispSwap_CopyTexSubImage3D},

-    /* [ 292] =  4124 */ {__glXDisp_FogCoordfvEXT, __glXDispSwap_FogCoordfvEXT},

-    /* [ 293] =  4125 */ {__glXDisp_FogCoorddvEXT, __glXDispSwap_FogCoorddvEXT},

-    /* [ 294] =  4126 */ {__glXDisp_SecondaryColor3bvEXT, __glXDispSwap_SecondaryColor3bvEXT},

-    /* [ 295] =  4127 */ {__glXDisp_SecondaryColor3svEXT, __glXDispSwap_SecondaryColor3svEXT},

-    /* [ 296] =  4176 */ {NULL, NULL},

-    /* [ 297] =  4177 */ {NULL, NULL},

-    /* [ 298] =  4178 */ {NULL, NULL},

-    /* [ 299] =  4179 */ {NULL, NULL},

-    /* [ 300] =  4180 */ {__glXDisp_BindProgramNV, __glXDispSwap_BindProgramNV},

-    /* [ 301] =  4181 */ {__glXDisp_ExecuteProgramNV, __glXDispSwap_ExecuteProgramNV},

-    /* [ 302] =  4182 */ {__glXDisp_RequestResidentProgramsNV, __glXDispSwap_RequestResidentProgramsNV},

-    /* [ 303] =  4183 */ {__glXDisp_LoadProgramNV, __glXDispSwap_LoadProgramNV},

-    /* [ 304] =  4184 */ {__glXDisp_ProgramEnvParameter4fvARB, __glXDispSwap_ProgramEnvParameter4fvARB},

-    /* [ 305] =  4185 */ {__glXDisp_ProgramEnvParameter4dvARB, __glXDispSwap_ProgramEnvParameter4dvARB},

-    /* [ 306] =  4186 */ {__glXDisp_ProgramParameters4fvNV, __glXDispSwap_ProgramParameters4fvNV},

-    /* [ 307] =  4187 */ {__glXDisp_ProgramParameters4dvNV, __glXDispSwap_ProgramParameters4dvNV},

-    /* [ 308] =  4188 */ {__glXDisp_TrackMatrixNV, __glXDispSwap_TrackMatrixNV},

-    /* [ 309] =  4189 */ {__glXDisp_VertexAttrib1svARB, __glXDispSwap_VertexAttrib1svARB},

-    /* [ 310] =  4190 */ {__glXDisp_VertexAttrib2svARB, __glXDispSwap_VertexAttrib2svARB},

-    /* [ 311] =  4191 */ {__glXDisp_VertexAttrib3svARB, __glXDispSwap_VertexAttrib3svARB},

-    /* [ 312] =  4192 */ {__glXDisp_VertexAttrib4svARB, __glXDispSwap_VertexAttrib4svARB},

-    /* [ 313] =  4193 */ {__glXDisp_VertexAttrib1fvARB, __glXDispSwap_VertexAttrib1fvARB},

-    /* [ 314] =  4194 */ {__glXDisp_VertexAttrib2fvARB, __glXDispSwap_VertexAttrib2fvARB},

-    /* [ 315] =  4195 */ {__glXDisp_VertexAttrib3fvARB, __glXDispSwap_VertexAttrib3fvARB},

-    /* [ 316] =  4196 */ {__glXDisp_VertexAttrib4fvARB, __glXDispSwap_VertexAttrib4fvARB},

-    /* [ 317] =  4197 */ {__glXDisp_VertexAttrib1dvARB, __glXDispSwap_VertexAttrib1dvARB},

-    /* [ 318] =  4198 */ {__glXDisp_VertexAttrib2dvARB, __glXDispSwap_VertexAttrib2dvARB},

-    /* [ 319] =  4199 */ {__glXDisp_VertexAttrib3dvARB, __glXDispSwap_VertexAttrib3dvARB},

-    /* [ 320] =  4200 */ {__glXDisp_VertexAttrib4dvARB, __glXDispSwap_VertexAttrib4dvARB},

-    /* [ 321] =  4201 */ {__glXDisp_VertexAttrib4NubvARB, __glXDispSwap_VertexAttrib4NubvARB},

-    /* [ 322] =  4202 */ {__glXDisp_VertexAttribs1svNV, __glXDispSwap_VertexAttribs1svNV},

-    /* [ 323] =  4203 */ {__glXDisp_VertexAttribs2svNV, __glXDispSwap_VertexAttribs2svNV},

-    /* [ 324] =  4204 */ {__glXDisp_VertexAttribs3svNV, __glXDispSwap_VertexAttribs3svNV},

-    /* [ 325] =  4205 */ {__glXDisp_VertexAttribs4svNV, __glXDispSwap_VertexAttribs4svNV},

-    /* [ 326] =  4206 */ {__glXDisp_VertexAttribs1fvNV, __glXDispSwap_VertexAttribs1fvNV},

-    /* [ 327] =  4207 */ {__glXDisp_VertexAttribs2fvNV, __glXDispSwap_VertexAttribs2fvNV},

-    /* [ 328] =  4208 */ {__glXDisp_VertexAttribs3fvNV, __glXDispSwap_VertexAttribs3fvNV},

-    /* [ 329] =  4209 */ {__glXDisp_VertexAttribs4fvNV, __glXDispSwap_VertexAttribs4fvNV},

-    /* [ 330] =  4210 */ {__glXDisp_VertexAttribs1dvNV, __glXDispSwap_VertexAttribs1dvNV},

-    /* [ 331] =  4211 */ {__glXDisp_VertexAttribs2dvNV, __glXDispSwap_VertexAttribs2dvNV},

-    /* [ 332] =  4212 */ {__glXDisp_VertexAttribs3dvNV, __glXDispSwap_VertexAttribs3dvNV},

-    /* [ 333] =  4213 */ {__glXDisp_VertexAttribs4dvNV, __glXDispSwap_VertexAttribs4dvNV},

-    /* [ 334] =  4214 */ {__glXDisp_VertexAttribs4ubvNV, __glXDispSwap_VertexAttribs4ubvNV},

-    /* [ 335] =  4215 */ {__glXDisp_ProgramLocalParameter4fvARB, __glXDispSwap_ProgramLocalParameter4fvARB},

-    /* [ 336] =  4216 */ {__glXDisp_ProgramLocalParameter4dvARB, __glXDispSwap_ProgramLocalParameter4dvARB},

-    /* [ 337] =  4217 */ {__glXDisp_ProgramStringARB, __glXDispSwap_ProgramStringARB},

-    /* [ 338] =  4218 */ {__glXDisp_ProgramNamedParameter4fvNV, __glXDispSwap_ProgramNamedParameter4fvNV},

-    /* [ 339] =  4219 */ {__glXDisp_ProgramNamedParameter4dvNV, __glXDispSwap_ProgramNamedParameter4dvNV},

-    /* [ 340] =  4220 */ {__glXDisp_ActiveStencilFaceEXT, __glXDispSwap_ActiveStencilFaceEXT},

-    /* [ 341] =  4221 */ {__glXDisp_PointParameteriNV, __glXDispSwap_PointParameteriNV},

-    /* [ 342] =  4222 */ {__glXDisp_PointParameterivNV, __glXDispSwap_PointParameterivNV},

-    /* [ 343] =  4223 */ {NULL, NULL},

-    /* [ 344] =  4224 */ {NULL, NULL},

-    /* [ 345] =  4225 */ {NULL, NULL},

-    /* [ 346] =  4226 */ {NULL, NULL},

-    /* [ 347] =  4227 */ {NULL, NULL},

-    /* [ 348] =  4228 */ {__glXDisp_BlendEquationSeparateEXT, __glXDispSwap_BlendEquationSeparateEXT},

-    /* [ 349] =  4229 */ {NULL, NULL},

-    /* [ 350] =  4230 */ {__glXDisp_VertexAttrib4bvARB, __glXDispSwap_VertexAttrib4bvARB},

-    /* [ 351] =  4231 */ {__glXDisp_VertexAttrib4ivARB, __glXDispSwap_VertexAttrib4ivARB},

-    /* [ 352] =  4232 */ {__glXDisp_VertexAttrib4ubvARB, __glXDispSwap_VertexAttrib4ubvARB},

-    /* [ 353] =  4233 */ {__glXDisp_VertexAttrib4usvARB, __glXDispSwap_VertexAttrib4usvARB},

-    /* [ 354] =  4234 */ {__glXDisp_VertexAttrib4uivARB, __glXDispSwap_VertexAttrib4uivARB},

-    /* [ 355] =  4235 */ {__glXDisp_VertexAttrib4NbvARB, __glXDispSwap_VertexAttrib4NbvARB},

-    /* [ 356] =  4236 */ {__glXDisp_VertexAttrib4NsvARB, __glXDispSwap_VertexAttrib4NsvARB},

-    /* [ 357] =  4237 */ {__glXDisp_VertexAttrib4NivARB, __glXDispSwap_VertexAttrib4NivARB},

-    /* [ 358] =  4238 */ {__glXDisp_VertexAttrib4NusvARB, __glXDispSwap_VertexAttrib4NusvARB},

-    /* [ 359] =  4239 */ {__glXDisp_VertexAttrib4NuivARB, __glXDispSwap_VertexAttrib4NuivARB},

-    /* [ 360] =  4320 */ {__glXDisp_DeleteFramebuffersEXT, __glXDispSwap_DeleteFramebuffersEXT},

-    /* [ 361] =  4321 */ {__glXDisp_FramebufferTexture1DEXT, __glXDispSwap_FramebufferTexture1DEXT},

-    /* [ 362] =  4322 */ {__glXDisp_FramebufferTexture2DEXT, __glXDispSwap_FramebufferTexture2DEXT},

-    /* [ 363] =  4323 */ {__glXDisp_FramebufferTexture3DEXT, __glXDispSwap_FramebufferTexture3DEXT},

-    /* [ 364] =  4324 */ {__glXDisp_FramebufferRenderbufferEXT, __glXDispSwap_FramebufferRenderbufferEXT},

-    /* [ 365] =  4325 */ {__glXDisp_GenerateMipmapEXT, __glXDispSwap_GenerateMipmapEXT},

-    /* [ 366] =  4326 */ {NULL, NULL},

-    /* [ 367] =  4327 */ {NULL, NULL},

-    /* [ 368] =  4328 */ {NULL, NULL},

-    /* [ 369] =  4329 */ {NULL, NULL},

-    /* [ 370] =  4330 */ {__glXDisp_BlitFramebufferEXT, __glXDispSwap_BlitFramebufferEXT},

-    /* [ 371] =  4331 */ {__glXDisp_RenderbufferStorageMultisample, __glXDispSwap_RenderbufferStorageMultisample},

-    /* [ 372] =  4332 */ {NULL, NULL},

-    /* [ 373] =  4333 */ {NULL, NULL},

-    /* [ 374] =  4334 */ {NULL, NULL},

-    /* [ 375] =  4335 */ {NULL, NULL},

-    /* [ 376] =  4128 */ {__glXDisp_SecondaryColor3ivEXT, __glXDispSwap_SecondaryColor3ivEXT},

-    /* [ 377] =  4129 */ {__glXDisp_SecondaryColor3fvEXT, __glXDispSwap_SecondaryColor3fvEXT},

-    /* [ 378] =  4130 */ {__glXDisp_SecondaryColor3dvEXT, __glXDispSwap_SecondaryColor3dvEXT},

-    /* [ 379] =  4131 */ {__glXDisp_SecondaryColor3ubvEXT, __glXDispSwap_SecondaryColor3ubvEXT},

-    /* [ 380] =  4132 */ {__glXDisp_SecondaryColor3usvEXT, __glXDispSwap_SecondaryColor3usvEXT},

-    /* [ 381] =  4133 */ {__glXDisp_SecondaryColor3uivEXT, __glXDispSwap_SecondaryColor3uivEXT},

-    /* [ 382] =  4134 */ {__glXDisp_BlendFuncSeparateEXT, __glXDispSwap_BlendFuncSeparateEXT},

-    /* [ 383] =  4135 */ {NULL, NULL},

-    /* [ 384] =  4264 */ {NULL, NULL},

-    /* [ 385] =  4265 */ {__glXDisp_VertexAttrib1svNV, __glXDispSwap_VertexAttrib1svNV},

-    /* [ 386] =  4266 */ {__glXDisp_VertexAttrib2svNV, __glXDispSwap_VertexAttrib2svNV},

-    /* [ 387] =  4267 */ {__glXDisp_VertexAttrib3svNV, __glXDispSwap_VertexAttrib3svNV},

-    /* [ 388] =  4268 */ {__glXDisp_VertexAttrib4svNV, __glXDispSwap_VertexAttrib4svNV},

-    /* [ 389] =  4269 */ {__glXDisp_VertexAttrib1fvNV, __glXDispSwap_VertexAttrib1fvNV},

-    /* [ 390] =  4270 */ {__glXDisp_VertexAttrib2fvNV, __glXDispSwap_VertexAttrib2fvNV},

-    /* [ 391] =  4271 */ {__glXDisp_VertexAttrib3fvNV, __glXDispSwap_VertexAttrib3fvNV},

-    /* [ 392] =  4272 */ {__glXDisp_VertexAttrib4fvNV, __glXDispSwap_VertexAttrib4fvNV},

-    /* [ 393] =  4273 */ {__glXDisp_VertexAttrib1dvNV, __glXDispSwap_VertexAttrib1dvNV},

-    /* [ 394] =  4274 */ {__glXDisp_VertexAttrib2dvNV, __glXDispSwap_VertexAttrib2dvNV},

-    /* [ 395] =  4275 */ {__glXDisp_VertexAttrib3dvNV, __glXDispSwap_VertexAttrib3dvNV},

-    /* [ 396] =  4276 */ {__glXDisp_VertexAttrib4dvNV, __glXDispSwap_VertexAttrib4dvNV},

-    /* [ 397] =  4277 */ {__glXDisp_VertexAttrib4ubvNV, __glXDispSwap_VertexAttrib4ubvNV},

-    /* [ 398] =  4278 */ {NULL, NULL},

-    /* [ 399] =  4279 */ {NULL, NULL},

-    /* [ 400] =  4312 */ {NULL, NULL},

-    /* [ 401] =  4313 */ {NULL, NULL},

-    /* [ 402] =  4314 */ {NULL, NULL},

-    /* [ 403] =  4315 */ {NULL, NULL},

-    /* [ 404] =  4316 */ {__glXDisp_BindRenderbufferEXT, __glXDispSwap_BindRenderbufferEXT},

-    /* [ 405] =  4317 */ {__glXDisp_DeleteRenderbuffersEXT, __glXDispSwap_DeleteRenderbuffersEXT},

-    /* [ 406] =  4318 */ {__glXDisp_RenderbufferStorageEXT, __glXDispSwap_RenderbufferStorageEXT},

-    /* [ 407] =  4319 */ {__glXDisp_BindFramebufferEXT, __glXDispSwap_BindFramebufferEXT},

-};

-

-static const int_fast16_t Render_size_table[408][2] = {

-    /* [  0] =     0 */ {  0, ~0},

-    /* [  1] =     1 */ {  8, ~0},

-    /* [  2] =     2 */ { 12,  0},

-    /* [  3] =     3 */ {  8, ~0},

-    /* [  4] =     4 */ {  8, ~0},

-    /* [  5] =     5 */ { 48,  1},

-    /* [  6] =     6 */ {  8, ~0},

-    /* [  7] =     7 */ { 28, ~0},

-    /* [  8] =     8 */ { 16, ~0},

-    /* [  9] =     9 */ { 16, ~0},

-    /* [ 10] =    10 */ { 12, ~0},

-    /* [ 11] =    11 */ {  8, ~0},

-    /* [ 12] =    12 */ { 16, ~0},

-    /* [ 13] =    13 */ { 12, ~0},

-    /* [ 14] =    14 */ {  8, ~0},

-    /* [ 15] =    15 */ { 36, ~0},

-    /* [ 16] =    16 */ { 20, ~0},

-    /* [ 17] =    17 */ { 20, ~0},

-    /* [ 18] =    18 */ { 12, ~0},

-    /* [ 19] =    19 */ {  8, ~0},

-    /* [ 20] =    20 */ { 20, ~0},

-    /* [ 21] =    21 */ { 12, ~0},

-    /* [ 22] =    22 */ {  8, ~0},

-    /* [ 23] =    23 */ {  4, ~0},

-    /* [ 24] =    24 */ { 12, ~0},

-    /* [ 25] =    25 */ {  8, ~0},

-    /* [ 26] =    26 */ {  8, ~0},

-    /* [ 27] =    27 */ {  8, ~0},

-    /* [ 28] =    28 */ {  8, ~0},

-    /* [ 29] =    29 */ { 28, ~0},

-    /* [ 30] =    30 */ { 16, ~0},

-    /* [ 31] =    31 */ { 16, ~0},

-    /* [ 32] =    32 */ { 12, ~0},

-    /* [ 33] =    33 */ { 20, ~0},

-    /* [ 34] =    34 */ { 12, ~0},

-    /* [ 35] =    35 */ { 12, ~0},

-    /* [ 36] =    36 */ {  8, ~0},

-    /* [ 37] =    37 */ { 28, ~0},

-    /* [ 38] =    38 */ { 16, ~0},

-    /* [ 39] =    39 */ { 16, ~0},

-    /* [ 40] =    40 */ { 12, ~0},

-    /* [ 41] =    41 */ { 36, ~0},

-    /* [ 42] =    42 */ { 20, ~0},

-    /* [ 43] =    43 */ { 20, ~0},

-    /* [ 44] =    44 */ { 12, ~0},

-    /* [ 45] =    45 */ { 36, ~0},

-    /* [ 46] =    46 */ { 20, ~0},

-    /* [ 47] =    47 */ { 20, ~0},

-    /* [ 48] =    48 */ { 12, ~0},

-    /* [ 49] =    49 */ { 12, ~0},

-    /* [ 50] =    50 */ {  8, ~0},

-    /* [ 51] =    51 */ {  8, ~0},

-    /* [ 52] =    52 */ {  8, ~0},

-    /* [ 53] =    53 */ { 20, ~0},

-    /* [ 54] =    54 */ { 12, ~0},

-    /* [ 55] =    55 */ { 12, ~0},

-    /* [ 56] =    56 */ {  8, ~0},

-    /* [ 57] =    57 */ { 28, ~0},

-    /* [ 58] =    58 */ { 16, ~0},

-    /* [ 59] =    59 */ { 16, ~0},

-    /* [ 60] =    60 */ { 12, ~0},

-    /* [ 61] =    61 */ { 36, ~0},

-    /* [ 62] =    62 */ { 20, ~0},

-    /* [ 63] =    63 */ { 20, ~0},

-    /* [ 64] =    64 */ { 12, ~0},

-    /* [ 65] =    65 */ { 20, ~0},

-    /* [ 66] =    66 */ { 12, ~0},

-    /* [ 67] =    67 */ { 12, ~0},

-    /* [ 68] =    68 */ {  8, ~0},

-    /* [ 69] =    69 */ { 28, ~0},

-    /* [ 70] =    70 */ { 16, ~0},

-    /* [ 71] =    71 */ { 16, ~0},

-    /* [ 72] =    72 */ { 12, ~0},

-    /* [ 73] =    73 */ { 36, ~0},

-    /* [ 74] =    74 */ { 20, ~0},

-    /* [ 75] =    75 */ { 20, ~0},

-    /* [ 76] =    76 */ { 12, ~0},

-    /* [ 77] =    77 */ { 40, ~0},

-    /* [ 78] =    78 */ { 12, ~0},

-    /* [ 79] =    79 */ {  8, ~0},

-    /* [ 80] =    80 */ { 12, ~0},

-    /* [ 81] =    81 */ {  8,  2},

-    /* [ 82] =    82 */ { 12, ~0},

-    /* [ 83] =    83 */ {  8,  3},

-    /* [ 84] =    84 */ {  8, ~0},

-    /* [ 85] =    85 */ { 12, ~0},

-    /* [ 86] =    86 */ { 16, ~0},

-    /* [ 87] =    87 */ { 12,  4},

-    /* [ 88] =    88 */ { 16, ~0},

-    /* [ 89] =    89 */ { 12,  5},

-    /* [ 90] =    90 */ { 12, ~0},

-    /* [ 91] =    91 */ {  8,  6},

-    /* [ 92] =    92 */ { 12, ~0},

-    /* [ 93] =    93 */ {  8,  7},

-    /* [ 94] =    94 */ { 12, ~0},

-    /* [ 95] =    95 */ {  8, ~0},

-    /* [ 96] =    96 */ { 16, ~0},

-    /* [ 97] =    97 */ { 12,  8},

-    /* [ 98] =    98 */ { 16, ~0},

-    /* [ 99] =    99 */ { 12,  9},

-    /* [100] =   100 */ {  8, ~0},

-    /* [101] =   101 */ { 12, ~0},

-    /* [102] =   102 */ { 24, 10},

-    /* [103] =   103 */ { 20, ~0},

-    /* [104] =   104 */ {  8, ~0},

-    /* [105] =   105 */ { 16, ~0},

-    /* [106] =   106 */ { 12, 11},

-    /* [107] =   107 */ { 16, ~0},

-    /* [108] =   108 */ { 12, 12},

-    /* [109] =   109 */ { 56, 13},

-    /* [110] =   110 */ { 56, 14},

-    /* [111] =   111 */ { 16, ~0},

-    /* [112] =   112 */ { 12, 15},

-    /* [113] =   113 */ { 16, ~0},

-    /* [114] =   114 */ { 12, 16},

-    /* [115] =   115 */ { 20, ~0},

-    /* [116] =   116 */ { 12, 17},

-    /* [117] =   117 */ { 16, ~0},

-    /* [118] =   118 */ { 12, 18},

-    /* [119] =   119 */ { 16, ~0},

-    /* [120] =   120 */ { 12, 19},

-    /* [121] =   121 */ {  4, ~0},

-    /* [122] =   122 */ {  8, ~0},

-    /* [123] =   123 */ {  8, ~0},

-    /* [124] =   124 */ {  4, ~0},

-    /* [125] =   125 */ {  8, ~0},

-    /* [126] =   126 */ {  8, ~0},

-    /* [127] =   127 */ {  8, ~0},

-    /* [128] =   128 */ { 20, ~0},

-    /* [129] =   129 */ {  8, ~0},

-    /* [130] =   130 */ { 20, ~0},

-    /* [131] =   131 */ {  8, ~0},

-    /* [132] =   132 */ { 12, ~0},

-    /* [133] =   133 */ {  8, ~0},

-    /* [134] =   134 */ {  8, ~0},

-    /* [135] =   135 */ {  8, ~0},

-    /* [136] =   136 */ {  8, ~0},

-    /* [137] =   137 */ { 12, ~0},

-    /* [138] =   138 */ {  8, ~0},

-    /* [139] =   139 */ {  8, ~0},

-    /* [140] =   140 */ {  0, ~0},

-    /* [141] =   141 */ {  4, ~0},

-    /* [142] =   142 */ {  8, ~0},

-    /* [143] =   143 */ { 28, 20},

-    /* [144] =   144 */ { 20, 21},

-    /* [145] =   145 */ { 48, 22},

-    /* [146] =   146 */ { 32, 23},

-    /* [147] =   147 */ { 24, ~0},

-    /* [148] =   148 */ { 16, ~0},

-    /* [149] =   149 */ { 44, ~0},

-    /* [150] =   150 */ { 28, ~0},

-    /* [151] =   151 */ { 12, ~0},

-    /* [152] =   152 */ {  8, ~0},

-    /* [153] =   153 */ { 20, ~0},

-    /* [154] =   154 */ { 12, ~0},

-    /* [155] =   155 */ { 16, ~0},

-    /* [156] =   156 */ {  8, ~0},

-    /* [157] =   157 */ { 24, ~0},

-    /* [158] =   158 */ { 12, ~0},

-    /* [159] =   159 */ { 12, ~0},

-    /* [160] =   160 */ { 12, ~0},

-    /* [161] =   161 */ {  8, ~0},

-    /* [162] =   162 */ { 16, ~0},

-    /* [163] =   163 */ { 16, ~0},

-    /* [164] =   164 */ {  8, ~0},

-    /* [165] =   165 */ { 12, ~0},

-    /* [166] =   166 */ { 12, ~0},

-    /* [167] =   167 */ { 12, ~0},

-    /* [168] =   168 */ { 12, 24},

-    /* [169] =   169 */ { 12, 25},

-    /* [170] =   170 */ { 12, 26},

-    /* [171] =   171 */ {  8, ~0},

-    /* [172] =   172 */ { 24, ~0},

-    /* [173] =   173 */ { 40, 27},

-    /* [174] =   174 */ { 20, ~0},

-    /* [175] =   175 */ { 52, ~0},

-    /* [176] =   176 */ {  4, ~0},

-    /* [177] =   177 */ { 68, ~0},

-    /* [178] =   178 */ {132, ~0},

-    /* [179] =   179 */ {  8, ~0},

-    /* [180] =   180 */ { 68, ~0},

-    /* [181] =   181 */ {132, ~0},

-    /* [182] =   182 */ { 52, ~0},

-    /* [183] =   183 */ {  4, ~0},

-    /* [184] =   184 */ {  4, ~0},

-    /* [185] =   185 */ { 36, ~0},

-    /* [186] =   186 */ { 20, ~0},

-    /* [187] =   187 */ { 28, ~0},

-    /* [188] =   188 */ { 16, ~0},

-    /* [189] =   189 */ { 28, ~0},

-    /* [190] =   190 */ { 16, ~0},

-    /* [191] =   191 */ { 20, ~0},

-    /* [192] =   192 */ { 12, ~0},

-    /* [193] =   193 */ { 16, 28},

-    /* [194] =   194 */ {  8, ~0},

-    /* [195] =   195 */ { 44, 29},

-    /* [196] =   196 */ { 24, ~0},

-    /* [197] =   197 */ {  8, ~0},

-    /* [198] =   198 */ { 16, ~0},

-    /* [199] =   199 */ { 12, ~0},

-    /* [200] =   200 */ { 12, ~0},

-    /* [201] =   201 */ { 12, ~0},

-    /* [202] =   202 */ { 24, ~0},

-    /* [203] =   203 */ { 16, ~0},

-    /* [204] =   204 */ { 16, ~0},

-    /* [205] =   205 */ { 12, ~0},

-    /* [206] =   206 */ { 32, ~0},

-    /* [207] =   207 */ { 20, ~0},

-    /* [208] =   208 */ { 20, ~0},

-    /* [209] =   209 */ { 16, ~0},

-    /* [210] =   210 */ { 40, ~0},

-    /* [211] =   211 */ { 24, ~0},

-    /* [212] =   212 */ { 24, ~0},

-    /* [213] =   213 */ { 16, ~0},

-    /* [214] =   214 */ { 28, 30},

-    /* [215] =   215 */ { 32, 31},

-    /* [216] =   216 */ { 36, 32},

-    /* [217] =   217 */ { 28, 33},

-    /* [218] =   218 */ { 36, 34},

-    /* [219] =   219 */ { 44, 35},

-    /* [220] =   220 */ {  0, ~0},

-    /* [221] =   221 */ {  0, ~0},

-    /* [222] =   222 */ {  0, ~0},

-    /* [223] =   223 */ {  0, ~0},

-    /* [224] =   224 */ {  0, ~0},

-    /* [225] =   225 */ {  0, ~0},

-    /* [226] =   226 */ {  0, ~0},

-    /* [227] =   227 */ {  0, ~0},

-    /* [228] =   228 */ {  0, ~0},

-    /* [229] =   229 */ { 12, ~0},

-    /* [230] =   230 */ { 16, ~0},

-    /* [231] =   231 */ { 12, ~0},

-    /* [232] =   232 */ {  8, ~0},

-    /* [233] =   233 */ {  8, 36},

-    /* [234] =   234 */ { 12, ~0},

-    /* [235] =   235 */ {  0, ~0},

-    /* [236] =   236 */ {  0, ~0},

-    /* [237] =   237 */ { 24, ~0},

-    /* [238] =   238 */ {  0, ~0},

-    /* [239] =   239 */ {  0, ~0},

-    /* [240] =  2048 */ { 12, ~0},

-    /* [241] =  2049 */ {  8, ~0},

-    /* [242] =  2050 */ {  0, ~0},

-    /* [243] =  2051 */ {  0, ~0},

-    /* [244] =  2052 */ {  0, ~0},

-    /* [245] =  2053 */ { 44, 37},

-    /* [246] =  2054 */ { 12, 38},

-    /* [247] =  2055 */ { 12, 39},

-    /* [248] =  2056 */ { 24, ~0},

-    /* [249] =  2057 */ {  0, ~0},

-    /* [250] =  2058 */ {  0, ~0},

-    /* [251] =  2059 */ {  0, ~0},

-    /* [252] =  2060 */ {  0, ~0},

-    /* [253] =  2061 */ {  0, ~0},

-    /* [254] =  2062 */ {  0, ~0},

-    /* [255] =  2063 */ {  0, ~0},

-    /* [256] =  2064 */ {  0, ~0},

-    /* [257] =  2065 */ { 12, ~0},

-    /* [258] =  2066 */ {  8, 40},

-    /* [259] =  2067 */ {  0, ~0},

-    /* [260] =  2068 */ {  0, ~0},

-    /* [261] =  2069 */ {  0, ~0},

-    /* [262] =  2070 */ {  0, ~0},

-    /* [263] =  2071 */ {  0, ~0},

-    /* [264] =  4096 */ { 20, ~0},

-    /* [265] =  4097 */ {  8, ~0},

-    /* [266] =  4098 */ {  0, ~0},

-    /* [267] =  4099 */ { 60, 41},

-    /* [268] =  4100 */ { 60, 42},

-    /* [269] =  4101 */ { 48, 43},

-    /* [270] =  4102 */ { 48, 44},

-    /* [271] =  4103 */ { 16, ~0},

-    /* [272] =  4104 */ { 12, 45},

-    /* [273] =  4105 */ { 16, ~0},

-    /* [274] =  4106 */ { 12, 46},

-    /* [275] =  4107 */ { 24, ~0},

-    /* [276] =  4108 */ { 28, ~0},

-    /* [277] =  4109 */ { 32, 47},

-    /* [278] =  4110 */ { 20, ~0},

-    /* [279] =  4111 */ { 16, ~0},

-    /* [280] =  4112 */ {  8, ~0},

-    /* [281] =  4113 */ {  8, ~0},

-    /* [282] =  4114 */ { 84, 48},

-    /* [283] =  4115 */ { 92, 49},

-    /* [284] =  4116 */ {  0, ~0},

-    /* [285] =  4117 */ { 12, ~0},

-    /* [286] =  4118 */ {  8, 50},

-    /* [287] =  4119 */ { 32, ~0},

-    /* [288] =  4120 */ { 36, ~0},

-    /* [289] =  4121 */ { 28, ~0},

-    /* [290] =  4122 */ { 36, ~0},

-    /* [291] =  4123 */ { 40, ~0},

-    /* [292] =  4124 */ {  8, ~0},

-    /* [293] =  4125 */ { 12, ~0},

-    /* [294] =  4126 */ {  8, ~0},

-    /* [295] =  4127 */ { 12, ~0},

-    /* [296] =  4176 */ {  0, ~0},

-    /* [297] =  4177 */ {  0, ~0},

-    /* [298] =  4178 */ {  0, ~0},

-    /* [299] =  4179 */ {  0, ~0},

-    /* [300] =  4180 */ { 12, ~0},

-    /* [301] =  4181 */ { 28, ~0},

-    /* [302] =  4182 */ {  8, 51},

-    /* [303] =  4183 */ { 16, 52},

-    /* [304] =  4184 */ { 28, ~0},

-    /* [305] =  4185 */ { 44, ~0},

-    /* [306] =  4186 */ { 16, 53},

-    /* [307] =  4187 */ { 16, 54},

-    /* [308] =  4188 */ { 20, ~0},

-    /* [309] =  4189 */ { 12, ~0},

-    /* [310] =  4190 */ { 12, ~0},

-    /* [311] =  4191 */ { 16, ~0},

-    /* [312] =  4192 */ { 16, ~0},

-    /* [313] =  4193 */ { 12, ~0},

-    /* [314] =  4194 */ { 16, ~0},

-    /* [315] =  4195 */ { 20, ~0},

-    /* [316] =  4196 */ { 24, ~0},

-    /* [317] =  4197 */ { 16, ~0},

-    /* [318] =  4198 */ { 24, ~0},

-    /* [319] =  4199 */ { 32, ~0},

-    /* [320] =  4200 */ { 40, ~0},

-    /* [321] =  4201 */ { 12, ~0},

-    /* [322] =  4202 */ { 12, 55},

-    /* [323] =  4203 */ { 12, 56},

-    /* [324] =  4204 */ { 12, 57},

-    /* [325] =  4205 */ { 12, 58},

-    /* [326] =  4206 */ { 12, 59},

-    /* [327] =  4207 */ { 12, 60},

-    /* [328] =  4208 */ { 12, 61},

-    /* [329] =  4209 */ { 12, 62},

-    /* [330] =  4210 */ { 12, 63},

-    /* [331] =  4211 */ { 12, 64},

-    /* [332] =  4212 */ { 12, 65},

-    /* [333] =  4213 */ { 12, 66},

-    /* [334] =  4214 */ { 12, 67},

-    /* [335] =  4215 */ { 28, ~0},

-    /* [336] =  4216 */ { 44, ~0},

-    /* [337] =  4217 */ { 16, 68},

-    /* [338] =  4218 */ { 28, 69},

-    /* [339] =  4219 */ { 44, 70},

-    /* [340] =  4220 */ {  8, ~0},

-    /* [341] =  4221 */ { 12, ~0},

-    /* [342] =  4222 */ {  8, 71},

-    /* [343] =  4223 */ {  0, ~0},

-    /* [344] =  4224 */ {  0, ~0},

-    /* [345] =  4225 */ {  0, ~0},

-    /* [346] =  4226 */ {  0, ~0},

-    /* [347] =  4227 */ {  0, ~0},

-    /* [348] =  4228 */ { 12, ~0},

-    /* [349] =  4229 */ {  0, ~0},

-    /* [350] =  4230 */ { 12, ~0},

-    /* [351] =  4231 */ { 24, ~0},

-    /* [352] =  4232 */ { 12, ~0},

-    /* [353] =  4233 */ { 16, ~0},

-    /* [354] =  4234 */ { 24, ~0},

-    /* [355] =  4235 */ { 12, ~0},

-    /* [356] =  4236 */ { 16, ~0},

-    /* [357] =  4237 */ { 24, ~0},

-    /* [358] =  4238 */ { 16, ~0},

-    /* [359] =  4239 */ { 24, ~0},

-    /* [360] =  4320 */ {  8, 72},

-    /* [361] =  4321 */ { 24, ~0},

-    /* [362] =  4322 */ { 24, ~0},

-    /* [363] =  4323 */ { 28, ~0},

-    /* [364] =  4324 */ { 20, ~0},

-    /* [365] =  4325 */ {  8, ~0},

-    /* [366] =  4326 */ {  0, ~0},

-    /* [367] =  4327 */ {  0, ~0},

-    /* [368] =  4328 */ {  0, ~0},

-    /* [369] =  4329 */ {  0, ~0},

-    /* [370] =  4330 */ { 44, ~0},

-    /* [371] =  4331 */ { 24, ~0},

-    /* [372] =  4332 */ {  0, ~0},

-    /* [373] =  4333 */ {  0, ~0},

-    /* [374] =  4334 */ {  0, ~0},

-    /* [375] =  4335 */ {  0, ~0},

-    /* [376] =  4128 */ { 16, ~0},

-    /* [377] =  4129 */ { 16, ~0},

-    /* [378] =  4130 */ { 28, ~0},

-    /* [379] =  4131 */ {  8, ~0},

-    /* [380] =  4132 */ { 12, ~0},

-    /* [381] =  4133 */ { 16, ~0},

-    /* [382] =  4134 */ { 20, ~0},

-    /* [383] =  4135 */ {  0, ~0},

-    /* [384] =  4264 */ {  0, ~0},

-    /* [385] =  4265 */ { 12, ~0},

-    /* [386] =  4266 */ { 12, ~0},

-    /* [387] =  4267 */ { 16, ~0},

-    /* [388] =  4268 */ { 16, ~0},

-    /* [389] =  4269 */ { 12, ~0},

-    /* [390] =  4270 */ { 16, ~0},

-    /* [391] =  4271 */ { 20, ~0},

-    /* [392] =  4272 */ { 24, ~0},

-    /* [393] =  4273 */ { 16, ~0},

-    /* [394] =  4274 */ { 24, ~0},

-    /* [395] =  4275 */ { 32, ~0},

-    /* [396] =  4276 */ { 40, ~0},

-    /* [397] =  4277 */ { 12, ~0},

-    /* [398] =  4278 */ {  0, ~0},

-    /* [399] =  4279 */ {  0, ~0},

-    /* [400] =  4312 */ {  0, ~0},

-    /* [401] =  4313 */ {  0, ~0},

-    /* [402] =  4314 */ {  0, ~0},

-    /* [403] =  4315 */ {  0, ~0},

-    /* [404] =  4316 */ { 12, ~0},

-    /* [405] =  4317 */ {  8, 73},

-    /* [406] =  4318 */ { 20, ~0},

-    /* [407] =  4319 */ { 12, ~0},

-};

-

-static const gl_proto_size_func Render_size_func_table[74] = {

-   __glXCallListsReqSize,

-   __glXBitmapReqSize,

-   __glXFogfvReqSize,

-   __glXFogivReqSize,

-   __glXLightfvReqSize,

-   __glXLightivReqSize,

-   __glXLightModelfvReqSize,

-   __glXLightModelivReqSize,

-   __glXMaterialfvReqSize,

-   __glXMaterialivReqSize,

-   __glXPolygonStippleReqSize,

-   __glXTexParameterfvReqSize,

-   __glXTexParameterivReqSize,

-   __glXTexImage1DReqSize,

-   __glXTexImage2DReqSize,

-   __glXTexEnvfvReqSize,

-   __glXTexEnvivReqSize,

-   __glXTexGendvReqSize,

-   __glXTexGenfvReqSize,

-   __glXTexGenivReqSize,

-   __glXMap1dReqSize,

-   __glXMap1fReqSize,

-   __glXMap2dReqSize,

-   __glXMap2fReqSize,

-   __glXPixelMapfvReqSize,

-   __glXPixelMapuivReqSize,

-   __glXPixelMapusvReqSize,

-   __glXDrawPixelsReqSize,

-   __glXDrawArraysReqSize,

-   __glXColorSubTableReqSize,

-   __glXCompressedTexImage1DARBReqSize,

-   __glXCompressedTexImage2DARBReqSize,

-   __glXCompressedTexImage3DARBReqSize,

-   __glXCompressedTexSubImage1DARBReqSize,

-   __glXCompressedTexSubImage2DARBReqSize,

-   __glXCompressedTexSubImage3DARBReqSize,

-   __glXDrawBuffersARBReqSize,

-   __glXColorTableReqSize,

-   __glXColorTableParameterfvReqSize,

-   __glXColorTableParameterivReqSize,

-   __glXPointParameterfvEXTReqSize,

-   __glXTexSubImage1DReqSize,

-   __glXTexSubImage2DReqSize,

-   __glXConvolutionFilter1DReqSize,

-   __glXConvolutionFilter2DReqSize,

-   __glXConvolutionParameterfvReqSize,

-   __glXConvolutionParameterivReqSize,

-   __glXSeparableFilter2DReqSize,

-   __glXTexImage3DReqSize,

-   __glXTexSubImage3DReqSize,

-   __glXPrioritizeTexturesReqSize,

-   __glXRequestResidentProgramsNVReqSize,

-   __glXLoadProgramNVReqSize,

-   __glXProgramParameters4fvNVReqSize,

-   __glXProgramParameters4dvNVReqSize,

-   __glXVertexAttribs1svNVReqSize,

-   __glXVertexAttribs2svNVReqSize,

-   __glXVertexAttribs3svNVReqSize,

-   __glXVertexAttribs4svNVReqSize,

-   __glXVertexAttribs1fvNVReqSize,

-   __glXVertexAttribs2fvNVReqSize,

-   __glXVertexAttribs3fvNVReqSize,

-   __glXVertexAttribs4fvNVReqSize,

-   __glXVertexAttribs1dvNVReqSize,

-   __glXVertexAttribs2dvNVReqSize,

-   __glXVertexAttribs3dvNVReqSize,

-   __glXVertexAttribs4dvNVReqSize,

-   __glXVertexAttribs4ubvNVReqSize,

-   __glXProgramStringARBReqSize,

-   __glXProgramNamedParameter4fvNVReqSize,

-   __glXProgramNamedParameter4dvNVReqSize,

-   __glXPointParameterivNVReqSize,

-   __glXDeleteFramebuffersEXTReqSize,

-   __glXDeleteRenderbuffersEXTReqSize,

-};

-

-const struct __glXDispatchInfo Render_dispatch_info = {

-    13,

-    Render_dispatch_tree,

-    Render_function_table,

-    Render_size_table,

-    Render_size_func_table

-};

-

-/*****************************************************************/

-/* tree depth = 12 */

-static const int_fast16_t VendorPriv_dispatch_tree[152] = {

-    /* [0] -> opcode range [0, 131072], node depth 1 */

-    2,

-    5,

-    EMPTY_LEAF,

-    119,

-    EMPTY_LEAF,

-

-    /* [5] -> opcode range [0, 32768], node depth 2 */

-    1,

-    8,

-    EMPTY_LEAF,

-

-    /* [8] -> opcode range [0, 16384], node depth 3 */

-    1,

-    11,

-    EMPTY_LEAF,

-

-    /* [11] -> opcode range [0, 8192], node depth 4 */

-    2,

-    16,

-    EMPTY_LEAF,

-    78,

-    EMPTY_LEAF,

-

-    /* [16] -> opcode range [0, 2048], node depth 5 */

-    2,

-    21,

-    EMPTY_LEAF,

-    36,

-    EMPTY_LEAF,

-

-    /* [21] -> opcode range [0, 512], node depth 6 */

-    1,

-    24,

-    EMPTY_LEAF,

-

-    /* [24] -> opcode range [0, 256], node depth 7 */

-    1,

-    27,

-    EMPTY_LEAF,

-

-    /* [27] -> opcode range [0, 128], node depth 8 */

-    1,

-    30,

-    EMPTY_LEAF,

-

-    /* [30] -> opcode range [0, 64], node depth 9 */

-    1,

-    33,

-    EMPTY_LEAF,

-

-    /* [33] -> opcode range [0, 32], node depth 10 */

-    1,

-    LEAF(0),

-    EMPTY_LEAF,

-

-    /* [36] -> opcode range [1024, 1536], node depth 6 */

-    2,

-    41,

-    EMPTY_LEAF,

-    53,

-    67,

-

-    /* [41] -> opcode range [1024, 1152], node depth 7 */

-    1,

-    44,

-    EMPTY_LEAF,

-

-    /* [44] -> opcode range [1024, 1088], node depth 8 */

-    1,

-    47,

-    EMPTY_LEAF,

-

-    /* [47] -> opcode range [1024, 1056], node depth 9 */

-    1,

-    50,

-    EMPTY_LEAF,

-

-    /* [50] -> opcode range [1024, 1040], node depth 10 */

-    1,

-    LEAF(16),

-    EMPTY_LEAF,

-

-    /* [53] -> opcode range [1280, 1408], node depth 7 */

-    1,

-    56,

-    EMPTY_LEAF,

-

-    /* [56] -> opcode range [1280, 1344], node depth 8 */

-    2,

-    61,

-    LEAF(24),

-    EMPTY_LEAF,

-    64,

-

-    /* [61] -> opcode range [1280, 1296], node depth 9 */

-    1,

-    EMPTY_LEAF,

-    LEAF(40),

-

-    /* [64] -> opcode range [1328, 1344], node depth 9 */

-    1,

-    LEAF(48),

-    EMPTY_LEAF,

-

-    /* [67] -> opcode range [1408, 1536], node depth 7 */

-    1,

-    70,

-    EMPTY_LEAF,

-

-    /* [70] -> opcode range [1408, 1472], node depth 8 */

-    1,

-    73,

-    EMPTY_LEAF,

-

-    /* [73] -> opcode range [1408, 1440], node depth 9 */

-    2,

-    EMPTY_LEAF,

-    LEAF(56),

-    LEAF(64),

-    EMPTY_LEAF,

-

-    /* [78] -> opcode range [4096, 6144], node depth 5 */

-    2,

-    83,

-    EMPTY_LEAF,

-    101,

-    EMPTY_LEAF,

-

-    /* [83] -> opcode range [4096, 4608], node depth 6 */

-    1,

-    86,

-    EMPTY_LEAF,

-

-    /* [86] -> opcode range [4096, 4352], node depth 7 */

-    1,

-    89,

-    EMPTY_LEAF,

-

-    /* [89] -> opcode range [4096, 4224], node depth 8 */

-    1,

-    92,

-    EMPTY_LEAF,

-

-    /* [92] -> opcode range [4096, 4160], node depth 9 */

-    1,

-    95,

-    EMPTY_LEAF,

-

-    /* [95] -> opcode range [4096, 4128], node depth 10 */

-    1,

-    98,

-    EMPTY_LEAF,

-

-    /* [98] -> opcode range [4096, 4112], node depth 11 */

-    1,

-    LEAF(72),

-    EMPTY_LEAF,

-

-    /* [101] -> opcode range [5120, 5632], node depth 6 */

-    1,

-    104,

-    EMPTY_LEAF,

-

-    /* [104] -> opcode range [5120, 5376], node depth 7 */

-    1,

-    107,

-    EMPTY_LEAF,

-

-    /* [107] -> opcode range [5120, 5248], node depth 8 */

-    1,

-    110,

-    EMPTY_LEAF,

-

-    /* [110] -> opcode range [5120, 5184], node depth 9 */

-    1,

-    EMPTY_LEAF,

-    113,

-

-    /* [113] -> opcode range [5152, 5184], node depth 10 */

-    1,

-    116,

-    EMPTY_LEAF,

-

-    /* [116] -> opcode range [5152, 5168], node depth 11 */

-    1,

-    LEAF(80),

-    EMPTY_LEAF,

-

-    /* [119] -> opcode range [65536, 98304], node depth 2 */

-    1,

-    122,

-    EMPTY_LEAF,

-

-    /* [122] -> opcode range [65536, 81920], node depth 3 */

-    1,

-    125,

-    EMPTY_LEAF,

-

-    /* [125] -> opcode range [65536, 73728], node depth 4 */

-    1,

-    128,

-    EMPTY_LEAF,

-

-    /* [128] -> opcode range [65536, 69632], node depth 5 */

-    1,

-    131,

-    EMPTY_LEAF,

-

-    /* [131] -> opcode range [65536, 67584], node depth 6 */

-    1,

-    134,

-    EMPTY_LEAF,

-

-    /* [134] -> opcode range [65536, 66560], node depth 7 */

-    1,

-    137,

-    EMPTY_LEAF,

-

-    /* [137] -> opcode range [65536, 66048], node depth 8 */

-    1,

-    140,

-    EMPTY_LEAF,

-

-    /* [140] -> opcode range [65536, 65792], node depth 9 */

-    1,

-    143,

-    EMPTY_LEAF,

-

-    /* [143] -> opcode range [65536, 65664], node depth 10 */

-    1,

-    146,

-    EMPTY_LEAF,

-

-    /* [146] -> opcode range [65536, 65600], node depth 11 */

-    1,

-    149,

-    EMPTY_LEAF,

-

-    /* [149] -> opcode range [65536, 65568], node depth 12 */

-    1,

-    LEAF(88),

-    EMPTY_LEAF,

-

-};

-

-static const void *VendorPriv_function_table[104][2] = {

-    /* [  0] =     0 */ {NULL, NULL},

-    /* [  1] =     1 */ {__glXDisp_GetConvolutionFilterEXT, __glXDispSwap_GetConvolutionFilterEXT},

-    /* [  2] =     2 */ {__glXDisp_GetConvolutionParameterfvEXT, __glXDispSwap_GetConvolutionParameterfvEXT},

-    /* [  3] =     3 */ {__glXDisp_GetConvolutionParameterivEXT, __glXDispSwap_GetConvolutionParameterivEXT},

-    /* [  4] =     4 */ {__glXDisp_GetSeparableFilterEXT, __glXDispSwap_GetSeparableFilterEXT},

-    /* [  5] =     5 */ {__glXDisp_GetHistogramEXT, __glXDispSwap_GetHistogramEXT},

-    /* [  6] =     6 */ {__glXDisp_GetHistogramParameterfvEXT, __glXDispSwap_GetHistogramParameterfvEXT},

-    /* [  7] =     7 */ {__glXDisp_GetHistogramParameterivEXT, __glXDispSwap_GetHistogramParameterivEXT},

-    /* [  8] =     8 */ {__glXDisp_GetMinmaxEXT, __glXDispSwap_GetMinmaxEXT},

-    /* [  9] =     9 */ {__glXDisp_GetMinmaxParameterfvEXT, __glXDispSwap_GetMinmaxParameterfvEXT},

-    /* [ 10] =    10 */ {__glXDisp_GetMinmaxParameterivEXT, __glXDispSwap_GetMinmaxParameterivEXT},

-    /* [ 11] =    11 */ {__glXDisp_AreTexturesResidentEXT, __glXDispSwap_AreTexturesResidentEXT},

-    /* [ 12] =    12 */ {__glXDisp_DeleteTexturesEXT, __glXDispSwap_DeleteTexturesEXT},

-    /* [ 13] =    13 */ {__glXDisp_GenTexturesEXT, __glXDispSwap_GenTexturesEXT},

-    /* [ 14] =    14 */ {__glXDisp_IsTextureEXT, __glXDispSwap_IsTextureEXT},

-    /* [ 15] =    15 */ {NULL, NULL},

-    /* [ 16] =  1024 */ {__glXDisp_QueryContextInfoEXT, __glXDispSwap_QueryContextInfoEXT},

-    /* [ 17] =  1025 */ {NULL, NULL},

-    /* [ 18] =  1026 */ {NULL, NULL},

-    /* [ 19] =  1027 */ {NULL, NULL},

-    /* [ 20] =  1028 */ {NULL, NULL},

-    /* [ 21] =  1029 */ {NULL, NULL},

-    /* [ 22] =  1030 */ {NULL, NULL},

-    /* [ 23] =  1031 */ {NULL, NULL},

-    /* [ 24] =  1296 */ {__glXDisp_GetProgramEnvParameterfvARB, __glXDispSwap_GetProgramEnvParameterfvARB},

-    /* [ 25] =  1297 */ {__glXDisp_GetProgramEnvParameterdvARB, __glXDispSwap_GetProgramEnvParameterdvARB},

-    /* [ 26] =  1298 */ {__glXDisp_GetProgramivNV, __glXDispSwap_GetProgramivNV},

-    /* [ 27] =  1299 */ {__glXDisp_GetProgramStringNV, __glXDispSwap_GetProgramStringNV},

-    /* [ 28] =  1300 */ {__glXDisp_GetTrackMatrixivNV, __glXDispSwap_GetTrackMatrixivNV},

-    /* [ 29] =  1301 */ {__glXDisp_GetVertexAttribdvARB, __glXDispSwap_GetVertexAttribdvARB},

-    /* [ 30] =  1302 */ {__glXDisp_GetVertexAttribfvARB, __glXDispSwap_GetVertexAttribfvARB},

-    /* [ 31] =  1303 */ {__glXDisp_GetVertexAttribivNV, __glXDispSwap_GetVertexAttribivNV},

-    /* [ 32] =  1304 */ {__glXDisp_IsProgramNV, __glXDispSwap_IsProgramNV},

-    /* [ 33] =  1305 */ {__glXDisp_GetProgramLocalParameterfvARB, __glXDispSwap_GetProgramLocalParameterfvARB},

-    /* [ 34] =  1306 */ {__glXDisp_GetProgramLocalParameterdvARB, __glXDispSwap_GetProgramLocalParameterdvARB},

-    /* [ 35] =  1307 */ {__glXDisp_GetProgramivARB, __glXDispSwap_GetProgramivARB},

-    /* [ 36] =  1308 */ {__glXDisp_GetProgramStringARB, __glXDispSwap_GetProgramStringARB},

-    /* [ 37] =  1309 */ {NULL, NULL},

-    /* [ 38] =  1310 */ {__glXDisp_GetProgramNamedParameterfvNV, __glXDispSwap_GetProgramNamedParameterfvNV},

-    /* [ 39] =  1311 */ {__glXDisp_GetProgramNamedParameterdvNV, __glXDispSwap_GetProgramNamedParameterdvNV},

-    /* [ 40] =  1288 */ {NULL, NULL},

-    /* [ 41] =  1289 */ {NULL, NULL},

-    /* [ 42] =  1290 */ {NULL, NULL},

-    /* [ 43] =  1291 */ {NULL, NULL},

-    /* [ 44] =  1292 */ {NULL, NULL},

-    /* [ 45] =  1293 */ {__glXDisp_AreProgramsResidentNV, __glXDispSwap_AreProgramsResidentNV},

-    /* [ 46] =  1294 */ {__glXDisp_DeleteProgramsNV, __glXDispSwap_DeleteProgramsNV},

-    /* [ 47] =  1295 */ {__glXDisp_GenProgramsNV, __glXDispSwap_GenProgramsNV},

-    /* [ 48] =  1328 */ {NULL, NULL},

-    /* [ 49] =  1329 */ {NULL, NULL},

-    /* [ 50] =  1330 */ {__glXDisp_BindTexImageEXT, __glXDispSwap_BindTexImageEXT},

-    /* [ 51] =  1331 */ {__glXDisp_ReleaseTexImageEXT, __glXDispSwap_ReleaseTexImageEXT},

-    /* [ 52] =  1332 */ {NULL, NULL},

-    /* [ 53] =  1333 */ {NULL, NULL},

-    /* [ 54] =  1334 */ {NULL, NULL},

-    /* [ 55] =  1335 */ {NULL, NULL},

-    /* [ 56] =  1416 */ {NULL, NULL},

-    /* [ 57] =  1417 */ {NULL, NULL},

-    /* [ 58] =  1418 */ {NULL, NULL},

-    /* [ 59] =  1419 */ {NULL, NULL},

-    /* [ 60] =  1420 */ {NULL, NULL},

-    /* [ 61] =  1421 */ {NULL, NULL},

-    /* [ 62] =  1422 */ {__glXDisp_IsRenderbufferEXT, __glXDispSwap_IsRenderbufferEXT},

-    /* [ 63] =  1423 */ {__glXDisp_GenRenderbuffersEXT, __glXDispSwap_GenRenderbuffersEXT},

-    /* [ 64] =  1424 */ {__glXDisp_GetRenderbufferParameterivEXT, __glXDispSwap_GetRenderbufferParameterivEXT},

-    /* [ 65] =  1425 */ {__glXDisp_IsFramebufferEXT, __glXDispSwap_IsFramebufferEXT},

-    /* [ 66] =  1426 */ {__glXDisp_GenFramebuffersEXT, __glXDispSwap_GenFramebuffersEXT},

-    /* [ 67] =  1427 */ {__glXDisp_CheckFramebufferStatusEXT, __glXDispSwap_CheckFramebufferStatusEXT},

-    /* [ 68] =  1428 */ {__glXDisp_GetFramebufferAttachmentParameterivEXT, __glXDispSwap_GetFramebufferAttachmentParameterivEXT},

-    /* [ 69] =  1429 */ {NULL, NULL},

-    /* [ 70] =  1430 */ {NULL, NULL},

-    /* [ 71] =  1431 */ {NULL, NULL},

-    /* [ 72] =  4096 */ {NULL, NULL},

-    /* [ 73] =  4097 */ {NULL, NULL},

-    /* [ 74] =  4098 */ {__glXDisp_GetColorTableSGI, __glXDispSwap_GetColorTableSGI},

-    /* [ 75] =  4099 */ {__glXDisp_GetColorTableParameterfvSGI, __glXDispSwap_GetColorTableParameterfvSGI},

-    /* [ 76] =  4100 */ {__glXDisp_GetColorTableParameterivSGI, __glXDispSwap_GetColorTableParameterivSGI},

-    /* [ 77] =  4101 */ {NULL, NULL},

-    /* [ 78] =  4102 */ {NULL, NULL},

-    /* [ 79] =  4103 */ {NULL, NULL},

-    /* [ 80] =  5152 */ {NULL, NULL},

-    /* [ 81] =  5153 */ {NULL, NULL},

-    /* [ 82] =  5154 */ {__glXDisp_CopySubBufferMESA, __glXDispSwap_CopySubBufferMESA},

-    /* [ 83] =  5155 */ {NULL, NULL},

-    /* [ 84] =  5156 */ {NULL, NULL},

-    /* [ 85] =  5157 */ {NULL, NULL},

-    /* [ 86] =  5158 */ {NULL, NULL},

-    /* [ 87] =  5159 */ {NULL, NULL},

-    /* [ 88] = 65536 */ {__glXDisp_SwapIntervalSGI, __glXDispSwap_SwapIntervalSGI},

-    /* [ 89] = 65537 */ {__glXDisp_MakeCurrentReadSGI, __glXDispSwap_MakeCurrentReadSGI},

-    /* [ 90] = 65538 */ {NULL, NULL},

-    /* [ 91] = 65539 */ {NULL, NULL},

-    /* [ 92] = 65540 */ {__glXDisp_GetFBConfigsSGIX, __glXDispSwap_GetFBConfigsSGIX},

-    /* [ 93] = 65541 */ {__glXDisp_CreateContextWithConfigSGIX, __glXDispSwap_CreateContextWithConfigSGIX},

-    /* [ 94] = 65542 */ {__glXDisp_CreateGLXPixmapWithConfigSGIX, __glXDispSwap_CreateGLXPixmapWithConfigSGIX},

-    /* [ 95] = 65543 */ {__glXDisp_CreateGLXPbufferSGIX, __glXDispSwap_CreateGLXPbufferSGIX},

-    /* [ 96] = 65544 */ {__glXDisp_DestroyGLXPbufferSGIX, __glXDispSwap_DestroyGLXPbufferSGIX},

-    /* [ 97] = 65545 */ {__glXDisp_ChangeDrawableAttributesSGIX, __glXDispSwap_ChangeDrawableAttributesSGIX},

-    /* [ 98] = 65546 */ {__glXDisp_GetDrawableAttributesSGIX, __glXDispSwap_GetDrawableAttributesSGIX},

-    /* [ 99] = 65547 */ {NULL, NULL},

-    /* [ 100] = 65548 */ {NULL, NULL},

-    /* [ 101] = 65549 */ {NULL, NULL},

-    /* [ 102] = 65550 */ {NULL, NULL},

-    /* [ 103] = 65551 */ {NULL, NULL},

-};

-

-const struct __glXDispatchInfo VendorPriv_dispatch_info = {

-    17,

-    VendorPriv_dispatch_tree,

-    VendorPriv_function_table,

-    NULL,

-    NULL

-};

-

+/* DO NOT EDIT - This file generated automatically by glX_server_table.py (from Mesa) script */
+
+/*
+ * (C) Copyright IBM Corporation 2005, 2006
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * IBM,
+ * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef HAVE_DIX_CONFIG_H
+#include "glheader.h"
+#endif
+
+#include <inttypes.h>
+#include "glxserver.h"
+#include "glxext.h"
+#include "indirect_dispatch.h"
+#include "indirect_reqsize.h"
+#include "indirect_table.h"
+
+/*****************************************************************/
+/* tree depth = 3 */
+static const int_fast16_t Single_dispatch_tree[24] = {
+    /* [0] -> opcode range [0, 256], node depth 1 */
+    2,
+    5,
+    13,
+    16,
+    EMPTY_LEAF,
+
+    /* [5] -> opcode range [0, 64], node depth 2 */
+    2,
+    LEAF(0),
+    LEAF(16),
+    10,
+    EMPTY_LEAF,
+
+    /* [10] -> opcode range [32, 48], node depth 3 */
+    1,
+    LEAF(32),
+    EMPTY_LEAF,
+
+    /* [13] -> opcode range [64, 128], node depth 2 */
+    1,
+    EMPTY_LEAF,
+    LEAF(40),
+
+    /* [16] -> opcode range [128, 192], node depth 2 */
+    2,
+    LEAF(72),
+    LEAF(88),
+    21,
+    EMPTY_LEAF,
+
+    /* [21] -> opcode range [160, 176], node depth 3 */
+    1,
+    LEAF(104),
+    EMPTY_LEAF,
+
+};
+
+static const void *Single_function_table[112][2] = {
+    /* [  0] =     0 */ {NULL, NULL},
+    /* [  1] =     1 */ {__glXDisp_Render, __glXDispSwap_Render},
+    /* [  2] =     2 */ {__glXDisp_RenderLarge, __glXDispSwap_RenderLarge},
+    /* [  3] =     3 */ {__glXDisp_CreateContext, __glXDispSwap_CreateContext},
+    /* [  4] =     4 */ {__glXDisp_DestroyContext, __glXDispSwap_DestroyContext},
+    /* [  5] =     5 */ {__glXDisp_MakeCurrent, __glXDispSwap_MakeCurrent},
+    /* [  6] =     6 */ {__glXDisp_IsDirect, __glXDispSwap_IsDirect},
+    /* [  7] =     7 */ {__glXDisp_QueryVersion, __glXDispSwap_QueryVersion},
+    /* [  8] =     8 */ {__glXDisp_WaitGL, __glXDispSwap_WaitGL},
+    /* [  9] =     9 */ {__glXDisp_WaitX, __glXDispSwap_WaitX},
+    /* [ 10] =    10 */ {__glXDisp_CopyContext, __glXDispSwap_CopyContext},
+    /* [ 11] =    11 */ {__glXDisp_SwapBuffers, __glXDispSwap_SwapBuffers},
+    /* [ 12] =    12 */ {__glXDisp_UseXFont, __glXDispSwap_UseXFont},
+    /* [ 13] =    13 */ {__glXDisp_CreateGLXPixmap, __glXDispSwap_CreateGLXPixmap},
+    /* [ 14] =    14 */ {__glXDisp_GetVisualConfigs, __glXDispSwap_GetVisualConfigs},
+    /* [ 15] =    15 */ {__glXDisp_DestroyGLXPixmap, __glXDispSwap_DestroyGLXPixmap},
+    /* [ 16] =    16 */ {__glXDisp_VendorPrivate, __glXDispSwap_VendorPrivate},
+    /* [ 17] =    17 */ {__glXDisp_VendorPrivateWithReply, __glXDispSwap_VendorPrivateWithReply},
+    /* [ 18] =    18 */ {__glXDisp_QueryExtensionsString, __glXDispSwap_QueryExtensionsString},
+    /* [ 19] =    19 */ {__glXDisp_QueryServerString, __glXDispSwap_QueryServerString},
+    /* [ 20] =    20 */ {__glXDisp_ClientInfo, __glXDispSwap_ClientInfo},
+    /* [ 21] =    21 */ {__glXDisp_GetFBConfigs, __glXDispSwap_GetFBConfigs},
+    /* [ 22] =    22 */ {__glXDisp_CreatePixmap, __glXDispSwap_CreatePixmap},
+    /* [ 23] =    23 */ {__glXDisp_DestroyPixmap, __glXDispSwap_DestroyPixmap},
+    /* [ 24] =    24 */ {__glXDisp_CreateNewContext, __glXDispSwap_CreateNewContext},
+    /* [ 25] =    25 */ {__glXDisp_QueryContext, __glXDispSwap_QueryContext},
+    /* [ 26] =    26 */ {__glXDisp_MakeContextCurrent, __glXDispSwap_MakeContextCurrent},
+    /* [ 27] =    27 */ {__glXDisp_CreatePbuffer, __glXDispSwap_CreatePbuffer},
+    /* [ 28] =    28 */ {__glXDisp_DestroyPbuffer, __glXDispSwap_DestroyPbuffer},
+    /* [ 29] =    29 */ {__glXDisp_GetDrawableAttributes, __glXDispSwap_GetDrawableAttributes},
+    /* [ 30] =    30 */ {__glXDisp_ChangeDrawableAttributes, __glXDispSwap_ChangeDrawableAttributes},
+    /* [ 31] =    31 */ {__glXDisp_CreateWindow, __glXDispSwap_CreateWindow},
+    /* [ 32] =    32 */ {__glXDisp_DestroyWindow, __glXDispSwap_DestroyWindow},
+    /* [ 33] =    33 */ {NULL, NULL},
+    /* [ 34] =    34 */ {NULL, NULL},
+    /* [ 35] =    35 */ {NULL, NULL},
+    /* [ 36] =    36 */ {NULL, NULL},
+    /* [ 37] =    37 */ {NULL, NULL},
+    /* [ 38] =    38 */ {NULL, NULL},
+    /* [ 39] =    39 */ {NULL, NULL},
+    /* [ 40] =    96 */ {NULL, NULL},
+    /* [ 41] =    97 */ {NULL, NULL},
+    /* [ 42] =    98 */ {NULL, NULL},
+    /* [ 43] =    99 */ {NULL, NULL},
+    /* [ 44] =   100 */ {NULL, NULL},
+    /* [ 45] =   101 */ {__glXDisp_NewList, __glXDispSwap_NewList},
+    /* [ 46] =   102 */ {__glXDisp_EndList, __glXDispSwap_EndList},
+    /* [ 47] =   103 */ {__glXDisp_DeleteLists, __glXDispSwap_DeleteLists},
+    /* [ 48] =   104 */ {__glXDisp_GenLists, __glXDispSwap_GenLists},
+    /* [ 49] =   105 */ {__glXDisp_FeedbackBuffer, __glXDispSwap_FeedbackBuffer},
+    /* [ 50] =   106 */ {__glXDisp_SelectBuffer, __glXDispSwap_SelectBuffer},
+    /* [ 51] =   107 */ {__glXDisp_RenderMode, __glXDispSwap_RenderMode},
+    /* [ 52] =   108 */ {__glXDisp_Finish, __glXDispSwap_Finish},
+    /* [ 53] =   109 */ {__glXDisp_PixelStoref, __glXDispSwap_PixelStoref},
+    /* [ 54] =   110 */ {__glXDisp_PixelStorei, __glXDispSwap_PixelStorei},
+    /* [ 55] =   111 */ {__glXDisp_ReadPixels, __glXDispSwap_ReadPixels},
+    /* [ 56] =   112 */ {__glXDisp_GetBooleanv, __glXDispSwap_GetBooleanv},
+    /* [ 57] =   113 */ {__glXDisp_GetClipPlane, __glXDispSwap_GetClipPlane},
+    /* [ 58] =   114 */ {__glXDisp_GetDoublev, __glXDispSwap_GetDoublev},
+    /* [ 59] =   115 */ {__glXDisp_GetError, __glXDispSwap_GetError},
+    /* [ 60] =   116 */ {__glXDisp_GetFloatv, __glXDispSwap_GetFloatv},
+    /* [ 61] =   117 */ {__glXDisp_GetIntegerv, __glXDispSwap_GetIntegerv},
+    /* [ 62] =   118 */ {__glXDisp_GetLightfv, __glXDispSwap_GetLightfv},
+    /* [ 63] =   119 */ {__glXDisp_GetLightiv, __glXDispSwap_GetLightiv},
+    /* [ 64] =   120 */ {__glXDisp_GetMapdv, __glXDispSwap_GetMapdv},
+    /* [ 65] =   121 */ {__glXDisp_GetMapfv, __glXDispSwap_GetMapfv},
+    /* [ 66] =   122 */ {__glXDisp_GetMapiv, __glXDispSwap_GetMapiv},
+    /* [ 67] =   123 */ {__glXDisp_GetMaterialfv, __glXDispSwap_GetMaterialfv},
+    /* [ 68] =   124 */ {__glXDisp_GetMaterialiv, __glXDispSwap_GetMaterialiv},
+    /* [ 69] =   125 */ {__glXDisp_GetPixelMapfv, __glXDispSwap_GetPixelMapfv},
+    /* [ 70] =   126 */ {__glXDisp_GetPixelMapuiv, __glXDispSwap_GetPixelMapuiv},
+    /* [ 71] =   127 */ {__glXDisp_GetPixelMapusv, __glXDispSwap_GetPixelMapusv},
+    /* [ 72] =   128 */ {__glXDisp_GetPolygonStipple, __glXDispSwap_GetPolygonStipple},
+    /* [ 73] =   129 */ {__glXDisp_GetString, __glXDispSwap_GetString},
+    /* [ 74] =   130 */ {__glXDisp_GetTexEnvfv, __glXDispSwap_GetTexEnvfv},
+    /* [ 75] =   131 */ {__glXDisp_GetTexEnviv, __glXDispSwap_GetTexEnviv},
+    /* [ 76] =   132 */ {__glXDisp_GetTexGendv, __glXDispSwap_GetTexGendv},
+    /* [ 77] =   133 */ {__glXDisp_GetTexGenfv, __glXDispSwap_GetTexGenfv},
+    /* [ 78] =   134 */ {__glXDisp_GetTexGeniv, __glXDispSwap_GetTexGeniv},
+    /* [ 79] =   135 */ {__glXDisp_GetTexImage, __glXDispSwap_GetTexImage},
+    /* [ 80] =   136 */ {__glXDisp_GetTexParameterfv, __glXDispSwap_GetTexParameterfv},
+    /* [ 81] =   137 */ {__glXDisp_GetTexParameteriv, __glXDispSwap_GetTexParameteriv},
+    /* [ 82] =   138 */ {__glXDisp_GetTexLevelParameterfv, __glXDispSwap_GetTexLevelParameterfv},
+    /* [ 83] =   139 */ {__glXDisp_GetTexLevelParameteriv, __glXDispSwap_GetTexLevelParameteriv},
+    /* [ 84] =   140 */ {__glXDisp_IsEnabled, __glXDispSwap_IsEnabled},
+    /* [ 85] =   141 */ {__glXDisp_IsList, __glXDispSwap_IsList},
+    /* [ 86] =   142 */ {__glXDisp_Flush, __glXDispSwap_Flush},
+    /* [ 87] =   143 */ {__glXDisp_AreTexturesResident, __glXDispSwap_AreTexturesResident},
+    /* [ 88] =   144 */ {__glXDisp_DeleteTextures, __glXDispSwap_DeleteTextures},
+    /* [ 89] =   145 */ {__glXDisp_GenTextures, __glXDispSwap_GenTextures},
+    /* [ 90] =   146 */ {__glXDisp_IsTexture, __glXDispSwap_IsTexture},
+    /* [ 91] =   147 */ {__glXDisp_GetColorTable, __glXDispSwap_GetColorTable},
+    /* [ 92] =   148 */ {__glXDisp_GetColorTableParameterfv, __glXDispSwap_GetColorTableParameterfv},
+    /* [ 93] =   149 */ {__glXDisp_GetColorTableParameteriv, __glXDispSwap_GetColorTableParameteriv},
+    /* [ 94] =   150 */ {__glXDisp_GetConvolutionFilter, __glXDispSwap_GetConvolutionFilter},
+    /* [ 95] =   151 */ {__glXDisp_GetConvolutionParameterfv, __glXDispSwap_GetConvolutionParameterfv},
+    /* [ 96] =   152 */ {__glXDisp_GetConvolutionParameteriv, __glXDispSwap_GetConvolutionParameteriv},
+    /* [ 97] =   153 */ {__glXDisp_GetSeparableFilter, __glXDispSwap_GetSeparableFilter},
+    /* [ 98] =   154 */ {__glXDisp_GetHistogram, __glXDispSwap_GetHistogram},
+    /* [ 99] =   155 */ {__glXDisp_GetHistogramParameterfv, __glXDispSwap_GetHistogramParameterfv},
+    /* [ 100] =   156 */ {__glXDisp_GetHistogramParameteriv, __glXDispSwap_GetHistogramParameteriv},
+    /* [ 101] =   157 */ {__glXDisp_GetMinmax, __glXDispSwap_GetMinmax},
+    /* [ 102] =   158 */ {__glXDisp_GetMinmaxParameterfv, __glXDispSwap_GetMinmaxParameterfv},
+    /* [ 103] =   159 */ {__glXDisp_GetMinmaxParameteriv, __glXDispSwap_GetMinmaxParameteriv},
+    /* [ 104] =   160 */ {__glXDisp_GetCompressedTexImageARB, __glXDispSwap_GetCompressedTexImageARB},
+    /* [ 105] =   161 */ {__glXDisp_DeleteQueriesARB, __glXDispSwap_DeleteQueriesARB},
+    /* [ 106] =   162 */ {__glXDisp_GenQueriesARB, __glXDispSwap_GenQueriesARB},
+    /* [ 107] =   163 */ {__glXDisp_IsQueryARB, __glXDispSwap_IsQueryARB},
+    /* [ 108] =   164 */ {__glXDisp_GetQueryivARB, __glXDispSwap_GetQueryivARB},
+    /* [ 109] =   165 */ {__glXDisp_GetQueryObjectivARB, __glXDispSwap_GetQueryObjectivARB},
+    /* [ 110] =   166 */ {__glXDisp_GetQueryObjectuivARB, __glXDispSwap_GetQueryObjectuivARB},
+    /* [ 111] =   167 */ {NULL, NULL},
+};
+
+const struct __glXDispatchInfo Single_dispatch_info = {
+    8,
+    Single_dispatch_tree,
+    Single_function_table,
+    NULL,
+    NULL
+};
+
+/*****************************************************************/
+/* tree depth = 8 */
+static const int_fast16_t Render_dispatch_tree[92] = {
+    /* [0] -> opcode range [0, 8192], node depth 1 */
+    2,
+    5,
+    31,
+    54,
+    EMPTY_LEAF,
+
+    /* [5] -> opcode range [0, 2048], node depth 2 */
+    1,
+    8,
+    EMPTY_LEAF,
+
+    /* [8] -> opcode range [0, 1024], node depth 3 */
+    1,
+    11,
+    EMPTY_LEAF,
+
+    /* [11] -> opcode range [0, 512], node depth 4 */
+    1,
+    14,
+    EMPTY_LEAF,
+
+    /* [14] -> opcode range [0, 256], node depth 5 */
+    4,
+    LEAF(0),
+    LEAF(16),
+    LEAF(32),
+    LEAF(48),
+    LEAF(64),
+    LEAF(80),
+    LEAF(96),
+    LEAF(112),
+    LEAF(128),
+    LEAF(144),
+    LEAF(160),
+    LEAF(176),
+    LEAF(192),
+    LEAF(208),
+    LEAF(224),
+    EMPTY_LEAF,
+
+    /* [31] -> opcode range [2048, 4096], node depth 2 */
+    1,
+    34,
+    EMPTY_LEAF,
+
+    /* [34] -> opcode range [2048, 3072], node depth 3 */
+    1,
+    37,
+    EMPTY_LEAF,
+
+    /* [37] -> opcode range [2048, 2560], node depth 4 */
+    1,
+    40,
+    EMPTY_LEAF,
+
+    /* [40] -> opcode range [2048, 2304], node depth 5 */
+    1,
+    43,
+    EMPTY_LEAF,
+
+    /* [43] -> opcode range [2048, 2176], node depth 6 */
+    1,
+    46,
+    EMPTY_LEAF,
+
+    /* [46] -> opcode range [2048, 2112], node depth 7 */
+    1,
+    49,
+    EMPTY_LEAF,
+
+    /* [49] -> opcode range [2048, 2080], node depth 8 */
+    2,
+    LEAF(240),
+    LEAF(248),
+    LEAF(256),
+    EMPTY_LEAF,
+
+    /* [54] -> opcode range [4096, 6144], node depth 2 */
+    1,
+    57,
+    EMPTY_LEAF,
+
+    /* [57] -> opcode range [4096, 5120], node depth 3 */
+    1,
+    60,
+    EMPTY_LEAF,
+
+    /* [60] -> opcode range [4096, 4608], node depth 4 */
+    1,
+    63,
+    EMPTY_LEAF,
+
+    /* [63] -> opcode range [4096, 4352], node depth 5 */
+    4,
+    LEAF(264),
+    LEAF(280),
+    80,
+    EMPTY_LEAF,
+    EMPTY_LEAF,
+    LEAF(296),
+    LEAF(312),
+    LEAF(328),
+    LEAF(344),
+    EMPTY_LEAF,
+    83,
+    86,
+    EMPTY_LEAF,
+    89,
+    LEAF(360),
+    EMPTY_LEAF,
+
+    /* [80] -> opcode range [4128, 4144], node depth 6 */
+    1,
+    LEAF(376),
+    EMPTY_LEAF,
+
+    /* [83] -> opcode range [4256, 4272], node depth 6 */
+    1,
+    EMPTY_LEAF,
+    LEAF(384),
+
+    /* [86] -> opcode range [4272, 4288], node depth 6 */
+    1,
+    LEAF(392),
+    EMPTY_LEAF,
+
+    /* [89] -> opcode range [4304, 4320], node depth 6 */
+    1,
+    EMPTY_LEAF,
+    LEAF(400),
+
+};
+
+static const void *Render_function_table[408][2] = {
+    /* [  0] =     0 */ {NULL, NULL},
+    /* [  1] =     1 */ {__glXDisp_CallList, __glXDispSwap_CallList},
+    /* [  2] =     2 */ {__glXDisp_CallLists, __glXDispSwap_CallLists},
+    /* [  3] =     3 */ {__glXDisp_ListBase, __glXDispSwap_ListBase},
+    /* [  4] =     4 */ {__glXDisp_Begin, __glXDispSwap_Begin},
+    /* [  5] =     5 */ {__glXDisp_Bitmap, __glXDispSwap_Bitmap},
+    /* [  6] =     6 */ {__glXDisp_Color3bv, __glXDispSwap_Color3bv},
+    /* [  7] =     7 */ {__glXDisp_Color3dv, __glXDispSwap_Color3dv},
+    /* [  8] =     8 */ {__glXDisp_Color3fv, __glXDispSwap_Color3fv},
+    /* [  9] =     9 */ {__glXDisp_Color3iv, __glXDispSwap_Color3iv},
+    /* [ 10] =    10 */ {__glXDisp_Color3sv, __glXDispSwap_Color3sv},
+    /* [ 11] =    11 */ {__glXDisp_Color3ubv, __glXDispSwap_Color3ubv},
+    /* [ 12] =    12 */ {__glXDisp_Color3uiv, __glXDispSwap_Color3uiv},
+    /* [ 13] =    13 */ {__glXDisp_Color3usv, __glXDispSwap_Color3usv},
+    /* [ 14] =    14 */ {__glXDisp_Color4bv, __glXDispSwap_Color4bv},
+    /* [ 15] =    15 */ {__glXDisp_Color4dv, __glXDispSwap_Color4dv},
+    /* [ 16] =    16 */ {__glXDisp_Color4fv, __glXDispSwap_Color4fv},
+    /* [ 17] =    17 */ {__glXDisp_Color4iv, __glXDispSwap_Color4iv},
+    /* [ 18] =    18 */ {__glXDisp_Color4sv, __glXDispSwap_Color4sv},
+    /* [ 19] =    19 */ {__glXDisp_Color4ubv, __glXDispSwap_Color4ubv},
+    /* [ 20] =    20 */ {__glXDisp_Color4uiv, __glXDispSwap_Color4uiv},
+    /* [ 21] =    21 */ {__glXDisp_Color4usv, __glXDispSwap_Color4usv},
+    /* [ 22] =    22 */ {__glXDisp_EdgeFlagv, __glXDispSwap_EdgeFlagv},
+    /* [ 23] =    23 */ {__glXDisp_End, __glXDispSwap_End},
+    /* [ 24] =    24 */ {__glXDisp_Indexdv, __glXDispSwap_Indexdv},
+    /* [ 25] =    25 */ {__glXDisp_Indexfv, __glXDispSwap_Indexfv},
+    /* [ 26] =    26 */ {__glXDisp_Indexiv, __glXDispSwap_Indexiv},
+    /* [ 27] =    27 */ {__glXDisp_Indexsv, __glXDispSwap_Indexsv},
+    /* [ 28] =    28 */ {__glXDisp_Normal3bv, __glXDispSwap_Normal3bv},
+    /* [ 29] =    29 */ {__glXDisp_Normal3dv, __glXDispSwap_Normal3dv},
+    /* [ 30] =    30 */ {__glXDisp_Normal3fv, __glXDispSwap_Normal3fv},
+    /* [ 31] =    31 */ {__glXDisp_Normal3iv, __glXDispSwap_Normal3iv},
+    /* [ 32] =    32 */ {__glXDisp_Normal3sv, __glXDispSwap_Normal3sv},
+    /* [ 33] =    33 */ {__glXDisp_RasterPos2dv, __glXDispSwap_RasterPos2dv},
+    /* [ 34] =    34 */ {__glXDisp_RasterPos2fv, __glXDispSwap_RasterPos2fv},
+    /* [ 35] =    35 */ {__glXDisp_RasterPos2iv, __glXDispSwap_RasterPos2iv},
+    /* [ 36] =    36 */ {__glXDisp_RasterPos2sv, __glXDispSwap_RasterPos2sv},
+    /* [ 37] =    37 */ {__glXDisp_RasterPos3dv, __glXDispSwap_RasterPos3dv},
+    /* [ 38] =    38 */ {__glXDisp_RasterPos3fv, __glXDispSwap_RasterPos3fv},
+    /* [ 39] =    39 */ {__glXDisp_RasterPos3iv, __glXDispSwap_RasterPos3iv},
+    /* [ 40] =    40 */ {__glXDisp_RasterPos3sv, __glXDispSwap_RasterPos3sv},
+    /* [ 41] =    41 */ {__glXDisp_RasterPos4dv, __glXDispSwap_RasterPos4dv},
+    /* [ 42] =    42 */ {__glXDisp_RasterPos4fv, __glXDispSwap_RasterPos4fv},
+    /* [ 43] =    43 */ {__glXDisp_RasterPos4iv, __glXDispSwap_RasterPos4iv},
+    /* [ 44] =    44 */ {__glXDisp_RasterPos4sv, __glXDispSwap_RasterPos4sv},
+    /* [ 45] =    45 */ {__glXDisp_Rectdv, __glXDispSwap_Rectdv},
+    /* [ 46] =    46 */ {__glXDisp_Rectfv, __glXDispSwap_Rectfv},
+    /* [ 47] =    47 */ {__glXDisp_Rectiv, __glXDispSwap_Rectiv},
+    /* [ 48] =    48 */ {__glXDisp_Rectsv, __glXDispSwap_Rectsv},
+    /* [ 49] =    49 */ {__glXDisp_TexCoord1dv, __glXDispSwap_TexCoord1dv},
+    /* [ 50] =    50 */ {__glXDisp_TexCoord1fv, __glXDispSwap_TexCoord1fv},
+    /* [ 51] =    51 */ {__glXDisp_TexCoord1iv, __glXDispSwap_TexCoord1iv},
+    /* [ 52] =    52 */ {__glXDisp_TexCoord1sv, __glXDispSwap_TexCoord1sv},
+    /* [ 53] =    53 */ {__glXDisp_TexCoord2dv, __glXDispSwap_TexCoord2dv},
+    /* [ 54] =    54 */ {__glXDisp_TexCoord2fv, __glXDispSwap_TexCoord2fv},
+    /* [ 55] =    55 */ {__glXDisp_TexCoord2iv, __glXDispSwap_TexCoord2iv},
+    /* [ 56] =    56 */ {__glXDisp_TexCoord2sv, __glXDispSwap_TexCoord2sv},
+    /* [ 57] =    57 */ {__glXDisp_TexCoord3dv, __glXDispSwap_TexCoord3dv},
+    /* [ 58] =    58 */ {__glXDisp_TexCoord3fv, __glXDispSwap_TexCoord3fv},
+    /* [ 59] =    59 */ {__glXDisp_TexCoord3iv, __glXDispSwap_TexCoord3iv},
+    /* [ 60] =    60 */ {__glXDisp_TexCoord3sv, __glXDispSwap_TexCoord3sv},
+    /* [ 61] =    61 */ {__glXDisp_TexCoord4dv, __glXDispSwap_TexCoord4dv},
+    /* [ 62] =    62 */ {__glXDisp_TexCoord4fv, __glXDispSwap_TexCoord4fv},
+    /* [ 63] =    63 */ {__glXDisp_TexCoord4iv, __glXDispSwap_TexCoord4iv},
+    /* [ 64] =    64 */ {__glXDisp_TexCoord4sv, __glXDispSwap_TexCoord4sv},
+    /* [ 65] =    65 */ {__glXDisp_Vertex2dv, __glXDispSwap_Vertex2dv},
+    /* [ 66] =    66 */ {__glXDisp_Vertex2fv, __glXDispSwap_Vertex2fv},
+    /* [ 67] =    67 */ {__glXDisp_Vertex2iv, __glXDispSwap_Vertex2iv},
+    /* [ 68] =    68 */ {__glXDisp_Vertex2sv, __glXDispSwap_Vertex2sv},
+    /* [ 69] =    69 */ {__glXDisp_Vertex3dv, __glXDispSwap_Vertex3dv},
+    /* [ 70] =    70 */ {__glXDisp_Vertex3fv, __glXDispSwap_Vertex3fv},
+    /* [ 71] =    71 */ {__glXDisp_Vertex3iv, __glXDispSwap_Vertex3iv},
+    /* [ 72] =    72 */ {__glXDisp_Vertex3sv, __glXDispSwap_Vertex3sv},
+    /* [ 73] =    73 */ {__glXDisp_Vertex4dv, __glXDispSwap_Vertex4dv},
+    /* [ 74] =    74 */ {__glXDisp_Vertex4fv, __glXDispSwap_Vertex4fv},
+    /* [ 75] =    75 */ {__glXDisp_Vertex4iv, __glXDispSwap_Vertex4iv},
+    /* [ 76] =    76 */ {__glXDisp_Vertex4sv, __glXDispSwap_Vertex4sv},
+    /* [ 77] =    77 */ {__glXDisp_ClipPlane, __glXDispSwap_ClipPlane},
+    /* [ 78] =    78 */ {__glXDisp_ColorMaterial, __glXDispSwap_ColorMaterial},
+    /* [ 79] =    79 */ {__glXDisp_CullFace, __glXDispSwap_CullFace},
+    /* [ 80] =    80 */ {__glXDisp_Fogf, __glXDispSwap_Fogf},
+    /* [ 81] =    81 */ {__glXDisp_Fogfv, __glXDispSwap_Fogfv},
+    /* [ 82] =    82 */ {__glXDisp_Fogi, __glXDispSwap_Fogi},
+    /* [ 83] =    83 */ {__glXDisp_Fogiv, __glXDispSwap_Fogiv},
+    /* [ 84] =    84 */ {__glXDisp_FrontFace, __glXDispSwap_FrontFace},
+    /* [ 85] =    85 */ {__glXDisp_Hint, __glXDispSwap_Hint},
+    /* [ 86] =    86 */ {__glXDisp_Lightf, __glXDispSwap_Lightf},
+    /* [ 87] =    87 */ {__glXDisp_Lightfv, __glXDispSwap_Lightfv},
+    /* [ 88] =    88 */ {__glXDisp_Lighti, __glXDispSwap_Lighti},
+    /* [ 89] =    89 */ {__glXDisp_Lightiv, __glXDispSwap_Lightiv},
+    /* [ 90] =    90 */ {__glXDisp_LightModelf, __glXDispSwap_LightModelf},
+    /* [ 91] =    91 */ {__glXDisp_LightModelfv, __glXDispSwap_LightModelfv},
+    /* [ 92] =    92 */ {__glXDisp_LightModeli, __glXDispSwap_LightModeli},
+    /* [ 93] =    93 */ {__glXDisp_LightModeliv, __glXDispSwap_LightModeliv},
+    /* [ 94] =    94 */ {__glXDisp_LineStipple, __glXDispSwap_LineStipple},
+    /* [ 95] =    95 */ {__glXDisp_LineWidth, __glXDispSwap_LineWidth},
+    /* [ 96] =    96 */ {__glXDisp_Materialf, __glXDispSwap_Materialf},
+    /* [ 97] =    97 */ {__glXDisp_Materialfv, __glXDispSwap_Materialfv},
+    /* [ 98] =    98 */ {__glXDisp_Materiali, __glXDispSwap_Materiali},
+    /* [ 99] =    99 */ {__glXDisp_Materialiv, __glXDispSwap_Materialiv},
+    /* [ 100] =   100 */ {__glXDisp_PointSize, __glXDispSwap_PointSize},
+    /* [ 101] =   101 */ {__glXDisp_PolygonMode, __glXDispSwap_PolygonMode},
+    /* [ 102] =   102 */ {__glXDisp_PolygonStipple, __glXDispSwap_PolygonStipple},
+    /* [ 103] =   103 */ {__glXDisp_Scissor, __glXDispSwap_Scissor},
+    /* [ 104] =   104 */ {__glXDisp_ShadeModel, __glXDispSwap_ShadeModel},
+    /* [ 105] =   105 */ {__glXDisp_TexParameterf, __glXDispSwap_TexParameterf},
+    /* [ 106] =   106 */ {__glXDisp_TexParameterfv, __glXDispSwap_TexParameterfv},
+    /* [ 107] =   107 */ {__glXDisp_TexParameteri, __glXDispSwap_TexParameteri},
+    /* [ 108] =   108 */ {__glXDisp_TexParameteriv, __glXDispSwap_TexParameteriv},
+    /* [ 109] =   109 */ {__glXDisp_TexImage1D, __glXDispSwap_TexImage1D},
+    /* [ 110] =   110 */ {__glXDisp_TexImage2D, __glXDispSwap_TexImage2D},
+    /* [ 111] =   111 */ {__glXDisp_TexEnvf, __glXDispSwap_TexEnvf},
+    /* [ 112] =   112 */ {__glXDisp_TexEnvfv, __glXDispSwap_TexEnvfv},
+    /* [ 113] =   113 */ {__glXDisp_TexEnvi, __glXDispSwap_TexEnvi},
+    /* [ 114] =   114 */ {__glXDisp_TexEnviv, __glXDispSwap_TexEnviv},
+    /* [ 115] =   115 */ {__glXDisp_TexGend, __glXDispSwap_TexGend},
+    /* [ 116] =   116 */ {__glXDisp_TexGendv, __glXDispSwap_TexGendv},
+    /* [ 117] =   117 */ {__glXDisp_TexGenf, __glXDispSwap_TexGenf},
+    /* [ 118] =   118 */ {__glXDisp_TexGenfv, __glXDispSwap_TexGenfv},
+    /* [ 119] =   119 */ {__glXDisp_TexGeni, __glXDispSwap_TexGeni},
+    /* [ 120] =   120 */ {__glXDisp_TexGeniv, __glXDispSwap_TexGeniv},
+    /* [ 121] =   121 */ {__glXDisp_InitNames, __glXDispSwap_InitNames},
+    /* [ 122] =   122 */ {__glXDisp_LoadName, __glXDispSwap_LoadName},
+    /* [ 123] =   123 */ {__glXDisp_PassThrough, __glXDispSwap_PassThrough},
+    /* [ 124] =   124 */ {__glXDisp_PopName, __glXDispSwap_PopName},
+    /* [ 125] =   125 */ {__glXDisp_PushName, __glXDispSwap_PushName},
+    /* [ 126] =   126 */ {__glXDisp_DrawBuffer, __glXDispSwap_DrawBuffer},
+    /* [ 127] =   127 */ {__glXDisp_Clear, __glXDispSwap_Clear},
+    /* [ 128] =   128 */ {__glXDisp_ClearAccum, __glXDispSwap_ClearAccum},
+    /* [ 129] =   129 */ {__glXDisp_ClearIndex, __glXDispSwap_ClearIndex},
+    /* [ 130] =   130 */ {__glXDisp_ClearColor, __glXDispSwap_ClearColor},
+    /* [ 131] =   131 */ {__glXDisp_ClearStencil, __glXDispSwap_ClearStencil},
+    /* [ 132] =   132 */ {__glXDisp_ClearDepth, __glXDispSwap_ClearDepth},
+    /* [ 133] =   133 */ {__glXDisp_StencilMask, __glXDispSwap_StencilMask},
+    /* [ 134] =   134 */ {__glXDisp_ColorMask, __glXDispSwap_ColorMask},
+    /* [ 135] =   135 */ {__glXDisp_DepthMask, __glXDispSwap_DepthMask},
+    /* [ 136] =   136 */ {__glXDisp_IndexMask, __glXDispSwap_IndexMask},
+    /* [ 137] =   137 */ {__glXDisp_Accum, __glXDispSwap_Accum},
+    /* [ 138] =   138 */ {__glXDisp_Disable, __glXDispSwap_Disable},
+    /* [ 139] =   139 */ {__glXDisp_Enable, __glXDispSwap_Enable},
+    /* [ 140] =   140 */ {NULL, NULL},
+    /* [ 141] =   141 */ {__glXDisp_PopAttrib, __glXDispSwap_PopAttrib},
+    /* [ 142] =   142 */ {__glXDisp_PushAttrib, __glXDispSwap_PushAttrib},
+    /* [ 143] =   143 */ {__glXDisp_Map1d, __glXDispSwap_Map1d},
+    /* [ 144] =   144 */ {__glXDisp_Map1f, __glXDispSwap_Map1f},
+    /* [ 145] =   145 */ {__glXDisp_Map2d, __glXDispSwap_Map2d},
+    /* [ 146] =   146 */ {__glXDisp_Map2f, __glXDispSwap_Map2f},
+    /* [ 147] =   147 */ {__glXDisp_MapGrid1d, __glXDispSwap_MapGrid1d},
+    /* [ 148] =   148 */ {__glXDisp_MapGrid1f, __glXDispSwap_MapGrid1f},
+    /* [ 149] =   149 */ {__glXDisp_MapGrid2d, __glXDispSwap_MapGrid2d},
+    /* [ 150] =   150 */ {__glXDisp_MapGrid2f, __glXDispSwap_MapGrid2f},
+    /* [ 151] =   151 */ {__glXDisp_EvalCoord1dv, __glXDispSwap_EvalCoord1dv},
+    /* [ 152] =   152 */ {__glXDisp_EvalCoord1fv, __glXDispSwap_EvalCoord1fv},
+    /* [ 153] =   153 */ {__glXDisp_EvalCoord2dv, __glXDispSwap_EvalCoord2dv},
+    /* [ 154] =   154 */ {__glXDisp_EvalCoord2fv, __glXDispSwap_EvalCoord2fv},
+    /* [ 155] =   155 */ {__glXDisp_EvalMesh1, __glXDispSwap_EvalMesh1},
+    /* [ 156] =   156 */ {__glXDisp_EvalPoint1, __glXDispSwap_EvalPoint1},
+    /* [ 157] =   157 */ {__glXDisp_EvalMesh2, __glXDispSwap_EvalMesh2},
+    /* [ 158] =   158 */ {__glXDisp_EvalPoint2, __glXDispSwap_EvalPoint2},
+    /* [ 159] =   159 */ {__glXDisp_AlphaFunc, __glXDispSwap_AlphaFunc},
+    /* [ 160] =   160 */ {__glXDisp_BlendFunc, __glXDispSwap_BlendFunc},
+    /* [ 161] =   161 */ {__glXDisp_LogicOp, __glXDispSwap_LogicOp},
+    /* [ 162] =   162 */ {__glXDisp_StencilFunc, __glXDispSwap_StencilFunc},
+    /* [ 163] =   163 */ {__glXDisp_StencilOp, __glXDispSwap_StencilOp},
+    /* [ 164] =   164 */ {__glXDisp_DepthFunc, __glXDispSwap_DepthFunc},
+    /* [ 165] =   165 */ {__glXDisp_PixelZoom, __glXDispSwap_PixelZoom},
+    /* [ 166] =   166 */ {__glXDisp_PixelTransferf, __glXDispSwap_PixelTransferf},
+    /* [ 167] =   167 */ {__glXDisp_PixelTransferi, __glXDispSwap_PixelTransferi},
+    /* [ 168] =   168 */ {__glXDisp_PixelMapfv, __glXDispSwap_PixelMapfv},
+    /* [ 169] =   169 */ {__glXDisp_PixelMapuiv, __glXDispSwap_PixelMapuiv},
+    /* [ 170] =   170 */ {__glXDisp_PixelMapusv, __glXDispSwap_PixelMapusv},
+    /* [ 171] =   171 */ {__glXDisp_ReadBuffer, __glXDispSwap_ReadBuffer},
+    /* [ 172] =   172 */ {__glXDisp_CopyPixels, __glXDispSwap_CopyPixels},
+    /* [ 173] =   173 */ {__glXDisp_DrawPixels, __glXDispSwap_DrawPixels},
+    /* [ 174] =   174 */ {__glXDisp_DepthRange, __glXDispSwap_DepthRange},
+    /* [ 175] =   175 */ {__glXDisp_Frustum, __glXDispSwap_Frustum},
+    /* [ 176] =   176 */ {__glXDisp_LoadIdentity, __glXDispSwap_LoadIdentity},
+    /* [ 177] =   177 */ {__glXDisp_LoadMatrixf, __glXDispSwap_LoadMatrixf},
+    /* [ 178] =   178 */ {__glXDisp_LoadMatrixd, __glXDispSwap_LoadMatrixd},
+    /* [ 179] =   179 */ {__glXDisp_MatrixMode, __glXDispSwap_MatrixMode},
+    /* [ 180] =   180 */ {__glXDisp_MultMatrixf, __glXDispSwap_MultMatrixf},
+    /* [ 181] =   181 */ {__glXDisp_MultMatrixd, __glXDispSwap_MultMatrixd},
+    /* [ 182] =   182 */ {__glXDisp_Ortho, __glXDispSwap_Ortho},
+    /* [ 183] =   183 */ {__glXDisp_PopMatrix, __glXDispSwap_PopMatrix},
+    /* [ 184] =   184 */ {__glXDisp_PushMatrix, __glXDispSwap_PushMatrix},
+    /* [ 185] =   185 */ {__glXDisp_Rotated, __glXDispSwap_Rotated},
+    /* [ 186] =   186 */ {__glXDisp_Rotatef, __glXDispSwap_Rotatef},
+    /* [ 187] =   187 */ {__glXDisp_Scaled, __glXDispSwap_Scaled},
+    /* [ 188] =   188 */ {__glXDisp_Scalef, __glXDispSwap_Scalef},
+    /* [ 189] =   189 */ {__glXDisp_Translated, __glXDispSwap_Translated},
+    /* [ 190] =   190 */ {__glXDisp_Translatef, __glXDispSwap_Translatef},
+    /* [ 191] =   191 */ {__glXDisp_Viewport, __glXDispSwap_Viewport},
+    /* [ 192] =   192 */ {__glXDisp_PolygonOffset, __glXDispSwap_PolygonOffset},
+    /* [ 193] =   193 */ {__glXDisp_DrawArrays, __glXDispSwap_DrawArrays},
+    /* [ 194] =   194 */ {__glXDisp_Indexubv, __glXDispSwap_Indexubv},
+    /* [ 195] =   195 */ {__glXDisp_ColorSubTable, __glXDispSwap_ColorSubTable},
+    /* [ 196] =   196 */ {__glXDisp_CopyColorSubTable, __glXDispSwap_CopyColorSubTable},
+    /* [ 197] =   197 */ {__glXDisp_ActiveTextureARB, __glXDispSwap_ActiveTextureARB},
+    /* [ 198] =   198 */ {__glXDisp_MultiTexCoord1dvARB, __glXDispSwap_MultiTexCoord1dvARB},
+    /* [ 199] =   199 */ {__glXDisp_MultiTexCoord1fvARB, __glXDispSwap_MultiTexCoord1fvARB},
+    /* [ 200] =   200 */ {__glXDisp_MultiTexCoord1ivARB, __glXDispSwap_MultiTexCoord1ivARB},
+    /* [ 201] =   201 */ {__glXDisp_MultiTexCoord1svARB, __glXDispSwap_MultiTexCoord1svARB},
+    /* [ 202] =   202 */ {__glXDisp_MultiTexCoord2dvARB, __glXDispSwap_MultiTexCoord2dvARB},
+    /* [ 203] =   203 */ {__glXDisp_MultiTexCoord2fvARB, __glXDispSwap_MultiTexCoord2fvARB},
+    /* [ 204] =   204 */ {__glXDisp_MultiTexCoord2ivARB, __glXDispSwap_MultiTexCoord2ivARB},
+    /* [ 205] =   205 */ {__glXDisp_MultiTexCoord2svARB, __glXDispSwap_MultiTexCoord2svARB},
+    /* [ 206] =   206 */ {__glXDisp_MultiTexCoord3dvARB, __glXDispSwap_MultiTexCoord3dvARB},
+    /* [ 207] =   207 */ {__glXDisp_MultiTexCoord3fvARB, __glXDispSwap_MultiTexCoord3fvARB},
+    /* [ 208] =   208 */ {__glXDisp_MultiTexCoord3ivARB, __glXDispSwap_MultiTexCoord3ivARB},
+    /* [ 209] =   209 */ {__glXDisp_MultiTexCoord3svARB, __glXDispSwap_MultiTexCoord3svARB},
+    /* [ 210] =   210 */ {__glXDisp_MultiTexCoord4dvARB, __glXDispSwap_MultiTexCoord4dvARB},
+    /* [ 211] =   211 */ {__glXDisp_MultiTexCoord4fvARB, __glXDispSwap_MultiTexCoord4fvARB},
+    /* [ 212] =   212 */ {__glXDisp_MultiTexCoord4ivARB, __glXDispSwap_MultiTexCoord4ivARB},
+    /* [ 213] =   213 */ {__glXDisp_MultiTexCoord4svARB, __glXDispSwap_MultiTexCoord4svARB},
+    /* [ 214] =   214 */ {__glXDisp_CompressedTexImage1DARB, __glXDispSwap_CompressedTexImage1DARB},
+    /* [ 215] =   215 */ {__glXDisp_CompressedTexImage2DARB, __glXDispSwap_CompressedTexImage2DARB},
+    /* [ 216] =   216 */ {__glXDisp_CompressedTexImage3DARB, __glXDispSwap_CompressedTexImage3DARB},
+    /* [ 217] =   217 */ {__glXDisp_CompressedTexSubImage1DARB, __glXDispSwap_CompressedTexSubImage1DARB},
+    /* [ 218] =   218 */ {__glXDisp_CompressedTexSubImage2DARB, __glXDispSwap_CompressedTexSubImage2DARB},
+    /* [ 219] =   219 */ {__glXDisp_CompressedTexSubImage3DARB, __glXDispSwap_CompressedTexSubImage3DARB},
+    /* [ 220] =   220 */ {NULL, NULL},
+    /* [ 221] =   221 */ {NULL, NULL},
+    /* [ 222] =   222 */ {NULL, NULL},
+    /* [ 223] =   223 */ {NULL, NULL},
+    /* [ 224] =   224 */ {NULL, NULL},
+    /* [ 225] =   225 */ {NULL, NULL},
+    /* [ 226] =   226 */ {NULL, NULL},
+    /* [ 227] =   227 */ {NULL, NULL},
+    /* [ 228] =   228 */ {NULL, NULL},
+    /* [ 229] =   229 */ {__glXDisp_SampleCoverageARB, __glXDispSwap_SampleCoverageARB},
+    /* [ 230] =   230 */ {__glXDisp_WindowPos3fvMESA, __glXDispSwap_WindowPos3fvMESA},
+    /* [ 231] =   231 */ {__glXDisp_BeginQueryARB, __glXDispSwap_BeginQueryARB},
+    /* [ 232] =   232 */ {__glXDisp_EndQueryARB, __glXDispSwap_EndQueryARB},
+    /* [ 233] =   233 */ {__glXDisp_DrawBuffersARB, __glXDispSwap_DrawBuffersARB},
+    /* [ 234] =   234 */ {__glXDisp_ClampColorARB, __glXDispSwap_ClampColorARB},
+    /* [ 235] =   235 */ {NULL, NULL},
+    /* [ 236] =   236 */ {NULL, NULL},
+    /* [ 237] =   237 */ {__glXDisp_FramebufferTextureLayerEXT, __glXDispSwap_FramebufferTextureLayerEXT},
+    /* [ 238] =   238 */ {NULL, NULL},
+    /* [ 239] =   239 */ {NULL, NULL},
+    /* [ 240] =  2048 */ {__glXDisp_SampleMaskSGIS, __glXDispSwap_SampleMaskSGIS},
+    /* [ 241] =  2049 */ {__glXDisp_SamplePatternSGIS, __glXDispSwap_SamplePatternSGIS},
+    /* [ 242] =  2050 */ {NULL, NULL},
+    /* [ 243] =  2051 */ {NULL, NULL},
+    /* [ 244] =  2052 */ {NULL, NULL},
+    /* [ 245] =  2053 */ {__glXDisp_ColorTable, __glXDispSwap_ColorTable},
+    /* [ 246] =  2054 */ {__glXDisp_ColorTableParameterfv, __glXDispSwap_ColorTableParameterfv},
+    /* [ 247] =  2055 */ {__glXDisp_ColorTableParameteriv, __glXDispSwap_ColorTableParameteriv},
+    /* [ 248] =  2056 */ {__glXDisp_CopyColorTable, __glXDispSwap_CopyColorTable},
+    /* [ 249] =  2057 */ {NULL, NULL},
+    /* [ 250] =  2058 */ {NULL, NULL},
+    /* [ 251] =  2059 */ {NULL, NULL},
+    /* [ 252] =  2060 */ {NULL, NULL},
+    /* [ 253] =  2061 */ {NULL, NULL},
+    /* [ 254] =  2062 */ {NULL, NULL},
+    /* [ 255] =  2063 */ {NULL, NULL},
+    /* [ 256] =  2064 */ {NULL, NULL},
+    /* [ 257] =  2065 */ {__glXDisp_PointParameterfEXT, __glXDispSwap_PointParameterfEXT},
+    /* [ 258] =  2066 */ {__glXDisp_PointParameterfvEXT, __glXDispSwap_PointParameterfvEXT},
+    /* [ 259] =  2067 */ {NULL, NULL},
+    /* [ 260] =  2068 */ {NULL, NULL},
+    /* [ 261] =  2069 */ {NULL, NULL},
+    /* [ 262] =  2070 */ {NULL, NULL},
+    /* [ 263] =  2071 */ {NULL, NULL},
+    /* [ 264] =  4096 */ {__glXDisp_BlendColor, __glXDispSwap_BlendColor},
+    /* [ 265] =  4097 */ {__glXDisp_BlendEquation, __glXDispSwap_BlendEquation},
+    /* [ 266] =  4098 */ {NULL, NULL},
+    /* [ 267] =  4099 */ {__glXDisp_TexSubImage1D, __glXDispSwap_TexSubImage1D},
+    /* [ 268] =  4100 */ {__glXDisp_TexSubImage2D, __glXDispSwap_TexSubImage2D},
+    /* [ 269] =  4101 */ {__glXDisp_ConvolutionFilter1D, __glXDispSwap_ConvolutionFilter1D},
+    /* [ 270] =  4102 */ {__glXDisp_ConvolutionFilter2D, __glXDispSwap_ConvolutionFilter2D},
+    /* [ 271] =  4103 */ {__glXDisp_ConvolutionParameterf, __glXDispSwap_ConvolutionParameterf},
+    /* [ 272] =  4104 */ {__glXDisp_ConvolutionParameterfv, __glXDispSwap_ConvolutionParameterfv},
+    /* [ 273] =  4105 */ {__glXDisp_ConvolutionParameteri, __glXDispSwap_ConvolutionParameteri},
+    /* [ 274] =  4106 */ {__glXDisp_ConvolutionParameteriv, __glXDispSwap_ConvolutionParameteriv},
+    /* [ 275] =  4107 */ {__glXDisp_CopyConvolutionFilter1D, __glXDispSwap_CopyConvolutionFilter1D},
+    /* [ 276] =  4108 */ {__glXDisp_CopyConvolutionFilter2D, __glXDispSwap_CopyConvolutionFilter2D},
+    /* [ 277] =  4109 */ {__glXDisp_SeparableFilter2D, __glXDispSwap_SeparableFilter2D},
+    /* [ 278] =  4110 */ {__glXDisp_Histogram, __glXDispSwap_Histogram},
+    /* [ 279] =  4111 */ {__glXDisp_Minmax, __glXDispSwap_Minmax},
+    /* [ 280] =  4112 */ {__glXDisp_ResetHistogram, __glXDispSwap_ResetHistogram},
+    /* [ 281] =  4113 */ {__glXDisp_ResetMinmax, __glXDispSwap_ResetMinmax},
+    /* [ 282] =  4114 */ {__glXDisp_TexImage3D, __glXDispSwap_TexImage3D},
+    /* [ 283] =  4115 */ {__glXDisp_TexSubImage3D, __glXDispSwap_TexSubImage3D},
+    /* [ 284] =  4116 */ {NULL, NULL},
+    /* [ 285] =  4117 */ {__glXDisp_BindTexture, __glXDispSwap_BindTexture},
+    /* [ 286] =  4118 */ {__glXDisp_PrioritizeTextures, __glXDispSwap_PrioritizeTextures},
+    /* [ 287] =  4119 */ {__glXDisp_CopyTexImage1D, __glXDispSwap_CopyTexImage1D},
+    /* [ 288] =  4120 */ {__glXDisp_CopyTexImage2D, __glXDispSwap_CopyTexImage2D},
+    /* [ 289] =  4121 */ {__glXDisp_CopyTexSubImage1D, __glXDispSwap_CopyTexSubImage1D},
+    /* [ 290] =  4122 */ {__glXDisp_CopyTexSubImage2D, __glXDispSwap_CopyTexSubImage2D},
+    /* [ 291] =  4123 */ {__glXDisp_CopyTexSubImage3D, __glXDispSwap_CopyTexSubImage3D},
+    /* [ 292] =  4124 */ {__glXDisp_FogCoordfvEXT, __glXDispSwap_FogCoordfvEXT},
+    /* [ 293] =  4125 */ {__glXDisp_FogCoorddvEXT, __glXDispSwap_FogCoorddvEXT},
+    /* [ 294] =  4126 */ {__glXDisp_SecondaryColor3bvEXT, __glXDispSwap_SecondaryColor3bvEXT},
+    /* [ 295] =  4127 */ {__glXDisp_SecondaryColor3svEXT, __glXDispSwap_SecondaryColor3svEXT},
+    /* [ 296] =  4176 */ {NULL, NULL},
+    /* [ 297] =  4177 */ {NULL, NULL},
+    /* [ 298] =  4178 */ {NULL, NULL},
+    /* [ 299] =  4179 */ {NULL, NULL},
+    /* [ 300] =  4180 */ {__glXDisp_BindProgramNV, __glXDispSwap_BindProgramNV},
+    /* [ 301] =  4181 */ {__glXDisp_ExecuteProgramNV, __glXDispSwap_ExecuteProgramNV},
+    /* [ 302] =  4182 */ {__glXDisp_RequestResidentProgramsNV, __glXDispSwap_RequestResidentProgramsNV},
+    /* [ 303] =  4183 */ {__glXDisp_LoadProgramNV, __glXDispSwap_LoadProgramNV},
+    /* [ 304] =  4184 */ {__glXDisp_ProgramEnvParameter4fvARB, __glXDispSwap_ProgramEnvParameter4fvARB},
+    /* [ 305] =  4185 */ {__glXDisp_ProgramEnvParameter4dvARB, __glXDispSwap_ProgramEnvParameter4dvARB},
+    /* [ 306] =  4186 */ {__glXDisp_ProgramParameters4fvNV, __glXDispSwap_ProgramParameters4fvNV},
+    /* [ 307] =  4187 */ {__glXDisp_ProgramParameters4dvNV, __glXDispSwap_ProgramParameters4dvNV},
+    /* [ 308] =  4188 */ {__glXDisp_TrackMatrixNV, __glXDispSwap_TrackMatrixNV},
+    /* [ 309] =  4189 */ {__glXDisp_VertexAttrib1svARB, __glXDispSwap_VertexAttrib1svARB},
+    /* [ 310] =  4190 */ {__glXDisp_VertexAttrib2svARB, __glXDispSwap_VertexAttrib2svARB},
+    /* [ 311] =  4191 */ {__glXDisp_VertexAttrib3svARB, __glXDispSwap_VertexAttrib3svARB},
+    /* [ 312] =  4192 */ {__glXDisp_VertexAttrib4svARB, __glXDispSwap_VertexAttrib4svARB},
+    /* [ 313] =  4193 */ {__glXDisp_VertexAttrib1fvARB, __glXDispSwap_VertexAttrib1fvARB},
+    /* [ 314] =  4194 */ {__glXDisp_VertexAttrib2fvARB, __glXDispSwap_VertexAttrib2fvARB},
+    /* [ 315] =  4195 */ {__glXDisp_VertexAttrib3fvARB, __glXDispSwap_VertexAttrib3fvARB},
+    /* [ 316] =  4196 */ {__glXDisp_VertexAttrib4fvARB, __glXDispSwap_VertexAttrib4fvARB},
+    /* [ 317] =  4197 */ {__glXDisp_VertexAttrib1dvARB, __glXDispSwap_VertexAttrib1dvARB},
+    /* [ 318] =  4198 */ {__glXDisp_VertexAttrib2dvARB, __glXDispSwap_VertexAttrib2dvARB},
+    /* [ 319] =  4199 */ {__glXDisp_VertexAttrib3dvARB, __glXDispSwap_VertexAttrib3dvARB},
+    /* [ 320] =  4200 */ {__glXDisp_VertexAttrib4dvARB, __glXDispSwap_VertexAttrib4dvARB},
+    /* [ 321] =  4201 */ {__glXDisp_VertexAttrib4NubvARB, __glXDispSwap_VertexAttrib4NubvARB},
+    /* [ 322] =  4202 */ {__glXDisp_VertexAttribs1svNV, __glXDispSwap_VertexAttribs1svNV},
+    /* [ 323] =  4203 */ {__glXDisp_VertexAttribs2svNV, __glXDispSwap_VertexAttribs2svNV},
+    /* [ 324] =  4204 */ {__glXDisp_VertexAttribs3svNV, __glXDispSwap_VertexAttribs3svNV},
+    /* [ 325] =  4205 */ {__glXDisp_VertexAttribs4svNV, __glXDispSwap_VertexAttribs4svNV},
+    /* [ 326] =  4206 */ {__glXDisp_VertexAttribs1fvNV, __glXDispSwap_VertexAttribs1fvNV},
+    /* [ 327] =  4207 */ {__glXDisp_VertexAttribs2fvNV, __glXDispSwap_VertexAttribs2fvNV},
+    /* [ 328] =  4208 */ {__glXDisp_VertexAttribs3fvNV, __glXDispSwap_VertexAttribs3fvNV},
+    /* [ 329] =  4209 */ {__glXDisp_VertexAttribs4fvNV, __glXDispSwap_VertexAttribs4fvNV},
+    /* [ 330] =  4210 */ {__glXDisp_VertexAttribs1dvNV, __glXDispSwap_VertexAttribs1dvNV},
+    /* [ 331] =  4211 */ {__glXDisp_VertexAttribs2dvNV, __glXDispSwap_VertexAttribs2dvNV},
+    /* [ 332] =  4212 */ {__glXDisp_VertexAttribs3dvNV, __glXDispSwap_VertexAttribs3dvNV},
+    /* [ 333] =  4213 */ {__glXDisp_VertexAttribs4dvNV, __glXDispSwap_VertexAttribs4dvNV},
+    /* [ 334] =  4214 */ {__glXDisp_VertexAttribs4ubvNV, __glXDispSwap_VertexAttribs4ubvNV},
+    /* [ 335] =  4215 */ {__glXDisp_ProgramLocalParameter4fvARB, __glXDispSwap_ProgramLocalParameter4fvARB},
+    /* [ 336] =  4216 */ {__glXDisp_ProgramLocalParameter4dvARB, __glXDispSwap_ProgramLocalParameter4dvARB},
+    /* [ 337] =  4217 */ {__glXDisp_ProgramStringARB, __glXDispSwap_ProgramStringARB},
+    /* [ 338] =  4218 */ {__glXDisp_ProgramNamedParameter4fvNV, __glXDispSwap_ProgramNamedParameter4fvNV},
+    /* [ 339] =  4219 */ {__glXDisp_ProgramNamedParameter4dvNV, __glXDispSwap_ProgramNamedParameter4dvNV},
+    /* [ 340] =  4220 */ {__glXDisp_ActiveStencilFaceEXT, __glXDispSwap_ActiveStencilFaceEXT},
+    /* [ 341] =  4221 */ {__glXDisp_PointParameteriNV, __glXDispSwap_PointParameteriNV},
+    /* [ 342] =  4222 */ {__glXDisp_PointParameterivNV, __glXDispSwap_PointParameterivNV},
+    /* [ 343] =  4223 */ {NULL, NULL},
+    /* [ 344] =  4224 */ {NULL, NULL},
+    /* [ 345] =  4225 */ {NULL, NULL},
+    /* [ 346] =  4226 */ {NULL, NULL},
+    /* [ 347] =  4227 */ {NULL, NULL},
+    /* [ 348] =  4228 */ {__glXDisp_BlendEquationSeparateEXT, __glXDispSwap_BlendEquationSeparateEXT},
+    /* [ 349] =  4229 */ {NULL, NULL},
+    /* [ 350] =  4230 */ {__glXDisp_VertexAttrib4bvARB, __glXDispSwap_VertexAttrib4bvARB},
+    /* [ 351] =  4231 */ {__glXDisp_VertexAttrib4ivARB, __glXDispSwap_VertexAttrib4ivARB},
+    /* [ 352] =  4232 */ {__glXDisp_VertexAttrib4ubvARB, __glXDispSwap_VertexAttrib4ubvARB},
+    /* [ 353] =  4233 */ {__glXDisp_VertexAttrib4usvARB, __glXDispSwap_VertexAttrib4usvARB},
+    /* [ 354] =  4234 */ {__glXDisp_VertexAttrib4uivARB, __glXDispSwap_VertexAttrib4uivARB},
+    /* [ 355] =  4235 */ {__glXDisp_VertexAttrib4NbvARB, __glXDispSwap_VertexAttrib4NbvARB},
+    /* [ 356] =  4236 */ {__glXDisp_VertexAttrib4NsvARB, __glXDispSwap_VertexAttrib4NsvARB},
+    /* [ 357] =  4237 */ {__glXDisp_VertexAttrib4NivARB, __glXDispSwap_VertexAttrib4NivARB},
+    /* [ 358] =  4238 */ {__glXDisp_VertexAttrib4NusvARB, __glXDispSwap_VertexAttrib4NusvARB},
+    /* [ 359] =  4239 */ {__glXDisp_VertexAttrib4NuivARB, __glXDispSwap_VertexAttrib4NuivARB},
+    /* [ 360] =  4320 */ {__glXDisp_DeleteFramebuffersEXT, __glXDispSwap_DeleteFramebuffersEXT},
+    /* [ 361] =  4321 */ {__glXDisp_FramebufferTexture1DEXT, __glXDispSwap_FramebufferTexture1DEXT},
+    /* [ 362] =  4322 */ {__glXDisp_FramebufferTexture2DEXT, __glXDispSwap_FramebufferTexture2DEXT},
+    /* [ 363] =  4323 */ {__glXDisp_FramebufferTexture3DEXT, __glXDispSwap_FramebufferTexture3DEXT},
+    /* [ 364] =  4324 */ {__glXDisp_FramebufferRenderbufferEXT, __glXDispSwap_FramebufferRenderbufferEXT},
+    /* [ 365] =  4325 */ {__glXDisp_GenerateMipmapEXT, __glXDispSwap_GenerateMipmapEXT},
+    /* [ 366] =  4326 */ {NULL, NULL},
+    /* [ 367] =  4327 */ {NULL, NULL},
+    /* [ 368] =  4328 */ {NULL, NULL},
+    /* [ 369] =  4329 */ {NULL, NULL},
+    /* [ 370] =  4330 */ {__glXDisp_BlitFramebufferEXT, __glXDispSwap_BlitFramebufferEXT},
+    /* [ 371] =  4331 */ {__glXDisp_RenderbufferStorageMultisample, __glXDispSwap_RenderbufferStorageMultisample},
+    /* [ 372] =  4332 */ {NULL, NULL},
+    /* [ 373] =  4333 */ {NULL, NULL},
+    /* [ 374] =  4334 */ {NULL, NULL},
+    /* [ 375] =  4335 */ {NULL, NULL},
+    /* [ 376] =  4128 */ {__glXDisp_SecondaryColor3ivEXT, __glXDispSwap_SecondaryColor3ivEXT},
+    /* [ 377] =  4129 */ {__glXDisp_SecondaryColor3fvEXT, __glXDispSwap_SecondaryColor3fvEXT},
+    /* [ 378] =  4130 */ {__glXDisp_SecondaryColor3dvEXT, __glXDispSwap_SecondaryColor3dvEXT},
+    /* [ 379] =  4131 */ {__glXDisp_SecondaryColor3ubvEXT, __glXDispSwap_SecondaryColor3ubvEXT},
+    /* [ 380] =  4132 */ {__glXDisp_SecondaryColor3usvEXT, __glXDispSwap_SecondaryColor3usvEXT},
+    /* [ 381] =  4133 */ {__glXDisp_SecondaryColor3uivEXT, __glXDispSwap_SecondaryColor3uivEXT},
+    /* [ 382] =  4134 */ {__glXDisp_BlendFuncSeparateEXT, __glXDispSwap_BlendFuncSeparateEXT},
+    /* [ 383] =  4135 */ {NULL, NULL},
+    /* [ 384] =  4264 */ {NULL, NULL},
+    /* [ 385] =  4265 */ {__glXDisp_VertexAttrib1svNV, __glXDispSwap_VertexAttrib1svNV},
+    /* [ 386] =  4266 */ {__glXDisp_VertexAttrib2svNV, __glXDispSwap_VertexAttrib2svNV},
+    /* [ 387] =  4267 */ {__glXDisp_VertexAttrib3svNV, __glXDispSwap_VertexAttrib3svNV},
+    /* [ 388] =  4268 */ {__glXDisp_VertexAttrib4svNV, __glXDispSwap_VertexAttrib4svNV},
+    /* [ 389] =  4269 */ {__glXDisp_VertexAttrib1fvNV, __glXDispSwap_VertexAttrib1fvNV},
+    /* [ 390] =  4270 */ {__glXDisp_VertexAttrib2fvNV, __glXDispSwap_VertexAttrib2fvNV},
+    /* [ 391] =  4271 */ {__glXDisp_VertexAttrib3fvNV, __glXDispSwap_VertexAttrib3fvNV},
+    /* [ 392] =  4272 */ {__glXDisp_VertexAttrib4fvNV, __glXDispSwap_VertexAttrib4fvNV},
+    /* [ 393] =  4273 */ {__glXDisp_VertexAttrib1dvNV, __glXDispSwap_VertexAttrib1dvNV},
+    /* [ 394] =  4274 */ {__glXDisp_VertexAttrib2dvNV, __glXDispSwap_VertexAttrib2dvNV},
+    /* [ 395] =  4275 */ {__glXDisp_VertexAttrib3dvNV, __glXDispSwap_VertexAttrib3dvNV},
+    /* [ 396] =  4276 */ {__glXDisp_VertexAttrib4dvNV, __glXDispSwap_VertexAttrib4dvNV},
+    /* [ 397] =  4277 */ {__glXDisp_VertexAttrib4ubvNV, __glXDispSwap_VertexAttrib4ubvNV},
+    /* [ 398] =  4278 */ {NULL, NULL},
+    /* [ 399] =  4279 */ {NULL, NULL},
+    /* [ 400] =  4312 */ {NULL, NULL},
+    /* [ 401] =  4313 */ {NULL, NULL},
+    /* [ 402] =  4314 */ {NULL, NULL},
+    /* [ 403] =  4315 */ {NULL, NULL},
+    /* [ 404] =  4316 */ {__glXDisp_BindRenderbufferEXT, __glXDispSwap_BindRenderbufferEXT},
+    /* [ 405] =  4317 */ {__glXDisp_DeleteRenderbuffersEXT, __glXDispSwap_DeleteRenderbuffersEXT},
+    /* [ 406] =  4318 */ {__glXDisp_RenderbufferStorageEXT, __glXDispSwap_RenderbufferStorageEXT},
+    /* [ 407] =  4319 */ {__glXDisp_BindFramebufferEXT, __glXDispSwap_BindFramebufferEXT},
+};
+
+static const int_fast16_t Render_size_table[408][2] = {
+    /* [  0] =     0 */ {  0, ~0},
+    /* [  1] =     1 */ {  8, ~0},
+    /* [  2] =     2 */ { 12,  0},
+    /* [  3] =     3 */ {  8, ~0},
+    /* [  4] =     4 */ {  8, ~0},
+    /* [  5] =     5 */ { 48,  1},
+    /* [  6] =     6 */ {  8, ~0},
+    /* [  7] =     7 */ { 28, ~0},
+    /* [  8] =     8 */ { 16, ~0},
+    /* [  9] =     9 */ { 16, ~0},
+    /* [ 10] =    10 */ { 12, ~0},
+    /* [ 11] =    11 */ {  8, ~0},
+    /* [ 12] =    12 */ { 16, ~0},
+    /* [ 13] =    13 */ { 12, ~0},
+    /* [ 14] =    14 */ {  8, ~0},
+    /* [ 15] =    15 */ { 36, ~0},
+    /* [ 16] =    16 */ { 20, ~0},
+    /* [ 17] =    17 */ { 20, ~0},
+    /* [ 18] =    18 */ { 12, ~0},
+    /* [ 19] =    19 */ {  8, ~0},
+    /* [ 20] =    20 */ { 20, ~0},
+    /* [ 21] =    21 */ { 12, ~0},
+    /* [ 22] =    22 */ {  8, ~0},
+    /* [ 23] =    23 */ {  4, ~0},
+    /* [ 24] =    24 */ { 12, ~0},
+    /* [ 25] =    25 */ {  8, ~0},
+    /* [ 26] =    26 */ {  8, ~0},
+    /* [ 27] =    27 */ {  8, ~0},
+    /* [ 28] =    28 */ {  8, ~0},
+    /* [ 29] =    29 */ { 28, ~0},
+    /* [ 30] =    30 */ { 16, ~0},
+    /* [ 31] =    31 */ { 16, ~0},
+    /* [ 32] =    32 */ { 12, ~0},
+    /* [ 33] =    33 */ { 20, ~0},
+    /* [ 34] =    34 */ { 12, ~0},
+    /* [ 35] =    35 */ { 12, ~0},
+    /* [ 36] =    36 */ {  8, ~0},
+    /* [ 37] =    37 */ { 28, ~0},
+    /* [ 38] =    38 */ { 16, ~0},
+    /* [ 39] =    39 */ { 16, ~0},
+    /* [ 40] =    40 */ { 12, ~0},
+    /* [ 41] =    41 */ { 36, ~0},
+    /* [ 42] =    42 */ { 20, ~0},
+    /* [ 43] =    43 */ { 20, ~0},
+    /* [ 44] =    44 */ { 12, ~0},
+    /* [ 45] =    45 */ { 36, ~0},
+    /* [ 46] =    46 */ { 20, ~0},
+    /* [ 47] =    47 */ { 20, ~0},
+    /* [ 48] =    48 */ { 12, ~0},
+    /* [ 49] =    49 */ { 12, ~0},
+    /* [ 50] =    50 */ {  8, ~0},
+    /* [ 51] =    51 */ {  8, ~0},
+    /* [ 52] =    52 */ {  8, ~0},
+    /* [ 53] =    53 */ { 20, ~0},
+    /* [ 54] =    54 */ { 12, ~0},
+    /* [ 55] =    55 */ { 12, ~0},
+    /* [ 56] =    56 */ {  8, ~0},
+    /* [ 57] =    57 */ { 28, ~0},
+    /* [ 58] =    58 */ { 16, ~0},
+    /* [ 59] =    59 */ { 16, ~0},
+    /* [ 60] =    60 */ { 12, ~0},
+    /* [ 61] =    61 */ { 36, ~0},
+    /* [ 62] =    62 */ { 20, ~0},
+    /* [ 63] =    63 */ { 20, ~0},
+    /* [ 64] =    64 */ { 12, ~0},
+    /* [ 65] =    65 */ { 20, ~0},
+    /* [ 66] =    66 */ { 12, ~0},
+    /* [ 67] =    67 */ { 12, ~0},
+    /* [ 68] =    68 */ {  8, ~0},
+    /* [ 69] =    69 */ { 28, ~0},
+    /* [ 70] =    70 */ { 16, ~0},
+    /* [ 71] =    71 */ { 16, ~0},
+    /* [ 72] =    72 */ { 12, ~0},
+    /* [ 73] =    73 */ { 36, ~0},
+    /* [ 74] =    74 */ { 20, ~0},
+    /* [ 75] =    75 */ { 20, ~0},
+    /* [ 76] =    76 */ { 12, ~0},
+    /* [ 77] =    77 */ { 40, ~0},
+    /* [ 78] =    78 */ { 12, ~0},
+    /* [ 79] =    79 */ {  8, ~0},
+    /* [ 80] =    80 */ { 12, ~0},
+    /* [ 81] =    81 */ {  8,  2},
+    /* [ 82] =    82 */ { 12, ~0},
+    /* [ 83] =    83 */ {  8,  3},
+    /* [ 84] =    84 */ {  8, ~0},
+    /* [ 85] =    85 */ { 12, ~0},
+    /* [ 86] =    86 */ { 16, ~0},
+    /* [ 87] =    87 */ { 12,  4},
+    /* [ 88] =    88 */ { 16, ~0},
+    /* [ 89] =    89 */ { 12,  5},
+    /* [ 90] =    90 */ { 12, ~0},
+    /* [ 91] =    91 */ {  8,  6},
+    /* [ 92] =    92 */ { 12, ~0},
+    /* [ 93] =    93 */ {  8,  7},
+    /* [ 94] =    94 */ { 12, ~0},
+    /* [ 95] =    95 */ {  8, ~0},
+    /* [ 96] =    96 */ { 16, ~0},
+    /* [ 97] =    97 */ { 12,  8},
+    /* [ 98] =    98 */ { 16, ~0},
+    /* [ 99] =    99 */ { 12,  9},
+    /* [100] =   100 */ {  8, ~0},
+    /* [101] =   101 */ { 12, ~0},
+    /* [102] =   102 */ { 24, 10},
+    /* [103] =   103 */ { 20, ~0},
+    /* [104] =   104 */ {  8, ~0},
+    /* [105] =   105 */ { 16, ~0},
+    /* [106] =   106 */ { 12, 11},
+    /* [107] =   107 */ { 16, ~0},
+    /* [108] =   108 */ { 12, 12},
+    /* [109] =   109 */ { 56, 13},
+    /* [110] =   110 */ { 56, 14},
+    /* [111] =   111 */ { 16, ~0},
+    /* [112] =   112 */ { 12, 15},
+    /* [113] =   113 */ { 16, ~0},
+    /* [114] =   114 */ { 12, 16},
+    /* [115] =   115 */ { 20, ~0},
+    /* [116] =   116 */ { 12, 17},
+    /* [117] =   117 */ { 16, ~0},
+    /* [118] =   118 */ { 12, 18},
+    /* [119] =   119 */ { 16, ~0},
+    /* [120] =   120 */ { 12, 19},
+    /* [121] =   121 */ {  4, ~0},
+    /* [122] =   122 */ {  8, ~0},
+    /* [123] =   123 */ {  8, ~0},
+    /* [124] =   124 */ {  4, ~0},
+    /* [125] =   125 */ {  8, ~0},
+    /* [126] =   126 */ {  8, ~0},
+    /* [127] =   127 */ {  8, ~0},
+    /* [128] =   128 */ { 20, ~0},
+    /* [129] =   129 */ {  8, ~0},
+    /* [130] =   130 */ { 20, ~0},
+    /* [131] =   131 */ {  8, ~0},
+    /* [132] =   132 */ { 12, ~0},
+    /* [133] =   133 */ {  8, ~0},
+    /* [134] =   134 */ {  8, ~0},
+    /* [135] =   135 */ {  8, ~0},
+    /* [136] =   136 */ {  8, ~0},
+    /* [137] =   137 */ { 12, ~0},
+    /* [138] =   138 */ {  8, ~0},
+    /* [139] =   139 */ {  8, ~0},
+    /* [140] =   140 */ {  0, ~0},
+    /* [141] =   141 */ {  4, ~0},
+    /* [142] =   142 */ {  8, ~0},
+    /* [143] =   143 */ { 28, 20},
+    /* [144] =   144 */ { 20, 21},
+    /* [145] =   145 */ { 48, 22},
+    /* [146] =   146 */ { 32, 23},
+    /* [147] =   147 */ { 24, ~0},
+    /* [148] =   148 */ { 16, ~0},
+    /* [149] =   149 */ { 44, ~0},
+    /* [150] =   150 */ { 28, ~0},
+    /* [151] =   151 */ { 12, ~0},
+    /* [152] =   152 */ {  8, ~0},
+    /* [153] =   153 */ { 20, ~0},
+    /* [154] =   154 */ { 12, ~0},
+    /* [155] =   155 */ { 16, ~0},
+    /* [156] =   156 */ {  8, ~0},
+    /* [157] =   157 */ { 24, ~0},
+    /* [158] =   158 */ { 12, ~0},
+    /* [159] =   159 */ { 12, ~0},
+    /* [160] =   160 */ { 12, ~0},
+    /* [161] =   161 */ {  8, ~0},
+    /* [162] =   162 */ { 16, ~0},
+    /* [163] =   163 */ { 16, ~0},
+    /* [164] =   164 */ {  8, ~0},
+    /* [165] =   165 */ { 12, ~0},
+    /* [166] =   166 */ { 12, ~0},
+    /* [167] =   167 */ { 12, ~0},
+    /* [168] =   168 */ { 12, 24},
+    /* [169] =   169 */ { 12, 25},
+    /* [170] =   170 */ { 12, 26},
+    /* [171] =   171 */ {  8, ~0},
+    /* [172] =   172 */ { 24, ~0},
+    /* [173] =   173 */ { 40, 27},
+    /* [174] =   174 */ { 20, ~0},
+    /* [175] =   175 */ { 52, ~0},
+    /* [176] =   176 */ {  4, ~0},
+    /* [177] =   177 */ { 68, ~0},
+    /* [178] =   178 */ {132, ~0},
+    /* [179] =   179 */ {  8, ~0},
+    /* [180] =   180 */ { 68, ~0},
+    /* [181] =   181 */ {132, ~0},
+    /* [182] =   182 */ { 52, ~0},
+    /* [183] =   183 */ {  4, ~0},
+    /* [184] =   184 */ {  4, ~0},
+    /* [185] =   185 */ { 36, ~0},
+    /* [186] =   186 */ { 20, ~0},
+    /* [187] =   187 */ { 28, ~0},
+    /* [188] =   188 */ { 16, ~0},
+    /* [189] =   189 */ { 28, ~0},
+    /* [190] =   190 */ { 16, ~0},
+    /* [191] =   191 */ { 20, ~0},
+    /* [192] =   192 */ { 12, ~0},
+    /* [193] =   193 */ { 16, 28},
+    /* [194] =   194 */ {  8, ~0},
+    /* [195] =   195 */ { 44, 29},
+    /* [196] =   196 */ { 24, ~0},
+    /* [197] =   197 */ {  8, ~0},
+    /* [198] =   198 */ { 16, ~0},
+    /* [199] =   199 */ { 12, ~0},
+    /* [200] =   200 */ { 12, ~0},
+    /* [201] =   201 */ { 12, ~0},
+    /* [202] =   202 */ { 24, ~0},
+    /* [203] =   203 */ { 16, ~0},
+    /* [204] =   204 */ { 16, ~0},
+    /* [205] =   205 */ { 12, ~0},
+    /* [206] =   206 */ { 32, ~0},
+    /* [207] =   207 */ { 20, ~0},
+    /* [208] =   208 */ { 20, ~0},
+    /* [209] =   209 */ { 16, ~0},
+    /* [210] =   210 */ { 40, ~0},
+    /* [211] =   211 */ { 24, ~0},
+    /* [212] =   212 */ { 24, ~0},
+    /* [213] =   213 */ { 16, ~0},
+    /* [214] =   214 */ { 28, 30},
+    /* [215] =   215 */ { 32, 31},
+    /* [216] =   216 */ { 36, 32},
+    /* [217] =   217 */ { 28, 33},
+    /* [218] =   218 */ { 36, 34},
+    /* [219] =   219 */ { 44, 35},
+    /* [220] =   220 */ {  0, ~0},
+    /* [221] =   221 */ {  0, ~0},
+    /* [222] =   222 */ {  0, ~0},
+    /* [223] =   223 */ {  0, ~0},
+    /* [224] =   224 */ {  0, ~0},
+    /* [225] =   225 */ {  0, ~0},
+    /* [226] =   226 */ {  0, ~0},
+    /* [227] =   227 */ {  0, ~0},
+    /* [228] =   228 */ {  0, ~0},
+    /* [229] =   229 */ { 12, ~0},
+    /* [230] =   230 */ { 16, ~0},
+    /* [231] =   231 */ { 12, ~0},
+    /* [232] =   232 */ {  8, ~0},
+    /* [233] =   233 */ {  8, 36},
+    /* [234] =   234 */ { 12, ~0},
+    /* [235] =   235 */ {  0, ~0},
+    /* [236] =   236 */ {  0, ~0},
+    /* [237] =   237 */ { 24, ~0},
+    /* [238] =   238 */ {  0, ~0},
+    /* [239] =   239 */ {  0, ~0},
+    /* [240] =  2048 */ { 12, ~0},
+    /* [241] =  2049 */ {  8, ~0},
+    /* [242] =  2050 */ {  0, ~0},
+    /* [243] =  2051 */ {  0, ~0},
+    /* [244] =  2052 */ {  0, ~0},
+    /* [245] =  2053 */ { 44, 37},
+    /* [246] =  2054 */ { 12, 38},
+    /* [247] =  2055 */ { 12, 39},
+    /* [248] =  2056 */ { 24, ~0},
+    /* [249] =  2057 */ {  0, ~0},
+    /* [250] =  2058 */ {  0, ~0},
+    /* [251] =  2059 */ {  0, ~0},
+    /* [252] =  2060 */ {  0, ~0},
+    /* [253] =  2061 */ {  0, ~0},
+    /* [254] =  2062 */ {  0, ~0},
+    /* [255] =  2063 */ {  0, ~0},
+    /* [256] =  2064 */ {  0, ~0},
+    /* [257] =  2065 */ { 12, ~0},
+    /* [258] =  2066 */ {  8, 40},
+    /* [259] =  2067 */ {  0, ~0},
+    /* [260] =  2068 */ {  0, ~0},
+    /* [261] =  2069 */ {  0, ~0},
+    /* [262] =  2070 */ {  0, ~0},
+    /* [263] =  2071 */ {  0, ~0},
+    /* [264] =  4096 */ { 20, ~0},
+    /* [265] =  4097 */ {  8, ~0},
+    /* [266] =  4098 */ {  0, ~0},
+    /* [267] =  4099 */ { 60, 41},
+    /* [268] =  4100 */ { 60, 42},
+    /* [269] =  4101 */ { 48, 43},
+    /* [270] =  4102 */ { 48, 44},
+    /* [271] =  4103 */ { 16, ~0},
+    /* [272] =  4104 */ { 12, 45},
+    /* [273] =  4105 */ { 16, ~0},
+    /* [274] =  4106 */ { 12, 46},
+    /* [275] =  4107 */ { 24, ~0},
+    /* [276] =  4108 */ { 28, ~0},
+    /* [277] =  4109 */ { 32, 47},
+    /* [278] =  4110 */ { 20, ~0},
+    /* [279] =  4111 */ { 16, ~0},
+    /* [280] =  4112 */ {  8, ~0},
+    /* [281] =  4113 */ {  8, ~0},
+    /* [282] =  4114 */ { 84, 48},
+    /* [283] =  4115 */ { 92, 49},
+    /* [284] =  4116 */ {  0, ~0},
+    /* [285] =  4117 */ { 12, ~0},
+    /* [286] =  4118 */ {  8, 50},
+    /* [287] =  4119 */ { 32, ~0},
+    /* [288] =  4120 */ { 36, ~0},
+    /* [289] =  4121 */ { 28, ~0},
+    /* [290] =  4122 */ { 36, ~0},
+    /* [291] =  4123 */ { 40, ~0},
+    /* [292] =  4124 */ {  8, ~0},
+    /* [293] =  4125 */ { 12, ~0},
+    /* [294] =  4126 */ {  8, ~0},
+    /* [295] =  4127 */ { 12, ~0},
+    /* [296] =  4176 */ {  0, ~0},
+    /* [297] =  4177 */ {  0, ~0},
+    /* [298] =  4178 */ {  0, ~0},
+    /* [299] =  4179 */ {  0, ~0},
+    /* [300] =  4180 */ { 12, ~0},
+    /* [301] =  4181 */ { 28, ~0},
+    /* [302] =  4182 */ {  8, 51},
+    /* [303] =  4183 */ { 16, 52},
+    /* [304] =  4184 */ { 28, ~0},
+    /* [305] =  4185 */ { 44, ~0},
+    /* [306] =  4186 */ { 16, 53},
+    /* [307] =  4187 */ { 16, 54},
+    /* [308] =  4188 */ { 20, ~0},
+    /* [309] =  4189 */ { 12, ~0},
+    /* [310] =  4190 */ { 12, ~0},
+    /* [311] =  4191 */ { 16, ~0},
+    /* [312] =  4192 */ { 16, ~0},
+    /* [313] =  4193 */ { 12, ~0},
+    /* [314] =  4194 */ { 16, ~0},
+    /* [315] =  4195 */ { 20, ~0},
+    /* [316] =  4196 */ { 24, ~0},
+    /* [317] =  4197 */ { 16, ~0},
+    /* [318] =  4198 */ { 24, ~0},
+    /* [319] =  4199 */ { 32, ~0},
+    /* [320] =  4200 */ { 40, ~0},
+    /* [321] =  4201 */ { 12, ~0},
+    /* [322] =  4202 */ { 12, 55},
+    /* [323] =  4203 */ { 12, 56},
+    /* [324] =  4204 */ { 12, 57},
+    /* [325] =  4205 */ { 12, 58},
+    /* [326] =  4206 */ { 12, 59},
+    /* [327] =  4207 */ { 12, 60},
+    /* [328] =  4208 */ { 12, 61},
+    /* [329] =  4209 */ { 12, 62},
+    /* [330] =  4210 */ { 12, 63},
+    /* [331] =  4211 */ { 12, 64},
+    /* [332] =  4212 */ { 12, 65},
+    /* [333] =  4213 */ { 12, 66},
+    /* [334] =  4214 */ { 12, 67},
+    /* [335] =  4215 */ { 28, ~0},
+    /* [336] =  4216 */ { 44, ~0},
+    /* [337] =  4217 */ { 16, 68},
+    /* [338] =  4218 */ { 28, 69},
+    /* [339] =  4219 */ { 44, 70},
+    /* [340] =  4220 */ {  8, ~0},
+    /* [341] =  4221 */ { 12, ~0},
+    /* [342] =  4222 */ {  8, 71},
+    /* [343] =  4223 */ {  0, ~0},
+    /* [344] =  4224 */ {  0, ~0},
+    /* [345] =  4225 */ {  0, ~0},
+    /* [346] =  4226 */ {  0, ~0},
+    /* [347] =  4227 */ {  0, ~0},
+    /* [348] =  4228 */ { 12, ~0},
+    /* [349] =  4229 */ {  0, ~0},
+    /* [350] =  4230 */ { 12, ~0},
+    /* [351] =  4231 */ { 24, ~0},
+    /* [352] =  4232 */ { 12, ~0},
+    /* [353] =  4233 */ { 16, ~0},
+    /* [354] =  4234 */ { 24, ~0},
+    /* [355] =  4235 */ { 12, ~0},
+    /* [356] =  4236 */ { 16, ~0},
+    /* [357] =  4237 */ { 24, ~0},
+    /* [358] =  4238 */ { 16, ~0},
+    /* [359] =  4239 */ { 24, ~0},
+    /* [360] =  4320 */ {  8, 72},
+    /* [361] =  4321 */ { 24, ~0},
+    /* [362] =  4322 */ { 24, ~0},
+    /* [363] =  4323 */ { 28, ~0},
+    /* [364] =  4324 */ { 20, ~0},
+    /* [365] =  4325 */ {  8, ~0},
+    /* [366] =  4326 */ {  0, ~0},
+    /* [367] =  4327 */ {  0, ~0},
+    /* [368] =  4328 */ {  0, ~0},
+    /* [369] =  4329 */ {  0, ~0},
+    /* [370] =  4330 */ { 44, ~0},
+    /* [371] =  4331 */ { 24, ~0},
+    /* [372] =  4332 */ {  0, ~0},
+    /* [373] =  4333 */ {  0, ~0},
+    /* [374] =  4334 */ {  0, ~0},
+    /* [375] =  4335 */ {  0, ~0},
+    /* [376] =  4128 */ { 16, ~0},
+    /* [377] =  4129 */ { 16, ~0},
+    /* [378] =  4130 */ { 28, ~0},
+    /* [379] =  4131 */ {  8, ~0},
+    /* [380] =  4132 */ { 12, ~0},
+    /* [381] =  4133 */ { 16, ~0},
+    /* [382] =  4134 */ { 20, ~0},
+    /* [383] =  4135 */ {  0, ~0},
+    /* [384] =  4264 */ {  0, ~0},
+    /* [385] =  4265 */ { 12, ~0},
+    /* [386] =  4266 */ { 12, ~0},
+    /* [387] =  4267 */ { 16, ~0},
+    /* [388] =  4268 */ { 16, ~0},
+    /* [389] =  4269 */ { 12, ~0},
+    /* [390] =  4270 */ { 16, ~0},
+    /* [391] =  4271 */ { 20, ~0},
+    /* [392] =  4272 */ { 24, ~0},
+    /* [393] =  4273 */ { 16, ~0},
+    /* [394] =  4274 */ { 24, ~0},
+    /* [395] =  4275 */ { 32, ~0},
+    /* [396] =  4276 */ { 40, ~0},
+    /* [397] =  4277 */ { 12, ~0},
+    /* [398] =  4278 */ {  0, ~0},
+    /* [399] =  4279 */ {  0, ~0},
+    /* [400] =  4312 */ {  0, ~0},
+    /* [401] =  4313 */ {  0, ~0},
+    /* [402] =  4314 */ {  0, ~0},
+    /* [403] =  4315 */ {  0, ~0},
+    /* [404] =  4316 */ { 12, ~0},
+    /* [405] =  4317 */ {  8, 73},
+    /* [406] =  4318 */ { 20, ~0},
+    /* [407] =  4319 */ { 12, ~0},
+};
+
+static const gl_proto_size_func Render_size_func_table[74] = {
+   __glXCallListsReqSize,
+   __glXBitmapReqSize,
+   __glXFogfvReqSize,
+   __glXFogivReqSize,
+   __glXLightfvReqSize,
+   __glXLightivReqSize,
+   __glXLightModelfvReqSize,
+   __glXLightModelivReqSize,
+   __glXMaterialfvReqSize,
+   __glXMaterialivReqSize,
+   __glXPolygonStippleReqSize,
+   __glXTexParameterfvReqSize,
+   __glXTexParameterivReqSize,
+   __glXTexImage1DReqSize,
+   __glXTexImage2DReqSize,
+   __glXTexEnvfvReqSize,
+   __glXTexEnvivReqSize,
+   __glXTexGendvReqSize,
+   __glXTexGenfvReqSize,
+   __glXTexGenivReqSize,
+   __glXMap1dReqSize,
+   __glXMap1fReqSize,
+   __glXMap2dReqSize,
+   __glXMap2fReqSize,
+   __glXPixelMapfvReqSize,
+   __glXPixelMapuivReqSize,
+   __glXPixelMapusvReqSize,
+   __glXDrawPixelsReqSize,
+   __glXDrawArraysReqSize,
+   __glXColorSubTableReqSize,
+   __glXCompressedTexImage1DARBReqSize,
+   __glXCompressedTexImage2DARBReqSize,
+   __glXCompressedTexImage3DARBReqSize,
+   __glXCompressedTexSubImage1DARBReqSize,
+   __glXCompressedTexSubImage2DARBReqSize,
+   __glXCompressedTexSubImage3DARBReqSize,
+   __glXDrawBuffersARBReqSize,
+   __glXColorTableReqSize,
+   __glXColorTableParameterfvReqSize,
+   __glXColorTableParameterivReqSize,
+   __glXPointParameterfvEXTReqSize,
+   __glXTexSubImage1DReqSize,
+   __glXTexSubImage2DReqSize,
+   __glXConvolutionFilter1DReqSize,
+   __glXConvolutionFilter2DReqSize,
+   __glXConvolutionParameterfvReqSize,
+   __glXConvolutionParameterivReqSize,
+   __glXSeparableFilter2DReqSize,
+   __glXTexImage3DReqSize,
+   __glXTexSubImage3DReqSize,
+   __glXPrioritizeTexturesReqSize,
+   __glXRequestResidentProgramsNVReqSize,
+   __glXLoadProgramNVReqSize,
+   __glXProgramParameters4fvNVReqSize,
+   __glXProgramParameters4dvNVReqSize,
+   __glXVertexAttribs1svNVReqSize,
+   __glXVertexAttribs2svNVReqSize,
+   __glXVertexAttribs3svNVReqSize,
+   __glXVertexAttribs4svNVReqSize,
+   __glXVertexAttribs1fvNVReqSize,
+   __glXVertexAttribs2fvNVReqSize,
+   __glXVertexAttribs3fvNVReqSize,
+   __glXVertexAttribs4fvNVReqSize,
+   __glXVertexAttribs1dvNVReqSize,
+   __glXVertexAttribs2dvNVReqSize,
+   __glXVertexAttribs3dvNVReqSize,
+   __glXVertexAttribs4dvNVReqSize,
+   __glXVertexAttribs4ubvNVReqSize,
+   __glXProgramStringARBReqSize,
+   __glXProgramNamedParameter4fvNVReqSize,
+   __glXProgramNamedParameter4dvNVReqSize,
+   __glXPointParameterivNVReqSize,
+   __glXDeleteFramebuffersEXTReqSize,
+   __glXDeleteRenderbuffersEXTReqSize,
+};
+
+const struct __glXDispatchInfo Render_dispatch_info = {
+    13,
+    Render_dispatch_tree,
+    Render_function_table,
+    Render_size_table,
+    Render_size_func_table
+};
+
+/*****************************************************************/
+/* tree depth = 12 */
+static const int_fast16_t VendorPriv_dispatch_tree[152] = {
+    /* [0] -> opcode range [0, 131072], node depth 1 */
+    2,
+    5,
+    EMPTY_LEAF,
+    119,
+    EMPTY_LEAF,
+
+    /* [5] -> opcode range [0, 32768], node depth 2 */
+    1,
+    8,
+    EMPTY_LEAF,
+
+    /* [8] -> opcode range [0, 16384], node depth 3 */
+    1,
+    11,
+    EMPTY_LEAF,
+
+    /* [11] -> opcode range [0, 8192], node depth 4 */
+    2,
+    16,
+    EMPTY_LEAF,
+    78,
+    EMPTY_LEAF,
+
+    /* [16] -> opcode range [0, 2048], node depth 5 */
+    2,
+    21,
+    EMPTY_LEAF,
+    36,
+    EMPTY_LEAF,
+
+    /* [21] -> opcode range [0, 512], node depth 6 */
+    1,
+    24,
+    EMPTY_LEAF,
+
+    /* [24] -> opcode range [0, 256], node depth 7 */
+    1,
+    27,
+    EMPTY_LEAF,
+
+    /* [27] -> opcode range [0, 128], node depth 8 */
+    1,
+    30,
+    EMPTY_LEAF,
+
+    /* [30] -> opcode range [0, 64], node depth 9 */
+    1,
+    33,
+    EMPTY_LEAF,
+
+    /* [33] -> opcode range [0, 32], node depth 10 */
+    1,
+    LEAF(0),
+    EMPTY_LEAF,
+
+    /* [36] -> opcode range [1024, 1536], node depth 6 */
+    2,
+    41,
+    EMPTY_LEAF,
+    53,
+    67,
+
+    /* [41] -> opcode range [1024, 1152], node depth 7 */
+    1,
+    44,
+    EMPTY_LEAF,
+
+    /* [44] -> opcode range [1024, 1088], node depth 8 */
+    1,
+    47,
+    EMPTY_LEAF,
+
+    /* [47] -> opcode range [1024, 1056], node depth 9 */
+    1,
+    50,
+    EMPTY_LEAF,
+
+    /* [50] -> opcode range [1024, 1040], node depth 10 */
+    1,
+    LEAF(16),
+    EMPTY_LEAF,
+
+    /* [53] -> opcode range [1280, 1408], node depth 7 */
+    1,
+    56,
+    EMPTY_LEAF,
+
+    /* [56] -> opcode range [1280, 1344], node depth 8 */
+    2,
+    61,
+    LEAF(24),
+    EMPTY_LEAF,
+    64,
+
+    /* [61] -> opcode range [1280, 1296], node depth 9 */
+    1,
+    EMPTY_LEAF,
+    LEAF(40),
+
+    /* [64] -> opcode range [1328, 1344], node depth 9 */
+    1,
+    LEAF(48),
+    EMPTY_LEAF,
+
+    /* [67] -> opcode range [1408, 1536], node depth 7 */
+    1,
+    70,
+    EMPTY_LEAF,
+
+    /* [70] -> opcode range [1408, 1472], node depth 8 */
+    1,
+    73,
+    EMPTY_LEAF,
+
+    /* [73] -> opcode range [1408, 1440], node depth 9 */
+    2,
+    EMPTY_LEAF,
+    LEAF(56),
+    LEAF(64),
+    EMPTY_LEAF,
+
+    /* [78] -> opcode range [4096, 6144], node depth 5 */
+    2,
+    83,
+    EMPTY_LEAF,
+    101,
+    EMPTY_LEAF,
+
+    /* [83] -> opcode range [4096, 4608], node depth 6 */
+    1,
+    86,
+    EMPTY_LEAF,
+
+    /* [86] -> opcode range [4096, 4352], node depth 7 */
+    1,
+    89,
+    EMPTY_LEAF,
+
+    /* [89] -> opcode range [4096, 4224], node depth 8 */
+    1,
+    92,
+    EMPTY_LEAF,
+
+    /* [92] -> opcode range [4096, 4160], node depth 9 */
+    1,
+    95,
+    EMPTY_LEAF,
+
+    /* [95] -> opcode range [4096, 4128], node depth 10 */
+    1,
+    98,
+    EMPTY_LEAF,
+
+    /* [98] -> opcode range [4096, 4112], node depth 11 */
+    1,
+    LEAF(72),
+    EMPTY_LEAF,
+
+    /* [101] -> opcode range [5120, 5632], node depth 6 */
+    1,
+    104,
+    EMPTY_LEAF,
+
+    /* [104] -> opcode range [5120, 5376], node depth 7 */
+    1,
+    107,
+    EMPTY_LEAF,
+
+    /* [107] -> opcode range [5120, 5248], node depth 8 */
+    1,
+    110,
+    EMPTY_LEAF,
+
+    /* [110] -> opcode range [5120, 5184], node depth 9 */
+    1,
+    EMPTY_LEAF,
+    113,
+
+    /* [113] -> opcode range [5152, 5184], node depth 10 */
+    1,
+    116,
+    EMPTY_LEAF,
+
+    /* [116] -> opcode range [5152, 5168], node depth 11 */
+    1,
+    LEAF(80),
+    EMPTY_LEAF,
+
+    /* [119] -> opcode range [65536, 98304], node depth 2 */
+    1,
+    122,
+    EMPTY_LEAF,
+
+    /* [122] -> opcode range [65536, 81920], node depth 3 */
+    1,
+    125,
+    EMPTY_LEAF,
+
+    /* [125] -> opcode range [65536, 73728], node depth 4 */
+    1,
+    128,
+    EMPTY_LEAF,
+
+    /* [128] -> opcode range [65536, 69632], node depth 5 */
+    1,
+    131,
+    EMPTY_LEAF,
+
+    /* [131] -> opcode range [65536, 67584], node depth 6 */
+    1,
+    134,
+    EMPTY_LEAF,
+
+    /* [134] -> opcode range [65536, 66560], node depth 7 */
+    1,
+    137,
+    EMPTY_LEAF,
+
+    /* [137] -> opcode range [65536, 66048], node depth 8 */
+    1,
+    140,
+    EMPTY_LEAF,
+
+    /* [140] -> opcode range [65536, 65792], node depth 9 */
+    1,
+    143,
+    EMPTY_LEAF,
+
+    /* [143] -> opcode range [65536, 65664], node depth 10 */
+    1,
+    146,
+    EMPTY_LEAF,
+
+    /* [146] -> opcode range [65536, 65600], node depth 11 */
+    1,
+    149,
+    EMPTY_LEAF,
+
+    /* [149] -> opcode range [65536, 65568], node depth 12 */
+    1,
+    LEAF(88),
+    EMPTY_LEAF,
+
+};
+
+static const void *VendorPriv_function_table[104][2] = {
+    /* [  0] =     0 */ {NULL, NULL},
+    /* [  1] =     1 */ {__glXDisp_GetConvolutionFilterEXT, __glXDispSwap_GetConvolutionFilterEXT},
+    /* [  2] =     2 */ {__glXDisp_GetConvolutionParameterfvEXT, __glXDispSwap_GetConvolutionParameterfvEXT},
+    /* [  3] =     3 */ {__glXDisp_GetConvolutionParameterivEXT, __glXDispSwap_GetConvolutionParameterivEXT},
+    /* [  4] =     4 */ {__glXDisp_GetSeparableFilterEXT, __glXDispSwap_GetSeparableFilterEXT},
+    /* [  5] =     5 */ {__glXDisp_GetHistogramEXT, __glXDispSwap_GetHistogramEXT},
+    /* [  6] =     6 */ {__glXDisp_GetHistogramParameterfvEXT, __glXDispSwap_GetHistogramParameterfvEXT},
+    /* [  7] =     7 */ {__glXDisp_GetHistogramParameterivEXT, __glXDispSwap_GetHistogramParameterivEXT},
+    /* [  8] =     8 */ {__glXDisp_GetMinmaxEXT, __glXDispSwap_GetMinmaxEXT},
+    /* [  9] =     9 */ {__glXDisp_GetMinmaxParameterfvEXT, __glXDispSwap_GetMinmaxParameterfvEXT},
+    /* [ 10] =    10 */ {__glXDisp_GetMinmaxParameterivEXT, __glXDispSwap_GetMinmaxParameterivEXT},
+    /* [ 11] =    11 */ {__glXDisp_AreTexturesResidentEXT, __glXDispSwap_AreTexturesResidentEXT},
+    /* [ 12] =    12 */ {__glXDisp_DeleteTexturesEXT, __glXDispSwap_DeleteTexturesEXT},
+    /* [ 13] =    13 */ {__glXDisp_GenTexturesEXT, __glXDispSwap_GenTexturesEXT},
+    /* [ 14] =    14 */ {__glXDisp_IsTextureEXT, __glXDispSwap_IsTextureEXT},
+    /* [ 15] =    15 */ {NULL, NULL},
+    /* [ 16] =  1024 */ {__glXDisp_QueryContextInfoEXT, __glXDispSwap_QueryContextInfoEXT},
+    /* [ 17] =  1025 */ {NULL, NULL},
+    /* [ 18] =  1026 */ {NULL, NULL},
+    /* [ 19] =  1027 */ {NULL, NULL},
+    /* [ 20] =  1028 */ {NULL, NULL},
+    /* [ 21] =  1029 */ {NULL, NULL},
+    /* [ 22] =  1030 */ {NULL, NULL},
+    /* [ 23] =  1031 */ {NULL, NULL},
+    /* [ 24] =  1296 */ {__glXDisp_GetProgramEnvParameterfvARB, __glXDispSwap_GetProgramEnvParameterfvARB},
+    /* [ 25] =  1297 */ {__glXDisp_GetProgramEnvParameterdvARB, __glXDispSwap_GetProgramEnvParameterdvARB},
+    /* [ 26] =  1298 */ {__glXDisp_GetProgramivNV, __glXDispSwap_GetProgramivNV},
+    /* [ 27] =  1299 */ {__glXDisp_GetProgramStringNV, __glXDispSwap_GetProgramStringNV},
+    /* [ 28] =  1300 */ {__glXDisp_GetTrackMatrixivNV, __glXDispSwap_GetTrackMatrixivNV},
+    /* [ 29] =  1301 */ {__glXDisp_GetVertexAttribdvARB, __glXDispSwap_GetVertexAttribdvARB},
+    /* [ 30] =  1302 */ {__glXDisp_GetVertexAttribfvARB, __glXDispSwap_GetVertexAttribfvARB},
+    /* [ 31] =  1303 */ {__glXDisp_GetVertexAttribivNV, __glXDispSwap_GetVertexAttribivNV},
+    /* [ 32] =  1304 */ {__glXDisp_IsProgramNV, __glXDispSwap_IsProgramNV},
+    /* [ 33] =  1305 */ {__glXDisp_GetProgramLocalParameterfvARB, __glXDispSwap_GetProgramLocalParameterfvARB},
+    /* [ 34] =  1306 */ {__glXDisp_GetProgramLocalParameterdvARB, __glXDispSwap_GetProgramLocalParameterdvARB},
+    /* [ 35] =  1307 */ {__glXDisp_GetProgramivARB, __glXDispSwap_GetProgramivARB},
+    /* [ 36] =  1308 */ {__glXDisp_GetProgramStringARB, __glXDispSwap_GetProgramStringARB},
+    /* [ 37] =  1309 */ {NULL, NULL},
+    /* [ 38] =  1310 */ {__glXDisp_GetProgramNamedParameterfvNV, __glXDispSwap_GetProgramNamedParameterfvNV},
+    /* [ 39] =  1311 */ {__glXDisp_GetProgramNamedParameterdvNV, __glXDispSwap_GetProgramNamedParameterdvNV},
+    /* [ 40] =  1288 */ {NULL, NULL},
+    /* [ 41] =  1289 */ {NULL, NULL},
+    /* [ 42] =  1290 */ {NULL, NULL},
+    /* [ 43] =  1291 */ {NULL, NULL},
+    /* [ 44] =  1292 */ {NULL, NULL},
+    /* [ 45] =  1293 */ {__glXDisp_AreProgramsResidentNV, __glXDispSwap_AreProgramsResidentNV},
+    /* [ 46] =  1294 */ {__glXDisp_DeleteProgramsNV, __glXDispSwap_DeleteProgramsNV},
+    /* [ 47] =  1295 */ {__glXDisp_GenProgramsNV, __glXDispSwap_GenProgramsNV},
+    /* [ 48] =  1328 */ {NULL, NULL},
+    /* [ 49] =  1329 */ {NULL, NULL},
+    /* [ 50] =  1330 */ {__glXDisp_BindTexImageEXT, __glXDispSwap_BindTexImageEXT},
+    /* [ 51] =  1331 */ {__glXDisp_ReleaseTexImageEXT, __glXDispSwap_ReleaseTexImageEXT},
+    /* [ 52] =  1332 */ {NULL, NULL},
+    /* [ 53] =  1333 */ {NULL, NULL},
+    /* [ 54] =  1334 */ {NULL, NULL},
+    /* [ 55] =  1335 */ {NULL, NULL},
+    /* [ 56] =  1416 */ {NULL, NULL},
+    /* [ 57] =  1417 */ {NULL, NULL},
+    /* [ 58] =  1418 */ {NULL, NULL},
+    /* [ 59] =  1419 */ {NULL, NULL},
+    /* [ 60] =  1420 */ {NULL, NULL},
+    /* [ 61] =  1421 */ {NULL, NULL},
+    /* [ 62] =  1422 */ {__glXDisp_IsRenderbufferEXT, __glXDispSwap_IsRenderbufferEXT},
+    /* [ 63] =  1423 */ {__glXDisp_GenRenderbuffersEXT, __glXDispSwap_GenRenderbuffersEXT},
+    /* [ 64] =  1424 */ {__glXDisp_GetRenderbufferParameterivEXT, __glXDispSwap_GetRenderbufferParameterivEXT},
+    /* [ 65] =  1425 */ {__glXDisp_IsFramebufferEXT, __glXDispSwap_IsFramebufferEXT},
+    /* [ 66] =  1426 */ {__glXDisp_GenFramebuffersEXT, __glXDispSwap_GenFramebuffersEXT},
+    /* [ 67] =  1427 */ {__glXDisp_CheckFramebufferStatusEXT, __glXDispSwap_CheckFramebufferStatusEXT},
+    /* [ 68] =  1428 */ {__glXDisp_GetFramebufferAttachmentParameterivEXT, __glXDispSwap_GetFramebufferAttachmentParameterivEXT},
+    /* [ 69] =  1429 */ {NULL, NULL},
+    /* [ 70] =  1430 */ {NULL, NULL},
+    /* [ 71] =  1431 */ {NULL, NULL},
+    /* [ 72] =  4096 */ {NULL, NULL},
+    /* [ 73] =  4097 */ {NULL, NULL},
+    /* [ 74] =  4098 */ {__glXDisp_GetColorTableSGI, __glXDispSwap_GetColorTableSGI},
+    /* [ 75] =  4099 */ {__glXDisp_GetColorTableParameterfvSGI, __glXDispSwap_GetColorTableParameterfvSGI},
+    /* [ 76] =  4100 */ {__glXDisp_GetColorTableParameterivSGI, __glXDispSwap_GetColorTableParameterivSGI},
+    /* [ 77] =  4101 */ {NULL, NULL},
+    /* [ 78] =  4102 */ {NULL, NULL},
+    /* [ 79] =  4103 */ {NULL, NULL},
+    /* [ 80] =  5152 */ {NULL, NULL},
+    /* [ 81] =  5153 */ {NULL, NULL},
+    /* [ 82] =  5154 */ {__glXDisp_CopySubBufferMESA, __glXDispSwap_CopySubBufferMESA},
+    /* [ 83] =  5155 */ {NULL, NULL},
+    /* [ 84] =  5156 */ {NULL, NULL},
+    /* [ 85] =  5157 */ {NULL, NULL},
+    /* [ 86] =  5158 */ {NULL, NULL},
+    /* [ 87] =  5159 */ {NULL, NULL},
+    /* [ 88] = 65536 */ {__glXDisp_SwapIntervalSGI, __glXDispSwap_SwapIntervalSGI},
+    /* [ 89] = 65537 */ {__glXDisp_MakeCurrentReadSGI, __glXDispSwap_MakeCurrentReadSGI},
+    /* [ 90] = 65538 */ {NULL, NULL},
+    /* [ 91] = 65539 */ {NULL, NULL},
+    /* [ 92] = 65540 */ {__glXDisp_GetFBConfigsSGIX, __glXDispSwap_GetFBConfigsSGIX},
+    /* [ 93] = 65541 */ {__glXDisp_CreateContextWithConfigSGIX, __glXDispSwap_CreateContextWithConfigSGIX},
+    /* [ 94] = 65542 */ {__glXDisp_CreateGLXPixmapWithConfigSGIX, __glXDispSwap_CreateGLXPixmapWithConfigSGIX},
+    /* [ 95] = 65543 */ {__glXDisp_CreateGLXPbufferSGIX, __glXDispSwap_CreateGLXPbufferSGIX},
+    /* [ 96] = 65544 */ {__glXDisp_DestroyGLXPbufferSGIX, __glXDispSwap_DestroyGLXPbufferSGIX},
+    /* [ 97] = 65545 */ {__glXDisp_ChangeDrawableAttributesSGIX, __glXDispSwap_ChangeDrawableAttributesSGIX},
+    /* [ 98] = 65546 */ {__glXDisp_GetDrawableAttributesSGIX, __glXDispSwap_GetDrawableAttributesSGIX},
+    /* [ 99] = 65547 */ {NULL, NULL},
+    /* [ 100] = 65548 */ {NULL, NULL},
+    /* [ 101] = 65549 */ {NULL, NULL},
+    /* [ 102] = 65550 */ {NULL, NULL},
+    /* [ 103] = 65551 */ {NULL, NULL},
+};
+
+const struct __glXDispatchInfo VendorPriv_dispatch_info = {
+    17,
+    VendorPriv_dispatch_tree,
+    VendorPriv_function_table,
+    NULL,
+    NULL
+};
+
diff --git a/xorg-server/hw/dmx/examples/Makefile.am b/xorg-server/hw/dmx/examples/Makefile.am
index 229bb57fc..d055ddc71 100644
--- a/xorg-server/hw/dmx/examples/Makefile.am
+++ b/xorg-server/hw/dmx/examples/Makefile.am
@@ -10,60 +10,60 @@ bin_PROGRAMS = \
 noinst_PROGRAMS = xinput xtest evi res xled xbell $(EV_PROG)
 
 dmxinfo_SOURCES = dmxinfo.c
-dmxinfo_LDADD = @DMXEXAMPLES_DEP_LIBS@
-dmxinfo_CFLAGS = @DMXEXAMPLES_DEP_CFLAGS@
+dmxinfo_LDADD = $(DMXEXAMPLES_DEP_LIBS)
+dmxinfo_CFLAGS = $(DMXEXAMPLES_DEP_CFLAGS) $(CWARNFLAGS)
 
 dmxwininfo_SOURCES = dmxwininfo.c
-dmxwininfo_LDADD = @DMXXMUEXAMPLES_DEP_LIBS@
-dmxwininfo_CFLAGS = @DMXXMUEXAMPLES_DEP_CFLAGS@
+dmxwininfo_LDADD = $(DMXXMUEXAMPLES_DEP_LIBS)
+dmxwininfo_CFLAGS = $(DMXXMUEXAMPLES_DEP_CFLAGS) $(CWARNFLAGS)
 
 dmxreconfig_SOURCES = dmxreconfig.c
-dmxreconfig_LDADD = @DMXEXAMPLES_DEP_LIBS@
-dmxreconfig_CFLAGS = @DMXEXAMPLES_DEP_CFLAGS@
+dmxreconfig_LDADD = $(DMXEXAMPLES_DEP_LIBS)
+dmxreconfig_CFLAGS = $(DMXEXAMPLES_DEP_CFLAGS) $(CWARNFLAGS)
 
 dmxresize_SOURCES = dmxresize.c
-dmxresize_LDADD = @DMXEXAMPLES_DEP_LIBS@
-dmxresize_CFLAGS = @DMXEXAMPLES_DEP_CFLAGS@
+dmxresize_LDADD = $(DMXEXAMPLES_DEP_LIBS)
+dmxresize_CFLAGS = $(DMXEXAMPLES_DEP_CFLAGS) $(CWARNFLAGS)
 
 dmxaddscreen_SOURCES = dmxaddscreen.c
-dmxaddscreen_LDADD = @DMXEXAMPLES_DEP_LIBS@
-dmxaddscreen_CFLAGS = @DMXEXAMPLES_DEP_CFLAGS@
+dmxaddscreen_LDADD = $(DMXEXAMPLES_DEP_LIBS)
+dmxaddscreen_CFLAGS = $(DMXEXAMPLES_DEP_CFLAGS) $(CWARNFLAGS)
 
 dmxrmscreen_SOURCES = dmxrmscreen.c
-dmxrmscreen_LDADD = @DMXEXAMPLES_DEP_LIBS@
-dmxrmscreen_CFLAGS = @DMXEXAMPLES_DEP_CFLAGS@
+dmxrmscreen_LDADD = $(DMXEXAMPLES_DEP_LIBS)
+dmxrmscreen_CFLAGS = $(DMXEXAMPLES_DEP_CFLAGS) $(CWARNFLAGS)
 
 dmxaddinput_SOURCES = dmxaddinput.c
-dmxaddinput_LDADD = @DMXEXAMPLES_DEP_LIBS@
-dmxaddinput_CFLAGS = @DMXEXAMPLES_DEP_CFLAGS@
+dmxaddinput_LDADD = $(DMXEXAMPLES_DEP_LIBS)
+dmxaddinput_CFLAGS = $(DMXEXAMPLES_DEP_CFLAGS) $(CWARNFLAGS)
 
 dmxrminput_SOURCES = dmxrminput.c
-dmxrminput_LDADD = @DMXEXAMPLES_DEP_LIBS@
-dmxrminput_CFLAGS = @DMXEXAMPLES_DEP_CFLAGS@
+dmxrminput_LDADD = $(DMXEXAMPLES_DEP_LIBS)
+dmxrminput_CFLAGS = $(DMXEXAMPLES_DEP_CFLAGS) $(CWARNFLAGS)
 
 xinput_SOURCES = xinput.c
-xinput_LDADD = @DMXXIEXAMPLES_DEP_LIBS@
-xinput_CFLAGS = @DMXXIEXAMPLES_DEP_CFLAGS@
+xinput_LDADD = $(DMXXIEXAMPLES_DEP_LIBS)
+xinput_CFLAGS = $(DMXXIEXAMPLES_DEP_CFLAGS) $(CWARNFLAGS)
 
 xtest_SOURCES = xtest.c
-xtest_LDADD = @XTSTEXAMPLES_DEP_LIBS@
-xtest_CFLAGS = @XTSTEXAMPLES_DEP_CFLAGS@
+xtest_LDADD = $(XTSTEXAMPLES_DEP_LIBS)
+xtest_CFLAGS = $(XTSTEXAMPLES_DEP_CFLAGS) $(CWARNFLAGS)
 
 evi_SOURCES = evi.c
-evi_LDADD = @X11EXAMPLES_DEP_LIBS@
-evi_CFLAGS = @X11EXAMPLES_DEP_CFLAGS@
+evi_LDADD = $(X11EXAMPLES_DEP_LIBS)
+evi_CFLAGS = $(X11EXAMPLES_DEP_CFLAGS) $(CWARNFLAGS)
 
 res_SOURCES = res.c
-res_LDADD = @XRESEXAMPLES_DEP_LIBS@
-res_CFLAGS = @XRESEXAMPLES_DEP_CFLAGS@
+res_LDADD = $(XRESEXAMPLES_DEP_LIBS)
+res_CFLAGS = $(XRESEXAMPLES_DEP_CFLAGS) $(CWARNFLAGS)
 
 xled_SOURCES = xled.c
-xled_LDADD = @X11EXAMPLES_DEP_LIBS@
-xled_CFLAGS = @X11EXAMPLES_DEP_CFLAGS@
+xled_LDADD = $(X11EXAMPLES_DEP_LIBS)
+xled_CFLAGS = $(X11EXAMPLES_DEP_CFLAGS) $(CWARNFLAGS)
 
 xbell_SOURCES = xbell.c
-xbell_LDADD = @X11EXAMPLES_DEP_LIBS@
-xbell_CFLAGS = @X11EXAMPLES_DEP_CFLAGS@
+xbell_LDADD = $(X11EXAMPLES_DEP_LIBS)
+xbell_CFLAGS = $(X11EXAMPLES_DEP_CFLAGS) $(CWARNFLAGS)
 
 ev_SOURCES = ev.c
 ev_LDADD = 
diff --git a/xorg-server/hw/kdrive/linux/keyboard.c b/xorg-server/hw/kdrive/linux/keyboard.c
index f5f9d9b8a..ba2637b58 100644
--- a/xorg-server/hw/kdrive/linux/keyboard.c
+++ b/xorg-server/hw/kdrive/linux/keyboard.c
@@ -692,7 +692,7 @@ LinuxKeyboardEnable (KdKeyboardInfo *ki)
         return !Success;
 
     fd = LinuxConsoleFd;
-    ki->driverPrivate = (void *) fd;
+    ki->driverPrivate = (void *) (intptr_t) fd;
 
     ioctl (fd, KDGKBMODE, &LinuxKbdTrans);
     tcgetattr (fd, &LinuxTermios);
@@ -724,7 +724,7 @@ LinuxKeyboardDisable (KdKeyboardInfo *ki)
     if (!ki)
         return;
 
-    fd = (int) ki->driverPrivate;
+    fd = (int) (intptr_t) ki->driverPrivate;
 
     KdUnregisterFd(ki, fd, FALSE);
     ioctl(fd, KDSKBMODE, LinuxKbdTrans);
@@ -753,7 +753,7 @@ LinuxKeyboardLeds (KdKeyboardInfo *ki, int leds)
     if (!ki)
         return;
 
-    ioctl ((int)ki->driverPrivate, KDSETLED, leds & 7);
+    ioctl ((int)(intptr_t)ki->driverPrivate, KDSETLED, leds & 7);
 }
 
 KdKeyboardDriver LinuxKeyboardDriver = {
diff --git a/xorg-server/hw/kdrive/linux/ms.c b/xorg-server/hw/kdrive/linux/ms.c
index b6151cd90..176e12550 100644
--- a/xorg-server/hw/kdrive/linux/ms.c
+++ b/xorg-server/hw/kdrive/linux/ms.c
@@ -152,7 +152,7 @@ MsEnable (KdPointerInfo *pi)
     }
     if (KdRegisterFd (port, MsRead, pi))
 	return TRUE;
-    pi->driverPrivate = (void *)port;
+    pi->driverPrivate = (void *)(intptr_t)port;
 
     return Success;
 
@@ -164,7 +164,7 @@ MsEnable (KdPointerInfo *pi)
 static void
 MsDisable (KdPointerInfo *pi)
 {
-    KdUnregisterFd (pi, (int)pi->driverPrivate, TRUE);
+    KdUnregisterFd (pi, (int)(intptr_t)pi->driverPrivate, TRUE);
 }
 
 static void
diff --git a/xorg-server/hw/kdrive/linux/ps2.c b/xorg-server/hw/kdrive/linux/ps2.c
index 465b963f2..b62d769f2 100644
--- a/xorg-server/hw/kdrive/linux/ps2.c
+++ b/xorg-server/hw/kdrive/linux/ps2.c
@@ -159,7 +159,7 @@ Ps2Enable (KdPointerInfo *pi)
         return BadAlloc;
     }
 
-    pi->driverPrivate = (void *)fd;
+    pi->driverPrivate = (void *)(intptr_t)fd;
 
     return Success;
 }
@@ -168,7 +168,7 @@ Ps2Enable (KdPointerInfo *pi)
 static void
 Ps2Disable (KdPointerInfo *pi)
 {
-    KdUnregisterFd (pi, (int)pi->driverPrivate, TRUE);
+    KdUnregisterFd (pi, (int)(intptr_t)pi->driverPrivate, TRUE);
 }
 
 static void
diff --git a/xorg-server/hw/xfree86/common/xf86Module.h b/xorg-server/hw/xfree86/common/xf86Module.h
index d35464351..1de87dbbe 100644
--- a/xorg-server/hw/xfree86/common/xf86Module.h
+++ b/xorg-server/hw/xfree86/common/xf86Module.h
@@ -83,7 +83,7 @@ typedef enum {
  */
 #define ABI_ANSIC_VERSION	SET_ABI_VERSION(0, 4)
 #define ABI_VIDEODRV_VERSION	SET_ABI_VERSION(12, 0)
-#define ABI_XINPUT_VERSION	SET_ABI_VERSION(15, 0)
+#define ABI_XINPUT_VERSION	SET_ABI_VERSION(16, 0)
 #define ABI_EXTENSION_VERSION	SET_ABI_VERSION(6, 0)
 #define ABI_FONT_VERSION	SET_ABI_VERSION(0, 6)
 
diff --git a/xorg-server/hw/xfree86/common/xf86Xinput.c b/xorg-server/hw/xfree86/common/xf86Xinput.c
index b9753f01d..280a6ec93 100644
--- a/xorg-server/hw/xfree86/common/xf86Xinput.c
+++ b/xorg-server/hw/xfree86/common/xf86Xinput.c
@@ -1410,4 +1410,28 @@ xf86EnableDevice(DeviceIntPtr dev)
     EnableDevice(dev, TRUE);
 }
 
+/**
+ * Post a touch event with optional valuators.  If this is the first touch in
+ * the sequence, at least x & y valuators must be provided. The driver is
+ * responsible for maintaining the correct event sequence (TouchBegin, TouchUpdate,
+ * TouchEnd). Submitting an update or end event for a unregistered touchid will
+ * result in errors.
+ * Touch IDs may be reused by the driver but only after a TouchEnd has been
+ * submitted for that touch ID.
+ *
+ * @param dev The device to post the event for
+ * @param touchid The touchid of the current touch event. Must be an
+ * existing ID for TouchUpdate or TouchEnd events
+ * @param type One of XI_TouchBegin, XI_TouchUpdate, XI_TouchEnd
+ * @param flags Flags for this event
+ * @param The valuator mask with all valuators set for this event.
+ */
+void
+xf86PostTouchEvent(DeviceIntPtr dev, uint32_t touchid, uint16_t type,
+                   uint32_t flags, const ValuatorMask *mask)
+{
+
+    QueueTouchEvents(dev, type, touchid, flags, mask);
+}
+
 /* end of xf86Xinput.c */
diff --git a/xorg-server/hw/xfree86/common/xf86Xinput.h b/xorg-server/hw/xfree86/common/xf86Xinput.h
index 7d96fac78..ad092dd03 100644
--- a/xorg-server/hw/xfree86/common/xf86Xinput.h
+++ b/xorg-server/hw/xfree86/common/xf86Xinput.h
@@ -141,6 +141,9 @@ extern _X_EXPORT void xf86PostKeyEventP(DeviceIntPtr device, unsigned int key_co
 		       const int *valuators);
 extern _X_EXPORT void xf86PostKeyboardEvent(DeviceIntPtr device, unsigned int key_code,
                            int is_down);
+extern _X_EXPORT void xf86PostTouchEvent(DeviceIntPtr dev, uint32_t touchid,
+                                         uint16_t type, uint32_t flags,
+                                         const ValuatorMask *mask);
 extern _X_EXPORT InputInfoPtr xf86FirstLocalDevice(void);
 extern _X_EXPORT int xf86ScaleAxis(int Cx, int to_max, int to_min, int from_max, int from_min);
 extern _X_EXPORT void xf86ProcessCommonOptions(InputInfoPtr pInfo, XF86OptionPtr options);
diff --git a/xorg-server/hw/xfree86/dri2/dri2.c b/xorg-server/hw/xfree86/dri2/dri2.c
index 0d613be8e..d6441a234 100644
--- a/xorg-server/hw/xfree86/dri2/dri2.c
+++ b/xorg-server/hw/xfree86/dri2/dri2.c
@@ -181,6 +181,7 @@ DRI2AllocateDrawable(DrawablePtr pDraw)
     pPriv->last_swap_ust = 0;
     list_init(&pPriv->reference_list);
     pPriv->serialNumber = DRI2DrawableSerial(pDraw);
+    pPriv->needInvalidate = FALSE;
 
     if (pDraw->type == DRAWABLE_WINDOW) {
 	pWin = (WindowPtr) pDraw;
@@ -376,6 +377,7 @@ allocate_or_reuse_buffer(DrawablePtr pDraw, DRI2ScreenPtr ds,
     int old_buf = find_attachment(pPriv, attachment);
 
     if ((old_buf < 0)
+	|| attachment == DRI2BufferFrontLeft
 	|| !dimensions_match
 	|| (pPriv->buffers[old_buf]->format != format)) {
 	*buffer = (*ds->CreateBuffer)(pDraw, attachment, format);
@@ -585,7 +587,7 @@ DRI2InvalidateDrawable(DrawablePtr pDraw)
     pPriv->needInvalidate = FALSE;
 
     list_for_each_entry(ref, &pPriv->reference_list, link)
-	ref->invalidate(pDraw, ref->priv);
+	ref->invalidate(pDraw, ref->priv, ref->id);
 }
 
 /*
@@ -828,6 +830,19 @@ DRI2WaitSwap(ClientPtr client, DrawablePtr pDrawable)
     return FALSE;
 }
 
+/*
+ * A TraverseTree callback to invalidate all windows using the same
+ * pixmap
+ */
+static int
+DRI2InvalidateWalk(WindowPtr pWin, pointer data)
+{
+    if (pWin->drawable.pScreen->GetWindowPixmap(pWin) != data)
+	return WT_DONTWALKCHILDREN;
+    DRI2InvalidateDrawable(&pWin->drawable);
+    return WT_WALKCHILDREN;
+}
+
 int
 DRI2SwapBuffers(ClientPtr client, DrawablePtr pDraw, CARD64 target_msc,
 		CARD64 divisor, CARD64 remainder, CARD64 *swap_target,
@@ -928,7 +943,24 @@ DRI2SwapBuffers(ClientPtr client, DrawablePtr pDraw, CARD64 target_msc,
      */
     *swap_target = pPriv->swap_count + pPriv->swapsPending;
 
-    DRI2InvalidateDrawable(pDraw);
+    if (pDraw->type == DRAWABLE_WINDOW) {
+	WindowPtr	pWin = (WindowPtr) pDraw;
+	PixmapPtr	pPixmap = pScreen->GetWindowPixmap(pWin);
+
+	/*
+	 * Find the top-most window using this pixmap
+	 */
+	while (pWin->parent && pScreen->GetWindowPixmap(pWin->parent) == pPixmap)
+	    pWin = pWin->parent;
+
+	/*
+	 * Walk the sub-tree to invalidate all of the
+	 * windows using the same pixmap
+	 */
+	TraverseTree(pWin, DRI2InvalidateWalk, pPixmap);
+	DRI2InvalidateDrawable(&pPixmap->drawable);
+    } else
+	DRI2InvalidateDrawable(pDraw);
 
     return Success;
 }
diff --git a/xorg-server/hw/xfree86/dri2/dri2.h b/xorg-server/hw/xfree86/dri2/dri2.h
index 9c93209d1..a67e35f73 100644
--- a/xorg-server/hw/xfree86/dri2/dri2.h
+++ b/xorg-server/hw/xfree86/dri2/dri2.h
@@ -166,7 +166,8 @@ typedef int		(*DRI2ScheduleWaitMSCProcPtr)(ClientPtr client,
 						      CARD64 remainder);
 
 typedef void		(*DRI2InvalidateProcPtr)(DrawablePtr pDraw,
-						 void *data);
+						 void *data,
+						 XID id);
 
 /**
  * DRI2 calls this hook when ever swap_limit is going to be changed. Default
diff --git a/xorg-server/hw/xfree86/dri2/dri2ext.c b/xorg-server/hw/xfree86/dri2/dri2ext.c
index e612cf051..73ef7f25e 100644
--- a/xorg-server/hw/xfree86/dri2/dri2ext.c
+++ b/xorg-server/hw/xfree86/dri2/dri2ext.c
@@ -156,13 +156,13 @@ ProcDRI2Authenticate(ClientPtr client)
 }
 
 static void
-DRI2InvalidateBuffersEvent(DrawablePtr pDraw, void *priv)
+DRI2InvalidateBuffersEvent(DrawablePtr pDraw, void *priv, XID id)
 {
     xDRI2InvalidateBuffers event;
     ClientPtr client = priv;
 
     event.type = DRI2EventBase + DRI2_InvalidateBuffers;
-    event.drawable = pDraw->id;
+    event.drawable = id;
 
     WriteEventsToClient(client, 1, (xEvent *)&event);
 }
diff --git a/xorg-server/hw/xquartz/mach-startup/Makefile.am b/xorg-server/hw/xquartz/mach-startup/Makefile.am
index 0b1f8977e..21ad5b503 100644
--- a/xorg-server/hw/xquartz/mach-startup/Makefile.am
+++ b/xorg-server/hw/xquartz/mach-startup/Makefile.am
@@ -12,6 +12,13 @@ x11app_PROGRAMS = X11.bin
 dist_X11_bin_SOURCES = \
 	bundle-main.c 
 
+# strndup(3) was added in Mac OS X 10.7, but we do this unconditionally to deal
+# with the case where we build on Lion but target Snow Leopard as the minimum
+# OS version.
+#if NEED_STRNDUP
+dist_X11_bin_SOURCES += $(top_srcdir)/os/strndup.c
+#endif
+
 nodist_X11_bin_SOURCES = \
 	mach_startupServer.c \
 	mach_startupUser.c
diff --git a/xorg-server/include/dix.h b/xorg-server/include/dix.h
index 272fd4161..f3f68d39c 100644
--- a/xorg-server/include/dix.h
+++ b/xorg-server/include/dix.h
@@ -405,6 +405,12 @@ extern int DeliverOneGrabbedEvent(
     DeviceIntPtr /* dev */,
     enum InputLevel /* level */);
 
+extern void DeliverTouchEvents(
+    DeviceIntPtr /* dev */,
+    TouchPointInfoPtr /* ti */,
+    InternalEvent* /* ev */,
+    XID /* resource */);
+
 extern void InitializeSprite(
     DeviceIntPtr /* pDev */,
     WindowPtr    /* pWin */);
@@ -582,6 +588,7 @@ extern Bool DevHasCursor(DeviceIntPtr pDev);
 extern _X_EXPORT Bool IsPointerDevice(DeviceIntPtr dev);
 extern _X_EXPORT Bool IsKeyboardDevice(DeviceIntPtr dev);
 extern Bool IsPointerEvent(InternalEvent *event);
+extern Bool IsTouchEvent(InternalEvent *event);
 extern _X_EXPORT Bool IsMaster(DeviceIntPtr dev);
 extern _X_EXPORT Bool IsFloating(DeviceIntPtr dev);
 
diff --git a/xorg-server/include/events.h b/xorg-server/include/events.h
index 375173adc..222cc3d19 100644
--- a/xorg-server/include/events.h
+++ b/xorg-server/include/events.h
@@ -26,6 +26,7 @@
 #define EVENTS_H
 typedef struct _DeviceEvent DeviceEvent;
 typedef struct _DeviceChangedEvent DeviceChangedEvent;
+typedef struct _TouchOwnershipEvent TouchOwnershipEvent;
 #if XFreeXDGA
 typedef struct _DGAEvent DGAEvent;
 #endif
diff --git a/xorg-server/include/eventstr.h b/xorg-server/include/eventstr.h
index 4d836fb14..e4410a79f 100644
--- a/xorg-server/include/eventstr.h
+++ b/xorg-server/include/eventstr.h
@@ -50,6 +50,10 @@ enum EventType {
     ET_ButtonPress,
     ET_ButtonRelease,
     ET_Motion,
+    ET_TouchBegin,
+    ET_TouchUpdate,
+    ET_TouchEnd,
+    ET_TouchOwnership,
     ET_Enter,
     ET_Leave,
     ET_FocusIn,
@@ -64,6 +68,9 @@ enum EventType {
     ET_RawButtonPress,
     ET_RawButtonRelease,
     ET_RawMotion,
+    ET_RawTouchBegin,
+    ET_RawTouchUpdate,
+    ET_RawTouchEnd,
     ET_XQuartz,
     ET_Internal = 0xFF /* First byte */
 };
@@ -84,9 +91,11 @@ struct _DeviceEvent
     int deviceid;         /**< Device to post this event for */
     int sourceid;         /**< The physical source device */
     union {
-        uint32_t button;  /**< Button number */
+        uint32_t button;  /**< Button number (also used in pointer emulating
+                               touch events) */
         uint32_t key;     /**< Key code */
     } detail;
+    uint32_t touchid;     /**< Touch ID (client_id) */
     int16_t root_x;       /**< Pos relative to root window in integral data */
     float root_x_frac;    /**< Pos relative to root window in frac part */
     int16_t root_y;       /**< Pos relative to root window in integral part */
@@ -115,6 +124,24 @@ struct _DeviceEvent
     uint32_t flags;   /**< Flags to be copied into the generated event */
 };
 
+/**
+ * Generated internally whenever a touch ownership chain changes - an owner
+ * has accepted or rejected a touch, or a grab/event selection in the delivery
+ * chain has been removed.
+ */
+struct _TouchOwnershipEvent
+{
+    unsigned char header; /**< Always ET_Internal */
+    enum EventType type;  /**< One of EventType */
+    int length;           /**< Length in bytes */
+    Time time;            /**< Time in ms */
+    int deviceid;         /**< Device to post this event for */
+    int sourceid;         /**< The physical source device */
+    uint32_t touchid;     /**< Touch ID (client_id) */
+    uint8_t reason;       /**< ::XIAcceptTouch, ::XIRejectTouch */
+    uint32_t resource;    /**< Provoking grab or event selection */
+    uint32_t flags;       /**< Flags to be copied into the generated event */
+};
 
 /* Flags used in DeviceChangedEvent to signal if the slave has changed */
 #define DEVCHANGE_SLAVE_SWITCH 0x2
@@ -230,6 +257,7 @@ union _InternalEvent {
         } any;
         DeviceEvent device_event;
         DeviceChangedEvent changed_event;
+        TouchOwnershipEvent touch_ownership_event;
 #if XFreeXDGA
         DGAEvent dga_event;
 #endif
diff --git a/xorg-server/include/exevents.h b/xorg-server/include/exevents.h
index 0ab04f525..bd1697066 100644
--- a/xorg-server/include/exevents.h
+++ b/xorg-server/include/exevents.h
@@ -222,6 +222,14 @@ GrabWindow(
 	GrabMask*              /* eventMask */);
 
 extern int
+GrabTouch(
+       ClientPtr              /* client */,
+       DeviceIntPtr           /* dev */,
+       DeviceIntPtr           /* mod_dev */,
+       GrabParameters*        /* param */,
+       GrabMask*              /* eventMask */);
+
+extern int
 SelectForWindow(
 	DeviceIntPtr           /* dev */,
 	WindowPtr              /* pWin */,
@@ -245,6 +253,10 @@ InputClientGone(
 	WindowPtr              /* pWin */,
 	XID                    /* id */);
 
+extern void
+WindowGone(
+	WindowPtr              /* win */);
+
 extern int
 SendEvent (
 	ClientPtr              /* client */,
diff --git a/xorg-server/include/input.h b/xorg-server/include/input.h
index bd12f6829..fb456175a 100644
--- a/xorg-server/include/input.h
+++ b/xorg-server/include/input.h
@@ -71,6 +71,15 @@ SOFTWARE.
 #define POINTER_NORAW		(1 << 5)	/* Don't generate RawEvents */
 #define POINTER_EMULATED	(1 << 6)	/* Event was emulated from another event */
 
+/* GetTouchEvent flags */
+#define TOUCH_ACCEPT            (1 << 0)
+#define TOUCH_REJECT            (1 << 1)
+#define TOUCH_PENDING_END       (1 << 2)
+#define TOUCH_CLIENT_ID         (1 << 3)        /* touch ID is the client-visible id */
+#define TOUCH_REPLAYING         (1 << 4)        /* event is being replayed */
+#define TOUCH_POINTER_EMULATED  (1 << 5)        /* touch event may be pointer emulated */
+#define TOUCH_END               (1 << 6)        /* really end this touch now */
+
 /*int constants for pointer acceleration schemes*/
 #define PtrAccelNoOp            0
 #define PtrAccelPredictable     1
@@ -115,6 +124,9 @@ typedef struct _DeviceIntRec *DeviceIntPtr;
 typedef struct _ValuatorClassRec *ValuatorClassPtr;
 typedef struct _ClassesRec *ClassesPtr;
 typedef struct _SpriteRec *SpritePtr;
+typedef struct _TouchClassRec *TouchClassPtr;
+typedef struct _TouchPointInfo *TouchPointInfoPtr;
+typedef struct _DDXTouchPointInfo *DDXTouchPointInfoPtr;
 typedef union _GrabMask GrabMask;
 
 typedef struct _ValuatorMask ValuatorMask;
@@ -315,6 +327,12 @@ extern _X_EXPORT Bool InitPointerAccelerationScheme(
 extern _X_EXPORT Bool InitFocusClassDeviceStruct(
     DeviceIntPtr /*device*/);
 
+extern _X_EXPORT Bool InitTouchClassDeviceStruct(
+    DeviceIntPtr /*device*/,
+    unsigned int /*max_touches*/,
+    unsigned int /*mode*/,
+    unsigned int /*numAxes*/);
+
 typedef void (*BellProcPtr)(
     int /*percent*/,
     DeviceIntPtr /*device*/,
@@ -471,6 +489,28 @@ extern _X_EXPORT void QueueKeyboardEvents(
     int key_code,
     const ValuatorMask *mask);
 
+extern int GetTouchEvents(
+    InternalEvent *events,
+    DeviceIntPtr pDev,
+    uint32_t ddx_touchid,
+    uint16_t type,
+    uint32_t flags,
+    const ValuatorMask *mask);
+
+void QueueTouchEvents(DeviceIntPtr device,
+                      int type,
+                      uint32_t ddx_touchid,
+                      int flags,
+                      const ValuatorMask *mask);
+
+extern int GetTouchOwnershipEvents(
+    InternalEvent *events,
+    DeviceIntPtr pDev,
+    TouchPointInfoPtr ti,
+    uint8_t mode,
+    XID resource,
+    uint32_t flags);
+
 extern _X_EXPORT int GetProximityEvents(
     InternalEvent *events,
     DeviceIntPtr pDev,
@@ -540,6 +580,51 @@ extern void SendDevicePresenceEvent(int deviceid, int type);
 extern _X_EXPORT InputAttributes *DuplicateInputAttributes(InputAttributes *attrs);
 extern _X_EXPORT void FreeInputAttributes(InputAttributes *attrs);
 
+enum TouchListenerState{
+    LISTENER_AWAITING_BEGIN = 0,   /**< Waiting for a TouchBegin event */
+    LISTENER_AWAITING_OWNER,       /**< Waiting for a TouchOwnership event */
+    LISTENER_IS_OWNER,             /**< Is the current owner */
+    LISTENER_HAS_END,              /**< Has already received the end event */
+};
+
+enum TouchListenerType {
+    LISTENER_GRAB,
+    LISTENER_POINTER_GRAB,
+    LISTENER_REGULAR,
+    LISTENER_POINTER_REGULAR,
+};
+
+extern void TouchInitDDXTouchPoint(DeviceIntPtr dev, DDXTouchPointInfoPtr ddxtouch);
+extern DDXTouchPointInfoPtr TouchBeginDDXTouch(DeviceIntPtr dev, uint32_t ddx_id);
+extern void TouchEndDDXTouch(DeviceIntPtr dev, DDXTouchPointInfoPtr ti);
+extern DDXTouchPointInfoPtr TouchFindByDDXID(DeviceIntPtr dev,
+                                             uint32_t ddx_id,
+                                             Bool create);
+extern Bool TouchInitTouchPoint(TouchClassPtr touch, ValuatorClassPtr v, int index);
+extern void TouchFreeTouchPoint(DeviceIntPtr dev, int index);
+extern TouchPointInfoPtr TouchBeginTouch(DeviceIntPtr dev, int sourceid,
+                                         uint32_t touchid, Bool emulate_pointer);
+extern TouchPointInfoPtr TouchFindByClientID(DeviceIntPtr dev,
+                                             uint32_t client_id);
+extern void TouchEndTouch(DeviceIntPtr dev, TouchPointInfoPtr ti);
+extern Bool TouchEventHistoryAllocate(TouchPointInfoPtr ti);
+extern void TouchEventHistoryFree(TouchPointInfoPtr ti);
+extern void TouchEventHistoryPush(TouchPointInfoPtr ti, const DeviceEvent *ev);
+extern void TouchEventHistoryReplay(TouchPointInfoPtr ti, DeviceIntPtr dev, XID resource);
+extern Bool TouchResourceIsOwner(TouchPointInfoPtr ti, XID resource);
+extern void TouchAddListener(TouchPointInfoPtr ti, XID resource, enum InputLevel level,
+                                     enum TouchListenerType type, enum TouchListenerState state);
+extern Bool TouchRemoveListener(TouchPointInfoPtr ti, XID resource);
+extern void TouchSetupListeners(DeviceIntPtr dev, TouchPointInfoPtr ti, InternalEvent *ev);
+extern Bool TouchEnsureSprite(DeviceIntPtr sourcedev, TouchPointInfoPtr ti,
+                              InternalEvent *ev);
+extern Bool TouchBuildDependentSpriteTrace(DeviceIntPtr dev, SpritePtr sprite);
+extern int TouchConvertToPointerEvent(const InternalEvent *ev,
+                                      InternalEvent *motion, InternalEvent *button);
+extern int TouchGetPointerEventType(const InternalEvent *ev);
+extern void TouchRemovePointerGrab(DeviceIntPtr dev);
+extern void TouchListenerGone(XID resource);
+
 /* misc event helpers */
 extern Mask GetEventMask(DeviceIntPtr dev, xEvent* ev, InputClientsPtr clients);
 extern Mask GetEventFilter(DeviceIntPtr dev, xEvent *event);
@@ -553,7 +638,7 @@ void FixUpEventFromWindow(SpritePtr pSprite,
 extern WindowPtr XYToWindow(SpritePtr pSprite, int x, int y);
 extern int EventIsDeliverable(DeviceIntPtr dev, int evtype, WindowPtr win);
 extern Bool ActivatePassiveGrab(DeviceIntPtr dev, GrabPtr grab,
-                                InternalEvent *ev);
+                                InternalEvent *ev, InternalEvent *real_event);
 /**
  * Masks specifying the type of event to deliver for an InternalEvent; used
  * by EventIsDeliverable.
diff --git a/xorg-server/include/inputstr.h b/xorg-server/include/inputstr.h
index 5aae1b512..518e2f4f7 100644
--- a/xorg-server/include/inputstr.h
+++ b/xorg-server/include/inputstr.h
@@ -49,6 +49,8 @@ SOFTWARE.
 #ifndef INPUTSTRUCT_H
 #define INPUTSTRUCT_H
 
+#include <X11/extensions/XI2proto.h>
+
 #include <pixman.h>
 #include "input.h"
 #include "window.h"
@@ -71,7 +73,7 @@ extern _X_EXPORT int CountBits(const uint8_t *mask, int len);
  * events to the protocol, the server will not support these events until
  * this number here is bumped.
  */
-#define XI2LASTEVENT    17 /* XI_RawMotion */
+#define XI2LASTEVENT    XI_RawTouchEnd
 #define XI2MASKSIZE     ((XI2LASTEVENT >> 3) + 1) /* no of bytes for masks */
 
 /**
@@ -298,6 +300,53 @@ typedef struct _ValuatorClassRec {
     int                   v_scroll_axis; /* vert smooth-scrolling axis */
 } ValuatorClassRec;
 
+typedef struct _TouchPointInfo {
+    uint32_t    client_id;          /* touch ID as seen in client events */
+    int         sourceid;           /* Source device's ID for this touchpoint */
+    Bool        active;             /* whether or not the touch is active */
+    Bool        pending_finish;     /* true if the touch is physically inactive
+                                     * but still owned by a grab */
+    SpriteRec   sprite;             /* window trace for delivery */
+    ValuatorMask *valuators;        /* last recorded axis values */
+    struct _TouchListener {
+        XID         listener;           /* grabs/event selection IDs receiving
+                                         * events for this touch */
+        enum TouchListenerType type;
+        enum TouchListenerState state;
+        enum InputLevel level;      /* matters only for emulating touches */
+    } *listeners;
+    int         num_listeners;
+    int         num_grabs;          /* number of open grabs on this touch
+                                     * which have not accepted or rejected */
+    Bool        emulate_pointer;
+    DeviceEvent *history;           /* History of events on this touchpoint */
+    size_t      history_elements;   /* Number of current elements in history */
+    size_t      history_size;       /* Size of history in elements */
+} TouchPointInfoRec;
+
+typedef struct _TouchListener TouchListener;
+
+typedef struct _DDXTouchPointInfo {
+    uint32_t    client_id;          /* touch ID as seen in client events */
+    Bool        active;             /* whether or not the touch is active */
+    uint32_t    ddx_id;             /* touch ID given by the DDX */
+    Bool        emulate_pointer;
+
+    ValuatorMask* valuators;        /* last recorded axis values */
+} DDXTouchPointInfoRec;
+
+typedef struct _TouchClassRec {
+    int                sourceid;
+    TouchPointInfoPtr  touches;
+    unsigned short     num_touches;    /* number of allocated touches */
+    unsigned short     max_touches;    /* maximum number of touches, may be 0 */
+    CARD8              mode;           /* ::XIDirectTouch, XIDependentTouch */
+    /* for pointer-emulation */
+    CARD8              buttonsDown;    /* number of buttons down */
+    unsigned short     state;          /* logical button state */
+    Mask               motionMask;
+} TouchClassRec;
+
 typedef struct _ButtonClassRec {
     int			sourceid;
     CARD8		numButtons;
@@ -381,6 +430,7 @@ typedef struct _LedFeedbackClassRec {
 typedef struct _ClassesRec {
     KeyClassPtr		key;
     ValuatorClassPtr	valuator;
+    TouchClassPtr	touch;
     ButtonClassPtr	button;
     FocusClassPtr	focus;
     ProximityClassPtr	proximity;
@@ -508,6 +558,7 @@ typedef struct _DeviceIntRec {
     int			id;
     KeyClassPtr		key;
     ValuatorClassPtr	valuator;
+    TouchClassPtr	touch;
     ButtonClassPtr	button;
     FocusClassPtr	focus;
     ProximityClassPtr	proximity;
@@ -539,6 +590,8 @@ typedef struct _DeviceIntRec {
         int             numValuators;
         DeviceIntPtr    slave;
         ValuatorMask    *scroll;
+        int             num_touches; /* size of the touches array */
+        DDXTouchPointInfoPtr touches;
     } last;
 
     /* Input device property handling. */
diff --git a/xorg-server/include/misc.h b/xorg-server/include/misc.h
index d401537c6..cc2ac32f3 100644
--- a/xorg-server/include/misc.h
+++ b/xorg-server/include/misc.h
@@ -380,8 +380,8 @@ extern _X_EXPORT unsigned long serverGeneration;
               xorg_backtrace();                                           \
           } } while(0)
 
-#define BUG_WARN_MSG(cond, msg, ...)                                      \
-          __BUG_WARN_MSG(cond, 1, msg, __VA_ARGS__)
+#define BUG_WARN_MSG(cond, ...)                                           \
+          __BUG_WARN_MSG(cond, 1, __VA_ARGS__)
 
 #define BUG_WARN(cond)  __BUG_WARN_MSG(cond, 0, NULL)
 
diff --git a/xorg-server/include/protocol-versions.h b/xorg-server/include/protocol-versions.h
index 832bcf756..479ac2f77 100644
--- a/xorg-server/include/protocol-versions.h
+++ b/xorg-server/include/protocol-versions.h
@@ -127,7 +127,7 @@
 
 /* X Input */
 #define SERVER_XI_MAJOR_VERSION			2
-#define SERVER_XI_MINOR_VERSION			1
+#define SERVER_XI_MINOR_VERSION			2
 
 /* XKB */
 #define SERVER_XKB_MAJOR_VERSION		1
diff --git a/xorg-server/mi/mieq.c b/xorg-server/mi/mieq.c
index 3d51a567b..6c46eb9fe 100644
--- a/xorg-server/mi/mieq.c
+++ b/xorg-server/mi/mieq.c
@@ -370,8 +370,14 @@ ChangeDeviceID(DeviceIntPtr dev, InternalEvent* event)
         case ET_ProximityOut:
         case ET_Hierarchy:
         case ET_DeviceChanged:
+        case ET_TouchBegin:
+        case ET_TouchUpdate:
+        case ET_TouchEnd:
             event->device_event.deviceid = dev->id;
             break;
+        case ET_TouchOwnership:
+            event->touch_ownership_event.deviceid = dev->id;
+            break;
 #if XFreeXDGA
         case ET_DGAEvent:
             break;
@@ -381,6 +387,9 @@ ChangeDeviceID(DeviceIntPtr dev, InternalEvent* event)
         case ET_RawButtonPress:
         case ET_RawButtonRelease:
         case ET_RawMotion:
+        case ET_RawTouchBegin:
+        case ET_RawTouchEnd:
+        case ET_RawTouchUpdate:
             event->raw_event.deviceid = dev->id;
             break;
         default:
@@ -462,6 +471,19 @@ CopyGetMasterEvent(DeviceIntPtr sdev,
 }
 
 
+static void
+mieqMoveToNewScreen(DeviceIntPtr dev, ScreenPtr screen, DeviceEvent *event)
+{
+    if (dev && screen && screen != DequeueScreen(dev))
+    {
+        int x = 0, y = 0;
+        DequeueScreen(dev) = screen;
+        x = event->root_x;
+        y = event->root_y;
+        NewCurrentScreen (dev, DequeueScreen(dev), x, y);
+    }
+}
+
 /**
  * Post the given @event through the device hierarchy, as appropriate.
  * Use this function if an event must be posted for a given device during the
@@ -473,7 +495,6 @@ mieqProcessDeviceEvent(DeviceIntPtr dev,
                        ScreenPtr screen)
 {
     mieqHandler handler;
-    int x = 0, y = 0;
     DeviceIntPtr master;
     InternalEvent mevent; /* master event */
 
@@ -490,12 +511,14 @@ mieqProcessDeviceEvent(DeviceIntPtr dev,
         case ET_KeyRelease:
         case ET_ButtonPress:
         case ET_ButtonRelease:
-            if (dev && screen && dev->spriteInfo->sprite && screen != DequeueScreen(dev) && !handler) {
-                DequeueScreen(dev) = screen;
-                x = event->device_event.root_x;
-                y = event->device_event.root_y;
-                NewCurrentScreen (dev, DequeueScreen(dev), x, y);
-            }
+            if (!handler)
+                mieqMoveToNewScreen(dev, screen, &event->device_event);
+            break;
+        case ET_TouchBegin:
+        case ET_TouchUpdate:
+        case ET_TouchEnd:
+            if (!handler && (event->device_event.flags & TOUCH_POINTER_EMULATED))
+                mieqMoveToNewScreen(dev, screen, &event->device_event);
             break;
         default:
             break;
diff --git a/xorg-server/test/Makefile.am b/xorg-server/test/Makefile.am
index 48393d39a..ba8932c5d 100644
--- a/xorg-server/test/Makefile.am
+++ b/xorg-server/test/Makefile.am
@@ -1,6 +1,6 @@
 if ENABLE_UNIT_TESTS
 SUBDIRS= .
-noinst_PROGRAMS = list string
+noinst_PROGRAMS = list string touch
 if XORG
 # Tests that require at least some DDX functions in order to fully link
 # For now, requires xf86 ddx, could be adjusted to use another
@@ -35,6 +35,7 @@ list_LDADD=$(TEST_LDADD)
 misc_LDADD=$(TEST_LDADD)
 fixes_LDADD=$(TEST_LDADD)
 xfree86_LDADD=$(TEST_LDADD)
+touch_LDADD=$(TEST_LDADD)
 
 libxservertest_la_LIBADD = $(XSERVER_LIBS)
 if XORG
diff --git a/xorg-server/test/input.c b/xorg-server/test/input.c
index d27b3f0c0..576cd8531 100644
--- a/xorg-server/test/input.c
+++ b/xorg-server/test/input.c
@@ -161,22 +161,31 @@ static void dix_check_grab_values(void)
     rc = CheckGrabValues(&client, &param);
     assert(rc == Success);
 
-    param.this_device_mode = GrabModeAsync + 1;
+    param.this_device_mode = XIGrabModeTouch;
+    rc = CheckGrabValues(&client, &param);
+    assert(rc == Success);
+
+    param.this_device_mode = XIGrabModeTouch + 1;
     rc = CheckGrabValues(&client, &param);
     assert(rc == BadValue);
     assert(client.errorValue == param.this_device_mode);
-    assert(client.errorValue == GrabModeAsync + 1);
+    assert(client.errorValue == XIGrabModeTouch + 1);
 
     param.this_device_mode = GrabModeSync;
     param.other_devices_mode = GrabModeAsync;
     rc = CheckGrabValues(&client, &param);
+
+    param.this_device_mode = GrabModeSync;
+    param.other_devices_mode = XIGrabModeTouch;
+    rc = CheckGrabValues(&client, &param);
+    assert(rc == Success);
     assert(rc == Success);
 
-    param.other_devices_mode = GrabModeAsync + 1;
+    param.other_devices_mode = XIGrabModeTouch + 1;
     rc = CheckGrabValues(&client, &param);
     assert(rc == BadValue);
     assert(client.errorValue == param.other_devices_mode);
-    assert(client.errorValue == GrabModeAsync + 1);
+    assert(client.errorValue == XIGrabModeTouch + 1);
 
     param.other_devices_mode = GrabModeSync;
 
diff --git a/xorg-server/test/touch.c b/xorg-server/test/touch.c
new file mode 100644
index 000000000..88955cbc1
--- /dev/null
+++ b/xorg-server/test/touch.c
@@ -0,0 +1,270 @@
+/**
+ * Copyright © 2011 Red Hat, Inc.
+ *
+ *  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 (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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ *  THE AUTHORS OR COPYRIGHT HOLDERS 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.
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <stdint.h>
+#include "inputstr.h"
+#include "assert.h"
+#include "scrnintstr.h"
+
+static void touch_grow_queue(void)
+{
+    DeviceIntRec dev;
+    ValuatorClassRec val;
+    TouchClassRec touch;
+    size_t size, new_size;
+    int i;
+
+    memset(&dev, 0, sizeof(dev));
+    dev.id = 2;
+    dev.valuator = &val;
+    val.numAxes = 5;
+    dev.touch = &touch;
+    inputInfo.devices = &dev;
+
+    size = 5;
+
+    dev.last.num_touches = size;
+    dev.last.touches = calloc(dev.last.num_touches, sizeof(*dev.last.touches));
+    assert(dev.last.touches);
+    for (i = 0; i < size; i++) {
+        dev.last.touches[i].active = TRUE;
+        dev.last.touches[i].ddx_id = i;
+        dev.last.touches[i].client_id = i * 2;
+    }
+
+    /* no more space, should've scheduled a workproc */
+    assert(TouchBeginDDXTouch(&dev, 1234) == NULL);
+    ProcessWorkQueue();
+
+    new_size = size + size/2 + 1;
+    assert(dev.last.num_touches == new_size);
+
+    /* make sure we haven't touched those */
+    for (i = 0; i < size; i++) {
+        DDXTouchPointInfoPtr t = &dev.last.touches[i];
+        assert(t->active == TRUE);
+        assert(t->ddx_id == i);
+        assert(t->client_id == i * 2);
+    }
+
+    /* make sure those are zero-initialized */
+    for (i = size; i < new_size; i++) {
+        DDXTouchPointInfoPtr t = &dev.last.touches[i];
+        assert(t->active == FALSE);
+        assert(t->client_id == 0);
+        assert(t->ddx_id == 0);
+    }
+}
+
+static void touch_find_ddxid(void)
+{
+    DeviceIntRec dev;
+    DDXTouchPointInfoPtr ti;
+    ValuatorClassRec val;
+    TouchClassRec touch;
+    int size = 5;
+    int i;
+
+    memset(&dev, 0, sizeof(dev));
+    dev.id = 2;
+    dev.valuator = &val;
+    val.numAxes = 5;
+    dev.touch = &touch;
+    dev.last.num_touches = size;
+    dev.last.touches = calloc(dev.last.num_touches, sizeof(*dev.last.touches));
+    inputInfo.devices = &dev;
+    assert(dev.last.touches);
+
+
+    dev.last.touches[0].active = TRUE;
+    dev.last.touches[0].ddx_id = 10;
+    dev.last.touches[0].client_id = 20;
+
+
+    /* existing */
+    ti = TouchFindByDDXID(&dev, 10, FALSE);
+    assert(ti == &dev.last.touches[0]);
+
+    /* non-existing */
+    ti = TouchFindByDDXID(&dev, 20, FALSE);
+    assert(ti == NULL);
+
+    /* Non-active */
+    dev.last.touches[0].active = FALSE;
+    ti = TouchFindByDDXID(&dev, 10, FALSE);
+    assert(ti == NULL);
+
+    /* create on number 2*/
+    dev.last.touches[0].active = TRUE;
+
+    ti = TouchFindByDDXID(&dev, 20, TRUE);
+    assert(ti == &dev.last.touches[1]);
+    assert(ti->active);
+    assert(ti->ddx_id == 20);
+
+    /* set all to active */
+    for (i = 0; i < size; i++)
+        dev.last.touches[i].active = TRUE;
+
+    /* Try to create more, fail */
+    ti = TouchFindByDDXID(&dev, 30, TRUE);
+    assert(ti == NULL);
+    ti = TouchFindByDDXID(&dev, 30, TRUE);
+    assert(ti == NULL);
+    /* make sure we haven't resized, we're in the signal handler */
+    assert(dev.last.num_touches == size);
+
+    /* stop one touchpoint, try to create, succeed */
+    dev.last.touches[2].active = FALSE;
+    ti = TouchFindByDDXID(&dev, 30, TRUE);
+    assert(ti == &dev.last.touches[2]);
+    /* but still grow anyway */
+    ProcessWorkQueue();
+    ti = TouchFindByDDXID(&dev, 40, TRUE);
+    assert(ti == &dev.last.touches[size]);
+}
+
+static void touch_begin_ddxtouch(void)
+{
+    DeviceIntRec dev;
+    DDXTouchPointInfoPtr ti;
+    ValuatorClassRec val;
+    TouchClassRec touch;
+    int ddx_id = 123;
+    unsigned int last_client_id = 0;
+    int size = 5;
+
+    memset(&dev, 0, sizeof(dev));
+    dev.id = 2;
+    dev.valuator = &val;
+    val.numAxes = 5;
+    touch.mode = XIDirectTouch;
+    dev.touch = &touch;
+    dev.last.num_touches = size;
+    dev.last.touches = calloc(dev.last.num_touches, sizeof(*dev.last.touches));
+    inputInfo.devices = &dev;
+    assert(dev.last.touches);
+
+    ti = TouchBeginDDXTouch(&dev, ddx_id);
+    assert(ti);
+    assert(ti->ddx_id == ddx_id);
+    /* client_id == ddx_id can happen in real life, but not in this test */
+    assert(ti->client_id != ddx_id);
+    assert(ti->active);
+    assert(ti->client_id > last_client_id);
+    assert(ti->emulate_pointer);
+    last_client_id = ti->client_id;
+
+    ddx_id += 10;
+    ti = TouchBeginDDXTouch(&dev, ddx_id);
+    assert(ti);
+    assert(ti->ddx_id == ddx_id);
+    /* client_id == ddx_id can happen in real life, but not in this test */
+    assert(ti->client_id != ddx_id);
+    assert(ti->active);
+    assert(ti->client_id > last_client_id);
+    assert(!ti->emulate_pointer);
+    last_client_id = ti->client_id;
+}
+
+static void touch_begin_touch(void)
+{
+    DeviceIntRec dev;
+    TouchClassRec touch;
+    ValuatorClassRec val;
+    TouchPointInfoPtr ti;
+    int touchid = 12434;
+    int sourceid = 23;
+    SpriteInfoRec sprite;
+    ScreenRec screen;
+
+    screenInfo.screens[0] = &screen;
+
+    memset(&dev, 0, sizeof(dev));
+    dev.id = 2;
+
+    memset(&sprite, 0, sizeof(sprite));
+    dev.spriteInfo = &sprite;
+
+    memset(&touch, 0, sizeof(touch));
+    touch.num_touches = 0;
+
+    memset(&val, 0, sizeof(val));
+    dev.valuator = &val;
+    val.numAxes = 2;
+
+    ti = TouchBeginTouch(&dev, sourceid, touchid, TRUE);
+    assert(!ti);
+
+    dev.touch = &touch;
+    ti = TouchBeginTouch(&dev, sourceid, touchid, TRUE);
+    assert(ti);
+    assert(ti->client_id == touchid);
+    assert(ti->active);
+    assert(ti->sourceid == sourceid);
+    assert(ti->emulate_pointer);
+
+    assert(touch.num_touches == 1);
+}
+
+static void touch_init(void)
+{
+    DeviceIntRec dev;
+    Atom labels[2] = {0};
+    int rc;
+    SpriteInfoRec sprite;
+    ScreenRec screen;
+
+    screenInfo.screens[0] = &screen;
+
+    memset(&dev, 0, sizeof(dev));
+
+    memset(&sprite, 0, sizeof(sprite));
+    dev.spriteInfo = &sprite;
+
+    InitAtoms();
+    rc = InitTouchClassDeviceStruct(&dev, 1, XIDirectTouch, 2);
+    assert(rc == FALSE);
+
+    InitValuatorClassDeviceStruct(&dev, 2, labels, 10, Absolute);
+    rc = InitTouchClassDeviceStruct(&dev, 1, XIDirectTouch, 2);
+    assert(rc == TRUE);
+    assert(dev.touch);
+}
+
+
+
+int main(int argc, char** argv)
+{
+    touch_grow_queue();
+    touch_find_ddxid();
+    touch_begin_ddxtouch();
+    touch_init();
+    touch_begin_touch();
+
+    return 0;
+}
diff --git a/xorg-server/test/xi2/protocol-eventconvert.c b/xorg-server/test/xi2/protocol-eventconvert.c
index e2037f911..faa9f407a 100644
--- a/xorg-server/test/xi2/protocol-eventconvert.c
+++ b/xorg-server/test/xi2/protocol-eventconvert.c
@@ -193,7 +193,6 @@ static void test_convert_XIRawEvent(void)
 
     memset(&in, 0, sizeof(in));
 
-    printf("Testing all event types\n");
     in.header = ET_Internal;
     in.type = ET_RawMotion;
     test_XIRawEvent(&in);
@@ -214,7 +213,6 @@ static void test_convert_XIRawEvent(void)
     in.type = ET_RawButtonRelease;
     test_XIRawEvent(&in);
 
-    printf("Testing details and other fields\n");
     in.detail.button = 1L;
     test_XIRawEvent(&in);
     in.detail.button = 1L << 8;
@@ -246,7 +244,6 @@ static void test_convert_XIRawEvent(void)
     in.deviceid = ~0 & 0xFF;
     test_XIRawEvent(&in);
 
-    printf("Testing valuator masks\n");
     for (i = 0; i < MAX_VALUATORS; i++)
     {
         XISetMask(in.valuators.mask, i);
@@ -432,7 +429,6 @@ static void test_convert_XIDeviceEvent(void)
 
     memset(&in, 0, sizeof(in));
 
-    printf("Testing simple field values\n");
     in.header = ET_Internal;
     in.type = ET_Motion;
     in.length = sizeof(DeviceEvent);
@@ -456,7 +452,6 @@ static void test_convert_XIDeviceEvent(void)
 
     test_XIDeviceEvent(&in);
 
-    printf("Testing field ranges\n");
     /* 32 bit */
     in.detail.button = 1L;
     test_XIDeviceEvent(&in);
@@ -604,7 +599,6 @@ static void test_convert_XIDeviceEvent(void)
     in.mods.effective = ~0 & 0xFF;
     test_XIDeviceEvent(&in);
 
-    printf("Testing button masks\n");
     for (i = 0; i < sizeof(in.buttons) * 8; i++)
     {
         XISetMask(in.buttons, i);
@@ -618,7 +612,6 @@ static void test_convert_XIDeviceEvent(void)
         test_XIDeviceEvent(&in);
     }
 
-    printf("Testing valuator masks\n");
     for (i = 0; i < MAX_VALUATORS; i++)
     {
         XISetMask(in.valuators.mask, i);
@@ -799,7 +792,6 @@ static void test_convert_XIDeviceChangedEvent(void)
     DeviceChangedEvent in;
     int i;
 
-    printf("Testing simple field values\n");
     memset(&in, 0, sizeof(in));
     in.header = ET_Internal;
     in.type = ET_DeviceChanged;
@@ -923,12 +915,108 @@ static void test_convert_XIDeviceChangedEvent(void)
     }
 }
 
+static void
+test_values_XITouchOwnershipEvent(TouchOwnershipEvent *in,
+                                  xXITouchOwnershipEvent *out,
+                                  BOOL swap)
+{
+    if (swap)
+    {
+        swaps(&out->sequenceNumber);
+        swapl(&out->length);
+        swaps(&out->evtype);
+        swaps(&out->deviceid);
+        swaps(&out->sourceid);
+        swapl(&out->time);
+        swapl(&out->touchid);
+        swapl(&out->root);
+        swapl(&out->event);
+        swapl(&out->child);
+        swapl(&out->time);
+    }
+
+    assert(out->type == GenericEvent);
+    assert(out->extension == 0); /* IReqCode defaults to 0 */
+    assert(out->evtype == GetXI2Type(in->type));
+    assert(out->time == in->time);
+    assert(out->deviceid == in->deviceid);
+    assert(out->sourceid == in->sourceid);
+    assert(out->touchid == in->touchid);
+    assert(out->flags == in->reason);
+}
+
+static void
+test_XITouchOwnershipEvent(TouchOwnershipEvent *in)
+{
+    xXITouchOwnershipEvent *out, *swapped;
+    int rc;
+
+    rc = EventToXI2((InternalEvent*)in, (xEvent**)&out);
+    assert(rc == Success);
+
+    test_values_XITouchOwnershipEvent(in, out, FALSE);
+
+    swapped = calloc(1, sizeof(xEvent) + out->length * 4);
+    XI2EventSwap((xGenericEvent*)out, (xGenericEvent*)swapped);
+    test_values_XITouchOwnershipEvent(in, swapped, TRUE);
+    free(out);
+    free(swapped);
+}
+
+static void
+test_convert_XITouchOwnershipEvent(void)
+{
+    TouchOwnershipEvent in;
+    long i;
+
+    memset(&in, 0, sizeof(in));
+    in.header           = ET_Internal;
+    in.type             = ET_TouchOwnership;
+    in.length           = sizeof(in);
+    in.time             = 0;
+    in.deviceid         = 1;
+    in.sourceid         = 2;
+    in.touchid          = 0;
+    in.reason           = 0;
+    in.resource         = 0;
+    in.flags            = 0;
+
+    test_XITouchOwnershipEvent(&in);
+
+    in.flags            = XIAcceptTouch;
+    test_XITouchOwnershipEvent(&in);
+
+    in.flags            = XIRejectTouch;
+    test_XITouchOwnershipEvent(&in);
+
+    for (i = 1; i <= 0xFFFF; i <<= 1)
+    {
+        in.deviceid = i;
+        test_XITouchOwnershipEvent(&in);
+    }
+
+    for (i = 1; i <= 0xFFFF; i <<= 1)
+    {
+        in.sourceid = i;
+        test_XITouchOwnershipEvent(&in);
+    }
+
+    for (i = 1; ; i <<= 1)
+    {
+        in.touchid = i;
+        test_XITouchOwnershipEvent(&in);
+	if (i == (1 << 31))
+	    break;
+    }
+}
+
 int main(int argc, char** argv)
 {
     test_convert_XIRawEvent();
     test_convert_XIFocusEvent();
     test_convert_XIDeviceEvent();
     test_convert_XIDeviceChangedEvent();
+    test_convert_XITouchOwnershipEvent();
 
     return 0;
 }
diff --git a/xorg-server/test/xi2/protocol-xipassivegrabdevice.c b/xorg-server/test/xi2/protocol-xipassivegrabdevice.c
index 89ffc3d29..b405556be 100644
--- a/xorg-server/test/xi2/protocol-xipassivegrabdevice.c
+++ b/xorg-server/test/xi2/protocol-xipassivegrabdevice.c
@@ -180,7 +180,7 @@ static void test_XIPassiveGrabDevice(void)
     request->deviceid = XIAllMasterDevices;
 
     printf("Testing invalid grab types\n");
-    for (i = XIGrabtypeFocusIn + 1; i < 0xFF; i++)
+    for (i = XIGrabtypeTouchBegin + 1; i < 0xFF; i++)
     {
         request->grab_type = i;
         request_XIPassiveGrabDevice(&client_request, request, BadValue, request->grab_type);
diff --git a/xorg-server/test/xi2/protocol-xiselectevents.c b/xorg-server/test/xi2/protocol-xiselectevents.c
index 4eaf839fa..0390858b1 100644
--- a/xorg-server/test/xi2/protocol-xiselectevents.c
+++ b/xorg-server/test/xi2/protocol-xiselectevents.c
@@ -125,6 +125,28 @@ static void request_XISelectEvent(xXISelectEventsReq *req, int error)
     assert(rc == error);
 }
 
+static void _set_bit(unsigned char *bits, int bit)
+{
+    SetBit(bits, bit);
+    if (bit >= XI_TouchBegin && bit <= XI_TouchOwnership)
+    {
+        SetBit(bits, XI_TouchBegin);
+        SetBit(bits, XI_TouchUpdate);
+        SetBit(bits, XI_TouchEnd);
+    }
+}
+
+static void _clear_bit(unsigned char *bits, int bit)
+{
+    ClearBit(bits, bit);
+    if (bit >= XI_TouchBegin && bit <= XI_TouchOwnership)
+    {
+        ClearBit(bits, XI_TouchBegin);
+        ClearBit(bits, XI_TouchUpdate);
+        ClearBit(bits, XI_TouchEnd);
+    }
+}
+
 static void request_XISelectEvents_masks(xXISelectEventsReq *req)
 {
     int i, j;
@@ -157,9 +179,9 @@ static void request_XISelectEvents_masks(xXISelectEventsReq *req)
         memset(bits, 0, mask->mask_len * 4);
         for (j = 0; j <= XI2LASTEVENT; j++)
         {
-            SetBit(bits, j);
+            _set_bit(bits, j);
             request_XISelectEvent(req, Success);
-            ClearBit(bits, j);
+            _clear_bit(bits, j);
         }
 
         /* Test 2:
@@ -173,7 +195,7 @@ static void request_XISelectEvents_masks(xXISelectEventsReq *req)
 
         for (j = 0; j <= XI2LASTEVENT; j++)
         {
-            SetBit(bits, j);
+            _set_bit(bits, j);
             request_XISelectEvent(req, Success);
         }
 
@@ -187,9 +209,9 @@ static void request_XISelectEvents_masks(xXISelectEventsReq *req)
 
         for (j = XI2LASTEVENT + 1; j < mask->mask_len * 4; j++)
         {
-            SetBit(bits, j);
+            _set_bit(bits, j);
             request_XISelectEvent(req, BadValue);
-            ClearBit(bits, j);
+            _clear_bit(bits, j);
         }
 
         /* Test 4:
@@ -200,7 +222,7 @@ static void request_XISelectEvents_masks(xXISelectEventsReq *req)
         memset(bits, 0, mask->mask_len * 4);
         for (j = 0; j <= XI2LASTEVENT; j++)
         {
-            SetBit(bits, j);
+            _set_bit(bits, j);
             request_XISelectEvent(req, Success);
         }
 
@@ -227,8 +249,8 @@ static void request_XISelectEvents_masks(xXISelectEventsReq *req)
         mask->mask_len = (nmasks + 3)/4;
         memset(bits, 0, mask->mask_len * 4);
         for (j = 0; j <= XI2LASTEVENT; j++)
-            SetBit(bits, j);
-        ClearBit(bits, XI_HierarchyChanged);
+            _set_bit(bits, j);
+        _clear_bit(bits, XI_HierarchyChanged);
         for (j = 1; j < 6; j++)
         {
             mask->deviceid = j;
diff --git a/xorg-server/xkeyboard-config/rules/base.xml.in b/xorg-server/xkeyboard-config/rules/base.xml.in
index 47d160e30..7c94620ab 100644
--- a/xorg-server/xkeyboard-config/rules/base.xml.in
+++ b/xorg-server/xkeyboard-config/rules/base.xml.in
@@ -4192,7 +4192,7 @@
         <name>rs</name>
         <!-- Keyboard indicator for Serbian layouts -->
         <_shortDescription>sr</_shortDescription>
-        <_description>Serbian</_description>
+        <_description>Serbian (Cyrillic)</_description>
         <languageList>
           <iso639Id>srp</iso639Id>
         </languageList>
@@ -4201,7 +4201,7 @@
         <variant>
           <configItem>
             <name>yz</name>
-            <_description>Serbian (Z and ZHE swapped)</_description>
+            <_description>Serbian (Cyrillic, Z and ZHE swapped)</_description>
           </configItem>
         </variant>
         <variant>
@@ -4231,7 +4231,7 @@
         <variant>
           <configItem>
             <name>alternatequotes</name>
-            <_description>Serbian (with guillemets)</_description>
+            <_description>Serbian (Cyrillic with guillemets)</_description>
           </configItem>
         </variant>
         <variant>
diff --git a/xorg-server/xkeyboard-config/symbols/la b/xorg-server/xkeyboard-config/symbols/la
index a174ddfcc..269cb2618 100644
--- a/xorg-server/xkeyboard-config/symbols/la
+++ b/xorg-server/xkeyboard-config/symbols/la
@@ -62,14 +62,6 @@ xkb_symbols "basic" {
     key <AB09> { [ 0x1000ec3,       dollar	]};
     key <AB10> { [ 0x1000e9d,       parenright	]};
 
-override key <LFSH> {
-	type[Group1]="PC_ALT_LEVEL2",
-	[ 	 Shift_L,		ISO_First_Group		]
-    };
-override key <RTSH> {
-	type[Group1]="PC_ALT_LEVEL2",
-	[ 	Shift_R,		ISO_Last_Group 		]
-    };
 };
 
 partial