From Peter Harris via https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=2981 :
authormorriss <morriss@f5534014-38df-0310-8fa8-9805f1628bb7>
Fri, 11 Sep 2009 01:57:59 +0000 (01:57 +0000)
committermorriss <morriss@f5534014-38df-0310-8fa8-9805f1628bb7>
Fri, 11 Sep 2009 01:57:59 +0000 (01:57 +0000)
This patch adds extension support to the X11 dissector.

I've removed the perl script from the make file, since the new one depends on
perl 5.10, xcbproto (at least git as of today), and mesa (at least the
mesa/src/mesa/glapi directory). It seemed easier to just add the generated
header files to svn directly.

git-svn-id: http://anonsvn.wireshark.org/wireshark/trunk@29854 f5534014-38df-0310-8fa8-9805f1628bb7

13 files changed:
AUTHORS
epan/dissectors/Makefile.am
epan/dissectors/Makefile.common
epan/dissectors/Makefile.nmake
epan/dissectors/README.X11 [new file with mode: 0644]
epan/dissectors/packet-x11.c
epan/dissectors/process-x11-fields.pl
epan/dissectors/process-x11-xcb.pl [new file with mode: 0755]
epan/dissectors/x11-declarations.h [new file with mode: 0644]
epan/dissectors/x11-extension-errors.h [new file with mode: 0644]
epan/dissectors/x11-extension-implementation.h [new file with mode: 0644]
epan/dissectors/x11-glx-render-enum.h [new file with mode: 0644]
epan/dissectors/x11-register-info.h [new file with mode: 0644]

diff --git a/AUTHORS b/AUTHORS
index 7e5a464dd75853c9d038e3f6f0a3008a2f8c216e..529bd4886effe8f375491071a0cc69ba4c4f15d2 100644 (file)
--- a/AUTHORS
+++ b/AUTHORS
@@ -2828,6 +2828,10 @@ David Castleford <david.castleford [AT] orange-ftgroup.com> {
        Simulcrypt dissector
 }
 
+Peter Harris           <pharris[AT]opentext.com> {
+       X11 extension decoding
+}
+
 Martin Lutz            <MartinL [AT] copadata.at> {
        IEC 61850 GOOSE Dissector
 }
index 21862d5e7a75494877552efecb742af27cbf6a55..672962894236359e65ac617f322e7535fac34a31 100644 (file)
@@ -48,22 +48,11 @@ EXTRA_DIST = \
        Makefile.common         \
        Makefile.nmake          \
        ncp2222.py              \
-       packet-ncp2222.inc      \
-       process-x11-fields.pl   \
-       x11-fields
+       packet-ncp2222.inc
 
 packet-ncp2222.c : $(srcdir)/ncp2222.py
        $(PYTHON) $< -o $@
 
-#
-# Build various header files for the X11 dissector.
-#
-PROC_X11_FIELDS = $(srcdir)/process-x11-fields.pl
-X11_FIELDS = $(srcdir)/x11-fields
-
-x11-declarations.h x11-register-info.h: $(PROC_X11_FIELDS) $(X11_FIELDS)
-       $(PERL) $(PROC_X11_FIELDS) < $(X11_FIELDS)
-
 #
 # Build register.c, which contains a function register_all_protocols()
 # that calls the register routines for all protocols and a function
index 9fd10461b5d4ce3daefdc8ae58f1cc20aa6c77e3..d19d8feffdbc84f9c89270d69054822c7d7f79e1 100644 (file)
 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 # "BUILT_SOURCES" are built before any "make all" or "make check" targets.
-BUILT_HEADER_FILES = \
-       x11-declarations.h      \
-       x11-register-info.h
-
 BUILT_C_FILES = \
        register.c
 
@@ -1241,6 +1237,11 @@ DISSECTOR_INCLUDES =     \
        packet-wtp.h    \
        packet-x11-keysym.h     \
        packet-x11-keysymdef.h  \
+       x11-declarations.h      \
+       x11-register-info.h     \
+       x11-extension-implementation.h  \
+       x11-extension-errors.h  \
+       x11-glx-render-enum.h   \
        packet-x411.h   \
        packet-x420.h   \
        packet-x509af.h \
index 60f30f9ad607cb0924c87bc2ccc384beff20ae7a..7e3f563a2ea592b701ccd93da24ac99b76621682 100644 (file)
@@ -38,18 +38,6 @@ packet-rrc.obj : packet-rrc.c
    $(CC) $(CVARSDLL) $(CFLAGS) /Zd /Fd.\ -c $?
 !ENDIF
 
-#
-# The header files listed here are built from x11-fields using Perl;
-# we declare a dependency here so that they get built.
-#
-packet-x11.obj : packet-x11.c x11-declarations.h x11-register-info.h
-
-#
-# Build various header files for the X11 dissector.
-#
-x11-declarations.h x11-register-info.h: x11-fields process-x11-fields.pl
-       $(PERL) process-x11-fields.pl <x11-fields
-
 #
 # Build register.c, which contains a function register_all_protocols()
 # that calls the register routines for all protocols and a function
diff --git a/epan/dissectors/README.X11 b/epan/dissectors/README.X11
new file mode 100644 (file)
index 0000000..d39a8ba
--- /dev/null
@@ -0,0 +1,23 @@
+The X11 dissector generator is no longer run automatically.
+
+To run the dissector generator, you will need perl 5.10 and the XML::Twig
+module from CPAN. You will also need 'git' to retrieve the lastest protocol
+descriptions.
+
+Once you have those, you also need the XML protocol descriptions. In the
+epan/dissectors directory, run the following commands:
+ git clone git://anongit.freedesktop.org/xcb/proto xcbproto
+ git clone git://anongit.freedesktop.org/git/mesa/mesa
+
+Or, if you have already cloned those repositories, "git pull" each one to bring
+it up to date. Please be aware that the Mesa repository is rather large; it is
+slightly more than 53MB as of this writing.
+
+Run the following:
+ perl5.10 ./process-x11-xcb.pl
+
+This will automatically run process-x11-fields.pl (for the core protocol
+definitions), and then it will process the XML descriptions from XCB and Mesa
+to generate the extension dissectors.
+
+Once process-x11-xcb.pl is complete, compile wireshark as usual.
index c558a47a3fd091f9ea4daa26f071def0f33fb341..b760e3c9cc9905fe54d2d24dd93b5dbede11602d 100644 (file)
@@ -63,6 +63,7 @@
 #include <glib.h>
 #include <epan/packet.h>
 #include <epan/conversation.h>
+#include <epan/expert.h>
 
 #include <epan/prefs.h>
 #include "packet-frame.h"
@@ -91,6 +92,8 @@
 #define UNKNOWN_OPCODE           0
 
 #define MAX_OPCODES            (255 + 1) /* 255 + INITIAL_CONN */
+#define LastExtensionError     255
+#define LastExtensionEvent     127
 
 #define BYTE_ORDER_BE          0
 #define BYTE_ORDER_LE          1
@@ -129,6 +132,13 @@ typedef struct _x11_conv_data {
       GHashTable *valtable;/* hashtable of sequencenumber <-> &opcode_vals */
       /* major opcodes including extensions (NULL terminated) */
       value_string opcode_vals[MAX_OPCODES+1];
+      /* error codes including extensions (NULL terminated) */
+      value_string errorcode_vals[LastExtensionError + 2];
+      /* event codes including extensions (NULL terminated) */
+      value_string eventcode_vals[LastExtensionEvent + 2];
+      GHashTable *eventcode_funcs;     /* hashtable of eventcode <-> dissect_event() */
+      GHashTable *reply_funcs;         /* hashtable of opcode <-> dissect_reply() */
+
       int      sequencenumber; /* sequencenumber of current packet.       */
       guint32  iconn_frame;    /* frame # of initial connection request   */
       guint32  iconn_reply;    /* frame # of initial connection reply     */
@@ -150,6 +160,11 @@ typedef struct _x11_conv_data {
 
 static x11_conv_data_t *x11_conv_data_list;
 
+static GHashTable *extension_table; /* hashtable of extension name <-> dispatch function */
+static GHashTable *event_table;     /* hashtable of extension name <-> event info list */
+static GHashTable *error_table;     /* hashtable of extension name <-> error list */
+static GHashTable *reply_table;     /* hashtable of extension name <-> reply list */
+
 /* Initialize the protocol and registered fields */
 static int proto_x11 = -1;
 
@@ -162,6 +177,8 @@ static gint ett_x11_list_of_arc = -1;
 static gint ett_x11_arc = -1;
 static gint ett_x11_list_of_atom = -1;
 static gint ett_x11_list_of_card32 = -1;
+static gint ett_x11_list_of_float = -1;
+static gint ett_x11_list_of_double = -1;
 static gint ett_x11_list_of_color_item = -1;
 static gint ett_x11_color_item = -1;
 static gint ett_x11_list_of_keycode = -1;
@@ -866,8 +883,6 @@ static const value_string opcode_vals[] = {
 #define ColormapNotify         32
 #define ClientMessage          33
 #define MappingNotify          34
-#define FirstExtensionEvent    64
-#define LastExtensionEvent     127
 
 static const value_string eventcode_vals[] = {
        { KeyPress,          "KeyPress" },
@@ -934,9 +949,6 @@ static const value_string eventcode_vals[] = {
 #define BadLength              16      /* Request length incorrect */
 #define BadImplementation      17      /* server is defective */
 
-#define FirstExtensionError    128
-#define LastExtensionError     255
-
 static const value_string errorcode_vals[] = {
        { Success,               "Success" },
        { BadRequest,            "BadRequest" },
@@ -956,8 +968,6 @@ static const value_string errorcode_vals[] = {
        { BadName,               "BadName" },
        { BadLength,             "BadLength" },
        { BadImplementation,     "BadImplementation" },
-       { FirstExtensionError,   "FirstExtensionError" },
-       { LastExtensionError,    "LastExtensionError" },
        { 0,                     NULL }
 };
 
@@ -1058,6 +1068,8 @@ static const value_string zero_is_none_vals[] = {
 #define VALUE8(tvb, offset) (tvb_get_guint8(tvb, offset))
 #define VALUE16(tvb, offset) (little_endian ? tvb_get_letohs(tvb, offset) : tvb_get_ntohs(tvb, offset))
 #define VALUE32(tvb, offset) (little_endian ? tvb_get_letohl(tvb, offset) : tvb_get_ntohl(tvb, offset))
+#define FLOAT(tvb, offset) (little_endian ? tvb_get_letohieee_float(tvb, offset) : tvb_get_ntohieee_float(tvb, offset))
+#define DOUBLE(tvb, offset) (little_endian ? tvb_get_letohieee_double(tvb, offset) : tvb_get_ntohieee_double(tvb, offset))
 
 #define FIELD8(name)  (field8(tvb, offsetp, t, hf_x11_##name, little_endian))
 #define FIELD16(name) (field16(tvb, offsetp, t, hf_x11_##name, little_endian))
@@ -1144,7 +1156,7 @@ static const value_string zero_is_none_vals[] = {
        ti = proto_tree_add_text(t, next_tvb, 0, -1, "event: %d (%s)",  \
                                 eventcode,                             \
                                 val_to_str(eventcode & 0x7F,           \
-                                           eventcode_vals,             \
+                                           state->eventcode_vals,             \
                                            "<Unknown eventcode %u>")); \
        proto_tree = proto_item_add_subtree(ti, ett_x11_event);         \
        decode_x11_event(next_tvb, eventcode, sent, proto_tree,         \
@@ -1169,7 +1181,15 @@ static const value_string zero_is_none_vals[] = {
 #define LISTofSTRING8(name, length) { listOfString8(tvb, offsetp, t, hf_x11_##name, hf_x11_##name##_string, (length), little_endian); }
 #define LISTofTEXTITEM8(name) { listOfTextItem(tvb, offsetp, t, hf_x11_##name, FALSE, next_offset, little_endian); }
 #define LISTofTEXTITEM16(name) { listOfTextItem(tvb, offsetp, t, hf_x11_##name, TRUE, next_offset, little_endian); }
-#define OPCODE()       { opcode = FIELD8(opcode); }
+#define OPCODE() {                                             \
+    const gchar *enumValue = NULL;                             \
+    opcode = VALUE8(tvb, *offsetp);                            \
+    enumValue = match_strval(opcode, state->opcode_vals);      \
+    proto_tree_add_uint_format(t, hf_x11_opcode, tvb, *offsetp, 1, opcode,     \
+            "opcode: %u (%s)", opcode, enumValue);             \
+    *offsetp += 1;                                             \
+  }
+
 #define PIXMAP(name)   { FIELD32(name); }
 #define REQUEST_LENGTH() (requestLength(tvb, offsetp, t, little_endian))
 #define SETofEVENT(name) { setOfEvent(tvb, offsetp, t, little_endian); }
@@ -1212,20 +1232,20 @@ static const value_string zero_is_none_vals[] = {
        *offsetp, sizeof(seqno), seqno,                                 \
        "sequencenumber: %d (%s)",                                      \
        (int)seqno,                                                     \
-       val_to_str(opcode, state->opcode_vals, "<Unknown opcode %d>")); \
+       val_to_str(opcode & 0xFF, state->opcode_vals, "<Unknown opcode %d>"));  \
        *offsetp += sizeof(seqno);                                      \
 } while (0)
 
 #define REPLYCONTENTS_COMMON() do {                                    \
        REPLY(reply);                                                   \
-       proto_tree_add_item(t, hf_x11_undecoded, tvb, offset,           \
+       proto_tree_add_item(t, hf_x11_undecoded, tvb, *offsetp,         \
        1, little_endian);                                              \
-       ++offset;                                                       \
+       ++(*offsetp);                                                   \
        SEQUENCENUMBER_REPLY(sequencenumber);                           \
        REPLYLENGTH(replylength);                                       \
-       proto_tree_add_item(t, hf_x11_undecoded, tvb, offset,           \
-       tvb_reported_length_remaining(tvb, offset), little_endian);     \
-       offset += tvb_reported_length_remaining(tvb, offset);           \
+       proto_tree_add_item(t, hf_x11_undecoded, tvb, *offsetp,         \
+       tvb_reported_length_remaining(tvb, *offsetp), little_endian);   \
+       *offsetp += tvb_reported_length_remaining(tvb, *offsetp);       \
 } while (0)
 
 
@@ -1447,6 +1467,28 @@ static void listOfByte(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
       *offsetp += length;
 }
 
+static void listOfCard16(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+                        int hf_item, int length, gboolean little_endian)
+{
+      proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 2, little_endian);
+      proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_card32);
+      while(length--) {
+           proto_tree_add_uint(tt, hf_item, tvb, *offsetp, 2, VALUE16(tvb, *offsetp));
+           *offsetp += 2;
+      }
+}
+
+static void listOfInt16(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+                        int hf_item, int length, gboolean little_endian)
+{
+      proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 2, little_endian);
+      proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_card32);
+      while(length--) {
+           proto_tree_add_int(tt, hf_item, tvb, *offsetp, 2, VALUE16(tvb, *offsetp));
+           *offsetp += 2;
+      }
+}
+
 static void listOfCard32(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
                         int hf_item, int length, gboolean little_endian)
 {
@@ -1458,6 +1500,39 @@ static void listOfCard32(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
       }
 }
 
+static void listOfInt32(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+                        int hf_item, int length, gboolean little_endian)
+{
+      proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 4, little_endian);
+      proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_card32);
+      while(length--) {
+           proto_tree_add_int(tt, hf_item, tvb, *offsetp, 4, VALUE32(tvb, *offsetp));
+           *offsetp += 4;
+      }
+}
+
+static void listOfFloat(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+                        int hf_item, int length, gboolean little_endian)
+{
+      proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 4, little_endian);
+      proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_float);
+      while(length--) {
+           proto_tree_add_float(tt, hf_item, tvb, *offsetp, 4, FLOAT(tvb, *offsetp));
+           *offsetp += 4;
+      }
+}
+
+static void listOfDouble(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
+                        int hf_item, int length, gboolean little_endian)
+{
+      proto_item *ti = proto_tree_add_item(t, hf, tvb, *offsetp, length * 8, little_endian);
+      proto_tree *tt = proto_item_add_subtree(ti, ett_x11_list_of_double);
+      while(length--) {
+           proto_tree_add_double(tt, hf_item, tvb, *offsetp, 8, DOUBLE(tvb, *offsetp));
+           *offsetp += 8;
+      }
+}
+
 static void listOfColorItem(tvbuff_t *tvb, int *offsetp, proto_tree *t, int hf,
                            int length, gboolean little_endian)
 {
@@ -2949,6 +3024,127 @@ static void dissect_x11_initial_reply(tvbuff_t *tvb, packet_info *pinfo,
 
 }
 
+typedef struct x11_reply_info {
+    const guint8 minor;
+    void (*dissect)(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian);
+} x11_reply_info;
+
+typedef struct event_info {
+    const gchar *name;
+    void (*dissect)(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian);
+} x11_event_info;
+
+static void set_handler(const char *name, void (*func)(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian),
+                       const char **errors,
+                       const x11_event_info *event_info,
+                       const x11_reply_info *reply_info)
+{
+    g_hash_table_insert(extension_table, (gpointer)name, (gpointer)func);
+    g_hash_table_insert(error_table, (gpointer)name, (gpointer)errors);
+    g_hash_table_insert(event_table, (gpointer)name, (gpointer)event_info);
+    g_hash_table_insert(reply_table, (gpointer)name, (gpointer)reply_info);
+}
+
+
+#include "x11-extension-errors.h"
+#include "x11-extension-implementation.h"
+
+static void tryExtension(int opcode, tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t,
+    x11_conv_data_t *state, gboolean little_endian)
+{
+    const gchar *extension;
+    void (*func)(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian);
+
+    extension = match_strval(opcode, state->opcode_vals);
+    if (!extension)
+       return;
+
+    func = g_hash_table_lookup(extension_table, extension);
+    if (func)
+       func(tvb, pinfo, offsetp, t, little_endian);
+}
+
+static void tryExtensionReply(int opcode, tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t,
+    x11_conv_data_t *state, gboolean little_endian)
+{
+    void (*func)(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian);
+
+    func = g_hash_table_lookup(state->reply_funcs, GINT_TO_POINTER(opcode));
+    if (func)
+       func(tvb, pinfo, offsetp, t, little_endian);
+    else
+       REPLYCONTENTS_COMMON();
+}
+
+static void tryExtensionEvent(int event, tvbuff_t *tvb, int *offsetp, proto_tree *t,
+    x11_conv_data_t *state, gboolean little_endian)
+{
+    void (*func)(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian);
+
+    func = g_hash_table_lookup(state->eventcode_funcs, GINT_TO_POINTER(event));
+    if (func)
+       func(tvb, offsetp, t, little_endian);
+}
+
+static void register_extension(x11_conv_data_t *state, value_string *vals_p,
+    int major_opcode, unsigned int first_event, unsigned int first_error)
+{
+    const char **error_string;
+    x11_event_info *event_info;
+    x11_reply_info *reply_info;
+    int i;
+
+    vals_p->value = major_opcode;
+
+    error_string = g_hash_table_lookup(error_table, vals_p->strptr);
+    while (error_string && *error_string && first_error <= LastExtensionError) {
+       /* store string of extension error */
+       for (i = 0; i <= LastExtensionError; i++) {
+           if (state->errorcode_vals[i].strptr == NULL) {
+               state->errorcode_vals[i].value = first_error;
+               state->errorcode_vals[i].strptr = *error_string;
+               break;
+           } else if (state->errorcode_vals[i].value == first_error) {
+               /* TODO: Warn about extensions stepping on each other */
+               state->errorcode_vals[i].strptr = *error_string;
+               break;
+           }
+       }
+       first_error++;
+       error_string++;
+    }
+
+    event_info = g_hash_table_lookup(event_table, vals_p->strptr);
+    while (event_info && event_info->name && first_event <= LastExtensionEvent) {
+       /* store string of extension event */
+       for (i = 0; i <= LastExtensionEvent; i++) {
+           if (state->eventcode_vals[i].strptr == NULL) {
+               state->eventcode_vals[i].value = first_event;
+               state->eventcode_vals[i].strptr = event_info->name;
+               break;
+           } else if (state->eventcode_vals[i].value == first_event) {
+               /* TODO: Warn about extensions stepping on each other */
+               state->eventcode_vals[i].strptr = event_info->name;
+               break;
+           }
+       }
+
+       /* store event decode function */
+       g_hash_table_insert(state->eventcode_funcs, GINT_TO_POINTER(first_event), (gpointer)event_info->dissect);
+
+       first_event++;
+       event_info++;
+    }
+
+    reply_info = g_hash_table_lookup(reply_table, vals_p->strptr);
+    if (reply_info)
+       for (i = 0; reply_info[i].dissect; i++)
+           g_hash_table_insert(state->reply_funcs,
+                       GINT_TO_POINTER(major_opcode | (reply_info[i].minor << 8)),
+                       (gpointer)reply_info[i].dissect);
+}
+
+
 static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo,
     proto_tree *tree, const char *sep, x11_conv_data_t *state,
     gboolean little_endian)
@@ -3009,6 +3205,7 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo,
                while(i < MAX_OPCODES) {
                        if (state->opcode_vals[i].strptr == NULL) {
                                state->opcode_vals[i].strptr = name;
+                               state->opcode_vals[i].value = -1;
                                g_hash_table_insert(state->valtable,
                                                    GINT_TO_POINTER(state->sequencenumber),
                                                    (int *)&state->opcode_vals[i]);
@@ -3078,9 +3275,12 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo,
                 * With Extension, we don't know, so assume there could be one
                 */
                if (opcode >= X_FirstExtension && opcode <= X_LastExtension) {
+                       guint32 minor;
+                       minor = tvb_get_guint8(tvb, 1);
+
                        g_hash_table_insert(state->seqtable,
                                            GINT_TO_POINTER(state->sequencenumber),
-                                           GINT_TO_POINTER(opcode));
+                                           GINT_TO_POINTER(opcode | (minor << 8)));
                }
 
                /*
@@ -4060,6 +4260,9 @@ static void dissect_x11_request(tvbuff_t *tvb, packet_info *pinfo,
            UNUSED(1);
            REQUEST_LENGTH();
            break;
+      default:
+           tryExtension(opcode, tvb, pinfo, offsetp, t, state, little_endian);
+           break;
       }
 
       if ((left = tvb_reported_length_remaining(tvb, offset)) > 0)
@@ -4378,6 +4581,36 @@ x11_stateinit(conversation_t *conversation)
          i++;
        }
 
+       /* initialise errorcodes */
+       i = 0;
+       while (1) {
+         if (errorcode_vals[i].strptr == NULL) break;
+         state->errorcode_vals[i].value = errorcode_vals[i].value;
+         state->errorcode_vals[i].strptr = errorcode_vals[i].strptr;
+         i++;
+       }
+       while (i <= LastExtensionError + 1) {
+         state->errorcode_vals[i].value = 0;
+         state->errorcode_vals[i].strptr = NULL;
+         i++;
+       }
+
+       /* initialise eventcodes */
+       i = 0;
+       while (1) {
+         if (eventcode_vals[i].strptr == NULL) break;
+         state->eventcode_vals[i].value = eventcode_vals[i].value;
+         state->eventcode_vals[i].strptr = eventcode_vals[i].strptr;
+         i++;
+       }
+       while (i <= LastExtensionEvent + 1) {
+         state->eventcode_vals[i].value = 0;
+         state->eventcode_vals[i].strptr = NULL;
+         i++;
+       }
+       state->eventcode_funcs = g_hash_table_new(g_direct_hash, g_direct_equal);
+       state->reply_funcs = g_hash_table_new(g_direct_hash, g_direct_equal);
+
        state->seqtable = g_hash_table_new(g_direct_hash, g_direct_equal);
        state->valtable = g_hash_table_new(g_direct_hash, g_direct_equal);
        g_hash_table_insert(state->seqtable, (int *)0, (int *)NOTHING_SEEN);
@@ -4533,7 +4766,7 @@ dissect_x11_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                  gboolean little_endian)
 {
        int offset = 0, *offsetp = &offset, length, left, opcode;
-       int major_opcode, sequence_number;
+       int major_opcode, sequence_number, first_error, first_event;
        value_string *vals_p;
        proto_item *ti;
        proto_tree *t;
@@ -4586,11 +4819,17 @@ dissect_x11_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                if (check_col(pinfo->cinfo, COL_INFO))
                        col_append_fstr(pinfo->cinfo, COL_INFO, "%s %s",
                                        sep,
-                                       val_to_str(opcode, state->opcode_vals,
+                                       val_to_str(opcode & 0xFF, state->opcode_vals,
                                                   "<Unknown opcode %d>"));
 
-               proto_item_append_text(ti, ", Reply, opcode: %d (%s)",
-                                      opcode, val_to_str(opcode,
+               if (opcode > 0xFF)
+                   proto_item_append_text(ti, ", Reply, opcode: %d.%d (%s)",
+                                          opcode & 0xFF, opcode >> 8, val_to_str(opcode & 0xFF,
+                                                         state->opcode_vals,
+                                                         "<Unknown opcode %d>"));
+               else
+                   proto_item_append_text(ti, ", Reply, opcode: %d (%s)",
+                                          opcode, val_to_str(opcode,
                                                          state->opcode_vals,
                                                          "<Unknown opcode %d>"));
        }
@@ -4617,7 +4856,10 @@ dissect_x11_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                                                     GINT_TO_POINTER(sequence_number));
                        if (vals_p != NULL) {
                                major_opcode = VALUE8(tvb, offset + 9);
-                               vals_p->value = major_opcode;
+                               first_event = VALUE8(tvb, offset + 10);
+                               first_error = VALUE8(tvb, offset + 11);
+
+                               register_extension(state, vals_p, major_opcode, first_event, first_error);
                                g_hash_table_remove(state->valtable,
                                                    GINT_TO_POINTER(sequence_number));
                        }
@@ -4883,8 +5125,12 @@ dissect_x11_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                                      state->keycodes_per_modifier);
                        break;
 
-               default:
+               case UNKNOWN_OPCODE:
                        REPLYCONTENTS_COMMON();
+                       break;
+
+               default:
+                       tryExtensionReply(opcode, tvb, pinfo, offsetp, t, state, little_endian);
        }
 
        if ((left = tvb_reported_length_remaining(tvb, offset)) > 0)
@@ -4932,12 +5178,12 @@ dissect_x11_event(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
        if (check_col(pinfo->cinfo, COL_INFO))
                col_append_fstr(pinfo->cinfo, COL_INFO, "%s %s%s",
                                sep, sent,
-                               val_to_str(eventcode & 0x7F, eventcode_vals,
+                               val_to_str(eventcode & 0x7F, state->eventcode_vals,
                                "<Unknown eventcode %u>"));
 
        proto_item_append_text(ti, ", Event, eventcode: %d (%s%s)",
                              eventcode, sent,
-                             val_to_str(eventcode & 0x7F, eventcode_vals,
+                             val_to_str(eventcode & 0x7F, state->eventcode_vals,
                              "<Unknown eventcode %u>"));
 
        if (tree == NULL)
@@ -4959,7 +5205,7 @@ decode_x11_event(tvbuff_t *tvb, unsigned char eventcode, const char *sent,
                                   eventcode,
                                   "eventcode: %d (%s%s)",
                                   eventcode, sent,
-                                  val_to_str(eventcode & 0x7F, eventcode_vals,
+                                  val_to_str(eventcode & 0x7F, state->eventcode_vals,
                                   "<Unknown eventcode %u>"));
        ++offset;
 
@@ -5248,6 +5494,7 @@ decode_x11_event(tvbuff_t *tvb, unsigned char eventcode, const char *sent,
                        break;
 
                default:
+                       tryExtensionEvent(eventcode & 0x7F, tvb, offsetp, t, state, little_endian);
                        break;
        }
 
@@ -5276,18 +5523,18 @@ dissect_x11_error(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
        errorcode = tvb_get_guint8(tvb, offset);
        if (check_col(pinfo->cinfo, COL_INFO))
                col_append_fstr(pinfo->cinfo, COL_INFO, "%s %s",
-               sep, val_to_str(errorcode, errorcode_vals, "<Unknown errorcode %u>"));
+               sep, val_to_str(errorcode, state->errorcode_vals, "<Unknown errorcode %u>"));
 
        proto_tree_add_uint_format(t, hf_x11_errorcode, tvb, offset, 1,
                                   errorcode,
                                   "errorcode: %d (%s)",
                                   errorcode,
-                                  val_to_str(errorcode, errorcode_vals,
+                                  val_to_str(errorcode, state->errorcode_vals,
                                   "<Unknown errorcode %u>"));
        ++offset;
 
         proto_item_append_text(ti, ", Error, errorcode: %d (%s)",
-                              errorcode, val_to_str(errorcode, errorcode_vals,
+                              errorcode, val_to_str(errorcode, state->errorcode_vals,
                               "<Unknown errorcode %u>"));
 
        if (tree == NULL)
@@ -5347,6 +5594,8 @@ void proto_register_x11(void)
            &ett_x11_arc,
            &ett_x11_list_of_atom,
            &ett_x11_list_of_card32,
+           &ett_x11_list_of_float,
+           &ett_x11_list_of_double,
            &ett_x11_list_of_color_item,
            &ett_x11_color_item,
            &ett_x11_list_of_keycode,
@@ -5383,6 +5632,12 @@ void proto_register_x11(void)
 
       register_init_routine(x11_init_protocol);
 
+      extension_table = g_hash_table_new(g_str_hash, g_str_equal);
+      error_table = g_hash_table_new(g_str_hash, g_str_equal);
+      event_table = g_hash_table_new(g_str_hash, g_str_equal);
+      reply_table = g_hash_table_new(g_str_hash, g_str_equal);
+      register_x11_extensions();
+
       x11_module = prefs_register_protocol(proto_x11, NULL);
       prefs_register_bool_preference(x11_module, "desegment",
            "Reassemble X11 messages spanning multiple TCP segments",
index b1c21cb2a301e11b5a2a081c39d59c4bfcbc0664..e444858338cacf6163770703d0e728d26dd9f769 100755 (executable)
@@ -4,7 +4,7 @@
 # X11 dissector, into header files declaring field-index
 # values and field definitions for those fields.
 #
-# Copyright 2000, Christophe Tronche <ch.tronche@computer.org>
+# Copyright 2000, Christophe Tronche <ch.tronche[AT]computer.org>
 #
 # $Id$
 #
 open(DECL, ">x11-declarations.h") || die;
 open(REG, ">x11-register-info.h") || die;
 
-$comment = "/* This file is generated by $0, do not edit. */\n\n";
-print DECL $comment;
-print REG  $comment;
+sub add_generated_header {
+    my ($out) = @_;
+
+    print $out <<eot
+/* Do not modify this file. */
+/* It was automatically generated by $0. */
+eot
+    ;
+    # Since this file is checked in, add its SVN revision
+    print $out "/* \$"."Id"."\$ */\n\n";
+
+    # Add license text
+    print $out <<eot
+/*
+ * Copyright 2000, Christophe Tronche <ch.tronche[AT]computer.org>
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald[AT]wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+eot
+    ;
+}
+
+add_generated_header(DECL);
+add_generated_header(REG);
 
 $prefix = '';
 $subfieldStringLength = 0;
diff --git a/epan/dissectors/process-x11-xcb.pl b/epan/dissectors/process-x11-xcb.pl
new file mode 100755 (executable)
index 0000000..c4133c3
--- /dev/null
@@ -0,0 +1,1217 @@
+#!/usr/bin/perl
+#
+# Script to convert xcbproto and mesa protocol files for
+# X11 dissector. Creates header files containing code to
+# dissect X11 extensions.
+#
+# Copyright 2008, 2009 Open Text Corporation <pharris[AT]opentext.com>
+#
+# $Id$
+#
+# Wireshark - Network traffic analyzer
+# By Gerald Combs <gerald@wireshark.org>
+# Copyright 1998 Gerald Combs
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+
+#TODO
+# - look ahead to see if values are ever used again before creating an "int" in the output
+# - support constructs that are legal in XCB, but don't appear to be used
+
+use 5.010;
+
+use warnings;
+use strict;
+
+use IO::File;
+use XML::Twig;
+
+use File::Spec;
+
+my @reslist = grep {!/xproto\.xml$/} glob File::Spec->catfile('xcbproto', 'src', '*.xml');
+my @register;
+
+my %basictype = (
+    char =>   { size => 1, type => 'FT_STRING', base => 'BASE_NONE',    get => 'VALUE8',  list => 'listOfByte', },
+    void =>   { size => 1, type => 'FT_BYTES',  base => 'BASE_NONE',    get => 'VALUE8',  list => 'listOfByte', },
+    BYTE =>   { size => 1, type => 'FT_BYTES',  base => 'BASE_NONE',    get => 'VALUE8',  list => 'listOfByte', },
+    CARD8 =>  { size => 1, type => 'FT_BYTES',  base => 'BASE_NONE',    get => 'VALUE8',  list => 'listOfByte', },
+    CARD16 => { size => 2, type => 'FT_UINT16', base => 'BASE_HEX_DEC', get => 'VALUE16', list => 'listOfCard16', },
+    CARD32 => { size => 4, type => 'FT_UINT32', base => 'BASE_HEX_DEC', get => 'VALUE32', list => 'listOfCard32', },
+    INT8 =>   { size => 1, type => 'FT_BYTES',  base => 'BASE_NONE',    get => 'VALUE8',  list => 'listOfByte', },
+    INT16 =>  { size => 2, type => 'FT_INT16',  base => 'BASE_DEC',     get => 'VALUE16', list => 'listOfInt16', },
+    INT32 =>  { size => 4, type => 'FT_INT32',  base => 'BASE_DEC',     get => 'VALUE32', list => 'listOfInt32', },
+    float =>  { size => 4, type => 'FT_FLOAT',  base => 'BASE_NONE',    get => 'FLOAT',   list => 'listOfFloat', },
+    double => { size => 8, type => 'FT_DOUBLE', base => 'BASE_NONE',    get => 'DOUBLE',  list => 'listOfDouble', },
+    BOOL =>   { size => 1, type => 'FT_BOOLEAN',base => 'BASE_NONE',    get => 'VALUE8',  list => 'listOfByte', },
+);
+
+my %simpletype;  # Reset at the beginning of each extension
+my %gltype;  # No need to reset, since it's only used once
+
+my %struct =  # Not reset; contains structures already defined.
+             # Also contains this black-list of structures never used by any
+             # extension (to avoid generating useless code).
+(
+    # structures defined by xproto, but not used by any extension
+    CHAR2B => 1,
+    POINT => 1,
+    ARC => 1,
+    FORMAT => 1,
+    VISUALTYPE => 1,
+    DEPTH => 1,
+    SCREEN => 1,
+    SetupRequest => 1,
+    SetupFailed => 1,
+    SetupAuthenticate => 1,
+    Setup => 1,
+    TIMECOORD => 1,
+    FONTPROP => 1,
+    CHARINFO => 1,
+    SEGMENT => 1,
+    COLORITEM => 1,
+    RGB => 1,
+    HOST => 1,
+
+    # structures defined by xinput, but never used (except by each other)(bug in xcb?)
+    InputInfo => 1,
+    KeyInfo => 1,
+    ButtonInfo => 1,
+    AxisInfo => 1,
+    ValuatorInfo => 1,
+    DeviceTimeCoord => 1,
+    FeedbackState => 1,
+    KbdFeedbackState => 1,
+    PtrFeedbackState => 1,
+    IntegerFeedbackState => 1,
+    StringFeedbackState => 1,
+    BellFeedbackState => 1,
+    LedFeedbackState => 1,
+    FeedbackCtl => 1,
+    KbdFeedbackCtl => 1,
+    PtrFeedbackCtl => 1,
+    IntegerFeedbackCtl => 1,
+    StringFeedbackCtl => 1,
+    BellFeedbackCtl => 1,
+    LedFeedbackCtl => 1,
+    InputState => 1,
+    KeyState => 1,
+    ButtonState => 1,
+    ValuatorState => 1,
+    DeviceState => 1,
+    DeviceResolutionState => 1,
+    DeviceAbsCalibState => 1,
+    DeviceAbsAreaState => 1,
+    DeviceCoreState => 1,
+    DeviceEnableState => 1,
+    DeviceCtl => 1,
+    DeviceResolutionCtl => 1,
+    DeviceAbsCalibCtl => 1,
+    DeviceAbsAreaCtrl => 1,
+    DeviceCoreCtrl => 1,
+    DeviceEnableCtrl => 1,
+
+    # structures defined by xv, but never used (bug in xcb?)
+    Image => 1,
+);
+my $header;
+my $extname;
+my $parentclass;
+my %request;
+my %event;
+my %reply;
+
+# Output files
+my $impl;
+my $reg;
+my $decl;
+my $error;
+
+# glRender sub-op output files
+my $enum;
+
+
+sub mesa_category_start {
+    my ($t, $elt) = @_;
+    my $name = $elt->att('name');
+    my $comment;
+    if ($name =~ /^\d\.\d$/) {
+       $comment = "version $name";
+    } else {
+       $comment = "extension $name";
+    }
+
+    print $enum "/* OpenGL $comment */\n";
+    print(" - $comment\n");
+}
+
+sub mesa_category {
+    my ($t, $elt) = @_;
+    $t->purge;
+}
+
+sub mesa_enum {
+    my ($t, $elt) = @_;
+    my $name = $elt->att('name');
+    my $value = $elt->att('value');
+
+    print $enum "  { $value, \"$name\" },\n" if (length($value) > 3 && length($value) < 10);
+    $t->purge;
+}
+
+sub mesa_type {
+    my ($t, $elt) = @_;
+
+    my $name = $elt->att('name');
+    my $size = $elt->att('size');
+    my $float = $elt->att('float');
+    my $unsigned = $elt->att('unsigned');
+    my $base;
+
+    $t->purge;
+
+    if($name eq 'enum') {
+       # enum does not have a direct X equivalent
+       $gltype{'GLenum'} = { size => 4, type => 'FT_UINT32', base => 'BASE_HEX',
+                             get => 'VALUE32', list => 'listOfCard32',
+                             val => 'VALS(mesa_enum)', };
+       return;
+    }
+
+    $name = 'GL'.$name;
+    if (defined($float) && $float eq 'true') {
+       $base = 'float';
+       $base = 'double' if ($size == 8);
+    } else {
+       $base = 'INT';
+       if (defined($unsigned) && $unsigned eq 'true') {
+           $base = 'CARD';
+       }
+       $base .= ($size * 8);
+
+       $base = 'BOOL' if ($name eq 'bool');
+       $base = 'BYTE' if ($name eq 'void');
+    }
+
+    $gltype{$name} = $basictype{$base};
+}
+
+sub registered_name($$)
+{
+    my $name = shift;
+    my $field = shift;
+
+    return "hf_x11_$header"."_$name"."_$field";
+}
+
+sub mesa_function {
+    my ($t, $elt) = @_;
+    # rop == glRender sub-op
+    # sop == GLX minor opcode
+    my $glx = $elt->first_child('glx');
+    unless(defined $glx) { $t->purge; return; }
+
+    my $rop = $glx->att('rop');
+    unless (defined $rop) { $t->purge; return; }
+
+    # Ideally, we want the main name, not the alias name.
+    # Practically, we'd have to scan the file twice to find
+    # the functions that we want to skip.
+    my $alias = $elt->att('alias');
+    if (defined $alias) { $t->purge; return; }
+
+    my $name = $elt->att('name');
+    $request{$rop} = $name;
+
+    my $image;
+
+    my $length = 0;
+    my @elements = $elt->children('param');
+
+    # Wireshark defines _U_ to mean "Unused" (compiler specific define)
+    if (!@elements) {
+       print $impl <<eot
+static void mesa_$name(tvbuff_t *tvb _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_)
+{
+eot
+;
+    } else {
+       print $impl <<eot
+static void mesa_$name(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+eot
+;
+    }
+
+    foreach my $e (@elements) {
+       # Register field with wireshark
+
+       my $type = $e->att('type');
+       $type =~ s/^const //;
+       my $list;
+       $list = 1 if ($type =~ /\*$/);
+       $type =~ s/ \*$//;
+
+       my $fieldname = $e->att('name');
+       my $regname = registered_name($name, $fieldname);
+
+       my $info = $gltype{$type};
+       my $ft = $info->{'type'};
+       my $base = $info->{'base'};
+       my $val = $info->{'val'} // 'NULL';
+
+       print $decl "static int $regname = -1;\n";
+       if ($list and $info->{'size'} > 1) {
+           print $reg "{ &$regname, { \"$fieldname\", \"x11.glx.render.$name.$fieldname\", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }},\n";
+           $regname .= '_item';
+           print $decl "static int $regname = -1;\n";
+       }
+       print $reg "{ &$regname, { \"$fieldname\", \"x11.glx.render.$name.$fieldname\", $ft, $base, $val, 0, NULL, HFILL }},\n";
+
+       if ($e->att('counter')) {
+           print $impl "    int $fieldname;\n";
+       }
+
+       if ($list) {
+           if ($e->att('img_format')) {
+               $image = 1;
+               foreach my $wholename (('swap bytes', 'lsb first')) {
+                   # Boolean values
+                   my $varname = $wholename;
+                   $varname =~ s/\s//g;
+                   my $regname = registered_name($name, $varname);
+                   print $decl "static int $regname = -1;\n";
+                   print $reg "{ &$regname, { \"$wholename\", \"x11.glx.render.$name.$varname\", FT_BOOLEAN, BASE_NONE, NULL, 0, NULL, HFILL }},\n";
+               }
+               foreach my $wholename (('row length', 'skip rows', 'skip pixels', 'alignment')) {
+                   # Integer values
+                   my $varname = $wholename;
+                   $varname =~ s/\s//g;
+                   my $regname = registered_name($name, $varname);
+                   print $decl "static int $regname = -1;\n";
+                   print $reg "{ &$regname, { \"$wholename\", \"x11.glx.render.$name.$varname\", FT_UINT32, BASE_HEX_DEC, NULL, 0, NULL, HFILL }},\n";
+               }
+           }
+       }
+    }
+
+    # The image requests have a few implicit elements first:
+    if ($image) {
+       foreach my $wholename (('swap bytes', 'lsb first')) {
+           # Boolean values
+           my $varname = $wholename;
+           $varname =~ s/\s//g;
+           my $regname = registered_name($name, $varname);
+           print $impl "    proto_tree_add_item(t, $regname, tvb, *offsetp, 1, little_endian);\n";
+           print $impl "    *offsetp += 1;\n";
+           $length += 1;
+       }
+       print $impl "    UNUSED(2);\n";
+       $length += 2;
+       foreach my $wholename (('row length', 'skip rows', 'skip pixels', 'alignment')) {
+           # Integer values
+           my $varname = $wholename;
+           $varname =~ s/\s//g;
+           my $regname = registered_name($name, $varname);
+           print $impl "    proto_tree_add_item(t, $regname, tvb, *offsetp, 4, little_endian);\n";
+           print $impl "    *offsetp += 4;\n";
+           $length += 4;
+       }
+    }
+
+    foreach my $e (@elements) {
+       my $type = $e->att('type');
+       $type =~ s/^const //;
+       my $list;
+       $list = 1 if ($type =~ /\*$/);
+       $type =~ s/ \*$//;
+
+       my $fieldname = $e->att('name');
+       my $regname = registered_name($name, $fieldname);
+
+       my $info = $gltype{$type};
+       my $ft = $info->{'type'};
+       my $base = $info->{'base'};
+
+        if (!$list) {
+           my $size = $info->{'size'};
+           my $get = $info->{'get'};
+
+           if ($e->att('counter')) {
+               print $impl "    $fieldname = $get(tvb, *offsetp);\n";
+           }
+           print $impl "    proto_tree_add_item(t, $regname, tvb, *offsetp, $size, little_endian);\n";
+           print $impl "    *offsetp += $size;\n";
+           $length += $size;
+        } else {       # list
+           # TODO: variable_param
+           my $list = $info->{'list'};
+           my $count = $e->att('count');
+           my $variable_param = $e->att('variable_param');
+
+           $regname .= ", $regname".'_item' if ($info->{'size'} > 1);
+           if (defined($count) && !defined($variable_param)) {
+               print $impl "    $list(tvb, offsetp, t, $regname, $count, little_endian);\n";
+           } else {
+               print $impl "    $list(tvb, offsetp, t, $regname, (length - $length) / $gltype{$type}{'size'}, little_endian);\n";
+           }
+       }
+    }
+
+    print $impl "}\n\n";
+    $t->purge;
+}
+
+sub get_ref($$)
+{
+    my $elt = shift;
+    my $refref = shift;
+    my $rv;
+
+    given($elt->name()) {
+       when ('fieldref') {
+           $rv = $elt->text();
+           $refref->{$rv} = 1;
+           $rv = 'f_'.$rv;
+       }
+       when ('value') { $rv = $elt->text(); }
+       when ('op') { $rv = get_op($elt, $refref); }
+       default { die "Invalid op fragment: $_" }
+    }
+    return $rv;
+}
+
+sub get_op($;$) {
+    my $op = shift;
+    my $refref = shift // {};
+
+    my @elements = $op->children(qr/fieldref|value|op/);
+    (@elements == 2) or die ("Wrong number of children for 'op'\n");
+    my $left;
+    my $right;
+
+    $left = get_ref($elements[0], $refref);
+    $right = get_ref($elements[1], $refref);
+
+    return "($left " . $op->att('op') . " $right)";
+}
+
+sub register_element($$$;$)
+{
+    my $e = shift;
+    my $varpat = shift;
+    my $humanpat = shift;
+    my $indent = shift // ' ' x 4;
+
+    return if ($e->name() eq 'pad');
+
+    # Register field with wireshark
+
+    my $fieldname = $e->att('name');
+    my $type = $e->att('type');
+    $type =~ s/^.*://;
+
+    my $regname = 'hf_x11_'.sprintf ($varpat, $fieldname);
+    my $humanname = 'x11.'.sprintf ($humanpat, $fieldname);
+
+    my $info = $basictype{$type} // $simpletype{$type} // $struct{$type};
+    my $ft = $info->{'type'} // 'FT_NONE';
+    my $base = $info->{'base'} // 'BASE_NONE';
+
+    print $decl "static int $regname = -1;\n";
+    if ($e->name() eq 'list' and $info->{'size'} > 1) {
+       print $reg "{ &$regname, { \"$fieldname\", \"$humanname\", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }},\n";
+       $regname .= '_item';
+       print $decl "static int $regname = -1;\n";
+    }
+    print $reg "{ &$regname, { \"$fieldname\", \"$humanname\", $ft, $base, NULL, 0, NULL, HFILL }},\n";
+
+    if ($e->name() eq 'field') {
+       if ($basictype{$type} or $simpletype{$type}) {
+           # Pre-declare variable
+           print $impl $indent."int f_$fieldname;\n";
+       }
+    }
+}
+
+sub dissect_element($$$;$$)
+{
+    my $e = shift;
+    my $varpat = shift;
+    my $length = shift;
+    my $adjustlength = shift;
+    my $indent = shift // ' ' x 4;
+
+    if ($e->name() eq 'pad') {
+       my $bytes = $e->att('bytes');
+       print $impl $indent."UNUSED($bytes);\n";
+       $length += $bytes;
+    } elsif ($e->name() eq 'field') {
+       my $fieldname = $e->att('name');
+       my $regname = 'hf_x11_'.sprintf ($varpat, $fieldname);
+       my $type = $e->att('type');
+       $type =~ s/^.*://;
+
+       if ($basictype{$type} or $simpletype{$type}) {
+           my $info = $basictype{$type} // $simpletype{$type};
+           my $size = $info->{'size'};
+           my $get = $info->{'get'};
+
+           print $impl $indent."f_$fieldname = $get(tvb, *offsetp);\n";
+           print $impl $indent."proto_tree_add_item(t, $regname, tvb, *offsetp, $size, little_endian);\n";
+           print $impl $indent."*offsetp += $size;\n";
+           $length += $size;
+       } elsif ($struct{$type}) {
+           # TODO: variable-lengths (when $info->{'size'} == 0 )
+           my $info = $struct{$type};
+           $length += $info->{'size'};
+           print $impl $indent."struct_$type(tvb, offsetp, t, little_endian, 1);\n";
+       } else {
+           die ("Unrecognized type: $type\n");
+       }
+    } else {   # list
+       my $fieldname = $e->att('name');
+       my $regname = 'hf_x11_'.sprintf ($varpat, $fieldname);
+       my $type = $e->att('type');
+       $type =~ s/^.*://;
+
+       my $info = $basictype{$type} // $simpletype{$type} // $struct{$type};
+       my $lencalc = "(length - $length) / $info->{'size'}";
+       my $lentype = $e->first_child();
+       if (defined $lentype) {
+           given ($lentype->name()) {
+               when ('value') { $lencalc = $lentype->text(); }
+               when ('fieldref') { $lencalc = 'f_'.$lentype->text(); }
+               when ('op') { $lencalc = get_op($lentype); }
+           }
+       }
+
+       if ($basictype{$type} or $simpletype{$type}) {
+           my $list = $info->{'list'};
+           $regname .= ", $regname".'_item' if ($info->{'size'} > 1);
+           print $impl $indent."$list(tvb, offsetp, t, $regname, $lencalc, little_endian);\n";
+       } elsif ($struct{$type}) {
+           print $impl $indent."struct_$type(tvb, offsetp, t, little_endian, $lencalc);\n";
+       } else {
+           die ("Unrecognized type: $type\n");
+       }
+       
+       if ($adjustlength && defined($lentype)) {
+         # Some requests end with a list of unspecified length
+         # Adjust the length field here so that the next $lencalc will be accurate
+         say $impl $indent."length -= $lencalc * $info->{'size'};";
+       }
+    }
+    return $length;
+}
+
+sub struct {
+    my ($t, $elt) = @_;
+    my $name = $elt->att('name');
+
+    if (defined $struct{$name}) {
+       $t->purge;
+       return;
+    }
+
+    my @elements = $elt->children(qr/pad|field|list/);
+
+    print(" - Struct $name\n");
+
+    my %refs;
+    my $size = 0;
+    my $dynamic = 0;
+    my $needi = 0;
+    # Find struct size
+    foreach my $e (@elements) {
+       my $count;
+       $count = 1;
+        if ($e->name() eq 'pad') {
+            my $bytes = $e->att('bytes');
+           $size += $bytes;
+           next;
+        } elsif ($e->name() eq 'list') {
+            my $type = $e->att('type');
+           my $info = $basictype{$type} // $simpletype{$type} // $struct{$type};
+           my $count;
+
+           $needi = 1 if ($info->{'size'} == 0);
+
+           if ($e->has_child('fieldref') || $e->has_child('op')) {
+               my $ref = $e->first_child('fieldref');
+               if (defined $ref) {
+                   $refs{$ref->text()} = 1;
+               } else {
+                   get_op($e->first_child('op'), \%refs);
+               }
+               $count = 0;
+               $dynamic = 1;
+           } else {
+               $count = $e->first_child('value')->text();
+           }
+       } # else 'field'
+
+       my $type = $e->att('type');
+       my $info = $basictype{$type} // $simpletype{$type} // $struct{$type};
+
+       $size += $info->{'size'} * $count;
+    }
+
+    if ($dynamic) {
+       $size = 0;
+       print $impl <<eot
+
+static int struct_size_$name(tvbuff_t *tvb, int *offsetp, int little_endian _U_)
+{
+    int size = 0;
+eot
+;
+       say $impl '    int i, off;' if ($needi);
+
+       foreach my $ref (keys %refs) {
+           say $impl "    int f_$ref;";
+       }
+
+       foreach my $e (@elements) {
+           my $count;
+           $count = 1;
+
+           my $type = $e->att('type') // '';
+           my $info = $basictype{$type} // $simpletype{$type} // $struct{$type};
+
+           given ($e->name()) {
+               when ('pad') {
+                   my $bytes = $e->att('bytes');
+                   $size += $bytes;
+               }
+               when ('list') {
+                   my $len = $e->first_child();
+                   my $infosize = $info->{'size'};
+                   my $sizemul;
+
+                   given ($len->name()) {
+                       when ('op') { $sizemul = get_op($len, \%refs); }
+                       when ('fieldref') { $sizemul = 'f_'.$len->text(); }
+                       when ('value') {
+                           if ($infosize) {
+                               $size += $infosize * $len->text();
+                           } else {
+                               $sizemul = $len->text();
+                           }
+                       }
+                       default { die "Invalid list size: $_\n"; }
+                   }
+                   if (defined $sizemul) {
+                       if ($infosize) {
+                           say $impl "    size += $sizemul * $infosize;";
+                       } else {
+                           say $impl "    for (i = 0; i < $sizemul; i++) {";
+                           say $impl "        off = (*offsetp) + size + $size;";
+                           say $impl "        size += struct_size_$type(tvb, &off, little_endian);";
+                           say $impl '    }';
+                       }
+                   }
+               }
+               when ('field') {
+                   my $fname = $e->att('name');
+                   if (defined($refs{$fname})) {
+                       say $impl "    f_$fname = $info->{'get'}(tvb, *offsetp + size + $size);";
+                   }
+                   $size += $info->{'size'};
+               }
+           }
+       }
+       say $impl "    return size + $size;";
+       say $impl '}';
+       $size = 0; # 0 means "dynamic calcuation required"
+    }
+
+    print $decl "static int hf_x11_struct_$name = -1;\n";
+    print $reg "{ &hf_x11_struct_$name, { \"$name\", \"x11.struct.$name\", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }},\n";
+
+    print $impl <<eot
+
+static void struct_$name(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count)
+{
+    int i;
+    for (i = 0; i < count; i++) {
+       proto_item *item;
+       proto_tree *t;
+eot
+;
+
+    my $varpat = 'struct_'.$name.'_%s';
+    my $humanpat = "struct.$name.%s";
+
+    foreach my $e (@elements) {
+       register_element($e, $varpat, $humanpat, "\t");
+    }
+
+    my $sizecalc = $size;
+    $size or $sizecalc = "struct_size_$name(tvb, offsetp, little_endian)";
+
+    print $impl <<eot
+
+       item = proto_tree_add_item(root, hf_x11_struct_$name, tvb, *offsetp, $sizecalc, little_endian);
+       t = proto_item_add_subtree(item, ett_x11_rectangle);
+eot
+;
+    my $length = 0;
+    foreach my $e (@elements) {
+       $length = dissect_element($e, $varpat, $length, 0, "\t");
+    }
+
+    print $impl "    }\n}\n";
+    $struct{$name} = { size => $size };
+    $t->purge;
+}
+
+sub union {
+    # TODO proper dissection
+    #
+    # Right now, the only extension to use a union is randr.
+    # for now, punt.
+    my ($t, $elt) = @_;
+    my $name = $elt->att('name');
+
+    if (defined $struct{$name}) {
+       $t->purge;
+       return;
+    }
+
+    my @elements = $elt->children(qr/field/);
+    my @sizes;
+
+    print(" - Union $name\n");
+
+    # Find union size
+    foreach my $e (@elements) {
+       my $type = $e->att('type');
+       my $info = $basictype{$type} // $simpletype{$type} // $struct{$type};
+
+       $info->{'size'} > 0 or die ("Error: Union containing variable sized struct\n");
+       push @sizes, $info->{'size'};
+    }
+    @sizes = sort {$b <=> $a} @sizes;
+    my $size = $sizes[0];
+
+    print $decl "static int hf_x11_union_$name = -1;\n";
+    print $reg "{ &hf_x11_union_$name, { \"$name\", \"x11.union.$name\", FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL }},\n";
+
+    print $impl <<eot
+
+static void struct_$name(tvbuff_t *tvb, int *offsetp, proto_tree *root, int little_endian, int count)
+{
+    int i;
+    int base = *offsetp;
+    for (i = 0; i < count; i++) {
+       proto_item *item;
+       proto_tree *t;
+
+       item = proto_tree_add_item(root, hf_x11_union_$name, tvb, base, $size, little_endian);
+       t = proto_item_add_subtree(item, ett_x11_rectangle);
+
+eot
+;
+
+    my $varpat = 'union_'.$name.'_%s';
+    my $humanpat = "union.$name.%s";
+
+    my $length = 0;
+    foreach my $e (@elements) {
+       say $impl '        *offsetp = base;';
+       dissect_element($e, $varpat, 0, 0, "\t");
+    }
+    say $impl "        base += $size;";
+    say $impl '    }';
+    say $impl '    *offsetp = base;';
+    say $impl '}';
+
+    $struct{$name} = { size => $size };
+    $t->purge;
+}
+
+sub request {
+    my ($t, $elt) = @_;
+    my $name = $elt->att('name');
+
+    print(" - Request $name\n");
+    $request{$elt->att('opcode')} = $name;
+
+    my $length = 4;
+    my @elements = $elt->children(qr/pad|field|list/);
+
+    # Wireshark defines _U_ to mean "Unused" (compiler specific define)
+    if (!@elements) {
+       print $impl <<eot
+
+static void $header$name(tvbuff_t *tvb _U_, packet_info *pinfo _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_)
+{
+eot
+;
+    } else {
+       print $impl <<eot
+
+static void $header$name(tvbuff_t *tvb, packet_info *pinfo _U_, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+eot
+;
+    }
+    my $varpat = $header.'_'.$name.'_%s';
+    my $humanpat = "$header.$name.%s";
+
+    foreach my $e (@elements) {
+       register_element($e, $varpat, $humanpat);
+    }
+
+    foreach my $e (@elements) {
+       if ($e->name() eq 'list' && $name eq 'Render' && $e->att('name') eq 'data' && -e 'mesa/src/mesa/glapi/gl_API.xml') {
+           # Special case: Use mesa-generated dissector for 'data'
+           print $impl "    dispatch_glx_render(tvb, pinfo, offsetp, t, little_endian, (length - $length));\n";
+       } else {
+           $length = dissect_element($e, $varpat, $length, 1);
+       }
+    }
+
+    say $impl '}';
+
+    my $reply = $elt->first_child('reply');
+    if ($reply) {
+       $reply{$elt->att('opcode')} = $name;
+
+       $varpat = $header.'_'.$name.'_reply_%s';
+       $humanpat = "$header.$name.reply.%s";
+
+       @elements = $reply->children(qr/pad|field|list/);
+
+       # Wireshark defines _U_ to mean "Unused" (compiler specific define)
+       if (!@elements) {
+           say $impl "static void $header$name"."_Reply(tvbuff_t *tvb _U_, packet_info *pinfo, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_)\n{";
+       } else {
+           say $impl "static void $header$name"."_Reply(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian)\n{";
+       }
+       say $impl '    int f_length, length, sequence_number;' if (@elements);
+
+       foreach my $e (@elements) {
+           register_element($e, $varpat, $humanpat);
+       }
+
+       say $impl '';
+       say $impl '    col_append_fstr(pinfo->cinfo, COL_INFO, "-'.$name.'");';
+       say $impl '';
+       say $impl '    REPLY(reply);';
+
+       my $first = 1;
+       my $length = 1;
+       foreach my $e (@elements) {
+           $length = dissect_element($e, $varpat, $length);
+           if ($first) {
+               $first = 0;
+               say $impl '    sequence_number = VALUE16(tvb, *offsetp);';
+               say $impl '    proto_tree_add_uint_format(t, hf_x11_reply_sequencenumber, tvb, *offsetp, 2, sequence_number,';
+               say $impl '            "sequencenumber: %d ('.$header.'-'.$name.')", sequence_number);';
+               say $impl '    *offsetp += 2;';
+
+               say $impl '    f_length = VALUE32(tvb, *offsetp);';
+               say $impl '    length = f_length * 4 + 32;';
+               say $impl '    proto_tree_add_item(t, hf_x11_replylength, tvb, *offsetp, 4, little_endian);';
+               say $impl '    *offsetp += 4;';
+
+               $length += 6;
+           }
+       }
+
+       say $impl '}';
+    }
+    $t->purge;
+}
+
+sub defxid(@) {
+    my $name;
+    while ($name = shift) {
+       $simpletype{$name} = { size => 4, type => 'FT_UINT32',  base => 'BASE_HEX',  get => 'VALUE32', list => 'listOfCard32', };
+    }
+}
+
+sub xidtype {
+    my ($t, $elt) = @_;
+    my $name = $elt->att('name');
+
+    defxid($name);
+
+    $t->purge;
+}
+
+sub typedef {
+    my ($t, $elt) = @_;
+    my $oldname = $elt->att('oldname');
+    my $newname = $elt->att('newname');
+
+    # Duplicate the type
+    my $info = $basictype{$oldname} // $simpletype{$oldname};
+    $simpletype{$newname} = $info;
+
+    $t->purge;
+}
+
+sub error {
+    my ($t, $elt) = @_;
+
+    my $number = $elt->att('number');
+    if ($number >= 0) {
+       my $name = $elt->att('name');
+       print $error "  \"$header-$name\",\n";
+    }
+
+    $t->purge;
+}
+
+sub event {
+    my ($t, $elt) = @_;
+
+    my $number = $elt->att('number');
+    my $name = $elt->att('name');
+
+    $event{$elt->att('number')} = $name;
+
+    my $length = 1;
+    my @elements = $elt->children(qr/pad|field|list/);
+
+    # Wireshark defines _U_ to mean "Unused" (compiler specific define)
+    if (!@elements) {
+       print $impl <<eot
+
+static void $header$name(tvbuff_t *tvb _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_)
+{
+eot
+;
+    } else {
+       print $impl <<eot
+
+static void $header$name(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian)
+{
+eot
+;
+    }
+    
+    my $varpat = $header.'_'.$name.'_%s';
+    my $humanpat = "$header.$name.%s";
+
+    foreach my $e (@elements) {
+       register_element($e, $varpat, $humanpat);
+    }
+
+    my $first = 1;
+    foreach my $e (@elements) {
+       $length = dissect_element($e, $varpat, $length);
+       if ($first) {
+           $first = 0;
+           say $impl "    CARD16(event_sequencenumber);";
+       }
+    }
+
+    print $impl "}\n";
+
+    $t->purge;
+}
+
+sub include
+{
+    my ($t, $elt) = @_;
+    my $include = $elt->text();
+
+    print " - Import $include\n";
+    my $xml = XML::Twig->new(
+               twig_roots => {
+                   'import' => \&include,
+                   'struct' => \&struct,
+                   'xidtype' => \&xidtype,
+                   'xidunion' => \&xidtype,
+                   'typedef' => \&typedef,
+               });
+    $xml->parsefile("xcbproto/src/$include.xml") or die ("Cannot open $include.xml\n");
+
+    $t->purge;
+}
+
+
+sub xcb_start {
+    my ($t, $elt) = @_;
+    $header = $elt->att('header');
+    $extname = ($elt->att('extension-name') or $header);
+
+    print("Extension $extname\n");
+
+    $parentclass = 'XProto';
+    undef %request;
+    undef %event;
+    undef %reply;
+
+    %simpletype = ();
+
+    print $error "const char *$header"."_errors[] = {\n";
+}
+
+sub xcb {
+    my ($t, $elt) = @_;
+
+    my $xextname = $elt->att('extension-xname');
+    my $lookup_name = $header . "_extension_minor";
+    my $error_name = $header . "_errors";
+    my $event_name = $header . "_events";
+    my $reply_name = $header . "_replies";
+
+    print $decl "static int hf_x11_$lookup_name = -1;\n\n";
+
+    print $impl "static const value_string $lookup_name"."[] = {\n";
+    foreach my $req (sort {$a <=> $b} keys %request) {
+       print $impl "    { $req, \"$request{$req}\" },\n";
+    }
+    print $impl "    { 0, NULL }\n";
+    print $impl "};\n";
+
+    say $impl "const x11_event_info $event_name".'[] = {';
+    foreach my $e (sort {$a <=> $b} keys %event) {
+       say $impl "    { \"$header-$event{$e}\", $header$event{$e} },";
+    }
+    say $impl '    { NULL, NULL }';
+    say $impl '};';
+
+    print $impl "static x11_reply_info $reply_name"."[] = {\n";
+    foreach my $e (sort {$a <=> $b} keys %reply) {
+       print $impl "    { $e, $header$reply{$e}_Reply },\n";
+    }
+    print $impl "    { 0, NULL }\n";
+    print $impl "};\n";
+
+    print $reg "{ &hf_x11_$lookup_name, { \"extension-minor\", \"x11.extension-minor\", FT_UINT8, BASE_DEC, VALS($lookup_name), 0, \"minor opcode\", HFILL }},\n\n";
+
+    print $impl <<eot
+
+static void dispatch_$header(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian)
+{
+    int minor, length;
+    minor = CARD8($lookup_name);
+    length = REQUEST_LENGTH();
+
+    col_append_fstr(pinfo->cinfo, COL_INFO, "-%s",
+                         val_to_str(minor, $lookup_name,
+                                    "<Unknown opcode %d>"));
+    switch (minor) {
+eot
+    ;
+
+    foreach my $req (sort {$a <=> $b} keys %request) {
+       print $impl "    case $req:\n";
+       print $impl "\t$header$request{$req}(tvb, pinfo, offsetp, t, little_endian, length);\n";
+       print $impl "\tbreak;\n";
+    }
+    say $impl "    /* No need for a default case here, since Unknown is printed above,";
+    say $impl "       and UNDECODED() is taken care of by dissect_x11_request */";
+    print $impl "    }\n}\n";
+    print $impl <<eot
+
+static void register_$header(void)
+{
+    set_handler("$xextname", dispatch_$header, $error_name, $event_name, $reply_name);
+}
+eot
+    ;
+
+    print $error "  NULL\n};\n\n";
+
+    push @register, $header;
+}
+
+sub add_generated_header {
+    my ($out) = @_;
+
+    print $out <<eot
+/* Do not modify this file. */
+/* It was automatically generated by $0. */
+eot
+    ;
+    # Since this file is checked in, add its SVN revision
+    print $out "/* \$"."Id"."\$ */\n\n";
+
+    # Add license text
+    print $out <<eot
+/*
+ * Copyright 2008, 2009 Open Text Corporation <pharris[AT]opentext.com>
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald[AT]wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+eot
+    ;
+}
+
+# initialize core X11 protocol
+system('./process-x11-fields.pl < x11-fields');
+
+# Extension implementation
+$impl = new IO::File '> x11-extension-implementation.h'
+           or die ("Cannot open x11-extension-implementation.h for writing\n");
+$error = new IO::File '> x11-extension-errors.h'
+           or die ("Cannot open x11-extension-errors.h for writing\n");
+
+add_generated_header($impl);
+add_generated_header($error);
+
+# Open the files generated by process-x11-fields.pl for appending
+$reg = new IO::File '>> x11-register-info.h'
+           or die ("Cannot open x11-register-info.h for appending\n");
+$decl = new IO::File '>> x11-declarations.h'
+           or die ("Cannot open x11-declarations.h for appending\n");
+
+print $reg "\n/* Generated by $0 below this line */\n";
+print $decl "\n/* Generated by $0 below this line */\n";
+
+# Mesa for glRender
+if (-e 'mesa/src/mesa/glapi/gl_API.xml') {
+    $enum = new IO::File '> x11-glx-render-enum.h'
+           or die ("Cannot open x11-glx-render-enum.h for writing\n");
+    add_generated_header($enum);
+    print $enum "static const value_string mesa_enum[] = {\n";
+    print $impl '#include "x11-glx-render-enum.h"'."\n\n";
+
+    print("Mesa glRender:\n");
+    $header = "glx_render";
+
+    my $xml = XML::Twig->new(
+               start_tag_handlers => {
+                   'category' => \&mesa_category_start,
+               },
+               twig_roots => {
+                   'category' => \&mesa_category,
+                   'enum' => \&mesa_enum,
+                   'type' => \&mesa_type,
+                   'function' => \&mesa_function,
+               });
+    $xml->parsefile('mesa/src/mesa/glapi/gl_API.xml') or die ("Cannot open gl_API\n");
+
+    print $enum "    { 0, NULL }\n";
+    print $enum "};\n";
+    $enum->close();
+
+    print $decl "static int hf_x11_glx_render_op_name = -1;\n\n";
+
+    print $impl "static const value_string glx_render_op_name"."[] = {\n";
+    foreach my $req (sort {$a <=> $b} keys %request) {
+       print $impl "    { $req, \"gl$request{$req}\" },\n";
+    }
+    print $impl "    { 0, NULL }\n";
+    print $impl "};\n";
+
+    print $reg "{ &hf_x11_glx_render_op_name, { \"render op\", \"x11.glx.render.op\", FT_UINT16, BASE_DEC, VALS(glx_render_op_name), 0, \"render op\", HFILL }},\n\n";
+
+# Uses ett_x11_list_of_rectangle, since I am unable to see how the subtree type matters.
+    print $impl <<eot
+
+static void dispatch_glx_render(tvbuff_t *tvb, packet_info *pinfo, int *offsetp, proto_tree *t, int little_endian, int length)
+{
+    while (length >= 4) {
+       guint32 op, len;
+       int next;
+       proto_item *ti;
+       proto_tree *tt;
+
+       len = VALUE16(tvb, *offsetp);
+
+       op = VALUE16(tvb, *offsetp + 2);
+       ti = proto_tree_add_uint(t, hf_x11_glx_render_op_name, tvb, *offsetp, len, op);
+       
+       tt = proto_item_add_subtree(ti, ett_x11_list_of_rectangle);
+
+       ti = proto_tree_add_item(tt, hf_x11_request_length, tvb, *offsetp, 2, little_endian);
+       *offsetp += 2;
+       proto_tree_add_item(tt, hf_x11_glx_render_op_name, tvb, *offsetp, 2, little_endian);
+       *offsetp += 2;
+       
+       if (len < 4) {
+           expert_add_info_format(pinfo, ti, PI_MALFORMED, PI_ERROR, "Invalid Length");
+           /* Eat the rest of the packet, mark it undecoded */
+           len = length;
+           op = -1;
+       }
+       len -= 4;
+
+       next = *offsetp + len;
+
+       switch (op) {
+eot
+    ;
+    foreach my $req (sort {$a <=> $b} keys %request) {
+       print $impl "\tcase $req:\n";
+       print $impl "\t    mesa_$request{$req}(tvb, offsetp, tt, little_endian, len);\n";
+       print $impl "\t    break;\n";
+    }
+    print $impl "\tdefault:\n";
+    print $impl "\t    proto_tree_add_item(tt, hf_x11_undecoded, tvb, *offsetp, len, little_endian);\n";
+    print $impl "\t    *offsetp += len;\n";
+
+    print $impl "\t}\n";
+    print $impl "\tif (*offsetp < next) {\n";
+    print $impl "\t    proto_tree_add_item(tt, hf_x11_unused, tvb, *offsetp, next - *offsetp, little_endian);\n";
+    print $impl "\t    *offsetp = next;\n";
+    print $impl "\t}\n";
+    print $impl "\tlength -= (len + 4);\n";
+    print $impl "    }\n}\n";
+}
+
+# XCB
+foreach my $ext (@reslist) {
+    my $xml = XML::Twig->new(
+               start_tag_handlers => {
+                   'xcb' => \&xcb_start,
+               },
+               twig_roots => {
+                   'xcb' => \&xcb,
+                   'import' => \&include,
+                   'request' => \&request,
+                   'struct' => \&struct,
+                   'union' => \&union,
+                   'xidtype' => \&xidtype,
+                   'xidunion' => \&xidtype,
+                   'typedef' => \&typedef,
+                   'error' => \&error,
+                   'errorcopy' => \&error,
+                   'event' => \&event,
+               });
+    $xml->parsefile($ext) or die ("Cannot open $ext\n");
+}
+
+print $impl "static void register_x11_extensions(void)\n{\n";
+foreach my $reg (@register) {
+    print $impl "    register_$reg();\n";
+}
+print $impl "}\n";
diff --git a/epan/dissectors/x11-declarations.h b/epan/dissectors/x11-declarations.h
new file mode 100644 (file)
index 0000000..2240b4e
--- /dev/null
@@ -0,0 +1,4118 @@
+/* Do not modify this file. */
+/* It was automatically generated by ./process-x11-fields.pl. */
+/* $Id$ */
+
+/*
+ * Copyright 2000, Christophe Tronche <ch.tronche[AT]computer.org>
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald[AT]wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+static int hf_x11_above_sibling = -1;
+static int hf_x11_acceleration_denominator = -1;
+static int hf_x11_acceleration_numerator = -1;
+static int hf_x11_access_mode = -1;
+static int hf_x11_address = -1;
+static int hf_x11_ip_address = -1;
+static int hf_x11_address_length = -1;
+static int hf_x11_alloc = -1;
+static int hf_x11_allow_events_mode = -1;
+static int hf_x11_allow_exposures = -1;
+static int hf_x11_arcs = -1;
+static int hf_x11_arc = -1;
+static int hf_x11_arc_x = -1;
+static int hf_x11_arc_y = -1;
+static int hf_x11_arc_width = -1;
+static int hf_x11_arc_height = -1;
+static int hf_x11_arc_angle1 = -1;
+static int hf_x11_arc_angle2 = -1;
+static int hf_x11_arc_mode = -1;
+static int hf_x11_atom = -1;
+static int hf_x11_authorization_protocol_name_length = -1;
+static int hf_x11_authorization_protocol_name = -1;
+static int hf_x11_authorization_protocol_data_length = -1;
+static int hf_x11_authorization_protocol_data = -1;
+static int hf_x11_auto_repeat_mode = -1;
+static int hf_x11_bitmap_format_bit_order = -1;
+static int hf_x11_bitmap_format_scanline_pad = -1;
+static int hf_x11_bitmap_format_scanline_unit = -1;
+static int hf_x11_bytes_after = -1;
+static int hf_x11_back_blue = -1;
+static int hf_x11_back_green = -1;
+static int hf_x11_back_red = -1;
+static int hf_x11_background = -1;
+static int hf_x11_background_pixel = -1;
+static int hf_x11_background_pixmap = -1;
+static int hf_x11_backing_pixel = -1;
+static int hf_x11_backing_planes = -1;
+static int hf_x11_backing_store = -1;
+static int hf_x11_bell_duration = -1;
+static int hf_x11_bell_percent = -1;
+static int hf_x11_bell_pitch = -1;
+static int hf_x11_bit_gravity = -1;
+static int hf_x11_bit_plane = -1;
+static int hf_x11_blue = -1;
+static int hf_x11_blues = -1;
+static int hf_x11_border_pixel = -1;
+static int hf_x11_border_pixmap = -1;
+static int hf_x11_border_width = -1;
+static int hf_x11_button = -1;
+static int hf_x11_byte_order = -1;
+static int hf_x11_childwindow = -1;
+static int hf_x11_cap_style = -1;
+static int hf_x11_change_host_mode = -1;
+static int hf_x11_cid = -1;
+static int hf_x11_class = -1;
+static int hf_x11_clip_mask = -1;
+static int hf_x11_clip_x_origin = -1;
+static int hf_x11_clip_y_origin = -1;
+static int hf_x11_close_down_mode = -1;
+static int hf_x11_cmap = -1;
+static int hf_x11_colormap = -1;
+static int hf_x11_colormap_state = -1;
+static int hf_x11_color_items = -1;
+static int hf_x11_coloritem = -1;
+static int hf_x11_coloritem_pixel = -1;
+static int hf_x11_coloritem_red = -1;
+static int hf_x11_coloritem_green = -1;
+static int hf_x11_coloritem_blue = -1;
+static int hf_x11_coloritem_flags = -1;
+static int hf_x11_coloritem_flags_do_red = -1;
+static int hf_x11_coloritem_flags_do_green = -1;
+static int hf_x11_coloritem_flags_do_blue = -1;
+static int hf_x11_coloritem_flags_unused = -1;
+static int hf_x11_coloritem_unused = -1;
+static int hf_x11_colors = -1;
+static int hf_x11_configure_window_mask = -1;
+static int hf_x11_configure_window_mask_x = -1;
+static int hf_x11_configure_window_mask_y = -1;
+static int hf_x11_configure_window_mask_width = -1;
+static int hf_x11_configure_window_mask_height = -1;
+static int hf_x11_configure_window_mask_border_width = -1;
+static int hf_x11_configure_window_mask_sibling = -1;
+static int hf_x11_configure_window_mask_stack_mode = -1;
+static int hf_x11_confine_to = -1;
+static int hf_x11_contiguous = -1;
+static int hf_x11_coordinate_mode = -1;
+static int hf_x11_count = -1;
+static int hf_x11_cursor = -1;
+static int hf_x11_dash_offset = -1;
+static int hf_x11_dashes = -1;
+static int hf_x11_dashes_length = -1;
+static int hf_x11_do_acceleration = -1;
+static int hf_x11_do_threshold = -1;
+static int hf_x11_detail = -1;
+static int hf_x11_do_not_propagate_mask = -1;
+static int hf_x11_do_not_propagate_mask_KeyPress = -1;
+static int hf_x11_do_not_propagate_mask_KeyRelease = -1;
+static int hf_x11_do_not_propagate_mask_ButtonPress = -1;
+static int hf_x11_do_not_propagate_mask_ButtonRelease = -1;
+static int hf_x11_do_not_propagate_mask_PointerMotion = -1;
+static int hf_x11_do_not_propagate_mask_Button1Motion = -1;
+static int hf_x11_do_not_propagate_mask_Button2Motion = -1;
+static int hf_x11_do_not_propagate_mask_Button3Motion = -1;
+static int hf_x11_do_not_propagate_mask_Button4Motion = -1;
+static int hf_x11_do_not_propagate_mask_Button5Motion = -1;
+static int hf_x11_do_not_propagate_mask_ButtonMotion = -1;
+static int hf_x11_do_not_propagate_mask_erroneous_bits = -1;
+static int hf_x11_event_sequencenumber = -1;
+static int hf_x11_error = -1;
+static int hf_x11_error_badvalue = -1;
+static int hf_x11_error_sequencenumber = -1;
+static int hf_x11_errorcode = -1;
+static int hf_x11_event_x = -1;
+static int hf_x11_event_y = -1;
+static int hf_x11_eventbutton = -1;
+static int hf_x11_eventcode = -1;
+static int hf_x11_eventwindow = -1;
+static int hf_x11_first_event = -1;
+static int hf_x11_first_error = -1;
+static int hf_x11_gc_dashes = -1;
+static int hf_x11_gc_value_mask = -1;
+static int hf_x11_gc_value_mask_function = -1;
+static int hf_x11_gc_value_mask_plane_mask = -1;
+static int hf_x11_gc_value_mask_foreground = -1;
+static int hf_x11_gc_value_mask_background = -1;
+static int hf_x11_gc_value_mask_line_width = -1;
+static int hf_x11_gc_value_mask_line_style = -1;
+static int hf_x11_gc_value_mask_cap_style = -1;
+static int hf_x11_gc_value_mask_join_style = -1;
+static int hf_x11_gc_value_mask_fill_style = -1;
+static int hf_x11_gc_value_mask_fill_rule = -1;
+static int hf_x11_gc_value_mask_tile = -1;
+static int hf_x11_gc_value_mask_stipple = -1;
+static int hf_x11_gc_value_mask_tile_stipple_x_origin = -1;
+static int hf_x11_gc_value_mask_tile_stipple_y_origin = -1;
+static int hf_x11_gc_value_mask_font = -1;
+static int hf_x11_gc_value_mask_subwindow_mode = -1;
+static int hf_x11_gc_value_mask_graphics_exposures = -1;
+static int hf_x11_gc_value_mask_clip_x_origin = -1;
+static int hf_x11_gc_value_mask_clip_y_origin = -1;
+static int hf_x11_gc_value_mask_clip_mask = -1;
+static int hf_x11_gc_value_mask_dash_offset = -1;
+static int hf_x11_gc_value_mask_gc_dashes = -1;
+static int hf_x11_gc_value_mask_arc_mode = -1;
+static int hf_x11_green = -1;
+static int hf_x11_greens = -1;
+static int hf_x11_data = -1;
+static int hf_x11_data_length = -1;
+static int hf_x11_delete = -1;
+static int hf_x11_delta = -1;
+static int hf_x11_depth = -1;
+static int hf_x11_destination = -1;
+static int hf_x11_direction = -1;
+static int hf_x11_drawable = -1;
+static int hf_x11_dst_drawable = -1;
+static int hf_x11_dst_gc = -1;
+static int hf_x11_dst_window = -1;
+static int hf_x11_dst_x = -1;
+static int hf_x11_dst_y = -1;
+static int hf_x11_event_detail = -1;
+static int hf_x11_event_mask = -1;
+static int hf_x11_event_mask_KeyPress = -1;
+static int hf_x11_event_mask_KeyRelease = -1;
+static int hf_x11_event_mask_ButtonPress = -1;
+static int hf_x11_event_mask_ButtonRelease = -1;
+static int hf_x11_event_mask_EnterWindow = -1;
+static int hf_x11_event_mask_LeaveWindow = -1;
+static int hf_x11_event_mask_PointerMotion = -1;
+static int hf_x11_event_mask_PointerMotionHint = -1;
+static int hf_x11_event_mask_Button1Motion = -1;
+static int hf_x11_event_mask_Button2Motion = -1;
+static int hf_x11_event_mask_Button3Motion = -1;
+static int hf_x11_event_mask_Button4Motion = -1;
+static int hf_x11_event_mask_Button5Motion = -1;
+static int hf_x11_event_mask_ButtonMotion = -1;
+static int hf_x11_event_mask_KeymapState = -1;
+static int hf_x11_event_mask_Exposure = -1;
+static int hf_x11_event_mask_VisibilityChange = -1;
+static int hf_x11_event_mask_StructureNotify = -1;
+static int hf_x11_event_mask_ResizeRedirect = -1;
+static int hf_x11_event_mask_SubstructureNotify = -1;
+static int hf_x11_event_mask_SubstructureRedirect = -1;
+static int hf_x11_event_mask_FocusChange = -1;
+static int hf_x11_event_mask_PropertyChange = -1;
+static int hf_x11_event_mask_ColormapChange = -1;
+static int hf_x11_event_mask_OwnerGrabButton = -1;
+static int hf_x11_event_mask_erroneous_bits = -1;
+static int hf_x11_exact_blue = -1;
+static int hf_x11_exact_green = -1;
+static int hf_x11_exact_red = -1;
+static int hf_x11_exposures = -1;
+static int hf_x11_family = -1;
+static int hf_x11_fid = -1;
+static int hf_x11_fill_rule = -1;
+static int hf_x11_fill_style = -1;
+static int hf_x11_first_keycode = -1;
+static int hf_x11_focus = -1;
+static int hf_x11_focus_detail = -1;
+static int hf_x11_focus_mode = -1;
+static int hf_x11_font = -1;
+static int hf_x11_fore_blue = -1;
+static int hf_x11_fore_green = -1;
+static int hf_x11_fore_red = -1;
+static int hf_x11_foreground = -1;
+static int hf_x11_format = -1;
+static int hf_x11_from_configure = -1;
+static int hf_x11_function = -1;
+static int hf_x11_gc = -1;
+static int hf_x11_get_property_type = -1;
+static int hf_x11_grab_mode = -1;
+static int hf_x11_grab_status = -1;
+static int hf_x11_grab_window = -1;
+static int hf_x11_graphics_exposures = -1;
+static int hf_x11_height = -1;
+static int hf_x11_image_byte_order = -1;
+static int hf_x11_initial_connection = -1;
+static int hf_x11_image_format = -1;
+static int hf_x11_image_pixmap_format = -1;
+static int hf_x11_interval = -1;
+static int hf_x11_items = -1;
+static int hf_x11_join_style = -1;
+static int hf_x11_key = -1;
+static int hf_x11_key_click_percent = -1;
+static int hf_x11_keyboard_key = -1;
+static int hf_x11_keyboard_mode = -1;
+static int hf_x11_keybut_mask_erroneous_bits = -1;
+static int hf_x11_keycode = -1;
+static int hf_x11_keyboard_value_mask = -1;
+static int hf_x11_keyboard_value_mask_key_click_percent = -1;
+static int hf_x11_keyboard_value_mask_bell_percent = -1;
+static int hf_x11_keyboard_value_mask_bell_pitch = -1;
+static int hf_x11_keyboard_value_mask_bell_duration = -1;
+static int hf_x11_keyboard_value_mask_led = -1;
+static int hf_x11_keyboard_value_mask_led_mode = -1;
+static int hf_x11_keyboard_value_mask_keyboard_key = -1;
+static int hf_x11_keyboard_value_mask_auto_repeat_mode = -1;
+static int hf_x11_keycode_count = -1;
+static int hf_x11_keycodes = -1;
+static int hf_x11_keycodes_item = -1;
+static int hf_x11_keycodes_per_modifier = -1;
+static int hf_x11_keys = -1;
+static int hf_x11_keysyms = -1;
+static int hf_x11_keysyms_item = -1;
+static int hf_x11_keysyms_item_keysym = -1;
+static int hf_x11_keysyms_per_keycode = -1;
+static int hf_x11_length_of_reason = -1;
+static int hf_x11_length_of_vendor = -1;
+static int hf_x11_led = -1;
+static int hf_x11_led_mode = -1;
+static int hf_x11_left_pad = -1;
+static int hf_x11_line_style = -1;
+static int hf_x11_line_width = -1;
+static int hf_x11_long_length = -1;
+static int hf_x11_long_offset = -1;
+static int hf_x11_map = -1;
+static int hf_x11_map_length = -1;
+static int hf_x11_mapping_request = -1;
+static int hf_x11_mask = -1;
+static int hf_x11_mask_char = -1;
+static int hf_x11_mask_font = -1;
+static int hf_x11_max_names = -1;
+static int hf_x11_mid = -1;
+static int hf_x11_mode = -1;
+static int hf_x11_major_opcode = -1;
+static int hf_x11_max_keycode = -1;
+static int hf_x11_maximum_request_length = -1;
+static int hf_x11_min_keycode = -1;
+static int hf_x11_minor_opcode = -1;
+static int hf_x11_modifiers_mask = -1;
+static int hf_x11_modifiers_mask_Shift = -1;
+static int hf_x11_modifiers_mask_Lock = -1;
+static int hf_x11_modifiers_mask_Control = -1;
+static int hf_x11_modifiers_mask_Mod1 = -1;
+static int hf_x11_modifiers_mask_Mod2 = -1;
+static int hf_x11_modifiers_mask_Mod3 = -1;
+static int hf_x11_modifiers_mask_Mod4 = -1;
+static int hf_x11_modifiers_mask_Mod5 = -1;
+static int hf_x11_modifiers_mask_Button1 = -1;
+static int hf_x11_modifiers_mask_Button2 = -1;
+static int hf_x11_modifiers_mask_Button3 = -1;
+static int hf_x11_modifiers_mask_Button4 = -1;
+static int hf_x11_modifiers_mask_Button5 = -1;
+static int hf_x11_modifiers_mask_AnyModifier = -1;
+static int hf_x11_modifiers_mask_erroneous_bits = -1;
+static int hf_x11_motion_buffer_size = -1;
+static int hf_x11_new = -1;
+static int hf_x11_number_of_formats_in_pixmap_formats = -1;
+static int hf_x11_number_of_screens_in_roots = -1;
+static int hf_x11_name = -1;
+static int hf_x11_name_length = -1;
+static int hf_x11_odd_length = -1;
+static int hf_x11_only_if_exists = -1;
+static int hf_x11_opcode = -1;
+static int hf_x11_ordering = -1;
+static int hf_x11_override_redirect = -1;
+static int hf_x11_owner = -1;
+static int hf_x11_owner_events = -1;
+static int hf_x11_parent = -1;
+static int hf_x11_path = -1;
+static int hf_x11_path_string = -1;
+static int hf_x11_pattern = -1;
+static int hf_x11_pattern_length = -1;
+static int hf_x11_percent = -1;
+static int hf_x11_pid = -1;
+static int hf_x11_pixel = -1;
+static int hf_x11_pixels = -1;
+static int hf_x11_pixels_item = -1;
+static int hf_x11_pixmap = -1;
+static int hf_x11_place = -1;
+static int hf_x11_plane_mask = -1;
+static int hf_x11_planes = -1;
+static int hf_x11_point = -1;
+static int hf_x11_points = -1;
+static int hf_x11_point_x = -1;
+static int hf_x11_point_y = -1;
+static int hf_x11_pointer_event_mask = -1;
+static int hf_x11_pointer_event_mask_ButtonPress = -1;
+static int hf_x11_pointer_event_mask_ButtonRelease = -1;
+static int hf_x11_pointer_event_mask_EnterWindow = -1;
+static int hf_x11_pointer_event_mask_LeaveWindow = -1;
+static int hf_x11_pointer_event_mask_PointerMotion = -1;
+static int hf_x11_pointer_event_mask_PointerMotionHint = -1;
+static int hf_x11_pointer_event_mask_Button1Motion = -1;
+static int hf_x11_pointer_event_mask_Button2Motion = -1;
+static int hf_x11_pointer_event_mask_Button3Motion = -1;
+static int hf_x11_pointer_event_mask_Button4Motion = -1;
+static int hf_x11_pointer_event_mask_Button5Motion = -1;
+static int hf_x11_pointer_event_mask_ButtonMotion = -1;
+static int hf_x11_pointer_event_mask_KeymapState = -1;
+static int hf_x11_pointer_event_mask_erroneous_bits = -1;
+static int hf_x11_pointer_mode = -1;
+static int hf_x11_prefer_blanking = -1;
+static int hf_x11_present = -1;
+static int hf_x11_propagate = -1;
+static int hf_x11_properties = -1;
+static int hf_x11_properties_item = -1;
+static int hf_x11_property = -1;
+static int hf_x11_property_number = -1;
+static int hf_x11_property_state = -1;
+static int hf_x11_protocol_major_version = -1;
+static int hf_x11_protocol_minor_version = -1;
+static int hf_x11_reason = -1;
+static int hf_x11_rectangle_height = -1;
+static int hf_x11_rectangles = -1;
+static int hf_x11_rectangle = -1;
+static int hf_x11_rectangle_width = -1;
+static int hf_x11_rectangle_x = -1;
+static int hf_x11_rectangle_y = -1;
+static int hf_x11_red = -1;
+static int hf_x11_reds = -1;
+static int hf_x11_request = -1;
+static int hf_x11_requestor = -1;
+static int hf_x11_request_length = -1;
+static int hf_x11_resource = -1;
+static int hf_x11_revert_to = -1;
+static int hf_x11_release_number = -1;
+static int hf_x11_reply = -1;
+static int hf_x11_reply_sequencenumber = -1;
+static int hf_x11_replylength = -1;
+static int hf_x11_replyopcode = -1;
+static int hf_x11_resource_id_base = -1;
+static int hf_x11_resource_id_mask = -1;
+static int hf_x11_root_x = -1;
+static int hf_x11_root_y = -1;
+static int hf_x11_rootwindow = -1;
+static int hf_x11_same_screen = -1;
+static int hf_x11_same_screen_focus_mask = -1;
+static int hf_x11_same_screen_focus_mask_focus = -1;
+static int hf_x11_same_screen_focus_mask_same_screen = -1;
+static int hf_x11_success = -1;
+static int hf_x11_save_set_mode = -1;
+static int hf_x11_save_under = -1;
+static int hf_x11_screen_saver_mode = -1;
+static int hf_x11_segment = -1;
+static int hf_x11_segments = -1;
+static int hf_x11_segment_x1 = -1;
+static int hf_x11_segment_x2 = -1;
+static int hf_x11_segment_y1 = -1;
+static int hf_x11_segment_y2 = -1;
+static int hf_x11_selection = -1;
+static int hf_x11_shape = -1;
+static int hf_x11_sibling = -1;
+static int hf_x11_source_pixmap = -1;
+static int hf_x11_source_font = -1;
+static int hf_x11_source_char = -1;
+static int hf_x11_src_cmap = -1;
+static int hf_x11_src_drawable = -1;
+static int hf_x11_src_gc = -1;
+static int hf_x11_src_height = -1;
+static int hf_x11_src_width = -1;
+static int hf_x11_src_window = -1;
+static int hf_x11_src_x = -1;
+static int hf_x11_src_y = -1;
+static int hf_x11_start = -1;
+static int hf_x11_stack_mode = -1;
+static int hf_x11_stipple = -1;
+static int hf_x11_stop = -1;
+static int hf_x11_str_number_in_path = -1;
+static int hf_x11_string = -1;
+static int hf_x11_string16 = -1;
+static int hf_x11_string16_bytes = -1;
+static int hf_x11_string_length = -1;
+static int hf_x11_subwindow_mode = -1;
+static int hf_x11_target = -1;
+static int hf_x11_textitem = -1;
+static int hf_x11_textitem_font = -1;
+static int hf_x11_textitem_string = -1;
+static int hf_x11_textitem_string_delta = -1;
+static int hf_x11_textitem_string_string8 = -1;
+static int hf_x11_textitem_string_string16 = -1;
+static int hf_x11_textitem_string_string16_bytes = -1;
+static int hf_x11_threshold = -1;
+static int hf_x11_tile = -1;
+static int hf_x11_tile_stipple_x_origin = -1;
+static int hf_x11_tile_stipple_y_origin = -1;
+static int hf_x11_time = -1;
+static int hf_x11_timeout = -1;
+static int hf_x11_type = -1;
+static int hf_x11_undecoded = -1;
+static int hf_x11_unused = -1;
+static int hf_x11_valuelength = -1;
+static int hf_x11_vendor = -1;
+static int hf_x11_visibility_state = -1;
+static int hf_x11_visual = -1;
+static int hf_x11_visual_blue = -1;
+static int hf_x11_visual_green = -1;
+static int hf_x11_visual_red = -1;
+static int hf_x11_visualid = -1;
+static int hf_x11_warp_pointer_dst_window = -1;
+static int hf_x11_warp_pointer_src_window = -1;
+static int hf_x11_wid = -1;
+static int hf_x11_width = -1;
+static int hf_x11_win_gravity = -1;
+static int hf_x11_win_x = -1;
+static int hf_x11_win_y = -1;
+static int hf_x11_window = -1;
+static int hf_x11_window_class = -1;
+static int hf_x11_window_value_mask = -1;
+static int hf_x11_window_value_mask_background_pixmap = -1;
+static int hf_x11_window_value_mask_background_pixel = -1;
+static int hf_x11_window_value_mask_border_pixmap = -1;
+static int hf_x11_window_value_mask_border_pixel = -1;
+static int hf_x11_window_value_mask_bit_gravity = -1;
+static int hf_x11_window_value_mask_win_gravity = -1;
+static int hf_x11_window_value_mask_backing_store = -1;
+static int hf_x11_window_value_mask_backing_planes = -1;
+static int hf_x11_window_value_mask_backing_pixel = -1;
+static int hf_x11_window_value_mask_override_redirect = -1;
+static int hf_x11_window_value_mask_save_under = -1;
+static int hf_x11_window_value_mask_event_mask = -1;
+static int hf_x11_window_value_mask_do_not_propagate_mask = -1;
+static int hf_x11_window_value_mask_colormap = -1;
+static int hf_x11_window_value_mask_cursor = -1;
+static int hf_x11_x = -1;
+static int hf_x11_y = -1;
+
+/* Generated by process-x11-xcb.pl below this line */
+static int hf_x11_glx_render_CallList_list = -1;
+static int hf_x11_glx_render_CallLists_n = -1;
+static int hf_x11_glx_render_CallLists_type = -1;
+static int hf_x11_glx_render_CallLists_lists = -1;
+static int hf_x11_glx_render_ListBase_base = -1;
+static int hf_x11_glx_render_Begin_mode = -1;
+static int hf_x11_glx_render_Bitmap_width = -1;
+static int hf_x11_glx_render_Bitmap_height = -1;
+static int hf_x11_glx_render_Bitmap_xorig = -1;
+static int hf_x11_glx_render_Bitmap_yorig = -1;
+static int hf_x11_glx_render_Bitmap_xmove = -1;
+static int hf_x11_glx_render_Bitmap_ymove = -1;
+static int hf_x11_glx_render_Bitmap_bitmap = -1;
+static int hf_x11_glx_render_Bitmap_swapbytes = -1;
+static int hf_x11_glx_render_Bitmap_lsbfirst = -1;
+static int hf_x11_glx_render_Bitmap_rowlength = -1;
+static int hf_x11_glx_render_Bitmap_skiprows = -1;
+static int hf_x11_glx_render_Bitmap_skippixels = -1;
+static int hf_x11_glx_render_Bitmap_alignment = -1;
+static int hf_x11_glx_render_Color3bv_v = -1;
+static int hf_x11_glx_render_Color3dv_v = -1;
+static int hf_x11_glx_render_Color3dv_v_item = -1;
+static int hf_x11_glx_render_Color3fv_v = -1;
+static int hf_x11_glx_render_Color3fv_v_item = -1;
+static int hf_x11_glx_render_Color3iv_v = -1;
+static int hf_x11_glx_render_Color3iv_v_item = -1;
+static int hf_x11_glx_render_Color3sv_v = -1;
+static int hf_x11_glx_render_Color3sv_v_item = -1;
+static int hf_x11_glx_render_Color3ubv_v = -1;
+static int hf_x11_glx_render_Color3uiv_v = -1;
+static int hf_x11_glx_render_Color3uiv_v_item = -1;
+static int hf_x11_glx_render_Color3usv_v = -1;
+static int hf_x11_glx_render_Color3usv_v_item = -1;
+static int hf_x11_glx_render_Color4bv_v = -1;
+static int hf_x11_glx_render_Color4dv_v = -1;
+static int hf_x11_glx_render_Color4dv_v_item = -1;
+static int hf_x11_glx_render_Color4fv_v = -1;
+static int hf_x11_glx_render_Color4fv_v_item = -1;
+static int hf_x11_glx_render_Color4iv_v = -1;
+static int hf_x11_glx_render_Color4iv_v_item = -1;
+static int hf_x11_glx_render_Color4sv_v = -1;
+static int hf_x11_glx_render_Color4sv_v_item = -1;
+static int hf_x11_glx_render_Color4ubv_v = -1;
+static int hf_x11_glx_render_Color4uiv_v = -1;
+static int hf_x11_glx_render_Color4uiv_v_item = -1;
+static int hf_x11_glx_render_Color4usv_v = -1;
+static int hf_x11_glx_render_Color4usv_v_item = -1;
+static int hf_x11_glx_render_EdgeFlagv_flag = -1;
+static int hf_x11_glx_render_Indexdv_c = -1;
+static int hf_x11_glx_render_Indexdv_c_item = -1;
+static int hf_x11_glx_render_Indexfv_c = -1;
+static int hf_x11_glx_render_Indexfv_c_item = -1;
+static int hf_x11_glx_render_Indexiv_c = -1;
+static int hf_x11_glx_render_Indexiv_c_item = -1;
+static int hf_x11_glx_render_Indexsv_c = -1;
+static int hf_x11_glx_render_Indexsv_c_item = -1;
+static int hf_x11_glx_render_Normal3bv_v = -1;
+static int hf_x11_glx_render_Normal3dv_v = -1;
+static int hf_x11_glx_render_Normal3dv_v_item = -1;
+static int hf_x11_glx_render_Normal3fv_v = -1;
+static int hf_x11_glx_render_Normal3fv_v_item = -1;
+static int hf_x11_glx_render_Normal3iv_v = -1;
+static int hf_x11_glx_render_Normal3iv_v_item = -1;
+static int hf_x11_glx_render_Normal3sv_v = -1;
+static int hf_x11_glx_render_Normal3sv_v_item = -1;
+static int hf_x11_glx_render_RasterPos2dv_v = -1;
+static int hf_x11_glx_render_RasterPos2dv_v_item = -1;
+static int hf_x11_glx_render_RasterPos2fv_v = -1;
+static int hf_x11_glx_render_RasterPos2fv_v_item = -1;
+static int hf_x11_glx_render_RasterPos2iv_v = -1;
+static int hf_x11_glx_render_RasterPos2iv_v_item = -1;
+static int hf_x11_glx_render_RasterPos2sv_v = -1;
+static int hf_x11_glx_render_RasterPos2sv_v_item = -1;
+static int hf_x11_glx_render_RasterPos3dv_v = -1;
+static int hf_x11_glx_render_RasterPos3dv_v_item = -1;
+static int hf_x11_glx_render_RasterPos3fv_v = -1;
+static int hf_x11_glx_render_RasterPos3fv_v_item = -1;
+static int hf_x11_glx_render_RasterPos3iv_v = -1;
+static int hf_x11_glx_render_RasterPos3iv_v_item = -1;
+static int hf_x11_glx_render_RasterPos3sv_v = -1;
+static int hf_x11_glx_render_RasterPos3sv_v_item = -1;
+static int hf_x11_glx_render_RasterPos4dv_v = -1;
+static int hf_x11_glx_render_RasterPos4dv_v_item = -1;
+static int hf_x11_glx_render_RasterPos4fv_v = -1;
+static int hf_x11_glx_render_RasterPos4fv_v_item = -1;
+static int hf_x11_glx_render_RasterPos4iv_v = -1;
+static int hf_x11_glx_render_RasterPos4iv_v_item = -1;
+static int hf_x11_glx_render_RasterPos4sv_v = -1;
+static int hf_x11_glx_render_RasterPos4sv_v_item = -1;
+static int hf_x11_glx_render_Rectdv_v1 = -1;
+static int hf_x11_glx_render_Rectdv_v1_item = -1;
+static int hf_x11_glx_render_Rectdv_v2 = -1;
+static int hf_x11_glx_render_Rectdv_v2_item = -1;
+static int hf_x11_glx_render_Rectfv_v1 = -1;
+static int hf_x11_glx_render_Rectfv_v1_item = -1;
+static int hf_x11_glx_render_Rectfv_v2 = -1;
+static int hf_x11_glx_render_Rectfv_v2_item = -1;
+static int hf_x11_glx_render_Rectiv_v1 = -1;
+static int hf_x11_glx_render_Rectiv_v1_item = -1;
+static int hf_x11_glx_render_Rectiv_v2 = -1;
+static int hf_x11_glx_render_Rectiv_v2_item = -1;
+static int hf_x11_glx_render_Rectsv_v1 = -1;
+static int hf_x11_glx_render_Rectsv_v1_item = -1;
+static int hf_x11_glx_render_Rectsv_v2 = -1;
+static int hf_x11_glx_render_Rectsv_v2_item = -1;
+static int hf_x11_glx_render_TexCoord1dv_v = -1;
+static int hf_x11_glx_render_TexCoord1dv_v_item = -1;
+static int hf_x11_glx_render_TexCoord1fv_v = -1;
+static int hf_x11_glx_render_TexCoord1fv_v_item = -1;
+static int hf_x11_glx_render_TexCoord1iv_v = -1;
+static int hf_x11_glx_render_TexCoord1iv_v_item = -1;
+static int hf_x11_glx_render_TexCoord1sv_v = -1;
+static int hf_x11_glx_render_TexCoord1sv_v_item = -1;
+static int hf_x11_glx_render_TexCoord2dv_v = -1;
+static int hf_x11_glx_render_TexCoord2dv_v_item = -1;
+static int hf_x11_glx_render_TexCoord2fv_v = -1;
+static int hf_x11_glx_render_TexCoord2fv_v_item = -1;
+static int hf_x11_glx_render_TexCoord2iv_v = -1;
+static int hf_x11_glx_render_TexCoord2iv_v_item = -1;
+static int hf_x11_glx_render_TexCoord2sv_v = -1;
+static int hf_x11_glx_render_TexCoord2sv_v_item = -1;
+static int hf_x11_glx_render_TexCoord3dv_v = -1;
+static int hf_x11_glx_render_TexCoord3dv_v_item = -1;
+static int hf_x11_glx_render_TexCoord3fv_v = -1;
+static int hf_x11_glx_render_TexCoord3fv_v_item = -1;
+static int hf_x11_glx_render_TexCoord3iv_v = -1;
+static int hf_x11_glx_render_TexCoord3iv_v_item = -1;
+static int hf_x11_glx_render_TexCoord3sv_v = -1;
+static int hf_x11_glx_render_TexCoord3sv_v_item = -1;
+static int hf_x11_glx_render_TexCoord4dv_v = -1;
+static int hf_x11_glx_render_TexCoord4dv_v_item = -1;
+static int hf_x11_glx_render_TexCoord4fv_v = -1;
+static int hf_x11_glx_render_TexCoord4fv_v_item = -1;
+static int hf_x11_glx_render_TexCoord4iv_v = -1;
+static int hf_x11_glx_render_TexCoord4iv_v_item = -1;
+static int hf_x11_glx_render_TexCoord4sv_v = -1;
+static int hf_x11_glx_render_TexCoord4sv_v_item = -1;
+static int hf_x11_glx_render_Vertex2dv_v = -1;
+static int hf_x11_glx_render_Vertex2dv_v_item = -1;
+static int hf_x11_glx_render_Vertex2fv_v = -1;
+static int hf_x11_glx_render_Vertex2fv_v_item = -1;
+static int hf_x11_glx_render_Vertex2iv_v = -1;
+static int hf_x11_glx_render_Vertex2iv_v_item = -1;
+static int hf_x11_glx_render_Vertex2sv_v = -1;
+static int hf_x11_glx_render_Vertex2sv_v_item = -1;
+static int hf_x11_glx_render_Vertex3dv_v = -1;
+static int hf_x11_glx_render_Vertex3dv_v_item = -1;
+static int hf_x11_glx_render_Vertex3fv_v = -1;
+static int hf_x11_glx_render_Vertex3fv_v_item = -1;
+static int hf_x11_glx_render_Vertex3iv_v = -1;
+static int hf_x11_glx_render_Vertex3iv_v_item = -1;
+static int hf_x11_glx_render_Vertex3sv_v = -1;
+static int hf_x11_glx_render_Vertex3sv_v_item = -1;
+static int hf_x11_glx_render_Vertex4dv_v = -1;
+static int hf_x11_glx_render_Vertex4dv_v_item = -1;
+static int hf_x11_glx_render_Vertex4fv_v = -1;
+static int hf_x11_glx_render_Vertex4fv_v_item = -1;
+static int hf_x11_glx_render_Vertex4iv_v = -1;
+static int hf_x11_glx_render_Vertex4iv_v_item = -1;
+static int hf_x11_glx_render_Vertex4sv_v = -1;
+static int hf_x11_glx_render_Vertex4sv_v_item = -1;
+static int hf_x11_glx_render_ClipPlane_plane = -1;
+static int hf_x11_glx_render_ClipPlane_equation = -1;
+static int hf_x11_glx_render_ClipPlane_equation_item = -1;
+static int hf_x11_glx_render_ColorMaterial_face = -1;
+static int hf_x11_glx_render_ColorMaterial_mode = -1;
+static int hf_x11_glx_render_CullFace_mode = -1;
+static int hf_x11_glx_render_Fogf_pname = -1;
+static int hf_x11_glx_render_Fogf_param = -1;
+static int hf_x11_glx_render_Fogfv_pname = -1;
+static int hf_x11_glx_render_Fogfv_params = -1;
+static int hf_x11_glx_render_Fogfv_params_item = -1;
+static int hf_x11_glx_render_Fogi_pname = -1;
+static int hf_x11_glx_render_Fogi_param = -1;
+static int hf_x11_glx_render_Fogiv_pname = -1;
+static int hf_x11_glx_render_Fogiv_params = -1;
+static int hf_x11_glx_render_Fogiv_params_item = -1;
+static int hf_x11_glx_render_FrontFace_mode = -1;
+static int hf_x11_glx_render_Hint_target = -1;
+static int hf_x11_glx_render_Hint_mode = -1;
+static int hf_x11_glx_render_Lightf_light = -1;
+static int hf_x11_glx_render_Lightf_pname = -1;
+static int hf_x11_glx_render_Lightf_param = -1;
+static int hf_x11_glx_render_Lightfv_light = -1;
+static int hf_x11_glx_render_Lightfv_pname = -1;
+static int hf_x11_glx_render_Lightfv_params = -1;
+static int hf_x11_glx_render_Lightfv_params_item = -1;
+static int hf_x11_glx_render_Lighti_light = -1;
+static int hf_x11_glx_render_Lighti_pname = -1;
+static int hf_x11_glx_render_Lighti_param = -1;
+static int hf_x11_glx_render_Lightiv_light = -1;
+static int hf_x11_glx_render_Lightiv_pname = -1;
+static int hf_x11_glx_render_Lightiv_params = -1;
+static int hf_x11_glx_render_Lightiv_params_item = -1;
+static int hf_x11_glx_render_LightModelf_pname = -1;
+static int hf_x11_glx_render_LightModelf_param = -1;
+static int hf_x11_glx_render_LightModelfv_pname = -1;
+static int hf_x11_glx_render_LightModelfv_params = -1;
+static int hf_x11_glx_render_LightModelfv_params_item = -1;
+static int hf_x11_glx_render_LightModeli_pname = -1;
+static int hf_x11_glx_render_LightModeli_param = -1;
+static int hf_x11_glx_render_LightModeliv_pname = -1;
+static int hf_x11_glx_render_LightModeliv_params = -1;
+static int hf_x11_glx_render_LightModeliv_params_item = -1;
+static int hf_x11_glx_render_LineStipple_factor = -1;
+static int hf_x11_glx_render_LineStipple_pattern = -1;
+static int hf_x11_glx_render_LineWidth_width = -1;
+static int hf_x11_glx_render_Materialf_face = -1;
+static int hf_x11_glx_render_Materialf_pname = -1;
+static int hf_x11_glx_render_Materialf_param = -1;
+static int hf_x11_glx_render_Materialfv_face = -1;
+static int hf_x11_glx_render_Materialfv_pname = -1;
+static int hf_x11_glx_render_Materialfv_params = -1;
+static int hf_x11_glx_render_Materialfv_params_item = -1;
+static int hf_x11_glx_render_Materiali_face = -1;
+static int hf_x11_glx_render_Materiali_pname = -1;
+static int hf_x11_glx_render_Materiali_param = -1;
+static int hf_x11_glx_render_Materialiv_face = -1;
+static int hf_x11_glx_render_Materialiv_pname = -1;
+static int hf_x11_glx_render_Materialiv_params = -1;
+static int hf_x11_glx_render_Materialiv_params_item = -1;
+static int hf_x11_glx_render_PointSize_size = -1;
+static int hf_x11_glx_render_PolygonMode_face = -1;
+static int hf_x11_glx_render_PolygonMode_mode = -1;
+static int hf_x11_glx_render_PolygonStipple_mask = -1;
+static int hf_x11_glx_render_PolygonStipple_swapbytes = -1;
+static int hf_x11_glx_render_PolygonStipple_lsbfirst = -1;
+static int hf_x11_glx_render_PolygonStipple_rowlength = -1;
+static int hf_x11_glx_render_PolygonStipple_skiprows = -1;
+static int hf_x11_glx_render_PolygonStipple_skippixels = -1;
+static int hf_x11_glx_render_PolygonStipple_alignment = -1;
+static int hf_x11_glx_render_Scissor_x = -1;
+static int hf_x11_glx_render_Scissor_y = -1;
+static int hf_x11_glx_render_Scissor_width = -1;
+static int hf_x11_glx_render_Scissor_height = -1;
+static int hf_x11_glx_render_ShadeModel_mode = -1;
+static int hf_x11_glx_render_TexParameterf_target = -1;
+static int hf_x11_glx_render_TexParameterf_pname = -1;
+static int hf_x11_glx_render_TexParameterf_param = -1;
+static int hf_x11_glx_render_TexParameterfv_target = -1;
+static int hf_x11_glx_render_TexParameterfv_pname = -1;
+static int hf_x11_glx_render_TexParameterfv_params = -1;
+static int hf_x11_glx_render_TexParameterfv_params_item = -1;
+static int hf_x11_glx_render_TexParameteri_target = -1;
+static int hf_x11_glx_render_TexParameteri_pname = -1;
+static int hf_x11_glx_render_TexParameteri_param = -1;
+static int hf_x11_glx_render_TexParameteriv_target = -1;
+static int hf_x11_glx_render_TexParameteriv_pname = -1;
+static int hf_x11_glx_render_TexParameteriv_params = -1;
+static int hf_x11_glx_render_TexParameteriv_params_item = -1;
+static int hf_x11_glx_render_TexImage1D_target = -1;
+static int hf_x11_glx_render_TexImage1D_level = -1;
+static int hf_x11_glx_render_TexImage1D_internalformat = -1;
+static int hf_x11_glx_render_TexImage1D_width = -1;
+static int hf_x11_glx_render_TexImage1D_border = -1;
+static int hf_x11_glx_render_TexImage1D_format = -1;
+static int hf_x11_glx_render_TexImage1D_type = -1;
+static int hf_x11_glx_render_TexImage1D_pixels = -1;
+static int hf_x11_glx_render_TexImage1D_swapbytes = -1;
+static int hf_x11_glx_render_TexImage1D_lsbfirst = -1;
+static int hf_x11_glx_render_TexImage1D_rowlength = -1;
+static int hf_x11_glx_render_TexImage1D_skiprows = -1;
+static int hf_x11_glx_render_TexImage1D_skippixels = -1;
+static int hf_x11_glx_render_TexImage1D_alignment = -1;
+static int hf_x11_glx_render_TexImage2D_target = -1;
+static int hf_x11_glx_render_TexImage2D_level = -1;
+static int hf_x11_glx_render_TexImage2D_internalformat = -1;
+static int hf_x11_glx_render_TexImage2D_width = -1;
+static int hf_x11_glx_render_TexImage2D_height = -1;
+static int hf_x11_glx_render_TexImage2D_border = -1;
+static int hf_x11_glx_render_TexImage2D_format = -1;
+static int hf_x11_glx_render_TexImage2D_type = -1;
+static int hf_x11_glx_render_TexImage2D_pixels = -1;
+static int hf_x11_glx_render_TexImage2D_swapbytes = -1;
+static int hf_x11_glx_render_TexImage2D_lsbfirst = -1;
+static int hf_x11_glx_render_TexImage2D_rowlength = -1;
+static int hf_x11_glx_render_TexImage2D_skiprows = -1;
+static int hf_x11_glx_render_TexImage2D_skippixels = -1;
+static int hf_x11_glx_render_TexImage2D_alignment = -1;
+static int hf_x11_glx_render_TexEnvf_target = -1;
+static int hf_x11_glx_render_TexEnvf_pname = -1;
+static int hf_x11_glx_render_TexEnvf_param = -1;
+static int hf_x11_glx_render_TexEnvfv_target = -1;
+static int hf_x11_glx_render_TexEnvfv_pname = -1;
+static int hf_x11_glx_render_TexEnvfv_params = -1;
+static int hf_x11_glx_render_TexEnvfv_params_item = -1;
+static int hf_x11_glx_render_TexEnvi_target = -1;
+static int hf_x11_glx_render_TexEnvi_pname = -1;
+static int hf_x11_glx_render_TexEnvi_param = -1;
+static int hf_x11_glx_render_TexEnviv_target = -1;
+static int hf_x11_glx_render_TexEnviv_pname = -1;
+static int hf_x11_glx_render_TexEnviv_params = -1;
+static int hf_x11_glx_render_TexEnviv_params_item = -1;
+static int hf_x11_glx_render_TexGend_coord = -1;
+static int hf_x11_glx_render_TexGend_pname = -1;
+static int hf_x11_glx_render_TexGend_param = -1;
+static int hf_x11_glx_render_TexGendv_coord = -1;
+static int hf_x11_glx_render_TexGendv_pname = -1;
+static int hf_x11_glx_render_TexGendv_params = -1;
+static int hf_x11_glx_render_TexGendv_params_item = -1;
+static int hf_x11_glx_render_TexGenf_coord = -1;
+static int hf_x11_glx_render_TexGenf_pname = -1;
+static int hf_x11_glx_render_TexGenf_param = -1;
+static int hf_x11_glx_render_TexGenfv_coord = -1;
+static int hf_x11_glx_render_TexGenfv_pname = -1;
+static int hf_x11_glx_render_TexGenfv_params = -1;
+static int hf_x11_glx_render_TexGenfv_params_item = -1;
+static int hf_x11_glx_render_TexGeni_coord = -1;
+static int hf_x11_glx_render_TexGeni_pname = -1;
+static int hf_x11_glx_render_TexGeni_param = -1;
+static int hf_x11_glx_render_TexGeniv_coord = -1;
+static int hf_x11_glx_render_TexGeniv_pname = -1;
+static int hf_x11_glx_render_TexGeniv_params = -1;
+static int hf_x11_glx_render_TexGeniv_params_item = -1;
+static int hf_x11_glx_render_LoadName_name = -1;
+static int hf_x11_glx_render_PassThrough_token = -1;
+static int hf_x11_glx_render_PushName_name = -1;
+static int hf_x11_glx_render_DrawBuffer_mode = -1;
+static int hf_x11_glx_render_Clear_mask = -1;
+static int hf_x11_glx_render_ClearAccum_red = -1;
+static int hf_x11_glx_render_ClearAccum_green = -1;
+static int hf_x11_glx_render_ClearAccum_blue = -1;
+static int hf_x11_glx_render_ClearAccum_alpha = -1;
+static int hf_x11_glx_render_ClearIndex_c = -1;
+static int hf_x11_glx_render_ClearColor_red = -1;
+static int hf_x11_glx_render_ClearColor_green = -1;
+static int hf_x11_glx_render_ClearColor_blue = -1;
+static int hf_x11_glx_render_ClearColor_alpha = -1;
+static int hf_x11_glx_render_ClearStencil_s = -1;
+static int hf_x11_glx_render_ClearDepth_depth = -1;
+static int hf_x11_glx_render_StencilMask_mask = -1;
+static int hf_x11_glx_render_ColorMask_red = -1;
+static int hf_x11_glx_render_ColorMask_green = -1;
+static int hf_x11_glx_render_ColorMask_blue = -1;
+static int hf_x11_glx_render_ColorMask_alpha = -1;
+static int hf_x11_glx_render_DepthMask_flag = -1;
+static int hf_x11_glx_render_IndexMask_mask = -1;
+static int hf_x11_glx_render_Accum_op = -1;
+static int hf_x11_glx_render_Accum_value = -1;
+static int hf_x11_glx_render_Disable_cap = -1;
+static int hf_x11_glx_render_Enable_cap = -1;
+static int hf_x11_glx_render_PushAttrib_mask = -1;
+static int hf_x11_glx_render_Map1d_target = -1;
+static int hf_x11_glx_render_Map1d_u1 = -1;
+static int hf_x11_glx_render_Map1d_u2 = -1;
+static int hf_x11_glx_render_Map1d_stride = -1;
+static int hf_x11_glx_render_Map1d_order = -1;
+static int hf_x11_glx_render_Map1d_points = -1;
+static int hf_x11_glx_render_Map1d_points_item = -1;
+static int hf_x11_glx_render_Map1f_target = -1;
+static int hf_x11_glx_render_Map1f_u1 = -1;
+static int hf_x11_glx_render_Map1f_u2 = -1;
+static int hf_x11_glx_render_Map1f_stride = -1;
+static int hf_x11_glx_render_Map1f_order = -1;
+static int hf_x11_glx_render_Map1f_points = -1;
+static int hf_x11_glx_render_Map1f_points_item = -1;
+static int hf_x11_glx_render_Map2d_target = -1;
+static int hf_x11_glx_render_Map2d_u1 = -1;
+static int hf_x11_glx_render_Map2d_u2 = -1;
+static int hf_x11_glx_render_Map2d_ustride = -1;
+static int hf_x11_glx_render_Map2d_uorder = -1;
+static int hf_x11_glx_render_Map2d_v1 = -1;
+static int hf_x11_glx_render_Map2d_v2 = -1;
+static int hf_x11_glx_render_Map2d_vstride = -1;
+static int hf_x11_glx_render_Map2d_vorder = -1;
+static int hf_x11_glx_render_Map2d_points = -1;
+static int hf_x11_glx_render_Map2d_points_item = -1;
+static int hf_x11_glx_render_Map2f_target = -1;
+static int hf_x11_glx_render_Map2f_u1 = -1;
+static int hf_x11_glx_render_Map2f_u2 = -1;
+static int hf_x11_glx_render_Map2f_ustride = -1;
+static int hf_x11_glx_render_Map2f_uorder = -1;
+static int hf_x11_glx_render_Map2f_v1 = -1;
+static int hf_x11_glx_render_Map2f_v2 = -1;
+static int hf_x11_glx_render_Map2f_vstride = -1;
+static int hf_x11_glx_render_Map2f_vorder = -1;
+static int hf_x11_glx_render_Map2f_points = -1;
+static int hf_x11_glx_render_Map2f_points_item = -1;
+static int hf_x11_glx_render_MapGrid1d_un = -1;
+static int hf_x11_glx_render_MapGrid1d_u1 = -1;
+static int hf_x11_glx_render_MapGrid1d_u2 = -1;
+static int hf_x11_glx_render_MapGrid1f_un = -1;
+static int hf_x11_glx_render_MapGrid1f_u1 = -1;
+static int hf_x11_glx_render_MapGrid1f_u2 = -1;
+static int hf_x11_glx_render_MapGrid2d_un = -1;
+static int hf_x11_glx_render_MapGrid2d_u1 = -1;
+static int hf_x11_glx_render_MapGrid2d_u2 = -1;
+static int hf_x11_glx_render_MapGrid2d_vn = -1;
+static int hf_x11_glx_render_MapGrid2d_v1 = -1;
+static int hf_x11_glx_render_MapGrid2d_v2 = -1;
+static int hf_x11_glx_render_MapGrid2f_un = -1;
+static int hf_x11_glx_render_MapGrid2f_u1 = -1;
+static int hf_x11_glx_render_MapGrid2f_u2 = -1;
+static int hf_x11_glx_render_MapGrid2f_vn = -1;
+static int hf_x11_glx_render_MapGrid2f_v1 = -1;
+static int hf_x11_glx_render_MapGrid2f_v2 = -1;
+static int hf_x11_glx_render_EvalCoord1dv_u = -1;
+static int hf_x11_glx_render_EvalCoord1dv_u_item = -1;
+static int hf_x11_glx_render_EvalCoord1fv_u = -1;
+static int hf_x11_glx_render_EvalCoord1fv_u_item = -1;
+static int hf_x11_glx_render_EvalCoord2dv_u = -1;
+static int hf_x11_glx_render_EvalCoord2dv_u_item = -1;
+static int hf_x11_glx_render_EvalCoord2fv_u = -1;
+static int hf_x11_glx_render_EvalCoord2fv_u_item = -1;
+static int hf_x11_glx_render_EvalMesh1_mode = -1;
+static int hf_x11_glx_render_EvalMesh1_i1 = -1;
+static int hf_x11_glx_render_EvalMesh1_i2 = -1;
+static int hf_x11_glx_render_EvalPoint1_i = -1;
+static int hf_x11_glx_render_EvalMesh2_mode = -1;
+static int hf_x11_glx_render_EvalMesh2_i1 = -1;
+static int hf_x11_glx_render_EvalMesh2_i2 = -1;
+static int hf_x11_glx_render_EvalMesh2_j1 = -1;
+static int hf_x11_glx_render_EvalMesh2_j2 = -1;
+static int hf_x11_glx_render_EvalPoint2_i = -1;
+static int hf_x11_glx_render_EvalPoint2_j = -1;
+static int hf_x11_glx_render_AlphaFunc_func = -1;
+static int hf_x11_glx_render_AlphaFunc_ref = -1;
+static int hf_x11_glx_render_BlendFunc_sfactor = -1;
+static int hf_x11_glx_render_BlendFunc_dfactor = -1;
+static int hf_x11_glx_render_LogicOp_opcode = -1;
+static int hf_x11_glx_render_StencilFunc_func = -1;
+static int hf_x11_glx_render_StencilFunc_ref = -1;
+static int hf_x11_glx_render_StencilFunc_mask = -1;
+static int hf_x11_glx_render_StencilOp_fail = -1;
+static int hf_x11_glx_render_StencilOp_zfail = -1;
+static int hf_x11_glx_render_StencilOp_zpass = -1;
+static int hf_x11_glx_render_DepthFunc_func = -1;
+static int hf_x11_glx_render_PixelZoom_xfactor = -1;
+static int hf_x11_glx_render_PixelZoom_yfactor = -1;
+static int hf_x11_glx_render_PixelTransferf_pname = -1;
+static int hf_x11_glx_render_PixelTransferf_param = -1;
+static int hf_x11_glx_render_PixelTransferi_pname = -1;
+static int hf_x11_glx_render_PixelTransferi_param = -1;
+static int hf_x11_glx_render_PixelMapfv_map = -1;
+static int hf_x11_glx_render_PixelMapfv_mapsize = -1;
+static int hf_x11_glx_render_PixelMapfv_values = -1;
+static int hf_x11_glx_render_PixelMapfv_values_item = -1;
+static int hf_x11_glx_render_PixelMapuiv_map = -1;
+static int hf_x11_glx_render_PixelMapuiv_mapsize = -1;
+static int hf_x11_glx_render_PixelMapuiv_values = -1;
+static int hf_x11_glx_render_PixelMapuiv_values_item = -1;
+static int hf_x11_glx_render_PixelMapusv_map = -1;
+static int hf_x11_glx_render_PixelMapusv_mapsize = -1;
+static int hf_x11_glx_render_PixelMapusv_values = -1;
+static int hf_x11_glx_render_PixelMapusv_values_item = -1;
+static int hf_x11_glx_render_ReadBuffer_mode = -1;
+static int hf_x11_glx_render_CopyPixels_x = -1;
+static int hf_x11_glx_render_CopyPixels_y = -1;
+static int hf_x11_glx_render_CopyPixels_width = -1;
+static int hf_x11_glx_render_CopyPixels_height = -1;
+static int hf_x11_glx_render_CopyPixels_type = -1;
+static int hf_x11_glx_render_DrawPixels_width = -1;
+static int hf_x11_glx_render_DrawPixels_height = -1;
+static int hf_x11_glx_render_DrawPixels_format = -1;
+static int hf_x11_glx_render_DrawPixels_type = -1;
+static int hf_x11_glx_render_DrawPixels_pixels = -1;
+static int hf_x11_glx_render_DrawPixels_swapbytes = -1;
+static int hf_x11_glx_render_DrawPixels_lsbfirst = -1;
+static int hf_x11_glx_render_DrawPixels_rowlength = -1;
+static int hf_x11_glx_render_DrawPixels_skiprows = -1;
+static int hf_x11_glx_render_DrawPixels_skippixels = -1;
+static int hf_x11_glx_render_DrawPixels_alignment = -1;
+static int hf_x11_glx_render_DepthRange_zNear = -1;
+static int hf_x11_glx_render_DepthRange_zFar = -1;
+static int hf_x11_glx_render_Frustum_left = -1;
+static int hf_x11_glx_render_Frustum_right = -1;
+static int hf_x11_glx_render_Frustum_bottom = -1;
+static int hf_x11_glx_render_Frustum_top = -1;
+static int hf_x11_glx_render_Frustum_zNear = -1;
+static int hf_x11_glx_render_Frustum_zFar = -1;
+static int hf_x11_glx_render_LoadMatrixf_m = -1;
+static int hf_x11_glx_render_LoadMatrixf_m_item = -1;
+static int hf_x11_glx_render_LoadMatrixd_m = -1;
+static int hf_x11_glx_render_LoadMatrixd_m_item = -1;
+static int hf_x11_glx_render_MatrixMode_mode = -1;
+static int hf_x11_glx_render_MultMatrixf_m = -1;
+static int hf_x11_glx_render_MultMatrixf_m_item = -1;
+static int hf_x11_glx_render_MultMatrixd_m = -1;
+static int hf_x11_glx_render_MultMatrixd_m_item = -1;
+static int hf_x11_glx_render_Ortho_left = -1;
+static int hf_x11_glx_render_Ortho_right = -1;
+static int hf_x11_glx_render_Ortho_bottom = -1;
+static int hf_x11_glx_render_Ortho_top = -1;
+static int hf_x11_glx_render_Ortho_zNear = -1;
+static int hf_x11_glx_render_Ortho_zFar = -1;
+static int hf_x11_glx_render_Rotated_angle = -1;
+static int hf_x11_glx_render_Rotated_x = -1;
+static int hf_x11_glx_render_Rotated_y = -1;
+static int hf_x11_glx_render_Rotated_z = -1;
+static int hf_x11_glx_render_Rotatef_angle = -1;
+static int hf_x11_glx_render_Rotatef_x = -1;
+static int hf_x11_glx_render_Rotatef_y = -1;
+static int hf_x11_glx_render_Rotatef_z = -1;
+static int hf_x11_glx_render_Scaled_x = -1;
+static int hf_x11_glx_render_Scaled_y = -1;
+static int hf_x11_glx_render_Scaled_z = -1;
+static int hf_x11_glx_render_Scalef_x = -1;
+static int hf_x11_glx_render_Scalef_y = -1;
+static int hf_x11_glx_render_Scalef_z = -1;
+static int hf_x11_glx_render_Translated_x = -1;
+static int hf_x11_glx_render_Translated_y = -1;
+static int hf_x11_glx_render_Translated_z = -1;
+static int hf_x11_glx_render_Translatef_x = -1;
+static int hf_x11_glx_render_Translatef_y = -1;
+static int hf_x11_glx_render_Translatef_z = -1;
+static int hf_x11_glx_render_Viewport_x = -1;
+static int hf_x11_glx_render_Viewport_y = -1;
+static int hf_x11_glx_render_Viewport_width = -1;
+static int hf_x11_glx_render_Viewport_height = -1;
+static int hf_x11_glx_render_DrawArrays_mode = -1;
+static int hf_x11_glx_render_DrawArrays_first = -1;
+static int hf_x11_glx_render_DrawArrays_count = -1;
+static int hf_x11_glx_render_PolygonOffset_factor = -1;
+static int hf_x11_glx_render_PolygonOffset_units = -1;
+static int hf_x11_glx_render_CopyTexImage1D_target = -1;
+static int hf_x11_glx_render_CopyTexImage1D_level = -1;
+static int hf_x11_glx_render_CopyTexImage1D_internalformat = -1;
+static int hf_x11_glx_render_CopyTexImage1D_x = -1;
+static int hf_x11_glx_render_CopyTexImage1D_y = -1;
+static int hf_x11_glx_render_CopyTexImage1D_width = -1;
+static int hf_x11_glx_render_CopyTexImage1D_border = -1;
+static int hf_x11_glx_render_CopyTexImage2D_target = -1;
+static int hf_x11_glx_render_CopyTexImage2D_level = -1;
+static int hf_x11_glx_render_CopyTexImage2D_internalformat = -1;
+static int hf_x11_glx_render_CopyTexImage2D_x = -1;
+static int hf_x11_glx_render_CopyTexImage2D_y = -1;
+static int hf_x11_glx_render_CopyTexImage2D_width = -1;
+static int hf_x11_glx_render_CopyTexImage2D_height = -1;
+static int hf_x11_glx_render_CopyTexImage2D_border = -1;
+static int hf_x11_glx_render_CopyTexSubImage1D_target = -1;
+static int hf_x11_glx_render_CopyTexSubImage1D_level = -1;
+static int hf_x11_glx_render_CopyTexSubImage1D_xoffset = -1;
+static int hf_x11_glx_render_CopyTexSubImage1D_x = -1;
+static int hf_x11_glx_render_CopyTexSubImage1D_y = -1;
+static int hf_x11_glx_render_CopyTexSubImage1D_width = -1;
+static int hf_x11_glx_render_CopyTexSubImage2D_target = -1;
+static int hf_x11_glx_render_CopyTexSubImage2D_level = -1;
+static int hf_x11_glx_render_CopyTexSubImage2D_xoffset = -1;
+static int hf_x11_glx_render_CopyTexSubImage2D_yoffset = -1;
+static int hf_x11_glx_render_CopyTexSubImage2D_x = -1;
+static int hf_x11_glx_render_CopyTexSubImage2D_y = -1;
+static int hf_x11_glx_render_CopyTexSubImage2D_width = -1;
+static int hf_x11_glx_render_CopyTexSubImage2D_height = -1;
+static int hf_x11_glx_render_TexSubImage1D_target = -1;
+static int hf_x11_glx_render_TexSubImage1D_level = -1;
+static int hf_x11_glx_render_TexSubImage1D_xoffset = -1;
+static int hf_x11_glx_render_TexSubImage1D_width = -1;
+static int hf_x11_glx_render_TexSubImage1D_format = -1;
+static int hf_x11_glx_render_TexSubImage1D_type = -1;
+static int hf_x11_glx_render_TexSubImage1D_UNUSED = -1;
+static int hf_x11_glx_render_TexSubImage1D_pixels = -1;
+static int hf_x11_glx_render_TexSubImage1D_swapbytes = -1;
+static int hf_x11_glx_render_TexSubImage1D_lsbfirst = -1;
+static int hf_x11_glx_render_TexSubImage1D_rowlength = -1;
+static int hf_x11_glx_render_TexSubImage1D_skiprows = -1;
+static int hf_x11_glx_render_TexSubImage1D_skippixels = -1;
+static int hf_x11_glx_render_TexSubImage1D_alignment = -1;
+static int hf_x11_glx_render_TexSubImage2D_target = -1;
+static int hf_x11_glx_render_TexSubImage2D_level = -1;
+static int hf_x11_glx_render_TexSubImage2D_xoffset = -1;
+static int hf_x11_glx_render_TexSubImage2D_yoffset = -1;
+static int hf_x11_glx_render_TexSubImage2D_width = -1;
+static int hf_x11_glx_render_TexSubImage2D_height = -1;
+static int hf_x11_glx_render_TexSubImage2D_format = -1;
+static int hf_x11_glx_render_TexSubImage2D_type = -1;
+static int hf_x11_glx_render_TexSubImage2D_UNUSED = -1;
+static int hf_x11_glx_render_TexSubImage2D_pixels = -1;
+static int hf_x11_glx_render_TexSubImage2D_swapbytes = -1;
+static int hf_x11_glx_render_TexSubImage2D_lsbfirst = -1;
+static int hf_x11_glx_render_TexSubImage2D_rowlength = -1;
+static int hf_x11_glx_render_TexSubImage2D_skiprows = -1;
+static int hf_x11_glx_render_TexSubImage2D_skippixels = -1;
+static int hf_x11_glx_render_TexSubImage2D_alignment = -1;
+static int hf_x11_glx_render_BindTexture_target = -1;
+static int hf_x11_glx_render_BindTexture_texture = -1;
+static int hf_x11_glx_render_PrioritizeTextures_n = -1;
+static int hf_x11_glx_render_PrioritizeTextures_textures = -1;
+static int hf_x11_glx_render_PrioritizeTextures_textures_item = -1;
+static int hf_x11_glx_render_PrioritizeTextures_priorities = -1;
+static int hf_x11_glx_render_PrioritizeTextures_priorities_item = -1;
+static int hf_x11_glx_render_Indexubv_c = -1;
+static int hf_x11_glx_render_BlendColor_red = -1;
+static int hf_x11_glx_render_BlendColor_green = -1;
+static int hf_x11_glx_render_BlendColor_blue = -1;
+static int hf_x11_glx_render_BlendColor_alpha = -1;
+static int hf_x11_glx_render_BlendEquation_mode = -1;
+static int hf_x11_glx_render_ColorTable_target = -1;
+static int hf_x11_glx_render_ColorTable_internalformat = -1;
+static int hf_x11_glx_render_ColorTable_width = -1;
+static int hf_x11_glx_render_ColorTable_format = -1;
+static int hf_x11_glx_render_ColorTable_type = -1;
+static int hf_x11_glx_render_ColorTable_table = -1;
+static int hf_x11_glx_render_ColorTable_swapbytes = -1;
+static int hf_x11_glx_render_ColorTable_lsbfirst = -1;
+static int hf_x11_glx_render_ColorTable_rowlength = -1;
+static int hf_x11_glx_render_ColorTable_skiprows = -1;
+static int hf_x11_glx_render_ColorTable_skippixels = -1;
+static int hf_x11_glx_render_ColorTable_alignment = -1;
+static int hf_x11_glx_render_ColorTableParameterfv_target = -1;
+static int hf_x11_glx_render_ColorTableParameterfv_pname = -1;
+static int hf_x11_glx_render_ColorTableParameterfv_params = -1;
+static int hf_x11_glx_render_ColorTableParameterfv_params_item = -1;
+static int hf_x11_glx_render_ColorTableParameteriv_target = -1;
+static int hf_x11_glx_render_ColorTableParameteriv_pname = -1;
+static int hf_x11_glx_render_ColorTableParameteriv_params = -1;
+static int hf_x11_glx_render_ColorTableParameteriv_params_item = -1;
+static int hf_x11_glx_render_CopyColorTable_target = -1;
+static int hf_x11_glx_render_CopyColorTable_internalformat = -1;
+static int hf_x11_glx_render_CopyColorTable_x = -1;
+static int hf_x11_glx_render_CopyColorTable_y = -1;
+static int hf_x11_glx_render_CopyColorTable_width = -1;
+static int hf_x11_glx_render_ColorSubTable_target = -1;
+static int hf_x11_glx_render_ColorSubTable_start = -1;
+static int hf_x11_glx_render_ColorSubTable_count = -1;
+static int hf_x11_glx_render_ColorSubTable_format = -1;
+static int hf_x11_glx_render_ColorSubTable_type = -1;
+static int hf_x11_glx_render_ColorSubTable_data = -1;
+static int hf_x11_glx_render_ColorSubTable_swapbytes = -1;
+static int hf_x11_glx_render_ColorSubTable_lsbfirst = -1;
+static int hf_x11_glx_render_ColorSubTable_rowlength = -1;
+static int hf_x11_glx_render_ColorSubTable_skiprows = -1;
+static int hf_x11_glx_render_ColorSubTable_skippixels = -1;
+static int hf_x11_glx_render_ColorSubTable_alignment = -1;
+static int hf_x11_glx_render_CopyColorSubTable_target = -1;
+static int hf_x11_glx_render_CopyColorSubTable_start = -1;
+static int hf_x11_glx_render_CopyColorSubTable_x = -1;
+static int hf_x11_glx_render_CopyColorSubTable_y = -1;
+static int hf_x11_glx_render_CopyColorSubTable_width = -1;
+static int hf_x11_glx_render_ConvolutionFilter1D_target = -1;
+static int hf_x11_glx_render_ConvolutionFilter1D_internalformat = -1;
+static int hf_x11_glx_render_ConvolutionFilter1D_width = -1;
+static int hf_x11_glx_render_ConvolutionFilter1D_format = -1;
+static int hf_x11_glx_render_ConvolutionFilter1D_type = -1;
+static int hf_x11_glx_render_ConvolutionFilter1D_image = -1;
+static int hf_x11_glx_render_ConvolutionFilter1D_swapbytes = -1;
+static int hf_x11_glx_render_ConvolutionFilter1D_lsbfirst = -1;
+static int hf_x11_glx_render_ConvolutionFilter1D_rowlength = -1;
+static int hf_x11_glx_render_ConvolutionFilter1D_skiprows = -1;
+static int hf_x11_glx_render_ConvolutionFilter1D_skippixels = -1;
+static int hf_x11_glx_render_ConvolutionFilter1D_alignment = -1;
+static int hf_x11_glx_render_ConvolutionFilter2D_target = -1;
+static int hf_x11_glx_render_ConvolutionFilter2D_internalformat = -1;
+static int hf_x11_glx_render_ConvolutionFilter2D_width = -1;
+static int hf_x11_glx_render_ConvolutionFilter2D_height = -1;
+static int hf_x11_glx_render_ConvolutionFilter2D_format = -1;
+static int hf_x11_glx_render_ConvolutionFilter2D_type = -1;
+static int hf_x11_glx_render_ConvolutionFilter2D_image = -1;
+static int hf_x11_glx_render_ConvolutionFilter2D_swapbytes = -1;
+static int hf_x11_glx_render_ConvolutionFilter2D_lsbfirst = -1;
+static int hf_x11_glx_render_ConvolutionFilter2D_rowlength = -1;
+static int hf_x11_glx_render_ConvolutionFilter2D_skiprows = -1;
+static int hf_x11_glx_render_ConvolutionFilter2D_skippixels = -1;
+static int hf_x11_glx_render_ConvolutionFilter2D_alignment = -1;
+static int hf_x11_glx_render_ConvolutionParameterf_target = -1;
+static int hf_x11_glx_render_ConvolutionParameterf_pname = -1;
+static int hf_x11_glx_render_ConvolutionParameterf_params = -1;
+static int hf_x11_glx_render_ConvolutionParameterfv_target = -1;
+static int hf_x11_glx_render_ConvolutionParameterfv_pname = -1;
+static int hf_x11_glx_render_ConvolutionParameterfv_params = -1;
+static int hf_x11_glx_render_ConvolutionParameterfv_params_item = -1;
+static int hf_x11_glx_render_ConvolutionParameteri_target = -1;
+static int hf_x11_glx_render_ConvolutionParameteri_pname = -1;
+static int hf_x11_glx_render_ConvolutionParameteri_params = -1;
+static int hf_x11_glx_render_ConvolutionParameteriv_target = -1;
+static int hf_x11_glx_render_ConvolutionParameteriv_pname = -1;
+static int hf_x11_glx_render_ConvolutionParameteriv_params = -1;
+static int hf_x11_glx_render_ConvolutionParameteriv_params_item = -1;
+static int hf_x11_glx_render_CopyConvolutionFilter1D_target = -1;
+static int hf_x11_glx_render_CopyConvolutionFilter1D_internalformat = -1;
+static int hf_x11_glx_render_CopyConvolutionFilter1D_x = -1;
+static int hf_x11_glx_render_CopyConvolutionFilter1D_y = -1;
+static int hf_x11_glx_render_CopyConvolutionFilter1D_width = -1;
+static int hf_x11_glx_render_CopyConvolutionFilter2D_target = -1;
+static int hf_x11_glx_render_CopyConvolutionFilter2D_internalformat = -1;
+static int hf_x11_glx_render_CopyConvolutionFilter2D_x = -1;
+static int hf_x11_glx_render_CopyConvolutionFilter2D_y = -1;
+static int hf_x11_glx_render_CopyConvolutionFilter2D_width = -1;
+static int hf_x11_glx_render_CopyConvolutionFilter2D_height = -1;
+static int hf_x11_glx_render_SeparableFilter2D_target = -1;
+static int hf_x11_glx_render_SeparableFilter2D_internalformat = -1;
+static int hf_x11_glx_render_SeparableFilter2D_width = -1;
+static int hf_x11_glx_render_SeparableFilter2D_height = -1;
+static int hf_x11_glx_render_SeparableFilter2D_format = -1;
+static int hf_x11_glx_render_SeparableFilter2D_type = -1;
+static int hf_x11_glx_render_SeparableFilter2D_row = -1;
+static int hf_x11_glx_render_SeparableFilter2D_column = -1;
+static int hf_x11_glx_render_Histogram_target = -1;
+static int hf_x11_glx_render_Histogram_width = -1;
+static int hf_x11_glx_render_Histogram_internalformat = -1;
+static int hf_x11_glx_render_Histogram_sink = -1;
+static int hf_x11_glx_render_Minmax_target = -1;
+static int hf_x11_glx_render_Minmax_internalformat = -1;
+static int hf_x11_glx_render_Minmax_sink = -1;
+static int hf_x11_glx_render_ResetHistogram_target = -1;
+static int hf_x11_glx_render_ResetMinmax_target = -1;
+static int hf_x11_glx_render_TexImage3D_target = -1;
+static int hf_x11_glx_render_TexImage3D_level = -1;
+static int hf_x11_glx_render_TexImage3D_internalformat = -1;
+static int hf_x11_glx_render_TexImage3D_width = -1;
+static int hf_x11_glx_render_TexImage3D_height = -1;
+static int hf_x11_glx_render_TexImage3D_depth = -1;
+static int hf_x11_glx_render_TexImage3D_border = -1;
+static int hf_x11_glx_render_TexImage3D_format = -1;
+static int hf_x11_glx_render_TexImage3D_type = -1;
+static int hf_x11_glx_render_TexImage3D_pixels = -1;
+static int hf_x11_glx_render_TexImage3D_swapbytes = -1;
+static int hf_x11_glx_render_TexImage3D_lsbfirst = -1;
+static int hf_x11_glx_render_TexImage3D_rowlength = -1;
+static int hf_x11_glx_render_TexImage3D_skiprows = -1;
+static int hf_x11_glx_render_TexImage3D_skippixels = -1;
+static int hf_x11_glx_render_TexImage3D_alignment = -1;
+static int hf_x11_glx_render_TexSubImage3D_target = -1;
+static int hf_x11_glx_render_TexSubImage3D_level = -1;
+static int hf_x11_glx_render_TexSubImage3D_xoffset = -1;
+static int hf_x11_glx_render_TexSubImage3D_yoffset = -1;
+static int hf_x11_glx_render_TexSubImage3D_zoffset = -1;
+static int hf_x11_glx_render_TexSubImage3D_width = -1;
+static int hf_x11_glx_render_TexSubImage3D_height = -1;
+static int hf_x11_glx_render_TexSubImage3D_depth = -1;
+static int hf_x11_glx_render_TexSubImage3D_format = -1;
+static int hf_x11_glx_render_TexSubImage3D_type = -1;
+static int hf_x11_glx_render_TexSubImage3D_UNUSED = -1;
+static int hf_x11_glx_render_TexSubImage3D_pixels = -1;
+static int hf_x11_glx_render_TexSubImage3D_swapbytes = -1;
+static int hf_x11_glx_render_TexSubImage3D_lsbfirst = -1;
+static int hf_x11_glx_render_TexSubImage3D_rowlength = -1;
+static int hf_x11_glx_render_TexSubImage3D_skiprows = -1;
+static int hf_x11_glx_render_TexSubImage3D_skippixels = -1;
+static int hf_x11_glx_render_TexSubImage3D_alignment = -1;
+static int hf_x11_glx_render_CopyTexSubImage3D_target = -1;
+static int hf_x11_glx_render_CopyTexSubImage3D_level = -1;
+static int hf_x11_glx_render_CopyTexSubImage3D_xoffset = -1;
+static int hf_x11_glx_render_CopyTexSubImage3D_yoffset = -1;
+static int hf_x11_glx_render_CopyTexSubImage3D_zoffset = -1;
+static int hf_x11_glx_render_CopyTexSubImage3D_x = -1;
+static int hf_x11_glx_render_CopyTexSubImage3D_y = -1;
+static int hf_x11_glx_render_CopyTexSubImage3D_width = -1;
+static int hf_x11_glx_render_CopyTexSubImage3D_height = -1;
+static int hf_x11_glx_render_ActiveTextureARB_texture = -1;
+static int hf_x11_glx_render_MultiTexCoord1dvARB_target = -1;
+static int hf_x11_glx_render_MultiTexCoord1dvARB_v = -1;
+static int hf_x11_glx_render_MultiTexCoord1dvARB_v_item = -1;
+static int hf_x11_glx_render_MultiTexCoord1fvARB_target = -1;
+static int hf_x11_glx_render_MultiTexCoord1fvARB_v = -1;
+static int hf_x11_glx_render_MultiTexCoord1fvARB_v_item = -1;
+static int hf_x11_glx_render_MultiTexCoord1ivARB_target = -1;
+static int hf_x11_glx_render_MultiTexCoord1ivARB_v = -1;
+static int hf_x11_glx_render_MultiTexCoord1ivARB_v_item = -1;
+static int hf_x11_glx_render_MultiTexCoord1svARB_target = -1;
+static int hf_x11_glx_render_MultiTexCoord1svARB_v = -1;
+static int hf_x11_glx_render_MultiTexCoord1svARB_v_item = -1;
+static int hf_x11_glx_render_MultiTexCoord2dvARB_target = -1;
+static int hf_x11_glx_render_MultiTexCoord2dvARB_v = -1;
+static int hf_x11_glx_render_MultiTexCoord2dvARB_v_item = -1;
+static int hf_x11_glx_render_MultiTexCoord2fvARB_target = -1;
+static int hf_x11_glx_render_MultiTexCoord2fvARB_v = -1;
+static int hf_x11_glx_render_MultiTexCoord2fvARB_v_item = -1;
+static int hf_x11_glx_render_MultiTexCoord2ivARB_target = -1;
+static int hf_x11_glx_render_MultiTexCoord2ivARB_v = -1;
+static int hf_x11_glx_render_MultiTexCoord2ivARB_v_item = -1;
+static int hf_x11_glx_render_MultiTexCoord2svARB_target = -1;
+static int hf_x11_glx_render_MultiTexCoord2svARB_v = -1;
+static int hf_x11_glx_render_MultiTexCoord2svARB_v_item = -1;
+static int hf_x11_glx_render_MultiTexCoord3dvARB_target = -1;
+static int hf_x11_glx_render_MultiTexCoord3dvARB_v = -1;
+static int hf_x11_glx_render_MultiTexCoord3dvARB_v_item = -1;
+static int hf_x11_glx_render_MultiTexCoord3fvARB_target = -1;
+static int hf_x11_glx_render_MultiTexCoord3fvARB_v = -1;
+static int hf_x11_glx_render_MultiTexCoord3fvARB_v_item = -1;
+static int hf_x11_glx_render_MultiTexCoord3ivARB_target = -1;
+static int hf_x11_glx_render_MultiTexCoord3ivARB_v = -1;
+static int hf_x11_glx_render_MultiTexCoord3ivARB_v_item = -1;
+static int hf_x11_glx_render_MultiTexCoord3svARB_target = -1;
+static int hf_x11_glx_render_MultiTexCoord3svARB_v = -1;
+static int hf_x11_glx_render_MultiTexCoord3svARB_v_item = -1;
+static int hf_x11_glx_render_MultiTexCoord4dvARB_target = -1;
+static int hf_x11_glx_render_MultiTexCoord4dvARB_v = -1;
+static int hf_x11_glx_render_MultiTexCoord4dvARB_v_item = -1;
+static int hf_x11_glx_render_MultiTexCoord4fvARB_target = -1;
+static int hf_x11_glx_render_MultiTexCoord4fvARB_v = -1;
+static int hf_x11_glx_render_MultiTexCoord4fvARB_v_item = -1;
+static int hf_x11_glx_render_MultiTexCoord4ivARB_target = -1;
+static int hf_x11_glx_render_MultiTexCoord4ivARB_v = -1;
+static int hf_x11_glx_render_MultiTexCoord4ivARB_v_item = -1;
+static int hf_x11_glx_render_MultiTexCoord4svARB_target = -1;
+static int hf_x11_glx_render_MultiTexCoord4svARB_v = -1;
+static int hf_x11_glx_render_MultiTexCoord4svARB_v_item = -1;
+static int hf_x11_glx_render_SampleCoverageARB_value = -1;
+static int hf_x11_glx_render_SampleCoverageARB_invert = -1;
+static int hf_x11_glx_render_CompressedTexImage3DARB_target = -1;
+static int hf_x11_glx_render_CompressedTexImage3DARB_level = -1;
+static int hf_x11_glx_render_CompressedTexImage3DARB_internalformat = -1;
+static int hf_x11_glx_render_CompressedTexImage3DARB_width = -1;
+static int hf_x11_glx_render_CompressedTexImage3DARB_height = -1;
+static int hf_x11_glx_render_CompressedTexImage3DARB_depth = -1;
+static int hf_x11_glx_render_CompressedTexImage3DARB_border = -1;
+static int hf_x11_glx_render_CompressedTexImage3DARB_imageSize = -1;
+static int hf_x11_glx_render_CompressedTexImage3DARB_data = -1;
+static int hf_x11_glx_render_CompressedTexImage2DARB_target = -1;
+static int hf_x11_glx_render_CompressedTexImage2DARB_level = -1;
+static int hf_x11_glx_render_CompressedTexImage2DARB_internalformat = -1;
+static int hf_x11_glx_render_CompressedTexImage2DARB_width = -1;
+static int hf_x11_glx_render_CompressedTexImage2DARB_height = -1;
+static int hf_x11_glx_render_CompressedTexImage2DARB_border = -1;
+static int hf_x11_glx_render_CompressedTexImage2DARB_imageSize = -1;
+static int hf_x11_glx_render_CompressedTexImage2DARB_data = -1;
+static int hf_x11_glx_render_CompressedTexImage1DARB_target = -1;
+static int hf_x11_glx_render_CompressedTexImage1DARB_level = -1;
+static int hf_x11_glx_render_CompressedTexImage1DARB_internalformat = -1;
+static int hf_x11_glx_render_CompressedTexImage1DARB_width = -1;
+static int hf_x11_glx_render_CompressedTexImage1DARB_border = -1;
+static int hf_x11_glx_render_CompressedTexImage1DARB_imageSize = -1;
+static int hf_x11_glx_render_CompressedTexImage1DARB_data = -1;
+static int hf_x11_glx_render_CompressedTexSubImage3DARB_target = -1;
+static int hf_x11_glx_render_CompressedTexSubImage3DARB_level = -1;
+static int hf_x11_glx_render_CompressedTexSubImage3DARB_xoffset = -1;
+static int hf_x11_glx_render_CompressedTexSubImage3DARB_yoffset = -1;
+static int hf_x11_glx_render_CompressedTexSubImage3DARB_zoffset = -1;
+static int hf_x11_glx_render_CompressedTexSubImage3DARB_width = -1;
+static int hf_x11_glx_render_CompressedTexSubImage3DARB_height = -1;
+static int hf_x11_glx_render_CompressedTexSubImage3DARB_depth = -1;
+static int hf_x11_glx_render_CompressedTexSubImage3DARB_format = -1;
+static int hf_x11_glx_render_CompressedTexSubImage3DARB_imageSize = -1;
+static int hf_x11_glx_render_CompressedTexSubImage3DARB_data = -1;
+static int hf_x11_glx_render_CompressedTexSubImage2DARB_target = -1;
+static int hf_x11_glx_render_CompressedTexSubImage2DARB_level = -1;
+static int hf_x11_glx_render_CompressedTexSubImage2DARB_xoffset = -1;
+static int hf_x11_glx_render_CompressedTexSubImage2DARB_yoffset = -1;
+static int hf_x11_glx_render_CompressedTexSubImage2DARB_width = -1;
+static int hf_x11_glx_render_CompressedTexSubImage2DARB_height = -1;
+static int hf_x11_glx_render_CompressedTexSubImage2DARB_format = -1;
+static int hf_x11_glx_render_CompressedTexSubImage2DARB_imageSize = -1;
+static int hf_x11_glx_render_CompressedTexSubImage2DARB_data = -1;
+static int hf_x11_glx_render_CompressedTexSubImage1DARB_target = -1;
+static int hf_x11_glx_render_CompressedTexSubImage1DARB_level = -1;
+static int hf_x11_glx_render_CompressedTexSubImage1DARB_xoffset = -1;
+static int hf_x11_glx_render_CompressedTexSubImage1DARB_width = -1;
+static int hf_x11_glx_render_CompressedTexSubImage1DARB_format = -1;
+static int hf_x11_glx_render_CompressedTexSubImage1DARB_imageSize = -1;
+static int hf_x11_glx_render_CompressedTexSubImage1DARB_data = -1;
+static int hf_x11_glx_render_CurrentPaletteMatrixARB_index = -1;
+static int hf_x11_glx_render_MatrixIndexubvARB_size = -1;
+static int hf_x11_glx_render_MatrixIndexubvARB_indices = -1;
+static int hf_x11_glx_render_MatrixIndexusvARB_size = -1;
+static int hf_x11_glx_render_MatrixIndexusvARB_indices = -1;
+static int hf_x11_glx_render_MatrixIndexusvARB_indices_item = -1;
+static int hf_x11_glx_render_MatrixIndexuivARB_size = -1;
+static int hf_x11_glx_render_MatrixIndexuivARB_indices = -1;
+static int hf_x11_glx_render_MatrixIndexuivARB_indices_item = -1;
+static int hf_x11_glx_render_VertexAttrib1dvARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib1dvARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib1dvARB_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib1fvARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib1fvARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib1fvARB_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib1svARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib1svARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib1svARB_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib2dvARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib2dvARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib2dvARB_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib2fvARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib2fvARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib2fvARB_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib2svARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib2svARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib2svARB_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib3dvARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib3dvARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib3dvARB_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib3fvARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib3fvARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib3fvARB_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib3svARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib3svARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib3svARB_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib4dvARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib4dvARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib4dvARB_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib4fvARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib4fvARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib4fvARB_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib4svARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib4svARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib4svARB_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib4NubvARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib4NubvARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib4bvARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib4bvARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib4ivARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib4ivARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib4ivARB_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib4ubvARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib4ubvARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib4usvARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib4usvARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib4usvARB_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib4uivARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib4uivARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib4uivARB_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib4NbvARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib4NbvARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib4NsvARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib4NsvARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib4NsvARB_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib4NivARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib4NivARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib4NivARB_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib4NusvARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib4NusvARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib4NusvARB_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib4NuivARB_index = -1;
+static int hf_x11_glx_render_VertexAttrib4NuivARB_v = -1;
+static int hf_x11_glx_render_VertexAttrib4NuivARB_v_item = -1;
+static int hf_x11_glx_render_ProgramStringARB_target = -1;
+static int hf_x11_glx_render_ProgramStringARB_format = -1;
+static int hf_x11_glx_render_ProgramStringARB_len = -1;
+static int hf_x11_glx_render_ProgramStringARB_string = -1;
+static int hf_x11_glx_render_ProgramEnvParameter4dvARB_target = -1;
+static int hf_x11_glx_render_ProgramEnvParameter4dvARB_index = -1;
+static int hf_x11_glx_render_ProgramEnvParameter4dvARB_params = -1;
+static int hf_x11_glx_render_ProgramEnvParameter4dvARB_params_item = -1;
+static int hf_x11_glx_render_ProgramEnvParameter4fvARB_target = -1;
+static int hf_x11_glx_render_ProgramEnvParameter4fvARB_index = -1;
+static int hf_x11_glx_render_ProgramEnvParameter4fvARB_params = -1;
+static int hf_x11_glx_render_ProgramEnvParameter4fvARB_params_item = -1;
+static int hf_x11_glx_render_ProgramLocalParameter4dvARB_target = -1;
+static int hf_x11_glx_render_ProgramLocalParameter4dvARB_index = -1;
+static int hf_x11_glx_render_ProgramLocalParameter4dvARB_params = -1;
+static int hf_x11_glx_render_ProgramLocalParameter4dvARB_params_item = -1;
+static int hf_x11_glx_render_ProgramLocalParameter4fvARB_target = -1;
+static int hf_x11_glx_render_ProgramLocalParameter4fvARB_index = -1;
+static int hf_x11_glx_render_ProgramLocalParameter4fvARB_params = -1;
+static int hf_x11_glx_render_ProgramLocalParameter4fvARB_params_item = -1;
+static int hf_x11_glx_render_BeginQueryARB_target = -1;
+static int hf_x11_glx_render_BeginQueryARB_id = -1;
+static int hf_x11_glx_render_EndQueryARB_target = -1;
+static int hf_x11_glx_render_DrawBuffersARB_n = -1;
+static int hf_x11_glx_render_DrawBuffersARB_bufs = -1;
+static int hf_x11_glx_render_DrawBuffersARB_bufs_item = -1;
+static int hf_x11_glx_render_PolygonOffsetEXT_factor = -1;
+static int hf_x11_glx_render_PolygonOffsetEXT_bias = -1;
+static int hf_x11_glx_render_TexFilterFuncSGIS_target = -1;
+static int hf_x11_glx_render_TexFilterFuncSGIS_filter = -1;
+static int hf_x11_glx_render_TexFilterFuncSGIS_n = -1;
+static int hf_x11_glx_render_TexFilterFuncSGIS_weights = -1;
+static int hf_x11_glx_render_TexFilterFuncSGIS_weights_item = -1;
+static int hf_x11_glx_render_TexImage4DSGIS_target = -1;
+static int hf_x11_glx_render_TexImage4DSGIS_level = -1;
+static int hf_x11_glx_render_TexImage4DSGIS_internalformat = -1;
+static int hf_x11_glx_render_TexImage4DSGIS_width = -1;
+static int hf_x11_glx_render_TexImage4DSGIS_height = -1;
+static int hf_x11_glx_render_TexImage4DSGIS_depth = -1;
+static int hf_x11_glx_render_TexImage4DSGIS_size4d = -1;
+static int hf_x11_glx_render_TexImage4DSGIS_border = -1;
+static int hf_x11_glx_render_TexImage4DSGIS_format = -1;
+static int hf_x11_glx_render_TexImage4DSGIS_type = -1;
+static int hf_x11_glx_render_TexImage4DSGIS_pixels = -1;
+static int hf_x11_glx_render_TexImage4DSGIS_swapbytes = -1;
+static int hf_x11_glx_render_TexImage4DSGIS_lsbfirst = -1;
+static int hf_x11_glx_render_TexImage4DSGIS_rowlength = -1;
+static int hf_x11_glx_render_TexImage4DSGIS_skiprows = -1;
+static int hf_x11_glx_render_TexImage4DSGIS_skippixels = -1;
+static int hf_x11_glx_render_TexImage4DSGIS_alignment = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_target = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_level = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_xoffset = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_yoffset = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_zoffset = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_woffset = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_width = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_height = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_depth = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_size4d = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_format = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_type = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_UNUSED = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_pixels = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_swapbytes = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_lsbfirst = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_rowlength = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_skiprows = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_skippixels = -1;
+static int hf_x11_glx_render_TexSubImage4DSGIS_alignment = -1;
+static int hf_x11_glx_render_DetailTexFuncSGIS_target = -1;
+static int hf_x11_glx_render_DetailTexFuncSGIS_n = -1;
+static int hf_x11_glx_render_DetailTexFuncSGIS_points = -1;
+static int hf_x11_glx_render_DetailTexFuncSGIS_points_item = -1;
+static int hf_x11_glx_render_SharpenTexFuncSGIS_target = -1;
+static int hf_x11_glx_render_SharpenTexFuncSGIS_n = -1;
+static int hf_x11_glx_render_SharpenTexFuncSGIS_points = -1;
+static int hf_x11_glx_render_SharpenTexFuncSGIS_points_item = -1;
+static int hf_x11_glx_render_SampleMaskSGIS_value = -1;
+static int hf_x11_glx_render_SampleMaskSGIS_invert = -1;
+static int hf_x11_glx_render_SamplePatternSGIS_pattern = -1;
+static int hf_x11_glx_render_PointParameterfEXT_pname = -1;
+static int hf_x11_glx_render_PointParameterfEXT_param = -1;
+static int hf_x11_glx_render_PointParameterfvEXT_pname = -1;
+static int hf_x11_glx_render_PointParameterfvEXT_params = -1;
+static int hf_x11_glx_render_PointParameterfvEXT_params_item = -1;
+static int hf_x11_glx_render_FrameZoomSGIX_factor = -1;
+static int hf_x11_glx_render_ReferencePlaneSGIX_equation = -1;
+static int hf_x11_glx_render_ReferencePlaneSGIX_equation_item = -1;
+static int hf_x11_glx_render_FogFuncSGIS_n = -1;
+static int hf_x11_glx_render_FogFuncSGIS_points = -1;
+static int hf_x11_glx_render_FogFuncSGIS_points_item = -1;
+static int hf_x11_glx_render_SecondaryColor3bvEXT_v = -1;
+static int hf_x11_glx_render_SecondaryColor3dvEXT_v = -1;
+static int hf_x11_glx_render_SecondaryColor3dvEXT_v_item = -1;
+static int hf_x11_glx_render_SecondaryColor3fvEXT_v = -1;
+static int hf_x11_glx_render_SecondaryColor3fvEXT_v_item = -1;
+static int hf_x11_glx_render_SecondaryColor3ivEXT_v = -1;
+static int hf_x11_glx_render_SecondaryColor3ivEXT_v_item = -1;
+static int hf_x11_glx_render_SecondaryColor3svEXT_v = -1;
+static int hf_x11_glx_render_SecondaryColor3svEXT_v_item = -1;
+static int hf_x11_glx_render_SecondaryColor3ubvEXT_v = -1;
+static int hf_x11_glx_render_SecondaryColor3uivEXT_v = -1;
+static int hf_x11_glx_render_SecondaryColor3uivEXT_v_item = -1;
+static int hf_x11_glx_render_SecondaryColor3usvEXT_v = -1;
+static int hf_x11_glx_render_SecondaryColor3usvEXT_v_item = -1;
+static int hf_x11_glx_render_FogCoordfvEXT_coord = -1;
+static int hf_x11_glx_render_FogCoordfvEXT_coord_item = -1;
+static int hf_x11_glx_render_FogCoorddvEXT_coord = -1;
+static int hf_x11_glx_render_FogCoorddvEXT_coord_item = -1;
+static int hf_x11_glx_render_PixelTexGenSGIX_mode = -1;
+static int hf_x11_glx_render_BlendFuncSeparateEXT_sfactorRGB = -1;
+static int hf_x11_glx_render_BlendFuncSeparateEXT_dfactorRGB = -1;
+static int hf_x11_glx_render_BlendFuncSeparateEXT_sfactorAlpha = -1;
+static int hf_x11_glx_render_BlendFuncSeparateEXT_dfactorAlpha = -1;
+static int hf_x11_glx_render_VertexWeightfvEXT_weight = -1;
+static int hf_x11_glx_render_VertexWeightfvEXT_weight_item = -1;
+static int hf_x11_glx_render_CombinerParameterfvNV_pname = -1;
+static int hf_x11_glx_render_CombinerParameterfvNV_params = -1;
+static int hf_x11_glx_render_CombinerParameterfvNV_params_item = -1;
+static int hf_x11_glx_render_CombinerParameterfNV_pname = -1;
+static int hf_x11_glx_render_CombinerParameterfNV_param = -1;
+static int hf_x11_glx_render_CombinerParameterivNV_pname = -1;
+static int hf_x11_glx_render_CombinerParameterivNV_params = -1;
+static int hf_x11_glx_render_CombinerParameterivNV_params_item = -1;
+static int hf_x11_glx_render_CombinerParameteriNV_pname = -1;
+static int hf_x11_glx_render_CombinerParameteriNV_param = -1;
+static int hf_x11_glx_render_CombinerInputNV_stage = -1;
+static int hf_x11_glx_render_CombinerInputNV_portion = -1;
+static int hf_x11_glx_render_CombinerInputNV_variable = -1;
+static int hf_x11_glx_render_CombinerInputNV_input = -1;
+static int hf_x11_glx_render_CombinerInputNV_mapping = -1;
+static int hf_x11_glx_render_CombinerInputNV_componentUsage = -1;
+static int hf_x11_glx_render_CombinerOutputNV_stage = -1;
+static int hf_x11_glx_render_CombinerOutputNV_portion = -1;
+static int hf_x11_glx_render_CombinerOutputNV_abOutput = -1;
+static int hf_x11_glx_render_CombinerOutputNV_cdOutput = -1;
+static int hf_x11_glx_render_CombinerOutputNV_sumOutput = -1;
+static int hf_x11_glx_render_CombinerOutputNV_scale = -1;
+static int hf_x11_glx_render_CombinerOutputNV_bias = -1;
+static int hf_x11_glx_render_CombinerOutputNV_abDotProduct = -1;
+static int hf_x11_glx_render_CombinerOutputNV_cdDotProduct = -1;
+static int hf_x11_glx_render_CombinerOutputNV_muxSum = -1;
+static int hf_x11_glx_render_FinalCombinerInputNV_variable = -1;
+static int hf_x11_glx_render_FinalCombinerInputNV_input = -1;
+static int hf_x11_glx_render_FinalCombinerInputNV_mapping = -1;
+static int hf_x11_glx_render_FinalCombinerInputNV_componentUsage = -1;
+static int hf_x11_glx_render_WindowPos3fvMESA_v = -1;
+static int hf_x11_glx_render_WindowPos3fvMESA_v_item = -1;
+static int hf_x11_glx_render_TextureColorMaskSGIS_red = -1;
+static int hf_x11_glx_render_TextureColorMaskSGIS_green = -1;
+static int hf_x11_glx_render_TextureColorMaskSGIS_blue = -1;
+static int hf_x11_glx_render_TextureColorMaskSGIS_alpha = -1;
+static int hf_x11_glx_render_BindProgramNV_target = -1;
+static int hf_x11_glx_render_BindProgramNV_program = -1;
+static int hf_x11_glx_render_ExecuteProgramNV_target = -1;
+static int hf_x11_glx_render_ExecuteProgramNV_id = -1;
+static int hf_x11_glx_render_ExecuteProgramNV_params = -1;
+static int hf_x11_glx_render_ExecuteProgramNV_params_item = -1;
+static int hf_x11_glx_render_LoadProgramNV_target = -1;
+static int hf_x11_glx_render_LoadProgramNV_id = -1;
+static int hf_x11_glx_render_LoadProgramNV_len = -1;
+static int hf_x11_glx_render_LoadProgramNV_program = -1;
+static int hf_x11_glx_render_ProgramParameters4dvNV_target = -1;
+static int hf_x11_glx_render_ProgramParameters4dvNV_index = -1;
+static int hf_x11_glx_render_ProgramParameters4dvNV_num = -1;
+static int hf_x11_glx_render_ProgramParameters4dvNV_params = -1;
+static int hf_x11_glx_render_ProgramParameters4dvNV_params_item = -1;
+static int hf_x11_glx_render_ProgramParameters4fvNV_target = -1;
+static int hf_x11_glx_render_ProgramParameters4fvNV_index = -1;
+static int hf_x11_glx_render_ProgramParameters4fvNV_num = -1;
+static int hf_x11_glx_render_ProgramParameters4fvNV_params = -1;
+static int hf_x11_glx_render_ProgramParameters4fvNV_params_item = -1;
+static int hf_x11_glx_render_RequestResidentProgramsNV_n = -1;
+static int hf_x11_glx_render_RequestResidentProgramsNV_ids = -1;
+static int hf_x11_glx_render_RequestResidentProgramsNV_ids_item = -1;
+static int hf_x11_glx_render_TrackMatrixNV_target = -1;
+static int hf_x11_glx_render_TrackMatrixNV_address = -1;
+static int hf_x11_glx_render_TrackMatrixNV_matrix = -1;
+static int hf_x11_glx_render_TrackMatrixNV_transform = -1;
+static int hf_x11_glx_render_VertexAttrib1svNV_index = -1;
+static int hf_x11_glx_render_VertexAttrib1svNV_v = -1;
+static int hf_x11_glx_render_VertexAttrib1svNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib2svNV_index = -1;
+static int hf_x11_glx_render_VertexAttrib2svNV_v = -1;
+static int hf_x11_glx_render_VertexAttrib2svNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib3svNV_index = -1;
+static int hf_x11_glx_render_VertexAttrib3svNV_v = -1;
+static int hf_x11_glx_render_VertexAttrib3svNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib4svNV_index = -1;
+static int hf_x11_glx_render_VertexAttrib4svNV_v = -1;
+static int hf_x11_glx_render_VertexAttrib4svNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib1fvNV_index = -1;
+static int hf_x11_glx_render_VertexAttrib1fvNV_v = -1;
+static int hf_x11_glx_render_VertexAttrib1fvNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib2fvNV_index = -1;
+static int hf_x11_glx_render_VertexAttrib2fvNV_v = -1;
+static int hf_x11_glx_render_VertexAttrib2fvNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib3fvNV_index = -1;
+static int hf_x11_glx_render_VertexAttrib3fvNV_v = -1;
+static int hf_x11_glx_render_VertexAttrib3fvNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib4fvNV_index = -1;
+static int hf_x11_glx_render_VertexAttrib4fvNV_v = -1;
+static int hf_x11_glx_render_VertexAttrib4fvNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib1dvNV_index = -1;
+static int hf_x11_glx_render_VertexAttrib1dvNV_v = -1;
+static int hf_x11_glx_render_VertexAttrib1dvNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib2dvNV_index = -1;
+static int hf_x11_glx_render_VertexAttrib2dvNV_v = -1;
+static int hf_x11_glx_render_VertexAttrib2dvNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib3dvNV_index = -1;
+static int hf_x11_glx_render_VertexAttrib3dvNV_v = -1;
+static int hf_x11_glx_render_VertexAttrib3dvNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib4dvNV_index = -1;
+static int hf_x11_glx_render_VertexAttrib4dvNV_v = -1;
+static int hf_x11_glx_render_VertexAttrib4dvNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttrib4ubvNV_index = -1;
+static int hf_x11_glx_render_VertexAttrib4ubvNV_v = -1;
+static int hf_x11_glx_render_VertexAttribs1svNV_index = -1;
+static int hf_x11_glx_render_VertexAttribs1svNV_n = -1;
+static int hf_x11_glx_render_VertexAttribs1svNV_v = -1;
+static int hf_x11_glx_render_VertexAttribs1svNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttribs2svNV_index = -1;
+static int hf_x11_glx_render_VertexAttribs2svNV_n = -1;
+static int hf_x11_glx_render_VertexAttribs2svNV_v = -1;
+static int hf_x11_glx_render_VertexAttribs2svNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttribs3svNV_index = -1;
+static int hf_x11_glx_render_VertexAttribs3svNV_n = -1;
+static int hf_x11_glx_render_VertexAttribs3svNV_v = -1;
+static int hf_x11_glx_render_VertexAttribs3svNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttribs4svNV_index = -1;
+static int hf_x11_glx_render_VertexAttribs4svNV_n = -1;
+static int hf_x11_glx_render_VertexAttribs4svNV_v = -1;
+static int hf_x11_glx_render_VertexAttribs4svNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttribs1fvNV_index = -1;
+static int hf_x11_glx_render_VertexAttribs1fvNV_n = -1;
+static int hf_x11_glx_render_VertexAttribs1fvNV_v = -1;
+static int hf_x11_glx_render_VertexAttribs1fvNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttribs2fvNV_index = -1;
+static int hf_x11_glx_render_VertexAttribs2fvNV_n = -1;
+static int hf_x11_glx_render_VertexAttribs2fvNV_v = -1;
+static int hf_x11_glx_render_VertexAttribs2fvNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttribs3fvNV_index = -1;
+static int hf_x11_glx_render_VertexAttribs3fvNV_n = -1;
+static int hf_x11_glx_render_VertexAttribs3fvNV_v = -1;
+static int hf_x11_glx_render_VertexAttribs3fvNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttribs4fvNV_index = -1;
+static int hf_x11_glx_render_VertexAttribs4fvNV_n = -1;
+static int hf_x11_glx_render_VertexAttribs4fvNV_v = -1;
+static int hf_x11_glx_render_VertexAttribs4fvNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttribs1dvNV_index = -1;
+static int hf_x11_glx_render_VertexAttribs1dvNV_n = -1;
+static int hf_x11_glx_render_VertexAttribs1dvNV_v = -1;
+static int hf_x11_glx_render_VertexAttribs1dvNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttribs2dvNV_index = -1;
+static int hf_x11_glx_render_VertexAttribs2dvNV_n = -1;
+static int hf_x11_glx_render_VertexAttribs2dvNV_v = -1;
+static int hf_x11_glx_render_VertexAttribs2dvNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttribs3dvNV_index = -1;
+static int hf_x11_glx_render_VertexAttribs3dvNV_n = -1;
+static int hf_x11_glx_render_VertexAttribs3dvNV_v = -1;
+static int hf_x11_glx_render_VertexAttribs3dvNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttribs4dvNV_index = -1;
+static int hf_x11_glx_render_VertexAttribs4dvNV_n = -1;
+static int hf_x11_glx_render_VertexAttribs4dvNV_v = -1;
+static int hf_x11_glx_render_VertexAttribs4dvNV_v_item = -1;
+static int hf_x11_glx_render_VertexAttribs4ubvNV_index = -1;
+static int hf_x11_glx_render_VertexAttribs4ubvNV_n = -1;
+static int hf_x11_glx_render_VertexAttribs4ubvNV_v = -1;
+static int hf_x11_glx_render_PointParameteriNV_pname = -1;
+static int hf_x11_glx_render_PointParameteriNV_param = -1;
+static int hf_x11_glx_render_PointParameterivNV_pname = -1;
+static int hf_x11_glx_render_PointParameterivNV_params = -1;
+static int hf_x11_glx_render_PointParameterivNV_params_item = -1;
+static int hf_x11_glx_render_ActiveStencilFaceEXT_face = -1;
+static int hf_x11_glx_render_ProgramNamedParameter4fvNV_id = -1;
+static int hf_x11_glx_render_ProgramNamedParameter4fvNV_len = -1;
+static int hf_x11_glx_render_ProgramNamedParameter4fvNV_name = -1;
+static int hf_x11_glx_render_ProgramNamedParameter4fvNV_v = -1;
+static int hf_x11_glx_render_ProgramNamedParameter4fvNV_v_item = -1;
+static int hf_x11_glx_render_ProgramNamedParameter4dvNV_id = -1;
+static int hf_x11_glx_render_ProgramNamedParameter4dvNV_len = -1;
+static int hf_x11_glx_render_ProgramNamedParameter4dvNV_name = -1;
+static int hf_x11_glx_render_ProgramNamedParameter4dvNV_v = -1;
+static int hf_x11_glx_render_ProgramNamedParameter4dvNV_v_item = -1;
+static int hf_x11_glx_render_DepthBoundsEXT_zmin = -1;
+static int hf_x11_glx_render_DepthBoundsEXT_zmax = -1;
+static int hf_x11_glx_render_BlendEquationSeparateEXT_modeRGB = -1;
+static int hf_x11_glx_render_BlendEquationSeparateEXT_modeA = -1;
+static int hf_x11_glx_render_op_name = -1;
+
+static int hf_x11_bigreq_Enable_reply_maximum_request_length = -1;
+static int hf_x11_bigreq_extension_minor = -1;
+
+static int hf_x11_struct_RECTANGLE = -1;
+static int hf_x11_struct_RECTANGLE_x = -1;
+static int hf_x11_struct_RECTANGLE_y = -1;
+static int hf_x11_struct_RECTANGLE_width = -1;
+static int hf_x11_struct_RECTANGLE_height = -1;
+static int hf_x11_struct_STR = -1;
+static int hf_x11_struct_STR_name_len = -1;
+static int hf_x11_struct_STR_name = -1;
+static int hf_x11_struct_DIRECTFORMAT = -1;
+static int hf_x11_struct_DIRECTFORMAT_red_shift = -1;
+static int hf_x11_struct_DIRECTFORMAT_red_mask = -1;
+static int hf_x11_struct_DIRECTFORMAT_green_shift = -1;
+static int hf_x11_struct_DIRECTFORMAT_green_mask = -1;
+static int hf_x11_struct_DIRECTFORMAT_blue_shift = -1;
+static int hf_x11_struct_DIRECTFORMAT_blue_mask = -1;
+static int hf_x11_struct_DIRECTFORMAT_alpha_shift = -1;
+static int hf_x11_struct_DIRECTFORMAT_alpha_mask = -1;
+static int hf_x11_struct_PICTFORMINFO = -1;
+static int hf_x11_struct_PICTFORMINFO_id = -1;
+static int hf_x11_struct_PICTFORMINFO_type = -1;
+static int hf_x11_struct_PICTFORMINFO_depth = -1;
+static int hf_x11_struct_PICTFORMINFO_direct = -1;
+static int hf_x11_struct_PICTFORMINFO_colormap = -1;
+static int hf_x11_struct_PICTVISUAL = -1;
+static int hf_x11_struct_PICTVISUAL_visual = -1;
+static int hf_x11_struct_PICTVISUAL_format = -1;
+static int hf_x11_struct_PICTDEPTH = -1;
+static int hf_x11_struct_PICTDEPTH_depth = -1;
+static int hf_x11_struct_PICTDEPTH_num_visuals = -1;
+static int hf_x11_struct_PICTDEPTH_visuals = -1;
+static int hf_x11_struct_PICTDEPTH_visuals_item = -1;
+static int hf_x11_struct_PICTSCREEN = -1;
+static int hf_x11_struct_PICTSCREEN_num_depths = -1;
+static int hf_x11_struct_PICTSCREEN_fallback = -1;
+static int hf_x11_struct_PICTSCREEN_depths = -1;
+static int hf_x11_struct_INDEXVALUE = -1;
+static int hf_x11_struct_INDEXVALUE_pixel = -1;
+static int hf_x11_struct_INDEXVALUE_red = -1;
+static int hf_x11_struct_INDEXVALUE_green = -1;
+static int hf_x11_struct_INDEXVALUE_blue = -1;
+static int hf_x11_struct_INDEXVALUE_alpha = -1;
+static int hf_x11_struct_COLOR = -1;
+static int hf_x11_struct_COLOR_red = -1;
+static int hf_x11_struct_COLOR_green = -1;
+static int hf_x11_struct_COLOR_blue = -1;
+static int hf_x11_struct_COLOR_alpha = -1;
+static int hf_x11_struct_POINTFIX = -1;
+static int hf_x11_struct_POINTFIX_x = -1;
+static int hf_x11_struct_POINTFIX_y = -1;
+static int hf_x11_struct_LINEFIX = -1;
+static int hf_x11_struct_LINEFIX_p1 = -1;
+static int hf_x11_struct_LINEFIX_p2 = -1;
+static int hf_x11_struct_TRIANGLE = -1;
+static int hf_x11_struct_TRIANGLE_p1 = -1;
+static int hf_x11_struct_TRIANGLE_p2 = -1;
+static int hf_x11_struct_TRIANGLE_p3 = -1;
+static int hf_x11_struct_TRAPEZOID = -1;
+static int hf_x11_struct_TRAPEZOID_top = -1;
+static int hf_x11_struct_TRAPEZOID_bottom = -1;
+static int hf_x11_struct_TRAPEZOID_left = -1;
+static int hf_x11_struct_TRAPEZOID_right = -1;
+static int hf_x11_struct_GLYPHINFO = -1;
+static int hf_x11_struct_GLYPHINFO_width = -1;
+static int hf_x11_struct_GLYPHINFO_height = -1;
+static int hf_x11_struct_GLYPHINFO_x = -1;
+static int hf_x11_struct_GLYPHINFO_y = -1;
+static int hf_x11_struct_GLYPHINFO_x_off = -1;
+static int hf_x11_struct_GLYPHINFO_y_off = -1;
+static int hf_x11_struct_TRANSFORM = -1;
+static int hf_x11_struct_TRANSFORM_matrix11 = -1;
+static int hf_x11_struct_TRANSFORM_matrix12 = -1;
+static int hf_x11_struct_TRANSFORM_matrix13 = -1;
+static int hf_x11_struct_TRANSFORM_matrix21 = -1;
+static int hf_x11_struct_TRANSFORM_matrix22 = -1;
+static int hf_x11_struct_TRANSFORM_matrix23 = -1;
+static int hf_x11_struct_TRANSFORM_matrix31 = -1;
+static int hf_x11_struct_TRANSFORM_matrix32 = -1;
+static int hf_x11_struct_TRANSFORM_matrix33 = -1;
+static int hf_x11_struct_ANIMCURSORELT = -1;
+static int hf_x11_struct_ANIMCURSORELT_cursor = -1;
+static int hf_x11_struct_ANIMCURSORELT_delay = -1;
+static int hf_x11_struct_SPANFIX = -1;
+static int hf_x11_struct_SPANFIX_l = -1;
+static int hf_x11_struct_SPANFIX_r = -1;
+static int hf_x11_struct_SPANFIX_y = -1;
+static int hf_x11_struct_TRAP = -1;
+static int hf_x11_struct_TRAP_top = -1;
+static int hf_x11_struct_TRAP_bot = -1;
+static int hf_x11_composite_QueryVersion_client_major_version = -1;
+static int hf_x11_composite_QueryVersion_client_minor_version = -1;
+static int hf_x11_composite_QueryVersion_reply_major_version = -1;
+static int hf_x11_composite_QueryVersion_reply_minor_version = -1;
+static int hf_x11_composite_RedirectWindow_window = -1;
+static int hf_x11_composite_RedirectWindow_update = -1;
+static int hf_x11_composite_RedirectSubwindows_window = -1;
+static int hf_x11_composite_RedirectSubwindows_update = -1;
+static int hf_x11_composite_UnredirectWindow_window = -1;
+static int hf_x11_composite_UnredirectWindow_update = -1;
+static int hf_x11_composite_UnredirectSubwindows_window = -1;
+static int hf_x11_composite_UnredirectSubwindows_update = -1;
+static int hf_x11_composite_CreateRegionFromBorderClip_region = -1;
+static int hf_x11_composite_CreateRegionFromBorderClip_window = -1;
+static int hf_x11_composite_NameWindowPixmap_window = -1;
+static int hf_x11_composite_NameWindowPixmap_pixmap = -1;
+static int hf_x11_composite_GetOverlayWindow_window = -1;
+static int hf_x11_composite_GetOverlayWindow_reply_overlay_win = -1;
+static int hf_x11_composite_ReleaseOverlayWindow_window = -1;
+static int hf_x11_composite_extension_minor = -1;
+
+static int hf_x11_damage_QueryVersion_client_major_version = -1;
+static int hf_x11_damage_QueryVersion_client_minor_version = -1;
+static int hf_x11_damage_QueryVersion_reply_major_version = -1;
+static int hf_x11_damage_QueryVersion_reply_minor_version = -1;
+static int hf_x11_damage_Create_damage = -1;
+static int hf_x11_damage_Create_drawable = -1;
+static int hf_x11_damage_Create_level = -1;
+static int hf_x11_damage_Destroy_damage = -1;
+static int hf_x11_damage_Subtract_damage = -1;
+static int hf_x11_damage_Subtract_repair = -1;
+static int hf_x11_damage_Subtract_parts = -1;
+static int hf_x11_damage_Add_drawable = -1;
+static int hf_x11_damage_Add_region = -1;
+static int hf_x11_damage_Notify_level = -1;
+static int hf_x11_damage_Notify_drawable = -1;
+static int hf_x11_damage_Notify_damage = -1;
+static int hf_x11_damage_Notify_timestamp = -1;
+static int hf_x11_damage_Notify_area = -1;
+static int hf_x11_damage_Notify_geometry = -1;
+static int hf_x11_damage_extension_minor = -1;
+
+static int hf_x11_dpms_GetVersion_client_major_version = -1;
+static int hf_x11_dpms_GetVersion_client_minor_version = -1;
+static int hf_x11_dpms_GetVersion_reply_server_major_version = -1;
+static int hf_x11_dpms_GetVersion_reply_server_minor_version = -1;
+static int hf_x11_dpms_Capable_reply_capable = -1;
+static int hf_x11_dpms_GetTimeouts_reply_standby_timeout = -1;
+static int hf_x11_dpms_GetTimeouts_reply_suspend_timeout = -1;
+static int hf_x11_dpms_GetTimeouts_reply_off_timeout = -1;
+static int hf_x11_dpms_SetTimeouts_standby_timeout = -1;
+static int hf_x11_dpms_SetTimeouts_suspend_timeout = -1;
+static int hf_x11_dpms_SetTimeouts_off_timeout = -1;
+static int hf_x11_dpms_ForceLevel_power_level = -1;
+static int hf_x11_dpms_Info_reply_power_level = -1;
+static int hf_x11_dpms_Info_reply_state = -1;
+static int hf_x11_dpms_extension_minor = -1;
+
+static int hf_x11_ge_QueryVersion_client_major_version = -1;
+static int hf_x11_ge_QueryVersion_client_minor_version = -1;
+static int hf_x11_ge_QueryVersion_reply_major_version = -1;
+static int hf_x11_ge_QueryVersion_reply_minor_version = -1;
+static int hf_x11_ge_extension_minor = -1;
+
+static int hf_x11_glx_PbufferClobber_event_type = -1;
+static int hf_x11_glx_PbufferClobber_draw_type = -1;
+static int hf_x11_glx_PbufferClobber_drawable = -1;
+static int hf_x11_glx_PbufferClobber_b_mask = -1;
+static int hf_x11_glx_PbufferClobber_aux_buffer = -1;
+static int hf_x11_glx_PbufferClobber_x = -1;
+static int hf_x11_glx_PbufferClobber_y = -1;
+static int hf_x11_glx_PbufferClobber_width = -1;
+static int hf_x11_glx_PbufferClobber_height = -1;
+static int hf_x11_glx_PbufferClobber_count = -1;
+static int hf_x11_glx_Render_context_tag = -1;
+static int hf_x11_glx_Render_data = -1;
+static int hf_x11_glx_RenderLarge_context_tag = -1;
+static int hf_x11_glx_RenderLarge_request_num = -1;
+static int hf_x11_glx_RenderLarge_request_total = -1;
+static int hf_x11_glx_RenderLarge_data_len = -1;
+static int hf_x11_glx_RenderLarge_data = -1;
+static int hf_x11_glx_CreateContext_context = -1;
+static int hf_x11_glx_CreateContext_visual = -1;
+static int hf_x11_glx_CreateContext_screen = -1;
+static int hf_x11_glx_CreateContext_share_list = -1;
+static int hf_x11_glx_CreateContext_is_direct = -1;
+static int hf_x11_glx_DestroyContext_context = -1;
+static int hf_x11_glx_MakeCurrent_drawable = -1;
+static int hf_x11_glx_MakeCurrent_context = -1;
+static int hf_x11_glx_MakeCurrent_old_context_tag = -1;
+static int hf_x11_glx_MakeCurrent_reply_context_tag = -1;
+static int hf_x11_glx_IsDirect_context = -1;
+static int hf_x11_glx_IsDirect_reply_is_direct = -1;
+static int hf_x11_glx_QueryVersion_major_version = -1;
+static int hf_x11_glx_QueryVersion_minor_version = -1;
+static int hf_x11_glx_QueryVersion_reply_major_version = -1;
+static int hf_x11_glx_QueryVersion_reply_minor_version = -1;
+static int hf_x11_glx_WaitGL_context_tag = -1;
+static int hf_x11_glx_WaitX_context_tag = -1;
+static int hf_x11_glx_CopyContext_src = -1;
+static int hf_x11_glx_CopyContext_dest = -1;
+static int hf_x11_glx_CopyContext_mask = -1;
+static int hf_x11_glx_CopyContext_src_context_tag = -1;
+static int hf_x11_glx_SwapBuffers_context_tag = -1;
+static int hf_x11_glx_SwapBuffers_drawable = -1;
+static int hf_x11_glx_UseXFont_context_tag = -1;
+static int hf_x11_glx_UseXFont_font = -1;
+static int hf_x11_glx_UseXFont_first = -1;
+static int hf_x11_glx_UseXFont_count = -1;
+static int hf_x11_glx_UseXFont_list_base = -1;
+static int hf_x11_glx_CreateGLXPixmap_screen = -1;
+static int hf_x11_glx_CreateGLXPixmap_visual = -1;
+static int hf_x11_glx_CreateGLXPixmap_pixmap = -1;
+static int hf_x11_glx_CreateGLXPixmap_glx_pixmap = -1;
+static int hf_x11_glx_GetVisualConfigs_screen = -1;
+static int hf_x11_glx_GetVisualConfigs_reply_num_visuals = -1;
+static int hf_x11_glx_GetVisualConfigs_reply_num_properties = -1;
+static int hf_x11_glx_GetVisualConfigs_reply_property_list = -1;
+static int hf_x11_glx_GetVisualConfigs_reply_property_list_item = -1;
+static int hf_x11_glx_DestroyGLXPixmap_glx_pixmap = -1;
+static int hf_x11_glx_VendorPrivate_vendor_code = -1;
+static int hf_x11_glx_VendorPrivate_context_tag = -1;
+static int hf_x11_glx_VendorPrivate_data = -1;
+static int hf_x11_glx_VendorPrivateWithReply_vendor_code = -1;
+static int hf_x11_glx_VendorPrivateWithReply_context_tag = -1;
+static int hf_x11_glx_VendorPrivateWithReply_data = -1;
+static int hf_x11_glx_VendorPrivateWithReply_reply_retval = -1;
+static int hf_x11_glx_VendorPrivateWithReply_reply_data1 = -1;
+static int hf_x11_glx_VendorPrivateWithReply_reply_data2 = -1;
+static int hf_x11_glx_QueryExtensionsString_screen = -1;
+static int hf_x11_glx_QueryExtensionsString_reply_n = -1;
+static int hf_x11_glx_QueryServerString_screen = -1;
+static int hf_x11_glx_QueryServerString_name = -1;
+static int hf_x11_glx_QueryServerString_reply_str_len = -1;
+static int hf_x11_glx_QueryServerString_reply_string = -1;
+static int hf_x11_glx_ClientInfo_major_version = -1;
+static int hf_x11_glx_ClientInfo_minor_version = -1;
+static int hf_x11_glx_ClientInfo_str_len = -1;
+static int hf_x11_glx_ClientInfo_string = -1;
+static int hf_x11_glx_GetFBConfigs_screen = -1;
+static int hf_x11_glx_GetFBConfigs_reply_num_FB_configs = -1;
+static int hf_x11_glx_GetFBConfigs_reply_num_properties = -1;
+static int hf_x11_glx_GetFBConfigs_reply_property_list = -1;
+static int hf_x11_glx_GetFBConfigs_reply_property_list_item = -1;
+static int hf_x11_glx_CreatePixmap_screen = -1;
+static int hf_x11_glx_CreatePixmap_fbconfig = -1;
+static int hf_x11_glx_CreatePixmap_pixmap = -1;
+static int hf_x11_glx_CreatePixmap_glx_pixmap = -1;
+static int hf_x11_glx_CreatePixmap_num_attribs = -1;
+static int hf_x11_glx_CreatePixmap_attribs = -1;
+static int hf_x11_glx_CreatePixmap_attribs_item = -1;
+static int hf_x11_glx_DestroyPixmap_glx_pixmap = -1;
+static int hf_x11_glx_CreateNewContext_context = -1;
+static int hf_x11_glx_CreateNewContext_fbconfig = -1;
+static int hf_x11_glx_CreateNewContext_screen = -1;
+static int hf_x11_glx_CreateNewContext_render_type = -1;
+static int hf_x11_glx_CreateNewContext_share_list = -1;
+static int hf_x11_glx_CreateNewContext_is_direct = -1;
+static int hf_x11_glx_CreateNewContext_reserved1 = -1;
+static int hf_x11_glx_CreateNewContext_reserved2 = -1;
+static int hf_x11_glx_QueryContext_context = -1;
+static int hf_x11_glx_QueryContext_reply_num_attribs = -1;
+static int hf_x11_glx_QueryContext_reply_attribs = -1;
+static int hf_x11_glx_QueryContext_reply_attribs_item = -1;
+static int hf_x11_glx_MakeContextCurrent_old_context_tag = -1;
+static int hf_x11_glx_MakeContextCurrent_drawable = -1;
+static int hf_x11_glx_MakeContextCurrent_read_drawable = -1;
+static int hf_x11_glx_MakeContextCurrent_context = -1;
+static int hf_x11_glx_MakeContextCurrent_reply_context_tag = -1;
+static int hf_x11_glx_CreatePbuffer_screen = -1;
+static int hf_x11_glx_CreatePbuffer_fbconfig = -1;
+static int hf_x11_glx_CreatePbuffer_pbuffer = -1;
+static int hf_x11_glx_CreatePbuffer_num_attribs = -1;
+static int hf_x11_glx_CreatePbuffer_attribs = -1;
+static int hf_x11_glx_CreatePbuffer_attribs_item = -1;
+static int hf_x11_glx_DestroyPbuffer_pbuffer = -1;
+static int hf_x11_glx_GetDrawableAttributes_drawable = -1;
+static int hf_x11_glx_GetDrawableAttributes_reply_num_attribs = -1;
+static int hf_x11_glx_GetDrawableAttributes_reply_attribs = -1;
+static int hf_x11_glx_GetDrawableAttributes_reply_attribs_item = -1;
+static int hf_x11_glx_ChangeDrawableAttributes_drawable = -1;
+static int hf_x11_glx_ChangeDrawableAttributes_num_attribs = -1;
+static int hf_x11_glx_ChangeDrawableAttributes_attribs = -1;
+static int hf_x11_glx_ChangeDrawableAttributes_attribs_item = -1;
+static int hf_x11_glx_CreateWindow_screen = -1;
+static int hf_x11_glx_CreateWindow_fbconfig = -1;
+static int hf_x11_glx_CreateWindow_window = -1;
+static int hf_x11_glx_CreateWindow_glx_window = -1;
+static int hf_x11_glx_CreateWindow_num_attribs = -1;
+static int hf_x11_glx_CreateWindow_attribs = -1;
+static int hf_x11_glx_CreateWindow_attribs_item = -1;
+static int hf_x11_glx_DeleteWindow_glxwindow = -1;
+static int hf_x11_glx_NewList_context_tag = -1;
+static int hf_x11_glx_NewList_list = -1;
+static int hf_x11_glx_NewList_mode = -1;
+static int hf_x11_glx_EndList_context_tag = -1;
+static int hf_x11_glx_DeleteLists_context_tag = -1;
+static int hf_x11_glx_DeleteLists_list = -1;
+static int hf_x11_glx_DeleteLists_range = -1;
+static int hf_x11_glx_GenLists_context_tag = -1;
+static int hf_x11_glx_GenLists_range = -1;
+static int hf_x11_glx_GenLists_reply_ret_val = -1;
+static int hf_x11_glx_FeedbackBuffer_context_tag = -1;
+static int hf_x11_glx_FeedbackBuffer_size = -1;
+static int hf_x11_glx_FeedbackBuffer_type = -1;
+static int hf_x11_glx_SelectBuffer_context_tag = -1;
+static int hf_x11_glx_SelectBuffer_size = -1;
+static int hf_x11_glx_RenderMode_context_tag = -1;
+static int hf_x11_glx_RenderMode_mode = -1;
+static int hf_x11_glx_RenderMode_reply_ret_val = -1;
+static int hf_x11_glx_RenderMode_reply_n = -1;
+static int hf_x11_glx_RenderMode_reply_new_mode = -1;
+static int hf_x11_glx_RenderMode_reply_data = -1;
+static int hf_x11_glx_RenderMode_reply_data_item = -1;
+static int hf_x11_glx_Finish_context_tag = -1;
+static int hf_x11_glx_PixelStoref_context_tag = -1;
+static int hf_x11_glx_PixelStoref_pname = -1;
+static int hf_x11_glx_PixelStoref_datum = -1;
+static int hf_x11_glx_PixelStorei_context_tag = -1;
+static int hf_x11_glx_PixelStorei_pname = -1;
+static int hf_x11_glx_PixelStorei_datum = -1;
+static int hf_x11_glx_ReadPixels_context_tag = -1;
+static int hf_x11_glx_ReadPixels_x = -1;
+static int hf_x11_glx_ReadPixels_y = -1;
+static int hf_x11_glx_ReadPixels_width = -1;
+static int hf_x11_glx_ReadPixels_height = -1;
+static int hf_x11_glx_ReadPixels_format = -1;
+static int hf_x11_glx_ReadPixels_type = -1;
+static int hf_x11_glx_ReadPixels_swap_bytes = -1;
+static int hf_x11_glx_ReadPixels_lsb_first = -1;
+static int hf_x11_glx_ReadPixels_reply_data = -1;
+static int hf_x11_glx_GetBooleanv_context_tag = -1;
+static int hf_x11_glx_GetBooleanv_pname = -1;
+static int hf_x11_glx_GetBooleanv_reply_n = -1;
+static int hf_x11_glx_GetBooleanv_reply_datum = -1;
+static int hf_x11_glx_GetBooleanv_reply_data = -1;
+static int hf_x11_glx_GetClipPlane_context_tag = -1;
+static int hf_x11_glx_GetClipPlane_plane = -1;
+static int hf_x11_glx_GetClipPlane_reply_data = -1;
+static int hf_x11_glx_GetClipPlane_reply_data_item = -1;
+static int hf_x11_glx_GetDoublev_context_tag = -1;
+static int hf_x11_glx_GetDoublev_pname = -1;
+static int hf_x11_glx_GetDoublev_reply_n = -1;
+static int hf_x11_glx_GetDoublev_reply_datum = -1;
+static int hf_x11_glx_GetDoublev_reply_data = -1;
+static int hf_x11_glx_GetDoublev_reply_data_item = -1;
+static int hf_x11_glx_GetError_context_tag = -1;
+static int hf_x11_glx_GetError_reply_error = -1;
+static int hf_x11_glx_GetFloatv_context_tag = -1;
+static int hf_x11_glx_GetFloatv_pname = -1;
+static int hf_x11_glx_GetFloatv_reply_n = -1;
+static int hf_x11_glx_GetFloatv_reply_datum = -1;
+static int hf_x11_glx_GetFloatv_reply_data = -1;
+static int hf_x11_glx_GetFloatv_reply_data_item = -1;
+static int hf_x11_glx_GetIntegerv_context_tag = -1;
+static int hf_x11_glx_GetIntegerv_pname = -1;
+static int hf_x11_glx_GetIntegerv_reply_n = -1;
+static int hf_x11_glx_GetIntegerv_reply_datum = -1;
+static int hf_x11_glx_GetIntegerv_reply_data = -1;
+static int hf_x11_glx_GetIntegerv_reply_data_item = -1;
+static int hf_x11_glx_GetLightfv_context_tag = -1;
+static int hf_x11_glx_GetLightfv_light = -1;
+static int hf_x11_glx_GetLightfv_pname = -1;
+static int hf_x11_glx_GetLightfv_reply_n = -1;
+static int hf_x11_glx_GetLightfv_reply_datum = -1;
+static int hf_x11_glx_GetLightfv_reply_data = -1;
+static int hf_x11_glx_GetLightfv_reply_data_item = -1;
+static int hf_x11_glx_GetLightiv_context_tag = -1;
+static int hf_x11_glx_GetLightiv_light = -1;
+static int hf_x11_glx_GetLightiv_pname = -1;
+static int hf_x11_glx_GetLightiv_reply_n = -1;
+static int hf_x11_glx_GetLightiv_reply_datum = -1;
+static int hf_x11_glx_GetLightiv_reply_data = -1;
+static int hf_x11_glx_GetLightiv_reply_data_item = -1;
+static int hf_x11_glx_GetMapdv_context_tag = -1;
+static int hf_x11_glx_GetMapdv_target = -1;
+static int hf_x11_glx_GetMapdv_query = -1;
+static int hf_x11_glx_GetMapdv_reply_n = -1;
+static int hf_x11_glx_GetMapdv_reply_datum = -1;
+static int hf_x11_glx_GetMapdv_reply_data = -1;
+static int hf_x11_glx_GetMapdv_reply_data_item = -1;
+static int hf_x11_glx_GetMapfv_context_tag = -1;
+static int hf_x11_glx_GetMapfv_target = -1;
+static int hf_x11_glx_GetMapfv_query = -1;
+static int hf_x11_glx_GetMapfv_reply_n = -1;
+static int hf_x11_glx_GetMapfv_reply_datum = -1;
+static int hf_x11_glx_GetMapfv_reply_data = -1;
+static int hf_x11_glx_GetMapfv_reply_data_item = -1;
+static int hf_x11_glx_GetMapiv_context_tag = -1;
+static int hf_x11_glx_GetMapiv_target = -1;
+static int hf_x11_glx_GetMapiv_query = -1;
+static int hf_x11_glx_GetMapiv_reply_n = -1;
+static int hf_x11_glx_GetMapiv_reply_datum = -1;
+static int hf_x11_glx_GetMapiv_reply_data = -1;
+static int hf_x11_glx_GetMapiv_reply_data_item = -1;
+static int hf_x11_glx_GetMaterialfv_context_tag = -1;
+static int hf_x11_glx_GetMaterialfv_face = -1;
+static int hf_x11_glx_GetMaterialfv_pname = -1;
+static int hf_x11_glx_GetMaterialfv_reply_n = -1;
+static int hf_x11_glx_GetMaterialfv_reply_datum = -1;
+static int hf_x11_glx_GetMaterialfv_reply_data = -1;
+static int hf_x11_glx_GetMaterialfv_reply_data_item = -1;
+static int hf_x11_glx_GetMaterialiv_context_tag = -1;
+static int hf_x11_glx_GetMaterialiv_face = -1;
+static int hf_x11_glx_GetMaterialiv_pname = -1;
+static int hf_x11_glx_GetMaterialiv_reply_n = -1;
+static int hf_x11_glx_GetMaterialiv_reply_datum = -1;
+static int hf_x11_glx_GetMaterialiv_reply_data = -1;
+static int hf_x11_glx_GetMaterialiv_reply_data_item = -1;
+static int hf_x11_glx_GetPixelMapfv_context_tag = -1;
+static int hf_x11_glx_GetPixelMapfv_map = -1;
+static int hf_x11_glx_GetPixelMapfv_reply_n = -1;
+static int hf_x11_glx_GetPixelMapfv_reply_datum = -1;
+static int hf_x11_glx_GetPixelMapfv_reply_data = -1;
+static int hf_x11_glx_GetPixelMapfv_reply_data_item = -1;
+static int hf_x11_glx_GetPixelMapuiv_context_tag = -1;
+static int hf_x11_glx_GetPixelMapuiv_map = -1;
+static int hf_x11_glx_GetPixelMapuiv_reply_n = -1;
+static int hf_x11_glx_GetPixelMapuiv_reply_datum = -1;
+static int hf_x11_glx_GetPixelMapuiv_reply_data = -1;
+static int hf_x11_glx_GetPixelMapuiv_reply_data_item = -1;
+static int hf_x11_glx_GetPixelMapusv_context_tag = -1;
+static int hf_x11_glx_GetPixelMapusv_map = -1;
+static int hf_x11_glx_GetPixelMapusv_reply_n = -1;
+static int hf_x11_glx_GetPixelMapusv_reply_datum = -1;
+static int hf_x11_glx_GetPixelMapusv_reply_data = -1;
+static int hf_x11_glx_GetPixelMapusv_reply_data_item = -1;
+static int hf_x11_glx_GetPolygonStipple_context_tag = -1;
+static int hf_x11_glx_GetPolygonStipple_lsb_first = -1;
+static int hf_x11_glx_GetPolygonStipple_reply_data = -1;
+static int hf_x11_glx_GetString_context_tag = -1;
+static int hf_x11_glx_GetString_name = -1;
+static int hf_x11_glx_GetString_reply_n = -1;
+static int hf_x11_glx_GetString_reply_string = -1;
+static int hf_x11_glx_GetTexEnvfv_context_tag = -1;
+static int hf_x11_glx_GetTexEnvfv_target = -1;
+static int hf_x11_glx_GetTexEnvfv_pname = -1;
+static int hf_x11_glx_GetTexEnvfv_reply_n = -1;
+static int hf_x11_glx_GetTexEnvfv_reply_datum = -1;
+static int hf_x11_glx_GetTexEnvfv_reply_data = -1;
+static int hf_x11_glx_GetTexEnvfv_reply_data_item = -1;
+static int hf_x11_glx_GetTexEnviv_context_tag = -1;
+static int hf_x11_glx_GetTexEnviv_target = -1;
+static int hf_x11_glx_GetTexEnviv_pname = -1;
+static int hf_x11_glx_GetTexEnviv_reply_n = -1;
+static int hf_x11_glx_GetTexEnviv_reply_datum = -1;
+static int hf_x11_glx_GetTexEnviv_reply_data = -1;
+static int hf_x11_glx_GetTexEnviv_reply_data_item = -1;
+static int hf_x11_glx_GetTexGendv_context_tag = -1;
+static int hf_x11_glx_GetTexGendv_coord = -1;
+static int hf_x11_glx_GetTexGendv_pname = -1;
+static int hf_x11_glx_GetTexGendv_reply_n = -1;
+static int hf_x11_glx_GetTexGendv_reply_datum = -1;
+static int hf_x11_glx_GetTexGendv_reply_data = -1;
+static int hf_x11_glx_GetTexGendv_reply_data_item = -1;
+static int hf_x11_glx_GetTexGenfv_context_tag = -1;
+static int hf_x11_glx_GetTexGenfv_coord = -1;
+static int hf_x11_glx_GetTexGenfv_pname = -1;
+static int hf_x11_glx_GetTexGenfv_reply_n = -1;
+static int hf_x11_glx_GetTexGenfv_reply_datum = -1;
+static int hf_x11_glx_GetTexGenfv_reply_data = -1;
+static int hf_x11_glx_GetTexGenfv_reply_data_item = -1;
+static int hf_x11_glx_GetTexGeniv_context_tag = -1;
+static int hf_x11_glx_GetTexGeniv_coord = -1;
+static int hf_x11_glx_GetTexGeniv_pname = -1;
+static int hf_x11_glx_GetTexGeniv_reply_n = -1;
+static int hf_x11_glx_GetTexGeniv_reply_datum = -1;
+static int hf_x11_glx_GetTexGeniv_reply_data = -1;
+static int hf_x11_glx_GetTexGeniv_reply_data_item = -1;
+static int hf_x11_glx_GetTexImage_context_tag = -1;
+static int hf_x11_glx_GetTexImage_target = -1;
+static int hf_x11_glx_GetTexImage_level = -1;
+static int hf_x11_glx_GetTexImage_format = -1;
+static int hf_x11_glx_GetTexImage_type = -1;
+static int hf_x11_glx_GetTexImage_swap_bytes = -1;
+static int hf_x11_glx_GetTexImage_reply_width = -1;
+static int hf_x11_glx_GetTexImage_reply_height = -1;
+static int hf_x11_glx_GetTexImage_reply_depth = -1;
+static int hf_x11_glx_GetTexImage_reply_data = -1;
+static int hf_x11_glx_GetTexParameterfv_context_tag = -1;
+static int hf_x11_glx_GetTexParameterfv_target = -1;
+static int hf_x11_glx_GetTexParameterfv_pname = -1;
+static int hf_x11_glx_GetTexParameterfv_reply_n = -1;
+static int hf_x11_glx_GetTexParameterfv_reply_datum = -1;
+static int hf_x11_glx_GetTexParameterfv_reply_data = -1;
+static int hf_x11_glx_GetTexParameterfv_reply_data_item = -1;
+static int hf_x11_glx_GetTexParameteriv_context_tag = -1;
+static int hf_x11_glx_GetTexParameteriv_target = -1;
+static int hf_x11_glx_GetTexParameteriv_pname = -1;
+static int hf_x11_glx_GetTexParameteriv_reply_n = -1;
+static int hf_x11_glx_GetTexParameteriv_reply_datum = -1;
+static int hf_x11_glx_GetTexParameteriv_reply_data = -1;
+static int hf_x11_glx_GetTexParameteriv_reply_data_item = -1;
+static int hf_x11_glx_GetTexLevelParameterfv_context_tag = -1;
+static int hf_x11_glx_GetTexLevelParameterfv_target = -1;
+static int hf_x11_glx_GetTexLevelParameterfv_level = -1;
+static int hf_x11_glx_GetTexLevelParameterfv_pname = -1;
+static int hf_x11_glx_GetTexLevelParameterfv_reply_n = -1;
+static int hf_x11_glx_GetTexLevelParameterfv_reply_datum = -1;
+static int hf_x11_glx_GetTexLevelParameterfv_reply_data = -1;
+static int hf_x11_glx_GetTexLevelParameterfv_reply_data_item = -1;
+static int hf_x11_glx_GetTexLevelParameteriv_context_tag = -1;
+static int hf_x11_glx_GetTexLevelParameteriv_target = -1;
+static int hf_x11_glx_GetTexLevelParameteriv_level = -1;
+static int hf_x11_glx_GetTexLevelParameteriv_pname = -1;
+static int hf_x11_glx_GetTexLevelParameteriv_reply_n = -1;
+static int hf_x11_glx_GetTexLevelParameteriv_reply_datum = -1;
+static int hf_x11_glx_GetTexLevelParameteriv_reply_data = -1;
+static int hf_x11_glx_GetTexLevelParameteriv_reply_data_item = -1;
+static int hf_x11_glx_IsList_context_tag = -1;
+static int hf_x11_glx_IsList_list = -1;
+static int hf_x11_glx_IsList_reply_ret_val = -1;
+static int hf_x11_glx_Flush_context_tag = -1;
+static int hf_x11_glx_AreTexturesResident_context_tag = -1;
+static int hf_x11_glx_AreTexturesResident_n = -1;
+static int hf_x11_glx_AreTexturesResident_textures = -1;
+static int hf_x11_glx_AreTexturesResident_textures_item = -1;
+static int hf_x11_glx_AreTexturesResident_reply_ret_val = -1;
+static int hf_x11_glx_AreTexturesResident_reply_data = -1;
+static int hf_x11_glx_DeleteTextures_context_tag = -1;
+static int hf_x11_glx_DeleteTextures_n = -1;
+static int hf_x11_glx_DeleteTextures_textures = -1;
+static int hf_x11_glx_DeleteTextures_textures_item = -1;
+static int hf_x11_glx_GenTextures_context_tag = -1;
+static int hf_x11_glx_GenTextures_n = -1;
+static int hf_x11_glx_GenTextures_reply_data = -1;
+static int hf_x11_glx_GenTextures_reply_data_item = -1;
+static int hf_x11_glx_IsTexture_context_tag = -1;
+static int hf_x11_glx_IsTexture_texture = -1;
+static int hf_x11_glx_IsTexture_reply_ret_val = -1;
+static int hf_x11_glx_GetColorTable_context_tag = -1;
+static int hf_x11_glx_GetColorTable_target = -1;
+static int hf_x11_glx_GetColorTable_format = -1;
+static int hf_x11_glx_GetColorTable_type = -1;
+static int hf_x11_glx_GetColorTable_swap_bytes = -1;
+static int hf_x11_glx_GetColorTable_reply_width = -1;
+static int hf_x11_glx_GetColorTable_reply_data = -1;
+static int hf_x11_glx_GetColorTableParameterfv_context_tag = -1;
+static int hf_x11_glx_GetColorTableParameterfv_target = -1;
+static int hf_x11_glx_GetColorTableParameterfv_pname = -1;
+static int hf_x11_glx_GetColorTableParameterfv_reply_n = -1;
+static int hf_x11_glx_GetColorTableParameterfv_reply_datum = -1;
+static int hf_x11_glx_GetColorTableParameterfv_reply_data = -1;
+static int hf_x11_glx_GetColorTableParameterfv_reply_data_item = -1;
+static int hf_x11_glx_GetColorTableParameteriv_context_tag = -1;
+static int hf_x11_glx_GetColorTableParameteriv_target = -1;
+static int hf_x11_glx_GetColorTableParameteriv_pname = -1;
+static int hf_x11_glx_GetColorTableParameteriv_reply_n = -1;
+static int hf_x11_glx_GetColorTableParameteriv_reply_datum = -1;
+static int hf_x11_glx_GetColorTableParameteriv_reply_data = -1;
+static int hf_x11_glx_GetColorTableParameteriv_reply_data_item = -1;
+static int hf_x11_glx_GetConvolutionFilter_context_tag = -1;
+static int hf_x11_glx_GetConvolutionFilter_target = -1;
+static int hf_x11_glx_GetConvolutionFilter_format = -1;
+static int hf_x11_glx_GetConvolutionFilter_type = -1;
+static int hf_x11_glx_GetConvolutionFilter_swap_bytes = -1;
+static int hf_x11_glx_GetConvolutionFilter_reply_width = -1;
+static int hf_x11_glx_GetConvolutionFilter_reply_height = -1;
+static int hf_x11_glx_GetConvolutionFilter_reply_data = -1;
+static int hf_x11_glx_GetConvolutionParameterfv_context_tag = -1;
+static int hf_x11_glx_GetConvolutionParameterfv_target = -1;
+static int hf_x11_glx_GetConvolutionParameterfv_pname = -1;
+static int hf_x11_glx_GetConvolutionParameterfv_reply_n = -1;
+static int hf_x11_glx_GetConvolutionParameterfv_reply_datum = -1;
+static int hf_x11_glx_GetConvolutionParameterfv_reply_data = -1;
+static int hf_x11_glx_GetConvolutionParameterfv_reply_data_item = -1;
+static int hf_x11_glx_GetConvolutionParameteriv_context_tag = -1;
+static int hf_x11_glx_GetConvolutionParameteriv_target = -1;
+static int hf_x11_glx_GetConvolutionParameteriv_pname = -1;
+static int hf_x11_glx_GetConvolutionParameteriv_reply_n = -1;
+static int hf_x11_glx_GetConvolutionParameteriv_reply_datum = -1;
+static int hf_x11_glx_GetConvolutionParameteriv_reply_data = -1;
+static int hf_x11_glx_GetConvolutionParameteriv_reply_data_item = -1;
+static int hf_x11_glx_GetSeparableFilter_context_tag = -1;
+static int hf_x11_glx_GetSeparableFilter_target = -1;
+static int hf_x11_glx_GetSeparableFilter_format = -1;
+static int hf_x11_glx_GetSeparableFilter_type = -1;
+static int hf_x11_glx_GetSeparableFilter_swap_bytes = -1;
+static int hf_x11_glx_GetSeparableFilter_reply_row_w = -1;
+static int hf_x11_glx_GetSeparableFilter_reply_col_h = -1;
+static int hf_x11_glx_GetSeparableFilter_reply_rows_and_cols = -1;
+static int hf_x11_glx_GetHistogram_context_tag = -1;
+static int hf_x11_glx_GetHistogram_target = -1;
+static int hf_x11_glx_GetHistogram_format = -1;
+static int hf_x11_glx_GetHistogram_type = -1;
+static int hf_x11_glx_GetHistogram_swap_bytes = -1;
+static int hf_x11_glx_GetHistogram_reset = -1;
+static int hf_x11_glx_GetHistogram_reply_width = -1;
+static int hf_x11_glx_GetHistogram_reply_data = -1;
+static int hf_x11_glx_GetHistogramParameterfv_context_tag = -1;
+static int hf_x11_glx_GetHistogramParameterfv_target = -1;
+static int hf_x11_glx_GetHistogramParameterfv_pname = -1;
+static int hf_x11_glx_GetHistogramParameterfv_reply_n = -1;
+static int hf_x11_glx_GetHistogramParameterfv_reply_datum = -1;
+static int hf_x11_glx_GetHistogramParameterfv_reply_data = -1;
+static int hf_x11_glx_GetHistogramParameterfv_reply_data_item = -1;
+static int hf_x11_glx_GetHistogramParameteriv_context_tag = -1;
+static int hf_x11_glx_GetHistogramParameteriv_target = -1;
+static int hf_x11_glx_GetHistogramParameteriv_pname = -1;
+static int hf_x11_glx_GetHistogramParameteriv_reply_n = -1;
+static int hf_x11_glx_GetHistogramParameteriv_reply_datum = -1;
+static int hf_x11_glx_GetHistogramParameteriv_reply_data = -1;
+static int hf_x11_glx_GetHistogramParameteriv_reply_data_item = -1;
+static int hf_x11_glx_GetMinmax_context_tag = -1;
+static int hf_x11_glx_GetMinmax_target = -1;
+static int hf_x11_glx_GetMinmax_format = -1;
+static int hf_x11_glx_GetMinmax_type = -1;
+static int hf_x11_glx_GetMinmax_swap_bytes = -1;
+static int hf_x11_glx_GetMinmax_reset = -1;
+static int hf_x11_glx_GetMinmax_reply_data = -1;
+static int hf_x11_glx_GetMinmaxParameterfv_context_tag = -1;
+static int hf_x11_glx_GetMinmaxParameterfv_target = -1;
+static int hf_x11_glx_GetMinmaxParameterfv_pname = -1;
+static int hf_x11_glx_GetMinmaxParameterfv_reply_n = -1;
+static int hf_x11_glx_GetMinmaxParameterfv_reply_datum = -1;
+static int hf_x11_glx_GetMinmaxParameterfv_reply_data = -1;
+static int hf_x11_glx_GetMinmaxParameterfv_reply_data_item = -1;
+static int hf_x11_glx_GetMinmaxParameteriv_context_tag = -1;
+static int hf_x11_glx_GetMinmaxParameteriv_target = -1;
+static int hf_x11_glx_GetMinmaxParameteriv_pname = -1;
+static int hf_x11_glx_GetMinmaxParameteriv_reply_n = -1;
+static int hf_x11_glx_GetMinmaxParameteriv_reply_datum = -1;
+static int hf_x11_glx_GetMinmaxParameteriv_reply_data = -1;
+static int hf_x11_glx_GetMinmaxParameteriv_reply_data_item = -1;
+static int hf_x11_glx_GetCompressedTexImageARB_context_tag = -1;
+static int hf_x11_glx_GetCompressedTexImageARB_target = -1;
+static int hf_x11_glx_GetCompressedTexImageARB_level = -1;
+static int hf_x11_glx_GetCompressedTexImageARB_reply_size = -1;
+static int hf_x11_glx_GetCompressedTexImageARB_reply_data = -1;
+static int hf_x11_glx_DeleteQueriesARB_context_tag = -1;
+static int hf_x11_glx_DeleteQueriesARB_n = -1;
+static int hf_x11_glx_DeleteQueriesARB_ids = -1;
+static int hf_x11_glx_DeleteQueriesARB_ids_item = -1;
+static int hf_x11_glx_GenQueriesARB_context_tag = -1;
+static int hf_x11_glx_GenQueriesARB_n = -1;
+static int hf_x11_glx_GenQueriesARB_reply_data = -1;
+static int hf_x11_glx_GenQueriesARB_reply_data_item = -1;
+static int hf_x11_glx_IsQueryARB_context_tag = -1;
+static int hf_x11_glx_IsQueryARB_id = -1;
+static int hf_x11_glx_IsQueryARB_reply_ret_val = -1;
+static int hf_x11_glx_GetQueryivARB_context_tag = -1;
+static int hf_x11_glx_GetQueryivARB_target = -1;
+static int hf_x11_glx_GetQueryivARB_pname = -1;
+static int hf_x11_glx_GetQueryivARB_reply_n = -1;
+static int hf_x11_glx_GetQueryivARB_reply_datum = -1;
+static int hf_x11_glx_GetQueryivARB_reply_data = -1;
+static int hf_x11_glx_GetQueryivARB_reply_data_item = -1;
+static int hf_x11_glx_GetQueryObjectivARB_context_tag = -1;
+static int hf_x11_glx_GetQueryObjectivARB_id = -1;
+static int hf_x11_glx_GetQueryObjectivARB_pname = -1;
+static int hf_x11_glx_GetQueryObjectivARB_reply_n = -1;
+static int hf_x11_glx_GetQueryObjectivARB_reply_datum = -1;
+static int hf_x11_glx_GetQueryObjectivARB_reply_data = -1;
+static int hf_x11_glx_GetQueryObjectivARB_reply_data_item = -1;
+static int hf_x11_glx_GetQueryObjectuivARB_context_tag = -1;
+static int hf_x11_glx_GetQueryObjectuivARB_id = -1;
+static int hf_x11_glx_GetQueryObjectuivARB_pname = -1;
+static int hf_x11_glx_GetQueryObjectuivARB_reply_n = -1;
+static int hf_x11_glx_GetQueryObjectuivARB_reply_datum = -1;
+static int hf_x11_glx_GetQueryObjectuivARB_reply_data = -1;
+static int hf_x11_glx_GetQueryObjectuivARB_reply_data_item = -1;
+static int hf_x11_glx_extension_minor = -1;
+
+static int hf_x11_struct_ScreenSize = -1;
+static int hf_x11_struct_ScreenSize_width = -1;
+static int hf_x11_struct_ScreenSize_height = -1;
+static int hf_x11_struct_ScreenSize_mwidth = -1;
+static int hf_x11_struct_ScreenSize_mheight = -1;
+static int hf_x11_struct_RefreshRates = -1;
+static int hf_x11_struct_RefreshRates_nRates = -1;
+static int hf_x11_struct_RefreshRates_rates = -1;
+static int hf_x11_struct_RefreshRates_rates_item = -1;
+static int hf_x11_randr_QueryVersion_major_version = -1;
+static int hf_x11_randr_QueryVersion_minor_version = -1;
+static int hf_x11_randr_QueryVersion_reply_major_version = -1;
+static int hf_x11_randr_QueryVersion_reply_minor_version = -1;
+static int hf_x11_randr_SetScreenConfig_window = -1;
+static int hf_x11_randr_SetScreenConfig_timestamp = -1;
+static int hf_x11_randr_SetScreenConfig_config_timestamp = -1;
+static int hf_x11_randr_SetScreenConfig_sizeID = -1;
+static int hf_x11_randr_SetScreenConfig_rotation = -1;
+static int hf_x11_randr_SetScreenConfig_rate = -1;
+static int hf_x11_randr_SetScreenConfig_reply_status = -1;
+static int hf_x11_randr_SetScreenConfig_reply_new_timestamp = -1;
+static int hf_x11_randr_SetScreenConfig_reply_config_timestamp = -1;
+static int hf_x11_randr_SetScreenConfig_reply_root = -1;
+static int hf_x11_randr_SetScreenConfig_reply_subpixel_order = -1;
+static int hf_x11_randr_SelectInput_window = -1;
+static int hf_x11_randr_SelectInput_enable = -1;
+static int hf_x11_randr_GetScreenInfo_window = -1;
+static int hf_x11_randr_GetScreenInfo_reply_rotations = -1;
+static int hf_x11_randr_GetScreenInfo_reply_root = -1;
+static int hf_x11_randr_GetScreenInfo_reply_timestamp = -1;
+static int hf_x11_randr_GetScreenInfo_reply_config_timestamp = -1;
+static int hf_x11_randr_GetScreenInfo_reply_nSizes = -1;
+static int hf_x11_randr_GetScreenInfo_reply_sizeID = -1;
+static int hf_x11_randr_GetScreenInfo_reply_rotation = -1;
+static int hf_x11_randr_GetScreenInfo_reply_rate = -1;
+static int hf_x11_randr_GetScreenInfo_reply_nInfo = -1;
+static int hf_x11_randr_GetScreenInfo_reply_sizes = -1;
+static int hf_x11_randr_GetScreenInfo_reply_sizes_item = -1;
+static int hf_x11_randr_GetScreenInfo_reply_rates = -1;
+static int hf_x11_randr_GetScreenSizeRange_window = -1;
+static int hf_x11_randr_GetScreenSizeRange_reply_min_width = -1;
+static int hf_x11_randr_GetScreenSizeRange_reply_min_height = -1;
+static int hf_x11_randr_GetScreenSizeRange_reply_max_width = -1;
+static int hf_x11_randr_GetScreenSizeRange_reply_max_height = -1;
+static int hf_x11_randr_SetScreenSize_window = -1;
+static int hf_x11_randr_SetScreenSize_width = -1;
+static int hf_x11_randr_SetScreenSize_height = -1;
+static int hf_x11_randr_SetScreenSize_mm_width = -1;
+static int hf_x11_randr_SetScreenSize_mm_height = -1;
+static int hf_x11_struct_ModeInfo = -1;
+static int hf_x11_struct_ModeInfo_id = -1;
+static int hf_x11_struct_ModeInfo_width = -1;
+static int hf_x11_struct_ModeInfo_height = -1;
+static int hf_x11_struct_ModeInfo_dot_clock = -1;
+static int hf_x11_struct_ModeInfo_hsync_start = -1;
+static int hf_x11_struct_ModeInfo_hsync_end = -1;
+static int hf_x11_struct_ModeInfo_htotal = -1;
+static int hf_x11_struct_ModeInfo_hskew = -1;
+static int hf_x11_struct_ModeInfo_vsync_start = -1;
+static int hf_x11_struct_ModeInfo_vsync_end = -1;
+static int hf_x11_struct_ModeInfo_vtotal = -1;
+static int hf_x11_struct_ModeInfo_name_len = -1;
+static int hf_x11_struct_ModeInfo_mode_flags = -1;
+static int hf_x11_randr_GetScreenResources_window = -1;
+static int hf_x11_randr_GetScreenResources_reply_timestamp = -1;
+static int hf_x11_randr_GetScreenResources_reply_config_timestamp = -1;
+static int hf_x11_randr_GetScreenResources_reply_num_crtcs = -1;
+static int hf_x11_randr_GetScreenResources_reply_num_outputs = -1;
+static int hf_x11_randr_GetScreenResources_reply_num_modes = -1;
+static int hf_x11_randr_GetScreenResources_reply_names_len = -1;
+static int hf_x11_randr_GetScreenResources_reply_crtcs = -1;
+static int hf_x11_randr_GetScreenResources_reply_crtcs_item = -1;
+static int hf_x11_randr_GetScreenResources_reply_outputs = -1;
+static int hf_x11_randr_GetScreenResources_reply_outputs_item = -1;
+static int hf_x11_randr_GetScreenResources_reply_modes = -1;
+static int hf_x11_randr_GetScreenResources_reply_modes_item = -1;
+static int hf_x11_randr_GetScreenResources_reply_names = -1;
+static int hf_x11_randr_GetOutputInfo_output = -1;
+static int hf_x11_randr_GetOutputInfo_config_timestamp = -1;
+static int hf_x11_randr_GetOutputInfo_reply_status = -1;
+static int hf_x11_randr_GetOutputInfo_reply_timestamp = -1;
+static int hf_x11_randr_GetOutputInfo_reply_crtc = -1;
+static int hf_x11_randr_GetOutputInfo_reply_mm_width = -1;
+static int hf_x11_randr_GetOutputInfo_reply_mm_height = -1;
+static int hf_x11_randr_GetOutputInfo_reply_connection = -1;
+static int hf_x11_randr_GetOutputInfo_reply_subpixel_order = -1;
+static int hf_x11_randr_GetOutputInfo_reply_num_crtcs = -1;
+static int hf_x11_randr_GetOutputInfo_reply_num_modes = -1;
+static int hf_x11_randr_GetOutputInfo_reply_num_preferred = -1;
+static int hf_x11_randr_GetOutputInfo_reply_num_clones = -1;
+static int hf_x11_randr_GetOutputInfo_reply_name_len = -1;
+static int hf_x11_randr_GetOutputInfo_reply_crtcs = -1;
+static int hf_x11_randr_GetOutputInfo_reply_crtcs_item = -1;
+static int hf_x11_randr_GetOutputInfo_reply_modes = -1;
+static int hf_x11_randr_GetOutputInfo_reply_modes_item = -1;
+static int hf_x11_randr_GetOutputInfo_reply_clones = -1;
+static int hf_x11_randr_GetOutputInfo_reply_clones_item = -1;
+static int hf_x11_randr_GetOutputInfo_reply_name = -1;
+static int hf_x11_randr_ListOutputProperties_output = -1;
+static int hf_x11_randr_ListOutputProperties_reply_num_atoms = -1;
+static int hf_x11_randr_ListOutputProperties_reply_atoms = -1;
+static int hf_x11_randr_ListOutputProperties_reply_atoms_item = -1;
+static int hf_x11_randr_QueryOutputProperty_output = -1;
+static int hf_x11_randr_QueryOutputProperty_property = -1;
+static int hf_x11_randr_QueryOutputProperty_reply_pending = -1;
+static int hf_x11_randr_QueryOutputProperty_reply_range = -1;
+static int hf_x11_randr_QueryOutputProperty_reply_immutable = -1;
+static int hf_x11_randr_QueryOutputProperty_reply_validValues = -1;
+static int hf_x11_randr_QueryOutputProperty_reply_validValues_item = -1;
+static int hf_x11_randr_ConfigureOutputProperty_output = -1;
+static int hf_x11_randr_ConfigureOutputProperty_property = -1;
+static int hf_x11_randr_ConfigureOutputProperty_pending = -1;
+static int hf_x11_randr_ConfigureOutputProperty_range = -1;
+static int hf_x11_randr_ConfigureOutputProperty_values = -1;
+static int hf_x11_randr_ConfigureOutputProperty_values_item = -1;
+static int hf_x11_randr_ChangeOutputProperty_output = -1;
+static int hf_x11_randr_ChangeOutputProperty_property = -1;
+static int hf_x11_randr_ChangeOutputProperty_type = -1;
+static int hf_x11_randr_ChangeOutputProperty_format = -1;
+static int hf_x11_randr_ChangeOutputProperty_mode = -1;
+static int hf_x11_randr_ChangeOutputProperty_num_units = -1;
+static int hf_x11_randr_ChangeOutputProperty_data = -1;
+static int hf_x11_randr_DeleteOutputProperty_output = -1;
+static int hf_x11_randr_DeleteOutputProperty_property = -1;
+static int hf_x11_randr_GetOutputProperty_output = -1;
+static int hf_x11_randr_GetOutputProperty_property = -1;
+static int hf_x11_randr_GetOutputProperty_type = -1;
+static int hf_x11_randr_GetOutputProperty_long_offset = -1;
+static int hf_x11_randr_GetOutputProperty_long_length = -1;
+static int hf_x11_randr_GetOutputProperty_delete = -1;
+static int hf_x11_randr_GetOutputProperty_pending = -1;
+static int hf_x11_randr_GetOutputProperty_reply_format = -1;
+static int hf_x11_randr_GetOutputProperty_reply_type = -1;
+static int hf_x11_randr_GetOutputProperty_reply_bytes_after = -1;
+static int hf_x11_randr_GetOutputProperty_reply_num_items = -1;
+static int hf_x11_randr_GetOutputProperty_reply_data = -1;
+static int hf_x11_randr_CreateMode_window = -1;
+static int hf_x11_randr_CreateMode_mode_info = -1;
+static int hf_x11_randr_CreateMode_name = -1;
+static int hf_x11_randr_CreateMode_reply_mode = -1;
+static int hf_x11_randr_DestroyMode_mode = -1;
+static int hf_x11_randr_AddOutputMode_output = -1;
+static int hf_x11_randr_AddOutputMode_mode = -1;
+static int hf_x11_randr_DeleteOutputMode_output = -1;
+static int hf_x11_randr_DeleteOutputMode_mode = -1;
+static int hf_x11_randr_GetCrtcInfo_crtc = -1;
+static int hf_x11_randr_GetCrtcInfo_config_timestamp = -1;
+static int hf_x11_randr_GetCrtcInfo_reply_status = -1;
+static int hf_x11_randr_GetCrtcInfo_reply_timestamp = -1;
+static int hf_x11_randr_GetCrtcInfo_reply_x = -1;
+static int hf_x11_randr_GetCrtcInfo_reply_y = -1;
+static int hf_x11_randr_GetCrtcInfo_reply_width = -1;
+static int hf_x11_randr_GetCrtcInfo_reply_height = -1;
+static int hf_x11_randr_GetCrtcInfo_reply_mode = -1;
+static int hf_x11_randr_GetCrtcInfo_reply_rotation = -1;
+static int hf_x11_randr_GetCrtcInfo_reply_rotations = -1;
+static int hf_x11_randr_GetCrtcInfo_reply_num_outputs = -1;
+static int hf_x11_randr_GetCrtcInfo_reply_num_possible_outputs = -1;
+static int hf_x11_randr_GetCrtcInfo_reply_outputs = -1;
+static int hf_x11_randr_GetCrtcInfo_reply_outputs_item = -1;
+static int hf_x11_randr_GetCrtcInfo_reply_possible = -1;
+static int hf_x11_randr_GetCrtcInfo_reply_possible_item = -1;
+static int hf_x11_randr_SetCrtcConfig_crtc = -1;
+static int hf_x11_randr_SetCrtcConfig_timestamp = -1;
+static int hf_x11_randr_SetCrtcConfig_config_timestamp = -1;
+static int hf_x11_randr_SetCrtcConfig_x = -1;
+static int hf_x11_randr_SetCrtcConfig_y = -1;
+static int hf_x11_randr_SetCrtcConfig_mode = -1;
+static int hf_x11_randr_SetCrtcConfig_rotation = -1;
+static int hf_x11_randr_SetCrtcConfig_outputs = -1;
+static int hf_x11_randr_SetCrtcConfig_outputs_item = -1;
+static int hf_x11_randr_SetCrtcConfig_reply_status = -1;
+static int hf_x11_randr_SetCrtcConfig_reply_timestamp = -1;
+static int hf_x11_randr_GetCrtcGammaSize_crtc = -1;
+static int hf_x11_randr_GetCrtcGammaSize_reply_size = -1;
+static int hf_x11_randr_GetCrtcGamma_crtc = -1;
+static int hf_x11_randr_GetCrtcGamma_reply_size = -1;
+static int hf_x11_randr_GetCrtcGamma_reply_red = -1;
+static int hf_x11_randr_GetCrtcGamma_reply_red_item = -1;
+static int hf_x11_randr_GetCrtcGamma_reply_green = -1;
+static int hf_x11_randr_GetCrtcGamma_reply_green_item = -1;
+static int hf_x11_randr_GetCrtcGamma_reply_blue = -1;
+static int hf_x11_randr_GetCrtcGamma_reply_blue_item = -1;
+static int hf_x11_randr_SetCrtcGamma_crtc = -1;
+static int hf_x11_randr_SetCrtcGamma_size = -1;
+static int hf_x11_randr_SetCrtcGamma_red = -1;
+static int hf_x11_randr_SetCrtcGamma_red_item = -1;
+static int hf_x11_randr_SetCrtcGamma_green = -1;
+static int hf_x11_randr_SetCrtcGamma_green_item = -1;
+static int hf_x11_randr_SetCrtcGamma_blue = -1;
+static int hf_x11_randr_SetCrtcGamma_blue_item = -1;
+static int hf_x11_randr_GetScreenResourcesCurrent_window = -1;
+static int hf_x11_randr_GetScreenResourcesCurrent_reply_timestamp = -1;
+static int hf_x11_randr_GetScreenResourcesCurrent_reply_config_timestamp = -1;
+static int hf_x11_randr_GetScreenResourcesCurrent_reply_num_crtcs = -1;
+static int hf_x11_randr_GetScreenResourcesCurrent_reply_num_outputs = -1;
+static int hf_x11_randr_GetScreenResourcesCurrent_reply_num_modes = -1;
+static int hf_x11_randr_GetScreenResourcesCurrent_reply_names_len = -1;
+static int hf_x11_randr_GetScreenResourcesCurrent_reply_crtcs = -1;
+static int hf_x11_randr_GetScreenResourcesCurrent_reply_crtcs_item = -1;
+static int hf_x11_randr_GetScreenResourcesCurrent_reply_outputs = -1;
+static int hf_x11_randr_GetScreenResourcesCurrent_reply_outputs_item = -1;
+static int hf_x11_randr_GetScreenResourcesCurrent_reply_modes = -1;
+static int hf_x11_randr_GetScreenResourcesCurrent_reply_modes_item = -1;
+static int hf_x11_randr_GetScreenResourcesCurrent_reply_names = -1;
+static int hf_x11_randr_SetCrtcTransform_crtc = -1;
+static int hf_x11_randr_SetCrtcTransform_transform = -1;
+static int hf_x11_randr_SetCrtcTransform_filter_len = -1;
+static int hf_x11_randr_SetCrtcTransform_filter_name = -1;
+static int hf_x11_randr_SetCrtcTransform_filter_params = -1;
+static int hf_x11_randr_SetCrtcTransform_filter_params_item = -1;
+static int hf_x11_randr_GetCrtcTransform_crtc = -1;
+static int hf_x11_randr_GetCrtcTransform_reply_pending_transform = -1;
+static int hf_x11_randr_GetCrtcTransform_reply_has_transforms = -1;
+static int hf_x11_randr_GetCrtcTransform_reply_current_transform = -1;
+static int hf_x11_randr_GetCrtcTransform_reply_pending_len = -1;
+static int hf_x11_randr_GetCrtcTransform_reply_pending_nparams = -1;
+static int hf_x11_randr_GetCrtcTransform_reply_current_len = -1;
+static int hf_x11_randr_GetCrtcTransform_reply_current_nparams = -1;
+static int hf_x11_randr_GetCrtcTransform_reply_pending_filter_name = -1;
+static int hf_x11_randr_GetCrtcTransform_reply_pending_params = -1;
+static int hf_x11_randr_GetCrtcTransform_reply_pending_params_item = -1;
+static int hf_x11_randr_GetCrtcTransform_reply_current_filter_name = -1;
+static int hf_x11_randr_GetCrtcTransform_reply_current_params = -1;
+static int hf_x11_randr_GetCrtcTransform_reply_current_params_item = -1;
+static int hf_x11_randr_GetPanning_crtc = -1;
+static int hf_x11_randr_GetPanning_reply_status = -1;
+static int hf_x11_randr_GetPanning_reply_timestamp = -1;
+static int hf_x11_randr_GetPanning_reply_left = -1;
+static int hf_x11_randr_GetPanning_reply_top = -1;
+static int hf_x11_randr_GetPanning_reply_width = -1;
+static int hf_x11_randr_GetPanning_reply_height = -1;
+static int hf_x11_randr_GetPanning_reply_track_left = -1;
+static int hf_x11_randr_GetPanning_reply_track_top = -1;
+static int hf_x11_randr_GetPanning_reply_track_width = -1;
+static int hf_x11_randr_GetPanning_reply_track_height = -1;
+static int hf_x11_randr_GetPanning_reply_border_left = -1;
+static int hf_x11_randr_GetPanning_reply_border_top = -1;
+static int hf_x11_randr_GetPanning_reply_border_right = -1;
+static int hf_x11_randr_GetPanning_reply_border_bottom = -1;
+static int hf_x11_randr_SetPanning_crtc = -1;
+static int hf_x11_randr_SetPanning_timestamp = -1;
+static int hf_x11_randr_SetPanning_left = -1;
+static int hf_x11_randr_SetPanning_top = -1;
+static int hf_x11_randr_SetPanning_width = -1;
+static int hf_x11_randr_SetPanning_height = -1;
+static int hf_x11_randr_SetPanning_track_left = -1;
+static int hf_x11_randr_SetPanning_track_top = -1;
+static int hf_x11_randr_SetPanning_track_width = -1;
+static int hf_x11_randr_SetPanning_track_height = -1;
+static int hf_x11_randr_SetPanning_border_left = -1;
+static int hf_x11_randr_SetPanning_border_top = -1;
+static int hf_x11_randr_SetPanning_border_right = -1;
+static int hf_x11_randr_SetPanning_border_bottom = -1;
+static int hf_x11_randr_SetPanning_reply_status = -1;
+static int hf_x11_randr_SetPanning_reply_timestamp = -1;
+static int hf_x11_randr_SetOutputPrimary_window = -1;
+static int hf_x11_randr_SetOutputPrimary_output = -1;
+static int hf_x11_randr_GetOutputPrimary_window = -1;
+static int hf_x11_randr_GetOutputPrimary_reply_output = -1;
+static int hf_x11_randr_ScreenChangeNotify_rotation = -1;
+static int hf_x11_randr_ScreenChangeNotify_timestamp = -1;
+static int hf_x11_randr_ScreenChangeNotify_config_timestamp = -1;
+static int hf_x11_randr_ScreenChangeNotify_root = -1;
+static int hf_x11_randr_ScreenChangeNotify_request_window = -1;
+static int hf_x11_randr_ScreenChangeNotify_sizeID = -1;
+static int hf_x11_randr_ScreenChangeNotify_subpixel_order = -1;
+static int hf_x11_randr_ScreenChangeNotify_width = -1;
+static int hf_x11_randr_ScreenChangeNotify_height = -1;
+static int hf_x11_randr_ScreenChangeNotify_mwidth = -1;
+static int hf_x11_randr_ScreenChangeNotify_mheight = -1;
+static int hf_x11_struct_CrtcChange = -1;
+static int hf_x11_struct_CrtcChange_timestamp = -1;
+static int hf_x11_struct_CrtcChange_window = -1;
+static int hf_x11_struct_CrtcChange_crtc = -1;
+static int hf_x11_struct_CrtcChange_mode = -1;
+static int hf_x11_struct_CrtcChange_rotation = -1;
+static int hf_x11_struct_CrtcChange_x = -1;
+static int hf_x11_struct_CrtcChange_y = -1;
+static int hf_x11_struct_CrtcChange_width = -1;
+static int hf_x11_struct_CrtcChange_height = -1;
+static int hf_x11_struct_OutputChange = -1;
+static int hf_x11_struct_OutputChange_timestamp = -1;
+static int hf_x11_struct_OutputChange_config_timestamp = -1;
+static int hf_x11_struct_OutputChange_window = -1;
+static int hf_x11_struct_OutputChange_output = -1;
+static int hf_x11_struct_OutputChange_crtc = -1;
+static int hf_x11_struct_OutputChange_mode = -1;
+static int hf_x11_struct_OutputChange_rotation = -1;
+static int hf_x11_struct_OutputChange_connection = -1;
+static int hf_x11_struct_OutputChange_subpixel_order = -1;
+static int hf_x11_struct_OutputProperty = -1;
+static int hf_x11_struct_OutputProperty_window = -1;
+static int hf_x11_struct_OutputProperty_output = -1;
+static int hf_x11_struct_OutputProperty_atom = -1;
+static int hf_x11_struct_OutputProperty_timestamp = -1;
+static int hf_x11_struct_OutputProperty_status = -1;
+static int hf_x11_union_NotifyData = -1;
+static int hf_x11_randr_Notify_subCode = -1;
+static int hf_x11_randr_Notify_u = -1;
+static int hf_x11_randr_extension_minor = -1;
+
+static int hf_x11_struct_Range8 = -1;
+static int hf_x11_struct_Range8_first = -1;
+static int hf_x11_struct_Range8_last = -1;
+static int hf_x11_struct_Range16 = -1;
+static int hf_x11_struct_Range16_first = -1;
+static int hf_x11_struct_Range16_last = -1;
+static int hf_x11_struct_ExtRange = -1;
+static int hf_x11_struct_ExtRange_major = -1;
+static int hf_x11_struct_ExtRange_minor = -1;
+static int hf_x11_struct_Range = -1;
+static int hf_x11_struct_Range_core_requests = -1;
+static int hf_x11_struct_Range_core_replies = -1;
+static int hf_x11_struct_Range_ext_requests = -1;
+static int hf_x11_struct_Range_ext_replies = -1;
+static int hf_x11_struct_Range_delivered_events = -1;
+static int hf_x11_struct_Range_device_events = -1;
+static int hf_x11_struct_Range_errors = -1;
+static int hf_x11_struct_Range_client_started = -1;
+static int hf_x11_struct_Range_client_died = -1;
+static int hf_x11_struct_ClientInfo = -1;
+static int hf_x11_struct_ClientInfo_client_resource = -1;
+static int hf_x11_struct_ClientInfo_num_ranges = -1;
+static int hf_x11_struct_ClientInfo_ranges = -1;
+static int hf_x11_struct_ClientInfo_ranges_item = -1;
+static int hf_x11_record_QueryVersion_major_version = -1;
+static int hf_x11_record_QueryVersion_minor_version = -1;
+static int hf_x11_record_QueryVersion_reply_major_version = -1;
+static int hf_x11_record_QueryVersion_reply_minor_version = -1;
+static int hf_x11_record_CreateContext_context = -1;
+static int hf_x11_record_CreateContext_element_header = -1;
+static int hf_x11_record_CreateContext_num_client_specs = -1;
+static int hf_x11_record_CreateContext_num_ranges = -1;
+static int hf_x11_record_CreateContext_client_specs = -1;
+static int hf_x11_record_CreateContext_client_specs_item = -1;
+static int hf_x11_record_CreateContext_ranges = -1;
+static int hf_x11_record_CreateContext_ranges_item = -1;
+static int hf_x11_record_RegisterClients_context = -1;
+static int hf_x11_record_RegisterClients_element_header = -1;
+static int hf_x11_record_RegisterClients_num_client_specs = -1;
+static int hf_x11_record_RegisterClients_num_ranges = -1;
+static int hf_x11_record_RegisterClients_client_specs = -1;
+static int hf_x11_record_RegisterClients_client_specs_item = -1;
+static int hf_x11_record_RegisterClients_ranges = -1;
+static int hf_x11_record_RegisterClients_ranges_item = -1;
+static int hf_x11_record_UnregisterClients_context = -1;
+static int hf_x11_record_UnregisterClients_num_client_specs = -1;
+static int hf_x11_record_UnregisterClients_client_specs = -1;
+static int hf_x11_record_UnregisterClients_client_specs_item = -1;
+static int hf_x11_record_GetContext_context = -1;
+static int hf_x11_record_GetContext_reply_enabled = -1;
+static int hf_x11_record_GetContext_reply_element_header = -1;
+static int hf_x11_record_GetContext_reply_num_intercepted_clients = -1;
+static int hf_x11_record_GetContext_reply_intercepted_clients = -1;
+static int hf_x11_record_EnableContext_context = -1;
+static int hf_x11_record_EnableContext_reply_category = -1;
+static int hf_x11_record_EnableContext_reply_element_header = -1;
+static int hf_x11_record_EnableContext_reply_client_swapped = -1;
+static int hf_x11_record_EnableContext_reply_xid_base = -1;
+static int hf_x11_record_EnableContext_reply_server_time = -1;
+static int hf_x11_record_EnableContext_reply_rec_sequence_num = -1;
+static int hf_x11_record_EnableContext_reply_data = -1;
+static int hf_x11_record_DisableContext_context = -1;
+static int hf_x11_record_FreeContext_context = -1;
+static int hf_x11_record_extension_minor = -1;
+
+static int hf_x11_render_QueryVersion_client_major_version = -1;
+static int hf_x11_render_QueryVersion_client_minor_version = -1;
+static int hf_x11_render_QueryVersion_reply_major_version = -1;
+static int hf_x11_render_QueryVersion_reply_minor_version = -1;
+static int hf_x11_render_QueryPictFormats_reply_num_formats = -1;
+static int hf_x11_render_QueryPictFormats_reply_num_screens = -1;
+static int hf_x11_render_QueryPictFormats_reply_num_depths = -1;
+static int hf_x11_render_QueryPictFormats_reply_num_visuals = -1;
+static int hf_x11_render_QueryPictFormats_reply_num_subpixel = -1;
+static int hf_x11_render_QueryPictFormats_reply_formats = -1;
+static int hf_x11_render_QueryPictFormats_reply_formats_item = -1;
+static int hf_x11_render_QueryPictFormats_reply_screens = -1;
+static int hf_x11_render_QueryPictFormats_reply_subpixels = -1;
+static int hf_x11_render_QueryPictFormats_reply_subpixels_item = -1;
+static int hf_x11_render_QueryPictIndexValues_format = -1;
+static int hf_x11_render_QueryPictIndexValues_reply_num_values = -1;
+static int hf_x11_render_QueryPictIndexValues_reply_values = -1;
+static int hf_x11_render_QueryPictIndexValues_reply_values_item = -1;
+static int hf_x11_render_CreatePicture_pid = -1;
+static int hf_x11_render_CreatePicture_drawable = -1;
+static int hf_x11_render_CreatePicture_format = -1;
+static int hf_x11_render_ChangePicture_picture = -1;
+static int hf_x11_render_SetPictureClipRectangles_picture = -1;
+static int hf_x11_render_SetPictureClipRectangles_clip_x_origin = -1;
+static int hf_x11_render_SetPictureClipRectangles_clip_y_origin = -1;
+static int hf_x11_render_SetPictureClipRectangles_rectangles = -1;
+static int hf_x11_render_SetPictureClipRectangles_rectangles_item = -1;
+static int hf_x11_render_FreePicture_picture = -1;
+static int hf_x11_render_Composite_op = -1;
+static int hf_x11_render_Composite_src = -1;
+static int hf_x11_render_Composite_mask = -1;
+static int hf_x11_render_Composite_dst = -1;
+static int hf_x11_render_Composite_src_x = -1;
+static int hf_x11_render_Composite_src_y = -1;
+static int hf_x11_render_Composite_mask_x = -1;
+static int hf_x11_render_Composite_mask_y = -1;
+static int hf_x11_render_Composite_dst_x = -1;
+static int hf_x11_render_Composite_dst_y = -1;
+static int hf_x11_render_Composite_width = -1;
+static int hf_x11_render_Composite_height = -1;
+static int hf_x11_render_Trapezoids_op = -1;
+static int hf_x11_render_Trapezoids_src = -1;
+static int hf_x11_render_Trapezoids_dst = -1;
+static int hf_x11_render_Trapezoids_mask_format = -1;
+static int hf_x11_render_Trapezoids_src_x = -1;
+static int hf_x11_render_Trapezoids_src_y = -1;
+static int hf_x11_render_Trapezoids_traps = -1;
+static int hf_x11_render_Trapezoids_traps_item = -1;
+static int hf_x11_render_Triangles_op = -1;
+static int hf_x11_render_Triangles_src = -1;
+static int hf_x11_render_Triangles_dst = -1;
+static int hf_x11_render_Triangles_mask_format = -1;
+static int hf_x11_render_Triangles_src_x = -1;
+static int hf_x11_render_Triangles_src_y = -1;
+static int hf_x11_render_Triangles_triangles = -1;
+static int hf_x11_render_Triangles_triangles_item = -1;
+static int hf_x11_render_TriStrip_op = -1;
+static int hf_x11_render_TriStrip_src = -1;
+static int hf_x11_render_TriStrip_dst = -1;
+static int hf_x11_render_TriStrip_mask_format = -1;
+static int hf_x11_render_TriStrip_src_x = -1;
+static int hf_x11_render_TriStrip_src_y = -1;
+static int hf_x11_render_TriStrip_points = -1;
+static int hf_x11_render_TriStrip_points_item = -1;
+static int hf_x11_render_TriFan_op = -1;
+static int hf_x11_render_TriFan_src = -1;
+static int hf_x11_render_TriFan_dst = -1;
+static int hf_x11_render_TriFan_mask_format = -1;
+static int hf_x11_render_TriFan_src_x = -1;
+static int hf_x11_render_TriFan_src_y = -1;
+static int hf_x11_render_TriFan_points = -1;
+static int hf_x11_render_TriFan_points_item = -1;
+static int hf_x11_render_CreateGlyphSet_gsid = -1;
+static int hf_x11_render_CreateGlyphSet_format = -1;
+static int hf_x11_render_ReferenceGlyphSet_gsid = -1;
+static int hf_x11_render_ReferenceGlyphSet_existing = -1;
+static int hf_x11_render_FreeGlyphSet_glyphset = -1;
+static int hf_x11_render_AddGlyphs_glyphset = -1;
+static int hf_x11_render_AddGlyphs_glyphs_len = -1;
+static int hf_x11_render_AddGlyphs_glyphids = -1;
+static int hf_x11_render_AddGlyphs_glyphids_item = -1;
+static int hf_x11_render_AddGlyphs_glyphs = -1;
+static int hf_x11_render_AddGlyphs_glyphs_item = -1;
+static int hf_x11_render_AddGlyphs_data = -1;
+static int hf_x11_render_FreeGlyphs_glyphset = -1;
+static int hf_x11_render_FreeGlyphs_glyphs = -1;
+static int hf_x11_render_FreeGlyphs_glyphs_item = -1;
+static int hf_x11_render_CompositeGlyphs8_op = -1;
+static int hf_x11_render_CompositeGlyphs8_src = -1;
+static int hf_x11_render_CompositeGlyphs8_dst = -1;
+static int hf_x11_render_CompositeGlyphs8_mask_format = -1;
+static int hf_x11_render_CompositeGlyphs8_glyphset = -1;
+static int hf_x11_render_CompositeGlyphs8_src_x = -1;
+static int hf_x11_render_CompositeGlyphs8_src_y = -1;
+static int hf_x11_render_CompositeGlyphs8_glyphcmds = -1;
+static int hf_x11_render_CompositeGlyphs16_op = -1;
+static int hf_x11_render_CompositeGlyphs16_src = -1;
+static int hf_x11_render_CompositeGlyphs16_dst = -1;
+static int hf_x11_render_CompositeGlyphs16_mask_format = -1;
+static int hf_x11_render_CompositeGlyphs16_glyphset = -1;
+static int hf_x11_render_CompositeGlyphs16_src_x = -1;
+static int hf_x11_render_CompositeGlyphs16_src_y = -1;
+static int hf_x11_render_CompositeGlyphs16_glyphcmds = -1;
+static int hf_x11_render_CompositeGlyphs32_op = -1;
+static int hf_x11_render_CompositeGlyphs32_src = -1;
+static int hf_x11_render_CompositeGlyphs32_dst = -1;
+static int hf_x11_render_CompositeGlyphs32_mask_format = -1;
+static int hf_x11_render_CompositeGlyphs32_glyphset = -1;
+static int hf_x11_render_CompositeGlyphs32_src_x = -1;
+static int hf_x11_render_CompositeGlyphs32_src_y = -1;
+static int hf_x11_render_CompositeGlyphs32_glyphcmds = -1;
+static int hf_x11_render_FillRectangles_op = -1;
+static int hf_x11_render_FillRectangles_dst = -1;
+static int hf_x11_render_FillRectangles_color = -1;
+static int hf_x11_render_FillRectangles_rects = -1;
+static int hf_x11_render_FillRectangles_rects_item = -1;
+static int hf_x11_render_CreateCursor_cid = -1;
+static int hf_x11_render_CreateCursor_source = -1;
+static int hf_x11_render_CreateCursor_x = -1;
+static int hf_x11_render_CreateCursor_y = -1;
+static int hf_x11_render_SetPictureTransform_picture = -1;
+static int hf_x11_render_SetPictureTransform_transform = -1;
+static int hf_x11_render_QueryFilters_drawable = -1;
+static int hf_x11_render_QueryFilters_reply_num_aliases = -1;
+static int hf_x11_render_QueryFilters_reply_num_filters = -1;
+static int hf_x11_render_QueryFilters_reply_aliases = -1;
+static int hf_x11_render_QueryFilters_reply_aliases_item = -1;
+static int hf_x11_render_QueryFilters_reply_filters = -1;
+static int hf_x11_render_SetPictureFilter_picture = -1;
+static int hf_x11_render_SetPictureFilter_filter_len = -1;
+static int hf_x11_render_SetPictureFilter_filter = -1;
+static int hf_x11_render_SetPictureFilter_values = -1;
+static int hf_x11_render_SetPictureFilter_values_item = -1;
+static int hf_x11_render_CreateAnimCursor_cid = -1;
+static int hf_x11_render_CreateAnimCursor_cursors = -1;
+static int hf_x11_render_CreateAnimCursor_cursors_item = -1;
+static int hf_x11_render_AddTraps_picture = -1;
+static int hf_x11_render_AddTraps_x_off = -1;
+static int hf_x11_render_AddTraps_y_off = -1;
+static int hf_x11_render_AddTraps_traps = -1;
+static int hf_x11_render_AddTraps_traps_item = -1;
+static int hf_x11_render_CreateSolidFill_picture = -1;
+static int hf_x11_render_CreateSolidFill_color = -1;
+static int hf_x11_render_CreateLinearGradient_picture = -1;
+static int hf_x11_render_CreateLinearGradient_p1 = -1;
+static int hf_x11_render_CreateLinearGradient_p2 = -1;
+static int hf_x11_render_CreateLinearGradient_num_stops = -1;
+static int hf_x11_render_CreateLinearGradient_stops = -1;
+static int hf_x11_render_CreateLinearGradient_stops_item = -1;
+static int hf_x11_render_CreateLinearGradient_colors = -1;
+static int hf_x11_render_CreateLinearGradient_colors_item = -1;
+static int hf_x11_render_CreateRadialGradient_picture = -1;
+static int hf_x11_render_CreateRadialGradient_inner = -1;
+static int hf_x11_render_CreateRadialGradient_outer = -1;
+static int hf_x11_render_CreateRadialGradient_inner_radius = -1;
+static int hf_x11_render_CreateRadialGradient_outer_radius = -1;
+static int hf_x11_render_CreateRadialGradient_num_stops = -1;
+static int hf_x11_render_CreateRadialGradient_stops = -1;
+static int hf_x11_render_CreateRadialGradient_stops_item = -1;
+static int hf_x11_render_CreateRadialGradient_colors = -1;
+static int hf_x11_render_CreateRadialGradient_colors_item = -1;
+static int hf_x11_render_CreateConicalGradient_picture = -1;
+static int hf_x11_render_CreateConicalGradient_center = -1;
+static int hf_x11_render_CreateConicalGradient_angle = -1;
+static int hf_x11_render_CreateConicalGradient_num_stops = -1;
+static int hf_x11_render_CreateConicalGradient_stops = -1;
+static int hf_x11_render_CreateConicalGradient_stops_item = -1;
+static int hf_x11_render_CreateConicalGradient_colors = -1;
+static int hf_x11_render_CreateConicalGradient_colors_item = -1;
+static int hf_x11_render_extension_minor = -1;
+
+static int hf_x11_struct_Client = -1;
+static int hf_x11_struct_Client_resource_base = -1;
+static int hf_x11_struct_Client_resource_mask = -1;
+static int hf_x11_struct_Type = -1;
+static int hf_x11_struct_Type_resource_type = -1;
+static int hf_x11_struct_Type_count = -1;
+static int hf_x11_res_QueryVersion_client_major = -1;
+static int hf_x11_res_QueryVersion_client_minor = -1;
+static int hf_x11_res_QueryVersion_reply_server_major = -1;
+static int hf_x11_res_QueryVersion_reply_server_minor = -1;
+static int hf_x11_res_QueryClients_reply_num_clients = -1;
+static int hf_x11_res_QueryClients_reply_clients = -1;
+static int hf_x11_res_QueryClients_reply_clients_item = -1;
+static int hf_x11_res_QueryClientResources_xid = -1;
+static int hf_x11_res_QueryClientResources_reply_num_types = -1;
+static int hf_x11_res_QueryClientResources_reply_types = -1;
+static int hf_x11_res_QueryClientResources_reply_types_item = -1;
+static int hf_x11_res_QueryClientPixmapBytes_xid = -1;
+static int hf_x11_res_QueryClientPixmapBytes_reply_bytes = -1;
+static int hf_x11_res_QueryClientPixmapBytes_reply_bytes_overflow = -1;
+static int hf_x11_res_extension_minor = -1;
+
+static int hf_x11_screensaver_QueryVersion_client_major_version = -1;
+static int hf_x11_screensaver_QueryVersion_client_minor_version = -1;
+static int hf_x11_screensaver_QueryVersion_reply_server_major_version = -1;
+static int hf_x11_screensaver_QueryVersion_reply_server_minor_version = -1;
+static int hf_x11_screensaver_QueryInfo_drawable = -1;
+static int hf_x11_screensaver_QueryInfo_reply_state = -1;
+static int hf_x11_screensaver_QueryInfo_reply_saver_window = -1;
+static int hf_x11_screensaver_QueryInfo_reply_ms_until_server = -1;
+static int hf_x11_screensaver_QueryInfo_reply_ms_since_user_input = -1;
+static int hf_x11_screensaver_QueryInfo_reply_event_mask = -1;
+static int hf_x11_screensaver_QueryInfo_reply_kind = -1;
+static int hf_x11_screensaver_SelectInput_drawable = -1;
+static int hf_x11_screensaver_SelectInput_event_mask = -1;
+static int hf_x11_screensaver_SetAttributes_drawable = -1;
+static int hf_x11_screensaver_SetAttributes_x = -1;
+static int hf_x11_screensaver_SetAttributes_y = -1;
+static int hf_x11_screensaver_SetAttributes_width = -1;
+static int hf_x11_screensaver_SetAttributes_height = -1;
+static int hf_x11_screensaver_SetAttributes_border_width = -1;
+static int hf_x11_screensaver_SetAttributes_class = -1;
+static int hf_x11_screensaver_SetAttributes_depth = -1;
+static int hf_x11_screensaver_SetAttributes_visual = -1;
+static int hf_x11_screensaver_UnsetAttributes_drawable = -1;
+static int hf_x11_screensaver_Suspend_suspend = -1;
+static int hf_x11_screensaver_Notify_code = -1;
+static int hf_x11_screensaver_Notify_state = -1;
+static int hf_x11_screensaver_Notify_sequence_number = -1;
+static int hf_x11_screensaver_Notify_time = -1;
+static int hf_x11_screensaver_Notify_root = -1;
+static int hf_x11_screensaver_Notify_window = -1;
+static int hf_x11_screensaver_Notify_kind = -1;
+static int hf_x11_screensaver_Notify_forced = -1;
+static int hf_x11_screensaver_extension_minor = -1;
+
+static int hf_x11_shape_Notify_shape_kind = -1;
+static int hf_x11_shape_Notify_affected_window = -1;
+static int hf_x11_shape_Notify_extents_x = -1;
+static int hf_x11_shape_Notify_extents_y = -1;
+static int hf_x11_shape_Notify_extents_width = -1;
+static int hf_x11_shape_Notify_extents_height = -1;
+static int hf_x11_shape_Notify_server_time = -1;
+static int hf_x11_shape_Notify_shaped = -1;
+static int hf_x11_shape_QueryVersion_reply_major_version = -1;
+static int hf_x11_shape_QueryVersion_reply_minor_version = -1;
+static int hf_x11_shape_Rectangles_operation = -1;
+static int hf_x11_shape_Rectangles_destination_kind = -1;
+static int hf_x11_shape_Rectangles_ordering = -1;
+static int hf_x11_shape_Rectangles_destination_window = -1;
+static int hf_x11_shape_Rectangles_x_offset = -1;
+static int hf_x11_shape_Rectangles_y_offset = -1;
+static int hf_x11_shape_Rectangles_rectangles = -1;
+static int hf_x11_shape_Rectangles_rectangles_item = -1;
+static int hf_x11_shape_Mask_operation = -1;
+static int hf_x11_shape_Mask_destination_kind = -1;
+static int hf_x11_shape_Mask_destination_window = -1;
+static int hf_x11_shape_Mask_x_offset = -1;
+static int hf_x11_shape_Mask_y_offset = -1;
+static int hf_x11_shape_Mask_source_bitmap = -1;
+static int hf_x11_shape_Combine_operation = -1;
+static int hf_x11_shape_Combine_destination_kind = -1;
+static int hf_x11_shape_Combine_source_kind = -1;
+static int hf_x11_shape_Combine_destination_window = -1;
+static int hf_x11_shape_Combine_x_offset = -1;
+static int hf_x11_shape_Combine_y_offset = -1;
+static int hf_x11_shape_Combine_source_window = -1;
+static int hf_x11_shape_Offset_destination_kind = -1;
+static int hf_x11_shape_Offset_destination_window = -1;
+static int hf_x11_shape_Offset_x_offset = -1;
+static int hf_x11_shape_Offset_y_offset = -1;
+static int hf_x11_shape_QueryExtents_destination_window = -1;
+static int hf_x11_shape_QueryExtents_reply_bounding_shaped = -1;
+static int hf_x11_shape_QueryExtents_reply_clip_shaped = -1;
+static int hf_x11_shape_QueryExtents_reply_bounding_shape_extents_x = -1;
+static int hf_x11_shape_QueryExtents_reply_bounding_shape_extents_y = -1;
+static int hf_x11_shape_QueryExtents_reply_bounding_shape_extents_width = -1;
+static int hf_x11_shape_QueryExtents_reply_bounding_shape_extents_height = -1;
+static int hf_x11_shape_QueryExtents_reply_clip_shape_extents_x = -1;
+static int hf_x11_shape_QueryExtents_reply_clip_shape_extents_y = -1;
+static int hf_x11_shape_QueryExtents_reply_clip_shape_extents_width = -1;
+static int hf_x11_shape_QueryExtents_reply_clip_shape_extents_height = -1;
+static int hf_x11_shape_SelectInput_destination_window = -1;
+static int hf_x11_shape_SelectInput_enable = -1;
+static int hf_x11_shape_InputSelected_destination_window = -1;
+static int hf_x11_shape_InputSelected_reply_enabled = -1;
+static int hf_x11_shape_GetRectangles_window = -1;
+static int hf_x11_shape_GetRectangles_source_kind = -1;
+static int hf_x11_shape_GetRectangles_reply_ordering = -1;
+static int hf_x11_shape_GetRectangles_reply_rectangles_len = -1;
+static int hf_x11_shape_GetRectangles_reply_rectangles = -1;
+static int hf_x11_shape_GetRectangles_reply_rectangles_item = -1;
+static int hf_x11_shape_extension_minor = -1;
+
+static int hf_x11_shm_Completion_drawable = -1;
+static int hf_x11_shm_Completion_minor_event = -1;
+static int hf_x11_shm_Completion_major_event = -1;
+static int hf_x11_shm_Completion_shmseg = -1;
+static int hf_x11_shm_Completion_offset = -1;
+static int hf_x11_shm_QueryVersion_reply_shared_pixmaps = -1;
+static int hf_x11_shm_QueryVersion_reply_major_version = -1;
+static int hf_x11_shm_QueryVersion_reply_minor_version = -1;
+static int hf_x11_shm_QueryVersion_reply_uid = -1;
+static int hf_x11_shm_QueryVersion_reply_gid = -1;
+static int hf_x11_shm_QueryVersion_reply_pixmap_format = -1;
+static int hf_x11_shm_Attach_shmseg = -1;
+static int hf_x11_shm_Attach_shmid = -1;
+static int hf_x11_shm_Attach_read_only = -1;
+static int hf_x11_shm_Detach_shmseg = -1;
+static int hf_x11_shm_PutImage_drawable = -1;
+static int hf_x11_shm_PutImage_gc = -1;
+static int hf_x11_shm_PutImage_total_width = -1;
+static int hf_x11_shm_PutImage_total_height = -1;
+static int hf_x11_shm_PutImage_src_x = -1;
+static int hf_x11_shm_PutImage_src_y = -1;
+static int hf_x11_shm_PutImage_src_width = -1;
+static int hf_x11_shm_PutImage_src_height = -1;
+static int hf_x11_shm_PutImage_dst_x = -1;
+static int hf_x11_shm_PutImage_dst_y = -1;
+static int hf_x11_shm_PutImage_depth = -1;
+static int hf_x11_shm_PutImage_format = -1;
+static int hf_x11_shm_PutImage_send_event = -1;
+static int hf_x11_shm_PutImage_shmseg = -1;
+static int hf_x11_shm_PutImage_offset = -1;
+static int hf_x11_shm_GetImage_drawable = -1;
+static int hf_x11_shm_GetImage_x = -1;
+static int hf_x11_shm_GetImage_y = -1;
+static int hf_x11_shm_GetImage_width = -1;
+static int hf_x11_shm_GetImage_height = -1;
+static int hf_x11_shm_GetImage_plane_mask = -1;
+static int hf_x11_shm_GetImage_format = -1;
+static int hf_x11_shm_GetImage_shmseg = -1;
+static int hf_x11_shm_GetImage_offset = -1;
+static int hf_x11_shm_GetImage_reply_depth = -1;
+static int hf_x11_shm_GetImage_reply_visual = -1;
+static int hf_x11_shm_GetImage_reply_size = -1;
+static int hf_x11_shm_CreatePixmap_pid = -1;
+static int hf_x11_shm_CreatePixmap_drawable = -1;
+static int hf_x11_shm_CreatePixmap_width = -1;
+static int hf_x11_shm_CreatePixmap_height = -1;
+static int hf_x11_shm_CreatePixmap_depth = -1;
+static int hf_x11_shm_CreatePixmap_shmseg = -1;
+static int hf_x11_shm_CreatePixmap_offset = -1;
+static int hf_x11_shm_extension_minor = -1;
+
+static int hf_x11_struct_INT64 = -1;
+static int hf_x11_struct_INT64_hi = -1;
+static int hf_x11_struct_INT64_lo = -1;
+static int hf_x11_struct_SYSTEMCOUNTER = -1;
+static int hf_x11_struct_SYSTEMCOUNTER_counter = -1;
+static int hf_x11_struct_SYSTEMCOUNTER_resolution = -1;
+static int hf_x11_struct_SYSTEMCOUNTER_name_len = -1;
+static int hf_x11_struct_SYSTEMCOUNTER_name = -1;
+static int hf_x11_struct_TRIGGER = -1;
+static int hf_x11_struct_TRIGGER_counter = -1;
+static int hf_x11_struct_TRIGGER_wait_type = -1;
+static int hf_x11_struct_TRIGGER_wait_value = -1;
+static int hf_x11_struct_TRIGGER_test_type = -1;
+static int hf_x11_struct_WAITCONDITION = -1;
+static int hf_x11_struct_WAITCONDITION_trigger = -1;
+static int hf_x11_struct_WAITCONDITION_event_threshold = -1;
+static int hf_x11_sync_Initialize_desired_major_version = -1;
+static int hf_x11_sync_Initialize_desired_minor_version = -1;
+static int hf_x11_sync_Initialize_reply_major_version = -1;
+static int hf_x11_sync_Initialize_reply_minor_version = -1;
+static int hf_x11_sync_ListSystemCounters_reply_counters_len = -1;
+static int hf_x11_sync_ListSystemCounters_reply_counters = -1;
+static int hf_x11_sync_CreateCounter_id = -1;
+static int hf_x11_sync_CreateCounter_initial_value = -1;
+static int hf_x11_sync_DestroyCounter_counter = -1;
+static int hf_x11_sync_QueryCounter_counter = -1;
+static int hf_x11_sync_QueryCounter_reply_counter_value = -1;
+static int hf_x11_sync_Await_wait_list = -1;
+static int hf_x11_sync_Await_wait_list_item = -1;
+static int hf_x11_sync_ChangeCounter_counter = -1;
+static int hf_x11_sync_ChangeCounter_amount = -1;
+static int hf_x11_sync_SetCounter_counter = -1;
+static int hf_x11_sync_SetCounter_value = -1;
+static int hf_x11_sync_CreateAlarm_id = -1;
+static int hf_x11_sync_ChangeAlarm_id = -1;
+static int hf_x11_sync_DestroyAlarm_alarm = -1;
+static int hf_x11_sync_QueryAlarm_alarm = -1;
+static int hf_x11_sync_QueryAlarm_reply_trigger = -1;
+static int hf_x11_sync_QueryAlarm_reply_delta = -1;
+static int hf_x11_sync_QueryAlarm_reply_events = -1;
+static int hf_x11_sync_QueryAlarm_reply_state = -1;
+static int hf_x11_sync_SetPriority_id = -1;
+static int hf_x11_sync_SetPriority_priority = -1;
+static int hf_x11_sync_GetPriority_id = -1;
+static int hf_x11_sync_GetPriority_reply_priority = -1;
+static int hf_x11_sync_CounterNotify_kind = -1;
+static int hf_x11_sync_CounterNotify_counter = -1;
+static int hf_x11_sync_CounterNotify_wait_value = -1;
+static int hf_x11_sync_CounterNotify_counter_value = -1;
+static int hf_x11_sync_CounterNotify_timestamp = -1;
+static int hf_x11_sync_CounterNotify_count = -1;
+static int hf_x11_sync_CounterNotify_destroyed = -1;
+static int hf_x11_sync_AlarmNotify_kind = -1;
+static int hf_x11_sync_AlarmNotify_alarm = -1;
+static int hf_x11_sync_AlarmNotify_counter_value = -1;
+static int hf_x11_sync_AlarmNotify_alarm_value = -1;
+static int hf_x11_sync_AlarmNotify_timestamp = -1;
+static int hf_x11_sync_AlarmNotify_state = -1;
+static int hf_x11_sync_extension_minor = -1;
+
+static int hf_x11_xc_misc_GetVersion_client_major_version = -1;
+static int hf_x11_xc_misc_GetVersion_client_minor_version = -1;
+static int hf_x11_xc_misc_GetVersion_reply_server_major_version = -1;
+static int hf_x11_xc_misc_GetVersion_reply_server_minor_version = -1;
+static int hf_x11_xc_misc_GetXIDRange_reply_start_id = -1;
+static int hf_x11_xc_misc_GetXIDRange_reply_count = -1;
+static int hf_x11_xc_misc_GetXIDList_count = -1;
+static int hf_x11_xc_misc_GetXIDList_reply_ids_len = -1;
+static int hf_x11_xc_misc_GetXIDList_reply_ids = -1;
+static int hf_x11_xc_misc_GetXIDList_reply_ids_item = -1;
+static int hf_x11_xc_misc_extension_minor = -1;
+
+static int hf_x11_xevie_QueryVersion_client_major_version = -1;
+static int hf_x11_xevie_QueryVersion_client_minor_version = -1;
+static int hf_x11_xevie_QueryVersion_reply_server_major_version = -1;
+static int hf_x11_xevie_QueryVersion_reply_server_minor_version = -1;
+static int hf_x11_xevie_Start_screen = -1;
+static int hf_x11_xevie_End_cmap = -1;
+static int hf_x11_struct_Event = -1;
+static int hf_x11_xevie_Send_event = -1;
+static int hf_x11_xevie_Send_data_type = -1;
+static int hf_x11_xevie_SelectInput_event_mask = -1;
+static int hf_x11_xevie_extension_minor = -1;
+
+static int hf_x11_struct_DrmClipRect = -1;
+static int hf_x11_struct_DrmClipRect_x1 = -1;
+static int hf_x11_struct_DrmClipRect_y1 = -1;
+static int hf_x11_struct_DrmClipRect_x2 = -1;
+static int hf_x11_struct_DrmClipRect_x3 = -1;
+static int hf_x11_xf86dri_QueryVersion_reply_dri_major_version = -1;
+static int hf_x11_xf86dri_QueryVersion_reply_dri_minor_version = -1;
+static int hf_x11_xf86dri_QueryVersion_reply_dri_minor_patch = -1;
+static int hf_x11_xf86dri_QueryDirectRenderingCapable_screen = -1;
+static int hf_x11_xf86dri_QueryDirectRenderingCapable_reply_is_capable = -1;
+static int hf_x11_xf86dri_OpenConnection_screen = -1;
+static int hf_x11_xf86dri_OpenConnection_reply_drm_client_key_low = -1;
+static int hf_x11_xf86dri_OpenConnection_reply_drm_client_key_high = -1;
+static int hf_x11_xf86dri_OpenConnection_reply_sarea_handle_low = -1;
+static int hf_x11_xf86dri_OpenConnection_reply_sarea_handle_high = -1;
+static int hf_x11_xf86dri_OpenConnection_reply_bus_id_len = -1;
+static int hf_x11_xf86dri_OpenConnection_reply_bus_id = -1;
+static int hf_x11_xf86dri_CloseConnection_screen = -1;
+static int hf_x11_xf86dri_GetClientDriverName_screen = -1;
+static int hf_x11_xf86dri_GetClientDriverName_reply_client_driver_major_version = -1;
+static int hf_x11_xf86dri_GetClientDriverName_reply_client_driver_minor_version = -1;
+static int hf_x11_xf86dri_GetClientDriverName_reply_client_driver_patch_version = -1;
+static int hf_x11_xf86dri_GetClientDriverName_reply_client_driver_name_len = -1;
+static int hf_x11_xf86dri_GetClientDriverName_reply_client_driver_name = -1;
+static int hf_x11_xf86dri_CreateContext_visual = -1;
+static int hf_x11_xf86dri_CreateContext_screen = -1;
+static int hf_x11_xf86dri_CreateContext_context = -1;
+static int hf_x11_xf86dri_CreateContext_reply_hw_context = -1;
+static int hf_x11_xf86dri_DestroyContext_screen = -1;
+static int hf_x11_xf86dri_DestroyContext_context = -1;
+static int hf_x11_xf86dri_CreateDrawable_screen = -1;
+static int hf_x11_xf86dri_CreateDrawable_drawable = -1;
+static int hf_x11_xf86dri_CreateDrawable_reply_hw_drawable_handle = -1;
+static int hf_x11_xf86dri_DestroyDrawable_screen = -1;
+static int hf_x11_xf86dri_DestroyDrawable_drawable = -1;
+static int hf_x11_xf86dri_GetDrawableInfo_screen = -1;
+static int hf_x11_xf86dri_GetDrawableInfo_drawable = -1;
+static int hf_x11_xf86dri_GetDrawableInfo_reply_drawable_table_index = -1;
+static int hf_x11_xf86dri_GetDrawableInfo_reply_drawable_table_stamp = -1;
+static int hf_x11_xf86dri_GetDrawableInfo_reply_drawable_origin_X = -1;
+static int hf_x11_xf86dri_GetDrawableInfo_reply_drawable_origin_Y = -1;
+static int hf_x11_xf86dri_GetDrawableInfo_reply_drawable_size_W = -1;
+static int hf_x11_xf86dri_GetDrawableInfo_reply_drawable_size_H = -1;
+static int hf_x11_xf86dri_GetDrawableInfo_reply_num_clip_rects = -1;
+static int hf_x11_xf86dri_GetDrawableInfo_reply_clip_rects = -1;
+static int hf_x11_xf86dri_GetDrawableInfo_reply_clip_rects_item = -1;
+static int hf_x11_xf86dri_GetDeviceInfo_screen = -1;
+static int hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_handle_low = -1;
+static int hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_handle_high = -1;
+static int hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_origin_offset = -1;
+static int hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_size = -1;
+static int hf_x11_xf86dri_GetDeviceInfo_reply_framebuffer_stride = -1;
+static int hf_x11_xf86dri_GetDeviceInfo_reply_device_private_size = -1;
+static int hf_x11_xf86dri_GetDeviceInfo_reply_device_private = -1;
+static int hf_x11_xf86dri_GetDeviceInfo_reply_device_private_item = -1;
+static int hf_x11_xf86dri_AuthConnection_screen = -1;
+static int hf_x11_xf86dri_AuthConnection_magic = -1;
+static int hf_x11_xf86dri_AuthConnection_reply_authenticated = -1;
+static int hf_x11_xf86dri_extension_minor = -1;
+
+static int hf_x11_xf86vidmode_QueryVersion_reply_major_version = -1;
+static int hf_x11_xf86vidmode_QueryVersion_reply_minor_version = -1;
+static int hf_x11_xf86vidmode_GetModeLine_screen = -1;
+static int hf_x11_xf86vidmode_GetModeLine_reply_dotclock = -1;
+static int hf_x11_xf86vidmode_GetModeLine_reply_hdisplay = -1;
+static int hf_x11_xf86vidmode_GetModeLine_reply_hsyncstart = -1;
+static int hf_x11_xf86vidmode_GetModeLine_reply_hsyncend = -1;
+static int hf_x11_xf86vidmode_GetModeLine_reply_htotal = -1;
+static int hf_x11_xf86vidmode_GetModeLine_reply_hskew = -1;
+static int hf_x11_xf86vidmode_GetModeLine_reply_vdisplay = -1;
+static int hf_x11_xf86vidmode_GetModeLine_reply_vsyncstart = -1;
+static int hf_x11_xf86vidmode_GetModeLine_reply_vsyncend = -1;
+static int hf_x11_xf86vidmode_GetModeLine_reply_vtotal = -1;
+static int hf_x11_xf86vidmode_GetModeLine_reply_flags = -1;
+static int hf_x11_xf86vidmode_GetModeLine_reply_privsize = -1;
+static int hf_x11_xf86vidmode_GetModeLine_reply_private = -1;
+static int hf_x11_xf86vidmode_ModModeLine_screen = -1;
+static int hf_x11_xf86vidmode_ModModeLine_hdisplay = -1;
+static int hf_x11_xf86vidmode_ModModeLine_hsyncstart = -1;
+static int hf_x11_xf86vidmode_ModModeLine_hsyncend = -1;
+static int hf_x11_xf86vidmode_ModModeLine_htotal = -1;
+static int hf_x11_xf86vidmode_ModModeLine_hskew = -1;
+static int hf_x11_xf86vidmode_ModModeLine_vdisplay = -1;
+static int hf_x11_xf86vidmode_ModModeLine_vsyncstart = -1;
+static int hf_x11_xf86vidmode_ModModeLine_vsyncend = -1;
+static int hf_x11_xf86vidmode_ModModeLine_vtotal = -1;
+static int hf_x11_xf86vidmode_ModModeLine_flags = -1;
+static int hf_x11_xf86vidmode_ModModeLine_privsize = -1;
+static int hf_x11_xf86vidmode_ModModeLine_private = -1;
+static int hf_x11_xf86vidmode_SwitchMode_screen = -1;
+static int hf_x11_xf86vidmode_SwitchMode_zoom = -1;
+static int hf_x11_xf86vidmode_GetMonitor_screen = -1;
+static int hf_x11_xf86vidmode_GetMonitor_reply_vendor_length = -1;
+static int hf_x11_xf86vidmode_GetMonitor_reply_model_length = -1;
+static int hf_x11_xf86vidmode_GetMonitor_reply_num_hsync = -1;
+static int hf_x11_xf86vidmode_GetMonitor_reply_num_vsync = -1;
+static int hf_x11_xf86vidmode_GetMonitor_reply_hsync = -1;
+static int hf_x11_xf86vidmode_GetMonitor_reply_hsync_item = -1;
+static int hf_x11_xf86vidmode_GetMonitor_reply_vsync = -1;
+static int hf_x11_xf86vidmode_GetMonitor_reply_vsync_item = -1;
+static int hf_x11_xf86vidmode_GetMonitor_reply_vendor = -1;
+static int hf_x11_xf86vidmode_GetMonitor_reply_alignment_pad = -1;
+static int hf_x11_xf86vidmode_GetMonitor_reply_model = -1;
+static int hf_x11_xf86vidmode_LockModeSwitch_screen = -1;
+static int hf_x11_xf86vidmode_LockModeSwitch_lock = -1;
+static int hf_x11_xf86vidmode_GetAllModeLines_screen = -1;
+static int hf_x11_xf86vidmode_GetAllModeLines_reply_modecount = -1;
+static int hf_x11_xf86vidmode_GetAllModeLines_reply_modeinfo = -1;
+static int hf_x11_xf86vidmode_GetAllModeLines_reply_modeinfo_item = -1;
+static int hf_x11_xf86vidmode_AddModeLine_screen = -1;
+static int hf_x11_xf86vidmode_AddModeLine_dotclock = -1;
+static int hf_x11_xf86vidmode_AddModeLine_hdisplay = -1;
+static int hf_x11_xf86vidmode_AddModeLine_hsyncstart = -1;
+static int hf_x11_xf86vidmode_AddModeLine_hsyncend = -1;
+static int hf_x11_xf86vidmode_AddModeLine_htotal = -1;
+static int hf_x11_xf86vidmode_AddModeLine_hskew = -1;
+static int hf_x11_xf86vidmode_AddModeLine_vdisplay = -1;
+static int hf_x11_xf86vidmode_AddModeLine_vsyncstart = -1;
+static int hf_x11_xf86vidmode_AddModeLine_vsyncend = -1;
+static int hf_x11_xf86vidmode_AddModeLine_vtotal = -1;
+static int hf_x11_xf86vidmode_AddModeLine_flags = -1;
+static int hf_x11_xf86vidmode_AddModeLine_privsize = -1;
+static int hf_x11_xf86vidmode_AddModeLine_after_dotclock = -1;
+static int hf_x11_xf86vidmode_AddModeLine_after_hdisplay = -1;
+static int hf_x11_xf86vidmode_AddModeLine_after_hsyncstart = -1;
+static int hf_x11_xf86vidmode_AddModeLine_after_hsyncend = -1;
+static int hf_x11_xf86vidmode_AddModeLine_after_htotal = -1;
+static int hf_x11_xf86vidmode_AddModeLine_after_hskew = -1;
+static int hf_x11_xf86vidmode_AddModeLine_after_vdisplay = -1;
+static int hf_x11_xf86vidmode_AddModeLine_after_vsyncstart = -1;
+static int hf_x11_xf86vidmode_AddModeLine_after_vsyncend = -1;
+static int hf_x11_xf86vidmode_AddModeLine_after_vtotal = -1;
+static int hf_x11_xf86vidmode_AddModeLine_after_flags = -1;
+static int hf_x11_xf86vidmode_AddModeLine_private = -1;
+static int hf_x11_xf86vidmode_DeleteModeLine_screen = -1;
+static int hf_x11_xf86vidmode_DeleteModeLine_dotclock = -1;
+static int hf_x11_xf86vidmode_DeleteModeLine_hdisplay = -1;
+static int hf_x11_xf86vidmode_DeleteModeLine_hsyncstart = -1;
+static int hf_x11_xf86vidmode_DeleteModeLine_hsyncend = -1;
+static int hf_x11_xf86vidmode_DeleteModeLine_htotal = -1;
+static int hf_x11_xf86vidmode_DeleteModeLine_hskew = -1;
+static int hf_x11_xf86vidmode_DeleteModeLine_vdisplay = -1;
+static int hf_x11_xf86vidmode_DeleteModeLine_vsyncstart = -1;
+static int hf_x11_xf86vidmode_DeleteModeLine_vsyncend = -1;
+static int hf_x11_xf86vidmode_DeleteModeLine_vtotal = -1;
+static int hf_x11_xf86vidmode_DeleteModeLine_flags = -1;
+static int hf_x11_xf86vidmode_DeleteModeLine_privsize = -1;
+static int hf_x11_xf86vidmode_DeleteModeLine_private = -1;
+static int hf_x11_xf86vidmode_ValidateModeLine_screen = -1;
+static int hf_x11_xf86vidmode_ValidateModeLine_dotclock = -1;
+static int hf_x11_xf86vidmode_ValidateModeLine_hdisplay = -1;
+static int hf_x11_xf86vidmode_ValidateModeLine_hsyncstart = -1;
+static int hf_x11_xf86vidmode_ValidateModeLine_hsyncend = -1;
+static int hf_x11_xf86vidmode_ValidateModeLine_htotal = -1;
+static int hf_x11_xf86vidmode_ValidateModeLine_hskew = -1;
+static int hf_x11_xf86vidmode_ValidateModeLine_vdisplay = -1;
+static int hf_x11_xf86vidmode_ValidateModeLine_vsyncstart = -1;
+static int hf_x11_xf86vidmode_ValidateModeLine_vsyncend = -1;
+static int hf_x11_xf86vidmode_ValidateModeLine_vtotal = -1;
+static int hf_x11_xf86vidmode_ValidateModeLine_flags = -1;
+static int hf_x11_xf86vidmode_ValidateModeLine_privsize = -1;
+static int hf_x11_xf86vidmode_ValidateModeLine_private = -1;
+static int hf_x11_xf86vidmode_ValidateModeLine_reply_status = -1;
+static int hf_x11_xf86vidmode_SwitchToMode_screen = -1;
+static int hf_x11_xf86vidmode_SwitchToMode_dotclock = -1;
+static int hf_x11_xf86vidmode_SwitchToMode_hdisplay = -1;
+static int hf_x11_xf86vidmode_SwitchToMode_hsyncstart = -1;
+static int hf_x11_xf86vidmode_SwitchToMode_hsyncend = -1;
+static int hf_x11_xf86vidmode_SwitchToMode_htotal = -1;
+static int hf_x11_xf86vidmode_SwitchToMode_hskew = -1;
+static int hf_x11_xf86vidmode_SwitchToMode_vdisplay = -1;
+static int hf_x11_xf86vidmode_SwitchToMode_vsyncstart = -1;
+static int hf_x11_xf86vidmode_SwitchToMode_vsyncend = -1;
+static int hf_x11_xf86vidmode_SwitchToMode_vtotal = -1;
+static int hf_x11_xf86vidmode_SwitchToMode_flags = -1;
+static int hf_x11_xf86vidmode_SwitchToMode_privsize = -1;
+static int hf_x11_xf86vidmode_SwitchToMode_private = -1;
+static int hf_x11_xf86vidmode_GetViewPort_screen = -1;
+static int hf_x11_xf86vidmode_GetViewPort_reply_x = -1;
+static int hf_x11_xf86vidmode_GetViewPort_reply_y = -1;
+static int hf_x11_xf86vidmode_SetViewPort_screen = -1;
+static int hf_x11_xf86vidmode_SetViewPort_x = -1;
+static int hf_x11_xf86vidmode_SetViewPort_y = -1;
+static int hf_x11_xf86vidmode_GetDotClocks_screen = -1;
+static int hf_x11_xf86vidmode_GetDotClocks_reply_flags = -1;
+static int hf_x11_xf86vidmode_GetDotClocks_reply_clocks = -1;
+static int hf_x11_xf86vidmode_GetDotClocks_reply_maxclocks = -1;
+static int hf_x11_xf86vidmode_GetDotClocks_reply_clock = -1;
+static int hf_x11_xf86vidmode_GetDotClocks_reply_clock_item = -1;
+static int hf_x11_xf86vidmode_SetClientVersion_major = -1;
+static int hf_x11_xf86vidmode_SetClientVersion_minor = -1;
+static int hf_x11_xf86vidmode_SetGamma_screen = -1;
+static int hf_x11_xf86vidmode_SetGamma_red = -1;
+static int hf_x11_xf86vidmode_SetGamma_green = -1;
+static int hf_x11_xf86vidmode_SetGamma_blue = -1;
+static int hf_x11_xf86vidmode_GetGamma_screen = -1;
+static int hf_x11_xf86vidmode_GetGamma_reply_red = -1;
+static int hf_x11_xf86vidmode_GetGamma_reply_green = -1;
+static int hf_x11_xf86vidmode_GetGamma_reply_blue = -1;
+static int hf_x11_xf86vidmode_GetGammaRamp_screen = -1;
+static int hf_x11_xf86vidmode_GetGammaRamp_size = -1;
+static int hf_x11_xf86vidmode_GetGammaRamp_reply_size = -1;
+static int hf_x11_xf86vidmode_GetGammaRamp_reply_red = -1;
+static int hf_x11_xf86vidmode_GetGammaRamp_reply_red_item = -1;
+static int hf_x11_xf86vidmode_GetGammaRamp_reply_green = -1;
+static int hf_x11_xf86vidmode_GetGammaRamp_reply_green_item = -1;
+static int hf_x11_xf86vidmode_GetGammaRamp_reply_blue = -1;
+static int hf_x11_xf86vidmode_GetGammaRamp_reply_blue_item = -1;
+static int hf_x11_xf86vidmode_SetGammaRamp_screen = -1;
+static int hf_x11_xf86vidmode_SetGammaRamp_size = -1;
+static int hf_x11_xf86vidmode_SetGammaRamp_red = -1;
+static int hf_x11_xf86vidmode_SetGammaRamp_red_item = -1;
+static int hf_x11_xf86vidmode_SetGammaRamp_green = -1;
+static int hf_x11_xf86vidmode_SetGammaRamp_green_item = -1;
+static int hf_x11_xf86vidmode_SetGammaRamp_blue = -1;
+static int hf_x11_xf86vidmode_SetGammaRamp_blue_item = -1;
+static int hf_x11_xf86vidmode_GetGammaRampSize_screen = -1;
+static int hf_x11_xf86vidmode_GetGammaRampSize_reply_size = -1;
+static int hf_x11_xf86vidmode_GetPermissions_screen = -1;
+static int hf_x11_xf86vidmode_GetPermissions_reply_permissions = -1;
+static int hf_x11_xf86vidmode_extension_minor = -1;
+
+static int hf_x11_xfixes_QueryVersion_client_major_version = -1;
+static int hf_x11_xfixes_QueryVersion_client_minor_version = -1;
+static int hf_x11_xfixes_QueryVersion_reply_major_version = -1;
+static int hf_x11_xfixes_QueryVersion_reply_minor_version = -1;
+static int hf_x11_xfixes_ChangeSaveSet_mode = -1;
+static int hf_x11_xfixes_ChangeSaveSet_target = -1;
+static int hf_x11_xfixes_ChangeSaveSet_map = -1;
+static int hf_x11_xfixes_ChangeSaveSet_window = -1;
+static int hf_x11_xfixes_SelectionNotify_subtype = -1;
+static int hf_x11_xfixes_SelectionNotify_window = -1;
+static int hf_x11_xfixes_SelectionNotify_owner = -1;
+static int hf_x11_xfixes_SelectionNotify_selection = -1;
+static int hf_x11_xfixes_SelectionNotify_timestamp = -1;
+static int hf_x11_xfixes_SelectionNotify_selection_timestamp = -1;
+static int hf_x11_xfixes_SelectSelectionInput_window = -1;
+static int hf_x11_xfixes_SelectSelectionInput_selection = -1;
+static int hf_x11_xfixes_SelectSelectionInput_event_mask = -1;
+static int hf_x11_xfixes_CursorNotify_subtype = -1;
+static int hf_x11_xfixes_CursorNotify_window = -1;
+static int hf_x11_xfixes_CursorNotify_cursor_serial = -1;
+static int hf_x11_xfixes_CursorNotify_timestamp = -1;
+static int hf_x11_xfixes_CursorNotify_name = -1;
+static int hf_x11_xfixes_SelectCursorInput_window = -1;
+static int hf_x11_xfixes_SelectCursorInput_event_mask = -1;
+static int hf_x11_xfixes_GetCursorImage_reply_x = -1;
+static int hf_x11_xfixes_GetCursorImage_reply_y = -1;
+static int hf_x11_xfixes_GetCursorImage_reply_width = -1;
+static int hf_x11_xfixes_GetCursorImage_reply_height = -1;
+static int hf_x11_xfixes_GetCursorImage_reply_xhot = -1;
+static int hf_x11_xfixes_GetCursorImage_reply_yhot = -1;
+static int hf_x11_xfixes_GetCursorImage_reply_cursor_serial = -1;
+static int hf_x11_xfixes_GetCursorImage_reply_cursor_image = -1;
+static int hf_x11_xfixes_GetCursorImage_reply_cursor_image_item = -1;
+static int hf_x11_xfixes_CreateRegion_region = -1;
+static int hf_x11_xfixes_CreateRegion_rectangles = -1;
+static int hf_x11_xfixes_CreateRegion_rectangles_item = -1;
+static int hf_x11_xfixes_CreateRegionFromBitmap_region = -1;
+static int hf_x11_xfixes_CreateRegionFromBitmap_bitmap = -1;
+static int hf_x11_xfixes_CreateRegionFromWindow_region = -1;
+static int hf_x11_xfixes_CreateRegionFromWindow_window = -1;
+static int hf_x11_xfixes_CreateRegionFromWindow_kind = -1;
+static int hf_x11_xfixes_CreateRegionFromGC_region = -1;
+static int hf_x11_xfixes_CreateRegionFromGC_gc = -1;
+static int hf_x11_xfixes_CreateRegionFromPicture_region = -1;
+static int hf_x11_xfixes_CreateRegionFromPicture_picture = -1;
+static int hf_x11_xfixes_DestroyRegion_region = -1;
+static int hf_x11_xfixes_SetRegion_region = -1;
+static int hf_x11_xfixes_SetRegion_rectangles = -1;
+static int hf_x11_xfixes_SetRegion_rectangles_item = -1;
+static int hf_x11_xfixes_CopyRegion_source = -1;
+static int hf_x11_xfixes_CopyRegion_destination = -1;
+static int hf_x11_xfixes_UnionRegion_source1 = -1;
+static int hf_x11_xfixes_UnionRegion_source2 = -1;
+static int hf_x11_xfixes_UnionRegion_destination = -1;
+static int hf_x11_xfixes_IntersectRegion_source1 = -1;
+static int hf_x11_xfixes_IntersectRegion_source2 = -1;
+static int hf_x11_xfixes_IntersectRegion_destination = -1;
+static int hf_x11_xfixes_SubtractRegion_source1 = -1;
+static int hf_x11_xfixes_SubtractRegion_source2 = -1;
+static int hf_x11_xfixes_SubtractRegion_destination = -1;
+static int hf_x11_xfixes_InvertRegion_source = -1;
+static int hf_x11_xfixes_InvertRegion_bounds = -1;
+static int hf_x11_xfixes_InvertRegion_destination = -1;
+static int hf_x11_xfixes_TranslateRegion_region = -1;
+static int hf_x11_xfixes_TranslateRegion_dx = -1;
+static int hf_x11_xfixes_TranslateRegion_dy = -1;
+static int hf_x11_xfixes_RegionExtents_source = -1;
+static int hf_x11_xfixes_RegionExtents_destination = -1;
+static int hf_x11_xfixes_FetchRegion_region = -1;
+static int hf_x11_xfixes_FetchRegion_reply_extents = -1;
+static int hf_x11_xfixes_FetchRegion_reply_rectangles = -1;
+static int hf_x11_xfixes_FetchRegion_reply_rectangles_item = -1;
+static int hf_x11_xfixes_SetGCClipRegion_gc = -1;
+static int hf_x11_xfixes_SetGCClipRegion_region = -1;
+static int hf_x11_xfixes_SetGCClipRegion_x_origin = -1;
+static int hf_x11_xfixes_SetGCClipRegion_y_origin = -1;
+static int hf_x11_xfixes_SetWindowShapeRegion_dest = -1;
+static int hf_x11_xfixes_SetWindowShapeRegion_dest_kind = -1;
+static int hf_x11_xfixes_SetWindowShapeRegion_x_offset = -1;
+static int hf_x11_xfixes_SetWindowShapeRegion_y_offset = -1;
+static int hf_x11_xfixes_SetWindowShapeRegion_region = -1;
+static int hf_x11_xfixes_SetPictureClipRegion_picture = -1;
+static int hf_x11_xfixes_SetPictureClipRegion_region = -1;
+static int hf_x11_xfixes_SetPictureClipRegion_x_origin = -1;
+static int hf_x11_xfixes_SetPictureClipRegion_y_origin = -1;
+static int hf_x11_xfixes_SetCursorName_cursor = -1;
+static int hf_x11_xfixes_SetCursorName_nbytes = -1;
+static int hf_x11_xfixes_SetCursorName_name = -1;
+static int hf_x11_xfixes_GetCursorName_cursor = -1;
+static int hf_x11_xfixes_GetCursorName_reply_atom = -1;
+static int hf_x11_xfixes_GetCursorName_reply_nbytes = -1;
+static int hf_x11_xfixes_GetCursorName_reply_name = -1;
+static int hf_x11_xfixes_GetCursorImageAndName_reply_x = -1;
+static int hf_x11_xfixes_GetCursorImageAndName_reply_y = -1;
+static int hf_x11_xfixes_GetCursorImageAndName_reply_width = -1;
+static int hf_x11_xfixes_GetCursorImageAndName_reply_height = -1;
+static int hf_x11_xfixes_GetCursorImageAndName_reply_xhot = -1;
+static int hf_x11_xfixes_GetCursorImageAndName_reply_yhot = -1;
+static int hf_x11_xfixes_GetCursorImageAndName_reply_cursor_serial = -1;
+static int hf_x11_xfixes_GetCursorImageAndName_reply_cursor_atom = -1;
+static int hf_x11_xfixes_GetCursorImageAndName_reply_nbytes = -1;
+static int hf_x11_xfixes_GetCursorImageAndName_reply_name = -1;
+static int hf_x11_xfixes_GetCursorImageAndName_reply_cursor_image = -1;
+static int hf_x11_xfixes_GetCursorImageAndName_reply_cursor_image_item = -1;
+static int hf_x11_xfixes_ChangeCursor_source = -1;
+static int hf_x11_xfixes_ChangeCursor_destination = -1;
+static int hf_x11_xfixes_ChangeCursorByName_src = -1;
+static int hf_x11_xfixes_ChangeCursorByName_nbytes = -1;
+static int hf_x11_xfixes_ChangeCursorByName_name = -1;
+static int hf_x11_xfixes_ExpandRegion_source = -1;
+static int hf_x11_xfixes_ExpandRegion_destination = -1;
+static int hf_x11_xfixes_ExpandRegion_left = -1;
+static int hf_x11_xfixes_ExpandRegion_right = -1;
+static int hf_x11_xfixes_ExpandRegion_top = -1;
+static int hf_x11_xfixes_ExpandRegion_bottom = -1;
+static int hf_x11_xfixes_HideCursor_window = -1;
+static int hf_x11_xfixes_ShowCursor_window = -1;
+static int hf_x11_xfixes_extension_minor = -1;
+
+static int hf_x11_struct_ScreenInfo = -1;
+static int hf_x11_struct_ScreenInfo_x_org = -1;
+static int hf_x11_struct_ScreenInfo_y_org = -1;
+static int hf_x11_struct_ScreenInfo_width = -1;
+static int hf_x11_struct_ScreenInfo_height = -1;
+static int hf_x11_xinerama_QueryVersion_major = -1;
+static int hf_x11_xinerama_QueryVersion_minor = -1;
+static int hf_x11_xinerama_QueryVersion_reply_major = -1;
+static int hf_x11_xinerama_QueryVersion_reply_minor = -1;
+static int hf_x11_xinerama_GetState_window = -1;
+static int hf_x11_xinerama_GetState_reply_state = -1;
+static int hf_x11_xinerama_GetState_reply_window = -1;
+static int hf_x11_xinerama_GetScreenCount_window = -1;
+static int hf_x11_xinerama_GetScreenCount_reply_screen_count = -1;
+static int hf_x11_xinerama_GetScreenCount_reply_window = -1;
+static int hf_x11_xinerama_GetScreenSize_window = -1;
+static int hf_x11_xinerama_GetScreenSize_screen = -1;
+static int hf_x11_xinerama_GetScreenSize_reply_width = -1;
+static int hf_x11_xinerama_GetScreenSize_reply_height = -1;
+static int hf_x11_xinerama_GetScreenSize_reply_window = -1;
+static int hf_x11_xinerama_GetScreenSize_reply_screen = -1;
+static int hf_x11_xinerama_IsActive_reply_state = -1;
+static int hf_x11_xinerama_QueryScreens_reply_number = -1;
+static int hf_x11_xinerama_QueryScreens_reply_screen_info = -1;
+static int hf_x11_xinerama_QueryScreens_reply_screen_info_item = -1;
+static int hf_x11_xinerama_extension_minor = -1;
+
+static int hf_x11_xinput_GetExtensionVersion_name_len = -1;
+static int hf_x11_xinput_GetExtensionVersion_name = -1;
+static int hf_x11_xinput_GetExtensionVersion_reply_server_major = -1;
+static int hf_x11_xinput_GetExtensionVersion_reply_server_minor = -1;
+static int hf_x11_xinput_GetExtensionVersion_reply_present = -1;
+static int hf_x11_struct_DeviceInfo = -1;
+static int hf_x11_struct_DeviceInfo_device_type = -1;
+static int hf_x11_struct_DeviceInfo_device_id = -1;
+static int hf_x11_struct_DeviceInfo_num_class_info = -1;
+static int hf_x11_struct_DeviceInfo_device_use = -1;
+static int hf_x11_xinput_ListInputDevices_reply_devices_len = -1;
+static int hf_x11_xinput_ListInputDevices_reply_devices = -1;
+static int hf_x11_xinput_ListInputDevices_reply_devices_item = -1;
+static int hf_x11_struct_InputClassInfo = -1;
+static int hf_x11_struct_InputClassInfo_class_id = -1;
+static int hf_x11_struct_InputClassInfo_event_type_base = -1;
+static int hf_x11_xinput_OpenDevice_device_id = -1;
+static int hf_x11_xinput_OpenDevice_reply_num_classes = -1;
+static int hf_x11_xinput_OpenDevice_reply_class_info = -1;
+static int hf_x11_xinput_OpenDevice_reply_class_info_item = -1;
+static int hf_x11_xinput_CloseDevice_device_id = -1;
+static int hf_x11_xinput_SetDeviceMode_device_id = -1;
+static int hf_x11_xinput_SetDeviceMode_mode = -1;
+static int hf_x11_xinput_SetDeviceMode_reply_status = -1;
+static int hf_x11_xinput_SelectExtensionEvent_window = -1;
+static int hf_x11_xinput_SelectExtensionEvent_num_classes = -1;
+static int hf_x11_xinput_SelectExtensionEvent_classes = -1;
+static int hf_x11_xinput_SelectExtensionEvent_classes_item = -1;
+static int hf_x11_xinput_GetSelectedExtensionEvents_window = -1;
+static int hf_x11_xinput_GetSelectedExtensionEvents_reply_num_this_classes = -1;
+static int hf_x11_xinput_GetSelectedExtensionEvents_reply_num_all_classes = -1;
+static int hf_x11_xinput_GetSelectedExtensionEvents_reply_this_classes = -1;
+static int hf_x11_xinput_GetSelectedExtensionEvents_reply_this_classes_item = -1;
+static int hf_x11_xinput_GetSelectedExtensionEvents_reply_all_classes = -1;
+static int hf_x11_xinput_GetSelectedExtensionEvents_reply_all_classes_item = -1;
+static int hf_x11_xinput_ChangeDeviceDontPropagateList_window = -1;
+static int hf_x11_xinput_ChangeDeviceDontPropagateList_num_classes = -1;
+static int hf_x11_xinput_ChangeDeviceDontPropagateList_mode = -1;
+static int hf_x11_xinput_ChangeDeviceDontPropagateList_classes = -1;
+static int hf_x11_xinput_ChangeDeviceDontPropagateList_classes_item = -1;
+static int hf_x11_xinput_GetDeviceDontPropagateList_window = -1;
+static int hf_x11_xinput_GetDeviceDontPropagateList_reply_num_classes = -1;
+static int hf_x11_xinput_GetDeviceDontPropagateList_reply_classes = -1;
+static int hf_x11_xinput_GetDeviceDontPropagateList_reply_classes_item = -1;
+static int hf_x11_xinput_GetDeviceMotionEvents_start = -1;
+static int hf_x11_xinput_GetDeviceMotionEvents_stop = -1;
+static int hf_x11_xinput_GetDeviceMotionEvents_device_id = -1;
+static int hf_x11_xinput_GetDeviceMotionEvents_reply_num_coords = -1;
+static int hf_x11_xinput_GetDeviceMotionEvents_reply_num_axes = -1;
+static int hf_x11_xinput_GetDeviceMotionEvents_reply_device_mode = -1;
+static int hf_x11_xinput_ChangeKeyboardDevice_device_id = -1;
+static int hf_x11_xinput_ChangeKeyboardDevice_reply_status = -1;
+static int hf_x11_xinput_ChangePointerDevice_x_axis = -1;
+static int hf_x11_xinput_ChangePointerDevice_y_axis = -1;
+static int hf_x11_xinput_ChangePointerDevice_device_id = -1;
+static int hf_x11_xinput_ChangePointerDevice_reply_status = -1;
+static int hf_x11_xinput_GrabDevice_grab_window = -1;
+static int hf_x11_xinput_GrabDevice_time = -1;
+static int hf_x11_xinput_GrabDevice_num_classes = -1;
+static int hf_x11_xinput_GrabDevice_this_device_mode = -1;
+static int hf_x11_xinput_GrabDevice_other_device_mode = -1;
+static int hf_x11_xinput_GrabDevice_owner_events = -1;
+static int hf_x11_xinput_GrabDevice_device_id = -1;
+static int hf_x11_xinput_GrabDevice_classes = -1;
+static int hf_x11_xinput_GrabDevice_classes_item = -1;
+static int hf_x11_xinput_GrabDevice_reply_status = -1;
+static int hf_x11_xinput_UngrabDevice_time = -1;
+static int hf_x11_xinput_UngrabDevice_device_id = -1;
+static int hf_x11_xinput_GrabDeviceKey_grab_window = -1;
+static int hf_x11_xinput_GrabDeviceKey_num_classes = -1;
+static int hf_x11_xinput_GrabDeviceKey_modifiers = -1;
+static int hf_x11_xinput_GrabDeviceKey_modifier_device = -1;
+static int hf_x11_xinput_GrabDeviceKey_grabbed_device = -1;
+static int hf_x11_xinput_GrabDeviceKey_key = -1;
+static int hf_x11_xinput_GrabDeviceKey_this_device_mode = -1;
+static int hf_x11_xinput_GrabDeviceKey_other_device_mode = -1;
+static int hf_x11_xinput_GrabDeviceKey_owner_events = -1;
+static int hf_x11_xinput_GrabDeviceKey_classes = -1;
+static int hf_x11_xinput_GrabDeviceKey_classes_item = -1;
+static int hf_x11_xinput_UngrabDeviceKey_grabWindow = -1;
+static int hf_x11_xinput_UngrabDeviceKey_modifiers = -1;
+static int hf_x11_xinput_UngrabDeviceKey_modifier_device = -1;
+static int hf_x11_xinput_UngrabDeviceKey_key = -1;
+static int hf_x11_xinput_UngrabDeviceKey_grabbed_device = -1;
+static int hf_x11_xinput_GrabDeviceButton_grab_window = -1;
+static int hf_x11_xinput_GrabDeviceButton_grabbed_device = -1;
+static int hf_x11_xinput_GrabDeviceButton_modifier_device = -1;
+static int hf_x11_xinput_GrabDeviceButton_num_classes = -1;
+static int hf_x11_xinput_GrabDeviceButton_modifiers = -1;
+static int hf_x11_xinput_GrabDeviceButton_this_device_mode = -1;
+static int hf_x11_xinput_GrabDeviceButton_other_device_mode = -1;
+static int hf_x11_xinput_GrabDeviceButton_button = -1;
+static int hf_x11_xinput_GrabDeviceButton_owner_events = -1;
+static int hf_x11_xinput_GrabDeviceButton_classes = -1;
+static int hf_x11_xinput_GrabDeviceButton_classes_item = -1;
+static int hf_x11_xinput_UngrabDeviceButton_grab_window = -1;
+static int hf_x11_xinput_UngrabDeviceButton_modifiers = -1;
+static int hf_x11_xinput_UngrabDeviceButton_modifier_device = -1;
+static int hf_x11_xinput_UngrabDeviceButton_button = -1;
+static int hf_x11_xinput_UngrabDeviceButton_grabbed_device = -1;
+static int hf_x11_xinput_AllowDeviceEvents_time = -1;
+static int hf_x11_xinput_AllowDeviceEvents_mode = -1;
+static int hf_x11_xinput_AllowDeviceEvents_device_id = -1;
+static int hf_x11_xinput_GetDeviceFocus_device_id = -1;
+static int hf_x11_xinput_GetDeviceFocus_reply_focus = -1;
+static int hf_x11_xinput_GetDeviceFocus_reply_time = -1;
+static int hf_x11_xinput_GetDeviceFocus_reply_revert_to = -1;
+static int hf_x11_xinput_SetDeviceFocus_focus = -1;
+static int hf_x11_xinput_SetDeviceFocus_time = -1;
+static int hf_x11_xinput_SetDeviceFocus_revert_to = -1;
+static int hf_x11_xinput_SetDeviceFocus_device_id = -1;
+static int hf_x11_xinput_GetFeedbackControl_device_id = -1;
+static int hf_x11_xinput_GetFeedbackControl_reply_num_feedback = -1;
+static int hf_x11_xinput_GetDeviceKeyMapping_device_id = -1;
+static int hf_x11_xinput_GetDeviceKeyMapping_first_keycode = -1;
+static int hf_x11_xinput_GetDeviceKeyMapping_count = -1;
+static int hf_x11_xinput_GetDeviceKeyMapping_reply_keysyms_per_keycode = -1;
+static int hf_x11_xinput_GetDeviceKeyMapping_reply_keysyms = -1;
+static int hf_x11_xinput_GetDeviceKeyMapping_reply_keysyms_item = -1;
+static int hf_x11_xinput_ChangeDeviceKeyMapping_device_id = -1;
+static int hf_x11_xinput_ChangeDeviceKeyMapping_first_keycode = -1;
+static int hf_x11_xinput_ChangeDeviceKeyMapping_keysyms_per_keycode = -1;
+static int hf_x11_xinput_ChangeDeviceKeyMapping_keycode_count = -1;
+static int hf_x11_xinput_ChangeDeviceKeyMapping_keysyms = -1;
+static int hf_x11_xinput_ChangeDeviceKeyMapping_keysyms_item = -1;
+static int hf_x11_xinput_GetDeviceModifierMapping_device_id = -1;
+static int hf_x11_xinput_GetDeviceModifierMapping_reply_keycodes_per_modifier = -1;
+static int hf_x11_xinput_GetDeviceModifierMapping_reply_keymaps = -1;
+static int hf_x11_xinput_SetDeviceModifierMapping_device_id = -1;
+static int hf_x11_xinput_SetDeviceModifierMapping_keycodes_per_modifier = -1;
+static int hf_x11_xinput_SetDeviceModifierMapping_keymaps = -1;
+static int hf_x11_xinput_SetDeviceModifierMapping_reply_status = -1;
+static int hf_x11_xinput_GetDeviceButtonMapping_device_id = -1;
+static int hf_x11_xinput_GetDeviceButtonMapping_reply_map_size = -1;
+static int hf_x11_xinput_GetDeviceButtonMapping_reply_map = -1;
+static int hf_x11_xinput_SetDeviceButtonMapping_device_id = -1;
+static int hf_x11_xinput_SetDeviceButtonMapping_map_size = -1;
+static int hf_x11_xinput_SetDeviceButtonMapping_map = -1;
+static int hf_x11_xinput_SetDeviceButtonMapping_reply_status = -1;
+static int hf_x11_xinput_QueryDeviceState_device_id = -1;
+static int hf_x11_xinput_QueryDeviceState_reply_num_classes = -1;
+static int hf_x11_xinput_SendExtensionEvent_destination = -1;
+static int hf_x11_xinput_SendExtensionEvent_device_id = -1;
+static int hf_x11_xinput_SendExtensionEvent_propagate = -1;
+static int hf_x11_xinput_SendExtensionEvent_num_classes = -1;
+static int hf_x11_xinput_SendExtensionEvent_num_events = -1;
+static int hf_x11_xinput_SendExtensionEvent_events = -1;
+static int hf_x11_xinput_SendExtensionEvent_classes = -1;
+static int hf_x11_xinput_SendExtensionEvent_classes_item = -1;
+static int hf_x11_xinput_DeviceBell_device_id = -1;
+static int hf_x11_xinput_DeviceBell_feedback_id = -1;
+static int hf_x11_xinput_DeviceBell_feedback_class = -1;
+static int hf_x11_xinput_DeviceBell_percent = -1;
+static int hf_x11_xinput_SetDeviceValuators_device_id = -1;
+static int hf_x11_xinput_SetDeviceValuators_first_valuator = -1;
+static int hf_x11_xinput_SetDeviceValuators_num_valuators = -1;
+static int hf_x11_xinput_SetDeviceValuators_valuators = -1;
+static int hf_x11_xinput_SetDeviceValuators_valuators_item = -1;
+static int hf_x11_xinput_SetDeviceValuators_reply_status = -1;
+static int hf_x11_xinput_GetDeviceControl_control_id = -1;
+static int hf_x11_xinput_GetDeviceControl_device_id = -1;
+static int hf_x11_xinput_GetDeviceControl_reply_status = -1;
+static int hf_x11_xinput_DeviceValuator_device_id = -1;
+static int hf_x11_xinput_DeviceValuator_device_state = -1;
+static int hf_x11_xinput_DeviceValuator_num_valuators = -1;
+static int hf_x11_xinput_DeviceValuator_first_valuator = -1;
+static int hf_x11_xinput_DeviceValuator_valuators = -1;
+static int hf_x11_xinput_DeviceValuator_valuators_item = -1;
+static int hf_x11_xinput_DeviceKeyPress_detail = -1;
+static int hf_x11_xinput_DeviceKeyPress_time = -1;
+static int hf_x11_xinput_DeviceKeyPress_root = -1;
+static int hf_x11_xinput_DeviceKeyPress_event = -1;
+static int hf_x11_xinput_DeviceKeyPress_child = -1;
+static int hf_x11_xinput_DeviceKeyPress_root_x = -1;
+static int hf_x11_xinput_DeviceKeyPress_root_y = -1;
+static int hf_x11_xinput_DeviceKeyPress_event_x = -1;
+static int hf_x11_xinput_DeviceKeyPress_event_y = -1;
+static int hf_x11_xinput_DeviceKeyPress_state = -1;
+static int hf_x11_xinput_DeviceKeyPress_same_screen = -1;
+static int hf_x11_xinput_DeviceKeyPress_device_id = -1;
+static int hf_x11_xinput_FocusIn_detail = -1;
+static int hf_x11_xinput_FocusIn_time = -1;
+static int hf_x11_xinput_FocusIn_window = -1;
+static int hf_x11_xinput_FocusIn_mode = -1;
+static int hf_x11_xinput_FocusIn_device_id = -1;
+static int hf_x11_xinput_DeviceStateNotify_device_id = -1;
+static int hf_x11_xinput_DeviceStateNotify_time = -1;
+static int hf_x11_xinput_DeviceStateNotify_num_keys = -1;
+static int hf_x11_xinput_DeviceStateNotify_num_buttons = -1;
+static int hf_x11_xinput_DeviceStateNotify_num_valuators = -1;
+static int hf_x11_xinput_DeviceStateNotify_classes_reported = -1;
+static int hf_x11_xinput_DeviceStateNotify_buttons = -1;
+static int hf_x11_xinput_DeviceStateNotify_keys = -1;
+static int hf_x11_xinput_DeviceStateNotify_valuators = -1;
+static int hf_x11_xinput_DeviceStateNotify_valuators_item = -1;
+static int hf_x11_xinput_DeviceMappingNotify_device_id = -1;
+static int hf_x11_xinput_DeviceMappingNotify_request = -1;
+static int hf_x11_xinput_DeviceMappingNotify_first_keycode = -1;
+static int hf_x11_xinput_DeviceMappingNotify_count = -1;
+static int hf_x11_xinput_DeviceMappingNotify_time = -1;
+static int hf_x11_xinput_ChangeDeviceNotify_device_id = -1;
+static int hf_x11_xinput_ChangeDeviceNotify_time = -1;
+static int hf_x11_xinput_ChangeDeviceNotify_request = -1;
+static int hf_x11_xinput_DeviceKeyStateNotify_device_id = -1;
+static int hf_x11_xinput_DeviceKeyStateNotify_keys = -1;
+static int hf_x11_xinput_DeviceButtonStateNotify_device_id = -1;
+static int hf_x11_xinput_DeviceButtonStateNotify_buttons = -1;
+static int hf_x11_xinput_DevicePresenceNotify_time = -1;
+static int hf_x11_xinput_DevicePresenceNotify_devchange = -1;
+static int hf_x11_xinput_DevicePresenceNotify_device_id = -1;
+static int hf_x11_xinput_DevicePresenceNotify_control = -1;
+static int hf_x11_xinput_extension_minor = -1;
+
+static int hf_x11_struct_PRINTER = -1;
+static int hf_x11_struct_PRINTER_nameLen = -1;
+static int hf_x11_struct_PRINTER_name = -1;
+static int hf_x11_struct_PRINTER_descLen = -1;
+static int hf_x11_struct_PRINTER_description = -1;
+static int hf_x11_xprint_PrintQueryVersion_reply_major_version = -1;
+static int hf_x11_xprint_PrintQueryVersion_reply_minor_version = -1;
+static int hf_x11_xprint_PrintGetPrinterList_printerNameLen = -1;
+static int hf_x11_xprint_PrintGetPrinterList_localeLen = -1;
+static int hf_x11_xprint_PrintGetPrinterList_printer_name = -1;
+static int hf_x11_xprint_PrintGetPrinterList_locale = -1;
+static int hf_x11_xprint_PrintGetPrinterList_reply_listCount = -1;
+static int hf_x11_xprint_PrintGetPrinterList_reply_printers = -1;
+static int hf_x11_xprint_CreateContext_context_id = -1;
+static int hf_x11_xprint_CreateContext_printerNameLen = -1;
+static int hf_x11_xprint_CreateContext_localeLen = -1;
+static int hf_x11_xprint_CreateContext_printerName = -1;
+static int hf_x11_xprint_CreateContext_locale = -1;
+static int hf_x11_xprint_PrintSetContext_context = -1;
+static int hf_x11_xprint_PrintGetContext_reply_context = -1;
+static int hf_x11_xprint_PrintDestroyContext_context = -1;
+static int hf_x11_xprint_PrintGetScreenOfContext_reply_root = -1;
+static int hf_x11_xprint_PrintStartJob_output_mode = -1;
+static int hf_x11_xprint_PrintEndJob_cancel = -1;
+static int hf_x11_xprint_PrintStartDoc_driver_mode = -1;
+static int hf_x11_xprint_PrintEndDoc_cancel = -1;
+static int hf_x11_xprint_PrintPutDocumentData_drawable = -1;
+static int hf_x11_xprint_PrintPutDocumentData_len_data = -1;
+static int hf_x11_xprint_PrintPutDocumentData_len_fmt = -1;
+static int hf_x11_xprint_PrintPutDocumentData_len_options = -1;
+static int hf_x11_xprint_PrintPutDocumentData_data = -1;
+static int hf_x11_xprint_PrintPutDocumentData_doc_format = -1;
+static int hf_x11_xprint_PrintPutDocumentData_options = -1;
+static int hf_x11_xprint_PrintGetDocumentData_context = -1;
+static int hf_x11_xprint_PrintGetDocumentData_max_bytes = -1;
+static int hf_x11_xprint_PrintGetDocumentData_reply_status_code = -1;
+static int hf_x11_xprint_PrintGetDocumentData_reply_finished_flag = -1;
+static int hf_x11_xprint_PrintGetDocumentData_reply_dataLen = -1;
+static int hf_x11_xprint_PrintGetDocumentData_reply_data = -1;
+static int hf_x11_xprint_PrintStartPage_window = -1;
+static int hf_x11_xprint_PrintEndPage_cancel = -1;
+static int hf_x11_xprint_PrintSelectInput_context = -1;
+static int hf_x11_xprint_PrintInputSelected_context = -1;
+static int hf_x11_xprint_PrintGetAttributes_context = -1;
+static int hf_x11_xprint_PrintGetAttributes_pool = -1;
+static int hf_x11_xprint_PrintGetAttributes_reply_stringLen = -1;
+static int hf_x11_xprint_PrintGetAttributes_reply_attributes = -1;
+static int hf_x11_xprint_PrintGetOneAttributes_context = -1;
+static int hf_x11_xprint_PrintGetOneAttributes_nameLen = -1;
+static int hf_x11_xprint_PrintGetOneAttributes_pool = -1;
+static int hf_x11_xprint_PrintGetOneAttributes_name = -1;
+static int hf_x11_xprint_PrintGetOneAttributes_reply_valueLen = -1;
+static int hf_x11_xprint_PrintGetOneAttributes_reply_value = -1;
+static int hf_x11_xprint_PrintSetAttributes_context = -1;
+static int hf_x11_xprint_PrintSetAttributes_stringLen = -1;
+static int hf_x11_xprint_PrintSetAttributes_pool = -1;
+static int hf_x11_xprint_PrintSetAttributes_rule = -1;
+static int hf_x11_xprint_PrintSetAttributes_attributes = -1;
+static int hf_x11_xprint_PrintGetPageDimensions_context = -1;
+static int hf_x11_xprint_PrintGetPageDimensions_reply_width = -1;
+static int hf_x11_xprint_PrintGetPageDimensions_reply_height = -1;
+static int hf_x11_xprint_PrintGetPageDimensions_reply_offset_x = -1;
+static int hf_x11_xprint_PrintGetPageDimensions_reply_offset_y = -1;
+static int hf_x11_xprint_PrintGetPageDimensions_reply_reproducible_width = -1;
+static int hf_x11_xprint_PrintGetPageDimensions_reply_reproducible_height = -1;
+static int hf_x11_xprint_PrintQueryScreens_reply_listCount = -1;
+static int hf_x11_xprint_PrintQueryScreens_reply_roots = -1;
+static int hf_x11_xprint_PrintQueryScreens_reply_roots_item = -1;
+static int hf_x11_xprint_PrintSetImageResolution_context = -1;
+static int hf_x11_xprint_PrintSetImageResolution_image_resolution = -1;
+static int hf_x11_xprint_PrintSetImageResolution_reply_status = -1;
+static int hf_x11_xprint_PrintSetImageResolution_reply_previous_resolutions = -1;
+static int hf_x11_xprint_PrintGetImageResolution_context = -1;
+static int hf_x11_xprint_PrintGetImageResolution_reply_image_resolution = -1;
+static int hf_x11_xprint_Notify_detail = -1;
+static int hf_x11_xprint_Notify_context = -1;
+static int hf_x11_xprint_Notify_cancel = -1;
+static int hf_x11_xprint_AttributNotify_detail = -1;
+static int hf_x11_xprint_AttributNotify_context = -1;
+static int hf_x11_xprint_extension_minor = -1;
+
+static int hf_x11_xselinux_QueryVersion_client_major = -1;
+static int hf_x11_xselinux_QueryVersion_client_minor = -1;
+static int hf_x11_xselinux_QueryVersion_reply_server_major = -1;
+static int hf_x11_xselinux_QueryVersion_reply_server_minor = -1;
+static int hf_x11_xselinux_SetDeviceCreateContext_context_len = -1;
+static int hf_x11_xselinux_SetDeviceCreateContext_context = -1;
+static int hf_x11_xselinux_GetDeviceCreateContext_reply_context_len = -1;
+static int hf_x11_xselinux_GetDeviceCreateContext_reply_context = -1;
+static int hf_x11_xselinux_SetDeviceContext_device = -1;
+static int hf_x11_xselinux_SetDeviceContext_context_len = -1;
+static int hf_x11_xselinux_SetDeviceContext_context = -1;
+static int hf_x11_xselinux_GetDeviceContext_device = -1;
+static int hf_x11_xselinux_GetDeviceContext_reply_context_len = -1;
+static int hf_x11_xselinux_GetDeviceContext_reply_context = -1;
+static int hf_x11_xselinux_SetWindowCreateContext_context_len = -1;
+static int hf_x11_xselinux_SetWindowCreateContext_context = -1;
+static int hf_x11_xselinux_GetWindowCreateContext_reply_context_len = -1;
+static int hf_x11_xselinux_GetWindowCreateContext_reply_context = -1;
+static int hf_x11_xselinux_GetWindowContext_window = -1;
+static int hf_x11_xselinux_GetWindowContext_reply_context_len = -1;
+static int hf_x11_xselinux_GetWindowContext_reply_context = -1;
+static int hf_x11_struct_ListItem = -1;
+static int hf_x11_struct_ListItem_name = -1;
+static int hf_x11_struct_ListItem_object_context_len = -1;
+static int hf_x11_struct_ListItem_data_context_len = -1;
+static int hf_x11_struct_ListItem_object_context = -1;
+static int hf_x11_struct_ListItem_data_context = -1;
+static int hf_x11_xselinux_SetPropertyCreateContext_context_len = -1;
+static int hf_x11_xselinux_SetPropertyCreateContext_context = -1;
+static int hf_x11_xselinux_GetPropertyCreateContext_reply_context_len = -1;
+static int hf_x11_xselinux_GetPropertyCreateContext_reply_context = -1;
+static int hf_x11_xselinux_SetPropertyUseContext_context_len = -1;
+static int hf_x11_xselinux_SetPropertyUseContext_context = -1;
+static int hf_x11_xselinux_GetPropertyUseContext_reply_context_len = -1;
+static int hf_x11_xselinux_GetPropertyUseContext_reply_context = -1;
+static int hf_x11_xselinux_GetPropertyContext_window = -1;
+static int hf_x11_xselinux_GetPropertyContext_property = -1;
+static int hf_x11_xselinux_GetPropertyContext_reply_context_len = -1;
+static int hf_x11_xselinux_GetPropertyContext_reply_context = -1;
+static int hf_x11_xselinux_GetPropertyDataContext_window = -1;
+static int hf_x11_xselinux_GetPropertyDataContext_property = -1;
+static int hf_x11_xselinux_GetPropertyDataContext_reply_context_len = -1;
+static int hf_x11_xselinux_GetPropertyDataContext_reply_context = -1;
+static int hf_x11_xselinux_ListProperties_window = -1;
+static int hf_x11_xselinux_ListProperties_reply_properties_len = -1;
+static int hf_x11_xselinux_ListProperties_reply_properties = -1;
+static int hf_x11_xselinux_SetSelectionCreateContext_context_len = -1;
+static int hf_x11_xselinux_SetSelectionCreateContext_context = -1;
+static int hf_x11_xselinux_GetSelectionCreateContext_reply_context_len = -1;
+static int hf_x11_xselinux_GetSelectionCreateContext_reply_context = -1;
+static int hf_x11_xselinux_SetSelectionUseContext_context_len = -1;
+static int hf_x11_xselinux_SetSelectionUseContext_context = -1;
+static int hf_x11_xselinux_GetSelectionUseContext_reply_context_len = -1;
+static int hf_x11_xselinux_GetSelectionUseContext_reply_context = -1;
+static int hf_x11_xselinux_GetSelectionContext_selection = -1;
+static int hf_x11_xselinux_GetSelectionContext_reply_context_len = -1;
+static int hf_x11_xselinux_GetSelectionContext_reply_context = -1;
+static int hf_x11_xselinux_GetSelectionDataContext_selection = -1;
+static int hf_x11_xselinux_GetSelectionDataContext_reply_context_len = -1;
+static int hf_x11_xselinux_GetSelectionDataContext_reply_context = -1;
+static int hf_x11_xselinux_ListSelections_reply_selections_len = -1;
+static int hf_x11_xselinux_ListSelections_reply_selections = -1;
+static int hf_x11_xselinux_GetClientContext_resource = -1;
+static int hf_x11_xselinux_GetClientContext_reply_context_len = -1;
+static int hf_x11_xselinux_GetClientContext_reply_context = -1;
+static int hf_x11_xselinux_extension_minor = -1;
+
+static int hf_x11_xtest_GetVersion_major_version = -1;
+static int hf_x11_xtest_GetVersion_minor_version = -1;
+static int hf_x11_xtest_GetVersion_reply_major_version = -1;
+static int hf_x11_xtest_GetVersion_reply_minor_version = -1;
+static int hf_x11_xtest_CompareCursor_window = -1;
+static int hf_x11_xtest_CompareCursor_cursor = -1;
+static int hf_x11_xtest_CompareCursor_reply_same = -1;
+static int hf_x11_xtest_FakeInput_type = -1;
+static int hf_x11_xtest_FakeInput_detail = -1;
+static int hf_x11_xtest_FakeInput_time = -1;
+static int hf_x11_xtest_FakeInput_root = -1;
+static int hf_x11_xtest_FakeInput_rootX = -1;
+static int hf_x11_xtest_FakeInput_rootY = -1;
+static int hf_x11_xtest_FakeInput_deviceid = -1;
+static int hf_x11_xtest_GrabControl_impervious = -1;
+static int hf_x11_xtest_extension_minor = -1;
+
+static int hf_x11_struct_Rational = -1;
+static int hf_x11_struct_Rational_numerator = -1;
+static int hf_x11_struct_Rational_denominator = -1;
+static int hf_x11_struct_Format = -1;
+static int hf_x11_struct_Format_visual = -1;
+static int hf_x11_struct_Format_depth = -1;
+static int hf_x11_struct_AdaptorInfo = -1;
+static int hf_x11_struct_AdaptorInfo_base_id = -1;
+static int hf_x11_struct_AdaptorInfo_name_size = -1;
+static int hf_x11_struct_AdaptorInfo_num_ports = -1;
+static int hf_x11_struct_AdaptorInfo_num_formats = -1;
+static int hf_x11_struct_AdaptorInfo_type = -1;
+static int hf_x11_struct_AdaptorInfo_name = -1;
+static int hf_x11_struct_AdaptorInfo_formats = -1;
+static int hf_x11_struct_AdaptorInfo_formats_item = -1;
+static int hf_x11_struct_EncodingInfo = -1;
+static int hf_x11_struct_EncodingInfo_encoding = -1;
+static int hf_x11_struct_EncodingInfo_name_size = -1;
+static int hf_x11_struct_EncodingInfo_width = -1;
+static int hf_x11_struct_EncodingInfo_height = -1;
+static int hf_x11_struct_EncodingInfo_rate = -1;
+static int hf_x11_struct_EncodingInfo_name = -1;
+static int hf_x11_struct_AttributeInfo = -1;
+static int hf_x11_struct_AttributeInfo_flags = -1;
+static int hf_x11_struct_AttributeInfo_min = -1;
+static int hf_x11_struct_AttributeInfo_max = -1;
+static int hf_x11_struct_AttributeInfo_size = -1;
+static int hf_x11_struct_AttributeInfo_name = -1;
+static int hf_x11_struct_ImageFormatInfo = -1;
+static int hf_x11_struct_ImageFormatInfo_id = -1;
+static int hf_x11_struct_ImageFormatInfo_type = -1;
+static int hf_x11_struct_ImageFormatInfo_byte_order = -1;
+static int hf_x11_struct_ImageFormatInfo_guid = -1;
+static int hf_x11_struct_ImageFormatInfo_bpp = -1;
+static int hf_x11_struct_ImageFormatInfo_num_planes = -1;
+static int hf_x11_struct_ImageFormatInfo_depth = -1;
+static int hf_x11_struct_ImageFormatInfo_red_mask = -1;
+static int hf_x11_struct_ImageFormatInfo_green_mask = -1;
+static int hf_x11_struct_ImageFormatInfo_blue_mask = -1;
+static int hf_x11_struct_ImageFormatInfo_format = -1;
+static int hf_x11_struct_ImageFormatInfo_y_sample_bits = -1;
+static int hf_x11_struct_ImageFormatInfo_u_sample_bits = -1;
+static int hf_x11_struct_ImageFormatInfo_v_sample_bits = -1;
+static int hf_x11_struct_ImageFormatInfo_vhorz_y_period = -1;
+static int hf_x11_struct_ImageFormatInfo_vhorz_u_period = -1;
+static int hf_x11_struct_ImageFormatInfo_vhorz_v_period = -1;
+static int hf_x11_struct_ImageFormatInfo_vvert_y_period = -1;
+static int hf_x11_struct_ImageFormatInfo_vvert_u_period = -1;
+static int hf_x11_struct_ImageFormatInfo_vvert_v_period = -1;
+static int hf_x11_struct_ImageFormatInfo_vcomp_order = -1;
+static int hf_x11_struct_ImageFormatInfo_vscanline_order = -1;
+static int hf_x11_xv_VideoNotify_reason = -1;
+static int hf_x11_xv_VideoNotify_time = -1;
+static int hf_x11_xv_VideoNotify_drawable = -1;
+static int hf_x11_xv_VideoNotify_port = -1;
+static int hf_x11_xv_PortNotify_time = -1;
+static int hf_x11_xv_PortNotify_port = -1;
+static int hf_x11_xv_PortNotify_attribute = -1;
+static int hf_x11_xv_PortNotify_value = -1;
+static int hf_x11_xv_QueryExtension_reply_major = -1;
+static int hf_x11_xv_QueryExtension_reply_minor = -1;
+static int hf_x11_xv_QueryAdaptors_window = -1;
+static int hf_x11_xv_QueryAdaptors_reply_num_adaptors = -1;
+static int hf_x11_xv_QueryAdaptors_reply_info = -1;
+static int hf_x11_xv_QueryEncodings_port = -1;
+static int hf_x11_xv_QueryEncodings_reply_num_encodings = -1;
+static int hf_x11_xv_QueryEncodings_reply_info = -1;
+static int hf_x11_xv_GrabPort_port = -1;
+static int hf_x11_xv_GrabPort_time = -1;
+static int hf_x11_xv_GrabPort_reply_result = -1;
+static int hf_x11_xv_UngrabPort_port = -1;
+static int hf_x11_xv_UngrabPort_time = -1;
+static int hf_x11_xv_PutVideo_port = -1;
+static int hf_x11_xv_PutVideo_drawable = -1;
+static int hf_x11_xv_PutVideo_gc = -1;
+static int hf_x11_xv_PutVideo_vid_x = -1;
+static int hf_x11_xv_PutVideo_vid_y = -1;
+static int hf_x11_xv_PutVideo_vid_w = -1;
+static int hf_x11_xv_PutVideo_vid_h = -1;
+static int hf_x11_xv_PutVideo_drw_x = -1;
+static int hf_x11_xv_PutVideo_drw_y = -1;
+static int hf_x11_xv_PutVideo_drw_w = -1;
+static int hf_x11_xv_PutVideo_drw_h = -1;
+static int hf_x11_xv_PutStill_port = -1;
+static int hf_x11_xv_PutStill_drawable = -1;
+static int hf_x11_xv_PutStill_gc = -1;
+static int hf_x11_xv_PutStill_vid_x = -1;
+static int hf_x11_xv_PutStill_vid_y = -1;
+static int hf_x11_xv_PutStill_vid_w = -1;
+static int hf_x11_xv_PutStill_vid_h = -1;
+static int hf_x11_xv_PutStill_drw_x = -1;
+static int hf_x11_xv_PutStill_drw_y = -1;
+static int hf_x11_xv_PutStill_drw_w = -1;
+static int hf_x11_xv_PutStill_drw_h = -1;
+static int hf_x11_xv_GetVideo_port = -1;
+static int hf_x11_xv_GetVideo_drawable = -1;
+static int hf_x11_xv_GetVideo_gc = -1;
+static int hf_x11_xv_GetVideo_vid_x = -1;
+static int hf_x11_xv_GetVideo_vid_y = -1;
+static int hf_x11_xv_GetVideo_vid_w = -1;
+static int hf_x11_xv_GetVideo_vid_h = -1;
+static int hf_x11_xv_GetVideo_drw_x = -1;
+static int hf_x11_xv_GetVideo_drw_y = -1;
+static int hf_x11_xv_GetVideo_drw_w = -1;
+static int hf_x11_xv_GetVideo_drw_h = -1;
+static int hf_x11_xv_GetStill_port = -1;
+static int hf_x11_xv_GetStill_drawable = -1;
+static int hf_x11_xv_GetStill_gc = -1;
+static int hf_x11_xv_GetStill_vid_x = -1;
+static int hf_x11_xv_GetStill_vid_y = -1;
+static int hf_x11_xv_GetStill_vid_w = -1;
+static int hf_x11_xv_GetStill_vid_h = -1;
+static int hf_x11_xv_GetStill_drw_x = -1;
+static int hf_x11_xv_GetStill_drw_y = -1;
+static int hf_x11_xv_GetStill_drw_w = -1;
+static int hf_x11_xv_GetStill_drw_h = -1;
+static int hf_x11_xv_StopVideo_port = -1;
+static int hf_x11_xv_StopVideo_drawable = -1;
+static int hf_x11_xv_SelectVideoNotify_drawable = -1;
+static int hf_x11_xv_SelectVideoNotify_onoff = -1;
+static int hf_x11_xv_SelectPortNotify_port = -1;
+static int hf_x11_xv_SelectPortNotify_onoff = -1;
+static int hf_x11_xv_QueryBestSize_port = -1;
+static int hf_x11_xv_QueryBestSize_vid_w = -1;
+static int hf_x11_xv_QueryBestSize_vid_h = -1;
+static int hf_x11_xv_QueryBestSize_drw_w = -1;
+static int hf_x11_xv_QueryBestSize_drw_h = -1;
+static int hf_x11_xv_QueryBestSize_motion = -1;
+static int hf_x11_xv_QueryBestSize_reply_actual_width = -1;
+static int hf_x11_xv_QueryBestSize_reply_actual_height = -1;
+static int hf_x11_xv_SetPortAttribute_port = -1;
+static int hf_x11_xv_SetPortAttribute_attribute = -1;
+static int hf_x11_xv_SetPortAttribute_value = -1;
+static int hf_x11_xv_GetPortAttribute_port = -1;
+static int hf_x11_xv_GetPortAttribute_attribute = -1;
+static int hf_x11_xv_GetPortAttribute_reply_value = -1;
+static int hf_x11_xv_QueryPortAttributes_port = -1;
+static int hf_x11_xv_QueryPortAttributes_reply_num_attributes = -1;
+static int hf_x11_xv_QueryPortAttributes_reply_text_size = -1;
+static int hf_x11_xv_QueryPortAttributes_reply_attributes = -1;
+static int hf_x11_xv_ListImageFormats_port = -1;
+static int hf_x11_xv_ListImageFormats_reply_num_formats = -1;
+static int hf_x11_xv_ListImageFormats_reply_format = -1;
+static int hf_x11_xv_ListImageFormats_reply_format_item = -1;
+static int hf_x11_xv_QueryImageAttributes_port = -1;
+static int hf_x11_xv_QueryImageAttributes_id = -1;
+static int hf_x11_xv_QueryImageAttributes_width = -1;
+static int hf_x11_xv_QueryImageAttributes_height = -1;
+static int hf_x11_xv_QueryImageAttributes_reply_num_planes = -1;
+static int hf_x11_xv_QueryImageAttributes_reply_data_size = -1;
+static int hf_x11_xv_QueryImageAttributes_reply_width = -1;
+static int hf_x11_xv_QueryImageAttributes_reply_height = -1;
+static int hf_x11_xv_QueryImageAttributes_reply_pitches = -1;
+static int hf_x11_xv_QueryImageAttributes_reply_pitches_item = -1;
+static int hf_x11_xv_QueryImageAttributes_reply_offsets = -1;
+static int hf_x11_xv_QueryImageAttributes_reply_offsets_item = -1;
+static int hf_x11_xv_PutImage_port = -1;
+static int hf_x11_xv_PutImage_drawable = -1;
+static int hf_x11_xv_PutImage_gc = -1;
+static int hf_x11_xv_PutImage_id = -1;
+static int hf_x11_xv_PutImage_src_x = -1;
+static int hf_x11_xv_PutImage_src_y = -1;
+static int hf_x11_xv_PutImage_src_w = -1;
+static int hf_x11_xv_PutImage_src_h = -1;
+static int hf_x11_xv_PutImage_drw_x = -1;
+static int hf_x11_xv_PutImage_drw_y = -1;
+static int hf_x11_xv_PutImage_drw_w = -1;
+static int hf_x11_xv_PutImage_drw_h = -1;
+static int hf_x11_xv_PutImage_width = -1;
+static int hf_x11_xv_PutImage_height = -1;
+static int hf_x11_xv_PutImage_data = -1;
+static int hf_x11_xv_ShmPutImage_port = -1;
+static int hf_x11_xv_ShmPutImage_drawable = -1;
+static int hf_x11_xv_ShmPutImage_gc = -1;
+static int hf_x11_xv_ShmPutImage_shmseg = -1;
+static int hf_x11_xv_ShmPutImage_id = -1;
+static int hf_x11_xv_ShmPutImage_offset = -1;
+static int hf_x11_xv_ShmPutImage_src_x = -1;
+static int hf_x11_xv_ShmPutImage_src_y = -1;
+static int hf_x11_xv_ShmPutImage_src_w = -1;
+static int hf_x11_xv_ShmPutImage_src_h = -1;
+static int hf_x11_xv_ShmPutImage_drw_x = -1;
+static int hf_x11_xv_ShmPutImage_drw_y = -1;
+static int hf_x11_xv_ShmPutImage_drw_w = -1;
+static int hf_x11_xv_ShmPutImage_drw_h = -1;
+static int hf_x11_xv_ShmPutImage_width = -1;
+static int hf_x11_xv_ShmPutImage_height = -1;
+static int hf_x11_xv_ShmPutImage_send_event = -1;
+static int hf_x11_xv_extension_minor = -1;
+
+static int hf_x11_struct_SurfaceInfo = -1;
+static int hf_x11_struct_SurfaceInfo_id = -1;
+static int hf_x11_struct_SurfaceInfo_chroma_format = -1;
+static int hf_x11_struct_SurfaceInfo_pad0 = -1;
+static int hf_x11_struct_SurfaceInfo_max_width = -1;
+static int hf_x11_struct_SurfaceInfo_max_height = -1;
+static int hf_x11_struct_SurfaceInfo_subpicture_max_width = -1;
+static int hf_x11_struct_SurfaceInfo_subpicture_max_height = -1;
+static int hf_x11_struct_SurfaceInfo_mc_type = -1;
+static int hf_x11_struct_SurfaceInfo_flags = -1;
+static int hf_x11_xvmc_QueryVersion_reply_major = -1;
+static int hf_x11_xvmc_QueryVersion_reply_minor = -1;
+static int hf_x11_xvmc_ListSurfaceTypes_port_id = -1;
+static int hf_x11_xvmc_ListSurfaceTypes_reply_num = -1;
+static int hf_x11_xvmc_ListSurfaceTypes_reply_surfaces = -1;
+static int hf_x11_xvmc_ListSurfaceTypes_reply_surfaces_item = -1;
+static int hf_x11_xvmc_CreateContext_context_id = -1;
+static int hf_x11_xvmc_CreateContext_port_id = -1;
+static int hf_x11_xvmc_CreateContext_surface_id = -1;
+static int hf_x11_xvmc_CreateContext_width = -1;
+static int hf_x11_xvmc_CreateContext_height = -1;
+static int hf_x11_xvmc_CreateContext_flags = -1;
+static int hf_x11_xvmc_CreateContext_reply_width_actual = -1;
+static int hf_x11_xvmc_CreateContext_reply_height_actual = -1;
+static int hf_x11_xvmc_CreateContext_reply_flags_return = -1;
+static int hf_x11_xvmc_CreateContext_reply_priv_data = -1;
+static int hf_x11_xvmc_CreateContext_reply_priv_data_item = -1;
+static int hf_x11_xvmc_DestroyContext_context_id = -1;
+static int hf_x11_xvmc_CreateSurface_surface_id = -1;
+static int hf_x11_xvmc_CreateSurface_context_id = -1;
+static int hf_x11_xvmc_CreateSurface_reply_priv_data = -1;
+static int hf_x11_xvmc_CreateSurface_reply_priv_data_item = -1;
+static int hf_x11_xvmc_DestroySurface_surface_id = -1;
+static int hf_x11_xvmc_CreateSubpicture_subpicture_id = -1;
+static int hf_x11_xvmc_CreateSubpicture_context = -1;
+static int hf_x11_xvmc_CreateSubpicture_xvimage_id = -1;
+static int hf_x11_xvmc_CreateSubpicture_width = -1;
+static int hf_x11_xvmc_CreateSubpicture_height = -1;
+static int hf_x11_xvmc_CreateSubpicture_reply_width_actual = -1;
+static int hf_x11_xvmc_CreateSubpicture_reply_height_actual = -1;
+static int hf_x11_xvmc_CreateSubpicture_reply_num_palette_entries = -1;
+static int hf_x11_xvmc_CreateSubpicture_reply_entry_bytes = -1;
+static int hf_x11_xvmc_CreateSubpicture_reply_component_order = -1;
+static int hf_x11_xvmc_CreateSubpicture_reply_priv_data = -1;
+static int hf_x11_xvmc_CreateSubpicture_reply_priv_data_item = -1;
+static int hf_x11_xvmc_DestroySubpicture_subpicture_id = -1;
+static int hf_x11_xvmc_ListSubpictureTypes_port_id = -1;
+static int hf_x11_xvmc_ListSubpictureTypes_surface_id = -1;
+static int hf_x11_xvmc_ListSubpictureTypes_reply_num = -1;
+static int hf_x11_xvmc_ListSubpictureTypes_reply_types = -1;
+static int hf_x11_xvmc_ListSubpictureTypes_reply_types_item = -1;
+static int hf_x11_xvmc_extension_minor = -1;
+
diff --git a/epan/dissectors/x11-extension-errors.h b/epan/dissectors/x11-extension-errors.h
new file mode 100644 (file)
index 0000000..5e64537
--- /dev/null
@@ -0,0 +1,174 @@
+/* Do not modify this file. */
+/* It was automatically generated by process-x11-xcb.pl. */
+/* $Id$ */
+
+/*
+ * Copyright 2008, 2009 Open Text Corporation <pharris[AT]opentext.com>
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald[AT]wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+const char *bigreq_errors[] = {
+  NULL
+};
+
+const char *composite_errors[] = {
+  NULL
+};
+
+const char *damage_errors[] = {
+  "damage-BadDamage",
+  NULL
+};
+
+const char *dpms_errors[] = {
+  NULL
+};
+
+const char *ge_errors[] = {
+  NULL
+};
+
+const char *glx_errors[] = {
+  "glx-BadContext",
+  "glx-BadContextState",
+  "glx-BadDrawable",
+  "glx-BadPixmap",
+  "glx-BadContextTag",
+  "glx-BadCurrentWindow",
+  "glx-BadRenderRequest",
+  "glx-BadLargeRequest",
+  "glx-UnsupportedPrivateRequest",
+  "glx-BadFBConfig",
+  "glx-BadPbuffer",
+  "glx-BadCurrentDrawable",
+  "glx-BadWindow",
+  NULL
+};
+
+const char *randr_errors[] = {
+  "randr-BadOutput",
+  "randr-BadCrtc",
+  "randr-BadMode",
+  NULL
+};
+
+const char *record_errors[] = {
+  "record-BadContext",
+  NULL
+};
+
+const char *render_errors[] = {
+  "render-PictFormat",
+  "render-Picture",
+  "render-PictOp",
+  "render-GlyphSet",
+  "render-Glyph",
+  NULL
+};
+
+const char *res_errors[] = {
+  NULL
+};
+
+const char *screensaver_errors[] = {
+  NULL
+};
+
+const char *shape_errors[] = {
+  NULL
+};
+
+const char *shm_errors[] = {
+  "shm-BadSeg",
+  NULL
+};
+
+const char *sync_errors[] = {
+  "sync-Counter",
+  "sync-Alarm",
+  NULL
+};
+
+const char *xc_misc_errors[] = {
+  NULL
+};
+
+const char *xevie_errors[] = {
+  NULL
+};
+
+const char *xf86dri_errors[] = {
+  NULL
+};
+
+const char *xf86vidmode_errors[] = {
+  "xf86vidmode-BadClock",
+  "xf86vidmode-BadHTimings",
+  "xf86vidmode-BadVTimings",
+  "xf86vidmode-ModeUnsuitable",
+  "xf86vidmode-ExtensionDisabled",
+  "xf86vidmode-ClientNotLocal",
+  "xf86vidmode-ZoomLocked",
+  NULL
+};
+
+const char *xfixes_errors[] = {
+  "xfixes-BadRegion",
+  NULL
+};
+
+const char *xinerama_errors[] = {
+  NULL
+};
+
+const char *xinput_errors[] = {
+  "xinput-Device",
+  "xinput-Event",
+  "xinput-Mode",
+  "xinput-DeviceBusy",
+  "xinput-Class",
+  NULL
+};
+
+const char *xprint_errors[] = {
+  "xprint-BadContext",
+  "xprint-BadSequence",
+  NULL
+};
+
+const char *xselinux_errors[] = {
+  NULL
+};
+
+const char *xtest_errors[] = {
+  NULL
+};
+
+const char *xv_errors[] = {
+  "xv-BadPort",
+  "xv-BadEncoding",
+  "xv-BadControl",
+  NULL
+};
+
+const char *xvmc_errors[] = {
+  NULL
+};
+
diff --git a/epan/dissectors/x11-extension-implementation.h b/epan/dissectors/x11-extension-implementation.h
new file mode 100644 (file)
index 0000000..323c629
--- /dev/null
@@ -0,0 +1,21965 @@
+/* Do not modify this file. */
+/* It was automatically generated by process-x11-xcb.pl. */
+/* $Id$ */
+
+/*
+ * Copyright 2008, 2009 Open Text Corporation <pharris[AT]opentext.com>
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald[AT]wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "x11-glx-render-enum.h"
+
+static void mesa_CallList(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_CallList_list, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_CallLists(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int n;
+    n = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_CallLists_n, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CallLists_type, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_CallLists_lists, (length - 8) / 1, little_endian);
+}
+
+static void mesa_ListBase(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ListBase_base, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Begin(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Begin_mode, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Bitmap(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Bitmap_swapbytes, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_Bitmap_lsbfirst, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    UNUSED(2);
+    proto_tree_add_item(t, hf_x11_glx_render_Bitmap_rowlength, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Bitmap_skiprows, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Bitmap_skippixels, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Bitmap_alignment, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Bitmap_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Bitmap_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Bitmap_xorig, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Bitmap_yorig, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Bitmap_xmove, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Bitmap_ymove, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_Bitmap_bitmap, (length - 44) / 1, little_endian);
+}
+
+static void mesa_Color3bv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_Color3bv_v, 3, little_endian);
+}
+
+static void mesa_Color3dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Color3dv_v, hf_x11_glx_render_Color3dv_v_item, 3, little_endian);
+}
+
+static void mesa_Color3fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Color3fv_v, hf_x11_glx_render_Color3fv_v_item, 3, little_endian);
+}
+
+static void mesa_Color3iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Color3iv_v, hf_x11_glx_render_Color3iv_v_item, 3, little_endian);
+}
+
+static void mesa_Color3sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_Color3sv_v, hf_x11_glx_render_Color3sv_v_item, 3, little_endian);
+}
+
+static void mesa_Color3ubv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_Color3ubv_v, 3, little_endian);
+}
+
+static void mesa_Color3uiv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfCard32(tvb, offsetp, t, hf_x11_glx_render_Color3uiv_v, hf_x11_glx_render_Color3uiv_v_item, 3, little_endian);
+}
+
+static void mesa_Color3usv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfCard16(tvb, offsetp, t, hf_x11_glx_render_Color3usv_v, hf_x11_glx_render_Color3usv_v_item, 3, little_endian);
+}
+
+static void mesa_Color4bv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_Color4bv_v, 4, little_endian);
+}
+
+static void mesa_Color4dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Color4dv_v, hf_x11_glx_render_Color4dv_v_item, 4, little_endian);
+}
+
+static void mesa_Color4fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Color4fv_v, hf_x11_glx_render_Color4fv_v_item, 4, little_endian);
+}
+
+static void mesa_Color4iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Color4iv_v, hf_x11_glx_render_Color4iv_v_item, 4, little_endian);
+}
+
+static void mesa_Color4sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_Color4sv_v, hf_x11_glx_render_Color4sv_v_item, 4, little_endian);
+}
+
+static void mesa_Color4ubv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_Color4ubv_v, 4, little_endian);
+}
+
+static void mesa_Color4uiv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfCard32(tvb, offsetp, t, hf_x11_glx_render_Color4uiv_v, hf_x11_glx_render_Color4uiv_v_item, 4, little_endian);
+}
+
+static void mesa_Color4usv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfCard16(tvb, offsetp, t, hf_x11_glx_render_Color4usv_v, hf_x11_glx_render_Color4usv_v_item, 4, little_endian);
+}
+
+static void mesa_EdgeFlagv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_EdgeFlagv_flag, 1, little_endian);
+}
+
+static void mesa_End(tvbuff_t *tvb _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_)
+{
+}
+
+static void mesa_Indexdv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Indexdv_c, hf_x11_glx_render_Indexdv_c_item, 1, little_endian);
+}
+
+static void mesa_Indexfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Indexfv_c, hf_x11_glx_render_Indexfv_c_item, 1, little_endian);
+}
+
+static void mesa_Indexiv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Indexiv_c, hf_x11_glx_render_Indexiv_c_item, 1, little_endian);
+}
+
+static void mesa_Indexsv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_Indexsv_c, hf_x11_glx_render_Indexsv_c_item, 1, little_endian);
+}
+
+static void mesa_Normal3bv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_Normal3bv_v, 3, little_endian);
+}
+
+static void mesa_Normal3dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Normal3dv_v, hf_x11_glx_render_Normal3dv_v_item, 3, little_endian);
+}
+
+static void mesa_Normal3fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Normal3fv_v, hf_x11_glx_render_Normal3fv_v_item, 3, little_endian);
+}
+
+static void mesa_Normal3iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Normal3iv_v, hf_x11_glx_render_Normal3iv_v_item, 3, little_endian);
+}
+
+static void mesa_Normal3sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_Normal3sv_v, hf_x11_glx_render_Normal3sv_v_item, 3, little_endian);
+}
+
+static void mesa_RasterPos2dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_RasterPos2dv_v, hf_x11_glx_render_RasterPos2dv_v_item, 2, little_endian);
+}
+
+static void mesa_RasterPos2fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_RasterPos2fv_v, hf_x11_glx_render_RasterPos2fv_v_item, 2, little_endian);
+}
+
+static void mesa_RasterPos2iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_RasterPos2iv_v, hf_x11_glx_render_RasterPos2iv_v_item, 2, little_endian);
+}
+
+static void mesa_RasterPos2sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_RasterPos2sv_v, hf_x11_glx_render_RasterPos2sv_v_item, 2, little_endian);
+}
+
+static void mesa_RasterPos3dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_RasterPos3dv_v, hf_x11_glx_render_RasterPos3dv_v_item, 3, little_endian);
+}
+
+static void mesa_RasterPos3fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_RasterPos3fv_v, hf_x11_glx_render_RasterPos3fv_v_item, 3, little_endian);
+}
+
+static void mesa_RasterPos3iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_RasterPos3iv_v, hf_x11_glx_render_RasterPos3iv_v_item, 3, little_endian);
+}
+
+static void mesa_RasterPos3sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_RasterPos3sv_v, hf_x11_glx_render_RasterPos3sv_v_item, 3, little_endian);
+}
+
+static void mesa_RasterPos4dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_RasterPos4dv_v, hf_x11_glx_render_RasterPos4dv_v_item, 4, little_endian);
+}
+
+static void mesa_RasterPos4fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_RasterPos4fv_v, hf_x11_glx_render_RasterPos4fv_v_item, 4, little_endian);
+}
+
+static void mesa_RasterPos4iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_RasterPos4iv_v, hf_x11_glx_render_RasterPos4iv_v_item, 4, little_endian);
+}
+
+static void mesa_RasterPos4sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_RasterPos4sv_v, hf_x11_glx_render_RasterPos4sv_v_item, 4, little_endian);
+}
+
+static void mesa_Rectdv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Rectdv_v1, hf_x11_glx_render_Rectdv_v1_item, 2, little_endian);
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Rectdv_v2, hf_x11_glx_render_Rectdv_v2_item, 2, little_endian);
+}
+
+static void mesa_Rectfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Rectfv_v1, hf_x11_glx_render_Rectfv_v1_item, 2, little_endian);
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Rectfv_v2, hf_x11_glx_render_Rectfv_v2_item, 2, little_endian);
+}
+
+static void mesa_Rectiv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Rectiv_v1, hf_x11_glx_render_Rectiv_v1_item, 2, little_endian);
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Rectiv_v2, hf_x11_glx_render_Rectiv_v2_item, 2, little_endian);
+}
+
+static void mesa_Rectsv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_Rectsv_v1, hf_x11_glx_render_Rectsv_v1_item, 2, little_endian);
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_Rectsv_v2, hf_x11_glx_render_Rectsv_v2_item, 2, little_endian);
+}
+
+static void mesa_TexCoord1dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_TexCoord1dv_v, hf_x11_glx_render_TexCoord1dv_v_item, 1, little_endian);
+}
+
+static void mesa_TexCoord1fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_TexCoord1fv_v, hf_x11_glx_render_TexCoord1fv_v_item, 1, little_endian);
+}
+
+static void mesa_TexCoord1iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_TexCoord1iv_v, hf_x11_glx_render_TexCoord1iv_v_item, 1, little_endian);
+}
+
+static void mesa_TexCoord1sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_TexCoord1sv_v, hf_x11_glx_render_TexCoord1sv_v_item, 1, little_endian);
+}
+
+static void mesa_TexCoord2dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_TexCoord2dv_v, hf_x11_glx_render_TexCoord2dv_v_item, 2, little_endian);
+}
+
+static void mesa_TexCoord2fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_TexCoord2fv_v, hf_x11_glx_render_TexCoord2fv_v_item, 2, little_endian);
+}
+
+static void mesa_TexCoord2iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_TexCoord2iv_v, hf_x11_glx_render_TexCoord2iv_v_item, 2, little_endian);
+}
+
+static void mesa_TexCoord2sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_TexCoord2sv_v, hf_x11_glx_render_TexCoord2sv_v_item, 2, little_endian);
+}
+
+static void mesa_TexCoord3dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_TexCoord3dv_v, hf_x11_glx_render_TexCoord3dv_v_item, 3, little_endian);
+}
+
+static void mesa_TexCoord3fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_TexCoord3fv_v, hf_x11_glx_render_TexCoord3fv_v_item, 3, little_endian);
+}
+
+static void mesa_TexCoord3iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_TexCoord3iv_v, hf_x11_glx_render_TexCoord3iv_v_item, 3, little_endian);
+}
+
+static void mesa_TexCoord3sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_TexCoord3sv_v, hf_x11_glx_render_TexCoord3sv_v_item, 3, little_endian);
+}
+
+static void mesa_TexCoord4dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_TexCoord4dv_v, hf_x11_glx_render_TexCoord4dv_v_item, 4, little_endian);
+}
+
+static void mesa_TexCoord4fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_TexCoord4fv_v, hf_x11_glx_render_TexCoord4fv_v_item, 4, little_endian);
+}
+
+static void mesa_TexCoord4iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_TexCoord4iv_v, hf_x11_glx_render_TexCoord4iv_v_item, 4, little_endian);
+}
+
+static void mesa_TexCoord4sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_TexCoord4sv_v, hf_x11_glx_render_TexCoord4sv_v_item, 4, little_endian);
+}
+
+static void mesa_Vertex2dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Vertex2dv_v, hf_x11_glx_render_Vertex2dv_v_item, 2, little_endian);
+}
+
+static void mesa_Vertex2fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Vertex2fv_v, hf_x11_glx_render_Vertex2fv_v_item, 2, little_endian);
+}
+
+static void mesa_Vertex2iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Vertex2iv_v, hf_x11_glx_render_Vertex2iv_v_item, 2, little_endian);
+}
+
+static void mesa_Vertex2sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_Vertex2sv_v, hf_x11_glx_render_Vertex2sv_v_item, 2, little_endian);
+}
+
+static void mesa_Vertex3dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Vertex3dv_v, hf_x11_glx_render_Vertex3dv_v_item, 3, little_endian);
+}
+
+static void mesa_Vertex3fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Vertex3fv_v, hf_x11_glx_render_Vertex3fv_v_item, 3, little_endian);
+}
+
+static void mesa_Vertex3iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Vertex3iv_v, hf_x11_glx_render_Vertex3iv_v_item, 3, little_endian);
+}
+
+static void mesa_Vertex3sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_Vertex3sv_v, hf_x11_glx_render_Vertex3sv_v_item, 3, little_endian);
+}
+
+static void mesa_Vertex4dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Vertex4dv_v, hf_x11_glx_render_Vertex4dv_v_item, 4, little_endian);
+}
+
+static void mesa_Vertex4fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Vertex4fv_v, hf_x11_glx_render_Vertex4fv_v_item, 4, little_endian);
+}
+
+static void mesa_Vertex4iv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Vertex4iv_v, hf_x11_glx_render_Vertex4iv_v_item, 4, little_endian);
+}
+
+static void mesa_Vertex4sv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_Vertex4sv_v, hf_x11_glx_render_Vertex4sv_v_item, 4, little_endian);
+}
+
+static void mesa_ClipPlane(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ClipPlane_plane, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_ClipPlane_equation, hf_x11_glx_render_ClipPlane_equation_item, 4, little_endian);
+}
+
+static void mesa_ColorMaterial(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ColorMaterial_face, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorMaterial_mode, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_CullFace(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_CullFace_mode, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Fogf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Fogf_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Fogf_param, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Fogfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Fogfv_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Fogfv_params, hf_x11_glx_render_Fogfv_params_item, (length - 4) / 4, little_endian);
+}
+
+static void mesa_Fogi(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Fogi_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Fogi_param, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Fogiv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Fogiv_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Fogiv_params, hf_x11_glx_render_Fogiv_params_item, (length - 4) / 4, little_endian);
+}
+
+static void mesa_FrontFace(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_FrontFace_mode, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Hint(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Hint_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Hint_mode, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Lightf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Lightf_light, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Lightf_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Lightf_param, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Lightfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Lightfv_light, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Lightfv_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Lightfv_params, hf_x11_glx_render_Lightfv_params_item, (length - 8) / 4, little_endian);
+}
+
+static void mesa_Lighti(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Lighti_light, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Lighti_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Lighti_param, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Lightiv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Lightiv_light, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Lightiv_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Lightiv_params, hf_x11_glx_render_Lightiv_params_item, (length - 8) / 4, little_endian);
+}
+
+static void mesa_LightModelf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_LightModelf_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_LightModelf_param, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_LightModelfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_LightModelfv_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_LightModelfv_params, hf_x11_glx_render_LightModelfv_params_item, (length - 4) / 4, little_endian);
+}
+
+static void mesa_LightModeli(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_LightModeli_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_LightModeli_param, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_LightModeliv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_LightModeliv_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_LightModeliv_params, hf_x11_glx_render_LightModeliv_params_item, (length - 4) / 4, little_endian);
+}
+
+static void mesa_LineStipple(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_LineStipple_factor, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_LineStipple_pattern, tvb, *offsetp, 2, little_endian);
+    *offsetp += 2;
+}
+
+static void mesa_LineWidth(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_LineWidth_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Materialf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Materialf_face, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Materialf_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Materialf_param, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Materialfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Materialfv_face, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Materialfv_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Materialfv_params, hf_x11_glx_render_Materialfv_params_item, (length - 8) / 4, little_endian);
+}
+
+static void mesa_Materiali(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Materiali_face, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Materiali_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Materiali_param, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Materialiv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Materialiv_face, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Materialiv_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_Materialiv_params, hf_x11_glx_render_Materialiv_params_item, (length - 8) / 4, little_endian);
+}
+
+static void mesa_PointSize(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_PointSize_size, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_PolygonMode(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_PolygonMode_face, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_PolygonMode_mode, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_PolygonStipple(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_PolygonStipple_swapbytes, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_PolygonStipple_lsbfirst, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    UNUSED(2);
+    proto_tree_add_item(t, hf_x11_glx_render_PolygonStipple_rowlength, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_PolygonStipple_skiprows, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_PolygonStipple_skippixels, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_PolygonStipple_alignment, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_PolygonStipple_mask, (length - 20) / 1, little_endian);
+}
+
+static void mesa_Scissor(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Scissor_x, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Scissor_y, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Scissor_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Scissor_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_ShadeModel(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ShadeModel_mode, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_TexParameterf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexParameterf_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexParameterf_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexParameterf_param, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_TexParameterfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexParameterfv_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexParameterfv_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_TexParameterfv_params, hf_x11_glx_render_TexParameterfv_params_item, (length - 8) / 4, little_endian);
+}
+
+static void mesa_TexParameteri(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexParameteri_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexParameteri_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexParameteri_param, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_TexParameteriv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexParameteriv_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexParameteriv_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_TexParameteriv_params, hf_x11_glx_render_TexParameteriv_params_item, (length - 8) / 4, little_endian);
+}
+
+static void mesa_TexImage1D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_swapbytes, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_lsbfirst, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    UNUSED(2);
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_rowlength, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_skiprows, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_skippixels, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_alignment, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_level, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_internalformat, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_border, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_format, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage1D_type, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_TexImage1D_pixels, (length - 48) / 1, little_endian);
+}
+
+static void mesa_TexImage2D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_swapbytes, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_lsbfirst, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    UNUSED(2);
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_rowlength, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_skiprows, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_skippixels, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_alignment, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_level, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_internalformat, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_border, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_format, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage2D_type, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_TexImage2D_pixels, (length - 52) / 1, little_endian);
+}
+
+static void mesa_TexEnvf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexEnvf_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexEnvf_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexEnvf_param, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_TexEnvfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexEnvfv_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexEnvfv_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_TexEnvfv_params, hf_x11_glx_render_TexEnvfv_params_item, (length - 8) / 4, little_endian);
+}
+
+static void mesa_TexEnvi(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexEnvi_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexEnvi_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexEnvi_param, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_TexEnviv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexEnviv_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexEnviv_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_TexEnviv_params, hf_x11_glx_render_TexEnviv_params_item, (length - 8) / 4, little_endian);
+}
+
+static void mesa_TexGend(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexGend_coord, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexGend_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexGend_param, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+}
+
+static void mesa_TexGendv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexGendv_coord, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexGendv_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_TexGendv_params, hf_x11_glx_render_TexGendv_params_item, (length - 8) / 8, little_endian);
+}
+
+static void mesa_TexGenf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexGenf_coord, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexGenf_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexGenf_param, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_TexGenfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexGenfv_coord, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexGenfv_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_TexGenfv_params, hf_x11_glx_render_TexGenfv_params_item, (length - 8) / 4, little_endian);
+}
+
+static void mesa_TexGeni(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexGeni_coord, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexGeni_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexGeni_param, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_TexGeniv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexGeniv_coord, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexGeniv_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_TexGeniv_params, hf_x11_glx_render_TexGeniv_params_item, (length - 8) / 4, little_endian);
+}
+
+static void mesa_InitNames(tvbuff_t *tvb _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_)
+{
+}
+
+static void mesa_LoadName(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_LoadName_name, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_PassThrough(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_PassThrough_token, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_PopName(tvbuff_t *tvb _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_)
+{
+}
+
+static void mesa_PushName(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_PushName_name, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_DrawBuffer(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_DrawBuffer_mode, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Clear(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Clear_mask, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_ClearAccum(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ClearAccum_red, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ClearAccum_green, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ClearAccum_blue, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ClearAccum_alpha, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_ClearIndex(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ClearIndex_c, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_ClearColor(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ClearColor_red, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ClearColor_green, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ClearColor_blue, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ClearColor_alpha, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_ClearStencil(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ClearStencil_s, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_ClearDepth(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ClearDepth_depth, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+}
+
+static void mesa_StencilMask(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_StencilMask_mask, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_ColorMask(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ColorMask_red, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorMask_green, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorMask_blue, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorMask_alpha, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+}
+
+static void mesa_DepthMask(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_DepthMask_flag, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+}
+
+static void mesa_IndexMask(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_IndexMask_mask, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Accum(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Accum_op, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Accum_value, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Disable(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Disable_cap, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Enable(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Enable_cap, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_PopAttrib(tvbuff_t *tvb _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_)
+{
+}
+
+static void mesa_PushAttrib(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_PushAttrib_mask, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Map1d(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Map1d_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Map1d_u1, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Map1d_u2, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Map1d_stride, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Map1d_order, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Map1d_points, hf_x11_glx_render_Map1d_points_item, (length - 28) / 8, little_endian);
+}
+
+static void mesa_Map1f(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Map1f_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Map1f_u1, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Map1f_u2, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Map1f_stride, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Map1f_order, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Map1f_points, hf_x11_glx_render_Map1f_points_item, (length - 20) / 4, little_endian);
+}
+
+static void mesa_Map2d(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Map2d_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Map2d_u1, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Map2d_u2, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Map2d_ustride, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Map2d_uorder, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Map2d_v1, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Map2d_v2, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Map2d_vstride, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Map2d_vorder, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_Map2d_points, hf_x11_glx_render_Map2d_points_item, (length - 52) / 8, little_endian);
+}
+
+static void mesa_Map2f(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Map2f_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Map2f_u1, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Map2f_u2, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Map2f_ustride, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Map2f_uorder, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Map2f_v1, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Map2f_v2, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Map2f_vstride, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Map2f_vorder, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_Map2f_points, hf_x11_glx_render_Map2f_points_item, (length - 36) / 4, little_endian);
+}
+
+static void mesa_MapGrid1d(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MapGrid1d_un, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_MapGrid1d_u1, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_MapGrid1d_u2, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+}
+
+static void mesa_MapGrid1f(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MapGrid1f_un, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_MapGrid1f_u1, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_MapGrid1f_u2, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_MapGrid2d(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MapGrid2d_un, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_MapGrid2d_u1, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_MapGrid2d_u2, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_MapGrid2d_vn, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_MapGrid2d_v1, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_MapGrid2d_v2, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+}
+
+static void mesa_MapGrid2f(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MapGrid2f_un, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_MapGrid2f_u1, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_MapGrid2f_u2, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_MapGrid2f_vn, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_MapGrid2f_v1, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_MapGrid2f_v2, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_EvalCoord1dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_EvalCoord1dv_u, hf_x11_glx_render_EvalCoord1dv_u_item, 1, little_endian);
+}
+
+static void mesa_EvalCoord1fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_EvalCoord1fv_u, hf_x11_glx_render_EvalCoord1fv_u_item, 1, little_endian);
+}
+
+static void mesa_EvalCoord2dv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_EvalCoord2dv_u, hf_x11_glx_render_EvalCoord2dv_u_item, 2, little_endian);
+}
+
+static void mesa_EvalCoord2fv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_EvalCoord2fv_u, hf_x11_glx_render_EvalCoord2fv_u_item, 2, little_endian);
+}
+
+static void mesa_EvalMesh1(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_EvalMesh1_mode, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_EvalMesh1_i1, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_EvalMesh1_i2, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_EvalPoint1(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_EvalPoint1_i, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_EvalMesh2(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_EvalMesh2_mode, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_EvalMesh2_i1, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_EvalMesh2_i2, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_EvalMesh2_j1, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_EvalMesh2_j2, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_EvalPoint2(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_EvalPoint2_i, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_EvalPoint2_j, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_AlphaFunc(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_AlphaFunc_func, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_AlphaFunc_ref, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_BlendFunc(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_BlendFunc_sfactor, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_BlendFunc_dfactor, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_LogicOp(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_LogicOp_opcode, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_StencilFunc(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_StencilFunc_func, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_StencilFunc_ref, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_StencilFunc_mask, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_StencilOp(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_StencilOp_fail, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_StencilOp_zfail, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_StencilOp_zpass, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_DepthFunc(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_DepthFunc_func, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_PixelZoom(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_PixelZoom_xfactor, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_PixelZoom_yfactor, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_PixelTransferf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_PixelTransferf_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_PixelTransferf_param, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_PixelTransferi(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_PixelTransferi_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_PixelTransferi_param, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_PixelMapfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int mapsize;
+    proto_tree_add_item(t, hf_x11_glx_render_PixelMapfv_map, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    mapsize = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_PixelMapfv_mapsize, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_PixelMapfv_values, hf_x11_glx_render_PixelMapfv_values_item, mapsize, little_endian);
+}
+
+static void mesa_PixelMapuiv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int mapsize;
+    proto_tree_add_item(t, hf_x11_glx_render_PixelMapuiv_map, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    mapsize = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_PixelMapuiv_mapsize, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfCard32(tvb, offsetp, t, hf_x11_glx_render_PixelMapuiv_values, hf_x11_glx_render_PixelMapuiv_values_item, mapsize, little_endian);
+}
+
+static void mesa_PixelMapusv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int mapsize;
+    proto_tree_add_item(t, hf_x11_glx_render_PixelMapusv_map, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    mapsize = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_PixelMapusv_mapsize, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfCard16(tvb, offsetp, t, hf_x11_glx_render_PixelMapusv_values, hf_x11_glx_render_PixelMapusv_values_item, mapsize, little_endian);
+}
+
+static void mesa_ReadBuffer(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ReadBuffer_mode, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_CopyPixels(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_CopyPixels_x, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyPixels_y, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyPixels_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyPixels_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyPixels_type, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_DrawPixels(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_swapbytes, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_lsbfirst, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    UNUSED(2);
+    proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_rowlength, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_skiprows, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_skippixels, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_alignment, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_format, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_DrawPixels_type, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_DrawPixels_pixels, (length - 36) / 1, little_endian);
+}
+
+static void mesa_DepthRange(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_DepthRange_zNear, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_DepthRange_zFar, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+}
+
+static void mesa_Frustum(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Frustum_left, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Frustum_right, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Frustum_bottom, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Frustum_top, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Frustum_zNear, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Frustum_zFar, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+}
+
+static void mesa_LoadIdentity(tvbuff_t *tvb _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_)
+{
+}
+
+static void mesa_LoadMatrixf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_LoadMatrixf_m, hf_x11_glx_render_LoadMatrixf_m_item, 16, little_endian);
+}
+
+static void mesa_LoadMatrixd(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_LoadMatrixd_m, hf_x11_glx_render_LoadMatrixd_m_item, 16, little_endian);
+}
+
+static void mesa_MatrixMode(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MatrixMode_mode, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_MultMatrixf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_MultMatrixf_m, hf_x11_glx_render_MultMatrixf_m_item, 16, little_endian);
+}
+
+static void mesa_MultMatrixd(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_MultMatrixd_m, hf_x11_glx_render_MultMatrixd_m_item, 16, little_endian);
+}
+
+static void mesa_Ortho(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Ortho_left, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Ortho_right, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Ortho_bottom, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Ortho_top, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Ortho_zNear, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Ortho_zFar, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+}
+
+static void mesa_PopMatrix(tvbuff_t *tvb _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_)
+{
+}
+
+static void mesa_PushMatrix(tvbuff_t *tvb _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_)
+{
+}
+
+static void mesa_Rotated(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Rotated_angle, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Rotated_x, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Rotated_y, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Rotated_z, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+}
+
+static void mesa_Rotatef(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Rotatef_angle, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Rotatef_x, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Rotatef_y, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Rotatef_z, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Scaled(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Scaled_x, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Scaled_y, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Scaled_z, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+}
+
+static void mesa_Scalef(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Scalef_x, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Scalef_y, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Scalef_z, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Translated(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Translated_x, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Translated_y, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+    proto_tree_add_item(t, hf_x11_glx_render_Translated_z, tvb, *offsetp, 8, little_endian);
+    *offsetp += 8;
+}
+
+static void mesa_Translatef(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Translatef_x, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Translatef_y, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Translatef_z, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_Viewport(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Viewport_x, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Viewport_y, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Viewport_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Viewport_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_DrawArrays(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_DrawArrays_mode, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_DrawArrays_first, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_DrawArrays_count, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_PolygonOffset(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_PolygonOffset_factor, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_PolygonOffset_units, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_CopyTexImage1D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage1D_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage1D_level, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage1D_internalformat, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage1D_x, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage1D_y, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage1D_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage1D_border, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_CopyTexImage2D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage2D_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage2D_level, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage2D_internalformat, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage2D_x, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage2D_y, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage2D_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage2D_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexImage2D_border, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_CopyTexSubImage1D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage1D_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage1D_level, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage1D_xoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage1D_x, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage1D_y, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage1D_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_CopyTexSubImage2D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage2D_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage2D_level, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage2D_xoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage2D_yoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage2D_x, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage2D_y, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage2D_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage2D_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_TexSubImage1D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_swapbytes, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_lsbfirst, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    UNUSED(2);
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_rowlength, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_skiprows, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_skippixels, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_alignment, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_level, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_xoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_format, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_type, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage1D_UNUSED, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_TexSubImage1D_pixels, (length - 48) / 1, little_endian);
+}
+
+static void mesa_TexSubImage2D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_swapbytes, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_lsbfirst, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    UNUSED(2);
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_rowlength, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_skiprows, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_skippixels, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_alignment, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_level, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_xoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_yoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_format, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_type, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage2D_UNUSED, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_TexSubImage2D_pixels, (length - 56) / 1, little_endian);
+}
+
+static void mesa_BindTexture(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_BindTexture_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_BindTexture_texture, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_PrioritizeTextures(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int n;
+    n = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_PrioritizeTextures_n, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfCard32(tvb, offsetp, t, hf_x11_glx_render_PrioritizeTextures_textures, hf_x11_glx_render_PrioritizeTextures_textures_item, n, little_endian);
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_PrioritizeTextures_priorities, hf_x11_glx_render_PrioritizeTextures_priorities_item, n, little_endian);
+}
+
+static void mesa_Indexubv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_Indexubv_c, 1, little_endian);
+}
+
+static void mesa_BlendColor(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_BlendColor_red, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_BlendColor_green, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_BlendColor_blue, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_BlendColor_alpha, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_BlendEquation(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_BlendEquation_mode, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_ColorTable(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ColorTable_swapbytes, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorTable_lsbfirst, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    UNUSED(2);
+    proto_tree_add_item(t, hf_x11_glx_render_ColorTable_rowlength, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorTable_skiprows, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorTable_skippixels, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorTable_alignment, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorTable_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorTable_internalformat, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorTable_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorTable_format, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorTable_type, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_ColorTable_table, (length - 40) / 1, little_endian);
+}
+
+static void mesa_ColorTableParameterfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ColorTableParameterfv_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorTableParameterfv_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_ColorTableParameterfv_params, hf_x11_glx_render_ColorTableParameterfv_params_item, (length - 8) / 4, little_endian);
+}
+
+static void mesa_ColorTableParameteriv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ColorTableParameteriv_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorTableParameteriv_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_ColorTableParameteriv_params, hf_x11_glx_render_ColorTableParameteriv_params_item, (length - 8) / 4, little_endian);
+}
+
+static void mesa_CopyColorTable(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_CopyColorTable_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyColorTable_internalformat, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyColorTable_x, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyColorTable_y, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyColorTable_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_ColorSubTable(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_swapbytes, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_lsbfirst, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    UNUSED(2);
+    proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_rowlength, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_skiprows, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_skippixels, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_alignment, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_start, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_count, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_format, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ColorSubTable_type, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_ColorSubTable_data, (length - 40) / 1, little_endian);
+}
+
+static void mesa_CopyColorSubTable(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_CopyColorSubTable_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyColorSubTable_start, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyColorSubTable_x, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyColorSubTable_y, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyColorSubTable_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_ConvolutionFilter1D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_swapbytes, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_lsbfirst, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    UNUSED(2);
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_rowlength, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_skiprows, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_skippixels, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_alignment, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_internalformat, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_format, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter1D_type, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_ConvolutionFilter1D_image, (length - 40) / 1, little_endian);
+}
+
+static void mesa_ConvolutionFilter2D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_swapbytes, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_lsbfirst, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    UNUSED(2);
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_rowlength, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_skiprows, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_skippixels, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_alignment, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_internalformat, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_format, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionFilter2D_type, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_ConvolutionFilter2D_image, (length - 44) / 1, little_endian);
+}
+
+static void mesa_ConvolutionParameterf(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameterf_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameterf_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameterf_params, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_ConvolutionParameterfv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameterfv_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameterfv_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_ConvolutionParameterfv_params, hf_x11_glx_render_ConvolutionParameterfv_params_item, (length - 8) / 4, little_endian);
+}
+
+static void mesa_ConvolutionParameteri(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameteri_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameteri_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameteri_params, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_ConvolutionParameteriv(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameteriv_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ConvolutionParameteriv_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_ConvolutionParameteriv_params, hf_x11_glx_render_ConvolutionParameteriv_params_item, (length - 8) / 4, little_endian);
+}
+
+static void mesa_CopyConvolutionFilter1D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter1D_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter1D_internalformat, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter1D_x, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter1D_y, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter1D_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_CopyConvolutionFilter2D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter2D_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter2D_internalformat, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter2D_x, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter2D_y, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter2D_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyConvolutionFilter2D_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_SeparableFilter2D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_SeparableFilter2D_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_SeparableFilter2D_internalformat, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_SeparableFilter2D_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_SeparableFilter2D_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_SeparableFilter2D_format, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_SeparableFilter2D_type, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_SeparableFilter2D_row, (length - 24) / 1, little_endian);
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_SeparableFilter2D_column, (length - 24) / 1, little_endian);
+}
+
+static void mesa_Histogram(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Histogram_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Histogram_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Histogram_internalformat, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Histogram_sink, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+}
+
+static void mesa_Minmax(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_Minmax_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Minmax_internalformat, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_Minmax_sink, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+}
+
+static void mesa_ResetHistogram(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ResetHistogram_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_ResetMinmax(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ResetMinmax_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_TexImage3D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_swapbytes, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_lsbfirst, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    UNUSED(2);
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_rowlength, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_skiprows, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_skippixels, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_alignment, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_level, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_internalformat, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_depth, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_border, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_format, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage3D_type, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_TexImage3D_pixels, (length - 56) / 1, little_endian);
+}
+
+static void mesa_TexSubImage3D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_swapbytes, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_lsbfirst, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    UNUSED(2);
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_rowlength, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_skiprows, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_skippixels, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_alignment, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_level, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_xoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_yoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_zoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_depth, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_format, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_type, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage3D_UNUSED, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_TexSubImage3D_pixels, (length - 64) / 1, little_endian);
+}
+
+static void mesa_CopyTexSubImage3D(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage3D_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage3D_level, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage3D_xoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage3D_yoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage3D_zoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage3D_x, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage3D_y, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage3D_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CopyTexSubImage3D_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_ActiveTextureARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ActiveTextureARB_texture, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_MultiTexCoord1dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord1dvARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord1dvARB_v, hf_x11_glx_render_MultiTexCoord1dvARB_v_item, 1, little_endian);
+}
+
+static void mesa_MultiTexCoord1fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord1fvARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord1fvARB_v, hf_x11_glx_render_MultiTexCoord1fvARB_v_item, 1, little_endian);
+}
+
+static void mesa_MultiTexCoord1ivARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord1ivARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord1ivARB_v, hf_x11_glx_render_MultiTexCoord1ivARB_v_item, 1, little_endian);
+}
+
+static void mesa_MultiTexCoord1svARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord1svARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord1svARB_v, hf_x11_glx_render_MultiTexCoord1svARB_v_item, 1, little_endian);
+}
+
+static void mesa_MultiTexCoord2dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord2dvARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord2dvARB_v, hf_x11_glx_render_MultiTexCoord2dvARB_v_item, 2, little_endian);
+}
+
+static void mesa_MultiTexCoord2fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord2fvARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord2fvARB_v, hf_x11_glx_render_MultiTexCoord2fvARB_v_item, 2, little_endian);
+}
+
+static void mesa_MultiTexCoord2ivARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord2ivARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord2ivARB_v, hf_x11_glx_render_MultiTexCoord2ivARB_v_item, 2, little_endian);
+}
+
+static void mesa_MultiTexCoord2svARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord2svARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord2svARB_v, hf_x11_glx_render_MultiTexCoord2svARB_v_item, 2, little_endian);
+}
+
+static void mesa_MultiTexCoord3dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord3dvARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord3dvARB_v, hf_x11_glx_render_MultiTexCoord3dvARB_v_item, 3, little_endian);
+}
+
+static void mesa_MultiTexCoord3fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord3fvARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord3fvARB_v, hf_x11_glx_render_MultiTexCoord3fvARB_v_item, 3, little_endian);
+}
+
+static void mesa_MultiTexCoord3ivARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord3ivARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord3ivARB_v, hf_x11_glx_render_MultiTexCoord3ivARB_v_item, 3, little_endian);
+}
+
+static void mesa_MultiTexCoord3svARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord3svARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord3svARB_v, hf_x11_glx_render_MultiTexCoord3svARB_v_item, 3, little_endian);
+}
+
+static void mesa_MultiTexCoord4dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord4dvARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord4dvARB_v, hf_x11_glx_render_MultiTexCoord4dvARB_v_item, 4, little_endian);
+}
+
+static void mesa_MultiTexCoord4fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord4fvARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord4fvARB_v, hf_x11_glx_render_MultiTexCoord4fvARB_v_item, 4, little_endian);
+}
+
+static void mesa_MultiTexCoord4ivARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord4ivARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord4ivARB_v, hf_x11_glx_render_MultiTexCoord4ivARB_v_item, 4, little_endian);
+}
+
+static void mesa_MultiTexCoord4svARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_MultiTexCoord4svARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_MultiTexCoord4svARB_v, hf_x11_glx_render_MultiTexCoord4svARB_v_item, 4, little_endian);
+}
+
+static void mesa_SampleCoverageARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_SampleCoverageARB_value, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_SampleCoverageARB_invert, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+}
+
+static void mesa_CompressedTexImage3DARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int imageSize;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage3DARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage3DARB_level, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage3DARB_internalformat, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage3DARB_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage3DARB_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage3DARB_depth, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage3DARB_border, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    imageSize = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage3DARB_imageSize, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_CompressedTexImage3DARB_data, imageSize, little_endian);
+}
+
+static void mesa_CompressedTexImage2DARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int imageSize;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage2DARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage2DARB_level, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage2DARB_internalformat, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage2DARB_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage2DARB_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage2DARB_border, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    imageSize = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage2DARB_imageSize, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_CompressedTexImage2DARB_data, imageSize, little_endian);
+}
+
+static void mesa_CompressedTexImage1DARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int imageSize;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage1DARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage1DARB_level, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage1DARB_internalformat, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage1DARB_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage1DARB_border, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    imageSize = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexImage1DARB_imageSize, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_CompressedTexImage1DARB_data, imageSize, little_endian);
+}
+
+static void mesa_CompressedTexSubImage3DARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int imageSize;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_level, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_xoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_yoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_zoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_depth, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_format, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    imageSize = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage3DARB_imageSize, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_CompressedTexSubImage3DARB_data, imageSize, little_endian);
+}
+
+static void mesa_CompressedTexSubImage2DARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int imageSize;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage2DARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage2DARB_level, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage2DARB_xoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage2DARB_yoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage2DARB_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage2DARB_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage2DARB_format, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    imageSize = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage2DARB_imageSize, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_CompressedTexSubImage2DARB_data, imageSize, little_endian);
+}
+
+static void mesa_CompressedTexSubImage1DARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int imageSize;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage1DARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage1DARB_level, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage1DARB_xoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage1DARB_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage1DARB_format, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    imageSize = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_CompressedTexSubImage1DARB_imageSize, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_CompressedTexSubImage1DARB_data, imageSize, little_endian);
+}
+
+static void mesa_CurrentPaletteMatrixARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_CurrentPaletteMatrixARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_MatrixIndexubvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int size;
+    size = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_MatrixIndexubvARB_size, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_MatrixIndexubvARB_indices, size, little_endian);
+}
+
+static void mesa_MatrixIndexusvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int size;
+    size = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_MatrixIndexusvARB_size, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfCard16(tvb, offsetp, t, hf_x11_glx_render_MatrixIndexusvARB_indices, hf_x11_glx_render_MatrixIndexusvARB_indices_item, size, little_endian);
+}
+
+static void mesa_MatrixIndexuivARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int size;
+    size = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_MatrixIndexuivARB_size, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfCard32(tvb, offsetp, t, hf_x11_glx_render_MatrixIndexuivARB_indices, hf_x11_glx_render_MatrixIndexuivARB_indices_item, size, little_endian);
+}
+
+static void mesa_VertexAttrib1dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib1dvARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib1dvARB_v, hf_x11_glx_render_VertexAttrib1dvARB_v_item, 1, little_endian);
+}
+
+static void mesa_VertexAttrib1fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib1fvARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib1fvARB_v, hf_x11_glx_render_VertexAttrib1fvARB_v_item, 1, little_endian);
+}
+
+static void mesa_VertexAttrib1svARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib1svARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib1svARB_v, hf_x11_glx_render_VertexAttrib1svARB_v_item, 1, little_endian);
+}
+
+static void mesa_VertexAttrib2dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib2dvARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib2dvARB_v, hf_x11_glx_render_VertexAttrib2dvARB_v_item, 2, little_endian);
+}
+
+static void mesa_VertexAttrib2fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib2fvARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib2fvARB_v, hf_x11_glx_render_VertexAttrib2fvARB_v_item, 2, little_endian);
+}
+
+static void mesa_VertexAttrib2svARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib2svARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib2svARB_v, hf_x11_glx_render_VertexAttrib2svARB_v_item, 2, little_endian);
+}
+
+static void mesa_VertexAttrib3dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib3dvARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib3dvARB_v, hf_x11_glx_render_VertexAttrib3dvARB_v_item, 3, little_endian);
+}
+
+static void mesa_VertexAttrib3fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib3fvARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib3fvARB_v, hf_x11_glx_render_VertexAttrib3fvARB_v_item, 3, little_endian);
+}
+
+static void mesa_VertexAttrib3svARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib3svARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib3svARB_v, hf_x11_glx_render_VertexAttrib3svARB_v_item, 3, little_endian);
+}
+
+static void mesa_VertexAttrib4dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4dvARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4dvARB_v, hf_x11_glx_render_VertexAttrib4dvARB_v_item, 4, little_endian);
+}
+
+static void mesa_VertexAttrib4fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4fvARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4fvARB_v, hf_x11_glx_render_VertexAttrib4fvARB_v_item, 4, little_endian);
+}
+
+static void mesa_VertexAttrib4svARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4svARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4svARB_v, hf_x11_glx_render_VertexAttrib4svARB_v_item, 4, little_endian);
+}
+
+static void mesa_VertexAttrib4NubvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4NubvARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4NubvARB_v, 4, little_endian);
+}
+
+static void mesa_VertexAttrib4bvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4bvARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4bvARB_v, 4, little_endian);
+}
+
+static void mesa_VertexAttrib4ivARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4ivARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4ivARB_v, hf_x11_glx_render_VertexAttrib4ivARB_v_item, 4, little_endian);
+}
+
+static void mesa_VertexAttrib4ubvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4ubvARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4ubvARB_v, 4, little_endian);
+}
+
+static void mesa_VertexAttrib4usvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4usvARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfCard16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4usvARB_v, hf_x11_glx_render_VertexAttrib4usvARB_v_item, 4, little_endian);
+}
+
+static void mesa_VertexAttrib4uivARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4uivARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfCard32(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4uivARB_v, hf_x11_glx_render_VertexAttrib4uivARB_v_item, 4, little_endian);
+}
+
+static void mesa_VertexAttrib4NbvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4NbvARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4NbvARB_v, 4, little_endian);
+}
+
+static void mesa_VertexAttrib4NsvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4NsvARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4NsvARB_v, hf_x11_glx_render_VertexAttrib4NsvARB_v_item, 4, little_endian);
+}
+
+static void mesa_VertexAttrib4NivARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4NivARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4NivARB_v, hf_x11_glx_render_VertexAttrib4NivARB_v_item, 4, little_endian);
+}
+
+static void mesa_VertexAttrib4NusvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4NusvARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfCard16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4NusvARB_v, hf_x11_glx_render_VertexAttrib4NusvARB_v_item, 4, little_endian);
+}
+
+static void mesa_VertexAttrib4NuivARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4NuivARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfCard32(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4NuivARB_v, hf_x11_glx_render_VertexAttrib4NuivARB_v_item, 4, little_endian);
+}
+
+static void mesa_ProgramStringARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int len;
+    proto_tree_add_item(t, hf_x11_glx_render_ProgramStringARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ProgramStringARB_format, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    len = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_ProgramStringARB_len, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_ProgramStringARB_string, len, little_endian);
+}
+
+static void mesa_ProgramEnvParameter4dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ProgramEnvParameter4dvARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ProgramEnvParameter4dvARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_ProgramEnvParameter4dvARB_params, hf_x11_glx_render_ProgramEnvParameter4dvARB_params_item, 4, little_endian);
+}
+
+static void mesa_ProgramEnvParameter4fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ProgramEnvParameter4fvARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ProgramEnvParameter4fvARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_ProgramEnvParameter4fvARB_params, hf_x11_glx_render_ProgramEnvParameter4fvARB_params_item, 4, little_endian);
+}
+
+static void mesa_ProgramLocalParameter4dvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ProgramLocalParameter4dvARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ProgramLocalParameter4dvARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_ProgramLocalParameter4dvARB_params, hf_x11_glx_render_ProgramLocalParameter4dvARB_params_item, 4, little_endian);
+}
+
+static void mesa_ProgramLocalParameter4fvARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ProgramLocalParameter4fvARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ProgramLocalParameter4fvARB_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_ProgramLocalParameter4fvARB_params, hf_x11_glx_render_ProgramLocalParameter4fvARB_params_item, 4, little_endian);
+}
+
+static void mesa_BeginQueryARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_BeginQueryARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_BeginQueryARB_id, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_EndQueryARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_EndQueryARB_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_DrawBuffersARB(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int n;
+    n = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_DrawBuffersARB_n, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfCard32(tvb, offsetp, t, hf_x11_glx_render_DrawBuffersARB_bufs, hf_x11_glx_render_DrawBuffersARB_bufs_item, n, little_endian);
+}
+
+static void mesa_PolygonOffsetEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_PolygonOffsetEXT_factor, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_PolygonOffsetEXT_bias, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_TexFilterFuncSGIS(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int n;
+    proto_tree_add_item(t, hf_x11_glx_render_TexFilterFuncSGIS_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexFilterFuncSGIS_filter, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    n = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_TexFilterFuncSGIS_n, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_TexFilterFuncSGIS_weights, hf_x11_glx_render_TexFilterFuncSGIS_weights_item, n, little_endian);
+}
+
+static void mesa_TexImage4DSGIS(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_swapbytes, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_lsbfirst, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    UNUSED(2);
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_rowlength, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_skiprows, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_skippixels, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_alignment, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_level, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_internalformat, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_depth, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_size4d, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_border, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_format, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexImage4DSGIS_type, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_TexImage4DSGIS_pixels, (length - 60) / 1, little_endian);
+}
+
+static void mesa_TexSubImage4DSGIS(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_swapbytes, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_lsbfirst, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    UNUSED(2);
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_rowlength, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_skiprows, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_skippixels, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_alignment, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_level, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_xoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_yoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_zoffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_woffset, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_width, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_height, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_depth, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_size4d, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_format, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_type, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TexSubImage4DSGIS_UNUSED, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_TexSubImage4DSGIS_pixels, (length - 72) / 1, little_endian);
+}
+
+static void mesa_DetailTexFuncSGIS(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int n;
+    proto_tree_add_item(t, hf_x11_glx_render_DetailTexFuncSGIS_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    n = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_DetailTexFuncSGIS_n, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_DetailTexFuncSGIS_points, hf_x11_glx_render_DetailTexFuncSGIS_points_item, n, little_endian);
+}
+
+static void mesa_SharpenTexFuncSGIS(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int n;
+    proto_tree_add_item(t, hf_x11_glx_render_SharpenTexFuncSGIS_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    n = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_SharpenTexFuncSGIS_n, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_SharpenTexFuncSGIS_points, hf_x11_glx_render_SharpenTexFuncSGIS_points_item, n, little_endian);
+}
+
+static void mesa_SampleMaskSGIS(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_SampleMaskSGIS_value, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_SampleMaskSGIS_invert, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+}
+
+static void mesa_SamplePatternSGIS(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_SamplePatternSGIS_pattern, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_PointParameterfEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_PointParameterfEXT_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_PointParameterfEXT_param, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_PointParameterfvEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_PointParameterfvEXT_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_PointParameterfvEXT_params, hf_x11_glx_render_PointParameterfvEXT_params_item, (length - 4) / 4, little_endian);
+}
+
+static void mesa_FrameZoomSGIX(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_FrameZoomSGIX_factor, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_TagSampleBufferSGIX(tvbuff_t *tvb _U_, int *offsetp _U_, proto_tree *t _U_, int little_endian _U_, int length _U_)
+{
+}
+
+static void mesa_ReferencePlaneSGIX(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_ReferencePlaneSGIX_equation, hf_x11_glx_render_ReferencePlaneSGIX_equation_item, 4, little_endian);
+}
+
+static void mesa_FogFuncSGIS(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int n;
+    n = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_FogFuncSGIS_n, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_FogFuncSGIS_points, hf_x11_glx_render_FogFuncSGIS_points_item, n, little_endian);
+}
+
+static void mesa_SecondaryColor3bvEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_SecondaryColor3bvEXT_v, 3, little_endian);
+}
+
+static void mesa_SecondaryColor3dvEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_SecondaryColor3dvEXT_v, hf_x11_glx_render_SecondaryColor3dvEXT_v_item, 3, little_endian);
+}
+
+static void mesa_SecondaryColor3fvEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_SecondaryColor3fvEXT_v, hf_x11_glx_render_SecondaryColor3fvEXT_v_item, 3, little_endian);
+}
+
+static void mesa_SecondaryColor3ivEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_SecondaryColor3ivEXT_v, hf_x11_glx_render_SecondaryColor3ivEXT_v_item, 3, little_endian);
+}
+
+static void mesa_SecondaryColor3svEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_SecondaryColor3svEXT_v, hf_x11_glx_render_SecondaryColor3svEXT_v_item, 3, little_endian);
+}
+
+static void mesa_SecondaryColor3ubvEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_SecondaryColor3ubvEXT_v, 3, little_endian);
+}
+
+static void mesa_SecondaryColor3uivEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfCard32(tvb, offsetp, t, hf_x11_glx_render_SecondaryColor3uivEXT_v, hf_x11_glx_render_SecondaryColor3uivEXT_v_item, 3, little_endian);
+}
+
+static void mesa_SecondaryColor3usvEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfCard16(tvb, offsetp, t, hf_x11_glx_render_SecondaryColor3usvEXT_v, hf_x11_glx_render_SecondaryColor3usvEXT_v_item, 3, little_endian);
+}
+
+static void mesa_FogCoordfvEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_FogCoordfvEXT_coord, hf_x11_glx_render_FogCoordfvEXT_coord_item, 1, little_endian);
+}
+
+static void mesa_FogCoorddvEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_FogCoorddvEXT_coord, hf_x11_glx_render_FogCoorddvEXT_coord_item, 1, little_endian);
+}
+
+static void mesa_PixelTexGenSGIX(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_PixelTexGenSGIX_mode, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_BlendFuncSeparateEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_BlendFuncSeparateEXT_sfactorRGB, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_BlendFuncSeparateEXT_dfactorRGB, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_BlendFuncSeparateEXT_sfactorAlpha, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_BlendFuncSeparateEXT_dfactorAlpha, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_VertexWeightfvEXT(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexWeightfvEXT_weight, hf_x11_glx_render_VertexWeightfvEXT_weight_item, 1, little_endian);
+}
+
+static void mesa_CombinerParameterfvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerParameterfvNV_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_CombinerParameterfvNV_params, hf_x11_glx_render_CombinerParameterfvNV_params_item, (length - 4) / 4, little_endian);
+}
+
+static void mesa_CombinerParameterfNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerParameterfNV_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerParameterfNV_param, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_CombinerParameterivNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerParameterivNV_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt32(tvb, offsetp, t, hf_x11_glx_render_CombinerParameterivNV_params, hf_x11_glx_render_CombinerParameterivNV_params_item, (length - 4) / 4, little_endian);
+}
+
+static void mesa_CombinerParameteriNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerParameteriNV_pname, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerParameteriNV_param, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_CombinerInputNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerInputNV_stage, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerInputNV_portion, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerInputNV_variable, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerInputNV_input, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerInputNV_mapping, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerInputNV_componentUsage, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_CombinerOutputNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_stage, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_portion, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_abOutput, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_cdOutput, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_sumOutput, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_scale, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_bias, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_abDotProduct, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_cdDotProduct, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_CombinerOutputNV_muxSum, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+}
+
+static void mesa_FinalCombinerInputNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_FinalCombinerInputNV_variable, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_FinalCombinerInputNV_input, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_FinalCombinerInputNV_mapping, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_FinalCombinerInputNV_componentUsage, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_WindowPos3fvMESA(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_WindowPos3fvMESA_v, hf_x11_glx_render_WindowPos3fvMESA_v_item, 3, little_endian);
+}
+
+static void mesa_TextureColorMaskSGIS(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TextureColorMaskSGIS_red, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_TextureColorMaskSGIS_green, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_TextureColorMaskSGIS_blue, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+    proto_tree_add_item(t, hf_x11_glx_render_TextureColorMaskSGIS_alpha, tvb, *offsetp, 1, little_endian);
+    *offsetp += 1;
+}
+
+static void mesa_BindProgramNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_BindProgramNV_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_BindProgramNV_program, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_ExecuteProgramNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_ExecuteProgramNV_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ExecuteProgramNV_id, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_ExecuteProgramNV_params, hf_x11_glx_render_ExecuteProgramNV_params_item, 4, little_endian);
+}
+
+static void mesa_LoadProgramNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int len;
+    proto_tree_add_item(t, hf_x11_glx_render_LoadProgramNV_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_LoadProgramNV_id, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    len = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_LoadProgramNV_len, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_LoadProgramNV_program, len, little_endian);
+}
+
+static void mesa_ProgramParameters4dvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int num;
+    proto_tree_add_item(t, hf_x11_glx_render_ProgramParameters4dvNV_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ProgramParameters4dvNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    num = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_ProgramParameters4dvNV_num, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_ProgramParameters4dvNV_params, hf_x11_glx_render_ProgramParameters4dvNV_params_item, num, little_endian);
+}
+
+static void mesa_ProgramParameters4fvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int num;
+    proto_tree_add_item(t, hf_x11_glx_render_ProgramParameters4fvNV_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_ProgramParameters4fvNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    num = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_ProgramParameters4fvNV_num, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_ProgramParameters4fvNV_params, hf_x11_glx_render_ProgramParameters4fvNV_params_item, num, little_endian);
+}
+
+static void mesa_RequestResidentProgramsNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int n;
+    n = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_RequestResidentProgramsNV_n, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfCard32(tvb, offsetp, t, hf_x11_glx_render_RequestResidentProgramsNV_ids, hf_x11_glx_render_RequestResidentProgramsNV_ids_item, n, little_endian);
+}
+
+static void mesa_TrackMatrixNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_TrackMatrixNV_target, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TrackMatrixNV_address, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TrackMatrixNV_matrix, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    proto_tree_add_item(t, hf_x11_glx_render_TrackMatrixNV_transform, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+}
+
+static void mesa_VertexAttrib1svNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib1svNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib1svNV_v, hf_x11_glx_render_VertexAttrib1svNV_v_item, 1, little_endian);
+}
+
+static void mesa_VertexAttrib2svNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib2svNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib2svNV_v, hf_x11_glx_render_VertexAttrib2svNV_v_item, 2, little_endian);
+}
+
+static void mesa_VertexAttrib3svNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib3svNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib3svNV_v, hf_x11_glx_render_VertexAttrib3svNV_v_item, 3, little_endian);
+}
+
+static void mesa_VertexAttrib4svNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4svNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4svNV_v, hf_x11_glx_render_VertexAttrib4svNV_v_item, 4, little_endian);
+}
+
+static void mesa_VertexAttrib1fvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib1fvNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib1fvNV_v, hf_x11_glx_render_VertexAttrib1fvNV_v_item, 1, little_endian);
+}
+
+static void mesa_VertexAttrib2fvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib2fvNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib2fvNV_v, hf_x11_glx_render_VertexAttrib2fvNV_v_item, 2, little_endian);
+}
+
+static void mesa_VertexAttrib3fvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib3fvNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib3fvNV_v, hf_x11_glx_render_VertexAttrib3fvNV_v_item, 3, little_endian);
+}
+
+static void mesa_VertexAttrib4fvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4fvNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4fvNV_v, hf_x11_glx_render_VertexAttrib4fvNV_v_item, 4, little_endian);
+}
+
+static void mesa_VertexAttrib1dvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib1dvNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib1dvNV_v, hf_x11_glx_render_VertexAttrib1dvNV_v_item, 1, little_endian);
+}
+
+static void mesa_VertexAttrib2dvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib2dvNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib2dvNV_v, hf_x11_glx_render_VertexAttrib2dvNV_v_item, 2, little_endian);
+}
+
+static void mesa_VertexAttrib3dvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib3dvNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib3dvNV_v, hf_x11_glx_render_VertexAttrib3dvNV_v_item, 3, little_endian);
+}
+
+static void mesa_VertexAttrib4dvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4dvNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfDouble(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4dvNV_v, hf_x11_glx_render_VertexAttrib4dvNV_v_item, 4, little_endian);
+}
+
+static void mesa_VertexAttrib4ubvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttrib4ubvNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfByte(tvb, offsetp, t, hf_x11_glx_render_VertexAttrib4ubvNV_v, 4, little_endian);
+}
+
+static void mesa_VertexAttribs1svNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int n;
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs1svNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    n = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs1svNV_n, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs1svNV_v, hf_x11_glx_render_VertexAttribs1svNV_v_item, n, little_endian);
+}
+
+static void mesa_VertexAttribs2svNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int n;
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs2svNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    n = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs2svNV_n, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs2svNV_v, hf_x11_glx_render_VertexAttribs2svNV_v_item, n, little_endian);
+}
+
+static void mesa_VertexAttribs3svNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int n;
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs3svNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    n = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs3svNV_n, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs3svNV_v, hf_x11_glx_render_VertexAttribs3svNV_v_item, n, little_endian);
+}
+
+static void mesa_VertexAttribs4svNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int n;
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs4svNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    n = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs4svNV_n, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfInt16(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs4svNV_v, hf_x11_glx_render_VertexAttribs4svNV_v_item, n, little_endian);
+}
+
+static void mesa_VertexAttribs1fvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int n;
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs1fvNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    n = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs1fvNV_n, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs1fvNV_v, hf_x11_glx_render_VertexAttribs1fvNV_v_item, n, little_endian);
+}
+
+static void mesa_VertexAttribs2fvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int n;
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs2fvNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    n = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs2fvNV_n, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs2fvNV_v, hf_x11_glx_render_VertexAttribs2fvNV_v_item, n, little_endian);
+}
+
+static void mesa_VertexAttribs3fvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int n;
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs3fvNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    n = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs3fvNV_n, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs3fvNV_v, hf_x11_glx_render_VertexAttribs3fvNV_v_item, n, little_endian);
+}
+
+static void mesa_VertexAttribs4fvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int n;
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs4fvNV_index, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    n = VALUE32(tvb, *offsetp);
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs4fvNV_n, tvb, *offsetp, 4, little_endian);
+    *offsetp += 4;
+    listOfFloat(tvb, offsetp, t, hf_x11_glx_render_VertexAttribs4fvNV_v, hf_x11_glx_render_VertexAttribs4fvNV_v_item, n, little_endian);
+}
+
+static void mesa_VertexAttribs1dvNV(tvbuff_t *tvb, int *offsetp, proto_tree *t, int little_endian, int length _U_)
+{
+    int n;
+    proto_tree_add_item(t, hf_x11_glx_render_VertexAttribs1dv